一、对象与过程的概念
python中的两大范式：1.面向过程 2.面向对象
他们两个都不是新的技术，而是一种做事的思维方式
1.面向过程：根据业务逻辑从上到下写垒代码
面向过程核心是过程二字，即先干什么，在干什么，最后干什么，也就是机械式的思维方式
优点：把复杂的问题简单化，进而流程化
缺点：扩展性差
使用场景：对扩展性要求不高的地方
while True：
if cpu利用率 > 90%:
#发送邮件提醒
连接邮箱服务器
发送邮件
关闭连接
if 硬盘使用空间 > 90%:
#发送邮件提醒
连接邮箱服务器
发送邮件
关闭连接
if 内存占用 > 80%:
#发送邮件提醒
连接邮箱服务器
发送邮件
关闭连接
函数式：将某功能代码封装到函数中，日后便无需重复编写，仅调用函数即可
def 发送邮件(内容)
#发送邮件提醒
连接邮箱服务器
发送邮件
关闭连接
while True：
if cpu利用率 > 90%:
发送邮件('CPU报警')
if 硬盘使用空间 > 90%:
发送邮件('硬盘报警')
if 内存占用 > 80%:
发送邮件('内存报警')
2.面向对象
面向对象核心是对象二字,在python中，一切皆对象
面向对象“的核心是“对象”二字 ，而对象的精髓在于“整合
- 在程序中：
对象就是盛放'数据属性'和'功能'的容器 - 在生活中:
对象就是'特征'与'技能'的结合体
所有的程序都是由”数据”与“功能“组成，因而编写程序的本质就是定义出一系列的数据，然后定义出一系列的功能来对数据进行操作。在学习”对象“之前，程序中的数据与功能是分离开的，如下
# 数据：name、age、sex
name='lili'
age=18
sex='female'
# 功能：tell_info
def tell_info(name,age,sex):
print('<%s:%s:%s>' %(name,age,sex))
# 此时若想执行查看个人信息的功能，需要同时拿来两样东西，一类是功能tell_info，另外一类则是多个数据name、age、sex，然后才能执行，非常麻烦
tell_info(name,age,sex)
在学习了“对象”之后，我们就有了一个容器，该容器可以盛放数据与功能，所以我们可以说：对象是把数据与功能整合到一起的产物，或者说”对象“就是一个盛放数据与功能的容器/箱子/盒子。
如果把”数据“比喻为”睫毛膏“、”眼影“、”唇彩“等化妆所需要的原材料；把”功能“比喻为眼线笔、眉笔等化妆所需要的工具，那么”对象“就是一个彩妆盒，彩妆盒可以把”原材料“与”工具“都装到一起
插图：对象与盒子
如果我们把”化妆“比喻为要执行的业务逻辑，此时只需要拿来一样东西即可，那就是彩妆盒，因为彩妆盒里整合了化妆所需的所有原材料与功能，这比起你分别拿来原材料与功能才能执行，要方便的多。
诶，你在这里是不是有疑问了？使用函数式编程和面向对象编程方式来执行一个“方法”时函数要比面向对象简便
面向对象：【创建对象】【通过对象执行方法】
函数编程：【执行函数】
总结：函数式的应用场景 --> 各个函数之间是独立且无共用的数据
在了解了对象的基本概念之后，理解面向对象的编程方式就相对简单很多了，面向对象编程就是要造出一个个的对象，把原本分散开的相关数据与功能整合到一个个的对象里，这么做既方便使用，也可以提高程序的解耦合程度，进而提升了程序的可扩展性（需要强调的是，软件质量属性包含很多方面，面向对象解决的仅仅只是扩展性问题）
3.创建类和对象
面向对象编程是一种编程方式，此编程方式的落地需要使用 “类” 和 “对象” 来实现，所以，面向对象编程其实就是对 “类” 和 “对象” 的使用。
1.类就是一个模板，模板里可以包含多个函数，函数里实现一些功能
2.对象则是根据模板创建的实例，通过实例对象可以执行类中的函数
class是关键字，表示类
创建对象，类名称后加括号即可
类即类别/种类，是面向对象分析和设计的基石，如果多个对象有相似的数据与功能，那么该多个对象就属于同一种类。有了类的好处是：我们可以把同一类对象相同的数据与功能存放到类里，而无需每个对象都重复存一份，这样每个对象里只需存自己独有的数据即可，极大地节省了空间。所以，如果说对象是用来存放数据与功能的容器，那么类则是用来存放多个对象相同的数据与功能的容器。
插图：类与对象关系图
#类的定义和对象的产生
# 对象：'特征'与'技能'的结合体
'''站在不同的角度，分的种类不一样'''
类：一系列相似特征与相似技能的结合体
问题来了？
到底是先有类还是先有对象？
1. 程序中
# 一定是先定义类，调用类产生对象(****************)
2. 生活中
# 先有对象，在有类
"""
专业语法来定义类
def index():
pass
class 类名():
pass
"""
# 1. 类名的命名遵循变量的命名规范
# 2. 类名的首字母一般大写
# 3. 如果类名存在多个单词，一般是大驼峰格式
class Student():
# 定义一个特征
school = 'SH' # 属性
country = 'China'
# 函数写到类里面叫方法
def choose_course(stu_dict, course):
stu_dict['courses'].append(course)
print('%s选课成功%s' % (stu_dict['name'], stu_dict['courses']))
"""
定义类发生的几件事情？
1. 定义类，会立马执行类体代码
2. 产生类的名称空间，并且把类中的属性和方法名字丢在类的名称空间中，其实就是丢在大字典里
3. 把类的名称空间绑定给__dict__，类名.__dict__
"""
# 如何查看类的名称空间？
# print(Student.__dict__)
# 如何产生对象？
stu1 = Student() # 类名()
stu2 = Student() # 类名()
'''调用类产生对象，得到的额对象就是一个空对象，空字典'''
print(stu1.__dict__) # {} # 对象有名称空间吗
print(stu2.__dict__) # {} # 对象有名称空间吗
#定义对象自己独有的属性
# 版本3：
class Student():
# 定义一个特征
school = 'SH' # 属性
country = 'China'
# # 初始化方法，当类被加括号调用的时候，会自动触发这个函数的执行
# def __init__(stu_dict, name, age, gender, course=[]):
# # stu_dict => stu
# # stu_dict => stu1
# stu_dict.name = name # stu.__dict__['name'] = 'kevin'
# stu_dict.age = age # stu.__dict__['age'] = 20
# stu_dict.gender = gender # stu.__dict__['gender'] = 'male'
# stu_dict.courses = course # stu.__dict__['courses'] = []
def __init__(stu_dict, name):
stu_dict.name = name
# 函数写到类里面叫方法
def choose_course(stu_dict, course):
stu_dict['courses'].append(course)
print('%s选课成功%s' % (stu_dict['name'], stu_dict['courses']))
'''类被调用的时候，类里面传的第一个参数是这个类产生的对象'''
# stu = Student('kevin', 20, 'male') # stu = Student(stu, 'kevin', 20, 'male')
# stu1 = Student('kevin1', 21, 'male') # stu = Student(stu, 'kevin', 20, 'male')
# stu1 = Student(stu1, 'kevin') # stu = Student(stu, 'kevin', 20, 'male')
# stu2 = Student(stu2, 'jack') # stu = Student(stu, 'kevin', 20, 'male')
# stu1 = Student()
# stu2 = Student()
#
# init(stu, 'kevin', 20, 'male')
# init(stu1, 'kevin1', 21, 'male')
# init(stu2, 'kevin2', 22, 'male')
# print(stu.__dict__)
print(stu1.__dict__) # {}
stu1.name = 'kevin' # stu1.__dict__['name'] = 'kevin'
属性的查找顺序
######1. 类属性的查找
# print(Student.school)
# print(Student.country)
# print(Student.country)
# 增加属性
# Student.aaa = 'xxx'
# print(Student.__dict__)
# 修改
# Student.school = 'beijing'
# print(Student.__dict__)
# 删除
# del Student.school
# print(Student.__dict__)
#########################对象属性
stu = Student('kevin', 20, 'male')
print(stu.__dict__)
# 查看
# print(stu.__dict__['name1'])
# print(stu.name1)
# print(stu.age)
# print(stu.gender)
# print(stu.school)
# print(stu.__dict__['school']) # 只能从对象自己的属性里面去查找，没有则直接报错
# stu.school = 'aaaaa'
'''对象的属性查找，先从自己对象属性里面去找，如果找到了，直接返回，如果找不到，在去产生这个对象的类中取查找'''
# print(stu.school)
# 增加
# stu.aaa = 'xxx'
# print(stu.__dict__)
# 修改
# stu.name = 'xxxx'
# print(stu.__dict__)
# 删除
# del stu.name
# print(stu.__dict__)