面向对象

面向对象前戏

编写代码简单的实现人打狗狗咬人的小游戏：
小潮走在路上被旺财咬了，人狗大战一触即发

1.使用字典

"""推导步骤1:代码定义出人和狗"""
person_dict = {
    'name': '小潮',
    'age': 17,
    'gender':'female',
    'hobby':'吃饭',
    'attack_val': 10000,
    'life_val':1000,
}
dog_dict = {
    'name': '旺财',
    'type': '柴犬',
    'attack_val': 10,
    'life_val': 100,
}

但是这样还不够，如果有一天小潮的妹妹小澪走在路上，窜出一只狗：小黑！！，现在又要求你写代码：

person_dict = {
    'name': '小澪',
    'age': 17,
    'gender':'female',
    'hobby':'游泳',
    'attack_val': 5,
    'life_val':200,
}
dog_dict = {
    'name': '小黑',
    'type': '哈士奇',
    'attack_val': 10,
    'life_val': 100,
}

接着写下去要累死了，所以我们使用函数！

2.使用函数

"""推导步骤2:将产生人和狗的字典封装成函数"""
def create_person(name,age,gender,hobby,attack_val,life_val):
    person = {
        'name': name,
        'age': age,
        'gender': gender,
        'hobby': hobby,
        'attack_val': attack_val,
        'life_val': life_val,
    }
    return person
p1 = create_person('小澪', 17, 'female', '游泳', 5, 200)  # 创建小澪

def create_dog(name,type,attack_val,life_val):
    person = {
        'name': name,
        'type': type,
        'attack_val': attack_val,
        'life_val': life_val,
    }
    return person

d1 = create_dog('小黑', '哈士奇', 10, 100)  # 创建小黑（狗狗）

3.创建攻击函数

创建简单的攻击函数，我们希望狗可以调用狗的攻击函数，人可以调用人的攻击函数。

def person_attack(person, dog): # 传入一个人的字典 和 一个狗的字典
    dog_life = dog.get('life_val') - person.get('attack_val')  # 生命值减去攻击力
    dog['life_val'] = dog_life
    print(f'''{person.get("name")}用拳头锤了{dog.get("name")}一拳,效果拔群!!
造成了{person.get("attack_val")}点伤害, {dog.get("name")}剩余HP={dog_life}''')

person_attack(p1,d1)  # 调用两次让小澪锤小黑两拳
person_attack(p1,d1)

确实可以攻击了，但是还有一个问题，这个函数是一个全局的函数，实际上他并不属于谁，任何人都可以调用。而我们希望让这个攻击函数和小澪本身建立联系，需要显式的告诉大家，这个函数属于某个人。即人的功能函数属于人，只有人才能调用，其他对象比如狗无法调用。

4.封装攻击函数和字典

"""推导步骤3:将产生人和狗的字典封装成函数并封装人和狗的攻击函数"""
def create_person(name, age, gender, hobby, attack_val, life_val):
    
    def person_attack(person, dog):  # 1. 人的攻击函数
        dog_life = dog.get('life_val') - person.get('attack_val')  
        dog['life_val'] = dog_life
        print(f'''{person.get("name")}锤了{dog.get("name")}一拳,效果拔群!!
    造成了{person.get("attack_val")}点伤害, {dog.get("name")}剩余HP={dog_life}''')

    person = {
        'name': name,
        'age': age,
        'gender': gender,
        'hobby': hobby,
        'attack_val': attack_val,
        'life_val': life_val,
        'person_attack': person_attack,  # 2. 放到这里啦
    }
    return person

如果person字典代表一个人的话，
那么person_attack这个方法只能通过人来调用，外部的
通过这个函数，我们还可以创建p2:小潮，让小潮调用人类的攻击方法，小潮攻击力100,一拳就让小黑寄了。

是不是就很方便了，其实这里就体现了面向对象的核心思想：将数据值和功能绑定。
什么是对象？对象就是数据值和功能的结合体。

编程思想

1.面向过程编程
	过程即流程 面向过程就是按照固定的流程解决问题
         注册功能 登录功能 转账功能
       需要列举出每一步的流程 并且随着步骤的深入 问题的解决越来越简单
    	ps:提出问题 然后制定出该问题的解决方案

2.面向对象编程
	对象即容器 数据与功能的结合体  (python中一切皆对象)
    	eg:游戏人物
   		亚索 劫 盲僧
       面向对象编程有点类似于造物主的感觉 我们只需要造出一个个对象
    	至于该对象将来会如何发展跟程序员没关系 也无法控制
        对象其实就是一个'容器' 将数据与功能整合到一起
         只要是符合上述描述的事物，都可以称之为是对象！！！
3.python面向对象
python针对面向对象编程提供了专门的语法 编写更精简
 
"""
上述两种编程思想没有优劣之分 需要结合实际需求而定
	如果需求是注册 登录 人脸识别肯定面向过程更合适
	如果需求是游戏人物肯定是面向对象更合适
实际编程两种思想是彼此交融的 只不过占比不同
"""

面向对象之类与对象

对象:数据与功能的结合体				对象才是核心
类:即类别、种类 相当于诸多对象的公有特征		类主要就是为了节省代码
"""
一个人					对象
一群人					人类(所有人相同的特征)

一条狗					对象
一群狗					犬类(所有狗相同的特征)
"""
现实中一般是先有对象再有类
比如出现了一种新的病毒，肯定是有人感染了，我们才会发现。然后才会去总结这个病毒属于什么类型的。、
程序中如果想要产生对象 必须要先定义出类
这个描述是具体的编程过程，后文会讲。

讲道理，对象和类应该是同时产生的。只要对象存在，必然能从对象中总结出对象的特征与功能。即使只有一个对象，那也可以说你是这个类的唯一实例。

类仅仅是为了描述对象公共的特征 黑人、白人、黄种人有差异，但都是人类。
类只能描述出公共的特征，不同的特征应该由对象自己描述。如何描述？从类获得公共特征之后？如何添加新的特征？

python中类和对象

请从抽象层面，回到现实的编程过程中= =，如何在python中创建类和对象？

类的语法结构

class 类名:
  '''代码注释'''
       对象公共的数据
       对象公共的功能
	   
1.class是定义类的关键字
2.类名的命名与变量名几乎一致 推荐类名的'首字母大写'用于区分
3.数据:变量名与数据值的绑定 功能(方法)其实就是函数

类的定义阶段

'''类体代码无需调用就会执行 产生类的名称空间'''
类在定义阶段就会执行类体代码 不需要调用！！ 跟函数不同。
函数产生局部名称空间 类会产生一个类的名称空间 外界无法直接调用

class Person():
    name = 'miku'
    print(f'{name},你好')  # 无需调用就会执行Person类中的print函数喔

print(name) # 无法使用类中的name，这说明类确实会产生名称空间
            # NameError: name 'name' is not defined

查看名称空间

dict

可以用双下dict来查看类或对象的名称空间

class Student:
    # 对象公共的数据
    student_name = '小澪'

    # 对象公共的功能
    def choice_course(self):
        print('选课功能')

# 1.查看类的名称空间
print(Student.__dict__)  # 返回一个看起来是字典的东西 实际不是哦  只是用字典的方式展示给你看 
print(type(Student.__dict__))  # <class 'mappingproxy'>  # 用起来还是当做字典用 使用get方法

# 2.获取类中的属性和方法
print(Student.__dict__.get('student_name'))  # 小澪
print(Student.__dict__.get('choice_course'))  # <function Student.choice_course at 0x0000026E014360D0>

获取类中的属性和方法

句点符

class Student:
    # 对象公共的数据
    student_name = '小澪'

    # 对象公共的功能
    def choice_course(self):
        print('选课功能')

'''在面向对象中 类和对象访问数据或者功能 可以统一采用句点符'''
print(Student.student_name)  # 小澪
print(Student.choice_course)  # <function Student.choice_course at 0x000001CD875260D0>

双下dict字典取值

class Student:
    # 对象公共的数据
    student_name = '小澪'

    # 对象公共的功能
    def choice_course(self):
        print('选课功能')

print(Student.__dict__.get('student_name'))  # 小澪
print(Student.__dict__.get('choice_course'))  # <function Student.choice_course at 0x0000026E014360D0>

类的调用

类的调用也是像函数，加圆括号。类的调用会产生对象。

class Student:
    # 对象公共的数据
    student_name = '小澪'

    # 对象公共的功能
    def choice_course(self):
        print('选课功能')

# 1.每执行一次都会产生一个全新的对象
obj1 = Student()
obj2 = Student()
obj3 = Student()
print(obj1 == obj2)  # False
print(obj1 is obj2)  # False

空对象

由类产生的对象，他的内部没有名字，但其可以使用类中的属性和方法。

class Student:
    # 对象公共的数据
    student_name = '小澪'

    # 对象公共的功能
    def choice_course(self):
        print('选课功能')

obj1 = Student()
# 1.里面一个名字也没有
print(obj1.__dict__)  # {}

# 2.但是对象可以调用类中的名字
obj1.choice_course()  #  选课功能
print(obj1.student_name)  # 小澪

# 3.当类中的属性/功能改变，所有由类产生的所有对象都会改变
obj2 = Student  # 再产生一个对象
print(obj2.student_name)  # 小澪
Student.student_name = '小潮'
print(obj1.student_name)  # 小潮
print(obj2.student_name)  # 小潮

对象独有的数据 (重要)

对象除了从类得到的公共数据，如何让对象有自己的数据？

1.手动添加

就像往字典里添加键值对一样！
有两种方法:

使用双下dict
使用句点符
这两种都是当数据存在时可以修改数据的值，当不存在时会新增。类似字典。

class Student:

    student_name = '小澪'
    def choice_course(self):
        print('选课功能')

obj1 = Student()
print(obj1.__dict__)  # {}
obj1.__dict__['age'] = 17
obj1.hobby = 'swimming'
print(obj1.__dict__)  # {'age': 17, 'hobby': 'swimming'}
# 这是两种不同的语法 产生的效果一样

2.封装成函数

这样添加太累了，所以封装成函数。

class Student:
    student_name = '小澪'
    def choice_course(self):
        print('选课功能')

obj1 = Student()

def init(obj, age, hobby):
    obj.__dict__['age'] = age
    obj.__dict__['hobby'] = hobby

init(obj1,17,'swimming')
print(obj1.__dict__)  # {'age': 17, 'hobby': 'swimming'}

3.函数的调用资格

小澪属于学生类，我们希望只有学生类的对象才能调用这个添加属性的函数。防止其他对象调用，容易混淆！

class Student:
    student_name = '小澪'

    def init(obj, age, hobby):
        obj.__dict__['age'] = age
        obj.__dict__['hobby'] = hobby

    def choice_course(self):
        print('选课功能')

stu1 = Student()
Student.init(stu1, 17, 'swimming')
stu2 = Student()
Student.init(stu2, 17, 'kill')
print(stu1.__dict__)  # {'age': 17, 'hobby': 'swimming'}
print(stu2.__dict__)  # {'age': 17, 'hobby': 'kill'}

4.init（重要）

双下init的函数，在类中会默认执行。这个双下init就是我们之前给对象添加属性的函数。

class Student:
    student_name = '小澪'

    def __init__(obj, age, hobby):  # 专门给学生添加独有数据的功能  类产生对象的过程中自动触发
        obj.__dict__['age'] = age
        obj.__dict__['hobby'] = hobby

    def choice_course(self):
        print('选课功能')
# 由于双下init默认执行 现在调用类产生对象 必须要传三个参数了！
obj1 = Student(17, 'swimming')　# 为什么这里只有两个？
# 这行代码做了两件事：
1. 产生一个对象
2. 将这个对象和其余两个数值一起传入__init__方法

print(obj1.__dict__)  # {'age': 17, 'hobby': 'swimming'}
print(obj1.student_name)  # 小澪
print(obj1.choice_course)  #  <bound method Student.choice_course of <__main__.Student object at 0x0000022587B26670>>

5.变量名修改

# 1. 将形参obj变成self
# 2. 使用句点法
这样就得到了类的标准写法
class Student:
    student_name = '小澪'

    def __init__(self, age, hobby):
        self.age = age  # self.__dict__['age'] = age
        self.hobby = hobby

    def choice_course(self):
        print('选课功能')
# 3. 不同的对象属性不同
stu1 = Student(17, 'swimming')
print(stu1.hobby)
stu2 = Student(17, 'kill')
print(stu2.hobby)

对象独有的功能（重要）

1.全局定义函数

直接在全局定义功能然后给对象添加这个全局函数虽然是添加了但是该函数就不是学生对象独有的了别的对象也可以添加

class Student:
    # 对象公共的数据
    student_name = '小澪'

    # 专门给学生添加独有数据的功能  类产生对象的过程中自动触发
    def __init__(self, age, hobby):
        self.age = age  # self.__dict__['age'] = age
        self.hobby = hobby

    # 对象公共的功能
    def hobby(self):
        print(f'爱好是{self.hobby}')

def eat():
    print('吃东西')
stu1 = Student(17, 'swimming')
stu1.eat = eat  # 手动添加
print(stu1.__dict__)  # {'age': 17, 'hobby': 'swimming', 'eat': <function eat at 0x0000019312447280>}

2.将函数放在类中（重要）

但是在类中的函数，所有这个类创建的对象都可以调用，怎么办?还是没有实现对象独有的功能。
其实python开发者已经定义好了：
当对象调用类中的函数时，会将对象自己作为第一个参数传入。

class Student:
    # 对象公共的数据
    food = '草莓'

    # 对象公共的功能
    def hobby(self):
        print(f'爱好是吃{self}')  # 爱好是吃<__main__.Student object at 0x000001FE53656670>
        print(f'爱好是吃{self.food}')  # 爱好是吃草莓


stu1 = Student()
stu1.hobby()  # 对象调用类中的函数
print(stu1.food)  # 草莓

另外一个例子,反映对象调用类中函数会把自己传进去：

class Student:
    # 对象公共的数据
    food = '草莓'

    # 对象公共的功能
    def hobby():
        print(f'爱好是吃草莓')

Student.hobby()  # 爱好是吃草莓  # 不报错
stu1 = Student()
stu1.hobby()  #  TypeError: hobby() takes 0 positional arguments but 1 was given  # 会报错

passion

面向对象

面向对象前戏

1.使用字典

2.使用函数

3.创建攻击函数

4.封装攻击函数和字典

编程思想

面向对象之类与对象

python中类和对象

类的语法结构

类的定义阶段

查看名称空间

dict

获取类中的属性和方法

句点符

双下dict字典取值

类的调用

空对象

对象独有的数据 (重要)

1.手动添加

2.封装成函数

3.函数的调用资格

4.init（重要）

5.变量名修改

对象独有的功能（重要）

1.全局定义函数

2.将函数放在类中（重要）

更多例子

类的公共属性与绑定方法（重要）

公告

passion

面向对象

面向对象前戏

1.使用字典

2.使用函数

3.创建攻击函数

4.封装攻击函数和字典

编程思想

面向对象之类与对象

python中类和对象

类的语法结构

类的定义阶段

查看名称空间

__dict__

获取类中的属性和方法

句点符

双下dict字典取值

类的调用

空对象

对象独有的数据 (重要)

1.手动添加

2.封装成函数

3.函数的调用资格

4.__init__（重要）

5.变量名修改

对象独有的功能（重要）

1.全局定义函数

2.将函数放在类中（重要）

更多例子

类的公共属性与绑定方法（重要）

公告

dict

4.init（重要）