Python面向对象

一、面向过程编程

在编程中，面向过程和面向对象是编程的两大思想，不是一门新的技术栈

什么是面向过程：

面向过程中的过程就是先干什么，再干什么，最后干什么，一种机械的思维方式

案例：

把大象装进冰箱分为几步？

第一步：打开冰箱门
第二步：把大象放冰箱
第三步：关上冰箱门

优点：复杂的问题简单化，进而流程化
缺点：扩展性差，牵一发而动全身
引用场景：一般用在扩展性要求比较差的情况上

使用面向过程写一个注册案例来体会面向过程的缺点

# 1.让用户输入用户名和密码
def in_userinfo():
    username = input('请输入用户名').strip()
    password = input('请输入密码').strip()
    """增加邮箱注册"""
    email = input('请输入邮箱').strip()
    return {
        'username': username,
        'password': password,
        'email': email
    }


# 2.验证信息
def check_info(userinfo):
    flag = True
    if len(userinfo['username']) == 0:
        print('用户名不能为空')
        flag = False
    if len(userinfo['password']) == 0:
        print('密码不能为空')
    """增加邮箱验证"""
    if len(userinfo['email']) == 0:
        print('邮箱不能为空')
    return {
        'flag': flag,
        'userinfo': userinfo
    }


# 3.保存信息
def save_info(data):
    if data['flag']:
        with open('a.txt', 'w', encoding='utf-8') as f:
            import json
            json.dump(data['userinfo'], f)


userinfo = in_userinfo()
data = check_info(userinfo)
save_info(data)

"""这个时候如果想要在注册时添加一个邮箱就得检查每一个函数需不需要添加，这时候就体现出它的缺点，扩展性差"""

二、面向对象编程

面向对象也是一种编程思维，不是一门新的技术栈

在Python中一切皆对象

对象是什么：

在生活中：对象就是“特征”与“技能”的集合体
在程序中：对象就是“数据属性”与“功能”的集合体

优点：扩展性强
缺点：简单的问题被复杂化了

举例：学生选课系统

在系统中有那些角色：
1.学生
2.老师
3.管理员
4.选课功能
…

用代码实现以上功能

# 2.创建对象功能
def choice_student(student, course):  # 赋予两个形参，一个是字典，一个是课程
    student['course'].append(course)  
    print('%s选课成功:%s' % (student['name'], student['course']))


# 1.创建每个学生的特征，对象数据属性
student1 = {
    'name': 'jack',
    'age': 20,
    'gender': 'male',
    'course': [],
    'choice_student': choice_student
}

student2 = {
    'name': 'sb',
    'age': 18,
    'gender': 'female',
    'course': [],
    'choice_student': choice_student
}

student1['choice_student'](student1, '语文')  # 调用student1字典内函数并赋予调用函数的名字，谁传第一个实参就是谁的名字
student1['choice_student'](student1, '数学')
student2['choice_student'](student2, '数学')
"""这个时候如果需要添加课程只需继续调用函数"""

三、类的定义和对象的产生

对象：数据与功能（方法）的结合体 对象才是核心

类： 多个对象相同数据和功能的结合体 类主要就是为了节省代码

程序中如果想产生对象，必须先有类，但生活中，一般先有对象再有类

1.类的语法

class Student():
	pass

"""
1. 关键字使用class来声明
2. class后面写的是类名，类名的命名：一般情况下遵循变量的命名规范即可，类名一般首字母都要大写，（小写也行，但是不推荐）
3. 如果你的类名比较长，推荐使用驼峰法，并且是大驼峰
4. 类名后面的小括号不能省略
"""

2.类的定义和对象的产生

class Student():
    school = '南山幼儿园'  # 类属性，就是变量

    # 函数写在类里面就称为方法
    def choice_student(student, course):  # 赋予两个形参，一个是字典，一个是课程
        student['course'].append(course)
        print('%s选课成功:%s' % (student['name'], student['course']))


print(Student.__dict__)  # {'__module__': '__main__', 'school': '南山幼儿园', 'choice_student': <function Student.choice_student at 0x00000289A52035E0>, '__dict__': <attribute '__dict__' of 'Student' objects>, '__weakref__': <attribute '__weakref__' of 'Student' objects>, '__doc__': None}

# 如何产生对象
stu = Student()

# 如何调用类产生对象
print(stu)  # <__main__.Student object at 0x0000026A1D6A5B80>
""" 类名加括号就会产生对象，并且每执行一次都会产生了一个全新的对象"""
# 1.类名加括号>>>对象
stu1 = Student()  # <__main__.Student object at 0x000002D2C3E54250>
stu2 = Student()  # <__main__.Student object at 0x000002D2C3EEB220>
stu3 = Student()  # <__main__.Student object at 0x000002D2C3EEBA60>
print(stu1,dtu2,stu3)  # 变量名obj1接收类名加括号之后的返回值(结果)

# 2.通过对象点__dict__ 得到的是空的字典 ，这个字典并不是真是的字典
print(stu1.__dict__)  # {} 目前对象是空的
print(stu2.__dict__)  # {}
print(stu3.__dict__)  # {}

# 3.通过对象点类内的变量名  >>>:变量名绑定的数据值
print(stu1.school_name)  # 南山幼儿园
print(stu2.school_name)  # 南山幼儿园
print(stu3.school_name)  # 南山幼儿园

# 4.类名修改类体代码内中的变量名绑定的数据值school_name
Student.school = '北海养老院'
print(stu1.school_name)  # 北海养老院
print(stu2.school_name)  # 北海养老院
print(stu3.school_name)  # 北海养老院

>>>>数据和功能  也称属性
>>>>数据       也称属性名
>>>>功能       也称方法



# 如何查看对象的名称空间
print(stu.__dict__)  # {} 默认情况下调用类会得到一个空对象，也就是一个空字典

3. 定制对象自己独有的属性

默认情况下，调用类产生一个对象，它是一个空对象，没有任何的数据
因此，我们需要给每一个对象添加数据

class Student():
    school = '南山幼儿园'  # 类属性，就是变量
    
    """它有特殊的含义, 在类里面必须叫__init__，然后调用类的时候才会自动触发执行"""

    ## 类里面一定要有这个方法吗? 不一定，也就是说，你如果需要提前定制对象的属性，你就写这个方法， 如果不需要，就不用写
    # 也称为是初始化方法
    def __init__(self, name, age, gender, course=None):
        if course is None:
            course = []
        self.name = name
        self.age = age
        self.gender = gender
        self.course = course


    # 函数写在类里面就称为方法
    def choice_student(student, course):  # 赋予两个形参，一个是字典，一个是课程
        student['course'].append(course)
        print('%s选课成功:%s' % (student['name'], student['course']))



stu = Student('jack', 18, 'male', 'python')
print(stu.__dict__)  #{'name': 'jack', 'age': 18, 'gender': 'male', 'course': 'python'}

4. 属性的查找顺序

class Student():
    school = 'SH'

    def __init__(self, name, age, gender):
        self.name = name
        self.age = age
        self.gender = gender


# 1. 类属性的查找

# 查
print(Student.__dict__['school'])
print(Student.school)

# 增加
Student.x = 'xxx'
Student.z = 666
print(Student.__dict__)

# 改
Student.school = 'BJ'
print(Student.__dict__)

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

# 对象的增删改查
stu = Student('kevin', 19, 'male')

# 1. 查
print(stu.name)
print(stu.age)
print(stu.gender)
# print(stu.x)
print(stu.school) # SH  #### 如果你使用的是点语法，那么，对象查找属性的时候，先从对象自己的名称空间中查找，如果找不到，就去产生这个对象的类中查找

"""如果你使用的__dict__取值，只能够取到对象自己名称空间中得属性，不会去类中查找"""
# print(stu.__dict__['school']) # SH  #### 如果你使用的是点语法，那么，对象查找属性的时候，先从对象自己的名称空间中查找，如果找不到，就去产生这个对象的类中查找
print(stu.__dict__)

# 增加
stu.x = 666

# 改
stu.x = 888
print(stu.__dict__)

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