目录
面向对象编程介绍
面向过程编程
面向过程编程的核心就是过程，过程指的是解决问题的步骤，也就是按照固定的顺序进行，执行程序，就好比流水线一样
- 优点：复杂的问题简单化，流程化
- 缺点：扩展性差
面向对象编程
面向对象编程的核心就是对象二字，对象就是特征与技能的结合体
基于面向对象编程的思想编程，就好比在创造一个世界，你是这个世界的主人，想怎么写就怎么写
- 优点：可扩展性强
- 缺点：编程复杂度远远提高
类与对象
- 类就是种类，分类，类别
对象就是特征与技能的结合体，我们可能有身高，体重，每个人的身高体重各不相同，但是都是有相似的特征的，就可以说我们是一类，而你和选课系统又不一样，因此
类就是：一系列对象相似的特征与技能的结合体
在现实生活中，我们先有的对象，然后才慢慢有了分类的概念
现实生活中定义类和对象
定义对象
就按我们的选课系统来讲，首先我们得先有学生对象：
对象一：
特征：
- 学校='oldboy'
- 姓名='hades'
- 年龄=18
- 性别='男'
- 技能：
- 选课
对象二：
特征：
- 学校='oldboy'
- 姓名='bonnie'
- 年龄=16
- 性别='女'
- 技能：
- 选课
定义类
- 学生类
- 相似的特征：
- 学校='oldboy'
- 相似的技能：
- 选课
- 相似的特征：
程序中定义类和对象
定义类
语法：class 类名（类名需要使用驼峰体）
class OldBoyStudent: school = 'oldboy' def course(self): print('is choosing course') - 定义函数时，函数只检测语法，不执行代码
- 定义类时，类的代码会在类定义阶段就立刻执行，并会产生一个类的名称空间。
print(OldBoyStudent.__dict__)
{'__module__': '__main__', 'school': 'oldboy', 'course': , '__dict__': , '__weakref__': , '__doc__': None} __dict__就是这个类里面的元素静态函数、类函数、普通函数、全局变量以及一些内置的属性都是放在类__dict__里的
print(OldBoyStudent.__dict__['school'])print(OldBoyStudent.school)
oldboyoldboy
OldBoyStudent.course(123)
is choosing course
OldBoyStudent.country = 'china' # 把country这个元素也放到OldBoyStudent这个类里面去了print(OldBoyStudent.country)print(OldBoyStudent.__dict__)
china{'__module__': '__main__', 'school': 'oldboy', 'course': , '__dict__': , '__weakref__': , '__doc__': None, 'country': 'china'} 定义对象
- 调用类就会产生对象，调用类的过程又称为类的实例化，实例化的结果称为类的对象/实例
调用类就会有一个返回值，该返回值就是类的一个具体的对象
stu1 = OldBoyStudent()print(stu1.school)print(stu1.country)
oldboychina
stu2 = OldBoyStudent()stu2.name = 'hades'print(stu2.school)print(stu2.country)print(stu2.name)print(stu1.name) # 报错，stu1这个对象根本就没有name这个变量名
oldboychinahades---------------------------------------------------------------------------AttributeError Traceback (most recent call last)in 4 print(stu2.country) 5 print(stu2.name)----> 6 print(stu1.name) # 报错，stu1这个对象根本就没有name这个变量名AttributeError: 'OldBoyStudent' object has no attribute 'name'
如此可以证明每一个对象之间是相互独立的，互不干扰，但如果类的属性发生变化，所有的对象也会发生变化，就如上面OldBoystudent.country = 'china'，所有的类的对象都具备了这个属性
定制对象的独有特征
定制对象独有属性
class Student: school = 'oldboy' def choose_course(self): print('is choosing course') stu1 = Student()stu2 = Student()stu3 = Student()print(stu1.__dict__)print(stu2.__dict__) {}{} - 对于类的对象，本身和类类似，也是一个名称空间，但是对象的名称空间用来存放对象独有的属性，而类中存放的是对象们共有的名字。因此我们可以直接为对象单独赋予属性而不会影响其他对象
stu1.name = 'hades'stu1.age = 27stu1.weigth = 120print(stu1.__dict__)print(stu2.__dict__)
{'name': 'hades', 'age': 27, 'weigth': 120}{} stu2.name = 'bonnie'stu2.age = 16stu2.weight = 90print(stu2.__dict__)
{'name': 'bonnie', 'age': 16, 'weight': 90} 类定义阶段定制属性
class Student: school = 'oldboy' def __init__(self,name,age,weight): """类在实例化的时候自动触发""" self.name = name self.age = age self.weight = weight def choose_course(self): print(f'{self.name}is choosing course') try: stu1 = Student() except Exception as e: print(e) __init__() missing 3 required positional arguments: 'name', 'age', and 'weight'
stu1 = Student('hades',27,120)print(stu1.__dict__) {'name': 'hades', 'age': 27, 'weight': 120} - 通过上述现象可以发现，调用类时发生两件事：
- 创造一个空对象
- 自动触发类中
__init__功能的执行，将stu1以及调用类括号内的参数一同传入
对象的属性查找顺序
属性查找
函数的查找顺序为：就近原则，从当前位置向外进行查找，如果当前位置为局部名称空间，则是局部—-》全局——》内置
类的查找顺序为：先从自己的名称空间进行查找，如果找不到，就去类的名称空间进行查找，如果还是找不到就会报错
class Student: school = 'oldboy' count = 0 def __init__(self,name,age,weight): self.name = name self.age = age self.weight = weight Student.count += 1 def choose_course(self): print(f'{self.name}is choosing course') stu1 = Student('hades',27,120)print(stu1.count)stu2 = Student('bonnie',16,90)print(stu1.count)print(stu2.count)stu3 = Student('zhu',2,150)print(Student.count) 1223
print(stu1.__dict__)print(stu2.__dict__)print(stu3.__dict__)
{'name': 'hades', 'age': 27, 'weight': 120}{'name': 'bonnie', 'age': 16, 'weight': 90}{'name': 'zhu', 'age': 2, 'weight': 150} - 由于上述修改的是类的属性，所以所有对象属性都会进行修改
类与对象的绑定方法
类与对象的绑定方法
class Student: school = 'oldboy' def __init__(self,name,age,weight): self.name = name self.age = age self.weight = weight def choose_course(self): print(f'{self.name} is choosing course') def func(self): print('from func') 类的名称空间中定义的属性和函数都是这个类的对象共有的，所有的对象都会有这些属性
对象的名称空间中的属性只是这个对象独有的，属于这个对象私有物品，是不会和其他对象进行分享的
类的绑定对象
stu1 = Student('hades',27,120)stu2 = Student('bonnie',16,90)stu3 = Student('zhu',2,150)print(stu1.name)stu1.choose_course()print(stu2.age)print(stu3.weight) hadeshades is choosing course16150
- 类中定义的函数就是一个普通的函数，所以我们定义的时候有几个形参我们调用的时候就要传几个实参
对象的绑定方法
类中定义的函数是共享给所有对象的，对象也可以使用，而且是绑定给对象用的
绑定的效果：绑定给谁，就应该由谁来调用，谁来调用就会将谁当作第一个参数自动传入
print(id(stu1.choose_course))print(id(stu2.choose_course))print(id(stu3.choose_course))print(id(Student.choose_course)) # 不相同
2232380939208223238093920822323809392082232383095672
- 补充：类中定义的函数，类确实可以使用，但其实类定义的函数大多情况下都是绑定给对象用的，所以在类中定义的函数都应该自带一个参数self
stu1.choose_course()stu2.choose_course()stu3.choose_course()
hades is choosing coursebonnie is choosing coursezhu is choosing course
类与数据类型
类与数据类型
- python3中统一了类与类型的概念，类就是类型
class Foo: passobj = Foo()lis1 = [1,2,3]lis2 = list([4,5,6])print(type(obj))print(lis1)print(lis2)print(type(lis))
[1, 2, 3][4, 5, 6]
- lis1和lis2都是list类实例化的对象，因此lis2使用append方法与lis1无关
lis2.append(7)print(lis1)print(lis2)
[1, 2, 3][4, 5, 6, 7]
list.append()方法原理
class Student: school = 'oldboy' def __init__(self,name,age,weight): self.name = name self.age = age self.weight = weight def choose_course(self): print(f'{self.name} is choosing course') def func(self): print('from func') stu1 = Student('hades',27,120) stu1.choose_course()
hades is choosing course
Student.choose_course(stu1)
hades is choosing course
lis = [1,2,3]lis.append(4)print(lis)list.append(lis,5)print(lis)
[1, 2, 3, 4][1, 2, 3, 4, 5]
对象的高度整合
对象和函数一样，可以引用、作为返回值、作为参数、作为容器元素
在类里面封装了一大堆特征/数据，然后又封装了一大堆方法（方法用来专门用来操控这些数据的），并且在这基础上对于不同对象，这些属性和方法有不一样