day22:初識面向對象

1，類能夠理解爲是一個模子，能夠是代碼精簡，方便增長實例，方便修改，更加規範，能知道具體的屬性，方法，可是不知道具體的值

2，對象有具體的值，屬性和技能都是根據類規範的

3， 先有類纔有對象

4，面向程序，面向函數，面向對象編程

5，面向對象優勢:解決了程序的擴展性,維護和擴展變得簡單，大大提升程序的開發效率，缺點，可控性比較差，應用場景：需求常常變化的軟件

6，Python中一切皆對象，比如Linux中一切結尾文件

class Person:
    def __init__(self,*args):
        # self是一個能夠存儲不少屬性的大字典
        self.name = args[0] # 王子點裏添加屬性的方式發生了變化
        self.hp = args[1]
        self.aggr = args[2]
        self.sex = args[3]
    def walk(self):
        print('走走走')

lisa = Person('lisa',100,200,'female')  # 實例化過程，想象序列化
print(lisa.__dict__)
print(Person.__dict__)

# {'name': 'lisa', 'hp': 100, 'aggr': 200, 'sex': 'female'}
# {'__module__': '__main__', '__init__': <function Person.__init__ at 0x10d412840>, 'walk': <function Person.walk at 0x10d4127b8>, '__dict__': <attribute '__dict__' of 'Person' objects>, '__weakref__': <attribute '__weakref__' of 'Person' objects>, '__doc__': None}

7,雙下init函數會在實例化的時候自動調用，而後傳參，而且會自動返回一個self對象

# 對象 = 類名()
# 過程:
#  類名() 首先會創造出一個對象，建立了一個self變量，建立的過程咱們不須要關心，系統自檢給建立
# 自動調用init方法，類名括號裏的參數會被這裏接收 
# 執行init方法，
# 返回sel

8，幫助理解面向對象的一段代碼

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('lisa',78,10)
print(egg['name'])

9，類裏面，我只要已建立一個class的時候，我就擁有了一個self，self等於空字典這個事不須要你去作，別人替你作了，只是你直接拿着這個就能夠用了。以點的方式操做而後最後把self返回給對象，新建立的對象，就是self。self裏面存儲的就是一個字典的關係

class Person:
    def __init__(self,*args):
        # self是一個能夠存儲不少屬性的大字典
        print(self.__dict__)  # {}

        self.name = args[0] # 王子點裏添加屬性的方式發生了變化
        self.hp = args[1]
        self.aggr = args[2]
        self.sex = args[3]

        print(self.__dict__)  # {'name': 'lisa', 'hp': 100, 'aggr': 200, 'sex': 'female'}


lisa = Person('lisa',100,200,'female')

10，新實例化的對象就是self

class Person:
    def __init__(self,*args):
        # self是一個能夠存儲不少屬性的大字典，
        print(self.__dict__)  # {}

        self.name = args[0] # 只不過往字典裏添加屬性的方式發生了變化
        self.hp = args[1]
        self.aggr = args[2]
        self.sex = args[3]
        print(id(self))
        print(self.__dict__)  # {'name': 'lisa', 'hp': 100, 'aggr': 200, 'sex': 'female'}


lisa = Person('lisa',100,200,'female')
print(id(lisa))
print(lisa.__dict__) # ID同樣，內存地址同樣，因此兩個就是同樣的


運行結果：
{}
4417958464
{'name': 'lisa', 'hp': 100, 'aggr': 200, 'sex': 'female'}
4417958464
{'name': 'lisa', 'hp': 100, 'aggr': 200, 'sex': 'female'}

11，調用方法

class Person:
    def __init__(self,*args): # 通常雙下init都放在最上面

        self.name = args[0]
        self.hp = args[1]
        self.aggr = args[2]
        self.sex = args[3]

    def walk(self):  # 這個參數是必須有的，只要是類的方法就得有，這個名字不用self也能夠，可是咱們不成文的規定都叫self
        print('hello')


lisa = Person('lisa',100,200,'female')
print(lisa.__dict__)
print(Person.__dict__) # 類的字典裏面有個walk，因此咱們能夠用類來調用試試
# {'name': 'lisa', 'hp': 100, 'aggr': 200, 'sex': 'female'}
# {'__module__': '__main__', '__init__': <function Person.__init__ at 0x1007b17b8>, 'walk': <function Person.walk at 0x1007b16a8>, '__dict__': <attribute '__dict__' of 'Person' objects>, '__weakref__': <attribute '__weakref__' of 'Person' objects>, '__doc__': None}

# Person.walk()  # 提示錯誤 TypeError: walk() missing 1 required positional argument: 'self'
Person.walk(lisa) # 由於Lisa就是self，因此咱們傳入Lisa
# hello
# 這種調用有一種簡寫的方法就是
lisa.walk() # 這個和Person.walk(lisa)效果是同樣的

12，總結

# 對象能作的事：
    # 查看屬性
    # 調用方法
# 類名能作的事：
    # 實例化
    # 調用方法：只不過要本身調用self參數

13，靜態屬性

class Person:
    country = 'China'  # 創造了一個只要是這個類就必定有的屬性
                       # 類屬性，靜態屬性

    def __init__(self,*args):

        self.name = args[0]
        self.hp = args[1]
        self.aggr = args[2]
        self.gender = args[3]

    def walk(self):
        print('hello')

lisa = Person('lisa',100,200,"female")


print(Person.country) # China
print(Person.__dict__['country'])   # China
print(lisa.__dict__['name']) # lisa
# 類名不能夠調用對象的屬性，能夠查看靜態屬性，不須要實例化就能夠查看

13,修改對象屬性，能夠經過屬性或者字典來修改

    country = 'China'  # 創造了一個只要是這個類就必定有的屬性
                       # 類屬性，靜態屬性

    def __init__(self,*args):

        self.name = args[0]
        self.hp = args[1]
        self.aggr = args[2]
        self.gender = args[3]

    def walk(self):
        print('hello')

lisa = Person('lisa',100,200,"female")


print(Person.country) # China
print(Person.__dict__['country'])   # China
print(lisa.__dict__['name']) # lisa
# 類名不能夠調用對象的屬性，能夠查看靜態屬性，不須要實例化就能夠查看

lisa.__dict__['name'] = 'lucy' # 修改爲功
print(lisa.__dict__['name'])  # lucy
# __dict__對於對象的屬性增刪改查均可以經過字典的語法進行，可是正產狀況下咱們不太這樣用，咱們通常這樣用
lisa.name = 'jack' # 經過屬性改，可是不經過字典改
print(lisa.__dict__['name']) # jack
# 這兩種修改方式本質上是同樣的

14，類屬性也就是靜態屬性的修改不能夠經過字典來修改，只能經過屬性來修改

class Person:
    country = 'China'  # 創造了一個只要是這個類就必定有的屬性
                       # 類屬性，靜態屬性

    def __init__(self,*args):

        self.name = args[0]
        self.hp = args[1]
        self.aggr = args[2]
        self.gender = args[3]

    def walk(self):
        print('hello')

lisa = Person('lisa',100,200,"female")


print(Person.country) # China
print(Person.__dict__['country'])   # China
# Person.__dict__['country'] ='USA'
# TypeError: 'mappingproxy' object does not support item assignment
Person.country = 'USA' # 修改爲功

15，大寫開頭的名字，通常都是給類名用

16，實例，計算圓的面積和周長

from math import pi
class Circle:
    def __index__(self,r):
        self.r = r
        
    def area(self):
        return pi *(self.r**2)
    
    def perimeter(self):
        return 2*pi*self.r
    
c1 = Circle(6)
print(c1.area())
print(c1.perimeter())