开放原子开发者工作坊

一、面向对象 & 面向过程

1、面向过程(流水线式思维)：

• 优点：程序复杂度较低，依据执行步骤顺序编写代码即可
• 缺点：代码复用性差，前后逻辑耦合度要高
• 应用场景：一旦完成基本很少改变的场景，著名的例子有Linux內核，git，以及Apache HTTP Server等

2、面向对象(上帝式思维)：

• 优点：可扩展性高，对程序某处的更改会反映到全局
• 缺点：可控性差，不如面向对象式编程可以准确预测程序执行结果
• 应用场景：需求经常变化的软件，一般需求的变化都集中在用户层，互联网应用，企业内部软件，游戏等

二、类和对象

定义：在python中，用变量表示属性，用函数表示方法，因而具有相同属性和方法的一类事物就是‘类’，对象则是这一类事物的具体体现

1、类

①声明类

class 类名:
    '类的文档字符串'
    类体

②类的作用：

• 属性引用：类名.属性名
• 方法调用：类名.方法名(对象名) / 对象名.方法名()
• 实例化：类名加括号就是实例化，会自动触发init函数的运行，可以用它来为每个实例定制自己的特征。
• 实例化的过程本质：类——>对象的过程
• self：在实例化过程中自动将对象(实例)自身传递给init方法的第一个参数，约定俗成将这个参数写作self
• 特殊的类属性：

类名.__dict__:查出的是一个字典，key为属性名，value为属性值
类名.__name__# 类的名字(字符串)
类名.__doc__# 类的文档字符串
类名.__base__# 类的第一个父类(在讲继承时会讲)
类名.__bases__# 类所有父类构成的元组(在讲继承时会讲)
类名.__dict__# 类的字典属性
类名.__module__# 类定义所在的模块
类名.__class__# 实例对应的类(仅新式类中)

2、对象

①定义：对象是类的具体体现，即实例

②作用：属性调用、方法调用(方法也称作动态属性，所以也可以归为一类)

3、对象之间的交互

class Dog():
    def __init__(self,name,blood,aggr,sex):
        self.name = name
        self.blood = blood
        self.aggr = aggr
        self.sex = sex

    def bite(self,person):
        person.blood -= self.aggr
        print('\033[1;31m{} \033[0m被 \033[1;31m{} \033[0m咬了，掉了\033[1;31m{} \033[0m的血'.format(person.name,self.name, self.aggr))

class Person():
    def __init__(self,name,blood,aggr,sex):
        self.name = name
        self.blood = blood
        self.aggr = aggr
        self.sex = sex

    def attack(self,dog):
        dog.blood -= self.aggr
        print('\033[1;31m{} \033[0m被 \033[1;31m{} \033[0m打了，掉了\033[1;31m{} \033[0m的血'.format(dog.name,self.name, self.aggr))

d = Dog('小狗儿',100,10,'teddy')
p = Person('小孩儿',100,5,'boy')

d.bite(p)
print('{}的血量'.format(p.name),p.blood)

p.attack(d)
print('{}的血量'.format(d.name),d.blood)

三、类的命名空间

1、定义：创建一个类就会创建一个类的命名空间，用来存储类中定义的所有名字，这些名字被称为类的属性

2、类的属性：

静态属性：在类中定义的变量，共享给所有对象

动态属性：在类中定义的方法，绑定到所有对象

3、举例

# 静态属性
class Foo:
    static_attr = 'Foo_attr'
    def func(self):
        print('Foo_method')

f1 = Foo()
print(id(f1.static_attr))
>>> 18769712
print(id(Foo.static_attr))
>>> 18769712

# 动态属性
class Foo:
    static_attr = 'Foo_attr'
    def func(self):
        print('Foo_method')

f1 = Foo()
print(f1.func)
>>> <bound method Foo.func of <__main__.Foo object at 0x00000000006BBCF8>>
print(Foo.func)
>>> <function Foo.func at 0x00000000006BE840>

四、对象命名空间

1、定义：

创建一个对象/实例就会创建一个对象/实例的名称空间，存放对象/实例的名字，称为对象/实例的属性

2、对象使用属性的顺序：

自己的命名空间—>类的命名空间—>父类的命名空间—>都找不到则报错

五、类的组合

1、定义：在一个类中以另外一个类的对象作为属性，称为类的组合

2、适用场景：

• 当类之间有显著不同，并且较小的类是较大的类所需要的组件时，用组合比较好
• 当类与类之间的关系为’什么是什么’的时候可以考虑使用类的组合

3、举例

from math import pi
class Circle:
    def __init__(self,radius):
        self.radius = radius
    def area(self):
        return self.radius**2*pi
    def perimeter(self):
        return self.radius*2*pi

class Ring:
    def __init__(self,R,r):
        self.outer_circle = Circle(R) # 此处即为类的组合
        self.inner_circle = Circle(r) # 此处即为类的组合
    def area(self):
        return self.outer_circle.area() - self.inner_circle.area()
    def perimeter(self):
        return self.outer_circle.perimeter()+self.inner_circle.perimeter()

r = Ring(10,5)
print(r.area())
print(r.perimeter())

六、面向对象三大特点——继承

1、定义：

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

2、继承的使用场景：什么是什么

3、查看父类的双下方法：Foo.__bases__

4、种类：

①单继承

• 父类中没有的属性在子类中出现叫做派生属性
• 父类中没有的方法在子类中出现叫做派生方法
• 只要是子类的对象调用，子类中有的名字一定用子类的，子类中没有才找父类的，如果父类也没有报错
• 如果父类、子类都有则用子类的 
  
  • 如果还想用父类的，单独调用父类的: 
    1、父类名.方法名 需要自己传self参数 
2、super().方法名 不需要自己传self
• 正常的代码中单继承 ===> 减少了代码的重复
• 继承表达的是一种子类是父类的关系

②多继承

• 在python2中 
  
  • 新式类：继承object类的才是新式类——>遵循广度优先原则 
    可以用Foo.\_\_mro\_\_方法查看继承顺序，mro方法只在新式类中存在
  • 经典类：直接创建一个类默认是经典类——>遵循深度优先原则
• 在python3中 
  
  • 所有在python3中创建的类都是新式类——>遵循广度优先原则
  • 可以用Foo.__mro__方法查看继承顺序，mro方法只在新式类中存在

5、super()关键字

①super()只在python3中存在

②super的本质 ：不是单纯找父类而是根据调用者的节点位置的广度优先顺序来的