Python知识点13---面向对象的编程

提前说一点：如果你是专注于Python开发，那么本系列知识点只是带你入个门再详细的开发点就要去看其他资料了，而如果你和作者一样只是操作其他技术的Python API那就足够了。

Python是一个完全面向对象开发的语言，它的一切都以对象的方式操作

类(Class): 用来描述具有相同的属性和方法的对象的集合。它定义了该集合中每个对象所共有的属性和方法。对象是类的实例。
类变量：类变量在整个实例化的对象中是公用的。类变量定义在类中且在函数体之外。类变量通常不作为实例变量使用。
数据成员：类变量或者实例变量, 用于处理类及其实例对象的相关的数据。
方法重写：如果从父类继承的方法不能满足子类的需求，可以对其进行改写，这个过程叫方法的覆盖（override），也称为方法的重写。
局部变量：定义在方法中的变量，只作用于当前实例的类。
实例变量：在类的声明中，属性是用变量来表示的。这种变量就称为实例变量，是在类声明的内部但是在类的其他成员方法之外声明的。
继承：即一个派生类（derived class）继承基类（base class）的字段和方法。继承也允许把一个派生类的对象作为一个基类对象对待。例如，有这样一个设计：一个Dog类型的对象派生自Animal类，这是模拟"是一个（is-a）"关系（例图，Dog是一个Animal）。
实例化：创建一个类的实例，类的具体对象。
方法：类中定义的函数。
对象：通过类定义的数据结构实例。对象包括两个数据成员（类变量和实例变量）和方法。

定义一个类的语法如下，注意如果你用的是Python2，那么不要写objeck，不然会报错的

class ClassName(objeck):'类的帮助信息'   #类文档字符串class_suite  #类体#类的实例方法def aaa(self) :return

实例化类，生成对象语法如下

变量名 = 类名()  ---不需要其他语言那样的new

---

Python的类里面，和其他语言不同的就是，有时方法中会多一个 self，这个变量你要使用的时候，一般都是放在第一个参数位，并且代表对象本身，下面这个例子可以解释这一点

class Test:def prt(self):print(self)t = Test()
print(t)
t.prt()结果发现指向的都是同一个对象：
<__main__.Test instance at 0x10d066878>
<__main__.Test instance at 0x10d066878>

切记：对于 self 本身来说，它不是一个定死的关键字，我们换成其他的名字也可以，只是在开发中我们按照惯例，把它写在了第一个参数位，并且起名为 self ，它本身其实是和JAVA的this对象等价的，只不过Python需要在参数位声明一下而已

而且当你使用了self的时候，在传递参数时，不需要在意它的值，因为可以自动补齐，如下

class Test :def fun_name(self,b,c):print(b+str(c))a = Test()
a.fun_name('忽略self正常传参',21)
结果：忽略self正常传参21

---

对于Python的类来说，也是拥有属性的，我们在类的内部，类实体方法的外部，书写属性即可，但是切记在类中书写属性的时候一定要给一个初值，不然访问的时候会报错

class Test :age = ''def fun_test():print('llll')

在使用这个类创建对象之后，对象会拥有类的所有东西，属性自然也包括其中，调用时语法如下，这一点在Python中叫做 “类外面获取对象属性”

对象名.属性名		#调用获取
对象名.属性名 = 值	#修改

但是注意，Python允许一个对象拥有属于自己的属性，这种属性不需要在类中定义，直接使用对象调用就可以，会自动生成一个数据这个对象自己的属性，其他对象没有，下面这个例子可以解释这一点，这一点在Python中也叫做 “类外面添加对象属性”

class Test :def fun_name():print('llll')a = Test()
b = Test()a.age = '12'
print(a.age)
print(b.age)结果会报错，提示对象b没有age属性：
12
Traceback (most recent call last):File "main.py", line 12, in <module>print(b.age)
AttributeError: Test instance has no attribute 'age'

这个时候有的小伙伴可能就会疑惑，有类外面获取对象属性、类外面添加对象属性，这两点都聚焦在对象的身上，和类的关系不是很明显，其实Python还有最后一种相关操作，叫做“在类内部获取对象属性”，对于这一点，个人认为其实是Python提供给我们开发者的一种辅助，防止我们由于其他因素导致访问不到对象的属性，比如被局部变量或者其他变量干扰，操作方式如下

class Test :age = 12def fun_name(self):print(self.age)a = Test()
a.fun_name()

其实就是self的应用，不过注意，这种操作可以和类外部添加属性那样直接调用一个原先没有的属性

class Test :def fun_name(self):print(self.age)a = Test()
a.age = 10
a.fun_name()

现在我猜测大家或许会混乱，没关系，记住核心的一点：在Python中，可以像常规那样使用对象和类，只是Python除此之外，允许一个属性在使用的时候，是从无到有的，也就是没有被预先定义的

其实对于self来说，它不止可以调用我们自己定义的属性，它还带有着其他的东西，有兴趣大家可以在其他地方找一找资料，比如可以获取对象实例化的类名

class Test :def fun_name(self):print(self.__class__)a = Test()
a.fun_name()结果：__main__.Test

---

对于对象的属性，Python其实有着其他的方式可以调用

getattr(obj, name[, default]) : 访问对象的属性。
hasattr(obj,name) : 检查是否存在一个属性。
setattr(obj,name,value) : 设置一个属性。如果属性不存在，会创建一个新属性。
delattr(obj, name) : 删除属性。hasattr(emp1, 'age')    # 如果存在 'age' 属性返回 True。
getattr(emp1, 'age')    # 返回 'age' 属性的值
setattr(emp1, 'age', 8) # 添加属性 'age' 值为 8
delattr(emp1, 'age')    # 删除属性 'age'

Python类的本身其实也有自带的被规定的属性，俗称类属性，为什么说它被规定呢？这个后面我会解释

调用的时候用   类名.类属性    就可以了__dict__ : 类的属性（包含一个字典，由类的数据属性组成）
__doc__ :类的文档字符串
__name__: 类名
__module__: 类定义所在的模块
__bases__ : 类的所有父类构成元素（包含了一个由所有父类组成的元组）

有意思的是我们通过类名可以直接将自己定义的属性获取到，这个时候，这个属性也叫做类属性

---

下面我们了解一下，在Python中对象是如何被垃圾回收的

在Python中只有一种垃圾回收机制，就是引用计数法，在 Python 内部记录着所有使用中的对象各有多少引用。

一个内部跟踪变量，称为一个引用计数器。

当对象被创建时， 就创建了一个引用计数， 当这个对象不再需要时， 也就是说， 这个对象的引用计数变为0 时， 它被垃圾回收。但是回收不是"立即"的， 由解释器在适当的时机，将垃圾对象占用的内存空间回收。

垃圾回收机制不仅针对引用计数为0的对象，同样也可以处理循环引用的情况。循环引用指的是，两个对象相互引用，但是没有其他变量引用他们。这种情况下，仅使用引用计数是不够的。Python 的垃圾收集器实际上是一个引用计数器和一个循环垃圾收集器。作为引用计数的补充， 垃圾收集器也会留心被分配的总量很大（即未通过引用计数销毁的那些）的对象。 在这种情况下， 解释器会暂停下来， 试图清理所有未引用的循环，其实说白了就是有a、b两个对象，它们独立与其他对象，产生较为单独的一对相互引用关系，这种对象时间长了，也会被回收掉

特别注意一个对象被回收时，会调用它的__del__方法，这个方法是用来回收对象的，但大家不要纠结，后面我会单独说这种有四个下滑线的方法，是干什么的

---

下面我们来了解一下类的继承，类继承语法如下

class 派生类名(基类名):...

Python的类继承的时候，和其他语言一样有着注意点：

1、如果在子类中需要父类的构造方法就需要显式的调用父类的构造方法，或者不重写父类的构造方法。实例如下

当你没有重写构造方法时：
class Father():def __init__(self, name):self.name=namedef getName(self):return 'Father ' + self.nameclass Son(Father):def getName(self):return 'Son '+self.nameson=Son('runoob')
print ( son.getName() )结果：Son runoob
从结果中你可以发现，传入的name值作用在了父类的构造器上-----------------------------------------------------------------------------
当你重写了子类的构造方法，但是没有调用父类的时候：
class Father():def __init__(self, name):self.name=namedef getName(self):return 'Father ' + self.nameclass Son(Father):def __init__(self, name):print ( "hi" )self.name =  namedef getName(self):return 'Son '+self.nameson=Son('runoob')
print ( son.getName() )结果：
hi
Son runoob
从结果来看，发现并没有调用父类的构造方法------------------------------------------------------------
当你重写了子类的构造方法，并调用了父类的构造方法时：
class Father():def __init__(self, name):self.name = nameprint("这里是父类")class Son(Father):def __init__(self, name):#第一种调用方法：super(Son, self).__init__(name)#第二种调用方法：Father.__init__(self,name)print ("hi")self.name =  namedef getName(self):return 'Son '+self.nameson=Son('runoob')
print ( son.getName() )
结果：
这里是父类
hi
Son runoob

2、在调用基类的方法时，基类的方法必须有self参数，不然无法执行，对于这一点其实大家养成写方法参数要带上self的习惯就可以了

基类没有self：
class Father():def __init__(self, name):self.name = namedef nnn():print('父类方法')class Son(Father):def __init__(self, name):Father.__init__(self,name)self.name =  nameson=Son('runoob')
son.nnn()
结果报错：
Traceback (most recent call last):File "main.py", line 17, in <module>son.nnn()
TypeError: nnn() takes no arguments (1 given)----------------------------------------------------------------
基类有self
class Father():def __init__(self, name):self.name = namedef nnn(self):print('父类方法')class Son(Father):def __init__(self, name):Father.__init__(self,name)self.name =  nameson=Son('runoob')
son.nnn()
结果：父类方法

3、Python 总是首先查找对应类型的方法，如果它不能在派生类中找到对应的方法，它才开始到基类中逐个查找。（先在本类中查找调用的方法，找不到才去基类中找）。

---

值得高兴的是Python支撑多继承

class A:        # 定义类 A
.....class B:         # 定义类 B
.....class C(A, B):   # 继承类 A 和 B
.....

还提供了两个检查函数

issubclass()  布尔函数判断一个类是另一个类的子类或者子孙类，语法：issubclass(子类,父类)
isinstance(obj, Class) 布尔函数如果obj是Class类的实例对象或者是一个Class子类的实例对象则返回true

---

Python也支持多态，在重写父类方法的时候也要注意self

class Father():def __init__(self, name):self.name = namedef nnn(self):print('父类方法')class Son(Father) :def __init__(self, name) :Father.__init__(self,name)self.name = namedef nnn(self,age) :print('子类方法' + str(age))def nnn(self,age,ppp) :print('子类方法' + str(age) + str(ppp))a = Son('Tom')
a.nnn(10)
a.nnn(10,20)
结果：
子类方法10
子类方法1020

---

如果看了我写的公共方法篇，一定知道加法是合并的意思，而有趣的是Python的对象也支持这样的操作，不过想要对象之间执行合并你需要重写__add__方法

class Vector:def __init__(self, a, b):self.a = aself.b = bdef __str__(self):return 'Vector (%d, %d)' % (self.a, self.b)def __add__(self,other):return Vector(self.a + other.a, self.b + other.b)v1 = Vector(2,10)
v2 = Vector(5,-2)
print v1 + v2
结果：Vector (7, 8)

---

值得一提的是，在Python中类也是有静态方法的

class Father():def __init__(self, name):self.name = name@staticmethoddef nnn(self):print('静态方法')Father.nnn()
a = Father('Tom')
a.nnn()