面向对象和类

内容概要

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

面向过程的概念

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

面向过程就像是设计一条流水线

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

面向对象的概念

面向对象核心是对象

什么是对象
      1.程序中
          函数：盛放数据的容器
          对象：盛放数据和函数的容器
      2.现实生活中
          一切都是对象
          对象：特征与技能的结合体

优点：扩展性强，可维护性强
缺点：编程复杂度高
应用场景：对扩展要求较高的地方(比如微信，QQ)

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


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

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

stu1['choose_course'](stu1, 'music')
stu2['choose_course'](stu2, 'linux')

类的定义和对象的产生

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

到底是先有类还是先有对象？
    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()
# 查看对象的名称空间
print(stu1.__dict__)

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

调用类发生了几件事？
1.得到一个空对象
2.调用了Student.__dict__
3.得到一个初始化结果

# 类名的首字母一般都是大写
class Student():
    # 定义一个属性
    # 变量放到类里面就称为属性
    school = 'sh'

    # 定义一个技能(函数)
    # 函数放到类里面就称为方法
    def choose_course(stu_dict, course):
        stu_dict['course'].append(course)
        print('%s选课成功%s' % (stu_dict['name'], stu_dict['course']))

    # 初始化
    # 自动传值
    # 调用类自动触发函数
    # 该方法不一定要定义
    def __init__(stu_obj, name, age, gender):
        stu_obj.name = name
        stu_obj.age = age
        stu_obj.gender = gender
    # 在这个方法中不能有返回值


stu1 = Student('aaa', 18, 'male')
stu2 = Student('sss', 18, 'male')
print(stu1.__dict__)
print(stu1.name)
print(stu2.name)
print(stu1.school)  # 先在对象名称空间找，再在类名称空间找
# print(stu1.__dict__) 报错，这是在对象自己的名称空间找，自己的名称空间没有

属性的查找顺序

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))