一.類

類名用大寫字母開頭

屬性是類中的變量，方法是類中的函數

類、class關鍵字：

>>> class Turtle:
...     color = 'green'
...     weight = 10
...     legs = 4
...     shell = True
...     mount = '大嘴'
...     def climb(self):
...             print("我正在努力的向前爬")
...     def run(self):
...             print("我正在飛快的向前怕")
...     def bite(self):
...             print("咬死你咬死你")
...     def eat(self):
...             print("有的吃真滿足")
...     def sleep(self):
...             print("困了困了")
...
>>> t1 = Turtle()
>>> t1.color
'green'
>>> t1.weight
10
>>> t1.legs
4
>>> t1.shell
True
>>> t1.mount
'大嘴'
>>> t1.climb()
我正在努力的向前爬
>>> t1.run()
我正在飛快的向前怕
>>> t1.bite()
咬死你咬死你
>>> t1.eat()
有的吃真滿足
>>> t1.sleep()
困了困了

二.封裝

在創建對象之前，通過類將相關的屬性和方法給打包到一起。然后再通過類來生成相應的對象

>>> class C:
...     def hello():
...             print('hello')
...
>>> c = C()
>>> c.hello()
Traceback (most recent call last):File "<stdin>", line 1, in <module>
TypeError: C.hello() takes 0 positional arguments but 1 was given

>>> class C:
...     def getSelf(self):
...             print(self)
...
>>> c = C()
>>> c.getSelf()
<__main__.C object at 0x000001536290D2E0>
>>> c
<__main__.C object at 0x000001536290D2E0>

傳遞到方法中self參數的實參就是實例對象本身

一個類可以生成無數個對象，當調用類中的方法時，python為了明確是哪一個實例對象在調用該方法，于是使用self參數將調用該方法的實例對象的信息進行了傳遞。

三.繼承

當子類繼承父類時，子類擁有和父類相同的方法和相同的屬性

>>> class A:
...     x = 1
...     def hell(self):
...             print('你好')
...
>>> class B(A):
...     def bb(self):
...             print('我是B的對像')
...
>>> b = B()
>>> b.x
1
>>> b.bb()
我是B的對像
>>> b.hell()
你好
>>> class B(A):
...     x = 123
...     def hello(self):
...             print('我是B的對象')
...
>>> b = B()
>>> b.x
123
>>> b.hello()
我是B的對象

isinstance()：判斷某個對象是否屬于某個方法

>>> isinstance(b,B)
True
>>> isinstance(b,A)
True

issubclass()：檢測一個類是否為某個類的子類

>>> issubclass(B,A)
True

多重繼承

>>> class A:
...     x = 1
...     def hello(self):
...             print('你好')
...
>>>
>>> class B():
...     x = 123
...     def hello(self):
...             print('這里是B')
...
>>> class C(A,B):
...     pass
...
>>> c = C()
>>> c.x
1
>>> c.hello()
你好

多重繼承時，多個父類擁有同樣的屬性和方法，子類對象調用時優先級從左至右。

組合：

組合（將需要的類一起進行實例化并放入新的類中），非繼承關系的幾個類放到一起

>>> class A:
...     def hello(self):
...             print('這里是A')
...
>>> class B:
...     def hello(self):
...             print('這里是B')
...
>>> class C:
...     def hello(self):
...             print('這里是C')
...
>>> class ABC:
...     a = A()
...     b = B()
...     c = C()
...     def hello(self):
...             self.a.hello()
...             self.b.hello()
...             self.c.hello()
...
>>> abc = ABC()
>>> abc.hello()
這里是A
這里是B
這里是C

綁定

實例對象跟類的方法進行綁定

實例能擁有自己的屬性，如果要通過類的方法對屬性進行操作，則需要使用self進行綁定

>>> class A:
...     x = 120
...     def set_x(self,i):
...             self.x = i
...
>>> a = A()
>>> a.set_x(520)
>>> a.x
520

若沒有這個self，那么直接對x進行操作，只是在set_x()函數內部創建了一個局部變量x

四.構造函數

構造函數__init__()

在類中定義__intit__()方法，就可以在實例化對象的時候實現一些變量的初始化

如果創建類的時候，沒有添加構造函數，python解釋器會自動創建一個不執行任何操作的默認構造函數；也就是說，只要創建類，一定會伴隨著一個構造函數誕生。只不過可以自定義一個構造函數，也可以由python解釋器自動創建一個默認的構造函數。

>>> class go:
...     def __init__(self, x, y):
...             self.x = x
...             self.y = y
...     def add(self):
...             return self.x + self.y
...     def mul(self):
...             return self.x * self.y
...
>>> a = go(3,4)
>>> a.__dict__
{'x': 3, 'y': 4}
>>> a.add()
7
>>> a.mul()
12

五.重寫

子類可以重新定義父類已有的屬性和方法來對父類中同名的屬性和方法進行覆蓋。

可以在子類中直接調用父類的方法，即調用未綁定的父類方法。但會造成鉆石繼承的問題。

>>> class gozi(go):
...     def __init__(self, x, y, z):
...             go.__init__(self, x, y)
...             self.z = z
...     def add(self):
...             return go.add(self) + self.z
...     def mul(self):
...             return self.x * self.y * self.z
...
>>> b = gozi(2, 3, 4)
>>> b.__dict__
{'x': 2, 'y': 3, 'z': 4}
>>> b.add()
9
>>> b.mul()
24

鉆石繼承問題：

>>> class A:
...     def __init__(self):
...             print('這里是A')
...
>>> class B1(A):
...     def __init__(self):
...             A.__init__(self)
...             print('這里是B1')
...
>>> class B2(A):
...     def __init__(self):
...             A.__init__(self)
...             print('這里是B2')
...
>>> class C(B1, B2):
...     def __init__(self):
...             B1.__init__(self)
...             B2.__init__(self)
...             print('這里是C')
...
>>> c = C()
這里是A
這里是B1
這里是A
這里是B2
這里是C

A被調用了兩次，因為C調用B1、B2，B1、B2又分別調用了A。

為了解決磚石繼承的問題可以使用super()函數。

>>> class A:
...     def __init__(self):
...             print('這里是A')
...
>>> class B1(A):
...     def __init__(self):
...             super().__init__()
...             print('這里是B1')
...
>>> class B2(A):
...     def __init__(self):
...             super().__init__()
...             print('這里是B2')
...
>>> class C(B1, B2):
...     def __init__(self):
...             super().__init__()
...             print('這里是C')
...
>>> c = C()
這里是A
這里是B2
這里是B1
這里是C

六.多態

同一個運算符、函數或對象在不同的場景下具有不同的作用效果

運算符的多態

>>> 3 + 5
8
>>> 'L' + 'ove'
'Love'

函數的多態

>>> len('love')
4
>>> len(['love','jiji','xixi'])
3