Python 面向对象
Python从设计之初就已经是一门面向对象的语言，正因为如此，在Python中创建一个类和对象是很容易的。本章节我们将详细介绍Python的面向对象编程。
如果你以前没有接触过面向对象的编程语言，那你可能需要先了解一些面向对象语言的一些基本特征，在头脑里头形成一个基本的面向对象的概念，这样有助于你更容易的学习Python的面向对象编程。
接下来我们先来简单的了解下面向对象的一些基本特征。
面向对象技术简介：
类(Class): 用来描述具有相同的属性和方法的对象的集合。它定义了该集合中每个对象所共有的属性和方法。对象是类的实例。 类变量：类变量在整个实例化的对象中是公用的。类变量定义在类中且在函数体之外。类变量通常不作为实例变量使用。 数据成员：类变量或者实例变量用于处理类及其实例对象的相关的数据。 方法重写：如果从父类继承的方法不能满足子类的需求，可以对其进行改写，这个过程叫方法的覆盖（override），也称为方法的重写。 实例变量：定义在方法中的变量，只作用于当前实例的类。 继承：即一个派生类（derived class）继承基类（base class）的字段和方法。继承也允许把一个派生类的对象作为一个基类对象对待。例如，有这样一个设计：一个Dog类型的对象派生自Animal类，这是模拟"是一个（is-a）"关系（例图，Dog是一个Animal）。 实例化：创建一个类的实例，类的具体对象。 方法：类中定义的函数。 对象：通过类定义的数据结构实例。对象包括两个数据成员（类变量和实例变量）和方法。
面向过程与面向对象编程的区别：
- 面向过程就是分析出解决问题所需要的步骤，然后用函数把这些步骤一步一步实现，使用的时候一个一个依次调用就可以了
- 面向对象是把构成问题事务分解成各个对象，建立对象的目的不是为了完成一个步骤，而是为了描叙某个事物在整个解决问题的步骤中的行为
面向过程与面向对象的优缺点：
面向过程：
- 优点：性能比面向对象高，因为类调用时需要实例化，开销比较大，比较消耗资源
- 缺点：没有面向对象易维护、易复用、易扩展
面向对象：
- 优点：易维护、易复用、易扩展，由于面向对象有封装、继承、多态性的特性，可以设计出低耦合的系统，使系统更加灵活、更加易于维护
- 缺点：性能比面向过程低
1 类与对象
类（class）：用来描述具有相同属性和方法的对象的集合。它定义了该集合中每个对象所共有的属性和方法。对象是类的实例
类变量：类变量在整个实例化的对象中是公用的。类变量定义在类中且在函数体之外。类变量通常不作为实例变量使用
对象：通过类定义的数据结构实例。对象包括两个数据成员（类变量和实例变量）和方法
1.1 类定义
语法：
class ClassName:
'类的帮助信息' #类文档字符串
class_suite #类体
应用：
class Student: #会产生一个类的名称空间，用来存放类内部的变量及函数
school = '北京昌平学校' #类的数据属性
def learn(self): #类的函数属性
print('is learning')
print(Student.__dict__) #查看类的名称空间
#执行结果：
{'__module__': '__main__', 'school': '北京昌平学校', 'learn': <function Student.learn at 0x000000000259B8C8>, '__dict__': <attribute '__dict__' of 'Student' objects>, '__weakref__': <attribute '__weakref__' of 'Student' objects>, '__doc__': None}
print(Student.school) #实际上，创建一个类之后，可以通过类名访问其属
#执行结果：
北京昌平学校
操作类的属性（属性引用）：
class Student:
school = '北京昌平学校'
def learn(self):
print('is learning')
Student.x = '王二' #增加,实际等同Student.__dict__['x'] = 123456，但Python3不支持这种操作
Student.y = '张三'
Student.school = '华北电力大学' #修改school
print(Student.__dict__)
结果：
{'__module__': '__main__', 'school': '华北电力大学', 'learn': <function Student.learn at 0x0000000001E7A8C8>, '__dict__': <attribute '__dict__' of 'Student' objects>, '__weakref__': <attribute '__weakref__' of 'Student' objects>, '__doc__': None, 'x': '王二', 'y': '张三'}shanc
删除：
del Student.y #删除
print(Student.__dict__)
结果：
{'__module__': '__main__', 'school': '华北电力大学', 'learn': <function Student.learn at 0x0000000001E8A8C8>, '__dict__': <attribute '__dict__' of 'Student' objects>, '__weakref__': <attribute '__weakref__' of 'Student' objects>, '__doc__': None, 'x': '王二'}
1.2 类对象
应用：
class Student:
school = '华北电力大学'
def learn(self):
print('is learning')
obj1 = Student() #类名加括号，会产生一个该类的实际存在的对象，该过程称为实例化，其结果obj1也可被称为实例
print(obj1) #obj1是一个空对象
#执行结果：
<__main__.Student object at 0x00000000028D97F0>
很多类都倾向于将对象创建为有初始状态的。因此类可能会定义一个名为 __init__() 的特殊方法，像下面这样：
def __init__(self): #类定义了 __init__() 方法的话，类的实例化操作会自动调用 __init__() 方法
self.data = []
__init__() 方法可以有参数，参数通过 __init__() 传递到类的实例化操作上。例如:
class Student:
school = '华北电力大学'
def __init__(self,name,age,sex): #在实例化时，产生对象之后执行
self.name = name
self.age = age
self.sex = sex
def learn(self):
print('is learning')
obj1 = Student('wang',25,'male') #先产生一个空对象obj1 2、Student.__init__(obj1,'wang',25,'male')
print(obj1.__dict__) #查看对象的名称空间
obj1.id = '1' #同样，对象属性也能被引用,等同obj1.__dict__['id'] = '1'，Python3是支持的
print(obj1.name,obj1.age,obj1.sex,obj1.id)
#执行结果：
{'name': 'wang', 'age': 25, 'sex': 'male'}
wang 25 male 1
1.3 属性查找
class Student:
school = '华北电力大学'
def __init__(self,name,age,sex):
self.name = name
self.age = age
self.sex = sex
def learn(self):
print('%s is learning'%self.name)
obj1 = Student('王二',25,'male')
obj2 = Student('张三',18,'male')
print(obj1.school) # obj1和obj2都能访问类里面的数据属性
print(obj2.school)
print(id(obj1.school)) #属性id也一致，类的数据属性是共享给所有对象的
print(id(obj2.school))
print(obj1.learn) #类的函数属性是绑定给所有对象的（绑定方法），内存地址也不一样
print(obj2.learn)
obj1.learn() #绑定给谁，就由谁来调用，谁来调用就把谁本身当做第一个参数传入（自动传值）
#结果：
华北电力大学
华北电力大学
31928928
31928928
<bound method Student.learn of <__main__.Student object at 0x0000000001E79B38>>
<bound method Student.learn of <__main__.Student object at 0x0000000001E79B70>>
王二 is learning
删除：
obj1.school = '华北大学' #修改obj1属性 print(obj1.school) #查找顺序：对象-->类 print(obj2.school) #obj2不受影响
给类加一个计数器功能，每实例化一次就加1
class Student:
count = 0
school = '华北电力大学'
def __init__(self,name,age,sex):
self.name = name
self.age = age
self.sex = sex
Student.count += 1
def learn(self):
print('%s is learning'%self.name)
obj1 = Student('王二',25,'male')
print(Student.count)
obj2 = Student('张三',18,'male')
print(Student.count)
obj3 = Student('李四',18,'male')
print(Student.count)
1.4 绑定到对象的方法的特殊之处
class OldboyStudent:
school='华北电力大学'
def __init__(self,name,age,sex):
self.name=name
self.age=age
self.sex=sex
def learn(self):
print('%s is learning' %self.name) #新增self.name
def eat(self):
print('%s is eating' %self.name)
def sleep(self):
print('%s is sleeping' %self.name)
s1=OldboyStudent('王二','男',18)
s2=OldboyStudent('张三','女',38)
s3=OldboyStudent('李四','男',78)
类中定义的函数（没有被任何装饰器装饰的）是类的函数属性，类可以使用，但必须遵循函数的参数规则，有几个参数需要传几个参数
OldboyStudent.learn(s1) OldboyStudent.learn(s2) OldboyStudent.learn(s3) 结果： 王二 is learning 张三 is learning 李四 is learning
类中定义的函数（没有被任何装饰器装饰的）,其实主要是给对象使用的，而且是绑定到对象的，虽然所有对象指向的都是相同的功能，但是绑定到不同的对象就是不同的绑定方法
强调：绑定到对象的方法的特殊之处在于，绑定给谁就由谁来调用，谁来调用，就会将‘谁’本身当做第一个参数传给方法，即自动传值（方法__init__也是一样的道理）
s1.learn() #等同于OldboyStudent.learn(s1) s2.learn() #等同于OldboyStudent.learn(s2) s3.learn() #等同于OldboyStudent.learn(s3)
注意：绑定到对象的方法的这种自动传值的特征，决定了在类中定义的函数都要默认写一个参数self，self可以是任意名字，但是约定俗成地写出self。
1.6 对象之间的交互
class Garen: #定义英雄盖伦的类，不同的玩家可以用它实例出自己英雄;
camp='Demacia' #所有玩家的英雄(盖伦)的阵营都是Demacia;
def __init__(self,nickname,aggressivity=58,life_value=455): #英雄的初始攻击力58...;
self.nickname=nickname #为自己的盖伦起个别名;
self.aggressivity=aggressivity #英雄都有自己的攻击力;
self.life_value=life_value #英雄都有自己的生命值;
def attack(self,enemy): #普通攻击技能，enemy是敌人;
enemy.life_value-=self.aggressivity #根据自己的攻击力，攻击敌人就减掉敌人的生命值。
我们可以仿照garen类再创建一个Riven类
class Riven:
camp='Noxus' #所有玩家的英雄(锐雯)的阵营都是Noxus;
def __init__(self,nickname,aggressivity=54,life_value=414): #英雄的初始攻击力54;
self.nickname=nickname #为自己的锐雯起个别名;
self.aggressivity=aggressivity #英雄都有自己的攻击力;
self.life_value=life_value #英雄都有自己的生命值;
def attack(self,enemy): #普通攻击技能，enemy是敌人;
enemy.life_value-=self.aggressivity #根据自己的攻击力，攻击敌人就减掉敌人的生命值。
实例出俩英雄
>>> g1=Garen('草丛伦')
>>> r1=Riven('锐雯雯')
交互：锐雯雯攻击草丛伦，反之一样
>>> g1.life_value 455 >>> r1.attack(g1) >>> g1.life_value 401
2 继承
面向对象的编程带来的主要好处之一是代码的重用，实现这种重用的方法之一是通过继承机制。继承完全可以理解成类之间的类型和子类型关系。
需要注意的地方：继承语法 class 派生类名（基类名）：//... 基类名写在括号里，基本类是在类定义的时候，在元组之中指明的。
在python中继承中的一些特点：
- 1：在继承中基类的构造（__init__()方法）不会被自动调用，它需要在其派生类的构造中亲自专门调用。
- 2：在调用基类的方法时，需要加上基类的类名前缀，且需要带上self参数变量。区别于在类中调用普通函数时并不需要带上self参数
- 3：Python总是首先查找对应类型的方法，如果它不能在派生类中找到对应的方法，它才开始到基类中逐个查找。（先在本类中查找调用的方法，找不到才去基类中找）。
如果在继承元组中列了一个以上的类，那么它就被称作"多重继承" 。
语法：
派生类的声明，与他们的父类类似，继承的基类列表跟在类名之后，如下所示：
class SubClassName (ParentClass1[, ParentClass2, ...]): 'Optional class documentation string' class_suite
实例：
class ParentClass1: #定义父类
pass
class ParentClass2: #定义父类
pass
class SubClass1(ParentClass1): #单继承，基类是ParentClass1，派生类是SubClass
pass
class SubClass2(ParentClass1,ParentClass2): #python支持多继承，用逗号分隔开多个继承的类
pass
查看继承
print(SubClass1.__bases__) #__base__只查看从左到右继承的第一个子类，__bases__则是查看所有继承的父类 结果：(<class '__main__.ParentClass1'>,) print(SubClass2.__bases__) 结果：(<class '__main__.ParentClass1'>, <class '__main__.ParentClass2'>)
经典类与新式类
1.只有在python2中才分新式类和经典类，python3中统一都是新式类 2.在python2中，没有显式的继承object类的类，以及该类的子类，都是经典类 3.在python2中，显式地声明继承object的类，以及该类的子类，都是新式类 3.在python3中，无论是否继承object，都默认继承object，即python3中所有类均为新式类 #关于新式类与经典类的区别，我们稍后讨论
解决代码重用实例：
class Hero:
def __init__(self,nickname,aggressivity,life_value):
self.nickname=nickname
self.aggressivity=aggressivity
self.life_value=life_value
def move_forward(self):
print('%s move forward' %self.nickname)
def move_backward(self):
print('%s move backward' %self.nickname)
def move_left(self):
print('%s move forward' %self.nickname)
def move_right(self):
print('%s move forward' %self.nickname)
def attack(self,enemy):
enemy.life_value-=self.aggressivity
class Garen(Hero):
pass
class Riven(Hero):
pass
g1=Garen('草丛伦',100,300)
r1=Riven('锐雯雯',57,200)
print(g1.life_value)
r1.attack(g1)
print(g1.life_value)
'''
运行结果
243
'''
3 方法重写
如果从父类继承的方法不能满足子类的需求，可以对其进行改写，这个过程叫方法的覆盖（override），也称为方法的重写。
class Parent: # 定义父类
def myMethod(self):
print ('调用父类方法')
class Child(Parent): # 定义子类
def myMethod(self):
print ('调用子类方法')
c = Child() # 子类实例
c.myMethod() # 子类调用重写方法
#执行结果：
调用子类方法
4 组合
组合指的是：在一个类中以另外一个类的对象作为数据属性，称为类的组合
实例：
class People:
school = '哈佛'
def __init__(self,name,age,sex):
self.name = name
self.age = age
self.sex = sex
class Student(People):
def __init__(self,name,age,sex):
People.__init__(self,name,age,sex)
self.course = [] #学生可以学习多名课程
def tell_info(self):
print('<name:%s age：%s sex：%s>' %(self.name,self.age,self.sex))
class Teacher(People):
def __init__(self,name,age,sex):
People.__init__(self,name,age,sex)
self.course = [] #老师可以教多名课程
self.students = [] #老师可以教多个学生
class Course: #单独定义一个course类
def __init__(self,course_name,course_period,course_price):
self.course_name=course_name
self.course_period=course_period
self.course_price=course_price
def tell_info(self):
print('<课程名:%s 周期：%s 价格：%s>' %(self.course_name,self.course_period,self.course_price))
S_obj1 = Student('Yim',25,'male')
S_obj2 = Student('Lin',22,'male')
T_obj1 = Teacher('Jim',18,'male')
python = Course('Python','6mons',100)
java = Course('Java','10mons',200)
T_obj1.course.append(python) #把课程加进去
T_obj1.course.append(java)
T_obj1.students.append(S_obj1) #把学生加进去
T_obj1.students.append(S_obj2)
S_obj1.course.append(python)
for i in T_obj1.course: #查看老师教的课程
i.tell_info() #Course('Python','6mons',100).tell_info() Course('Java','10mons',200).tell_info()
for i in T_obj1.students: #查看老师有多少名学生
i.tell_info()
for i in S_obj1.course: #查看学生学习的课程
i.tell_info()
#执行结果：
<课程名:Python 周期：6mons 价格：100>
<课程名:Java 周期：10mons 价格：200>
<name:Yim age：25 sex：male>
<name:Lin age：22 sex：male>
<课程名:Python 周期：6mons 价格：100>
5 继承实现原理
继承顺序：
实例：
class A(object):
def test(self):
print('from A')
class B(A):
def test(self):
print('from B')
class C(A):
def test(self):
print('from C')
class D(B):
def test(self):
print('from D')
class E(C):
def test(self):
print('from E')
class F(D,E):
# def test(self):
# print('from F')
pass
f1=F()
f1.test()
print(F.__mro__) #只有新式才有这个属性可以查看线性列表，经典类没有这个属性
#新式类继承顺序:F->D->B->E->C->A
#经典类继承顺序:F->D->B->A->E->C
#python3中统一都是新式类
#pyhon2中才分新式类与经典类
6 子类中调父类的方法
方法一：父类名.父类方法()
class Animal:
def __init__(self,name,age,sex):
self.name=name
self.age=age
self.sex=sex
def eat(self):
print('%s eat' %self.name)
def talk(self):
print('%s say' %self.name)
class People(Animal):
def __init__(self,name,age,sex,education):
Animal.__init__(self,name,age,sex) #调用父类方法，也可以不依赖于继承
self.education=education
def talk(self):
Animal.talk(self) #调用父类方法，也可以不依赖于继承
print('这是人在说话')
peo1=People('Yim',25,'male','幼儿园毕业')
print(peo1.__dict__)
方法二：super()，这种方法依赖于继承，从MRO列表当前的位置往后找
class Animal:
def __init__(self,name,age,sex):
self.name=name
self.age=age
self.sex=sex
def eat(self):
print('%s eat' %self.name)
def talk(self):
print('%s say' %self.name)
class People(Animal):
def __init__(self,name,age,sex,education):
super().__init__(name,age,sex) #python2：super(People.self).__init__()
self.education=education
def talk(self):
super().__init__(self)
print('这是人在说话')
peo1=People('Yim',25,'male','幼儿园毕业')
print(peo1.__dict__)
7 绑定方法与非绑定方法
1、绑定方法：绑定给谁，就由谁来调用，谁来调用就把谁本身当做第一个参数传入（自动传值）
绑定到类的方法：用classmethod装饰器装饰的方法
- 为类量身定制
- 类.bound_method()，自动将类当做第一个参数传入
- 其实对象也可调用，但仍将类当作第一个参数传入
绑定到对象的方法：没有被任何装饰器装饰的方法
- 为对象量身定制
- 对象.bound_method()，自动将对象作为第一个参数传入
- 属于类的函数，类可以调用，但是必须按照函数的规则来，没有自动传值那么一说
实例：
#配置文件settings.py HOST='127.0.0.1' PORT=3306
import settings
class Mysql:
def __init__(self,host,port):
self.host = host
self.port = port
@classmethod
def from_conf(cls): #绑定给类
return cls(settings.HOST,settings.PORT)
def fun1(self): #绑定给对象
pass
conn = Mysql.from_conf()
print(conn.host,conn.port)
#执行结果：
127.0.0.1 3306
2、非绑定方法：在类内部用staticmethod装饰器装饰的函数即非绑定方法，就是普通函数。statimethod不与类或对象绑定（应用场景），谁都可以调用，没有自动传值效果
import uuid
class Mysql:
def __init__(self,host,port):
self.host = host
self.port = port
self.id = self.create_uuid() #调用create_uuid函数
@staticmethod
def create_uuid(): #普通函数，没有自动传值效果
return str(uuid.uuid1())
conn = Mysql('127.0.0.1',3306)
print(conn.id)
#执行结果：
ea5637e8-8199-11e7-962a-34de1a770c8f
8 接口与归一化设计
接口提取了一群类共同的函数，可以把接口当做一个函数的集合。让子类去实现接口中的函数
在Python中没有一个叫做interface的关键字，如果模仿接口的概念，可以借助第三方模块：http://pypi.python.org/pypi/zope.interface，也可以使用继承
实例：
class Interface:#定义接口Interface类来模仿接口的概念，python中压根就没有interface关键字来定义一个接口。
def read(self): #定接口函数read
pass
def write(self): #定义接口函数write
pass
class Txt(Interface): #文本，具体实现read和write
def read(self):
print('文本数据的读取方法')
def write(self):
print('文本数据的写方法')
class Sata(Interface): #磁盘，具体实现read和write
def read(self):
print('硬盘数据的读取方法')
def write(self):
print('硬盘数据的写方法')
class Process(Interface):
def read(self):
print('进程数据的读取方法')
def write(self):
print('进程数据的写方法')
9 抽象类
抽象类是一个特殊的类，只能被继承不能被实例化，在Python中需要借助模块实现。以下是一个实例：
import abc
class Interface(metaclass=abc.ABCMeta):
@abc.abstractmethod
def read(self):
pass
@abc.abstractmethod
def write(self):
pass
class Txt(Interface):
def read(self): #必须要有read
print('文本数据的读取方法')
def write(self): #必须要有write
print('文本数据的写方法')
10 多态
是允许将父对象设置成为和一个或多个它的子对象相等的技术，比如Parent:=Child； 多态性使得能够利用同一类(基类)类型的指针来引用不同类的对象,以及根据所引用对象的不同,以不同的方式执行相同的操作
Python不直接支持多态，但可以间接实现
实例：
import abc
class Animal(metaclass=abc.ABCMeta): #同一类事物:动物
@abc.abstractmethod
def talk(self):
pass
class People(Animal): #动物的形态之一:人
def talk(self):
print('say hello')
class Dog(Animal): #动物的形态之二:狗
def talk(self):
print('say wangwang')
def func(animal):
animal.talk()
p = People()
d = Dog()
func(p)
func(d)
#执行结果：
say hello
say wangwang
11 封装
“封装”就是将抽象得到的数据和行为（或功能）相结合，形成一个有机的整体（即类）；封装的目的是增强安全性和简化编程，使用者不必了解具体的实现细节，而只是要通过外部接口，一特定的访问权限来使用类的成员
实例：
#这种隐藏不是真正意义上的隐藏，其实这仅仅是一种变形操作,只在类定义阶段发生的
#类中所有双下划线开头的名称如__x都会自动变形成：_类名__x的形式
#在子类定义的__x不会覆盖在父类定义的__x
class Foo:
__N = 123456 #变形为_Foo__N
def __init__(self,name):
self.name = name
def __f1(self): #变形为_Foo__f1
print('f1')
def bar(self):
self.__f1() #只有在类内部才可以通过__f1的形式访问到
f = Foo('Yim')
print(Foo.__dict__)
#print(Foo.__N) #外部无法直接访问
f.bar()
#执行结果：
{'__module__': '__main__', '_Foo__N': 123456, '__init__': <function Foo.__init__ at 0x00000000025FB8C8>, '_Foo__f1': <function Foo.__f1 at 0x00000000025FB950>, 'bar': <function Foo.bar at 0x00000000025FB9D8>, '__dict__': <attribute '__dict__' of 'Foo' objects>, '__weakref__': <attribute '__weakref__' of 'Foo' objects>, '__doc__': None}
f1
class People:
def __init__(self,name,age,sex):
self.__name = name
self.__age = age
self.__sex = sex
def tell_info(self):
print('<名字：%s 年龄：%s 性别：%s>' %(self.__name,self.__age,self.__sex))
def set_info(self,x,y,z): #可以定制一些控制逻辑来控制使用者对数据的操作
if not isinstance(x,str):
raise TypeError
if not isinstance(y,int):
raise TypeError
if not isinstance(z,str):
raise TypeError
self.__name = x
self.__age = y
self.__sex = z
p = People('Yim',25,'male')
p.set_info('Zim',18,'male')
p.tell_info()
#取款是功能,而这个功能有很多功能组成:插卡、密码认证、输入金额、打印账单、取钱
#对使用者来说,只需要知道取款这个功能即可,其余功能我们都可以隐藏起来,很明显这么做
#隔离了复杂度,同时也提升了安全性
class ATM:
def __card(self):
print('插卡')
def __auth(self):
print('用户认证')
def __input(self):
print('输入取款金额')
def __print_bill(self):
print('打印账单')
def __take_money(self):
print('取款')
def withdraw(self): #隔离复杂度
self.__card()
self.__auth()
self.__input()
self.__print_bill()
self.__take_money()
a=ATM()
a.withdraw()
静态属性property：property是一种特殊的属性，访问它时会执行一段功能（函数）然后返回值
#计算体质指数（BMI）
#体质指数（BMI）=体重（kg）÷身高^2（m）
class People:
def __init__(self,name,weight,height):
self.name = name
self.weight = weight
self.height = height
@property
def bmi(self):
return self.weight / (self.height ** 2)
p = People('Yim',70,1.80)
# print(p.bmi())
print(p.bmi)
