- 面向过程
- 核心是过程二字，过程指的是解决问题的步骤，设计一条流水线，机械式的思维方式
- 优点：复杂的问题流程化，进而简单化
- 缺点：可扩展性差
- 面向对象：
- 核心是对象二字，以上帝的视角，所有的物体都是对象，对象是特征与技能的结合体
- 优点：可扩展性强
- 缺点：编程复杂度高
- 应用场景：用户需求经常变化：互联网应用，游戏，企业内部应用
- 类：一些列对象相似的特征与技能的结合体
- 强调：站在不同的角度，得到的分类是不一样的
- 在现实世界中：先有对象，再有类
- 在程序世界中：先有类，再有对象，类相当于一个模型，定义好模型后，就可以照着这个模子生产对象了
- 类在定义阶段，内部函数已经运行，这一点与函数不同，函数是在调用时才运行
- 创建类和对象
1 #定义类：程序中，先定义类（首字母大写）
2 class OldboyStudent:
3 school = "oldboy"
4 def learn(self):
5 print("is learning")
6 def eat(self):
7 print("is eatting")
8 def sleep(self):
9 print("is sleeping")
- 类的使用
-
1 #查询
2 print(OldboyStudent.school)#oldboy
3 #改
4 OldboyStudent.school = "Oldboy"
5 print(OldboyStudent.school)#Oldboy
6 #增
7 OldboyStudent.x = 1
8 print(OldboyStudent.x)#1
9 #删
10 del OldboyStudent.x
11 print(OldboyStudent.x)#没找到，报错
-
- __init__方法和对象的使用（__init__方法用来为对象定制自己独有的属性）
- 加上__init__后，实例化的步骤为：
- 1.先产生一个空对象s1
- 2.OldboyStudent.__init__(s1,"Jone","男",23)
-
1 class OldboyStudent:
2 def __init__(self,name,age,sex):
3 self.name = name
4 self.age = age
5 self.sex = sex
6 s1 = OldboyStudent("Jone","男",23)#先调用类产生空对象s1，然后调用oldboy_student.__init__(s1,"Jone","男",23)
7 s2 = OldboyStudent("Tony","男",24)
8 s3 = OldboyStudent("Lucy","女",20)
9 #查
10 print(s3.__dict__)#{'name': 'Lucy', 'age': '女', 'sex': 20}
11 print(s3.name)#Lucy，和下面的代码等价
12 print(s3.__dict__["name"])#Lucy
13 #增
14 s3.course = "python"#等同于s3.__dict__["course"]="python
15 #删
16 del s3.course #等同于s2.__dict__.pop('course')
17 print(s3.course)#报错
- 属性查找：类有两种属性：数据属性和函数属性
- 类的数据属性是所有对象共享的，id都一样
- 类的函数属性是绑定给对象用的，称为绑定到对象的方法，obj.methon称为绑定方法，内存地址都不一样
- 类中定义的函数（没有被任何装饰器装饰的）即为类的函数属性，类可以使用，但必须遵循函数的参数规则，有几个参数需要传几个参数
- 对象本身只有独有的特征，相似的特征放在类中，当对象在查找一个属性时，首先从自己独有的特征中查找，如果没有，再从类中查找
- 补充说明：
- python中一切皆为对象，在python3中统一了类和类型的概念
- 定义一个数字，实际上是创建了一个int类的对象
-
1 #绑定方法
2 class OldboyStudent:
3 school = "oldboy"#类的数据属性，所有对象共享，id都一样
4 def __init__(self, name, age, sex):
5 self.name = name
6 self.age = age
7 self.sex = sex
8 def learn(self):#类的函数属性
9 print("%s is learning"%self.name)
10 def eat(self):
11 print("%s is eatting"%self.name)
12 def sleep(self):
13 print("%s is sleeping"%self.name)
14 s1 = OldboyStudent("Jone","男",23)#需遵循函数的参数规则，传入相应个数的参数
15 s2 = OldboyStudent("Tony","男",24)
16 s3 = OldboyStudent("Lucy","女",20)
17 #类的数据属性，所有对象共享的，id都一样
18 # print(id(OldboyStudent.school))#42042400
19 # print(id(s1.school))#42042400
20 # print(id(s2.school))#42042400
21 # print(id(s3.school))#42042400
22 #类的函数属性，类中定义的函数即类的函数属性
23 # 类的函数属性是绑定给对象使用的，obj.method称为绑定方法，内存地址都不一样
24 # print(OldboyStudent.learn)#<function OldboyStudent.learn at 0x00000000027E40D0>
25 # print(s1.learn)#<bound method OldboyStudent.learn of <__main__.oldboy_student object at 0x00000000027E75C0>>
26 # print(s2.learn)#<bound method OldboyStudent.learn of <__main__.oldboy_student object at 0x00000000027E75F8>>
27 # print(s3.learn)#<bound method OldboyStudent.learn of <__main__.oldboy_student object at 0x00000000027E7630>>
28 #绑定方法
29 s1.learn()#Jone is learning
30 OldboyStudent.learn(s1)#Jone is learning
31 #以上两句代码是等同的，绑定到对象的方法的这种自动传值的特征，决定了在类中定义的函数都要默认写一个参数self，
32 #self可以是任意名字，但是约定成俗地写成self