您的位置: 首页  >  IT文章  >  Day5-1 面向对象和面向过程

Day5-1 面向对象和面向过程

分类: IT文章 • 2024-03-05 07:51:40

摘要:

类的定义

类的增删改查

对象的增删改查 

对象的查找和绑定

面向对象和面向过程的区别:

1.面向过程就像是工厂的流水线,按部就班的有序的工作.

优点:把复杂的问题简单化

缺点:可扩展性差.一个步骤改动,其他的步骤几乎都要跟着改动.

适用:功能一旦实现之后就很少需要改变的场景.

2.面向对象:

2-1 什么是对象?

对象的具有一些特征和方法的集合.比如孙悟空是一个对象,他的特征是 毛脸雷公嘴,金箍棒,金箍圈.他的方法(技能)七十二变,火眼金睛.

优点:可扩展性强

缺点:编程复杂度高.

适用:互联网应用,企业应用,游戏.

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

在不同的角度,获取的类是不一样的.比如在生物类的角度看,人,花草树木都是一类的,归于生物类.在人类的角度,人类是单独的类别,花草树木是植物类.

那么是先对有对象还是现有类? 

在现实世界中:现有对象,再有类.

在程序中:要先定义类,再通过调用类产生对象.

类与函数的区别:

函数只有在被调用的时候,才会产生一个局部名称空间来存放函数体中的变量.

类一旦定义好了,就会产生一个局部名称空间来存放类体中的变量

注意：
  1.类中可以有任意python代码，这些代码在类定义阶段便会执行
  2.因而会产生新的名称空间，用来存放类的变量名与函数名，可以通过 类名.__dict__查看
  3.对于经典类来说我们可以通过该字典操作类名称空间的名字（新式类有限制），但python为我们提供专门的.语法
  4.点是访问属性的语法，类中定义的名字，都是类的属性

 

类的定义和增删改查:

 1 #在程序中:先定义类
 2 class Luffycity():
 3     school = "路飞学城"     # 这个叫数据属性
 4 
 5     def eat(self):         # 函数属性
 6         print("is eating")
 7 
 8     def sleep(self):
 9         print("is sleeping")
10 
11     def learn(self):
12         print("is learning")
13 
14 # 查看类的名称空间:
15 print(Luffycity.__dict__)
16 # 查看类的名称空间中变量或者函数
17 print(Luffycity.__dict__["school"])
18 print(Luffycity.__dict__["learn"])
19 print(Luffycity.__dict__["eat"])
20 # 下面的语句等同于上面的查看方法
21 print(Luffycity.school)
22 print(Luffycity.learn)
23 print(Luffycity.eat)
24 # 增加一个类,比如增加一个country = china
25 Luffycity.country ="china"
26 print(Luffycity.country)
27 
28 # 删除一个类数据类型
29 del Luffycity.country
30 print(Luffycity.__dict__)
31 
32 # 修改,把路飞学城修改成luffycity
33 Luffycity.school = "luffycity"
34 print(Luffycity.school)
类的定义和增删改查

 实例化对象和对象的增删改查:

 1 在现实世界中,对象和类:
 2     对象1.李春花
 3         特征:
 4             学校="路飞学城"
 5             名字="李春花"
 6             性别="女"
 7             年龄=20
 8         技能:
 9             吃饭
10             睡觉
11             学习
12        对象2.小狗剩
13         特征:
14             学校="路飞学城"
15             名字="小狗剩"
16             性别="男"
17             年龄=30
18         技能:
19             吃饭
20             睡觉
21             学习
22        对象3.王武
23         特征:
24             学校="路飞学城"
25             名字="王武"
26             性别="男"
27             年龄=18
28         技能:
29             吃饭
30             睡觉
31             学习
32 
33 现实生活中路飞学城的学生类:
34         相似的特征:
35         学校="路飞学城"
36         相似的技能:
37         吃饭
38         睡觉
39         学习
40 """
41 #__init__ 方法为对象定义独有的特征.
42 class Luffycity():
43     school = "路飞学城"
44         #          stu1,"李春花",20,"女"
45     def __init__(self,name,age,sex):
46         self.Name=name
47         self.Age=age
48         self.Sex=sex
49 
50     # __init__初始化的过程相当于
51     #self.Name="李春花"
52     #self.Age=20
53     #self.Sex="女"
54 
55     def eat(self):
56         print("is eating")
57 
58     def sleep(self):
59         print("is sleeping")
60 
61     def learn(self):
62         print("is learning")
63 
64 #stu1 = Luffycity()      # 实例化,产生一个对象,但是每个stu1只有学校是一样的,他们的姓名年龄性别都有不同,该怎么办呢?
65 #stu1 = Luffycity()     # 使用了__init__方法后,如果我们不按位置参数传参的话,会报少3个位置参数的错误.
66 stu1=Luffycity("李春花",20,"女")        # Luffycity.__init__(stu1,"李春花",20,"女")
67 # 我们来剖析一下加上__init__方法后,实例化的过程
68 #1.产生一个空的对象stu1
69 #2.Luffycity.__init__(stu1,"李春花",20,"女")    #self表示的就是对象自己
70 
71 #stu1对象经过实例化,也产生了3个数据属性.通过__dict__也能查看
72 print(stu1.__dict__)
73 
74 
75 # 对象的增删改查
76 
77 # 查看
78 print(stu1.Name)
79 # 删除
80 del stu1.Name
81 print(stu1.__dict__)
82 # 修改
83 stu1.Name = "王春花"
84 print(stu1.__dict__)
85 #增加
86 stu1.class_name = "python全栈开发"
87 print(stu1.__dict__)
88 
89 对象的增删改查
对象的增删改查

对象的查找和绑定函数数据: 

 1 class Luffycity():
 2     school = "路飞学城"
 3         #          stu1,"李春花",20,"女"
 4     def __init__(self,name,age,sex):
 5         self.Name=name
 6         self.Age=age
 7         self.Sex=sex
 8 
 9     # __init__初始化的过程相当于
10     #self.Name="李春花"
11     #self.Age=20
12     #self.Sex="女"
13 
14     def eat(self):
15         print("%s is eating" % self.Name)
16 
17     def sleep(self):
18         print("is sleeping")
19 
20     def learn(self,x):
21         print("%s is learning in %s" % (self.Name,x))
22 
23 
24 stu1 = Luffycity("李春花", 20, "女")
25 stu2 = Luffycity("小狗剩", 30, "男")
26 stu3 = Luffycity("王武", 18, "男")
27 # 对象:特征与技能的结合体
28 #类:一系列对象的相似的特征与相似的技能的结合体
29 
30 # 类中的数据属性:所有对象共有的. 我们看到对象和类的school的ID是一样的.说明他们引用的是同一个数据属性
31 print(Luffycity.school, id(Luffycity.school))
32 print(stu1.school, id(stu1.school))
33 print(stu2.school, id(stu2.school))
34 print(stu3.school, id(stu3.school))
35 # 类中的函数属性:绑定到对象,给对象使用的,但是每个对象的绑定方法不一样.下面输出的函数属性的内存地址都不同,说明分别绑定了对象
36 print(Luffycity.learn)
37 print(stu1.learn)
38 print(stu2.learn)
39 print(stu3.learn)
40 """当对象调用函数属性时,默认会把对象当作第一个参数传给函数属性中的self.也就是说谁调用函数属性,就把谁当作第一个参数传给self,
41 如果函数属性中,还有其他参数,必须传其他参数进去.实际上,类中的函数属性,就是给对象使用的"""
42 
43 stu1.learn("home") # 等价于stu1.learn(stu1,"home"),输出的是:李春花 is learning in home.默认会把stu1传入到self,所以我们不用写stu1
44 
45 
46 # 如果类和对象有一些共同的属性,那么对象去查找这个属性的时候,按照什么顺序呢?
47 stu1.x="i'm stu1"   # 当对象中,有x这个属性的时候,会输出对象本身的属性.
48 Luffycity.x = "i'm luffycity"   # 把上一行注释掉,发现,sut.x输出的是类的x属性.
49 print(stu1.x)                     
50 """把luffycity.x也注释掉,我们在全局设置一个x变量.再次输出stu1.x会报错.说明了查找属性的时候,只会从对象本身或者类中查找,
51 如果类上面还有父类,也会在父类中查找"""
绑定和查找

相关推荐