面向过程编程
-
前言:编程不就编程吗?怎么还有这么多的洋气词后缀??今天主要介绍一下面向过程和面向对象是什么。
大白话版本:面向过程编程可以比作是做一道菜,那么做一道菜分为几步呢??
- 准备食材
- 起锅烧油
- 放辅料
- 炒菜
- 出锅
最高端的食材往往只需要最简单的烹饪方式,呸,撤回来昂。这个过程,分布来,按部就班的,一步一步的过程为面向过程。
如果还不理解的话,那么想一想,把大象装进冰箱需要几步?😢😢😢,显然是三步了,打开冰箱把大象塞进去,关上冰箱!
- 面向过程编程其实也是一样的,将编程要实现的目标,按步骤实现,每一步就是一个过程!
实例一:
# 做菜的步骤,通过面向过程编程实现
def step1():
print('第一步,准备食材')
def step2():
print('第二步,起锅烧油')
def step3():
print('第一步,放辅料')
def step4():
print('第一步,炒菜')
def step5():
print('第一步,出锅')
def mainstep():
step1()
step2()
step3()
step4()
step5()
print('感谢老板祝老板生八个儿子')
mainstep()
#结果
第一步,准备食材
第二步,起锅烧油
第一步,放辅料
第一步,炒菜
第一步,出锅
感谢老板祝老板生八个儿子
实例二:
# 用户注册功能
'''
1.获取用户名和密码
2.组织成固定的格式
3.文件操作写入文件
'''
# 定义获取用户信息函数
def get_info():
username = input('please input your name>>>:').strip()
pwd = input('please input your pwd>>>:').strip()
if len(username) == 0 or len(pwd) == 0:
print('your username or name is empty,please try again!')
return
else:
user_id = {
'1': 'admin',
'2': 'user'
}
print(user_id)
choice = input('please choice your position:')
if choice == '1':
id = user_id[choice]
print('you are admin!')
elif choice == '2':
id = user_id[choice]
print('you are user!')
return make_info(username, pwd, id)
# 处理信息格式
def make_info(username, pwd, id):
data = f'{username}|{pwd}|{id}\n'
return save_info(data)
# 存储到文件
def save_info(data):
with open(r'user_info.txt', 'a', encoding='utf8') as f:
f.write(data)
print('sign success!')
# 调用主体函数
get_info()
# 结果
please input your name>>>:hammer
please input your pwd>>>:123
{'1': 'admin', '2': 'user'}
please choice your position:1
you are admin!
sign success!
牛逼定义:面向过程的程序设计把计算机程序视为一系列的命令集合,即一组函数的顺序执行。为了简化程序设计,面向过程把函数继续切分为子函数,即把大块函数通过切割成小块函数来降低系统的复杂度
一、面向对象
-
前言:面向对象,此对象非彼对象,面向对象的核心在于“对象”二字。
大白话版本:面向对象可以理解为,做菜的过程我们创造了一个机器人,把食材准备好和步骤写入机器人,那么可以理解为食材是我们需要的“数据”,如何做菜的步骤理解为“功能”,这个就是面向对象,总的来说就是定义出一系列的功能来对数据进行操作
-
-
程序中对象:对象是把数据和功能整合到一起的产物,或对象就是盛放数据与功能的容器
-
现实生活中:对象就是特征和技能的结合体
示例如下:
# 未学习面向对象前,所有数据和功能都是散开的
# 数据
name = 'HammerZe'
course = []
# 功能
def add_course(name,course):
course.append('python')
print(f"学生{name}选课{course}")
add_course(name,course)
# 结果
学生HammerZe选课['python']
这样我们发现,如果有100个学生需要和格式化输出结果怎么办?写100次吗?是不是非常的麻烦
# 升级版
def add_course(user_info,course):
user_info['course'].append(course)
print(f"学生{user_info['name']}选课{user_info['course']}")
user_info = {
'name': 'HammerZe',
'course':[],
'add_course':add_course,
}
user_info['add_course'](user_info,'python')
# 结果
学生HammerZe选课['python']
'''通过整合,把数据和功能写在一起,结果是一样的'''
类和对象
二者区别
-
生活中
-
对象:特征与技能的结合体
-
类:具有相似的特征,相似的技能归为一类,
-
例如:西瓜和哈密瓜可以归为一水果类,
狗和猫可以归为动物一类·····
-
强调:站在不同的分类角度,划分的类可能不一样,是先有对象,才有类的
-
-
程序中:
- 对象:数据和功能的结合体
- 类:具有相似数据,相似功能 的为一类
- 强调:必须先定义类,再调用类产生对象
定义格式:
-
定义函数
def 函数名():
pass
-
定义类:
class 类名():
pass
类比两者记忆
定义类发生的事情
- 立即执行类内代码
- 产生一个类的名称空间,把类内执行的名字都丢到名称空间中(丢到大字典中)
- 把类的名称空间绑定给__ dict __,
类名 . __dict__
查看名称空间
示例如下:
class Student():
def add_course(user_info, course):
user_info['course'].append(course)
print(f"学生{user_info['name']}选课{user_info['course']}")
print('调用类就会执行我!!')
# 查看类的名称空间
print(Student.__dict__)
# 产生对象:调用类的时候产生一个空对象{}
stu1 = Student()
# 查看对象的名称空间
print(stu1.__dict__) # {}
定义类的标准格式
用学生类举例
class Student():
# 初始化
def __init__(self,name,age):
self.name = name # stu.__dict__['name'] = 'Hammer'
self.age = age
'''注意:return 在这个方法中不能有返回值'''
# 选课方法
def choose_course(stu_dict,course):
stu_dict['course'].append(course)
print(f"学生{stu_dict['name']}选课{course}")
stu = Student('HammerZe',18)
'''1.调用类产生一个空对象
2.调用了Student.__dict__(空对象,'HmmerZe',18)'''
# 查看类的名称空间
print(Student.__dict__)
# 查看对象的名称空间
print(stu.__dict__)# {'name': 'HammerZe', 'age': 18}
# 取值
print(stu.__dict__['name'])
print(stu.name)
属性的查找顺序
- 属性的查找:
- 类属性:在类中的属性就称为类属性
- 对象属性:在对象自己的名称空间中属性就是对象属性
- 注意:
- 属性的查找:先从自己的对象中查找,然后在去产生对象的类中取找
如果使用dict从对象的名称空间获取值,找不到会报错
使用.获取值,在自己的名称空间找不到会取类的名称空间查找
- 属性的查找:先从自己的对象中查找,然后在去产生对象的类中取找
示例如下
class Student():
# 初始化
school = 'SH'
def __init__(self, name, age,course = None):
if course is None:
course = []
self.name = name # stu.__dict__['name'] = 'Hammer'
self.age = age
self.course = course
'''注意:return 在这个方法中不能有返回值'''
# 选课方法
def choose_course(self, course):
self.course.append(course)
print(f"学生{self.name}选课{self.course}")
stu = Student('HammerZe', 18)
'''1.调用类产生一个空对象
2.调用了Student.__dict__(空对象,'HmmerZe',18)'''
''' 属性的查找:先从自己的对象中查找,然后在去产生对象的类中取找
如果使用__dict__从对象的名称空间获取值,找不到会报错
使用.获取值,在自己的名称空间找不到会取类的名称空间查找
'''
# 类的查找
# 查看名称空间
print(Student.__dict__)
# 查看值
print(Student.school) # SH
# 查看方法
print(Student.choose_course)
# 类的增加
Student.country = 'China'
print(Student.__dict__['country']) # China
# 类的修改
Student.school = 'BJ'
print(Student.__dict__['school']) # BJ
# 类的删除
del Student.school
print(Student.__dict__.get('school')) # None
''' 底层为字典可以用get '''
# 对象的增删查改
# 查看名称空间
print(stu.__dict__) # {'name': 'HammerZe', 'age': 18}
# 查看值
print(stu.name) # HammerZe
# 修改值
stu.name = 'Ze'
print(stu.name) # Ze
# 增加值
stu.gender = 'male'
print(stu.__dict__) # {'name': 'Ze', 'age': 18, 'gender': 'male'}
# 删除值
del stu.gender
print(stu.__dict__) # {'name': 'Ze', 'age': 18}
# 方法的调用
# 类调用
Student.choose_course(stu,'python') # 学生Ze选课['python']
# 对象调用
stu.choose_course('java') # 学生Ze选课['python', 'java']
-
注意:类中的方法,类可以调用,对象也可以调用, 但是,推荐对象来调用,因为对象来调用,会把自己当成第一个参数传递给函数