020_面向對象

1，面向對象 、面向過程

　　1.1，面向過程：就像解數學題同樣，針對要解決的問題按照解題過程，解題步驟編寫程序

　　　　優勢是：極大的下降了寫程序的複雜度，只須要順着要執行的步驟，堆疊代碼便可。

　　　　缺點是：一套流水線或者流程就是用來解決一個問題，代碼牽一髮而動全身。

　　1.2，面向對象：以現實世界爲映像，針對具體的事物進行編程

　　　　以現實世界爲映像，將具備同種屬性，行爲的歸爲一類，就像名詞，人、貓、筆，等；對於類中的每個具體的事物，即個體稱爲對象，就像 人有張3、李四。

　　　　類：是對象的抽象化

　　　　對象：是類的具體化，實例化；

　　　　實例化：就是經過類屬性，建造一個具體的事物(即對象)的過程。例如：經過人這個類建立張三，李四等一個個具體的人物(即對象）的過程。

　　　　優勢是：解決了程序的擴展性。對某一個對象單獨修改，會馬上反映到整個體系中，如對遊戲中一我的物參數的特徵和技能修改都很容易。

　　　　缺點：可控性差，沒法向面向過程的程序設計流水線式的能夠很精準的預測問題的處理流程與結果，面向對象的程序一旦開始就由對象之間的交互解決問題，即使是上帝也沒法預測最終結果。因而咱們常常看到一個遊戲人某一參數的修改極有可能致使霸道的技能出現，一刀砍死3我的，這個遊戲就失去平衡。

2，面向對象引導

　　經過面向對象的思想，用面向過程的編程方式編寫。

    # 人狗大戰
def Dog(name,blood,aggr,kind):
    dog = {
        'name': name,
        'blood': blood,  # 血量
        'aggr': aggr,  # 攻擊力
        'kind': kind,
    }
    def bite(person):
        person['blood'] -= dog['aggr']
        print('%s被咬了，掉了%s的血' % (person['name'], dog['aggr']))
    dog['bite'] = bite
    return dog


def Person(name,blood,aggr,sex):
    person = {
        'name' : name,
        'blood': blood,   # 血量
        'aggr': aggr,      # 攻擊力
        'sex':sex,
    }
    def attack(dog):
        dog['blood'] -= person['aggr']
        print('%s被打了，掉了%s的血' % (dog['name'], person['aggr']))
    person['attack'] = attack
    return person

#以上建立了兩個模型，就是面向對象所說的類

jin = Dog('金老闆',1000,100,'teddy')    #面向對象所說的實例化，jin即爲對象
alex = Person('狗剩兒',100,1,'不詳')
nezha = Person('哪吒',200,2,'不詳')
print(jin)
jin['bite'](alex)
alex['attack'](jin)
# 直到調用了函數，賦值了以後才真的有了一個實實在在的人或狗

3，定義一個簡單的類

class 類名：
    屬性 = 'a'

print(類名.屬性)

• 類名爲與python中的函數名區分，通常第一個字母大寫
• 類名的做用 就是操做屬性 查看屬性

4，對象屬性

　　4.1，

class Person:         #不能象函數那樣定義參數，傳參；而是經過'__init__()'傳參；
	def __init__(self,*args):    #初始化方法，調用這個類建立對象時，會自動執行；
		print(args)

alex = Person('狗剩兒',100,1,'不詳')	#類的實例化，即建立實體對象

　　4.2，

class Person:        
	def __init__(self,*args):	# self就是一個能夠存儲不少屬性的大字典；必須傳參數
		self.name = args[0]		# 往字典裏添加屬性的方式發生了一些變化
		self.hp = args[1]
		self.aggr = args[2]
		self.sex = args[3]
		print(self.__dict__)	# 查看全部屬性 ，是一個字典

alex = Person('狗剩兒',100,1,'不詳')
print(alex) #是一個地址 
print(alex.name)  # 查看屬性值

# {'name': '狗剩兒', 'hp': 100, 'aggr': 1, 'sex': '不詳'}
# <__main__.Person object at 0x0000027E82A034E0>
# 狗剩兒

　　4.3，用函數的方式解釋上面的類函數

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'])

5，添加方法 （一類事物具備的行爲）

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('走走')

alex = Person('狗剩兒',100,1,'不詳')
print(alex)	#是一個地址
alex.walk()  #實例對象調用方法：「對象名.方法名(參數)」  
# Person.walk(alex)  #能夠這樣調用方法，但不是對象調用，不要用。	
print(alex.name)  # 查看屬性值

6，類，對象中的屬性問題

　　6.1，類，對象的屬性都是用字典保存的，能夠用字典的方法。但類的屬性屬於靜態變量，不能修改。

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

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

　　

print(Person.__dict__) #類的字典
print(alex.__dict__)	#對象的字典

# __dict__ 對於對象的增刪改查操做均可以經過字典的語法進行
print(Person.__dict__['country'])
Person.__dict__['country'] = '印度'
print(alex.__dict__['name'])
alex.__dict__['name'] = '二哥'
print(alex.name)

#其實面向對象能夠經過下面的方法進行上面的操做
print(alex.name)
alex.name = '二哥'
alex.age = 83
print(alex.name)