Python全栈（第一期）Day22

今日主要内容：
面向对象的引入
初始面向对象
面向对象的交互
实践

一，面向对象引入

1，编程方式

面向过程编程
面向函数编程
面向对象编程

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')
alex = Person('狗剩儿', 100, 1, '不详')

print(jin)
jin['bite'](alex)
# alex['attack'](jin)
# Dog函数和Person函数 都是定义了一类事物
# 直到调用了函数，赋值了之后才真的有了一个实实在在的人或狗


# 面向对象编程
# 所谓模子 就是 类 抽象的 我能知道有什么属性 有什么技能 但不能知道属性具体的值

输出结果：
{‘name’: ‘金老板’, ‘blood’: 1000, ‘aggr’: 100, ‘kind’: ‘teddy’, ‘bite’: <function Dog..bite at 0x0000026D029F9C80>}
狗剩儿被咬了，掉了100的血

二，初始面向对象

1，基本模型

# 自定义类
# def 函数名():
#     pass

class 类名:
    属性 = 'a'

print(类名.属性)
# 类名的作用 就是操作属性 查看属性

输出结果：
a

2，人狗大战改写（人）

class Person:                   # 类名，这个地方不接收变量

    country = 'China'           # 创造了一个只要是这个类就一定有的属性
                                # 类属性 静态属性

    def __init__(self, *args):  # 初始化方法，self是对象，是一个必须传的参数
                                # self就是一个可以存储很多属性的大字典
        self.name = args[0]     # 往字典里添加属性的方式发生了一些变化
        self.hp = args[1]
        self.aggr = args[2]
        self.sex = args[3]

    def walk(self, n):  # 这里的self，不一定非得是self

        print('%s开启疾走,共行%s进步！' % (self.name, n))


alex = Person('狗剩儿', 100, 1, '不详')  # 类名还可以实例化对象，alex对象   # 实例化
print(alex.__dict__)  # 查看所有属性
print(alex.name)      # 查看属性值


# Person.walk(alex，5)  这两行程序等价
alex.walk(5)


print('000000000000000000000000000000000')

# 可以更改
print(Person.__dict__['country'])
alex.__dict__['country'] = '印度'


print(alex.__dict__['name'])
alex.__dict__['name'] = '二哥'
print(alex.__dict__)


# 可以添加（字典操作）
alex.age = 83
print(alex.__dict__)

输出结果：
{‘name’: ‘狗剩儿’, ‘hp’: 100, ‘aggr’: 1, ‘sex’: ‘不详’}
狗剩儿
狗剩儿开启疾走,共行5进步！
000000000000000000000000000000000
China
狗剩儿
{‘name’: ‘二哥’, ‘hp’: 100, ‘aggr’: 1, ‘sex’: ‘不详’, ‘country’: ‘印度’}
{‘name’: ‘二哥’, ‘hp’: 100, ‘aggr’: 1, ‘sex’: ‘不详’, ‘country’: ‘印度’, ‘age’: 83}

3，知识点总结

# 对象 = 类名()
# 过程：
    # 类名() 首先 会创造出一个对象，创建了一个self变量
    # 调用init方法，类名括号里的参数会被这里接收
    # 执行init方法
    # 返回self
# 对象能做的事：
    # 查看属性
    # 调用方法
    # __dict__ 对于对象的增删改查操作都可以通过字典的语法进行！！
# 类名能做的事：
    # 实例化
    # 调用方法 : 只不过要自己传递self参数。
    # 调用类中的属性,也就是调用静态属性。
    # __dict__ 对于类中的名字只能看！不能操作！不能操作！不能操作！

三，面向对象的交互

# 类名开头是大写！
class Dog:
    def __init__(self, name, blood, aggr, kind):
        self.name = name
        self.hp = blood
        self.aggr = aggr
        self.kind = kind
    def bite(self, person):
        # 狗咬人，人掉血
        person.blood -= self.aggr

class Person:
    def __init__(self, name, blood, aggr, sex):
        self.name = name
        self.blood = blood
        self.aggr = aggr
        self.sex = sex
    def attack(self, dog):
        dog.hp -= self.aggr
        if dog.hp <= 0:
            print('%s打了%s,%s被打死了，扑街~~~' % (self.name, dog.name, dog.name))
        else:
            print('%s打了%s,掉了%s血' % (self.name, dog.name, self.aggr))


jin = Dog('金老板', 100, 20, 'teddy')
alex = Person('alex', 999, 998, '不详')


jin.bite(alex)   # Dog.bite(jin,alex)
print(alex.blood)

alex.attack(jin)  # Person.attack(alex,jin)
print(jin.hp)

输出结果：
979
alex打了金老板,金老板被打死了，扑街~~~
-898

四，实战部分

1，练习题一

# 练习一：在终端输出如下信息
#
# 小明，10岁，男，上山去砍柴
# 小明，10岁，男，开车去东北
# 小明，10岁，男，最爱大保健
# 老李，90岁，男，上山去砍柴
# 老李，90岁，男，开车去东北
# 老李，90岁，男，最爱大保健
# 老张…

# 以下两种情况考虑面向对象：
# 1，当有几个函数，需要反反复复传入相同的参数的时候，就可以考虑面向对象
# 2，非常明显的处理一类事物，这些事物都有相似的属性和功能

class Person:
    def __init__(self, name, age, sex):
        self.name = name
        self.age = age
        self.sex = sex

    def shangshan(self):
        print('%s,%s岁,%s,上山去砍柴' % (self.name,self.age,self.sex))

    def drive(self):
        print('%s,%s岁,%s,开车去东北' % (self.name,self.age,self.sex))

    def favor(self):
        print('%s,%s岁,%s,最爱大保健' % (self.name,self.age,self.sex))

ming = Person('小明', '10', '男')
ming.shangshan()
ming.drive()
ming.favor()
zhang = Person('老张', '90', '男')
zhang.shangshan()
zhang.drive()
zhang.favor()

输出结果：
小明,10岁,男,上山去砍柴
小明,10岁,男,开车去东北
小明,10岁,男,最爱大保健
老张,90岁,男,上山去砍柴
老张,90岁,男,开车去东北
老张,90岁,男,最爱大保健

2，练习题二

# 求周长和面积
from math import pi
class Circle:
    def __init__(self, r):
        self.r = r
    def area(self):
        return pi*(self.r**2)
    def perimeter(self):
        return 2*pi*self.r

c1 = Circle(6)
print(c1.area())
print(c1.perimeter())

输出结果：
113.09733552923255
37.69911184307752