面向對象編程——類(class)1
一、函數式編程 與 面向對象編程
def 函數名(參數)：
pass
class 類名：
def 函數名(self,參數)： # self必填
pass
z1 = 類名() # 這時，調用對象 z1，self參數即為 z1
例1：
class bar: def foo(self,arg): print(self,arg) z1 = bar() print(z1) # <__main__.bar object at 0x0000019BC3088D30> z1.foo(‘wjz‘) # <__main__.bar object at 0x0000019BC3088D30> wjz z2 = bar() print(z2) # <__main__.bar object at 0x0000019BC306B358> z2.foo(‘wjk‘) # <__main__.bar object at 0x0000019BC306B358> wjk
從上面的例子可以看出，self 就是當前調用的對象(即使後面繼承時)；
例2：
class bar:
def foo(self,arg):
print(self.job,arg)
z1 = bar()
z1.job = ‘IT‘
z1.foo(‘wjz‘) # IT wjz
z2 = bar()
z2.job = ‘IT‘
z2.foo(‘wjk‘) # IT wjk
從上面可以看出，當向對象存儲變量時，它會把該變量傳給類裏面的方法；
二、面向對象三大特性：封裝、繼承、多態
1. 封裝
構造方法：
當 obj = 類名() 時，實際上是做了兩件事：
在內存中開辟空間，創建對象；
通過對象，自動執行了一個方法：__init__方法(別名：構造方法)。
把公用的變量封裝到init方法中。 例如：
class DataBaseHelper: def __init__(self,ip,port,username,password): self.ip = ip self.port = port self.username = username self.password = password def insert(self): pass def delete(self): pass def update(self): pass def select(self): pass
適用場景：如果多個函數都用一些共同參數，則適合面向對象來做。例如上面數據庫操作；
2. 繼承
舉例：
class f:
def f1(self):
print("in the f.f1")
class s(f): #這裏加一個括號，指明該類的父類(基類)；子類(派生類)會繼承父類的方法；s類中找不到發方法，會去f類中找。
def s1(self):
print("in the s.s1")
def f1(self):
super(s,self).f1() # 這裏super(s,self) 表示是s的父類；
f.f1(self) # 這個等效上面這句 super(s,self).f1();註意，一定不能忘記self
print("in the s.f1")
z = s()
z.f1()
多繼承： 如果子類繼承多個父類，則排在前面的父類優先；如：
class father1:
def a1(self):
print("in the f1.a1")
class father2:
def a1(self):
print("in the f2.a1")
class son(father1,father2): # father1在前面，優先繼承；
def s1(self):
print("in the son.s1")
z = son()
z.a1() # 等效 son.a1(z) 打印 in the f1.ar 此時，father1和father2都有a1方法，並且son的父類有兩個，則按順序優先。
上面例子中，假如father1中沒有a1方法，而father2有。但是father1的父類有a1，則繼續在father1的父類中查找。都沒有時，才會去father2。但是，如果father0是father1和father2共同的父類，則會最後繼承共同的父類。如圖：
3. 多態
python中，原生多態。這個不重要，先忽略吧。
三、 類
類成員
類(class)的成員有字段、方法；其實還有一個屬性
- 字段分為靜態字段、普通字段；
- 方法分為構造方法、靜態方法、普通方法、類方法；
1. 字段
在類中定義的變量，稱為靜態字段，屬於類，保存在類中，可以通過類或者對象訪問；
在類中的方法中定義的字段，稱為普通字段，屬於對象，保存在對象中，只能通過對象訪問；
如下：
-
class make: port = 22 # 靜態字段 def __init__(self,ip,username,passwd): self.ip = ip # 普通字段 self.username = username self.passwd = passwd z1 = make(‘1.1.1.1‘,‘root‘,‘123456‘) print(z1.ip,z1.username,z1.passwd,z1.port) # 打印 1.1.1.1 root 123456 22 z2 = make(‘2.2.2.2‘,‘admin‘,‘admin‘) print(z2.ip,z2.username,z2.passwd,z2.port) # 打印 2.2.2.2 admin admin 22 print(make.port) # 打印 22 可見，靜態字段屬於類，同時也可以通過類對應的對象取得(因為對象通過類對象指針指向該類)。
2. 方法
構造方法：在上面面向對象三大特性之封裝章節已經提到，即init方法；self是必須的；
普通方法：和構造方法一樣，只是名字不是 init的方法就是普通方法；由對象調用，也可以通過類進行調用(必須指定self對象)，self是必須的；
靜態方法：在普通方法前面加上裝飾器 staticmethod，即是靜態方法；但是有個區別：self不是必須的；普通方法調用時，self就是當前調用對象；而靜態方法中，如果指定了self，則必須指定self才可以；由類或對象(對象調用其實是根據類對象指針，通過類進行調用)調用；
類方法：在普通方法前面加上裝飾器 classmethod，即是類方法；類方法中，一般不使用self，而是寫成 cls，cls為當前類；由類直接調用；類方法和靜態方法沒有太大區別；
例如：
-
class make: def __init__(self): # 構造方法 pass def upload(self): # 普通方法 pass @staticmethod def status(self): # 靜態方法，self不是必須的，可以不要self； pass @classmethod def classmd(cls): # 類方法，這裏一般寫cls print(cls) pass make.classmd() # 打印結果和 print(make)一樣。
3.屬性
說類的成員有兩種。其實還有一種，定義像方法，調用像字段；我們叫它 屬性
這種屬性還可以修改、刪除；其實並不是真的刪除，只是偽造字段的操作(修改、刪除)
-
class make: @property def its(self): # 定義屬性，如果定義了property之後，後面還有getter，則優先執行getter；如果沒有定義getter，則調用時執行property print("property") return 1 @its.getter def its(self): # 優先級高於property； print("getter") @its.setter def its(self,value): # 定義屬性its可以修改 print(value,"setter") @its.deleter def its(self): # 定義屬性its可以刪除 print("delete") obj = make() r = obj.its # obj.its像是調用字段，但是its定義時像方法； print(r) # 返回 1 obj.its = 123456 # 看似是更改，其實是找到 its.setter,然後執行。123456當做參數傳給 its.setter del obj.its # 看似是刪除，其實是找到its.deleter，然後執行
在上面的基礎上補充：
class make:
@property
def f1(self):
print("in the f1")
return 123
@f1.getter
def f1get(self):
print("in the f1getter")
return 00
@f1.setter
def f1set(self,value):
print("in the f1setter",value)
return 11
@f1.deleter
def f1del(self):
print("in the f1deleter")
return 22
@f1get.fget # 這裏可以執行 @property修飾的方法f1；
def f2(self):
print("in the f2")
return 456
@f1set.fset
def f3(self):
print("in the f3")
return 789
@f1del.fdel
def f4(self):
print("in the f4")
return 000
我們不調用類，只是定義這個類，這時：
@f1get.fget 會自動執行 f1get方法；
@f1set.fset 會自動執行 f1set方法；
@f1del.fdel 會自動執行 f1del方法；
三個是相同的原理，註意：fget可以執行 property、getter的對象；fset只可以執行setter的對象；fdel只可以執行deleter的對象。
這裏就拿fget舉例：
另外：
def f1(self):
return 123
per = property(fget=f1)
------ 上下兩部分等效 ------
@property
def per(self):
return 123
同理，
class make:
def f1(self):
print("in f1")
return 123
def f2(self,val):
print("in f2",val)
return 456
per = property(fget=f1,fset=f2) # 這裏就是關鍵字參數，fget/fset可以省略，就是位置參數；即，fget、fset、fdel順序。property(fget,fset,fdel,doc="描述")
z = make()
z.f1 = 123
------ 上下兩部分等效 ------
class make:
@property
def f1(self):
print("in f1")
return 123
@f1.setter
def f1(self,val):
print("in f2",val)
return 456
z = make()
z.f1 = 123面向對象編程——類(class)1