一、人狗大戰(zhàn)

1、需求

• 用代碼模擬人、狗打架的小游戲

  

  創(chuàng)新互聯(lián)建站堅(jiān)持“要么做到，要么別承諾”的工作理念，服務(wù)領(lǐng)域包括：做網(wǎng)站、網(wǎng)站建設(shè)、企業(yè)官網(wǎng)、英文網(wǎng)站、手機(jī)端網(wǎng)站、網(wǎng)站推廣等服務(wù)，滿足客戶于互聯(lián)網(wǎng)時(shí)代的站前網(wǎng)站設(shè)計(jì)、移動媒體設(shè)計(jì)的需求，幫助企業(yè)找到有效的互聯(lián)網(wǎng)解決方案。努力成為您成熟可靠的網(wǎng)絡(luò)建設(shè)合作伙伴！

• 人和狗種類不同，因此雙方的屬性各不相同

推導(dǎo)一：

• 人和狗各有不同屬性
• 使用字典方式儲存屬性較為方便，并可儲存多種屬性

# 1、在字典內(nèi)儲存‘人’屬性
person = {
     'name': '阿拉蕾',
     'age': 18,
     'gender': '女',
     'p_type': '戰(zhàn)士',
     'attack_val': 8000,
     'life_val': 
 }

# 2、在字典內(nèi)儲存‘狗’特有屬性
 dog1 = {
     'name': '小黑',
     'd_type': '泰迪',
     'attack_val': 100,
     'life_val': 8000
 }

推導(dǎo)二:

• 按照上述方法，如果想要定義多個(gè)‘人’和‘狗’就需要反復(fù)設(shè)置多個(gè)字典，這樣非常麻煩且費(fèi)時(shí)
• 這時(shí)可推導(dǎo)出，想要快速、便捷的定義多個(gè)‘人’和‘狗’，那么我們可以把字典內(nèi)的數(shù)據(jù)封裝在函數(shù)內(nèi)，利用傳參的方式，這樣可以較為方便的生成多個(gè)‘人’和‘狗’，只需要使用不同變量名調(diào)用函數(shù)時(shí)傳不同的參數(shù)即可

# 1、封裝‘人’屬性函數(shù)
def create_person(name, age, gender, p_type, attack_val, life_val):
    person_dict = {
        'name': name,
        'age': age,
        'gender': gender,
        'p_type': p_type,
        'attack_val': attack_val,
        'life_val': life_val
    }
    return person_dict


# 2、封裝‘狗’屬性的函數(shù)
def create_dog(name, d_type, attack_val, life_val):
    dog_dict = {
        'name': name,
        'd_type': d_type,
        'attack_val': attack_val,
        'life_val': life_val
    }
    return dog_dict


# 3、生成多個(gè)‘人’和‘狗’
p1 = create_person('阿拉蕾', 18, '男', '戰(zhàn)士', 8000, )
p2 = create_person('小朵朵', 28, '女', '法師', 100, 800)

d1 = create_dog('小黑', '泰迪', 100, 8000)
d2 = create_dog('小白', '斗牛', 100, )

推導(dǎo)三:

• ‘人’和‘狗’就類似于各自不同種類的對象
• 說到這里，我們就應(yīng)該明白，‘人’和‘狗’因?yàn)榉N類不同，所以雙方的屬性也各不相同，也就是說不同的對象，屬性（數(shù)據(jù)）各不相同
• 當(dāng)多個(gè)對象的屬性生成后，我們就要開始定義彼此打架的動作（功能）
  • 人打狗的動作
  • 狗咬人的動作

# 1、人打狗的動作
def person_attack(person_dict, dog_dict):
    print(f"{person_dict.get('name')}踢向{dog_dict.get('name')}")
    dog_dict['life_val'] -= person_dict.get('attack_val')
    print(f"人踢了狗一腳 狗掉血:{person_dict.get('attack_val')} 狗剩余血量:{dog_dict.get('life_val')}")
    
# 2、狗打人的動作
def dog_attack(dog_dict, person_dict):
    print(f"{dog_dict.get('name')}向{person_dict.get('name')}咬去")
    person_dict['life_val'] -= dog_dict.get('attack_val')
    print(f"狗咬了人一口 人掉血:{dog_dict.get('attack_val')} 人剩余血量:{person_dict.get('life_val')}")

# 3、調(diào)用雙方各自的函數(shù)，即可模擬出雙方打架的動作
person_attack(p1, d1)  # 人打狗
dog_attack(d2, p2)  # 狗咬人
-------------------------------------------------------
阿拉蕾踢向小黑
人踢了狗一腳 狗掉血:8000 狗剩余血量:0
小白向小朵朵咬去
狗咬了人一口 人掉血:100 人剩余血量:700

2、核心思路

• ‘人’和‘狗’就是不同的對象
  • 通過將不同的屬性封裝在不同的函數(shù)內(nèi)，就可以通過相同的函數(shù)快速生成不同屬性的對象
• ‘人’和‘狗’打架的方式就是對象的功能
  • 人的打架方式是踢，狗的打架方式是咬，也就是說不同的類有著不同的功能，而相同的類就可以有著彼此相同的功能

需求:

• 以上我們完成了不同種類的打架方式，但是在python中，如果沒有特別的限制，我們就可以把人攻擊的數(shù)據(jù)傳在狗攻擊函數(shù)內(nèi)，這樣就會產(chǎn)生混亂，要如何實(shí)現(xiàn)下列需求
  • ‘人’只能調(diào)用人的攻擊方式
  • ‘狗’只能調(diào)用狗的攻擊方式

推導(dǎo)一:

"""推導(dǎo)步驟4:如何實(shí)現(xiàn)只有人只能調(diào)用的人的攻擊動作  狗只能調(diào)用狗的攻擊動作>>>:數(shù)據(jù)與功能的綁定"""
def get_person(name, age, gender, p_type, attack_val, life_val):
    # 產(chǎn)生人的函數(shù)(功能)
     def person_attack(person_dict, dog_dict):
        print(f"{person_dict.get('name')}踢向{dog_dict.get('name')}")
        dog_dict['life_val'] -= person_dict.get('attack_val')
        print(f"人踢了狗一腳 狗掉血:{person_dict.get('attack_val')} 狗剩余血量:{dog_dict.get('life_val')}")
    # 表示人的信息(數(shù)據(jù))
    person_dict = {
        'name': name,
        'age': age,
        'gender': gender,
        'p_type': p_type,
        'attack_val': attack_val,
        'life_val': life_val,
        'person_attack': person_attack
    }
    return person_dict


def get_dog(name, d_type, attack_val, life_val):
    def dog_attack(dog_dict, person_dict):
        print(f"{dog_dict.get('name')}向{person_dict.get('name')}咬去")
        person_dict['life_val'] -= dog_dict.get('attack_val')
        print(f"狗咬了人一口 人掉血:{dog_dict.get('attack_val')} 人剩余血量:{person_dict.get('life_val')}")
    dog_dict = {
        'name': name,
        'd_type': d_type,
        'attack_val': attack_val,
        'life_val': life_val,
        'dog_attack': dog_attack
    }
    return dog_dict


person1 = get_person('jason', 18, 'male', '猛男', 8000, )
dog1 = get_dog('小黑', '惡霸', 800, )
person1.get('person_attack')(person1, dog1)

結(jié)論:

• 通過上列代碼，我們將人的專屬攻擊方式，封裝在了人的類別內(nèi)，實(shí)現(xiàn)了人專屬的屬性和功能，當(dāng)人在調(diào)用自身類別，并傳入符合條件的參數(shù)時(shí)，就可以生成一個(gè)人（對象）特有的屬性（數(shù)據(jù)）和攻擊方式（功能）
• 同上，我們也可將狗的數(shù)據(jù)和攻擊方式封裝在狗特有的函數(shù)內(nèi)，當(dāng)我們生成多條狗的時(shí)候，每條狗也就有了，狗（對象）特有的屬性（數(shù)據(jù)）和攻擊方式（功能）

人狗大戰(zhàn)推導(dǎo)就是面對對象的核心思想：數(shù)據(jù)與功能的綁定??！

二、編程思想

引言:

•   面向?qū)ο笫且环N編程思想，用這種思想為指導(dǎo)設(shè)計(jì)的程序，把數(shù)據(jù)和對數(shù)據(jù)的操作封裝在一起組成類，通過類來創(chuàng)建對象，通過對象之間的交互來實(shí)現(xiàn)程序的功能。
  

•    面向?qū)ο缶幊淌且环N編程方式，此編程方式的落地需要使用 “類” 和 “對象” 來實(shí)現(xiàn)，所以，面向?qū)ο缶幊唐鋵?shí)就是對 “類” 和 “對象” 的使用
  

1、面向過程編程

• 面向過程即流程
  • 在以上所學(xué)習(xí)的編程中，我們都是在按照固定的流程解決問題，制定一個(gè)結(jié)果，在奔向結(jié)果的過程中編寫代碼，以達(dá)到我們所需要的結(jié)果
  • 需要例舉出每一步流程 隨著流程的深入 結(jié)果慢慢浮現(xiàn)
    

2、面向?qū)ο缶幊?/h2>

• 對象即容器，數(shù)據(jù)與功能的結(jié)合體 （python中一切皆對象）
  • 類似于開放式游戲，制定出游戲人物的（對象）
  • 該人物未來會如何發(fā)展，全看用戶如何控制，和我們程序員沒有關(guān)系
    • 類似于王者榮耀，玩家控制英雄走向
      

上述兩種編程思想沒有優(yōu)劣之分 需要結(jié)合實(shí)際需求而定
如果需求是注冊 登錄 人臉識別肯定面向過程更合適
如果需求是游戲人物肯定是面向?qū)ο蟾线m
實(shí)際編程兩種思想是彼此交融的 只不過占比不同

1.語法結(jié)構(gòu)

class 類名:
	'''代碼注釋'''
	對象公共的數(shù)據(jù)
	對象公共的功能

1.class是定義類的關(guān)鍵字
2.類名幾乎和變量名一致，使用的時(shí)候推薦類名的首字母大寫
3.數(shù)據(jù)：
	變量名與數(shù)據(jù)值的綁定
  功能：
	功能（方法）其實(shí)就是具有一定功能的函數(shù)

2.定義與調(diào)用

需求：

• 清華大學(xué)選課系統(tǒng)

'''	
類在定義階段就會執(zhí)行類函數(shù)體代碼
但類的函數(shù)體代碼外界無法直接調(diào)用
'''

1、定義類
class Student:
    # 對象公共的數(shù)據(jù)
    school_name = '清華大學(xué)'
    
    # 對象公共的功能
    def choice_course(self):
        print('學(xué)生選課功能') 

查看類的名稱空間:

• 在面向?qū)ο笾校惡蛯ο笤L問數(shù)據(jù)或者功能，可以統(tǒng)一采用句點(diǎn)符

print(Student.__dict__) 
# {'__module__': '__main__', 'school_name': '清華大學(xué)', 'choice_course': , '__dict__': , '__weakref__': , '__doc__': None}

print(Student.__dict__.get('school_name'))
# 清華大學(xué)

print(Student.__dict__ .get('choice_course'))
# 

類的調(diào)用:

• 類加括號就會產(chǎn)生對象，并且每調(diào)用一次就會產(chǎn)生一個(gè)全新的對象
• 變量名obj接收類名加括號之后的返回值(結(jié)果)

1、調(diào)用對象
    obj1 = Student()  
    # <__main__.Student object at 0x000001992C2759D0> 
    obj2 = Student()
    # <__main__.Student object at 0x000001992C278E50>
    obj3 = Student()
    # <__main__.Student object at 0x000001992C278E20>
'''
三個(gè)變量名的地址各不相同，產(chǎn)生三個(gè)對象
 '''

2、查看對象內(nèi)部數(shù)據(jù)
    print(obj1.__dict__,
        obj2.__dict__,
        obj3.__dict__)
    # {} {} {}
'''
三個(gè)對象各自內(nèi)部都為空
 '''

3、調(diào)用對象共同數(shù)據(jù)
    print(obj1.school_name)
    # 清華大學(xué)
    print(obj2.school_name)
    # 清華大學(xué)
    print(obj3.school_name)
    # 清華大學(xué)
'''
同一類產(chǎn)生的對象，都可使用類內(nèi)部公用數(shù)據(jù)值
'''

數(shù)據(jù)和功能可稱統(tǒng)稱為屬性：

• 數(shù)據(jù)>>>屬性名

• 功能>>>方法

3、對象獨(dú)有數(shù)據(jù)

? 在上述使用類產(chǎn)生對象時(shí)，我們可以看出產(chǎn)生的對象并沒有自己特有的數(shù)據(jù)，針對如何給對象手動添加獨(dú)有數(shù)據(jù)，python提供了多種方式，其中前4種方式主要為推導(dǎo)第五種方式而來，我們只需簡單了解即可，在日后我們重點(diǎn)使用的是第五種方式

第一種：

• 通過__ dict __ 加中括號的方式

obj1.__dict__['name'] = 'jason'
obj1.__dict__['age'] = 18
obj1.__dict__['hobby'] = 'study'

第二種：

• 將對象獨(dú)有的數(shù)據(jù)提前封裝成函數(shù)，在后續(xù)添加的時(shí)候，通過傳參的方式進(jìn)行添加

def init(obj,name,age,hobby)
    obj.__dict__['name'] = name
    obj.__dict__['age'] = age
    obj.__dict__['hobby'] = hobby
    
init(ojb1.'kangkang', 18, 'read')
init(ojb2, 'zhangzhang', 28, 'ball')

第三種：

• 將封裝數(shù)據(jù)的函數(shù)放在類的內(nèi)部，只有相同類的對象才有資格使用

class Student:
    # 對象公用的數(shù)據(jù)
    school_name = '清華大學(xué)'

    # 專門給學(xué)生添加獨(dú)有數(shù)據(jù)的功能
    def init(obj, name, age, hobby):
        obj.__dict__['name'] = name
        obj.__dict__['age'] = age
        obj.__dict__['hobby'] = hobby
        # 對象公共的功能
	 def choice_course(self):
         print('學(xué)生選課功能')
            
            
stu1 = Student()
Student.init(stu1, 'kangkang', 18 , 'read')
Student.init(stu2, 'zhangzhang', 28 , 'ball')

第四種：

• 將封裝獨(dú)有功能的函數(shù)名替換成__ init __ 這種方式，在我們給對象添加獨(dú)有功能時(shí)，可自動觸發(fā)

class Student:
    # 對象公用的數(shù)據(jù)
    school_name = '清華大學(xué)'

    # 專門給學(xué)生添加獨(dú)有數(shù)據(jù)的功能
    def __init__(obj, name, age, hobby):
        obj.__dict__['name'] = name
        obj.__dict__['age'] = age
        obj.__dict__['hobby'] = hobby
        # 對象公共的功能
	 def choice_course(self):
         print('學(xué)生選課功能')

stu1 = Student('kangkang', 18, 'read')
Stu2 = Student('zhangzhang', 28, 'ball')

第五種：

• 封裝獨(dú)有數(shù)據(jù)的函數(shù)體的第一個(gè)參數(shù)位置修改為self

• 在使用類產(chǎn)生對象時(shí)直接在類的括號內(nèi)填入獨(dú)有數(shù)據(jù)

• 這種方式是我們?nèi)蘸笫褂妙惍a(chǎn)生獨(dú)有數(shù)據(jù)對象的主要方式

class Student:
    # 對象公用的數(shù)據(jù)
    school_name = '清華大學(xué)'

    # 專門給學(xué)生添加獨(dú)有數(shù)據(jù)的功能
    def __init__(self, name, age, hobby):
        self.__dict__['name'] = name
        self.__dict__['age'] = age
        self.__dict__['hobby'] = hobby
        # 對象公共的功能
	 def choice_course(self):
         print('學(xué)生選課功能')

stu1 = Student('kangkang', 18, 'read')
stu1 = Student('zhangzhang', 18, 'ball')

4、對象獨(dú)有功能

? 上述學(xué)習(xí)了如何給相同類對象添加獨(dú)有數(shù)據(jù)的方式，下面我們要學(xué)習(xí)如何給對象添加獨(dú)有功能

思考：

• 1、直接將功能函數(shù)體代碼定義在全局名稱空間種，那么該功能函數(shù)就不對象獨(dú)有的功能
• 2、將功能函數(shù)體代碼放在類中，但是類中的函數(shù)體功能，只要是此類產(chǎn)生的對象都可調(diào)用

解決方法：

• 定義在類中的功能，默認(rèn)就是給類產(chǎn)生的對象使用的，只要是此類產(chǎn)生的對象都可以使用
• 需要在功能函數(shù)形參數(shù)內(nèi)填入self，之后只需要用類名’點(diǎn)‘函數(shù)名的方式，函數(shù)參數(shù)內(nèi)填入調(diào)用對象名，就可直接使用該功能

class Student:
    # 對象公用的數(shù)據(jù)
    school_name = '清華大學(xué)'

    # 專門給學(xué)生添加獨(dú)有數(shù)據(jù)的功能
    def __init__(self, name, age, hobby):
        self.__dict__['name'] = name
        self.__dict__['age'] = age
        self.__dict__['hobby'] = hobby
        # 對象公共的功能
	 def choice_course(self):
         print('學(xué)生選課功能')
            
stu1 = Student()
Student.choice_course(stu1)

5、補(bǔ)充知識

1、對象數(shù)據(jù)值修改

# 只需要使用對象‘點(diǎn)’的數(shù)據(jù)綁定的變量名的方式重新賦值即可
stu1.name = 'zhaozhao'

# 當(dāng)名字不存在的情況下，將直接新增數(shù)據(jù)
stu1.paw = 123

當(dāng)前標(biāo)題：Python基礎(chǔ)之面向?qū)ο螅?、面向?qū)ο笈c編程思想
網(wǎng)站鏈接：http://weahome.cn/article/dscgiop.html