面向对象
作者:互联网
面向过程的概念
面向过程的核心是过程二字,解决问题的流程;即先做什么,后做什么,最后做什么。
例如:把大象放冰箱
1.打开冰箱门
2.把大象放冰箱
3.关上冰箱门
优点:复杂的问题流程化,进而简单化
缺点:扩展性差(牵一发而动全身),可维护性差
应用场景:对扩展性要求不高的地方;例如:安装包的使用
验证面向过程的扩展性差
# 注册功能
'''
1.用户输入用户名和密码
2.验证参数
3.写入文件,注册成功
'''
# 1. 用户输入用户名和密码
def interactive():
username = input('请输入用户名:').strip()
password = input('请输入密码:').strip()
email = input('请输入邮箱').strip()
return {
'username': username,
'password': password
}
# 2. 验证参数
def check_info(userinfo):
is_valid = False
if len(userinfo['username']) == 0:
print('用户名必须输入')
is_valid = True
if len(userinfo['password']) == 0:
print('密码必须输入')
is_valid = True
return {
'is_valid': is_valid,
'userinfo': userinfo
}
# 3. 写入文件,注册成功
def register(param):
if not param['is_valid']:
with open('userinfo.txt', 'w', encoding='utf-8') as f:
import json
json.dump(param['userinfo'], f)
def main():
# 1. 让用户输入用户名
userinfo = interactive()
# 2. 校验参数
check_param = check_info(userinfo)
# 3. 注册
register(check_param)
if __name__ == '__main__':
main()
如果需要用户输入的不仅仅是用户名和密码,而需要输入更多的信息,就需要一行一行代码查看去进行修改
面向对象的概念
面向对象的核心是对象二字
# 什么是对象?
1.在程序中:对象就是盛放数据属性和功能的容器(盛放数据和函数的容器、一个函数就是一个功能)
2.在现实生活中:对象就是特征与技能的集合体
优点:扩展性强、可维护性强
缺点:简单的问题复杂化
应用场景:对扩展性要求高的地方;例如:微信、QQ
# 以学生选课系统为例推导出面向对象
# 版本1:
stu_name = 'jason'
stu_age = 18
stu_gender = 'male'
stu_courses = []
def choose_course(course):
stu_courses.append(course)
print('%s选课成功%s' % (stu_name, stu_courses))
choose_course('python')
这只是一个学生的信息,学校的学生人数成千上万,即该版本不便于管理
# 版本2:
stu1 = {
'stu_name': 'jason',
'stu_age': 18,
'stu_gender': 'male',
'stu_courses': []
}
def choose_course(stu_dict, course):
stu_dict['stu_courses'].append(course)
print('%s选课成功%s' % (stu_dict['stu_name'], stu_dict['stu_courses']))
choose_course(stu1, 'python')
学生stu1为对象;但是该对象里面只有数据属性,并没有功能(对象是特征与技能的结合体)
# 版本3:将函数名写入字典中
def choose_course(stu_dict, course):
stu_dict['stu_courses'].append(course)
print('%s选课成功%s' % (stu_dict['stu_name'], stu_dict['stu_courses']))
stu1 = {
'stu_name': 'jason',
'stu_age': 18,
'stu_gender': 'male',
'stu_courses': [],
'choose_course': choose_course
}
stu1['choose_course'](stu1, 'python')
类的定义
对象:特征与技能的结合体
# 类:一系列对象相似的特征和相似的技能的结合体
强调:站在不同的角度,划分的分类不一样
问:
到底是先有类还是先有对象?
1. 现实生活中:
一定是先有对象,再有类(先有人 再有人类)
2. 程序中:
必须先定义类,在调用类产生对象(*****)
# 注意事项:类名,遵循变量的命名规范即可,类名一般都是首字母大写
# 类名有多个单词,推荐使用大驼峰(类名的每一个单词的首字母大写)
class Student(): ===> # 定义类
school = 'SH' ===> # 定义类属性
def choose_course(stu_dict, course): ===> # 定义类的方法(在类中,函数被称为方法)
stu_dict['stu_courses'].append(course)
print('%s选课成功%s' % (stu_dict['stu_name'], stu_dict['stu_courses']))
# 定义类发生的几件事?
1. 类定义完成后,会立马执行类体代码
2. 执行类体代码,把类中的名字(变量名和函数名)都丢到类的名称空间去
3. 把类的名称空间绑定给__dict__, 类名.__dict__
查看类的名称空间:
print(Student.__dict__)
产生对象:
stu1 = Student() # 调用类产生对象,把对象赋给stu1
stu2 = Student()
查看对象的名称空间
print(stu1.__dict__) 结果就是一个空字典
print(stu2.__dict__)
给对象定制自己独有的属性
# 版本1:
class Student():
school = 'SH'
def choose_course(stu_dict, course):
stu_dict['stu_courses'].append(course)
print('%s选课成功%s' % (stu_dict['stu_name'], stu_dict['stu_courses']))
stu1 = Student()
stu1.name = 'jason' # stu1.__dict__['name'] = 'jason'
stu1.age = 18 # stu1.__dict__['age'] = 18
stu1.gender = 'male' # stu1.__dict__['gender'] = 'male'
stu1.course = [] # stu1.__dict__['course'] = []
print(Student.__dict__)
print(stu1.__dict__)
这种写法只能给stu1定制属性,如果想给stu2定制属性就会出现重复的代码(出现重复的代码就会想到使用函数,如下面版本2)
# 版本2:把重复的代码封装成函数
class Student():
# 定义类属性
school = 'SH'
# 初始化, 魔术方法
def __init__(stu_dic, name, age, gender, course=[]):
stu_dic.name = name # stu.__dict__['name'] = 'tom'
stu_dic.age = age # stu.__dict__['age'] = 19
stu_dic.gender = gender # stu.__dict__['gender'] = 'male'
stu_dic.course = course # stu.__dict__['course'] = []
# 在类中,函数被称为是方法
def choose_course(stu_dic, course):
stu_dic['courses'].append(course)
print('%s选课成功%s' % (stu_dic['name'], stu_dic['courses']))
stu = Student('tom', 19, 'male',['python']) # 调用类的时候,会自动触发__init__方法,并且,会把对象自己当成第一个参数传给函数
stu1 = Student('kevin', 19, 'male', ['linux']) # 调用类的时候,会自动触发__init__方法,并且,会把对象自己当成第一个参数传给函数
print(stu.__dict__)
print(stu1.__dict__)
'''
调用类的过程也称为是实例化的过程,得到的对象就是一个实例
'''
属性的查找顺序
# 1.类属性
# # 增
# Student.aaa = 'xxx'
# print(Student.__dict__)
# # 删除
# del Student.school
# # 改
# Student.school = 'xxx'
# 查
# print(Student.__dict__['school'])
# print(Student.school)
# 2. 对象属性的增删改查
# 增
stu.x = 'aaa'
# 删除
del stu.x
# 改
stu.x = 'bbb'
# 查
print(stu.school)
# print(stu.__dict__['school'])
# 对象的属性查找顺序:先在对象自己的名称空间中查找,如果找不到,去产生对象的类中取查找
标签:__,stu1,course,面向对象,dict,print,stu 来源: https://www.cnblogs.com/blog-tc/p/15894191.html