類的定義
|
1
2
3
4
5
6
7
8
|
# class是定義類的關鍵字，ClassName為類的名稱class ClassName: # 在這里寫其他內容 passclass ClassName(object): # 在這里寫其他內容 pass |
這是一個最簡單的類定義,在python3后類定義一般都會繼承object類，不過不繼承也沒有多大的問題。
類對象
類對象也稱實例
|
1
2
|
# 這就是創建了一個類對象（實例），a是一個實例也是一個對象a = ClassName() |
變量
類內部里面有：類變量，局部變量，實例變量
類變量
類變量：所有類的實例化對象都同時共享類變量，也就是說，類變量在所有實例化對象中是作為公用資源存在的。
|
1
2
3
|
class ClassName(object): # 定義一個類變量 name = "Tom" |
類方法的調用方式有 2 種，既可以使用類名直接調用，也可以使用類的實例化（對象）調用。可以通過類名修改類變量的值，并且修改后，會影響所有的實例化的對象。
|
1
2
3
4
5
6
7
8
9
10
11
|
# 直接通過類名調用print(ClassName.name)# 創建類的實例（對象）a = ClassName()b = ClassName()// 通過類的實例調用print(a.name)print(b.name)ClassName.name = "Tim"print(a.name)print(b.name) |
運行結果為：
Tom
Tom
Tom
Tim
Tim
但如果實例的類變量的值修改后，在通過類名修改變量的值，不會影響這個實例的類變量。
|
1
2
3
4
5
6
7
8
9
|
a = ClassName()b = ClassName()a.name = "asf"ClassName.name = "Pig"print(a.name)print(b.name)ClassName.name = "aaa"print(a.name)print(b.name) |
運行結果：
asf
Pig
asf
aaa
通過運行結果可知，在對象a改變name值后，再調用Class Name.name = "Pig"對象a的name變量值沒有改變
局部變量
局部變量：局部變量只定義在類方法內，也只能在方法內使用
|
1
2
3
4
5
|
class ClassName(object): # 這是一個方法 def function(self): # 這是一個局部變量 name = "Tom" |
name定義在類方法內，所以是局部變量，在外部是無法調用，只能在方法內使用。
實例變量
實例變量：以self.變量名的方式定義的變量，稱為實例變量（屬性）
|
1
2
3
4
5
6
|
class ClassName(object): # 這是一個實例變量 def function1(self): self.name = "Tom" def function2(self): print(self.name) |
只作用于調用方法的對象，可以在其他方法內調用。
|
1
2
|
className = ClassName()className.function() |
運行結果：
Tom
如果定義在__init__()方法中的實例變量，可以同過只能通過對象名訪問。
|
1
2
3
4
5
6
|
class ClassName(object): def __init__(): self.name = "Tom"className = ClassName()print(className.name) |
運行結果：
Tom
私有變量
__name這就是私有變量，在變量前面加兩個_，self.__name也是私用變量，私有變量在類外部無法直接進行訪問。
|
1
2
3
4
5
|
class ClassName(object): # 定義了一個私有類變量 __name = "Tom" ClassName.__name |
運行結果：
---------------------------------------------------------------------------
AttributeError Traceback (most recent call last)
<ipython-input-8-08830fea0534> in <module>
2 __name = "Tom"
3
----> 4 ClassName.__nameAttributeError: type object 'ClassName' has no attribute '__name'
類的方法
在類里面用def關鍵字來定義方法，也叫函數。與普通方法的區別是，必須需要一個self的參數,self代表類自身
|
1
2
3
|
class ClassName(object): def function(self,a): pass |
def為定義函數的關鍵字，function為函數的名稱,
特殊方法
1.__init__()用來初始化類的參數一般叫構造方法
這個方法，我們一般類都會用到。
|
1
2
3
|
class ClassName(object): def __init__(self): self.name = "aaa" |
當類實例化時，會自動調用__init__
2.__call__()將對象當做函數時調用。
|
1
2
3
4
5
6
7
8
|
class ClassName(object): def __init__(self): self.name = "aaa" def __call__(self): print("aaa")c = ClassName() // 類實例化，執行了__init__()方法c() //執行了__call__()方法 |
3、__get__()類作為另一個類的屬性時自動調用
|
1
2
3
4
5
6
7
8
|
class ClassName: def __init__(self): pass def __get__(self,instance, owner): print("__get__調用了")class ClassName2: a = ClassName() |
運行結果：
__get__調用了
4、__new__() 是一種負責創建類實例的靜態方法，且該方法會優先 __init__() 初始化方法被調用。
。。。還有很多其他的類特殊方法
繼承
繼承在生活中是獲得父輩的財產，在編程語言中是獲得父類的所有變量，方法。通過繼承從類上衍生出新的類
單繼承
簡而言之，是繼承一個類，所繼承的類為基類（父類），繼承者為子類
|
1
2
3
4
5
6
7
|
# 父類class A: pass# 子類，繼承了A類class B(A)： pass |
上面是個簡單的繼承，子類在類名后面的括號內寫要繼承的類的名稱。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
|
# 父類class A: name = "Tom" def getName(self): print("..")# 子類，繼承了A類class B(A): passb = B()print(b.name)b.getName() |
運行結果：
Tom
..
發現B類沒有寫什么變量和方法，卻調用了A類的變量（屬性）和方法
當然如果不想要父類的某個變量或方法，可以重寫這個變量或方法
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
|
# 父類class A: name = "Tom" def getName(self): print("..")# 子類，繼承了A類class B(A): def getName(self): print("bbb")b = B()print(b.name)b.getName() |
運行結果：
Tom
bbb
多繼承
多繼承從名稱上來看，是繼承了多個類
|
1
2
3
4
5
6
7
8
|
class A: passclass B: passclass C(A, B): pass |
上面這個C類同時繼承了A類，B類
到此這篇關于python 類的基礎詳解與應用的文章就介紹到這了,更多相關python 類內容請搜索服務器之家以前的文章或繼續瀏覽下面的相關文章希望大家以后多多支持服務器之家！
原文鏈接：https://blog.csdn.net/m0_46778548/article/details/120977530
