面向对象

导引：

比如需要开发一个人狗大战的游戏，那么就需要对人和狗的角色进行设定：

人的角色设定，这显然是一个字典：

Alex={
    'name':'King',
    'Blood':100,
    'aggr':100,
    'sex':'None'
}

对狗的角色进行设定

Dog={
    'name':'哮天犬',
    'Blood':1000,
    'aggr':100,
    'kind':'Siberian husky'
}

但是在游戏中，显然不可能是一个人，那么如果要加人，怎么解决呢？继续复制一个人的信息？不对，可以利用函数，传参解决。

重新设定人的角色

def person(name,blood,aggr,sex):#将所有需要的参数都放在函数的参数里面
    person={
        'name':name,
        'Blood':blood,
        'aggr':aggr,
        'sex':sex
    }
    return person
Alex=person('alex',100,100,'None')#这里直接传参
print(Alex)


D:\anoconda\python.exe F:/python/python学习/人工智能/第一阶段day2/练习.py
{'name': 'alex', 'Blood': 100, 'aggr': 100, 'sex': 'None'}

Process finished with exit code 0

那么加人直接加参数就可以。

def person(name,blood,aggr,sex):#将所有需要的参数都放在函数的参数里面
    person={
        'name':name,
        'Blood':blood,
        'aggr':aggr,
        'sex':sex
    }
    return person
Alex=person('alex',100,100,'None')#这里直接传参
nezha=person('nezha',100,10,'Man')#这里直接传参,在原来Alex的基础上加上了哪吒
print(Alex)
print(nezha)


D:\anoconda\python.exe F:/python/python学习/人工智能/第一阶段day2/练习.py
{'name': 'alex', 'Blood': 100, 'aggr': 100, 'sex': 'None'}
{'name': 'nezha', 'Blood': 100, 'aggr': 10, 'sex': 'Man'}

Process finished with exit code 0

这样做的好处，代码精简、方便增加人物，方便修改，各种角色的设定更加规范。类似于，形成了设定角色的模子，可以按照这个模子的样式随意设定增加人物的数量。

对于狗的角色设定也是与此类似：

def dog(name,blood,aggr,kind):#将所有需要的参数都放在函数的参数里面
    person={
        'name':name,
        'Blood':blood,
        'aggr':aggr,
        'kind':kind
    }
    return dog

那么假设设定好角色以后：整体代码：

def person(name,blood,aggr,sex):#将所有需要的参数都放在函数的参数里面
    person={
        'name':name,
        'Blood':blood,
        'aggr':aggr,
        'sex':sex
    }
    return person
Alex=person('alex',100,100,'None')#这里直接传参
nezha=person('nezha',100,10,'Man')#这里直接传参,在原来Alex的基础上加上了哪吒
print(Alex)
print(nezha)


def dog(name,blood,aggr,kind):#将所有需要的参数都放在函数的参数里面
    person={
        'name':name,
        'Blood':blood,
        'aggr':aggr,
        'kind':kind
    }
    return dog
xiaotianquan=dog('哮天犬',1000,100,'Siberian husky')

通过以上对人和狗的定义：dog和person函数都是定义了一类事物，直到调用函数，赋值了以后才真的有一个实实在在的人或狗。

然后开始玩游戏

def person(name,blood,aggr,sex):#将所有需要的参数都放在函数的参数里面
    person={
        'name':name,
        'Blood':blood,
        'aggr':aggr,
        'sex':sex
    }
    return person



def dog(name,blood,aggr,kind):#将所有需要的参数都放在函数的参数里面
    dog={
        'name':name,
        'Blood':blood,
        'aggr':aggr,
        'kind':kind
    }
    return dog


#开始对战：
#人打狗
def attack(person,dog):
    dog['Blood']=dog['Blood']-person['aggr']
    print('%s被打了，掉了%s点血'%(dog['name'],person['aggr']))

#狗咬人
def bite(dog,person):
    person['Blood']=person['Blood']-dog['aggr']
    print('%s被咬了，掉了%s点血'%(person['name'],dog['aggr']))

Alex = person('alex', 100, 100, 'None')  # 这里直接传参
nezha = person('nezha', 100, 10, 'Man')  # 这里直接传参,在原来Alex的基础上加上了哪吒
xiaotianquan = dog('哮天犬', 1000, 100, 'Siberian husky')
attack(Alex,xiaotianquan)
print(xiaotianquan)#这里可以看到哮天犬的血少了

D:\anoconda\python.exe F:/python/python学习/人工智能/第一阶段day2/练习.py
哮天犬被打了，掉了100点血
{'name': '哮天犬', 'Blood': 900, 'aggr': 100, 'kind': 'Siberian husky'}

Process finished with exit code 0

出现逻辑错误

def person(name,blood,aggr,sex):#将所有需要的参数都放在函数的参数里面
    person={
        'name':name,
        'Blood':blood,
        'aggr':aggr,
        'sex':sex
    }
    return person

def dog(name,blood,aggr,kind):#将所有需要的参数都放在函数的参数里面
    dog={
        'name':name,
        'Blood':blood,
        'aggr':aggr,
        'kind':kind
    }
    return dog

#开始对战：
#人打狗
def attack(person, dog):
    dog['Blood'] = dog['Blood'] - person['aggr']
    print('%s被打了，掉了%s点血' % (dog['name'], person['aggr']))

#狗咬人
def bite(dog, person):
    person['Blood'] = person['Blood'] - dog['aggr']
    print('%s被咬了，掉了%s点血' % (person['name'], dog['aggr']))

Alex = person('alex', 100, 100, 'None')  # 这里直接传参
nezha = person('nezha', 100, 10, 'Man')  # 这里直接传参,在原来Alex的基础上加上了哪吒
xiaotianquan = dog('哮天犬', 1000, 100, 'Siberian husky')
attack(Alex,xiaotianquan)
bite(Alex,xiaotianquan)#但是这样写代码也能够执行，出现明显的逻辑错误，如何避免？

考虑利用闭包知识

第一步，封闭函数

def person(name,blood,aggr,sex):#将所有需要的参数都放在函数的参数里面
    person={
        'name':name,
        'Blood':blood,
        'aggr':aggr,
        'sex':sex
    }
    def attack(person, dog):
        dog['Blood'] = dog['Blood'] - person['aggr']
        print('%s被打了，掉了%s点血' % (dog['name'], person['aggr']))
    return person

def dog(name,blood,aggr,kind):#将所有需要的参数都放在函数的参数里面
    dog={
        'name':name,
        'Blood':blood,
        'aggr':aggr,
        'kind':kind
    }
    def bite(dog, person):
        person['Blood'] = person['Blood'] - dog['aggr']
        print('%s被咬了，掉了%s点血' % (person['name'], dog['aggr']))
    return dog

Alex = person('alex', 100, 100, 'None')  # 这里直接传参
nezha = person('nezha', 100, 10, 'Man')  # 这里直接传参,在原来Alex的基础上加上了哪吒
xiaotianquan = dog('哮天犬', 1000, 100, 'Siberian husky')

第二步，对代码进行修正

def person(name,blood,aggr,sex):#将所有需要的参数都放在函数的参数里面
    person={
        'name':name,
        'Blood':blood,
        'aggr':aggr,
        'sex':sex
    }
    # def attack(person, dog):删除person元素，变成下面的类型
    def attack(dog):
        dog['Blood'] = dog['Blood'] - person['aggr']
        print('%s被打了，掉了%s点血' % (dog['name'], person['aggr']))
    person['attack']=attack#等价于在第6行的sex后面加上'attack'：attack
    return person

def dog(name,blood,aggr,kind):#将所有需要的参数都放在函数的参数里面
    dog={
        'name':name,
        'Blood':blood,
        'aggr':aggr,
        'kind':kind
    }
    def bite(person):#同person的解释
        person['Blood'] = person['Blood'] - dog['aggr']
        print('%s被咬了，掉了%s点血' % (person['name'], dog['aggr']))
    dog['bite']=bite
    return dog

Alex = person('alex', 100, 100, 'None')  # 这里直接传参
nezha = person('nezha', 100, 10, 'Man')  # 这里直接传参,在原来Alex的基础上加上了哪吒
xiaotianquan = dog('哮天犬', 1000, 100, 'Siberian husky')
#开始玩游戏
#Alex打xiaotianquan
Alex['attack'](xiaotianquan)
#哮天犬咬哪吒
xiaotianquan['bite'](nezha)

以上就是一个完整的代码

以前的代码都是一步步直接面向结果，但是上面就是一个面向对象的编程。

面向对象的编程

所谓模子就是类，能够知道设定对象的各种属性；
本例中的Alex,nezha,xiaotianquan 就是对象，有具体的值。

在面向对象的编程中是先有类才有对象，对象是类的具体体现。