初次面向对象

面向过程的概念

面向过程核心：过程
	解决问题的流程，即先干什么，之后干什么，最后干什么
举例：
	1.洗衣服。步骤
	2.把大象关进冰箱。步骤
	3.流水线。步骤
优点:复杂的问题流程化，进而简单化
缺点:牵一发而动全身，扩展性差，可维护性差
应用场景:对扩展性要求不高的地方：安装包的使用

代码案例：
	用户注册：
		1.用户输入用户名，密码
		2.验证参数
		3.写入数据，注册成功

# 1.获取用户输入
def interactice():
	usernema = input('请输入姓名：').strip()
	password = input('请输入密码：').strip()
	return {
			'username':username,
			'password':password
			}
# 2.验证参数
def check_info(userinfo):
    '''
    userinfo = {
	'username':username,
	'password':password
    }
    
    '''
	is_calid = True
	if len(userinfo['username']) == 0:
		print('用户名不能为空')
		is_valid = False
	if len(userinfo['password']) == 0:
		print('密码不能为空')
		is_valid = False
	return {
		'is_valid':is_valid
		'userinfo':userinfo
    }

# 3.写入数据，注册成功
def register(param):
	'''
	param = {
	'is_valid':is_valid
	'userinfo':userinfo
	}
	'''
	import json
	if param['is_valid']:
		with open('userinfo','w',encoding='utf8') as f:
			json.dump(param['userinfo'],f)
def main():
	# 1.接收用户信息
	userinfo = interactice()
	# 2.判断用户输入
	info = check_info(userinfo)
    # 3.注册
	register(info)

if__name__ == '__main__':
    main()

面对对象概念

面对对象核心：对象
	1.程序中：
		对象是盛放数据属性和方法的容器
	2.现实中：
		对象就是特征与技能的结合体
优点：扩展性强，可维护性强
缺点：编程复杂度高
应用场景：用在扩展性要求高的地方。微信，QQ

代码案例：
	学生选课系统
def choose_course(stu_dic, course):
	'''
	stu_dic
	stu1 = {
    'name': 'xxx',
    'age': 18,
    'gender': 'male',
    'courses': [],
    'choose_course': choose_course
	}
	'''
    stu_dic['courses'].append(course)
    print("%s选课成功 %s" % (stu_dic['name'], stu_dic['courses']))

# 定义一个自己的字典，里面包含自己的信息和定义的函数
stu1 = {
    'name': 'xxx',
    'age': 18,
    'gender': 'male',
    'courses': [],
    'choose_course': choose_course
}
# 其中包含自己的属性和方法
# 将自己信息里面的函数取出并使用，然后传入自己，加上信息
stu1['choose_course'](stu1,'sss')

类的概念

对象：特征与技能的结合体
类：一系列对象相似的特征和相似的技能的结合体
# 注意：站在不同的角度，划分的类不一定一样
问题：先有对象还是先有类
	1.程序中
		必须先定义类，然后调用类产生对象
	2.生活中
		现有对象，再有类

类的定义和对象的产生

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

# 强调：站在不同的分类，划分的分类不一定一样

# 问题：
	到底是先有类，还是先有对象
    1.程序中
		必须先定义类，然后调用类产生对象
	2.现实中
		先有对象，再有类

语法定义：
	1.定义函数
		def 函数名():
            函数体代码
	2.定义类
		class 类名():
			类体代码
			定义的属性(变量)
			定义的技能(函数)
		# 在类的定义中运行可以直接运行类体代码

定义类：
	发生了什么事？
	1.立即执行类体代码
	2.产生一个类的名称空间，把类体内的名字扔到类的名称空间中(字典)
	3.在把类的名称空间绑定给__dict__,类名__dict__
    
类名一般情况下首字母大写
class Student():
    # 定义属性
	school = 'SH'
	# 定义一个技能
	def choose_course(stu_dict,course):
		stu_dict['course'].append(course)
        print('%s选课成功 %s' % (stu_dict['name'], stu_dict['course']))

# 查看类的名称空间
print(Student.__dict__)

# 调用类产生对象，默认产生的就是一个空对象{}

stu1 = Student()
print(stu1.__dict__)

给对象定制自己的独有属性和方法

产生的对象是一个空对象，可以定制独有的属性

class Studend():
	# 定义一个属性(所有对象都会有这个属性)
	school = 'SH'
	# 当调用类的时候，会自动调用的函数，
	# 该方法不是一定要定义，需要用到就定义，不需要刻意定义
	def __init__(stu_obj,name,age,gender)：
		# 空对象.name = name # 调用类会产生一个空对象
		# 空对象.age = age
		# 空对象.gender = gender
		stu_obj.name = name  # stu1.__dict__['name'] = 'jason'
		stu_obj.age = age  # stu1.__dict__['age'] = 18
		stu_obj.gender = gender  # stu1.__dict__['gender'] = 'male'、
		# return None # 在这个方法中不能有返回值，
# 定义一个技能(函数)
	def choose_course(stu_dict,course):
		stu_dict['course'].appen(course)
		print('选课成功')
调用类发生了几件事？
'''
	1.得到一个空对象
	2.调用了Student.__dict__(空对象，'name','age','male')
	3.得到一个初始化的结果
'''
stu = Student('qq',10,'male')  # Student(stu,'qq',18,'male')

属性的查找顺序

class Student():
	# 定义一个属性
	school = 'SH'

	def __init__(self, name, age, gender, course=None):
		if course is None:
			course = []
		self.name = name  # stu1.__dict__['name'] = 'jason'
		self.age = age  # stu1.__dict__['age'] = 18
		self.gender = gender  # stu1.__dict__['gender'] = 'male'
		self.course = course
	def choose_course(self, course):
		# stu_dict => stu
		self.course.append(course)
		print('%s选课成功 %s' % (self.name, self.course))

	def func(self, name, age):
		pass
# 属性的查找：
	1.类属性：在类中写的属性就是称为类属性
	2.对象属性：在对象自己的名称空间中的属性就是对象属性
# 类属性的查找
1.查
print(Student.schllo)  # 类点其中的属性
2.增
Student.country = 'China'  # 增加属性
3.改
Student.school = 'BJ'  # 修改所对应的属性
4.删
del Student.school  # 删除所对应的属性
print(Student.__dict__)  # 查看类中的属性
{}
stu = Student('ly', 18, 'male')  # 实例化对象， stu就是一个实例
# 对象属性的查找
1.查
print(stu.name)  # 对象点name就是字典点get(K的值)
2.增
stu.aaa = 'aaa'  # 直接增加K键，然后所对应V键
3.改
stu.name = 'bbb'  # 根据K键直接更改V
4.删
del stu.name  # 直接删掉整个键值对

# 类中的方法，类可以调用，对象也可以调用
类调用方法
Student.choose_course(stu,'python')  # 类来调用，函数的参数有几个就要传几个
print(Student.choose_course)
# 对象调用方法
# 类中的方法，类可以调用，对象也可以调用，但是推荐对象来调用，因为对象来调用，会把自己当成第一个参数传递给函数

stu.choose_course('python')  # stu.shoose_course(stu,'python')
stu1.choose_course('linux') # stu.choose_course(stu, 'linux')