python基础day31 面向对象

面向过程

在支持面向对象的语言中，都有两大范式：1. 面向过程；2. 面向对象

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

举例：
把大象放进冰箱需要几步？
1. 把冰箱门打开
2. 把大象放进去
3. 关上冰箱门
代码案例：实现面向过程的例子
以注册功能为例：
1. 接收用户名和密码
2. 做逻辑处理，验证参数
3. 把数据写入到文件里

面向过程：

优点：负责的问题简单化，进而流程化

缺点：扩展性差，牵一发而动全身

使用场景：多扩展性要求不高的地方，一般使用面向过程

面向对象

面向对象的核心就是“对象”二字

1. 在生活中：

　　对象就是特征与机能的结合体

2. 在程序中：

　　对象就是盛放数据属性和方法的结合体

　　属性：简单理解就是变量

　　方法：简单理解就是函数，或者叫功能

优点：扩展性强

缺点：编程复杂度变高了

使用场景：一般用在对扩展性要求较高的地方

类的定义和对象的产生

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

站在不同的角度，分类的结果是不一样的

类：就是一系列相似的特征和相似的技能的结合体

问题来了：
到底是先有类还是先有对象?
1. 在生活中：
先有对象，在有类
2. 在程序中：
必须先定义类，然后调用类产生对象 （重要）

# 给学生类定义一个属性和方法出来
class Student():
    # school就是一个属性
    school = 'SH'
    country = 'China'
    # 在类里面定义一个方法出来，本质上就是函数，写在类里面就叫方法
    def choose_course(stu_dict, course)
        stu_dict['course'].append(course):
        print("%s选择了%s成功，%s" % (stu_dict["name"], course, stu_dict["courses"]))

def func(self):
    pass
'''
函数如果不调用，不会调用函数体代码，类呢？
定义类发生的几件事情：
    1. 类一旦被定义，会立马执行类体代码
    2. 类一旦定义完成，会产生类的名称空间，他会把类中的名字都丢到类的名称空间去
    3. 会把类的名称空间绑定给__dict__属性，如何查看：类名.__dict__
'''
# 如何查看类的名称空间？
# print(Student.__dict__)


# 如何产生对象?
# 在程序中，必须先定义类，然后调用类产生对象，
# 如何调用类？
# 类名()

stu = Student()  # 这就是在调用类, 得到的结果就是一个对象
stu1 = Student()
print(stu)  # <__main__.Student object at 0x000001B27B31F220>

# 2. 对象也有它自己的名称空间
# 怎么查看对象的名称空间？ 跟类是一样的，stu.__dict__
print(stu.__dict__)  # {} 调用类产生对象，得到的是一个空对象，其实就是空字典
print(stu1.__dict__)

"""每调用一次类，都会产生一个对象，并且产生的对象之间是相互独立的，互补影响的"""
# 调用类的过程也是实例化的过程，得到的结果就是一个实例

定制对象自己独有的属性

class Student():
    # school就是一个属性
    school = 'SH'  # 属性就是变量

    # __init__这个函数名不能改名字，必须叫这个名字，一点都不能差
    def __init__(stu_obj, name, age, gender, salary):
        stu_obj.name = name  # stu.__dict__['name'] = 'kevin'
        stu_obj.age = age  # stu.__dict__['age'] = '18'
        stu_obj.gender = gender  # stu.__dict__['gender'] = 'male'
        stu_obj.salary = salary  # stu.__dict__['salary'] = '1800'

    # 在类里面定义一个方法出来，为什么叫方法了嫩？本质上就是函数，写在类里面就叫方法
    def choose_course(stu_dict, course, ):
        stu_dict["courses"].append(course)
        print("%s选择了%s成功，%s" % (stu_dict["name"], course, stu_dict["courses"]))

# 怎么得到一个对象
"""
    调用类会自动的触发类里面的__init__方法，然后会把得到的对象本身当成第一个参数自动传递
"""

# stu['choose_course'](stu, 'linux')
stu = Student('kevin', 18, 'male', 2800)  # stu = Student(stu, 'kevin', 18, 'male', 2800)
stu1 = Student('jason', 28, 'male', 3800)
# stu2 = Student()

"""__dict__开头的属性或者方法都有他自己的特殊含义，一般不建议使用"""

print(stu.__dict__)

名称空间的查找顺序（重点）

属性的查找顺序分两大类：
类属性：在类里面定义的属性就是类属性
对象属性：就是对象自己独有的属性

# 类属性
# 增删改查
# 查看
print(Student.school)

# 增加
Student.x = 'a'
Student.y = 'b'

# 改
Student.x = 10

# 删除
del Student.school
print(Student.__dict__)


# 对象属性
print(stu.__dict__)

# 查看
print(stu.__dict__['name'])
print(stu.__dict__['age'])
print(stu.__dict__['gender'])

print(stu.name)
print(stu.age)
print(stu.gender)
# stu.school = 10
print(stu.__dict__)
"""这是个特殊的：对象属性的查找顺序是：先在自己对象的名称空间中查找，如果找不到再去产生这个对象的类中取找，如果找不到，就报错"""
print(stu.school)  # SH

# 增加
stu.x = 1

# 改
stu.x = 10

# 删除
del stu.school
print(stu.__dict__)