Python 【類與對象】

類與對象

把類的個例就叫做實例 (instance)，可理解為“實際的例子”
類是某個特定的群體，實例是群體中某個具體的個體

Python中的對象等於類和實例的集合：即類可以看作是對象，實例也可以看作是對象，
比如列表list是個類對象，[1,2]是個實例對象，它們都是對象
“萬事萬物，皆為對象”

類的創建和調用

類的創建
類名的首字母要大寫

class Chinese:      # 創建一個類
    eye = 'black'

    def eat(self):   #參數self的特殊之處：在定義時不能丟，在調用時要忽略
        print('吃飯，選擇用筷子。')

wu = Chinese()   # 類的實例化
print(wu.eye)   # 實例調用類屬性
wu.eat()  # 調用類中的方法（傳參不用管self）

print(type(wu))

<class '__main__.Chinese'> #驗證了wufeng屬於Chinese這個類
print(wu)
<__main__.Chinese object at 0x7f295682d400> #Chinese類的一個實例對象(object),后面的一串字符表示這個對象的內存地址

#類中創建的屬性和方法可以被其所有的實例調用，
而且，實例的數目在理論上是無限的。
我們可以同時“新建”多個實例

類也被稱為“實例工廠”，因其為所有實例提供了一套藍圖（即預先設定好有什么屬性和方法）

創建類的兩個關鍵點
一 。特殊參數：self

那么如果想在類的內部調用類屬性，而實例又還沒創建之前，我們就需要有個變量先代替實例接收數據，這個變量就是參數self。

 

class Chinese:

    name = '吳'  # 類屬性name

    def say(self):     
        print(self.name + '是中國人')

person = Chinese()   # 創建Chinese的實例person
person.say()         # 調用實例方法

 

當最后一行代碼運行時，實例person會像參數一樣傳給self，替換掉self，self.name等價於person.name
person.name就相當於調用了類屬性name(即'吳')，然后跑完整個方法

相當於以下：

class Chinese:

    name = '吳'  # 類屬性name

    def say(person):     
        print(person.name + '是中國人')

person = Chinese()   # 創建Chinese的實例person
person.say()         # 調用實例方法
吳是中國人

如果想在類的方法內部調用其他方法時，我們也需要用到self來代表實例

 

class Chinese:

    def greeting(self):
        print('很高興遇見你')

    def say(self):
        self.greeting() 
        print('我來自中國')

person = Chinese()  # 創建實例person

person.say()  # 調用say()方法
很高興遇見你
我來自中國

self代表的是類的實例本身，方便數據的流轉
對此，我們需要記住兩點
第一點：只要在類中用def創建方法時，就必須把第一個參數位置留給 self，並在調用方法時忽略它（不用給self傳參）。
第二點：當在類的方法內部想調用類屬性或其他方法時，就要采用self.屬性名或self.方法名的格式。
##############################################################################################
二。特殊方法：初始化方法 （也叫構造函數）
定義初始化方法的格式是def __init__(self)，是由init加左右兩邊的【雙】下划線組成
初始化方法的作用在於：當每個實例對象創建時，該方法內的代碼無須調用就會自動運行。

 

class Chinese:

    def __init__(self): 
        print('很高興遇見你，我是初始化方法')

person = Chinese()
很高興遇見你，我是初始化方法

編寫習慣上，我們會在初始化方法內部完成類屬性的創建，為類屬性設置初始值，
這樣類中的其他方法就能直接、隨時調用

 

class Chinese:
    def __init__ (self):
        self.mouth = 1  # self.不能丟
        self.eye = 2
    
    def body(self):
        print('我有%s張嘴巴' % self.mouth)
        print('我有%s只眼睛' % self.eye)

person = Chinese()
person.body()
我有1張嘴巴
我有2只眼睛

 

 

除了設置固定常量，初始化方法同樣可以接收其他參數

 

class Chinese:

    def __init__(self, name, birth, region):
        self.name = name   # self.name = '吳' 
        self.birth = birth  # self.birth = '廣東'
        self.region = region  # self.region = '深圳'

    def born(self):
        print(self.name + '出生在' + self.birth)

    def live(self):
        print(self.name + '居住在' + self.region)    

person = Chinese('吳','廣東','深圳') # 傳入初始化方法的參數
#初始化方法有多個參數的時候，在實例化的時候就要傳入相應的值
person.born()
person.live()
吳出生在廣東
吳居住在深圳

 

#其實還可以不用初始化方法也能實現
但是此方法比不上初始化方法
初始化優點：
至少不必重復傳參，傳入的數據還可以被多次調用

 

class Chinese:

    def born(self, name, birthplace):
        print(name + '出生在' + birthplace)

    def live(self, name, region):
        print(name + '居住在' + region)   #不建議用此方法

person = Chinese()
person.born('吳','廣東')
person.live('吳','深圳')

一次性調用

class Chinese:
    def __init__(self,hometown,region):
        self.hometown = hometown
        self.region = region
        print('程序持續更新中……')

    def born(self):
        print('我生在%s。'%(self.hometown))

    def live(self):
        print('我在%s。'%(self.region))
    
    # 新建方法，調用上面的兩個方法（注：方法名可自定義）。
    def citys(self):
        self.born()
        self.live()

wu = Chinese('廣東', '深圳')
wu.citys()
# 調用方法后，程序運行方法中的代碼（即依次調用方法`born`和`live`）。
程序持續更新中……
我生在廣東。
我在深圳。

#####################################################################################################

面向對象編程
與面向對象編程相對應的是面向過程編程

面向過程編程：首先分析出解決問題所需要的步驟（即“第一步做什么，第二步做什么，第三步做什么”），
然后用函數實現各個步驟，再依次調用。

面向對象編程，將代碼具體的數據和處理方法都封裝在類中，讓我們不用完全了解過程也可以調用類中的各種方法。
這個優勢讓我們可以在 Python 中輕松地調用各種標准庫、第三方庫和自定義模塊（可以簡單理解成別人寫好的類）

#類編寫一個直觀的好處就是參數的傳遞會比普通函數要省事很多，也不必考慮全局變量和局部變量，因為類中的方法可以直接調用屬性。
#####################################################################################################################
綜合例子

 

class Robot:
    def __init__(self):
        self.name = input('我現在剛誕生，還沒有名字，幫我起一個吧。')
        self.master = input('對了，我要怎么稱呼你呢？')
        print('你好%s，我叫%s。很開心，遇見你~'%(self.master,self.name))
    
    def say_wish(self):
        wish = input('告訴我一個你的願望吧：')
        print(self.master+'的願望是：')
        # 這里也可以用字符串的格式化，不過，用循環語句的話，之后改復述次數會方便些。
        for i in range(3):
            print(wish)

robot1 = Robot()
robot1.say_wish()

 

#############################################################################################################################
類的繼承和定制
A類屬於B類，自然也擁有了B類的所有屬性和方法。
這句話在編程里就是：A類繼承了B類。

Python中，我們的習慣表述是：A類是B類的子類，而B類是A類的父類（或超類）

 

定制
子類也可以在繼承的基礎上進行個性化的定制
（1）創建新屬性、新方法；

（2）修改繼承到的屬性或方法。

————————————————————————————————————————————
繼承的基礎語法

class Chinese:在運行時相當於class Chinese(object):。

而object，是所有類的父類，我們將其稱為根類（可理解為類的始祖）。

#函數isinstance()，判斷某個實例是否屬於某個類
print(isinstance(1,int))   ## 判斷1是否為整數類的實例
True
print(isinstance(1,str))
False
print(isinstance(1,(int,str))) # 判斷實例是否屬於元組里幾個類中的一個
True

class Chinese:
    pass

class Cantonese(Chinese):
    pass

gonger = Chinese()
yewen = Cantonese()

print('\n驗證1：子類創建的實例同時也屬於父類')
print(isinstance(gonger,Chinese))  
print(isinstance(yewen,Chinese))  

print('\n驗證2：父類創建的實例不屬於子類。')
print(isinstance(gonger,Cantonese))

print('\n驗證3：類創建的實例都屬於根類。')
print(isinstance(gonger,object))  
print(isinstance(yewen,object))

驗證1：子類創建的實例同時也屬於父類
True
True

驗證2：父類創建的實例不屬於子類。
False

驗證3：類創建的實例都屬於根類。
True
True

————————————————————————————————————————————
類的繼承之多層繼承

子類創建的實例可調用所有層級父類的屬性和方法

 

 

class Earthman:
    eye_number = 2

# 中國人繼承了地球人
class Chinese(Earthman):
    eye_color = 'black'

# 廣東人繼承了中國人，同時也繼承了地球人。
class Cantonese(Chinese):
    pass

yewen = Cantonese()
print(yewen.eye_number)
print(yewen.eye_color)
2
black

 

####################################################################
類的繼承之多重繼承

一個類，可以同時繼承多個類，
語法為 class A(B,C,D):

就近原則：
越靠近子類（即越靠左）的父類，越親近，越優先考慮。子類調用屬性和方法時，會先在靠左的父類里找，找不到才往右找。

 

class Su:
    born_city = 'Jiangsu'
    wearing = 'thick'

    def diet(self):
        print('我們愛吃甜。')

class Yue:
    settle_city = 'Guangdong'
    wearing = 'thin'

    def diet(self):
        print('我們吃得清淡。')

class Yuesu(Yue,Su):  
    pass

xiaoming = Yuesu()
print(xiaoming.wearing) # 先在 Yue類找，找到了，打印出來。
print(xiaoming.born_city) # Yue類沒有born_city，才去Su類找。
xiaoming.diet() # 方法調用，和屬性調用一樣，也符合就近原則。

thin
Jiangsu
我們吃得清淡。

 

類的定制
定制，可以新增代碼

 

class Chinese:
    eye = 'black'

    def eat(self):
        print('吃飯，選擇用筷子。')

class Cantonese(Chinese):  # 類的繼承
    native_place = 'guangdong'  # 類的定制

    def dialect(self):  # 類的定制
        print('我們會講廣東話。')

yewen = Cantonese()
print(yewen.eye)           # 父類的屬性能用
print(yewen.native_place)  # 子類的定制屬性也能用
yewen.eat()                # 父類的方法能用
yewen.dialect()            # 子類的定制方法也能用

black
guangdong
吃飯，選擇用筷子。
我們會講廣東話。

定制，也可重寫代碼
在子類中，對父類代碼的修改

子類繼承父類方法的操作是在def語句后接父類.方法（參數）

 

 

class Chinese:

    def land_area(self,area):
        print('我們居住的地方，陸地面積是%d萬平方公里左右。'% area)

class Cantonese(Chinese):
    # 間接對方法進行重寫
    def land_area(self, area, rate = 0.0188):
        Chinese.land_area(self, area * rate)
        # 直接繼承父類方法，再調整參數。

gonger = Chinese()
yewen = Cantonese()
gonger.land_area(960)
yewen.land_area(960)

 

提示：初始化方法的定制，和一般的實例方法的定制是一樣的。

 

class Chinese:
    def __init__(self, greeting='你好', place='中國'):
        self.greeting = greeting
        self.place = place

    def greet(self):
        print('%s！歡迎來到%s。' % (self.greeting, self.place))   

# 請為子類完成定制，代碼量：兩行。
class Cantonese(Chinese):
    def __init__(self, greeting='雷猴', place='廣東'):  #重寫代碼最好是在繼承方法的基礎上通過代碼的調整完成定制
        Chinese.__init__(self, greeting ,place)   
   
yewen = Cantonese()
yewen.greet()
雷猴！歡迎來到廣東。

 

###################################################################################################################
列子

class Student:
    def __init__(self, name, job=None, time=0.00, time_effective=0.00): 
        self.name = name
        self.job = job
        self.time = time
        self.time_effective = time_effective

    def count_time(self, hour, rate):
        self.time += hour
        self.time_effective += hour * rate

class Programmer(Student):
    def __init__(self, name): #此處為啥只留name參數，因為沒有給出默認值，需要傳入參數，不能省略，然后其他都是默認參數
        Student.__init__(self, name, job='programmer', time=0.00, time_effective=0.00)

    def count_time(self, hour, rate=1):
        Student.count_time(self, hour, rate)

student1 = Student('韓梅梅')
student2 = Programmer('李雷')

print(student1.job)
print(student2.job)

student1.count_time(10, 0.8)
student2.count_time(10)

print(student1.time_effective)
print(student2.time_effective)