面向过程的概念

面向过程的核心是：过程二字，即先干什么，在干什么， 最后干什么。机械式思维方式

# 面向过程不是一门技术，是一种做事的思维方式
eg：
    大象放冰箱的步骤：
        1. 打开冰箱门，
        2. 把大象放进冰箱
        3. 观赏冰箱门
        
    优点：复杂的问题简单化，流程化
    缺点：扩展性差，牵一发而动全身
    应用场景：对扩展性要求不高的地方
    eg2:
        写一个注册功能

面向对象的概念

面向对象核心是：对象二字
    # 在python中，一切皆对象
    1. 在程序中：
        对象就是盛放数据属性和功能的容器
    2. 在现实生活中
        对象就是特征与技能的结合体
  
优点：扩展性强
缺点：简单的问题复杂化
应用场景：对扩展性要求高的地方

eg：学生选课系统为例
# 版本3：

def choose_course(stu_dic,course):
    stu_dic['courses'].append(course)
    print('%s选课成功%s' % (stu_dic['name'], stu_dic['courses']))

stu1 = {
    'name': 'tom',
    'age': 19,
    'gender': 'male',
    'courses': [],
    'choose_course':choose_course
}

stu2 = {
    'name': 'kevin',
    'age': 20,
    'gender': 'male',
    'courses': [],
    'choose_course': choose_course
}

stu1['choose_course'](stu1, 'python')
stu2['choose_course'](stu2, 'python')

类的定义与对象的产生

# 对象：特征与技能的结合体

# 站在不同的角度，划分的分类不一样
类：一系列对象相似的特征和相似的技能的结合体

问题来了?
    到底是先有类还是先有对象？
     1. 现实生活中:
            一定是先有对象，在有类
     2. 程序中：
         必须先定义类，在调用类产生对象（*******）
# 注意事项：类名，遵循变量的命名规范即可，类名一般都是首字母大写
# 类名有多个单词，推荐使用大驼峰

class Student():
    # 定义类属性
    school = 'SH'
    
    # 在类中，函数被称为是方法
    def choose_course(stu_dic, course):
        stu_dic['courses'].append(course)
        print('%s选课成功%s' % (stu_dic['name'], stu_dic['courses']))
    print(12233333)
    
'''
    定义类发生的几件事？
        1. 类定义完成后，会立马执行类体代码
        2. 执行类体代码，把类中的名字都丢到类的名称空间去
        3. 把类的名称空间绑定给__dict__, 类名.__dict__
'''

# 如何查看类的名称空间
print(Student.__dict__)

# 产生对象， 调用类，类名()
stu1 = Student()  # 调用类，得到一个空对象
stu2 = Student()

# 如何查看对象的名称空间
print(stu1.__dict__)  # 空字典
print(stu2.__dict__)  # 空字典

定制对象自己独有的属性

# 版本3：
class Student():
    # 定义类属性
    school = 'SH'

    # 初始化, 魔术方法
    def __init__(stu_dic, name, age, gender, course=[]):
        stu_dic.name = name  # stu.__dict__['name'] = 'tom'
        stu_dic.age = age  # stu.__dict__['age'] = 19
        stu_dic.gender = gender  # stu.__dict__['gender'] = 'male'
        stu_dic.course = course  # stu.__dict__['course'] = []

    # 在类中，函数被称为是方法
    def choose_course(stu_dic, course):
        stu_dic['courses'].append(course)
        print('%s选课成功%s' % (stu_dic['name'], stu_dic['courses']))


# Student()
# stu = Student(stu, 'tom', 19, 'male')
stu = Student('tom', 19, 'male')  # 调用类的时候，会自动触发__init__方法，并且，会把对象自己当成第一个参数传给函数
stu1 = Student('kevin', 19, 'male')  # 调用类的时候，会自动触发__init__方法，并且，会把对象自己当成第一个参数传给函数

# print(stu.__dict__)
# print(stu1.__dict__)

'''
    调用类的过程也称为是实例化的过程，得到的对象就是一个实例
'''

属性的查找顺序

print(stu1.__dict__)
# 1.类属性
# 读
# print(Student.__dict__['school'])
# print(Student.school)
#
# # 改
# Student.school = 'xxx'
#
#
# del Student.school
# # 删除
#
# # 曾
# Student.aaa = 'xxx'
# print(Student.__dict__)

# 2. 对象属性的增删改查
# print(stu.name)
# print(stu.age)
# print(stu.gender)

# print(stu1.name)
# print(stu1.age)
# print(stu1.gender)

# 对象的属性查找顺序：先在对象自己的名称空间中查找，如果找不到，去产生对象的类中取查找
print(stu.school)
# print(stu.__dict__['school'])

# 增
stu.x = 'aaa'
print(stu.__dict__)

# 改
stu.x = 'bbb'

# 删除
del  stu.x