python入門與進階篇(五)之面向對象

類的概念：類是現實世界或思維世界的實體在計算機中的反映，它將數據以及數據上的一些操作封裝在一起。

類首字母大寫 大駝峯命名 如StudentHomeWork

 

函數和方法的區別:

方法:設計層面 函數:程序運行、過程式的一種稱謂

模塊中的稱作變量和函數

 

python面向對象的特點：

1.sum在類中被稱作類變量(數據成員) do_homework()被稱爲類中的實例方法

2.self.name 和self.age被稱作實例變量

3.實例化訪問變量的時候首先會查找實例變量 找不到再找類變量 然後往上繼承

4.self指向的是實例對象

5. 構造函數__init__() 實例化的時候默認會執行 但是也可以手動調用執行student.__init__()，構造函數默認返回None 並且只能返回None 構造函數可以稱作特殊的實例方法

6.實例方法中訪問類變量Student.sum 或self.__class__.sum

7.通過@classmethod裝飾器將方法設置爲類方法 cls代表類本身

8.通過@staticmethod裝飾器將方法設置爲靜態方法 

class1.py:

class Student():
    # 類變量
    sum=0
    # 構造函數__init__() 實例化的時候默認會執行 但是也可以手動調用執行student.__init__()
    def __init__(self,name,age):
        # 實例變量
        self.name=name
        self.age=age
        # 實例方法中訪問類變量Student.sum 或self.__class__.sum
        print("類變量訪問方式1",Student.sum)
        print("類變量訪問方式2",self.__class__.sum)
        print ("構造函數默認返回None 並且只能返回None")
    # 實例方法
    def do_homework(self):
        print("做家庭作業")
    # 類方法 cls代表類本身
    @classmethod
    def plus_sum(cls):
        cls.sum+=1
        print("sum:"+str(cls.sum))
    #當該方法與類和實例沒什麼關係的時候可以使用,但不推薦使用靜態方法
    @staticmethod
    def add(x,y):
        print("this is a static methods!")

class2.py

#引入class1模塊中的Student類
from class1 import Student

student1=Student("張三",18)
Student.plus_sum() # sum=1
student2=Student("李四",20)
Student.plus_sum() # sum=2
# 實例對象也可以調用類方法 但是通常不建議這樣做
student1.plus_sum() # sum=3
# 實例對象也可以調用靜態方法
student1.add(1,2)  # this is a static methods!
print(student1.name)   #張三  
print(student2.name)   #李四
print(student1.__dict__) #__dict__實例變量 {'name': '張三', 'age': 18}
#外部通過Student.name訪問類變量
print(Student.sum)    #類變量

成員的可見性：

公共public 和私有private

__讓類中的變量和方法稱爲私有變量和方法

通過方法去改變類中的私有變量 

python通過將私有變量改變名字隱藏起來

class Student():
    # 類變量
    sum=0
    #私有變量
    __sum1=0
    # 構造函數__init__() 實例化的時候默認會執行 但是也可以手動調用執行student.__init__()
    def __init__(self,name,age):
        # 實例變量
        self.name=name
        self.age=age
        # 私有變量
        self.__score=0
        # 實例方法中訪問類變量Student.sum 或self.__class__.sum
        print("類變量訪問方式1",Student.sum)
        print("類變量訪問方式2",self.__class__.sum)
        print ("構造函數默認返回None 並且只能返回None")
    # 實例方法 私有方法
    def __do_homework(self):
        #內部調用實例方法
        self.do_english_homework()
        print("做家庭作業")
    def do_english_homework(self):
        print("做英語家庭作業")
    # 通過方法去改變私有變量
    def mark(self,score):
        if self.__score<0:
            print("分數不能爲負")
            return None
        self.__score=score
        print("得分爲:"+str(self.__score))

    # 類方法 cls代表類本身
    @classmethod
    def plus_sum(cls):
        cls.sum+=1
        print("sum:"+str(cls.sum))
    #當該方法與類和實例沒什麼關係的時候可以使用,但不推薦使用靜態方法
    @staticmethod
    def add(x,y):
        print("this is a static methods!")


student1=Student('張三',18)
student2=Student('李四',20)
student1.mark(59)
student1.__score=12
# {'name': '張三', 'age': 18, '_Student__score': 59, '__score': 12} 通過將私有變量改變名字隱藏起來
print(student1.__dict__)
#動態添加實例變量__score
print(student1.__score)  #2
print(student2.__score)  #報錯

 

繼承:python中子類是可以繼承多個父類的

推薦使用super的方式來調用父類的構造函數 而不是通過Human.__init__的顯式調用方式

可以在實例方法中通過super的方式來調用父類的實例方法

extend1:

class Human():
    sum=0
    def __init__(self,name,age):
        self.name=name
        self.age=age
    def get_name(self):
        print(self.name)
    def do_homework(self):
        print("這是父類的一個方法")

extend2:

#引入extend1模塊 Human類
from extend1 import Human

#傳入父類Human類 繼承Human類
class Student(Human):
    def __init__(self,school,name,age):
        self.school=school
        # 顯示調用父類__init__方法繼承Human類的name和age 類來調用實例方法需要傳入self
        # Human.__init__(self,name,age)
        #super的方式來調用父類的構造函數
        super(Student,self).__init__(name,age)
    def do_homework(self):
        #super的方式來調用父類的實例方法
        super(Student,self).do_homework()
        print("做家庭作業")

student1=Student("湖南長沙學院","張三",20)
#繼承父類Human的sum類變量
print(student1.sum)  # 0
print(student1.name) # 張三
print(student1.age)  # 20
# 繼承父類Human的get_name()實例方法
student1.get_name()  # 張三
#執行自己的do_homework()實例方法
student1.do_homework() #這是父類的一個方法 做家庭作業

 

思維導圖

 

枚舉:枚舉實際上是一個類

from enum import Enum
# IntEnum限制枚舉類型爲數字
from enum import IntEnum,unique

# 鑽石的類型 YELLOW:黃鑽 GREEN:綠鑽 BLACK:黑鑽 RED:紅鑽
class Vip(Enum):
    YELLOW=1
    #YELLOW_ALIAS 爲YELLOW的別名    
    YELLOW_ALIAS=1
    GREEN=2
    BLACK=3
    RED=4

# 枚舉的特點:相比於字典和普通的類 值不可變 且不允許重複的值
print(Vip.YELLOW.name)  # name 枚舉的名字
print(Vip.YELLOW.value) # value 枚舉的值

print(type(Vip.YELLOW.name)) #<class 'str'>
print(type(Vip.YELLOW)) #<enum 'Vip'> 枚舉的類型
print(Vip['YELLOW']) #Vip.YELLOW

#遍歷枚舉
for v in Vip:
    print(v)   #Vip.YELLOW Vip.GREEN Vip.BLACK Vip.RED

# 遍歷枚舉包括別名
for v in Vip.__members__:
    print(v)  #YELLOW YELLOW_ALIAS GREEN BLACK RED

# 枚舉不支持>比較運算符  支持==、is運算符

#將數字轉化爲枚舉類型
a=1
print(Vip(a)) #Vip.YELLOW

#@unique 讓枚舉的值唯一
@unique
class Vip(Enum):
    YELLOW=1    
    GREEN=1 # 報錯
    BLACK=3
    RED=4