目录结构：
1.类的基本使用
下面是类使用的一个简单案例，
class person:
"person 类的描述信息"
def __init__(self,name="",age=0):
self.name = name
self.age = age def setName(self,name):
'''设置名称'''
self.name = name def getName(self):
'''获取名称'''
return self.name def setAge(self,age):
self.age = age def getAge(self):
return self.age def __del__(self):
print("person (name:"+self.name+",age:"+str(self.age)+") is deleting") p = person("jame",12);
#Output:jame
print(p.getName())
#效果和下面的调用方式是一样的
#person.getName(p) #Output:12
print(p.getAge())
#效果和下面的调用方式是一样的
#person.getAge(self) #Output: person 类的描述信息
print(p.__doc__) #输出person类的帮助信息
print(help(person)) del p
输出：
jame
12
person (name:jame,age:12) is deleting
person 类的描述信息
Help on class person in module __main__: class person(builtins.object)
| person 类的描述信息
|
| Methods defined here:
|
...
__init__函数是构造函数，在构造对象的时候会自动调用该函数。
__del__函数是析构函数，在使用del删除目标对象时会自动调用该方法。
Python中，类不可以定义多个构造方法，只能定义一个构造方法。所有成员实例函数的第一个参数都必须是self参数（也可以有非self参数的成员函数，下面会讲解）。python会自动创建成员属性，无需提前定义，例如self.name=name。
类属性
类属性的定义无需使用self参数，可以直接定义到类中。类属性可以直接通过类名调用。
class Person:
type = "哺乳类" def __init__(self,name,age):
self.name = name
self.age = age p = Person("luyis",13)
#通过类名调用类属性
print(Person.type)
#通过对象调用类属性
print(p.type)
静态方法
静态方法是类中的函数，不需要实例。静态方法主要是用来存放逻辑性的代码，主要是一些逻辑属于类，但是和类本身没有交互，即在静态方法中，不会涉及到类中的方法和属性的操作。用 @staticmethod 装饰的不带 self 参数的方法，类的静态方法可以没有参数，可以直接使用类名调用。
import time
class TimeTest:
def __init__(self):
pass #静态方法
@staticmethod
def show_time():
print(time.strftime("%H:%M:%S", time.localtime())) TimeTest.show_time()
类方法
类方法是将类本身作为对象进行操作的方法。默认有个 cls 参数，可以被类和对象调用，需要加上 @classmethod 装饰器。
class ClassTest:
num = 0
def __init__(self,num):
ClassTest.num = num #类方法
@classmethod
def showNum(cls):
print(cls.num) c = ClassTest(20)
#通过类直接调用
ClassTest.showNum()
#通过实例对象调用
c.showNum()
私有成员
Python中的私有成员，不能在类外面直接访问。私有成员只需要在成员前面加上两条下划线(__)就表明该成员是私有的了。
class Person:
#__type是私有成员
__type = "哺乳类" def __init__(self,name="",age=0,country="中国"):
#__name,__age是私有成员
self.__name = name
self.__age = age
self.__setcountry(country) def get_name(self):
return self.__name def get_age(self):
return self.__age def set_name(self,name):
self.__name = name def set_age(self,age):
self.__age = age #__setcountry是私有函数
def __setcountry(self,cty):
self.country = cty @classmethod
def get_type(cls):
return cls.__type @classmethod
def set_type(cls,type):
cls.__type = type p = Person("jame",21)
print(p.get_name())
print(p.get_age())
print("--------------------") p.set_name("charlse")
p.set_age(31)
print(p.get_name())
print(p.get_age())
print("-------------------") print(Person.get_type())
print("------------------") Person.set_type("灵长类")
print(Person.get_type())
输出：
jame
21
--------------------
charlse
31
-------------------
哺乳类
------------------
灵长类
定义私有成员的格式：
__xxx:私有成员，只有类对象自己能访问，子类对象不能直接访问到这个成员，
注意：虽然不能在类外直接访问到类的私有成员，但在对象外部可以通过“ 对象名._类名__xxx ”这样的特殊方式来访问类的私有成员。应此，在Python中不存在严格意义上的私有成员。
class Person:
#__type是私有成员
__type = "哺乳类" def __init__(self,name="",age=0):
#__name,__age是私有成员
self.__name = name
self.__age = age p = Person("Emma",32);
#直接访问私有成员的值
print(p._Person__type)
print(p._Person__name)
print(p._Person__age) #直接修改私有成员的值
p._Person__age = 33
p._Person__name = "Angela"
p._Person__type = "灵长类" print("-------------------")
print(p._Person__type)
print(p._Person__name)
print(p._Person__age)
输出：
哺乳类
Emma
32
-------------------
灵长类
Angela
33
2.专有方法
Python除了自定义私有变量和方法外，还可以定义专有方法。专有方法是在特殊情况下或使用特殊语法时由python调用的，而不是像普通方法一样在代码中直接调用。看到形如__XXX__的变量或函数名时就需要注意下，这在python中是有特殊用途的,下面是Python中的部分专用方法：
__init__ : 构造函数，在生成对象时调用
__del__ : 析构函数，释放对象时使用
__str__: 打印，转换，适合于展示给用户看的
__repr__ : 打印，转换，适合开发者调试
__setitem__ : 按照索引赋值
__getitem__: 按照索引获取值
__len__: 获得长度
__call__: 函数调用
__add__: 加运算
__sub__: 减运算
__mul__: 乘运算
__div__: 除运算
__mod__: 求余运算
__pow__: 乘方
__doc__: 说明文档信息
上面笔者已经讲解过__init__和__del__函数的使用了，应此笔者不再这里重复缀述了。笔者接下来讲解其它的专有方法的用法：
__str__,__repr__
都是用于将对象转化为字符串的内置方法。
但是 repr() 函数将对象转化为供解释器读取的形式，__str__只是覆盖了__repr__以得到更友好的用户显示。
例如：
>>> y = 'a string'
>>> repr(y)
"'a string'"
>>> str(y)
'a string'
repr函数的返回字符串可以再次传递给eval函数。但是str函数的返回值传递给eval显然是不合适。
>>> y == eval(repr(y))
True
>>> y == eval(str(y))
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
File "<string>", line 1
a string
^
SyntaxError: unexpected EOF while parsing
repr返回的字符串应该是编译器能够再次解析的，str返回的字符串应该可以是易阅读的
在知道了repr和str的区别后，我们就知道该如何自定义__repr__和__str__函数了。
class person:
def __init__(self,name="",age=0):
self.__name = name
self.__age = age def __str__(self):
return "name:%s,age:%d"%(self.__name,self.__age) def __repr__(self):
return "person(name='%s',age=%d)"%(self.__name,self.__age) p = person("jame",12)
#Output: name:jame,age=12
print(str(p))#same as print(p) #Output: person(name='jame',age=12)
print(repr(p)) p2 = eval(repr(p))
#Output: name:jame,age=12
print(p2)
__setitem__,__getitem__
用于通过下标来设置和获取值，可以直接使用[]符来操作。
class DicDecorate:
def __init__(self,dic):
self.__dic = dic
def __getitem__(self,key):
return self.__dic[key]
def __setitem__(self,key,val):
self.__dic[key] = val
dicdec = DicDecorate({})
dicdec[0] = "hello"
dicdec[1] = "word"
print(dicdec[0])
print(dicdec[1])__len__()：
当调用len函数时会调用该方法。
lass DicDecorate:
def __init__(self,dic):
self.__dic = dic def __len__(self):
return len(self.__dic); dicdec = DicDecorate({})
print(len(dicdec))
__call__()
关于 __call__ 方法，不得不先提到一个概念，就是可调用对象（callable），我们平时自定义的函数、内置函数和类都属于可调用对象，但凡是可以把一对括号()应用到某个对象身上都可称之为可调用对象，判断对象是否为可调用对象可以用函数 callable。
如果在类中实现了 __call__ 方法，那么实例对象也将成为一个可调用对象。
class Entity:
def __init__(self, x, y):
self.x, self.y = x, y def __call__(self, x, y):
self.x, self.y = x, y def __str__(self):
return "x=%s,y=%s"%(self.x,self.y) e = Entity(2, 3) # 创建实例
if(callable(e)):
e(4, 5) #实例可以象函数那样执行，并传入x y值，修改对象的x y
#Output:x=4,y=5
print(e)
__add__: 加运算 __sub__: 减运算 __mul__: 乘运算 __div__: 除运算 __mod__: 求余运算 __pow__: 幂运算
class Vector:
def __init__(self, a, b):
self.a = a
self.b = b def __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)
3. 继承
3.1 单重继承
Python继承的语法格式：
class ClassName1(ClassName2):
statement
其中
ClassName1：派生类
ClassName2：基类
class Shape:
def __init__(self,type,area):
self.type = type
self.area = area
def describe(self):
return "Share type:%s,area=%f"%(self.type,self.area)
class Square(Shape):
def __init__(self,area):
super().__init__("square",area);
square = Square(12.1)
print(square.describe())
和其它编程语言一样，可以重写父类中的方法，可以继承父类中开放的属性和方法（不能继承父类中的私有属性和方法）。
3.2 多重继承
除了单重继承，Python还支持多重继承
class ClassName1(ClassName2,ClassName3,ClassName4...):
statement
Python多重继承中顺序继承是一个非常重要的概念，如果继承的多个父类中有相同的方法名，但在派生类中使用时未指定父类名，则Python解释器将从左至右搜索，即调用先继承的类中的同名方法。
class A:
def test(self):
print("I am in Class A");
class B:
def test(self):
print("I am in Class B"); class C(A,B):
def __call__(self):
#调用A类中的test方法
self.test()
#可以通过类名显示指定调用B类中的test方法
B.test(self) class D(B,A):
def __call__(self):
#调用B类的test方法
self.test()
#通过类名显示指定要调用A类中的test方法
A.test(self) c = C()
c()
print("---------------");
d = D()
d()
输出：
I am in Class A
I am in Class B
-----------------
I am in Class B
I am in Class A
通过上面的结果可以看出，子类在父类中查找方法的顺序是从左到右的。
3.3 砖石继承
砖石继承问题是Python多重继承中的典型问题，下面先通过一张图片看看什么是砖石继承。
通过这张图片看出，D继承了B和C，B和C又派生于A，在调用D类的test()方法时，会再去调用B和C的test()方法，B和C又会去调用A的test()方法，所以A类的test()方法在理论应该会被调用两次，例如：
class A:
def test(self):
print("I am in Class A");
class B(A):
def test(self):
A.test(self);
print("I am in Class B")
class C(A):
def test(self):
A.test(self);
print("I am in Class C"); class D(B,C):
def test(self):
B.test(self)
C.test(self)
print("I am in Class D") d = D()
d.test()
输出：
I am in Class A
I am in Class B
I am in Class A
I am in Class C
I am in Class D
从上面的输出结果可以看出，A类的test()被调用了两次。在有些情况这种逻辑将会造成极大的Bug，比如一笔银行转账记录转了两次。要避免这种情况，可以使用super()方法，当使用super()调用父类的test方法时，会转而去调用下一个重写了该super类的test方法，若没有的话才会去调用父类的test方法。
案例：
class A:
def test(self):
print("I am in Class A")
class B(A):
def test(self):
super().test() #不能替换为A.test(self)
print("I am in Class B")
class C(A):
def test(self):
super().test()
print("I am in Class C") class D(B,C):
def test(self):
super().test() #可以替换为B.test(self)
print("I am in Class D") d = D()
d.test()
输出：
I am in Class A
I am in Class C
I am in Class B
I am in Class D
通过上面的结果我们可以看出，super.test()和父类.test(self)是不一样的，在B类中使用super()调用父类的test()时，会去寻找B实例后的下一个类是否重写A类的test()方法，由于类D继承了类B和类C，所以类C在类B后，而且类C又重写了test()方法，应此会直接调用类C的test()方法。在类C的test()方法中，又使用了super().test()调用父类的test()，所以又会去寻找C实例后的下一个类有重写A类的test方法，因为类D只继承了B和C,并且类C是最后一个，所以C后没有实例直接重写A类的test()方法，因此直接去调用A类的test()方法。最终完整的方法压栈顺序是D->B->C->A。
下面的逻辑和上面案例中使用super()的逻辑是等同的：
class A:
def test(self):
print("I am in Class A")
class B(A):
def test(self):
C.test(self)#调用C
class C(A):
def test(self):
A.test(self)#调用A
class D(B,C):
def test(self):
B.test(self)#调用B
上面的逻辑变成了如图所示：