面向过程

面向过程不是一门技术，而是一种编程思想
核心是过程二字
过程就是先干什么再干什么，按照流程走，机械式思维

面向过程思想经典案例

把大象关进冰箱：
1.打开冰箱
2.把大象放进去
3.关闭冰箱门

优点

复杂的问题简单化

缺点

扩展性差，可维护性差

应用场景

对扩展性要求不高的地方

面向对象

核心是对象二字
在程序中，对象就是盛放数据属性和功能的容器
在现实中，对象就是特征与技能的结合体

优点

扩展性强

缺点

编程复杂度与面向过程相比变高

应用场景

对扩展性要求较高的场景，比如：qq，微信

案例：学生选课系统

版本一

# 先定义变量
stu1_name = 'egon'
stu1_age = 18
stu1_gender = 'male'
stu1_courses = []

# 写一个选课的功能
def choose_course(stu_name,stu_courses,course):
    stu_courses.append(course)
    print(f'{stu_name} 选课成功 {stu_courses}')

choose_course(stu1_name,stu1_courses,'python全栈开发')
# 输出：egon 选课成功 ['python全栈开发']

# 需要再添加一位学生时需要再次定义变量，非常麻烦
stu2_name = 'tom'
stu2_age = 28
stu2_gender = 'male'
stu2_courses = []
choose_course(stu2_name,stu2_courses,'linux全栈开发')
# 输出：tom 选课成功 ['linux全栈开发']

版本二

# 先定义字典，将学生信息存入字典
stu1 = {
    'name':'egon',
    'age':18,
    'gender':'male',
    'courses':[]
}

# 将函数修改成传入字典
def choose_course(stu_dic,course):
    stu_dic['courses'].append(course)
    print('%s 选课成功 %s'% (studic['name'],stu_dic['courses']))
    
choose_course(stu1,'python全栈开发')

stu2 = {
    'name':'tom',
    'age':28,
    'gender':'male',
    'courses':[]
}
choose_course(stu2,'linux全栈开发')

版本三

def choose_course(stu_dic,course):
    stu_dic['courses'].append(course)
    print('%s 选课成功 %s'% (studic['name'],stu_dic['courses']))
    
stu1 = {
    'name':'egon',
    'age':18,
    'gender':'male',
    'courses':[],
    'choose_course':choose_course
}

stu2 = {
    'name':'tom',
    'age':28,
    'gender':'male',
    'courses':[],
    'choose_course':choose_course
}

stu1['choose_course'](stu1,'python全栈开发')
stu2['choose_course'](stu2,'linux全栈开发')

# 最后的代码中包含了面向对象的精髓：将自己传给自己

类的概念

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

强调：站在不同的角度，划分的分类是不一样的

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

class

定义类的专业语法：class
'''
class 类名():
	pass
	
def 函数名():
	pass
'''
类名：一般是首字母大写->驼峰体
类名.__dict__() 可以查看类的名称空间

定义类发生的事：
	1.立刻执行类体代码
    2.产生了类的名称空间，把类里面定义的名字都存放在类的名称空间内
    3.把类的名称空间绑定给类名
    
class Student():
    school = 'SH'
    
    def choose_course(stu_dic,course):
        stu_dic['courses'].append(course)
        print('%s 选课成功 %s'% (studic['name'],stu_dic['courses']))

# 造对象，调用类产生对象
stu1 = Student()  # 调用类产生空对象
stu2 = Student()

产生对象发生的事：
	产生一个空对象，并且把该空对象当成第一个参数进行传递

定制对象自己独有的属性

版本一

class Student():
    school = 'SH'
    
    def choose_course(stu_dic,course):
        stu_dic['courses'].append(course)
        print('%s 选课成功 %s'% (studic['name'],stu_dic['courses']))
        
stu1 = Student()  # 此时stu1是个空对象，内存里是一个空字典
stu1.name = 'egon'  # 等于stu1.__dict__['name'] = 'egon'
stu1.age = 18
stu1.gender = 'male'
stu1.courses = []
# 此时stu1内：{'name':'egon'}

版本二

class Student():
    school = 'SH'
    
    def choose_course(stu_dic,course):
        stu_dic['courses'].append(course)
        print('%s 选课成功 %s'% (studic['name'],stu_dic['courses']))
        
def init(stu_obj,name,age,gender,courses=[]):
    stu_obj.name = name
    stu_obj.age = age
    stu_obj.gender = gender
    stu_obj.courses = courses
    
init(stu1,'egon',18,'male')
init(stu2,'tom',28,'male')

版本三

class Student():
    school = 'SH'
    
    # 初始化方法__init__
    def __init__(self,name,age,gender,courses=[]):
        self.name = name
        self.age = age
        self.gender = gender
        self.courses = courses
    
    def choose_course(self,course):
        self.courses.append(course)
        print('%s 选课成功 %s'% (self.name,self.courses))
        
stu1 = Student('egon',18,'male')

# self表示是自己这个对象

属性查找

类的属性查找

print(Student.__dict__['school'])
Student.xxx = 'xxx'  # 直接在类内部生成一个xxx = xxx
del Student.xxx  # 删除类内的xxx
Student.school = 'MMM'  # 直接覆盖类内的school

对象的属性查找

# 对象.语法取值，先从自己对象中取，如果没有，再去类中取值
print(stu1.school)
stu1.xxx = 'xxx'
del sut1.xxx
sut1.school = 'MMM'

Student内的school修改成x，与类有关的对象取的school值都变成x
在stu1内添加school变量，取 stu1.school 时则优先取stu1的school
类中的属性是共享给所有对象的，但是类中的方法是给对象用的，并且把对象当成第一个参数进行传递

标签：stu1,name,courses,python,笔记,day31,course,choose,stu
来源： https://www.cnblogs.com/Milu-Mi/p/15003630.html