内容概要

• 面向过程的概念
• 面向对象的概念
• 类的定义和对象的产生
• 属性的查找和方法的查找

内容详细

面向过程的概念

            面向过程核心是过程二字，解决问题的流程， 即先干什么，在干什么，最后干什么

            # 举例：
                1. 洗衣服
                2. 把大象放冰箱中需要几步？
                    '''
                        1. 把冰箱门打开
                        2. 把大象放进去
                        3. 关上冰箱门
                    '''
                 3. 流水线生产饮料

                优点：复杂的问题流程化，进而简单化
                缺点：牵一发而动全身，扩展性差，可维护性差
                应用场景：对扩展性要求不高的地方， eg：安装包的使用

                # 注册的功能
                    '''
                        1. 用户输入用户名和密码
                        2. 验证参数
                        3. 写入文件，注册成功
                    '''

面向对象

            面向对象核心是对象二字
                什么是对象?
                    1. 程序中：
                        函数:盛放数据的容器
                        对象：盛放数据和函数的容器
                    2. 现实生活中：
                        一切皆对象
                        对象：特征与节能的结合体
                   eg：

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

                # 举例：
                    以学生选课系统为例



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


            stu1 = {
                'name': 'jason',
                'age': 18,
                'gender': 'male',
                'course': [],
                'choose_course': choose_course
            }

            stu2 = {
                'name': 'ly',
                'age': 18,
                'gender': 'male',
                'course': [],
                'choose_course': choose_course
            }

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

类的定义和对象的产生

            对象: 特征与技能的结合体
            类：一系列对象相似的特征与相似的技能的结合体

            强调：站在不同的分类，划分的分类不一定一样

            # 问题来了：
                到底是先有类还是先有对象？
                1. 程序中：
                    必须先定义类，然后调用类产生对象
                2. 现实生活中：
                    先有对象，在有人类

            '''
            使用专业的语法定义类：
                1. 定义函数
                    def 函数名():
                        pass

                2. 定义类：
                    class 类名():
                        pass

            '''

            # 定义类:
            '''
                发生了什么事？
                    1. 立即执行类体代码
                    2. 产生一个类的名称空间，把类体里面执行的名字都扔到名称空间中(大字典)
                    3. 把类的名称空间绑定给__dict__, 类名.__dict__
            '''
            # 类名一般情况首字母大写
            class Student():
                # 定义一个属性
                school = 'SH'

                # 定义一个技能(函数)
                def choose_course(stu_dict, course):
                    stu_dict['course'].append(course)
                    print('%s选课成功 %s' % (stu_dict['name'], stu_dict['course']))

                print('>>>>>>')

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


            # 产生对象
            # 调用类产生对象，默认产生的就是一个空对象{}

            stu1 = Student()
            stu2 = Student()
            stu3 = Student()

            print(stu1.__dict__)
            print(stu2.__dict__)
            print(stu3.__dict__)

给对象定制自己独有的属性

     
            class Student():
                # 定义一个属性
                school = 'SH'

                # 初始化方法
                # 调用类自动触发的函数
                # 该方法不是一定要定义，需要用到就定义，不需要刻意不定义
                def __init__(stu_obj, name, age, gender):
                    # 空对象.name = name
                    # 空对象.age = age
                    # 空对象.gender = gender
                    stu_obj.name = name  # stu1.__dict__['name'] = 'jason'
                    stu_obj.age = age  # stu1.__dict__['age'] = 18
                    stu_obj.gender = gender  # stu1.__dict__['gender'] = 'male'、
                    # return None # 在这个方法中不能有返回值，
                # 定义一个技能(函数)
                def choose_course(stu_dict, course):
                    stu_dict['course'].append(course)
                    print('%s选课成功 %s' % (stu_dict['name'], stu_dict['course']))


            # 调用类发生了几件事？
            '''
                1. 得到一个空对象
                2. 调用了Student.__dict__(空对象,'ly', 18, 'male'),
                3. 得到一个初始化的结果。
            '''
            stu1 = Student('ly', 18, 'male')
            stu2 = Student('jason', 18, 'male')
            # stu1 = Student()
            # print(stu1.__dict__)
            # print(stu2.__dict__)

            # print(stu1.name)
            # print(stu2.name)

            # 属性的查找：先从自己的对象中查找，然后在去产生对象的类中取找

            stu1.school = 'aaaa'
            print(stu1.school)

属性的查找顺序

            class Student():
                # 定义一个属性
                school = 'SH'

                def __init__(self, name, age, gender, course=None):
                    if course is None:
                        course = []
                    self.name = name  # stu1.__dict__['name'] = 'jason'
                    self.age = age  # stu1.__dict__['age'] = 18
                    self.gender = gender  # stu1.__dict__['gender'] = 'male'
                    self.course = course
                def choose_course(self, course):
                    # stu_dict => stu
                    self.course.append(course)
                    print('%s选课成功 %s' % (self.name, self.course))

                def func(self, name, age):
                    pass

            # 属性的查找：
            # 1. 类属性: 在类中写的属性就称为类属性
            # 2. 对象属性：在对象自己的名称空间中的属性就是对象属性

            # 类属性的查找
            # 1. 查
            # print(Student.school)

            # 2. 增加
            # Student.country = 'China'


            # 3. 改
            # Student.school = 'BJ'

            # 4. 删除
            # del Student.school
            # print(Student.__dict__)
            # {}
            stu = Student('ly', 18, 'male')  # 实例化对象， stu就是一个实例
            # 对象属性
            # 1. 查
            # print(stu.name)
            # print(stu.age)
            # print(stu.gender)

            # 2. 增
            # stu.aaa = 'aaa'
            #
            # # 3. 改
            # stu.name = 'bbb'

            # 4. 删除
            # del stu.name
            # print(stu.__dict__)


            # 类中的方法，类可以调用，对象也可以调用
            # 类调用方法
            # Student.choose_course(stu, 'python') # 类来调用，函数的参数有几个就要传几个
            # print(Student.choose_course)

            # 对象调用方法
            # 类中的方法，类可以调用，对象也可以调用, 但是，推荐对象来调用，因为对象来调用，会把自己当成第一个参数传递给函数
            stu.choose_course('python') # stu.choose_course(stu， 'python')

            class Teacher():
                pass
            print(isinstance(123, int))
            print(isinstance(stu, Teacher))