类和继承

Python虽然以函数式著称，但在Python中，万物皆对象，其对面向对象编程是有着非常不错的支持的。类是面向对象的核心数据类型，下面代码就创建了一个Person类。

class Person:count = 0def __init__(self, name, ID):self.name = nameself.ID = IDPerson.count += 1def introduce(self):print(f"I'm {self.name}")def peopleCount(self):print(f"There are {Person.count} persons")p1 = Person("micro", 1)
p2 = Person("cold", 2)
p1.introduce()      # I'm micro
p1.peopleCount()    # There are 2 persons

其中，__init__函数用于类的初始化，参数self表示当前对象。所以创建p1和p2时，两人分别被赋予了不同的姓名和编号，并可通过introduce方法进行调用。

写在类内部、函数外部的变量属于整个类的共有变量，所以每当创建一个新的对象时，count都会加一。所以，无论p1还是p2在调用peopleCount函数时，均回得到共有两人的结果。当然，随着创建对象的增多，这个值也会随之增长。

在一个类中，一般变量被称作成员变量，函数被称作成员函数，也可称为方法。

如果只用一个关键词来形容面向对象，那么这个关键词一定是继承，不能继承的类将和结构体没什么区别。下面是一个继承了【Person】的类。

class Student(Person):def __init__(self, name, ID, grade):super(Student, self).__init__(name, ID)self.grade = gradedef introduce(self):print(f"I'm {self.name}", end=', ')self.getGrade()def getGrade(self):print(f"my grade is {self.grade}")p3.introduce()      # I'm soft, my grade is 4
p3.peopleCount()    # There are 3 persons

在类的继承过程中，如果想连带着继承类的某个方法，那么就可以直接将这个方法省略，比如peopleCount，便直接沿用了Person类中的内容。

相应地，如果重新写了这个函数，那么这个函数就会焕然一新，而与父类的同名方法变得毫无关联，这个过程叫做方法重写。introduce就是这种情况，虽然与Person类有着相同的名字，但输出结果发生了变化。

初始化函数也是一样，如果省略，就会沿用父类的做法；如果重写，就会变得与父类无关。super函数为子类和父类的函数之间架设了一道桥梁，super(Student, self)即可找到Student的父类，并调用其中的函数。所以Student类尽管重写了初始化方法，但也沿用了父类的一些处理，从而节约了代码。

变量保护

在Python中，出于于某些考虑，会对属性加以保护，不得随意访问。比如一个人的年龄，大小倒是无所谓了，但必须得是个数值，如果完全暴露出去，那被人改成字符串麻烦可就大了。

为此，在Python中，如果某个成员以双下划线开头，那么这就是无法被访问的，从而使得变量得以保护。

但另一方面，又不得不围绕这个属性创建一系列方法，最起码就得包括设置和读取的功能，为了让这些功能更易于调用，Python提供了property函数，示例如下

class Private(Person):def set_age(self, age):if type(age)==int:self.__age = agedef get_age(self):return self.__agedef del_age(self):del self.__ageage = property(get_age, set_age, '年龄')p3 = Private("c", 3)
p3.age = 18
print(p3.age)   # 18
p3.__age
'''直接调用会报错
Traceback (most recent call last):File "<stdin>", line 1, in <module>
AttributeError: 'Person' object has no attribute '__age'
'''
p3.age = "20"
print(p3.get_age())
print(p3.age)   # 18

其中，_age是一个私有变量，受到保护，无法访问。而age则可以赋值和调用值。但是，当把age的值设为字符串时，并没有响应，可见当赋值的时候，的确是调用了set_age方法。

property提供了装饰器的语法糖，从而上述功能可以写成形如下式的更加简洁的形式，并且添加了删除属性的功能。

class Private(Person):@propertydef age(self):return self.__age@age.setterdef age(self, age):if type(age)==int:self.__age = age@age.deleterdef age(self):del self.__age

在编程时，类内部的很多东西并不想被外界得到，即需要一种访问限制的方法，以避免下列情况的发生

p3.count -= 5
print(p3.count)   # -2

类装饰器

一般来说，在Python类中不加修饰的方法叫做实例方法，即只有经过经过实例化之后，才能调用。但也存在另一种需求，即不创建类的对象，而直接调用类的方法。比如想通过类的方法进行初始化，或者干脆只是把类当作一个函数库。

为此，可以使用类方法和静态方法，这两种方法可直接通过类的名字进行调用。区别在于，类方法会将类自身作为第一个参数传入，而静态方法则完全就是一个函数，某种意义上来讲，似乎和这个类并无关联，示例如下。

class Person:count = 0def __init__(self, name, ID):self.name = nameself.ID = IDPerson.count += 1def introduce(self):print(f"I'm {self.name}")@classmethoddef peopleCount(cls):print(f"There are {cls.count} persons")@classmethoddef alphaMan(cls, name, ID):cls.count -= 1return Person(name, ID)@staticmethoddef add(a,b):return a+b

其中，introduce是实例方法，无需多言。

【classmethod】是类方法的装饰器，上面代码中，peopleCount和alphaMan都是类方法，其第一个参数cls指代的就是Person自身。

【staticmethod】是静态方法修饰器，add方法即为静态方法，可见这个方法的目的是求和，从代码结构来看，实在看不到与Person的半点关联。

示例如下，可见静态方法和类方法均可不经实例化而调用，且前者与普通的函数没什么区别。当调用构造函数创建对象时，count会增加；而创建一个透明人，由于代码中剪掉了一个计数，所以count并不会增加。

Person.add(3,4)         # 7
Person.peopleCount()    # There are 0 persons
p1 = Person("a", 1)
Person.peopleCount()    # There are 1 persons
p2 = Person.alphaMan("b", 2)
Person.peopleCount()    # There are 1 persons