面向对象编程与类的定义和函数的产生

一.面向对象编程

面向对象编程的核心是对象

1.在程序中：

　　函数：盛放数据的容器

　　对象：盛放数据和函数的容器

2.在现实生活中：

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

3.优点是：

　　扩展性强，可维护性强

4.缺点是：

　　编程复杂度高

5.应用场景：

　　对扩展性要求较高的地方。比如说常用的微信。

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


student1 = {
    'name': 'jason',
    'age': 18,
    'gender': 'male',
    'course': [],
    'choose': chose_course
}
student2 = {
    'name': 'jack',
    'age': 18,
    'gender': 'male',
    'course': [],
    'choose': chose_course
}

student1['choose'](student1, 'python')
student2['choose'](student2, 'java')

二.类的定义与产生

1.对象：

　　特征与技能的结合体

2.类：

　　一系列对象相似的特征和相似的技能的结合体

3.现有类还是现有对象？

　　在程序中必须定义类，然后调用类产生对象

'''
语法格式:
1.定义函数:
    def 函数名（）：
        pass
2.定义类:
    class 类名（）：
        pass
'''
# 定义类:
'''
发生了什么事？
        1. 立即执行类体代码
        2. 产生一个类的名称空间，把类体里面执行的名字都扔到名称空间中(大字典)
        3. 把类的名称空间绑定给__dict__, 类名.__dict__
'''

class Student():
    school = 'SH'

def choose_corse(student, course):
    student['course'].append(course)
    print('学生%s选课成功 %s' % student, student['course'])


'''调用类产生了对象，默认情况下是一个空字典'''
stu1 = Student()
stu2 = Student()
'产生一个空字典'
print(stu1.__dict__)
'产生一个空字典'
print(stu2.__dict__)
print(Student.__dict__)

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

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

class Student():
    school = 'SH'

    def __init__(student, name, age, gender, course):
        student.name = name
        student.age = age
        student.gender = gender
        student.course = course

    def choose_course(student, course):
        student['course'].append(course)
        print('%s选课成功 %s' % (student['name'], student['course']))
'''
    1. 得到一个空对象
    2. 调用了Student.__dict__(空对象,'ly', 18, 'male'),
    3. 得到一个初始化的结果。
'''
student1 = Student('lw', 18, 'male', 'python')
print(student1.__dict__)
'属性的查找：先从自己的对象中查找，然后在去产生对象的类中查找'


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

四.属性的查找

 # 版本3：
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))