day22.面向对象初识

1.面向对象引入　　　　　　　　　　　　　　　　　　

先来创建一个小游戏：人狗大战

# 定义一个狗
def Gog(name,blood,aggr,kind):
    dog = {
        'name':name,
        'blood':blood,
        'aggr':aggr,
        'kind':kind
    }
    return dog

# 定义一个人
def Person(name,blood,aggr,kind):
    person ={
        'name':name,
        'blood':blood,
        'aggr':aggr,
        'kind':kind
    }
    return person

# 定义一个人的技能 打
def attack(person,dog):
    dog['blood'] -= person['aggr']
    print('{}被打了，掉了{}的血'.format(dog['name'],person['aggr']))

# 定义一个狗的技能 咬
def bite(dog,person):
    person['blood'] -= dog['aggr']
    print('{}被咬了，掉了{}的血'.format(person['name'],dog['aggr']))

yellow = Gog('dahuang',1000,100,'jinmao')
alex = Person('alex',800,50,'战士')

bite(yellow,alex)
#  "alex被咬了，掉了100的血"
bite(alex,yellow)
#  "dahuang被咬了，掉了50的血"   这里就出现了一些问题，狗咬狗

以上方法会出现 “人咬狗”的错误。衍生了人狗大战第二版

# 定义一个狗
def Gog(name,blood,aggr,kind):
    dog = {
        'name':name,
        'blood':blood,
        'aggr':aggr,
        'kind':kind
    }
    def bite(person):
        person['blood'] -= dog['aggr']
        print('{}被咬了，掉了{}的血'.format(person['name'], dog['aggr']))
    dog['bite'] = bite  # 将狗的技能作为一个字典参数加进来
    return dog

# 定义一个人
def Person(name,blood,aggr,kind):
    person ={
        'name':name,
        'blood':blood,
        'aggr':aggr,
        'kind':kind
    }
    def attack(dog):
        dog['blood'] -= person['aggr']
        print('{}被打了，掉了{}的血'.format(dog['name'], person['aggr']))
    person['attack'] = attack   # 将人的打技能作为字典参数传进来
    return person

yellow = Gog('dahuang',1000,100,'jinmao')
alex = Person('alex',800,50,'战士')

print(yellow) # 在狗，大黄内自带一个函数，需要传参：被咬的人
# {'name': 'dahuang', ...'bite': <function Gog.<locals>.bite at 0x0000027FAED2ABF8>}
yellow['bite'](alex)
# 给大黄的咬的技能函数加入一个参数人，一样可以得到结果
# alex被咬了，掉了100的血

2.面向对象编程理解　　　　　　　　　　　　　　　　

1. 所谓模子 就是类 抽象的，例如上面的函数人。例如人类
2. 但是根据 模子刻出来的就是对象，例如 根据狗刻出来的yellow(大黄)。人类中的科比，姚明为对象
3. 先有类再有对象

3.面向对象初识　　　　　　　　　　　　　　　　　　　

# 自定义类
class Person:                   # 类名
    country = 'China'           # 创建一个类属性(静态属性)，

    def __init__(self,*args):   # self 类似于一个可以存储很多属性的字典 (初始化方法，self是必须传参数)
        # print(self.__dict__)    # 此处可看到self是一个空字典
        self.name = args[0]     # name,hp,aggr,sex类似于在字典里放置属性
        self.hp = args[1]
        self.aggr = args[2]
        self.sex = args[3]
        print(self.__dict__)    # 此处可看到字典多了key,value
        # print(id(self))         # 内存地址与 'alex' 内存地址一样
    def work(self,n):             # self 是一个必要的任意参数，一般叫self。 (函数写在类中叫方法，一般必须传第一个self参数，后面其他参数)
        print('{}走走走,走了{}步'.format(self.name,n))


alex = Person('二狗子',100,50,'男') #alex对象 实例化。 执行类 + 括号就是在调用__init__(self)方法
print(alex.__dict__)            # 此处
# print(id(alex))
Person.work(alex,5)               # 调用方法 类名.方法名(对象名)
alex.work(10)                     # 等价于 Person.work(alex)
print(Person.country)

alex.__dict__['name'] = '中华田园犬'
print(alex.name)
alex.name = '土狗'
print(alex.__dict__['name'])    # alex.name == alex.__dict__['name'] 增删

# 类的属性是不可以进行修改的
# 对象可以做的事：
    # 1.查看属性(alex.name)，
    # 2.调用方法(alex.work())
    # 3.对于对象的增删改查可以通过__dict__方法进行或者 对象.属性

# 类名可以做的事：
    # 1.实例化对象
    # 2.调用方法，需要自己传递self参数
    # 3.调用类属性，静态属性
    # 4.__dict__对于类中的属性等只能看不能操作
####################
{'name': '二狗子', 'hp': 100, 'aggr': 50, 'sex': '男'}
{'name': '二狗子', 'hp': 100, 'aggr': 50, 'sex': '男'}
二狗子走走走,走了5步
二狗子走走走,走了10步
China
中华田园犬
土狗

4.面向对象练习　　　　　　　　　　　　　

4.1 人狗大战面向对象版

class Dog:
    def __init__(self,name,blood,aggr,kind):
        self.na = name
        self.hp = blood
        self.gong = aggr
        self.kin = kind
    def bite(self,person):
        # 狗咬人，人掉血
        person.hp -= self.gong
        if person.hp <= 0:
            print('{}咬了{}，{}被咬死了'.format(self.na,person.na,person.na))
        else:
            print('{}咬了{}，掉了{}血'.format(self.na,person.na,self.gong))

class Person:
    def __init__(self,name,blood,aggr,sex):
        self.na = name
        self.hp = blood
        self.gong = aggr
        self.se = sex
    def attrck(self,ddog):
        # 人打狗，狗掉血
        ddog.hp -= self.gong
        if ddog.hp <= 0:
            print('{}打了{}，{}被打死了'.format(self.na,ddog.na,ddog.na))
        else:
            print('{}打了{}，掉了{}血'.format(self.na,ddog.na,self.gong))

dijia = Person('奥特曼',500,50,'man')
yellow_dog = Dog('大黄',300,20,'teddy')

yellow_dog.bite(dijia)
dijia.attrck(yellow_dog)

"""
大黄咬了奥特曼，掉了20血
奥特曼打了大黄，掉了50血

4.2 圆的面积和周长

class circle:
    def __init__(self,banjin):
        self.bj = banjin
    def zhouchang(self):
        return self.bj * 2 * 3.14
    def mianji(self):
        return self.bj ** 2 * 3.14

ab = circle(2)
print(ab.zhouchang())
print(ab.mianji())

小结：

1. 当有几个函数需要反复传入相同参数的时候，可以考虑使用面向对象
2. 非常明显的处理一类事物，这些食物具有相同的属性和功能
3. 参数都是对象的属性