python是一种面向对象的编程语言，虽然并不要求以面向对象的方式进行编程实现，但是学会使用面向对象的方式进行编程，可以实现更加强大、复杂的功能
类
类是一种数据结构，是对现实世界的一种抽象，将数据属性以及行特性封装在一起。
类定义
使用class关键字来定义一个类
class ClassName:
''' class doc '''
class_suit
说明：class_suit可以包含：
- 数据属性定义，即变量
- 行为特性定义，即方法或者叫函数
例：
>>> class Person:
... name = ''
... def getName(self):
... return self.name
... def setName(self, name):
... self.name = name
...
>>> p = Person()
>>> p.setName('jone')
>>> p.getName()
'jone'
>>>
类属性
- 类的数据属性
在类里面定义的变量称为类的数据属性，如上面例子中Person类中定义的name
在上面例子中name是通过一个实例p再通过一个方法访问，还可以直接通过类名加上.来访问，如下：>>> Person.name '' >>> Person.name = 'alex' >>> Person.name 'alex' >>> p.getName() 'jone' - 类的方法属性
在类中定义的函数，就是类的方法属性，与普通函数的区别就是，类的方法第一个参数必须是self，这个参数代表实例本身，在通过实例调用方法时self会自动传入而不需要主动传入，如前面Person类例子
与数据属性类似，类的方法属性也可以通过类来直接访问，但是注意这种方式调用时第一个参数self必须主动传入，如下>>> Person.getName() Traceback (most recent call last): File "<stdin>", line 1, in <module> TypeError: getName() missing 1 required positional argument: 'self' >>> >>> Person.getName(Person) 'alex' >>> >>> Person.getName(p) 'jone' >>>注意：在早期的版本例如python2版本中，使用类直接调用方法时，第一个参数必须传入一个实例对象，而不能传入类本身
实例
类是一种数据结构，可以看成是类型，而类的实例就是类这种类型的一个具体的变量
类的实例化与函数调用类似都是通过()来实现，如前面例子：
p = Person()
就是创建了一个Person类的实例p
注意：python中类的实例化与函数调用类似，为了在代码中区分开来，建议类名字以大写字母开头（大驼峰），而函数以小写字母开头（小驼峰）
构造器
在python语言中，类的构造方法为内建方法__init__()，在类中会默认实现一个什么都不做的构造方法，所以在定义类的时候最好实现自己的逻辑来覆盖。
>>> class Person:
... def __init__(self, name, age):
... self.name = name
... self.age = age
... def getName(self):
... return self.name
... def getAge(self):
... return self.age
...
>>>
>>> p = Person('jhon', 12)
>>> p.getName()
'jhon'
>>> p.getAge()
12
>>>
析构器
python语言的析构方法也是通过内建函数实现：__del__()。可以在析构器中实现对对象回收前的一些清理工作
注意，只有在实例对象被回收的时候才会被调用
>>> class Person:
... def __init__(self):
... print(' init ')
... def __del__(self):
... print(' del ')
...
>>> p = Person()
init
>>> p1 = p
>>> p2 = p
>>> del p
>>> del p1
>>> del p2
del
>>>
继承
类似于C++，python类的继承可以包含单继承和多继承（即从多个类继承），定义如下
class ClassName(BaseClass1[, BaseClass2, ... , BaseClassN]):
''' class doc '''
class_suit
注意：定义类时，类名后面没有基类信息时，默认是从object类继承，如前面的类Person
例如：
>>> class Person:
... pass
...
>>> class Student(Person):
... pass
...
>>> p = Person()
>>> s = Student()
>>> s.__class__
<class '__main__.Student'>
>>> Student.__bases__
(<class '__main__.Person'>,)
>>> class Test:
... pass
...
>>> class Test1(Student, Test):
... pass
...
>>> t = Test1()
>>> t.__class__
<class '__main__.Test1'>
>>> Test1.__bases__
(<class '__main__.Student'>, <class '__main__.Test'>)
>>>
方法覆盖
当父类中的方法无法满足求时，可以在子类中以同名方法进行重写，这样在子类中就会覆盖父类中对应的方法，如下：
>>> class Person:
... def foo(self):
... print('Person.foo')
...
>>> class Student(Person):
... def foo(self):
... print('Student.foo')
...
>>> s = Student()
>>> s.foo()
Student.foo
>>> super(Student, s).foo()
Person.foo
>>>
说明：super是一个内建函数，可以通过此方法来访问对象的父类中的方法
多态
多态简单来说就是在一个类中，可以定义多个同名函数，以不同的参数类型或者参数个数来区分
但是python中函数定义时，参数是没有类型的，所以不可能提供不同参数类型的同名函数，我试了下使用同名函数之后只会以最后一次定义的函数为准，即后面定义的同名函数会覆盖前面定义的同名函数
>>> class Person:
... def foo(self, a):
... print(a)
... def foo(self, a, b):
... print('%s, %s' % (a, b))
...
>>> p = Person()
>>> p.foo(1)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: foo() missing 1 required positional argument: 'b'
>>> p.foo(1, 2)
1, 2
>>>
>>> class Person:
... def foo(self, a, b):
... print('%s, %s' % (a, b))
... def foo(self, a):
... print(a)
...
>>> p = Person()
>>> p.foo(1, 2)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: foo() takes 2 positional arguments but 3 were given
>>> p.foo(1)
1
>>>
个人理解：
从这个例子中可以看出来，python语言没有常规意义的多态
网友评论