#yyds干货盘点#Python之面向对象

一、面向对象和面向过程

面向对象的优点就是可扩展性强

二、id、type和value的概念

在python中一切皆对象，每产生一个对象会对应三个属性：id、类型type和数值

三、类和对象的概念

把一类事物的静态属性和动态可以执行的操作组合在一起所得到的这个概念就是类

类的一个个体就是对象，对象是具体的，实实在在的事物

对象是特征和技能的结合体，其中特征和技能分别对应对象的数据属性和方法属性

对象（实例）本身只有数据属性，但是python的class机制会将类的函数绑定到对象上，称为对象的方法，或者叫绑定方法，绑定方法唯一绑定一个对象，同一个雷的方法绑定到不同的对象上，属于不同的方法，内存地址都不会一样 在类内部定义的属性属于类本身的，由操作系统只分配-块内存空间，大家公用一块内存空间

创建一个类就会创建一个类的名称空间，用来存储类中定义的所有名字，这些名字称为类的属性，而类中有两种属性：数据属性和函数属性，其中类的数据属性是共享给所有对象的，而类的函数属性时绑定到所有对象的。

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

在obj.name会先从obj自己的名称空间里找name，找不到则去类中找，类也找不到就找父类...最后都找不到就抛出异常

类的相关方法（定义一个类，也会产生自己的名称空间）

类的相关方法（定义一个类，也会产生自己的名称空间）
类名.__name__ # 类的名字（字符串）
类名.__doc__ # 类的文档字符串
类名.__base__ # 类的第一个父类
类名.__bases__ # 类所有父类构成的元组
类名.__dict__ # 类的字典属性、名称空间
类名.__base__ # 类的第一个父类
类名.__base__ # 类的第一个父类

四、初始化构造函数__init__的作用

所谓初始化构造函数就是在构造对象的同时被对象自动调用，完成对事物的初始化，一个类只要生成一个类的对象，它一定会调用初始化构造函数。

特点：

一个类中只能有一个初始化构造函数

不能有返回值

可以用它来为每个实例定制自己的特征

示例程序：

class Student:
def __init__(self):
print('当前对象的地址是:%s'%self)
if __name__ == '__main__':
student1 = Student()
print(student1)
student2 = Student()
print(student2)

运行结果：

当前对象的地址是:<__main__.Student object at 0x00000000025ACF28><__main__.Student
object at 0x00000000025ACF28>
当前对象的地址是:<__main__.Student object at 0x00000000025D4048><__main__.Student
object at 0x00000000025D4048>Process finished with exit

code 0

五、属性查找

类的两种属性:数据属性和函数属性

类的数据属性是所有对象共享的，id都是一样

类的函数属性是绑定给对象使用的，obj.method称为绑定方法，内存地址都不一样；id是python的实现机制，并不能真实反映内存地址，如果有内存地址，还是内存地址为准

在obj.name会先从obj自己的名称空间里找到name，找不到则去类中找，类也找不到就找父类...最后都找不到就抛出异常

绑定到对象的方法的特殊之处

class OldboyStudent:
school='oldboy'
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)

类中定义的函数（没有被任何装饰器装饰的）

是类的函数属性，类可以使用，但必须遵循函数的参数规则，有几个参数就需要传几个参数

其实主要是给对象使用，而且是绑定到对象的，虽然所有对象指向都是相同的功能，但是绑定到不同的对象就是不同的绑定方法

强调：绑定到对象的方法的特殊之处在于，绑定给谁就由谁来调用，谁来调用，就会将‘谁’本身当作第一个参数传给方法，即自动传值（方法__init__也是一样的道理）

注意：绑定到对象方法的这种自动传值的特征，决定了在类中定义的函数都要默认写一个参数self，self可以是任意名字，但是约定俗成地写出self

ldboyStudent.learn(s1) #李坦克 is learning
OldboyStudent.learn(s2) #王大炮 is learning
OldboyStudent.learn(s3) #牛榴弹 is learning

s1.learn() #等同于OldboyStudent.learn(s1)
s2.learn() #等同于OldboyStudent.learn(s2)
s3.learn() #等同于OldboyStudent.learn(s3)

类即类型：python中一切皆为对象，且python3中类与类型是一个概念，类型就是类

​对象之间的交互

​​​class​ ​Teacher​:
​def​ ​__init__​(self, name): self.name = name
self.cost =
0
​def​ ​gain​(self, obj_course):
self.cost += obj_course.price
​class​ ​Course​:
​def​ ​__init__​(self, name, price): self.name = name
self.price = price
t1 = Teacher(
'alex')c1 = Course(
'python', 12500)t1.gain(c1)
​# t1.gain通过调用c1的内存地址来使用price数据属性​
print(t1)
print(c1)
print(t1.cost)
运行结果：
<__main__.Teacher object at 0x0367A8F0><__main__.Course object at
0x0367A0F0>
12500​​

六、面向对象之继承与派生

继承的区分:

什么是继承？继承是一种创建新类的方式，新建的类可以继承一个或者多个父类（python支持多继承），父类又可以称为基类或超类，新建的类称为派生类或子类；子类会“遗传”父类的属性，从而解决代码重用问题

单继承和多继承:

python2中多继承是深度优先

python3中多继承是广度优先

在class A(B,C)时,先继承B类的所有父类,如果有共同继承的类,则开始继承C类的所有父类直到共同继承的类

python对于定义的每一个类，都会计算出一个方法解析顺序（MRO）列表(通过C3线性化算法来实现)，这个列表就是一个简单的所有基类的线性顺序列表，,例如

class Teacher:
def __init__(self, name):
self.name = name
self.cost = 0

def gain(self, obj_course):
self.cost += obj_course.price


class Course:
def __init__(self, name, price):
self.name = name
self.price = price


t1 = Teacher('alex')
c1 = Course('python', 12500)

t1.gain(c1) # t1.gain通过调用c1的内存地址来使用price数据属性

print(t1)
print(c1)
print(t1.cost)

运行结果：
<__main__.Teacher object at 0x0367A8F0>
<__main__.Course object at 0x0367A0F0>
12500

在类class A情况下查看继承

使用.__bases__来查看所有继承的父类

使用.__base__只查看从左到右继承的第一个子类

经典类与新式类

1. 只有在python2中才分新式类和经典类，python3中统一是新式类

2. 在python2中，没有显示继承object类的类，以及该类的子类，都是经典类

3. 在python2中，显式地声明继承object的类，以及该类的子类，都是新式类

4. 在python3中，无论是否继承object，都是默认继承object，即python3中所有类均为新式类

提示：如果没有指定基类，python的类会默认继承object类，object是所有python类的基类，它提供了一些常见方法（如__str__）的实现。

继承与抽象，继承描述的是子类与父类之间的关系，是一种什么是什么的关系。要找出这种关系。必须先抽象再继承，抽象分为两个层次：

将对象比较像的部分抽取成类

将类比较像的部分抽取成父类

抽象最主要的作用是划分类别（可以隔离关注点，降低复杂度）

派生:子类可以添加自己新的属性或者在自己这里重新定义这些属性,一旦定义了自己的属性且与父类重名,那么调用新增的属性时,就以自己为准

组合,​组合指的是,在一个类中以另外一个类的对象作为数据属性,称为类的组合​​​class​ ​Date​:
​def​ ​__init__​(self,year,month,day): self.year = year
self.month = month
self.day = day

​def​ ​tell​(self): print(
"%s--%s--%s"%(self.year,self.month,self.day))
​class​ ​People​:
​def​ ​__init__​(self,name,age):
self.name = name
self.age = age
​class​ ​Student​(People):
​def​ ​__init__​(self,name,age,sex,year,month,day): People.__init__(self,name,age)
self.sex = sex

​#下面这一步骤就是组合​
self.birth = Date(year,month,day)
​if​ __name__ == '__main__': student = Student(
"alex",25,"man",2015,12,31) print(
"student的birth成员指向了一个Date对象!") print(
"%s"%student.birth)
student.birth.tell()

运行结果：
student的birth成员指向了一个Date对象!<__main__.Date object at
0x0000000002604358>
2015--12--31​​接口与归一化设计:

什么是接口？

接口指的是：自己提供给使用者来调用自己功能的方式\方法\入口

通过接口可以实现不相关类的相同行为，可以起到一个标志的作用

接口提供了不同的类进行相互协作的平台

在python中根本就没有一个叫做interface的关键字。如果非要去模仿接口的概念，可以借助第三方模块

raise：主动抛出异常，本来没有错，主动抛出错

#模拟Java中接口的概念
class S1:
def read(self):
raise TypeError("类型错误")
def write(self):
raise TypeError("类型错误")

class S2(S1):
def read(self):
print("from S2")
def write(self):
print("from S2")

class S3(S1):
def read(self):
print("from S3")
def read(self):
print("from S3")

if __name__ == '__main__':
s2 = S2()
s2.read()
s3 = S3()
s3.read()

运行结果：
from S2
from S3

为何要使用接口？

接口提取了一群类共同的函数，可以把接口当做一个函数的集合

然后让子类去实现接口中的函数

这么做的意义在于归一化，什么叫归一化，就是只要基于同一个接口实现的类，那么所有的这些类产生的对象在使用时，从用法上来说都一样

归一化的好处使用者无需关心对象的类是什么

抽象类:

python中抽象方法定义的方式：利用abc模块实现抽象类，在Java当中如果一个方法没有执行体就叫做抽象方法，而在python中不是以执行体的有无作为标准，而是以一个方法是否有@abc.abstactmethod装饰器作为标准，有则是抽象方法

抽象方法通过子类的实现可以变成普通的方法

抽象方法不存在重写的问题

含有抽象方法的类一定是抽象类，但是抽象类不一定含有抽象方法，此时也就没有什么意义了

抽象类是一个介于类和接口直接的一个概念，同时具备类和接口的部分特性，可以用来实现归一化设计

抽象类和普通类的不同之处在于:抽象类中只能有抽象方法(没有实现功能),该类不能被实例化,只能被继承,且子类必须实现抽象方法

"""
1、什么叫做抽象方法?含有@abc.abstractmethod标识符的就是？
2、原样抄下来也是重写？
"""
import abc
class File(metaclass=abc.ABCMeta):
@abc.abstractmethod
def read(self):
pass
#抽象类中可以有普通方法
def write(self):
print("11111")

class B(File):
#如果写pass,也是可以的,此时子类将会覆盖掉父类
def read(self):
pass

if __name__ == '__main__':
bb = B()
bb.read()
bb.write()

运行结果：

11111

super关键字的使用

super关键字产生的原因：在子类当中可以通过使用super关键字来调用父类中相应的方法，简化代码。

使用super调用的所有属性，都是从MRO列表当前的位置往后找，千万不要通过看代码去找继承关系，一定要通过看MRO列表

class Foo:
def test(self):
print("from foo")

class Bar(Foo):
def test(self):
#Foo.test(self)
super().test()
print("bar")

if __name__ == '__main__':
bb = Bar()
bb.test()

七、面向对象之多态,多态性

多态：指的是同一种事物有多种形态

多态性：定义统一的接口，可以传入不同类型的值，但是调用的逻辑都一样，执行的结果却不一样

多态性依赖于：1. 继承 2. 多态性的好处: 增加了程序灵活性 增加程序可扩展性 多态性的实现

八、面向对象封装

封装数据:将数据隐藏起来后对外提供操作该数据的接口,然后我们可以在接口附加上对该数据操作的限制,对数据属性操作的严格控制

封装方法:目的是隔离复杂度

python中用双下滑线的方式将属性隐藏起来(设置成私有的)

# 其实这仅仅这是一种变形操作且仅仅只在类定义阶段发生变形
# 类中所有双下划线开头的名称如__x都会在类定义时自动变形成:__类__x的形式：
class A:
__N = 0
def __init__(self):
self.__x = 10 # 变形为self._A__X
def __foo(self): #变形为_A__foo
print('from A')
def bar(self):
self.__foo() #只有在类内部才可以通过__foo的形式访问到.

#A._A__N是可以访问到的，
#这种，在外部是无法通过__x这个名字访问到。

这种变形需要注意的问题是：

这种机制也并没有真正意义上限制我们从外部直接访问属性，知道了类名和属性名就可以拼出名字，==这种操作并不是严格意义上的限制外部访问，仅仅只是一种语法意义上的变形，主要用来限制外部的直接访问

==变形的过程只有在类的定义时发生一次，在定义后的赋值操作，不会变形

封装不是单纯意义的隐藏

封装数据：隐藏起来后对外提供操作该睡觉的接口，然后我们可以在接口附加上对该数据操作的限制，以此完成对数据属性操作的严格控制

class Teacher:
def __init__(self, name, age):
self.set_info(name, age)

def tell_info(self):
print('姓名：%s，年龄：%s' % (self.__name, self.__age))

def set_info(self, name, age):
if not isinstance(name, str):
raise TypeError('姓名必须是字符串！！！')
if not isinstance(age, int):
raise TypeError('生日必须是数字！！！')
self.__name = name
self.__age = age


t = Teacher('alex', 12)
t.tell_info()

t.set_info('egon', 25)
t.tell_info()

运行结果：
姓名：alex，年龄：12
姓名：egon，年龄：25

封装方法：目的是隔离复杂度

#取款是功能,而这个功能有很多功能组成:插卡、密码认证、输入金额、打印账单、取钱
#对使用者来说,只需要知道取款这个功能即可,其余功能我们都可以隐藏起来,很明显这么做
#隔离了复杂度,同时也提升了安全性

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()

运行结果：

插卡
用户认证
输入取款金额
打印账单
取款

了解一下

python是不会阻止你访问私有的属性，模块也遵循这种约定，如果模块名以单下划线开头，那么from module import * 时不能被导入，但是from module import _private_module依然是可以导入的

特性（property）

什么是特性，property是一种特性的属性，访问它时会执行一段功能（函数）然后返回值

为什么要用property将一个类的函数定义成特性以后，对象再去使用的时候 ​​obj.name​​遵循了统一访问的原则

class Foo:
def __init__(self, name):
self.__name = name # 将所有的数据属性都隐藏起来

@property
def name(self):
return self.__name # obj.name访问的是self.__name（这也是真实值得存放位置）

@name.setter
def name(self, name):
if not isinstance(name, str): # 设定值之前进行类型检查
raise TypeError('%s is not string!' % name)
self.__name = name # 通过类型检查后，将值name存放到真实的位置self.__name

@name.deleter
def name(self):
raise TypeError('Can not delete')


f = Foo('alex')
print(f.name)

f.name = 'egon'
print(f.name)

del f.name # 抛出异常TypeError: Can not delete

运行结果：

alex
egon

封装与扩展性

封装在于明确区分内外，使得类实现者可以修改封装内的东西而不影响外部调用者的代码，而外部使用者只知道一个接口（函数），只要接口（函数）名，参数不变，使用者的代码永远无需改变。这就是提供一个良好的合作基础----或者说，只要接口这个基础约定不变，则代码改变不足为虑

九、面向对象之绑定方法与非绑定方法

类中定义的函数分为两大类

绑定方法（绑定给谁，谁来调用就自动将它本身当作第一个参数传入）

绑定到类的方法classmethod装饰器

为类量身定制

类.boud_method(),自动将类当作第一个参数传入

绑定到对象的方法

非绑定方法：用staticmethod装饰器装饰的方法

不与类或对象绑定，类和对象都可以调用

绑定方法

绑定给对象的方法

绑定给类的方法

classmethod是给类用的，即绑定到类，类在使用时会将类本身当做参数传给类方法的第一个参数（即便是对象来调用也会将类当作第一个参数传入），python为我们内置了函数classmethod来把类中的函数定义成类方法

import settings
class MySQL:
def __init__(self,host,port):
self.host=host
self.port=port

@classmethod
def from_conf(cls):
print(cls)
return cls(settings.HOST,settings.PORT)

print(MySQL.from_conf) #<bound method MySQL.from_conf of <class '__main__.MySQL'>>
conn=MySQL.from_conf()

conn.from_conf() #对象也可以调用，但是默认传的第一个参数仍然是类

非绑定方法

在类内部用staticmethod装饰的函数即非绑定方法，就是普通函数

staticmethod不与类或对象绑定，谁都可以调用，没有自动传值的效果