面向过程的程序设计：核心是过程二字，过程指的是解决问题的步骤，即先干什么再干什么......面向过程的设计就好比精心设计好一条流水线，是一种机械式的思维方式。
优点是：复杂度的问题流程化，进而简单化（一个复杂的问题，分成一个个小的步骤去实现，实现小的步骤将会非常简单）
缺点是：一套流水线或者流程就是用来解决一个问题，生产汽水的流水线无法生产汽车，即便是能，也得是大改，改一个组件，牵一发而动全身。2.面向对象编程
面向对象的程序设计：核心是对象二字
优点是：解决了程序的扩展性。对某一个对象单独修改，会立刻反映到整个体系中，如对游戏中一个人物参数的特征和技能修改都很容易。
缺点：
1. 编程的复杂度远高于面向过程，不了解面向对象而立即上手基于它设计程序，极容易出现过度设计的问题。一些扩展性要求低的场景使用面向对象会徒增编程难度，比如管理linux系统的shell脚本就不适合用面向对象去设计，面向过程反而更加适合。
2. 无法向面向过程的程序设计流水线式的可以很精准的预测问题的处理流程与结果，面向对象的程序一旦开始就由对象之间的交互解决问题，即便是上帝也无法准确地预测最终结果。于是我们经常看到对战类游戏，新增一个游戏人物，在对战的过程中极容易出现阴霸的技能，一刀砍死3个人，这种情况是无法准确预知的，只有对象之间交互才能准确地知道最终的结果。应用场景：需求经常变化的软件，一般需求的变化都集中在用户层，互联网应用，企业内部软件，游戏等都是面向对象的程序设计大显身手的好地方
举例
版本一
stu1_name = ‘egon‘
stu1_age = 18
stu1_gender = ‘male‘
stu1_course = []
stu2_name = ‘tom‘
stu2_age = 38
stu2_gender = ‘female‘
stu2_course = []
def choose_courses(): # 写死了
stu1_course.append(‘python开发‘)
def choose_courses(stu_name, stu_course, course):
stu_course.append(course)
print(f"学生 {stu_name} 选 {course} 课程成功")
choose_courses(stu1_name, stu1_course, ‘python‘)
choose_courses(stu2_name, stu2_course, ‘linux‘)版本2
stu1_dic = {
‘name‘: ‘egon‘,
‘age‘: 18,
‘gender‘: ‘male‘,
‘course‘: []
}
stu2_dic = {
‘name‘: ‘tom‘,
‘age‘: 38,
‘gender‘: ‘female‘,
‘course‘: []
}
def choose_courses(stu_dic, course):
stu_dic[‘course‘].append(course)
print(f"学生 {stu_dic[‘name‘]} 选 {course} 课程成功")
choose_courses(stu1_dic, ‘python‘)
choose_courses(stu2_dic, ‘linux‘)版本3
def choose_courses(stu_dic, course):
stu_dic[‘course‘].append(course)
print(f"学生 {stu_dic[‘name‘]} 选 {course} 课程成功")
stu1_dic = {
‘name‘: ‘egon‘,
‘age‘: 18,
‘gender‘: ‘male‘,
‘course‘: [],
‘choose_course‘: choose_courses
}
stu2_dic = {
‘name‘: ‘tom‘,
‘age‘: 38,
‘gender‘: ‘female‘,
‘course‘: [],
‘choose_course‘: choose_courses
}
stu1_dic[‘choose_course‘](stu1_dic,‘python‘)
stu2_dic[‘choose_course‘](stu2_dic,‘linux‘)二、介绍类与对象
版本4
def choose_courses(stu_dic, course):
stu_dic[‘course‘].append(course)
print(f"学生 {stu_dic[‘name‘]} 选 {course} 课程成功")
Student = {
‘school‘: ‘shanghai‘,
‘choose_course‘: choose_courses
}
stu1_dic = {
‘name‘: ‘egon‘,
‘age‘: 18,
‘gender‘: ‘male‘,
‘course‘: [],
‘Student‘: Student
}
stu2_dic = {
‘name‘: ‘tom‘,
‘age‘: 38,
‘gender‘: ‘female‘,
‘course‘: [],
‘Student‘: Student
}类
class Student:
school=‘shanghai‘
def choose_courses(stu_dic, course):
stu_dic[‘course‘].append(course)
print(f"学生 {stu_dic[‘name‘]} 选 {course} 课程成功")
print(Student.__dict__)类即类别、种类，是面向对象设计最重要的概念，对象是特征与技能的结合体，而类则是一系列对象相似的特征与技能的结合体
那么问题来了，先有的一个个具体存在的对象（比如一个具体存在的人），还是先有的人类这个概念，这个问题需要分两种情况去看
1.在现实世界中：先有对象，再有类
世界上肯定是先出现各种各样的实际存在的物体，然后随着人类文明的发展，人类站在不同的角度总结出了不同的种类，如人类、动物类、植物类等概念
也就说，对象是具体的存在，而类仅仅只是一个概念，并不真实存在
2.在程序中：务必保证先定义类，后产生对象
这与函数的使用是类似的，先定义函数，后调用函数，类也是一样的，在程序中需要先定义类，后调用类
不一样的是，调用函数会执行函数体代码返回的是函数体执行的结果，而调用类会产生对象，返回的是对象在程序中，务必保证：先定义（类），后使用（产生对象）
版本一
class Student:
school = ‘sh‘
def choose_course(stu_dic, course):
stu_dic[‘course‘].append(course)
print(f"学生 {stu_dic[‘name‘]} 选 {stu_dic[‘course‘]} 成功")
stu1_dic = Student()
stu2_dic = Student()
stu1_dic.name = ‘egon‘
stu1_dic.age = 18
stu1_dic.gender = ‘male‘
stu1_dic.courses = []
stu2_dic.name = ‘tom‘
stu2_dic.age = 38
stu2_dic.gender = ‘female‘
stu2_dic.courses = []
print(stu1_dic.__dict__)
print(stu2_dic.__dict__)
print(Student.__dict__)进化
class Student:
school = ‘sh‘
def __init__(stu_dic, name, age, gender, course=None):
if course is None:
courses = []
stu_dic.name = name
stu_dic.age = age
stu_dic.gender = gender
stu_dic.courses = courses
def choose_course(stu_dic, course):
stu_dic[‘course‘].append(course)
print(f"学生 {stu_dic[‘namef‘]} 选 {stu_dic[‘course‘]} 成功")
stu1_dic = Student(‘egon‘, 18, ‘male‘) # 调类传参是给init传参
stu2_dic = Student()类定义阶段发生3件事：
1.会执行类体代码
2.会产生一个类的名称空间，用来将类体代码运行过程中产生的名字丢进去
3.会将名称空间的内存地址绑定给类名
调用类发生三件事：
1.会创建空对象（会调用new方法来创建的空对象）
2.会自动触发类中init函数的运行，完成对象的初始化操作,init只能返回None
3.返回该对象
原文：https://blog.51cto.com/u_15129993/2704683