面向物件微講解

1. 面向物件的思想演變

'''
假如我們想實現一個人狗大戰的功能，就一個小小的功能我們來看看怎麼做
'''
# 1. 先定義人和狗的技能、血量、防禦，我們可以用字典來儲存這些資料
# person_dict = {
#     'name': 'oscar',
#     'skill': '火焰攻擊',
#     'hurt': 100,
#     'volume': 500
# }
# person1_dict = {
#     'name': 'kevin',
#     'skill': '寒冰攻擊',
#     'hurt': 80,
#     'volume': 450
# }
# dog_dict = {
#     'name': '土狗',
#     'skill': '土崩',
#     'hurt': 50,
#     'volume': 300
# }
# dog1_dict = {
#     'name': '修勾',
#     'skill': '撕咬',
#     'hurt': 60,
#     'volume': 400
# }
# 角色我們只寫了四個，就發現程式碼有些冗餘了，而且還有很多重複的程式碼，所以我們用函式來定義一個建立角色的方法
# def person_func(name, skill, hurt, volume):
#     person_dict = {
#         'name': name,
#         'skill': skill,
#         'hurt': hurt,
#         'volume': volume
#     }
#     return person_dict
#
#
# def dog_func(name, skill, hurt, volume):
#     dog_dict = {
#         'name': name,
#         'skill': skill,
#         'hurt': hurt,
#         'volume': volume
#     }
#     return dog_dict
#
# # 建立角色
# person1 = person_func('oscar', '火焰攻擊', 100, 500)
# person2 = person_func('kevin', '寒冰攻擊', 80, 450)
# dog1 = dog_func('土狗','土崩',50,300)
# dog2 = dog_func('修狗','撕咬',80,400)
# # 封裝一個攻擊函式
# def skill_person(person,dog):
#     print('人物角色:%s 使用: %s 攻擊動物角色:%s'% (person['name'],person['skill'],dog['name']))
#     dog['volume'] -= person['hurt']
#     print('攻擊成功，%s受到%s點傷害，血量剩餘為%s'% (dog['name'],person['hurt'],dog['volume']))
# def skill_dog(dog,person):
#     print('動物角色:%s 使用: %s 攻擊人物角色:%s'% (dog['name'],dog['skill'],person['name']))
#     person['volume'] -= dog['hurt']
#     print('攻擊成功，%s受到%s點傷害，血量剩餘為%s'% (person['name'],dog['hurt'],person['volume']))
skill_person(person2,dog2)
 

skill_dog(dog1,person1)
'''

人物角色:kevin 使用: 寒冰攻擊 攻擊動物角色:修狗

攻擊成功，修狗受到80點傷害，血量剩餘為320

動物角色:土狗 使用: 土崩 攻擊人物角色:oscar

攻擊成功，oscar受到50點傷害，血量剩餘為45

'''
我們想要的效果有了，但是呢有一些問題，我們來看
skill_dog(person1,dog1)
'''

動物角色:oscar 使用: 火焰攻擊 攻擊人物角色:土狗

攻擊成功，土狗受到100點傷害，血量剩餘為200

'''
我們發現該方法不結合實際，人可以呼叫狗的方法，狗可以呼叫人的方法，那要怎麼給他們加一個限制呢我們來看
def person_func(name, skill, hurt, volume):

# 把人物的攻擊方法寫進建立人物角色的方法中，這樣就只有人物角色才可以呼叫這個方法了

def skill_person(person, dog):

print('人物角色:%s 使用: %s 攻擊動物角色:%s' % (person['name'], person['skill'], dog['name']))

dog['volume'] -= person['hurt']

print('攻擊成功，%s受到%s點傷害，血量剩餘為%s' % (dog['name'], person['hurt'], dog['volume']))

person_dict = {

'name': name,

'skill': skill,

'hurt': hurt,

'volume': volume,

'skill_person': skill_person

}

return person_dict
 

def dog_func(name, skill, hurt, volume):

# 把狗的攻擊方法寫進建立狗的方法中，這樣就只有動物角色才可以呼叫這個方法了

def skill_dog(dog, person):

print('動物角色:%s 使用: %s 攻擊人物角色:%s' % (dog['name'], dog['skill'], person['name']))

person['volume'] -= dog['hurt']

print('攻擊成功，%s受到%s點傷害，血量剩餘為%s' % (person['name'], dog['hurt'], person['volume']))

dog_dict = {

'name': name,

'skill': skill,

'hurt': hurt,

'volume': volume,

'skill_dog': skill_dog

}

return dog_dict
 

建立角色
person1 = person_func('oscar', '火焰攻擊', 100, 500)

person2 = person_func('kevin', '寒冰攻擊', 80, 450)

dog1 = dog_func('土狗','土崩',50,300)

dog2 = dog_func('修狗','撕咬',80,400)

person1'skill_person'

dog1'skill_dog'

以上的推導就是面向物件的思想的演變，以上的程式碼將人物角色、動物角色的資料與功能整合到一起的操作就是面向物件程式設計的思想。

2. 程式設計思想

1.面向過程程式設計
	面向過程程式設計的核心就是'過程'，就是將程式的執行分步操作，在分步過程中解決問題。就象我們的自行車流水線，開頭
上來一個車架，放在傳送帶上，然後就開始裝輪子，裝完輪子裝鏈條，然後就是腳踏板，然後再檢驗一下腳踏板的壓力，然後裝腳
踏板的擋板，然後就是座套，再然後就是車把，這樣我們的一個自行車就完成了，就是一步一步分步操作的，中間還有很多的檢查，
這樣出錯了就可以直接糾正，然後放在流水線上就這下一步操作。
    這個例子呢就是一步一步分步的操作，在我們IT行業這樣的操作就叫面向過程程式設計。

2.面向物件程式設計
	面向物件程式設計的核心就是'物件'，'物件'其實就是一個容器，裡面整合了資料和功能，滿足這個條件的就是'物件'。比如
我們剛剛寫的那個人狗大戰的小遊戲，最後把人物角色、動物角色的資料與功能整合到一起，就可以稱之為面向物件程式設計，還比如我
們在pycharm寫程式碼的py檔案，檔案裡面也有功能、資料，也可以稱之為面向物件程式設計。還比如我們人，其實就是一個物件，我們有
手有腳，就相當於資料，我們可以吃飯、跑、游泳，這就是我們的功能，當我們來跑、吃飯的時候也可以稱之為面向物件程式設計。

面向過程程式設計與面向物件程式設計兩者沒有優劣之分，具體的要結合實際的業務情況，很多時候兩者都是共同使用的，只是使用的比例不同。

3. 類與物件的概念

我們剛剛已經講過物件就是資料與功能的結合體。
我們再來講講類，見名知意就是種類、類別，比如我們經常說的犬類、人類、貓類等等，都屬於一個類別，但是他們又各不相同，各自
有各自的特點，但是呢他們又有很多相似的點，‘比如隨便來條狗我們都知道他是一條狗’。所以呢'類'，就是相當於很多的個體有很多
相同的特徵，這裡很多個體可以是很多人，組成的就是人類，也可以是很多狗，組成就是犬類;但是在IT中呢，個體就相當於物件，特
徵就相當於資料、功能，所以IT中的'類'就是很多的物件具有相同特徵(資料、功能)的群體。

4. 類與物件的建立

#我們剛剛講過類與物件的概念，在程式碼的程式設計中是先有類再有物件的
我們來定義一個類，然後產生物件
# 定義一個學生類
class Student:
    # 學生類公共的資料
    school = '復旦大學'
    # 學生類公共的功能
    def chooes_course(self):
        print('學生選課')
'''
建立類的語法結構
class 類名:
	類體程式碼
'''
# 1.class是定義類的關鍵字
# 2.類名類似於函式名，但是首字母推薦大寫
# 3.類體程式碼就是存放物件公共資料和功能的地方(資料:變數名 = 變數值  功能:函式)
注意:類中的子程式碼，就是類體程式碼是無需呼叫就會執行的，然後產生類的名稱空間。

類獲取資料和功能的方法:dict

print(Student.__dict__)  # 返回的是一個字典
print(Student.__dict__['school'])  # 復旦大學 獲取類中的屬性
print(Student.__dict__['chooes_course'])  # <function Student.chooes_course at 0x0000014DFFF7BB70> 獲取類中的屬性

便捷方式:局點符

print(Student.school)  # 復旦大學
print(Student.chooes_course)  # <function Student.chooes_course at 0x0000014DFFF7BB70>

類產生物件的方法

obj1 = Student()  # 類名加括號產生物件
obj2 = Student()  # 類名加括號產生物件
print(obj1.__dict__,obj2.__dict__)  # {} {}
print(obj1.school)  # 復旦大學
print(obj1.chooes_course)  # <bound method Student.chooes_course of <__main__.Student object at 0x000001F87BCDB4A8>>
Student.school = '清華大學'  # 修改類中的屬性值
print(obj1.school)  # 清華大學

5. 物件的例項化

我們用類產生物件的時候，物件是沒有自己獨有的屬性的:

 class Student:
     school = '復旦大學'
     def chooes_course(self):
         print('學生選課')
 print(obj1.__dict__,obj2.__dict__)  # {} {} 目前物件沒有自己獨有的屬性

我們想要物件有自己獨有的屬性，就要新增，也就是新增鍵值對:

 obj1.__dict__['name'] = 'oscar'
 obj1.__dict__['age'] = '21'
 obj2.__dict__['name'] = 'jason'
 obj2.__dict__['age'] = '18'
 也可以使用便捷方式新增
'''
obj1.name = 'oscar'
obj1.age = '21'
obj2.name = 'jason'
obj2.age = '18'
'''
 print(obj1.__dict__,obj2.__dict__)  # {'name': 'oscar', 'age': '21'} {'name': 'jason', 'age': '18'}
 print(obj1.name)  # oscar
 print(obj2.name)  # jason

我們會發現有很多冗餘的程式碼，因為建立物件的時候可能會有很多，我們可以封裝成函式:

 def init(obj,name,age):
     obj.name = name
     obj.age = age
 init(obj1,'oscar',21)
 print(obj1.name)  # oscar

但是呢簡單的封裝成函式沒有提現出面向物件整合的精髓，所以我們將函式寫到類中去:

class Student:
    def init(obj,name,age):
        obj.name = name
        obj.age = age
    school = '復旦大學'
    def chooes_course(self):
        print('學生選課')

obj1 = Student()  # 類名加括號產生物件
obj2 = Student()  # 類名加括號產生物件
Student.init(obj1,'oscar',21)
print(obj1.name)  # oscar

類中針對給物件建立獨有資料的函式名，python專門定義了一個固定的方法:

class Student:
    def __init__(self,name,age):
        self.name = name
        self.age = age
    school = '復旦大學'
    def chooes_course(self):
        print('學生選課')

obj1 = Student('oscar',21)
obj2 = Student('jason',18)
print(obj1.name)  # oscar
print(obj2.age)  # 18
'''
類中的__init__方法會在類產生物件的時候自動執行。
類建立的具體步驟:
	1.先建立一個沒有獨有資料的空物件
	2.將空物件和類括號內傳入的資料一併交給__init__執行，__init__的第一個引數就是物件本身。
	3.將建立好的物件自動返回
'''

6. 繫結方法

在類中定義的函式預設都是繫結給物件使用的，即物件只要來呼叫，就會將該物件最為第一個引數傳入:

class Student:
    def __init__(self,name,age):
        self.name = name
        self.age = age
    school = '復旦大學'
    def course(self):
        print(self)
    def chooes_course(self):
        print('%s找到我了' % self.name)
    def chooes(self):
        print('%s找到我了' % self.name)

obj1 = Student('oscar',21)
obj2 = Student('jason',18)
# 類呼叫類中的方法，有幾個引數就需要傳入幾個引數
Student.course(123)  # 123
# 物件呼叫類中的函式，會將當前呼叫的物件當做第一個引數自動傳入
obj1.chooes_course()  # oscar找到我了

這裡是IT小白陸祿緋，歡迎各位大佬的指點！！！