溫馨提示×
您好，登錄后才能下訂單哦！
點擊 登錄注冊 即表示同意《億速云用戶服務條款》
您好，登錄后才能下訂單哦！
本文實例講述了Python面向對象之類和對象。分享給大家供大家參考，具體如下：
類和對象（1）
對象是什么？
對象=屬性（靜態）+方法（動態）；
屬性一般是一個個變量；方法是一個個函數；
#類的屬性 就是 類變量
#實例變量：定義在方法中的變量，只作用于當前實例的類。
例子：
class Turtle:#python 中類名約定以大寫字母開頭
'''關于類的簡單例子。。。'''
#屬性 == 類變量
color ="green"
weight="10kg"
legs=4
shell=True
mouth='big'
#方法
def climb(self):
self.name = "test" #實例變量：定義在方法中的變量，只作用于當前實例的類。
print("我在很努力爬。")
def run(self):
print('我在很努力跑。')
def bite(self):
print('我要要要要要')
def sleep(self):
print('我要睡覺啦。')
#創建一個實例對象也就是類的實例化！
tt =Turtle() #類的實例化，也就是創建一個對象，類名約定大寫字母開頭
tt.bite() #創建好類后就能調用類里面的方法叻；
tt.sleep()
面向對象的特征：
oo = Object Oriented（面向對象）
1.封裝（信息隱蔽技術）
python的列表list其實就是一個對象，它提供了很多方法：sort()、append()
封裝后就可以直接調用里面的方法了！！！
2.繼承
子類自動共享父類之間數據和方法的機制。
class MyList（list）:#創建一個類繼承list的所有方法和屬性 pass #相當于一個占位符 list1=MyList() #類實例化 list1.append(1) #繼承后調用list的方法append()
3.多態
不同對象對同一方法響應不同行動。就是名字一樣方法不一樣：
>>> class A:
def fun(self):
print('aaaa')
>>>class B ():
def fun(self):
print('bbb')
>>> a=A()
>>>b=B()
>>>a.fun()
aaaa
>>>b.fun()
bbb
類和對象（2）
self是什么？
如果把類當做圖紙，那么由類實例化后的對象就是可以住人的房子。self就相當于房子的門牌號，由self就可以找到對象。
一個類可以生成無數個對象，對象之間都很相似，因為都是來源與類的方法屬性。當對象方法被調用時，對象就會將自己作為第一個參數傳給self，python就是根據self知道哪一個對象在調用方法；
>>>class Ball():
def setname(self,name):
self.name=name
def kick (self):
print("我叫%r,誰踢我"%self.name)
>>>a=Ball() 實例化生成a對象
>>>a.setname('a') 調用方法設名為a
>>>b=Ball()
>>>b.setname('b')
>>>c=Ball()
>>>c.setname()
>>>a.kick () 通過self知道是哪個對象調用kick方法
我叫'a',誰踢我
>>>b.kick()
我叫'b',誰踢我
python的魔法方法：
__init__(self) 這個是構造方法。
實例化一個對象時，這個方法就會在對象創建時（實例化類就是創建對象）自動調用。實例化時就會調用__init__(self)這個方法。
實例化對象是可以傳入參數的，這些參數被傳入init方法中，可通過重寫方法來自定義對象初始化操作。
>>>class Ball:
def __init__(self,name):
self.name = name
def kick(self):
print('我叫%r,誰踢我'%self.name)
>>> b=Ball('b') #創建對象，這時__init__(self):就被調用了，可以傳入b
>>>b.kick()
我叫'b',誰踢我
公有和私有：
公有和私有數據類型。python中對象的屬性和方法都是公開的都是公有的通過.操作符訪問。
python中定義私有變量只需在變量名或函數名前增加兩個下劃線‘__'，那么這個函數、變量變為私的了。
>>> class P():
__name="liyue" #私有變量，外部不能通過.操作符直接訪問了
類和對象（3）：繼承
語法：
class A(B): ………….
B我們叫父類、基類或超類；
A我們叫子類，子類繼承父類的屬性和方法；
例子：
>>> class Parent():
defhello(self):
print("helloliyue!")
>>> class Child(Parent):
pass
>>> p=Parent()
>>> p.hello()
hello liyue!
>>> c=Child()
>>> c.hello()
hello liyue!
注意：如果子類中定義與父類同名的方法或屬性，則會自動覆蓋父類對應的方法或屬性。
例子：
>>> class Parent():
defhello(self):
print("helloliyue!")
>>> class Child(Parent):
defhello(self):
print("hahah!")
>>> p=Parent()
>>>p.hello ()
hello liyue!
>>> c =Child()
>>>c.hello () #子類和父類方法相同，（子類重寫父類方法）會覆蓋父類方法，但是父類自己的方法不變
hahah!
super()函數：解決了子類就算重寫父類方法或屬性仍然可以繼續使用父類的方法和屬性。
具體實例及說明：
import random as r
#利用繼承演示魚游動方向位置。
class Fish(): #父類
def __init__(self):
self.x =r.randint(0,10)
self.y =r.randint(0,10)
def move(self):
self.x -=1 #一直向西移動
print("我的位置是：",self.x,self.y)
classGoldfish(Fish): #子類
pass
classCarp(Fish): #子類
pass
classSalmon(Fish): #子類
pass
classShark(Fish):
def __init__(self): #這里重寫了__init__方法，就會覆蓋掉父類的方法了，用到super函數后就可以繼續使用父類的方法。
#super函數不用給定任何基類的名字(如下)，它會一層層找出代碼所有父類里面對應的方法，要改變該類的繼承關系時只需修改這個類的父類就行就是括號里面的Fish。
super().__init__() #super().重寫的屬性或方法
self.hungry = True
def eat(self):
if self.hungry:
print("我要吃了。。。")
self.hungry = False
else:
print('好飽了。。。')
>>> f=Fish()
>>>f.move()
我的位置是： -1 3
>>>f.move()
我的位置是： -2 3
>>>g=Goldfish()
>>>g.move()
我的位置是： 4 4
>>>s=Salmon()
>>>s.move()
我的位置是： 8 1
>>>s.move()
我的位置是： 7 1
>>> s=Shark()
>>>s.eat()
我要吃了。。。
>>>s.eat()
好飽了。。。
>>>s.move()
我的位置是： 5 10 #這就是子類就可以使用父類的move()方法
>>>s.move()
我的位置是： 4 10
類和對象（4）
1.組合：一般把幾個沒有什么關系的類放在一起使用時通過組合類的方法。
例子：要求定義一個類，叫水池，水池里面有烏龜和魚。
class Turtle(): #定義烏龜類
def __init__(self,x):
self.num = x
classFish(): #定義魚類
def __init__(self,y):
self.num = y
classPool(): #定義水池類
def __init__(self,x,y):
self.turtle = Turtle(x) #直接把需要的類在這里實例化就行了，組合實現
self.fish = Fish(y)
def print_num(self):
print("水池中總共有烏龜%d只，小魚%r條。"%(self.turtle.num,self.fish.num)
>>> p =Pool(1,10)
>>>p.print_num ()
水池中總共有烏龜1只，小魚10條
這就是組合，組合就是把類的實例化放到一個新類里面，他就把舊類組合進去了。
組合一般就是說把幾個不是有繼承關系的、沒有直線關系的幾個類放在一起，如果要實現縱向關系的幾個類，就是繼承。
2.類、類對象、實例對象
>>>class C(): #類，當類寫完后就變成了類對象
def x(self):
print("xaaa")
>>> c =C() #c是實例對象，C()是類對象
>>> c.x()
xaaa
>>> c.x= 1 #實例對象初始化一個變量
>>> c.x
1
>>> c.x() #就不能繼續調用原來的方法了，同名會覆蓋掉類的方法
Traceback (most recent call last):
File"<pyshell#18>", line 1, in <module>
c.x()
TypeError: 'int' object is not callable
所以：不要試圖在一個類里面定義所有的屬性和方法，應該利用繼承和組合機制；
用不同的詞性命名，如屬性名用名詞，方法名用動詞。
3.什么是綁定？
python嚴格要求方法需要有實例才能被調用，這種限制其實就是綁定。
>>>class CC: #類
def setxy(self,x,y):
self.x = x
self.y = y
def printxy(self):
print(self.x,self.y)
>>> dd= CC() #實例對象，類對象
>>>dd.__dict__ #查看實例對象所擁有的屬性
{}
>>>CC.__dict__ #查看類對象所擁有的屬性
mappingproxy({'setxy':<function CC.setxy at 0x00000000031F9B70>, 'printxy': <functionCC.printxy at 0x00000000031F9BF8>, '__module__': '__main__', '__weakref__':<attribute '__weakref__' of 'CC' objects>, '__dict__': <attribute '__dict__'of 'CC' objects>, '__doc__': None})
>>>dd.setxy (4,5) #實例對象中傳入x，y
>>>dd.__dict__ #實例對象就有屬性了，這兩個屬性緊屬于實例對象的，類對象中是沒有的
{'y': 5, 'x': 4} #類對象中是沒有實例對象傳入的，這歸功與綁定這個功能，self
為什么實例對象調用方法后類對象中沒有實例對象的屬性？
實例對象調用方法時，dd.setxy(dd,4,5) 實際上是這樣的，也就是（self.x = x；self.y = y）dd.x=4,dd.y=5,那么4,5存放在實例對象的空間，故這兩個屬性只屬于實例對象的。(實例對象調用類方法時，先把自己傳給self，self.x也就是dd.x.)
類對象與實例對象差別：
把類對象CC刪除后，del CC，再實例化就會報錯，但是已經實例化對象dd仍然可以調用類對象中的方法：
>>> delCC
>>>dd.setxy (3,4)
>>>dd.__dict__
{'y': 4, 'x': 3}
>>> dd =CC()
Traceback (most recent call last):
File"<pyshell#45>", line 1, in <module>
dd =CC()
NameError: name 'CC' is not defined
>>>dd.printxy ()
3 4
為什么已經實例化對象dd仍然可以調用類對象中的方法？
類中定義的屬性是靜態變量，方法也一樣，就算類對象被刪除了，屬性和方法一樣存放在內存中，故實例對象仍然可以從內存中調用類的方法和屬性，除非程序退出。所以創建一個類后最好先實例化再使用類對象中的方法，不要直接利用類對象調用方法。
self.x self相當于實例對象的名字，.x就是實例的空間了
更多關于Python相關內容感興趣的讀者可查看本站專題：《Python面向對象程序設計入門與進階教程》、《Python數據結構與算法教程》、《Python函數使用技巧總結》、《Python字符串操作技巧匯總》、《Python編碼操作技巧總結》及《Python入門與進階經典教程》
希望本文所述對大家Python程序設計有所幫助。
免責聲明：本站發布的內容（圖片、視頻和文字）以原創、轉載和分享為主，文章觀點不代表本網站立場，如果涉及侵權請聯系站長郵箱：is@yisu.com進行舉報，并提供相關證據，一經查實，將立刻刪除涉嫌侵權內容。
