day6--面向对象初识

Posted 2020-11-20 mmyy-blog

一面向过程与面向对象

面向过程：

流水线式的思维，顺着流程进行下去，类似于代码的堆叠，重视步骤

优点：不需要考虑太多东西，想到一个功能就写一个功能，堆叠代码

缺点：过程往往是先后执行的，要想变换功能或者增加功能，就要考虑重新堆叠大部分或者所有代码了，牵一发而动全身

面向对象：

将事务分解成各个对象，可以给这个对象附加相应的功能，后面的东西一旦调用，这些功能或者方法也就自然的拥有了

优点：对象可扩展，并可以单独修改，调用的地方会立刻显现，我是一块砖哪里需要哪里搬

缺点：无法预测出现问题的具体地方，对象和对象之间融合到一块了，找出问题需要很长时间

面向对象在实际运用中还是很普遍的，将事务拆分成各个对象，大家可以分头去做，往往进度比较快

面向对象的实现需要类和对象

二 类和对象

类：相当于一个模板，里面有这个模板的函数，变量，属性，方式方法等

对象：根据模板来创建，这样自然而然对象就拥有了类里面的东西

2.1 定义一个类

一个类的定义有其独特的方式，类名首字母大写，里面定义的函数，其参数必须有self

例如：

class Person:   #定义一个人类
    role = ‘person‘  #人的角色属性都是人
    def walk(self):  #人都可以走路，也就是有一个走路方法
        print("person is walking...")
print(Person.role)  #查看人的role属性
print(Person.walk)  #引用人的走路方法，注意，这里不是在调用

2.2实例化

类名加括号就是实例化，会自动触发__init__函数的运行，可以用它来为每个实例定制自己的特征

例如：

class Person:   #定义一个人类
    role = ‘person‘  #人的角色属性都是人
    def __init__(self,name):
        self.name = name  # 每一个角色都有自己的昵称;
        
    def walk(self):  #人都可以走路，也就是有一个走路方法
        print("person is walking...")


print(Person.role)  #查看人的role属性
print(Person.walk)  #引用人的走路方法，注意，这里不是在调用

实例化的过程就是类——>对象的过程

2.3类的属性

dir(类名)：查出的是一个名字列表
类名.__dict__:查出的是一个字典，key为属性名，value为属性值

二：特殊的类属性
类名.__name__# 类的名字(字符串)
类名.__doc__# 类的文档字符串
类名.__base__# 类的第一个父类(在讲继承时会讲)
类名.__bases__# 类所有父类构成的元组(在讲继承时会讲)
类名.__dict__# 类的字典属性
类名.__module__# 类定义所在的模块
类名.__class__# 实例对应的类(仅新式类中)

View Code

2.4类的查看

类的两种变量：静态变量和动态变量

例如：

class Person:  # class 关键字，定义了一个类
    ‘‘‘
    类里面的所有内容
    ‘‘‘
    animal = ‘高级动物‘ # 静态变量
    soup = ‘有思想‘  # 静态变量

    def __init__(self,name,sex,eye,high,weight,):  # 构造方法

        self.eye = eye  # 属性
        self.name = name
        self.sex = sex
        self.high = high
        self.weight = weight
        print(666)

    def work(self): # 动态变量，动态方法，方法
        print(self)
        # self.job = ‘IT‘
        print(‘人会工作....‘)

View Code

1，类名.__dict__方法  只能查看,不能增删改。

# print(Person.__dict__)
# print(Person.__dict__[‘animal‘])

#查询动态变量

 print(Person.__dict__[‘work‘](11))

2 类名.变量名  可增删改查

# print(Person.animal)
# print(Person.soup)
# Person.kind = ‘有性格‘
# Person.animal = ‘低等动物‘
# del Person.kind

查询动态变量

#Person.work(11)

2.5对象的查看

实例化一个对象内部进行了三步

# 内部进行三步：
# 1，实例化一个对象，在内存中产生一个对象空间。
# 2，自动执行init方法，并将这个空间对象。 <__main__.Person object at 0x0000000001F5ABE0> 传给self
# 3，通过构造方法里的代码给空间对象添加一些属性，并返回给对象。

View Code

对象的查看与类的查看类似，只是将类名换成了对象名

类的静态属性是共享给对象的，类的动态属性是绑定给对象的

三面向对象的三大特性

3.1继承

继承是一种创建新类的方式，在python中，新建的类可以继承一个或多个父类，父类又可称为基类或超类，新建的类称为派生类或子类

继承简单的来说就是子继承父

继承分为：单继承和多继承

一些对象具体相同的功能时，可以在它们的父类中实现，这样的话可以减少很多代码

注：除了子类和父类的称谓，你可能看到过 派生类 和 基类 ，他们与子类和父类只是叫法不同而已。

查看继承

类名.__bases__    #__base__只查看从左到右继承的第一个子类，__bases__则是查看所有继承的父类

如果没有指定基类，python会默认继承object类，object是所有python类的基类

例如：leiming.__bases__  

#结果为 (<class ‘object‘>,)

有很多情况是一个子类往往有很多父类，这个是多继承，它又是如何继承的

1、Python的类可以继承多个类，Java和C#中则只能继承一个类

2、Python的类如果继承了多个类，那么其寻找方法的方式有两种，分别是：深度优先和广度优先

 

• 当类是经典类时，多继承情况下，会按照深度优先方式查找
• 当类是新式类时，多继承情况下，会按照广度优先方式查找

经典类和新式类，从字面上可以看出一个老一个新，新的必然包含了跟多的功能，也是之后推荐的写法，从写法上区分的话，如果 当前类或者父类继承了object类，那么该类便是新式类，否则便是经典类。

class D:

    def bar(self):
        print ‘D.bar‘


class C(D):

    def bar(self):
        print ‘C.bar‘


class B(D):

    def bar(self):
        print ‘B.bar‘


class A(B, C):

    def bar(self):
        print ‘A.bar‘

a = A()
# 执行bar方法时
# 首先去A类中查找，如果A类中没有，则继续去B类中找，如果B类中么有，则继续去D类中找，如果D类中么有，则继续去C类中找，如果还是未找到，则报错
# 所以，查找顺序：A --> B --> D --> C
# 在上述查找bar方法的过程中，一旦找到，则寻找过程立即中断，便不会再继续找了
a.bar()

经典类多继承

class D(object):

    def bar(self):
        print ‘D.bar‘


class C(D):

    def bar(self):
        print ‘C.bar‘


class B(D):

    def bar(self):
        print ‘B.bar‘


class A(B, C):

    def bar(self):
        print ‘A.bar‘

a = A()
# 执行bar方法时
# 首先去A类中查找，如果A类中没有，则继续去B类中找，如果B类中么有，则继续去C类中找，如果C类中么有，则继续去D类中找，如果还是未找到，则报错
# 所以，查找顺序：A --> B --> C --> D
# 在上述查找bar方法的过程中，一旦找到，则寻找过程立即中断，便不会再继续找了
a.bar()

新式类多继承

待续。。。。。