面向对象

本文主要是介绍面向对象，对大家解决编程问题具有一定的参考价值，需要的程序猿们随着小编来一起学习吧！

面向过程的概念

面向过程的核心是过程二字，解决问题的流程；即先做什么，后做什么，最后做什么。
例如：把大象放冰箱
		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'])	
    # 对象的属性查找顺序：先在对象自己的名称空间中查找，如果找不到，去产生对象的类中取查找

这篇关于面向对象的文章就介绍到这儿，希望我们推荐的文章对大家有所帮助，也希望大家多多支持为之网！