一、類的相關知識

1）初識類

聲明

def functionName(args):
     ‘函數文檔字符串‘
      函數體 

‘‘‘
class 類名:
    ‘類的文檔字符串‘
    類體
‘‘‘

#我們創建一個類
class Data:
    pass

聲明類

class Person:   #定義一個人類
    role = ‘person‘  #人的角色屬性都是人
    def walk(self):  #人都可以走路，也就是有一個走路方法，也叫動態屬性
        print("person is walking...
 
")

類有兩種作用：屬性引用和實例化

屬性引用（類名.屬性）

class Person:   #定義一個人類
    role = ‘person‘  #人的角色屬性都是人
    def walk(self):  #人都可以走路，也就是有一個走路方法
        print("person is walking...")


print(Person.role)  #查看人的role屬性
print(Person.walk)  #引用人的走路方法，註意，這裏不是在調用

實例化：類名加括號就是實例化，會自動觸發__init__函數的運行。

可以用它來為每個實例定制自己的特征

class Person:   #定義一個人類
    role = ‘person‘  #人的角色屬性都是人
    def __init__(self,name):
        self.name = name  # 每一個角色都有自己的昵稱;
        
    def walk(self):  #人都可以走路，也就是有一個走路方法
        print("person is walking...")


print(Person.role)  #查看人的role屬性
print(Person.walk)  #引用人的走路方法，註意，這裏不是在調用
 

實例化的過程就是類——>對象的過程

原本我們只有一個Person類，在這個過程中，產生了一個egg對象，有自己具體的名字、攻擊力和生命值。

語法：對象名 = 類名(參數)

egg = Person(‘egon‘)  #類名()就等於在執行Person.__init__()
#執行完__init__()就會返回一個對象。這個對象類似一個字典，存著屬於這個人本身的一些屬性和方法。
#你可以偷偷的理解：egg = {‘name‘:‘egon‘,‘walk‘:walk}

查看屬性&調用方法

print(egg.name)     #查看屬性直接 對象名.屬性名
print(egg.walk())   #調用方法，對象名.方法名()

關於self

self：在實例化時自動將對象/實例本身傳給__init__的第一個參數，你也可以給他起個別的名字，但是正常人都不會這麽做。
因為你瞎改別人就不認識

類屬性的補充

一：我們定義的類的屬性到底存到哪裏了？有兩種方式查看
dir(類名)：查出的是一個名字列表
類名.__dict__:查出的是一個字典，key為屬性名，value為屬性值

二：特殊的類屬性
類名.__name__# 類的名字(字符串)
類名.__doc__# 類的文檔字符串
類名.__base__# 類的第一個父類(在講繼承時會講)
類名.__bases__# 類所有父類構成的元組(在講繼承時會講)
類名.__dict__# 類的字典屬性
類名.__module__# 類定義所在的模塊
類名.__class__# 實例對應的類(僅新式類中)

類屬性的補充

2）對象的相關知識

回到咱們的人狗大戰：現在我們需要對我們的類做出一點點改變

人類除了可以走路之外，還應該具備一些攻擊技能。

class Person:  # 定義一個人類
    role = ‘person‘  # 人的角色屬性都是人

    def __init__(self, name, aggressivity, life_value):
        self.name = name  # 每一個角色都有自己的昵稱;
        self.aggressivity = aggressivity  # 每一個角色都有自己的攻擊力;
        self.life_value = life_value  # 每一個角色都有自己的生命值;

    def attack(self,dog):  
        # 人可以攻擊狗，這裏的狗也是一個對象。
        # 人攻擊狗，那麽狗的生命值就會根據人的攻擊力而下降
        dog.life_value -= self.aggressivit

對象是關於類而實際存在的一個例子，即實例

對象/實例只有一種作用：屬性引用

egg = Person(‘egon‘,10,1000)
print(egg.name)
print(egg.aggressivity)
print(egg.life_value)

當然了，你也可以引用一個方法，因為方法也是一個屬性，只不過是一個類似函數的屬性，我們也管它叫動態屬性。

引用動態屬性並不是執行這個方法，要想調用方法和調用函數是一樣的，都需要在後面加上括號

print(egg.attack)

def Person(*args,**kwargs):
    self = {}
    def attack(self,dog):
        dog[‘life_value‘] -= self[‘aggressivity‘]

    def __init__(name,aggressivity,life_value):
        self[‘name‘] = name
        self[‘aggressivity‘] = aggressivity
        self[‘life_value‘] = life_value
        self[‘attack‘] = attack

    __init__(*args,**kwargs)
    return self

egg = Person(‘egon‘,78,10)
print(egg[‘name‘])

幫你了解面向對象

面向對象小結——定義及調用的固定模式

class 類名:
    def __init__(self,參數1,參數2):
        self.對象的屬性1 = 參數1
        self.對象的屬性2 = 參數2

    def 方法名(self):pass

    def 方法名2(self):pass

對象名 = 類名(1,2)  #對象就是實例，代表一個具體的東西
                  #類名() : 類名+括號就是實例化一個類，相當於調用了__init__方法
                  #括號裏傳參數，參數不需要傳self，其他與init中的形參一一對應
                  #結果返回一個對象
對象名.對象的屬性1   #查看對象的屬性，直接用 對象名.屬性名 即可
對象名.方法名()     #調用類中的方法，直接用 對象名.方法名() 即可

小結

3）對象之間的交互

創建一個狗類

class Dog:  # 定義一個狗類
    role = ‘dog‘  # 狗的角色屬性都是狗

    def __init__(self, name, breed, aggressivity, life_value):
        self.name = name  # 每一只狗都有自己的昵稱;
        self.breed = breed  # 每一只狗都有自己的品種;
        self.aggressivity = aggressivity  # 每一只狗都有自己的攻擊力;
        self.life_value = life_value  # 每一只狗都有自己的生命值;

    def bite(self,people):
        # 狗可以咬人，這裏的狗也是一個對象。
        # 狗咬人，那麽人的生命值就會根據狗的攻擊力而下降
　　　　 dog.life_value -= self.aggressivit

實例化一只實實在在的二哈

ha2 = Dog(‘二楞子‘,‘哈士奇‘,10,1000)  #創造了一只實實在在的狗ha2

交互egon打ha2一下

print(ha2.life_value)         #看看ha2的生命值
egg.attack(ha2)               #egg打了ha2一下
print(ha2.life_value)         #ha2掉了10點血

完善代碼

class Person:  # 定義一個人類
    role = ‘person‘  # 人的角色屬性都是人

    def __init__(self, name, aggressivity, life_value):
        self.name = name  # 每一個角色都有自己的昵稱;
        self.aggressivity = aggressivity  # 每一個角色都有自己的攻擊力;
        self.life_value = life_value  # 每一個角色都有自己的生命值;

    def attack(self,dog):
        # 人可以攻擊狗，這裏的狗也是一個對象。
        # 人攻擊狗，那麽狗的生命值就會根據人的攻擊力而下降
        dog.life_value -= self.aggressivity

class Dog:  # 定義一個狗類
    role = ‘dog‘  # 狗的角色屬性都是狗

    def __init__(self, name, breed, aggressivity, life_value):
        self.name = name  # 每一只狗都有自己的昵稱;
        self.breed = breed  # 每一只狗都有自己的品種;
        self.aggressivity = aggressivity  # 每一只狗都有自己的攻擊力;
        self.life_value = life_value  # 每一只狗都有自己的生命值;

    def bite(self,people):
        # 狗可以咬人，這裏的狗也是一個對象。
        # 狗咬人，那麽人的生命值就會根據狗的攻擊力而下降
        people.life_value -= self.aggressivity

egg = Person(‘egon‘,10,1000)  #創造了一個實實在在的人egg
ha2 = Dog(‘二楞子‘,‘哈士奇‘,10,1000)  #創造了一只實實在在的狗ha2
print(ha2.life_value)         #看看ha2的生命值
egg.attack(ha2)               #egg打了ha2一下
print(ha2.life_value)         #ha2掉了10點血

egon大戰哈士奇

from math import pi

class Circle:
    ‘‘‘
    定義了一個圓形類；
    提供計算面積(area)和周長(perimeter)的方法
    ‘‘‘
    def __init__(self,radius):
        self.radius = radius

    def area(self):
         return pi * self.radius * self.radius

    def perimeter(self):
        return 2 * pi *self.radius


circle =  Circle(10) #實例化一個圓
area1 = circle.area() #計算圓面積
per1 = circle.perimeter() #計算圓周長
print(area1,per1) #打印圓面積和周長

一個簡單的例子幫你理解面向對象

面向對象（一）——初識對象