面向对象1

1. 面向过程的概念

面向过程，核心是过程，解决问题的流程，即先干什么，再干什么，最后干什么。
举例：

1. 要把大象装冰箱，总共分几步？？？
2. 流水线flow line.
   优点：复杂的问题流程化，进而简单化。
   缺点：可扩展性差，可维护性差，牵一发动全身。
   应用场景：对扩展性要求不高的地方，eg：安装包的使用。
   用户注册功能面向过程实例：

# 注册功能
"""
1. 用户输入用户名和密码
2. 验证参数
3. 写入文件，验证成功
"""
# 1. 用户输入用户名和密码
def interactive():
    username = input('请输入用户名>>>:').strip()
    pwd = input('请输入密码>>>:').strip()
    return {
        'username': username,
        'pwd': pwd
	}

# 2. 验证参数
def check_info(userinfo):
    is_valid = True
    if len(userinfo['username']) == 0:
        print('用户名不能为空')
        is_valid = False
    if len(userinfo['pwd']) == 0:
        print('密码不能为空')
        is_valid = False
    return {
        'is_valid': is_valid,
        'userinfo': userinfo
	}
	
import json
# 3. 写入文件，注册成功
def register(param):
    if param['is_valid']:
        with open(r'userinfo.txt', 'w', encoding='utf8') as f:
            json.dump(param['userinfo'], f)

def main():
    # 1.让用户输入用户名
    userinfo = interactive()

    # 2.验证参数
    check_param = check_info(userinfo)
	
    # 3.注册成功
    register(check_param)

if __name__ == '__main__':
    main()

2. 面向对象

面向对象核心是对象二字
什么是对象？？？？

1. 程序中：
   函数：盛放数据的容器
   对象：盛放数据属性和方法（函数）的容器
2. 现实中：
   一切皆对象
   对象：特征与技能的结合体

优点：扩展性强，可维护性强。
缺点：编程复杂度高（相对而言）
应用场景：对扩展性要求较高的地方。
eg：微信，qq等

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

对象：特征与技能的结合体。
类：一系列对象相似的特征与相似的技能结合体。
强调：站在不同的类，划分的分类不一定一样。

---

问题来了：到底是先有类还是先有对象？？？

1. 程序中：必须先定义类，然后调用类，产生对象。
2. 现实中：先有对象，再有类。

# 专业的语法 定义类
class 类名():
    pass

# 定义类发生了什么？？？
"""
	1. 立即执行类体代码。
	2. 产生一个类的名称空间，把类体里面执行的名字，都扔到名称空间中（大字典）
	3. 把类的名称空间绑定给__dict__属性（类名.__dict__）
"""
# 定义一个学生类
class Student():
    # 定义一个类属性（类变量）
    school = 'SH'
    # 定义一个技能
    def choose_course(self,stu_dict,course):
        stu_dict['course'].append(course)
        print('选课成功')
    print('测试执行类体代码')

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

# 调用类，产生对象，默认产生的就是一个空对象（空字典）
stu1 = Student()
stu2 = Student()

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

对象的属性

class Student():
    school = 'SH'
	
    # 初始化方法
    # 调用类自动触发的函数
    # 该方法不是一定要定义，需要用到就定义
    def __init__(self,name,age,gender):
        # 空对象.name = name
        # 空对象.age = age
        # 空对象.gender = gender
        self.name = name
        self.age = age
        self.gender = gender
        return None # 在这个方法总不能有返回值
    # 定义一个技能（函数）
    def choose_course(self,stu_dict,course):
        stu_dict['course'].append(course)
        print('选课成功')

stu1 = Student('ly',18,'male')

# 调用类发生了几件事？？
"""
	1. 得到一个空对象
	2. 调用了Student.__dict__(self(空对象),'ly',18,'male')
	3. 得到一个初始化的结果
"""
# 属性的查找：先从自己的对象中查找，然后再去产生对象的类中去找

print(stu1.school) = 'SH'
stu.school = 'aaa'
print(stu.school) = 'aaaa'
print(Student.school) = 'SH'

4. 属性的查找

类属性（类变量）：在类中写的属性就成为类属性。

1.查
print(Student.school)

2.增
Student.country = 'China'

3.改
Student.school = 'BJ'

4.删
del Student.school

对象属性（实例变量）：在对象自己名称空间中的属性就是对象属性。

stu = Student('jx', 28, 'male')
1.查
print(stu.age)

2.增
stu.aaa = 'aaa'

3.改
stu.name = 'ccc'

4.删
del stu.name

print(stu.__dict__)

类中的方法，类可以调用，对象也可以调用。

# 类调用方法
# 类来调用，函数的参数有几个就要传几个
class Student():
    school = 'SH'
    
     def __init__(self,name,age,course=None):
        self.name = name
        self.age = age
        self.gender = gender
        self.course = course

    def choose_course(self,course):
        self.course.append(course)

# 类调用
stu = Student()
Student.choose_course(stu,'python')

# 对象调用，会把自己当作第一个参数传进去
stu.choose_course('python')

# 类中的方法，类和对象都可以调用，但是推荐对象来调用。