第五章---面向过程编程

Posted mumupa0824

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了第五章---面向过程编程相关的知识,希望对你有一定的参考价值。

编程范式(流派):
面向对象编程,面向过程编程 各有用处!!
编程:语法+数据结构(list dict)+算法(逻辑)

1.面向过程编程:核心是过程二字,过程指得是解决问题的步骤,相当于设计一条流水线,机械式的思维方式

       优点:复杂的问题流程化,进而简单化
       缺点:可扩展性差
       运用场景:系统监控脚本,自动部署脚本之类的,eg:软件包解压安装(不再需要扩展了)就可以使用面向过程的思维编写代码


 1 \'\'\'
 2 面向过程实例:用户登录注册
 3 第一步:用户输入用户名密码
 4 第二步:检查输入的合法性
 5 第三步:注册
 6 \'\'\'
 7 
 8 import json
 9 def interaction(): # 用户交互函数,用户用户输入用户名密码
10     name = input(\'name:\').strip()
11     pwd = input(\'pwd:\').strip()
12 
13     return {\'name\':name,
14              \'pwd\':pwd
15             }
16 
17 def check(user_info): # 用户校验函数,用户校验用户名密码的合法性
18     is_legal = True
19 
20     if len(user_info[\'name\']) == 0:
21         print(\'用户姓名不能为空!\')
22         is_legal = False
23 
24     if len(user_info[\'pwd\']) < 6:
25         print(\'用户密码不能少于6位!\')
26         is_legal = False
27     return {\'is_legal\':is_legal,
28              \'user_info\':user_info
29             }
30 
31 def register(check_info): # 注册
32     if check_info[\'is_legal\']:
33         with open(\'db.json\',\'w\',encoding=\'utf-8\') as f:
34             json.dump(check_info[\'user_info\'],f)
35 
36 def main():
37     user_info = interaction()
38     check_info = check(user_info)
39     register(check_info)
40 
41 if __name__ == \'__main__\':
42     main()

 

2.面向对象:核心就是对象二字,对象就是特征与技能的结合体

优点:可扩展性强
缺点:编程复杂度高
应用场景:用户需求经常变化,互联网应用,游戏,企业内部应用

类就是一系列对象相似的特征与技能的结合体
强调:站在不同的角度,得到的分类是不一样的

在现实世界中:一定是先有对象,后又类
在程序中:一定先定义类,后调用类产生对象

站在路飞学院的角度,大家都是学生

在现实世界中:
对象1:mm
特征:
学校=\'luffycity\'
名字=\'mm\'
性别=\'女\'
年龄=18
技能:
学习
吃饭
睡觉

对象2:mumu
特征:
学校=\'luffycity\'
名字=\'mumu\'
性别=\'男\'
年龄=1
技能:
学习
吃饭
睡觉

对象3:zz
特征:
学校=\'luffycity\'
名字=\'zz\'
性别=\'男\'
年龄=20
技能:
学习
吃饭
睡觉

总结现实中路飞学院的学生类:
相似的特征
学校=\'luffycity\'

相似的技能
学习
吃饭
睡觉
 1  1 # 先定义类:
 2  2 class LuffyStudengt:
 3  3     school = \'luffycity\'
 4  4     def learn(self):
 5  5         print(\'is learning\')
 6  6     def eat(self):
 7  7         print(\'is eating\')
 8  8     def sleep(self):
 9  9         print(\'is sleepping\')
10 10 
11 11 # 后产生对象
12 12 stu1 = LuffyStudengt()  # 实例化

 

3.如何使用类:

   先定义类:
   特征:变量 school
   技能:函数

类和函数的区别:
定义函数只有调用函数名加()才执行
定义类的时候类的内部代码都会执行

类的用途:
1.操作它的属性 增删改查
2.实例化 产生对象
 1 class LuffyStudengt:
 2     school = \'luffycity\'  # 数据属性
 3     
 4     def learn(self):      # 函数属性
 5         print(\'is learning\')
 6     def eat(self):     # 函数属性
 7         print(\'is eating\')
 8     def sleep(self):    # 函数属性
 9         print(\'is sleepping\')
10 
11 # 查看类的名称空间
12 print(LuffyStudengt.__dict__)
13 print(LuffyStudengt.__dict__[\'school\'])
14 
15 # 查:
16 print(LuffyStudengt.school) # == print(LuffyStudengt.__dict__[\'school\'])
17 
18 # 增:
19 LuffyStudengt.country = \'China\'
20 print(LuffyStudengt.__dict__)
21 
22 #
23 del LuffyStudengt.country
24 print(LuffyStudengt.__dict__)
25 
26 #
27 LuffyStudengt.school = \'Luffycity\'
28 print(LuffyStudengt.__dict__)

 

4.__init__方法

__init__方法用来为对象定制对象自己独有的特征

__init__实例化对象时会自动调
 1 class LuffyStudengt:
 2     school = \'luffycity\'
 3 
 4     # stu1,\'mm\',\'女\',18
 5     def __init__(self,name,sex,age):
 6         self.Name = name
 7         self.Sex = sex
 8         self.Age = age
 9 
10     def learn(self):
11         print(\'is learning\')
12     def eat(self):
13         print(\'is eating\')
14     def sleep(self):
15         print(\'is sleepping\')
16 
17 # 后产生对象
18 stu1 = LuffyStudengt(\'mm\',\'\',18)  # 实例化
19 
20 # 加上__init__方法后实例化的步骤
21 # 1.先产生一个空对象stu1
22 # 2.LuffyStudent.__init__(stu1,\'mm\',\'女\',18)
23 
24 #
25 print(stu1.__dict__)
26 print(stu1.Name)
27 
28 # 改:
29 stu1.Name = \'梦梦\'
30 print(stu1.__dict__)
31 print(stu1.Name)
32 
33 # 删除:
34 del stu1.Name
35 print(stu1.__dict__)
36 
37 # 增:
38 stu1.classname = \'python全站开发\'
39 print(stu1.__dict__)
40 
41 stu2=LuffyStudent(\'mumu\',\'\',1) #Luffycity.__init__(stu2,\'mumu\',\'男\',1)
42 print(stu2.__dict__)
43 print(stu2.Name)

 

5.属性查找与绑定方法

 1 class LuffyStudengt:
 2     school = \'luffycity\'
 3 
 4     # stu1,\'mm\',\'女\',18
 5     def __init__(self,name,sex,age):
 6         self.Name = name
 7         self.Sex = sex
 8         self.Age = age
 9 
10     def learn(self):
11         print(\'%s is learning\'% self.Name)
12     def eat(self):
13         print(\'%s is eating\'% self.Name)
14     def sleep(self):
15         print(\'%s is sleepping\'% self.Name)
16 
17 # 后产生对象
18 stu1 = LuffyStudengt(\'mm\',\'\',18)  # 实例化
19 stu2 = LuffyStudengt(\'mumu\',\'\',1)
20 stu3 = LuffyStudengt(\'zz\',\'\',20)
21 
22 # 对象:特征和技能的结合体
23 # 类:类是一系列对象相似的特征与相似的技能的结合体
24 
25 # 类中的数据属性:是所有对象共有的
26 # print(stu1.school,id(stu1.school))
27 # print(stu2.school,id(stu2.school))
28 # print(stu3.school,id(stu3.school))
29 #
30 # # luffycity 6854800
31 # # luffycity 6854800
32 # # luffycity 6854800
33 # 类中的函数属性:是绑定给对象使用的,绑定到不同的对象是不同的绑定方法
34 # 对象调用绑定方法时,会把对象本身当做第一个参数传入,传给self
35 # print(LuffyStudengt.learn)
36 # LuffyStudengt.learn(stu1)
37 
38 # print(stu1.learn)
39 # stu1.learn()
40 # print(stu2.learn)
41 # print(stu3.learn)
42 
43 # 变量查找顺序:首先会在对象的名称空间中找,找不到在去类的名称空间找,然后去父类的名称空间找,还找不到就不会去全局找了
44 stu1.x = \'from stu1\'
45 LuffyStudengt.x = \'from LuffyStudent\'
46 
47 print(stu1.x)
48 # from stu1

 

6.补充知识
1.站的角度不同,定义出的类是截然不同的;
2.现实中的类并不完全等于程序中的类,比如现实中的公司类,在程序中有时需要拆分成部门类,业务类等;
3.有时为了编程需求,程序中也可能会定义现实中不存在的类,比如策略类,现实中并不存在,但是在程序中却是一个很常见的类。

4.python 一切皆对象,在python3里统一了类与类型(list dict)的概念
 1 # print(type([1,2]))
 2 # print(list)
 3 class LuffyStudent:
 4     school = \'luffycity\'
 5 
 6     def __init__(self,name,sex,age):
 7         self.Name=name
 8         self.Sex=sex
 9         self.Age=age
10 
11     def learn(self,x):
12         print(\'%s,%s is learning\' % (self.Name,x))
13 
14     def eat(self):
15         print(\'%s is eatting\' % self.Name)
16 # print(LuffyStudent)
17 
18 li1 = [1,2,3] # li = list(1,2,3) # list 对象
19 li1.append(4) # 对象在调自己的绑定方法 # list.append(li1,4)
20 # list.append(li1,4) # 类中的方法 是给 对象用的
21 print(li1)

 

7.可扩展性高
 1 class Chinese:
 2     country = \'China\'
 3     def __init__(self,name,age,sex):
 4         self.name=name
 5         self.age=age
 6         self.sex=sex
 7     def eat(self):
 8         print(\'%s is eating\' % self.name)
 9 
10 p1 = Chinese(\'alice\',19,\'\')
11 p2 = Chinese(\'alex\',22,\'\')
12 
13 print(p1.name,p1.country)
14 print(p2.name,p2.country)
15 p1.eat()
16 p2.eat()

 

 

以上是关于第五章---面向过程编程的主要内容,如果未能解决你的问题,请参考以下文章

第五章:面向对象1

第五章 面向对象编程设计与开发——续2

第五章 面向对象编程设计与开发——续

java面向对象编程——第五章 对象的行为

使用java实现面向对象 第五章

第五章 使用java实现面向对象异常