标签：__ name power 19 hp dog person 面向对象编程

1. 面向对象编程引入

1.0 分析属性

做一款人狗大战的小游戏

 

人的属性：

　　人的姓名

　　人的性别

　　人的年龄

　　人的生命值

　　人的攻击力

 

狗的属性：

　　狗的名字

　　狗的年龄

　　狗的生命值

　　狗的攻击力

　　狗的品种

1.1 方式一：面条版　　使用字典定义属性

# 定义人和狗的参数
dog1 = {
    'name': '小黑',
    'age': 3,
    'hp': 100,
    'power': 30,
    'breed': '土'
}

dog2 = {
    'name': '旺财',
    'age': 10,
    'hp': 100,
    'power': 20,
    'breed': '洋'
}

person1 = {
    'name': 'kevin',
    'gender': 'male',
    'age': 32,
    'hp': 1000,
    'power': 40,
}

person2 = {
    'name': 'leo',
    'gender': 'male',
    'age': 37,
    'hp': 1000,
    'power': 30
}

print(f"{person2['name']}这个人打了狗{dog1['name']},狗掉了{person2['power']}hp,还剩{dog1['hp'] - person2['power']}hp")
# leo这个人打了狗小黑,狗掉了30hp,还剩70hp

 1.2 方式二：函数版　　封装成函数，减少代码冗余

解耦合：将某部分拆成小的部分，又将小的部分合并在一起

将人的属性、狗的属性，人打狗、狗咬人都定义函数

def init_person(name, gender, age, hp, power):
    info1 = {"name": name, "gender": gender, "age": age, "hp": hp, "power": power}
    return info1

def init_dog(name, age, hp, power, breed):
    info2 = {"name": name, "age": age, "hp": hp, "power": power, "breed": breed}
    return info2

def dog_attack_person(dog, person):
    """
    狗咬人函数
    :param dog:
    :param person:
    :return:
    """
    person["hp"] -= dog["power"]  # 人剩余的hp等于人的hp减狗的攻击力
    print(f"狗{dog['name']}咬了人{person['name']},人{person['name']}掉了{dog['power']}hp,还剩{person['hp']}hp")

def person_attack_dog(person, dog):
    """
    人打狗函数
    :param person:
    :param dog:
    :return:
    """
    dog["hp"] -= person["power"]
    print(
        f"{person['name']}这个人打了狗{dog['name']},狗掉了{person['power']}hp,还剩{dog['hp']}hp")

person1 = init_person(name='kevin', gender='male', age=32, hp=1000, power=40)
person2 = init_person(name='leo', gender='male', age=37, hp=1000, power=30)

dog1 = init_dog(name='小黑', age=3, hp=1000, power=30, breed='土')
dog2 = init_dog(name='旺财', age=4, hp=1000, power=20, breed='洋')

# 小黑咬了kevin
dog_attack_person(dog=dog1, person=person1)  # 狗小黑咬了人kevin,人kevin掉了30hp,还剩970hp

# 小黑咬了leo 
dog_attack_person(dog=dog1, person=person2)  # 狗小黑咬了人leo,人leo掉了30hp,还剩970hp

1.3 方式三：聚合版

只有人能调用人打狗函数，将人的属性、人打狗两个函数定义成一个函数

只有狗能调用狗咬人函数，将狗的属性，狗咬人两个函数定义成一个函数

将动作函数放在字典中

def init_person(name, gender, age, hp, power):
    def person_attack_dog(person, dog):
        dog["hp"] -= person["power"]
        print(f"{person['name']}这个人打了狗{dog['name']},狗掉了{person['power']}hp,还剩{dog['hp']}hp")

    info1 = {"name": name, "gender": gender, "age": age,
             "hp": hp, "power": power,
             'person_attack_dog': person_attack_dog}
    return info1

def init_dog(name, age, hp, power, breed):
    def dog_attack_person(dog, person):
        person["hp"] -= dog["power"]  # 人剩余的hp等于人的hp减狗的攻击力
        print(f"狗{dog['name']}咬了人{person['name']},人{person['name']}掉了{dog['power']}hp,还剩{person['hp']}hp")

    info2 = {"name": name, "age": age, "hp": hp,
             "power": power, "breed": breed,
             'dog_attack_person': dog_attack_person}
    return info2

person1 = init_person(name='kevin', gender='male', age=32, hp=1000, power=40)
person2 = init_person(name='leo', gender='male', age=37, hp=1000, power=30)

dog1 = init_dog(name='小黑', age=3, hp=1000, power=30, breed='土')
dog2 = init_dog(name='旺财', age=4, hp=1000, power=20, breed='洋')

# 小黑咬了leo
dog1['dog_attack_person'](dog1, person2)  # 狗小黑咬了人leo,人leo掉了30hp,还剩970hp

# kevin打了小黑
person1['person_attack_dog'](person1, dog1)  # kevin这个人打了狗小黑,狗掉了40hp,还剩960hp

1.4 总结

以上操作就是将数据与功能进行绑定

将数据与功能整合到一起的思想就是面向对象编程的思想

2. 面向过程与面向对象的概念

2.1 面向过程

过程的含义是将程序流程化，过程是流水线，按步骤解决问题

2.2 面向对象

面向对象的核心在于对象两个字，对象的含义是一个整体

对象就是容器，用来盛放数据和功能

面向对象的优点：解决了程序的扩展性，对某一个对象单独修改，会立刻反映到整个体系中

3. 类与对象

3.1 类的概念

类就是类别、种类的意思，是面向对象分析和设计的基石

如果多个对象有相似的数据与功能，那么该多个对象就属于同一个类   类的优点： 同一类对象相同的数据与功能存放到类里，而无需每个对象都重复存一份，这样每个对象里只需存自己独有的数据即可，极大地节省了空间。   对象是用来存放数据与功能的容器，类则是用来存放同一类多个对象相同的数据与功能的容器

 

类和对象哪个先产生？

 对于程序来说先有类才能有对象，对于人类的逻辑来说先有对象才能抽象出某一个类

 3.2 定义类的语法

class 类名(参数):
    代码体

# 类名建议使用大驼峰体
# 参数的括号可以不写
# 类中可以有任意python代码，这些代码在类定义阶段便会执行
# 因为会产生新的名称空间，用来存放类的变量名与函数名，可以通过类名.__dict__查看
# 点是访问属性的语法，类中定义的名字，都是类的属性

类的定义与使用举例

class Student:
    school = 'California'  # 定义学生类的数据
    grade = 3

    def reading(self):  # 定义学生类的功能
        print('读书')

    def rest(self):
        print('休息')


# 1.定义类之后，如何产生对象
stu1 = Student()  # <__main__.Student object at 0x000001FEAD21A110>
print(stu1)

# 2.查看对象的内置方法和属性
# print(dir(stu1))
# ['__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'exercise', 'grade', 'reading', 'school']

# 3.查看对象的名称空间
print(stu1.__dict__)  # {}
stu1.__dict__.update({'school': 'MIT'})
print(stu1.__dict__)  # {'school': 'MIT'}

# 4.调用对象中的属性
print(stu1.school)  # MIT
print(stu1.grade)  # 3
stu1.reading()  # 读书
stu1.rest()  # 休息

3.3 类的实例化---产生对象

调用类的过程称为将类实例化
拿到的返回值就是程序中的对象，或称为一个实例

 

 

3.4 修改对象的属性

（1）通过类的名称空间修改对象的属性

 举例：初始化对象的独有属性

class Student:
    name = ''
    gender = ''
    grade = None
    school = 'California'  # 定义学生类的数据---数据属性

    def reading(self):  # 定义学生类的功能---功能属性
        print('读书')

    def rest(self):
        print('休息')

stu1 = Student()
print(stu1.__dict__)  # {}
stu1.__dict__.update({'name': 'clinton', 'gender': 'male', 'grade':1})
print(stu1.__dict__)  # {'name': 'clinton', 'gender': 'male', 'grade': 1}
print(stu1.school)  # California
print(stu1.grade)  # 1

（2）通过函数来操作类的名称空间修改对象的属性---封装成函数

方法一：

 

标签：__,name,power,19,hp,dog,person,面向对象编程
From： https://www.cnblogs.com/hbutmeng/p/18357487