面向对象，面向过程 类与对象

面向对象，面向过程 类与对象

面向过程概念

	面向过程核心是过程二字，过程就是先干什么，在干什么，最后干什么
	
	eg:
		1. 开大冰箱门
		2. 把大象放进去
		3. 把门关上
	eg1:
		流水线生产饮料
	优点：复杂的问题简单化，进而流程化
	缺点：扩展性差，可维护性差
	应用场景：应用在扩展性要求不高的地方， eg:安装包的使用
	
	案例：
		用户注册:
			1. 用户输入用户命名， 密码
			2. 验证参数
			3. 写入数据注册成功

面向对象概念

"""
	核心是对象，
		1. 程序中：
			对象是盛放数据属性和方法的容器
		2. 现实生活中：
			对象就是特征与技能的结合体
		eg：
			西游记
	
	优点：
		扩展性强，可维护性强
	缺点：
		编程复杂度高
	应用场景：用在扩展性要求高的地方， eg:微信，qq
	
	案例：
		以学生选课系统为例
"""

类的概念

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

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

# 版本3

class Student():
    # 定义属性
    school = 'SH'
    def __init__(obj,x,y,z):
        obj.stu_name=x
        obj.stu_age=y
        obj.stu_gender=z

    # 当调用类的时候，会自动调用的函数, 初始化方法 （********）
    # def __init__(stu_obj, name, age, gender):
    #     # stu_obj   => stu1
    #     stu_obj.name = name  # stu1.__dict__['name'] = 'egon'
    #     stu_obj.age = age,  # stu1.__dict__['age'] = 18
    #     stu_obj.gender = gender  # stu1.__dict__['gender'] = 'male'

    def choose_course(stu_dic, course):
        stu_dic['courses'].append(course)
        print("%s选课成功 %s" % (stu_dic['name'], stu_dic['courses']))


# 调用类
"""
    调用类发生什么事？
       1. 会自定触发__init__方法 
       2. 把对象本身当成第一个参数自动传递给了__init__方法
"""
# stu1 = Student('egon', 18, 'male')  # Student(stu1， 'egon', 18, 'male')
# stu2 = Student('egon1', 18, 'male')  # Student(stu2， 'egon', 18, 'male')
# stu2 = Student()
# stu3 = Student()

#stu2 = Student()
stu1=Student('张三',25,'male')	
print(stu1)#输出内存地址
print(stu1.__dict__)

属性的查找

class Student():
    # 定义属性
    school = 'SH'
    # country = 'Chinese'
    # 当调用类的时候，会自动调用的函数, 初始化方法 （********）
    def __init__(stu_obj, name, age, gender, courese=None):
        # stu_obj   => stu1
        if courese is None:
            courese = []
        stu_obj.name1 = name  # stu1.__dict__['name'] = 'egon'
        stu_obj.age = age,  # stu1.__dict__['age'] = 18
        stu_obj.gender = gender  # stu1.__dict__['gender'] = 'male'
        stu_obj.courese = courese  # stu1.__dict__['gender'] = 'male'

    def choose_course(stu_obj, course):
        # stu_obj => stu
        # stu_dic['courses'].append(course)
        stu_obj.courese.append(course)

        """
        stu_obj = {'name': 'egon', 'age': (18,), 'gender': 'male', 'courese': []}
        """
        print("%s选课成功 %s" % (stu_obj.name, stu_obj.courese))


stu = Student('egon', 18, 'male')
stu1 = Student('egon1', 18, 'male')

# print(stu.__dict__)
# 类属性的查找
# print(Student.__dict__['school'])

# 查
# print(Student.school)

# 增加
# Student.country = 'Chinese'


# 修改
# Student.school = 'BJ'

# 删除
# del  Student.school
# Student.choose_course(stu, 'python')
# Student.choose_course(stu1, 'linux')
# print(Student.choose_course)


# print(Student.__dict__)

# 对象的属性查找
# print(stu.__dict__)
# print(stu.name)
# print(stu.age)
# print(stu.gender)
#
# stu.name = 'xxx'
# print(stu.name)
# print(stu.__dict__)
# stu.school = 'xxxxxxx'
# print(stu.__dict__)
# print(stu.school)

# 类中的方法类可以调用，但是推荐对象来调用，对象来调用，把对象本身当成第一个参数传递给函数的第一个参数
stu.choose_course('python') # stu.choose_course(stu, 'python')
stu1.choose_course('linux') # stu.choose_course(stu, 'python')