Python学习路程——面向对象

编程思想

'''
面对过程编程：

	过程即流程，面向过程就是按照固定的流程解决问题
	需要列举出每一步的流程，并且随着步骤的深入，问题的解决也越来越简单
	
	面向过程是一种以过程为中心的编程思想，其原理就是将问题分解成一个一个详细的步骤，然后通过函数实现每一个步骤，并依次调用。
	
面对对象编程：

	对象即容器，是数据和功能的结合体，万物皆可对象
	面向对象编程，我们只需要创造出一个一个的对象，至于对象的未来，则和我们无关
	
	面向对象则是一种以对象为中心的编程思想，通过分析问题，分解出一个一个的对象，然后通过不同对象之间的调用来组合解决问题。
'''

面向对象前戏

'''
1、为什么需要面向对象编程
	1.1 接近现实生活，容易建模。生活中的事物就是一个个的对象，很容易建立两者之间的联系。

　　1.2 对象提供了一种好的组织数据的方式，通过对象，我们可以把混乱的数据整合到一个类中，形成一个整体，这样处理起来更加方便。

　　1.3 对数据的封装，面向对象提供了public,private等访问控制，能够防止外部对数据的非法访问。

　　1.4 代码的重用，面向的对象的继承，多态，接口实现等特性能够很容易的实现代码的重用，而同时，我们可以将类作为一个整体，随处使用，也是一个很好的重用方法
　　
　　1.5 可扩展性，可维护性
2、面向对象的特点
	（1）万物皆对象（2）程序是对象的集合（3）它们通过发送消息来告诉彼此要做的（4）每个对象都有自己由其他对象所构成的存储（5）每个对象都拥有其类型，特定类型的所有对象都可以接受同样的消息。
	
3、面向对象的核心思想
	实现数据与功能的绑定，即数据和功能只有一定前置条件的才能调用
'''

人狗大战

# coding:utf-8
'''
编写代码实现人狗大战
    要求：
        人只能调用人的攻击动作，狗也一样，即实现数据与功能的绑定
'''


# 定于人的函数
def get_person(name, age, gender, p_type, attack_val, life_val):
    # 产生人的函数(功能)
    def person_attack(person_dict, dog_dict):
        print(f"人:{person_dict.get('name')}准备揍狗:{dog_dict.get('name')}")
        dog_dict['life_val'] -= person_dict.get('attack_val')
        print(f"人揍了狗一拳 狗掉血:{person_dict.get('attack_val')} 狗剩余血量:{dog_dict.get('life_val')}")
    # 表示人的数据
    person_dict = {
        'name': name,
        'age': age,
        'gender': gender,
        'p_type': p_type,
        'attack_val': attack_val,
        'life_val': life_val,
        'person_attack': person_attack
    }
    return person_dict


# 定义狗的函数
def get_dog(name, d_type, attack_val, life_val):
    # 产生狗的功能函数
    def dog_attack(dog_dict, person_dict):
        print(f"狗:{dog_dict.get('name')}准备咬人:{person_dict.get('name')}")
        person_dict['life_val'] -= dog_dict.get('attack_val')
        print(f"狗咬了人一口 人掉血:{dog_dict.get('attack_val')} 人剩余血量:{person_dict.get('life_val')}")
    # 产生狗的数据
    dog_dict = {
        'name': name,
        'd_type': d_type,
        'attack_val': attack_val,
        'life_val': life_val,
        'dog_attack': dog_attack
    }
    return dog_dict


dog = get_dog('大黄', '天狗', 999, 10000)
person = get_person('沉香', 18, 'man', '孝子', 9999, 99999)
# person.get('person_attack')(person, dog)
person['person_attack'](person, dog)

类与对象

'''
对象：
	数据与功能的结合体     核心
类：
	多个对象相同数据和功能的结合体

程序中一般都是先有类，后有对象
'''

类与对象的创建

'''
类的语法结构：
	class 类名:
		"""代码注释"""
		对象公共的数据
		对象公共的方法
	1、class是定义类的关键字
	2、类名的命名与变量名几乎一致，首字符大写
	3、数据：变量名与数据值的绑定，方法就是函数

数据和功能 也可以统称为属性    数据>>>属性名       功能>>>:方法

类的定义与调用
	类在定义阶段就会执行类体代码，但是属于类的局部名称空间，外部无法直接调用
'''

简单的选课系统

# coding:utf-8
# 定义学生类
class Student:
    # 对象的公共数据
    school = '剑桥大学'

    # 对象的公共的方法
    def choice_course(self):
        print('学生选课系统')


# 查看类的名称空间
print(Student.__dict__)
# 查看类的公共数据
print(Student.__dict__.get('school'))
# 查看类的公共方法
print(Student.__dict__.get('choice_course'))

# 查看类的公共数据、方法 可以通过句点符的方式查看
print(Student.school)
print(Student.choice_course)

# 类名加()就会产生对象，每执行一次就会产生一个全新的对象
# 变量名接收类名加括号之后的返回值(结果)
obj = Student()
obj1 = Student()
obj2 = Student()
print(obj, obj1, obj2)

# 所产生的对象里面是空的
print(obj.__dict__)
print(obj1.__dict__)
print(obj2.__dict__)

# 产生的对象里面的数据是一样的
print(obj.school)
print(obj1.school)
print(obj2.school)

# 类名.变量名 = 数据值 可以更改数据值
Student.school = '伦敦大学'
print(obj.school)
print(obj1.school)
print(obj2.school)

对象独有的数据

# coding:utf-8
# class Student:
    # school = '剑桥大学'
    #
    # def choice_course(self):
    #     print('学生选课系统')


# 定义变量来接收Student类产生的对象
# obj = Student()
# obj1 = Student()
# # 推导流程1 为每个对象手动添加独有的数据
# print(obj.__dict__)  # {} 形似字典，真身是名称空间
# obj.__dict__['name'] = 'maria'
# obj.__dict__['age'] = 18
# obj.__dict__['sexy'] = 'man'
# obj.__dict__['choice'] = 'English'
# print(obj.name)
# print(obj.age)
# print(obj.sexy)
# print(obj.choice)
#
# obj1.__dict__['name'] = 'jerry'
# obj1.__dict__['age'] = 18
# obj1.__dict__['sexy'] = 'woman'
# obj1.__dict__['choice'] = 'Chinese'
#
# print(obj1.name)
# print(obj1.age)
# print(obj1.sexy)
# print(obj1.choice)

# 推到流程2 将添加对象的独有数据的代码封装成函数
# def init(obj, name, age, sexy, choice):
#     obj.__dict__['name'] = name
#     obj.__dict__['age'] = age
#     obj.__dict__['sexy'] = sexy
#     obj.__dict__['choice'] = choice
#
#
# stu = Student()
# stu1 = Student()
# init(stu, 'maria', 18, 'man', 'English')
# init(stu1, 'jerry', 18, 'woman', 'Chinese')
# print(stu.__dict__)
# print(stu1.__dict__)

# 推到流程3 学生对象添加独有数据的函数只有学生对象有资格调用
# class Student:
#     school = '剑桥大学'
#
#     def init(obj, name, age, sexy, choice):
#         obj.__dict__['name'] = name
#         obj.__dict__['age'] = age
#         obj.__dict__['sexy'] = sexy
#         obj.__dict__['choice'] = choice
#
#     def choice_course(self):
#         print('学生选课系统')


# stu = Student()
# Student.init(stu, 'maria', 18, 'man', 'English')
# stu1 = Student()
# Student.init(stu1, 'jerry', 18, 'woman', 'Chinese')
# print(stu.__dict__)
# print(stu1.__dict__)

# 推到过程4 init方法变形
# class Student:
#     school = '剑桥大学'
#
#     def __init__(obj, name, age, sexy, choice):
#         obj.__dict__['name'] = name
#         obj.__dict__['age'] = age
#         obj.__dict__['sexy'] = sexy
#         obj.__dict__['choice'] = choice
#
#
#     def choice_course(self):
#         print('学生选课系统')
#
#
# stu = Student('maria', 18, 'man', 'English')
# print(stu.__dict__)
# print(stu.name)
# print(stu.school)


# 推导步骤5 变量名修改
class Student:
    school = '剑桥大学'

    def __init__(self, name, age, sexy, choice):
        self.name = name
        self.age = age
        self.sexy = sexy
        self.choice = choice


    def choice_course(self):
        print('学生选课系统')


stu = Student('jerry', 18, 'woman', 'Chinese')
print(stu.choice)

对象独有的功能

# coding:utf-8
# class Student:
#     school = '剑桥大学'
#
#     def __init__(self, name, age, sexy, choice):
#         self.name = name
#         self.age = age
#         self.sexy = sexy
#         self.choice = choice
#
#
#     def choice_course(self):
#         print(f'学生{self.name}正在使用选课系统')


# 直接定义在全局的功能函数，该函数就不是Student对象独有的函数
# def input_choice():
#     print('Student choice!')
#
#
# stu = Student('maria', 18, 'man', 'English')
# stu.input_choice = input_choice
# print(stu.__dict__)
# stu.input_choice()

# 只要将函数定义在类中，默认就是绑定给对象使用
class Student:
    school = '剑桥大学'

    def __init__(self, name, age, sexy, choice):
        self.name = name
        self.age = age
        self.sexy = sexy
        self.choice = choice

    def input_choice(self):
        print('Student choice!')
        return Student

    def choice_course(self):
        print(f'学生{self.name}正在使用选课系统')


# 类调用需要传入参数
# Student.input_choice(1)

# 对象调用会自动将对象作为第一个参数传入
stu = Student('maria', 18, 'man', 'English')
print(stu.input_choice())  # 结果里面会有一个返回值，不定义return则为None

'''
对象修改数据值
'''

# 当点的名字不存在的时候，则新增数据（形式类似键值对）
stu.hobby = 'dance'
# __dict__方法可以查看Student内的数据
print(stu.__dict__)