面向对象变成介绍
面向过程编程
核心是过程（流水线式思维），过程即解决问题的步骤，面向过程的设计就好比精心设计好一条流水线，考虑周全什么时候处理什么东西。主要应用在一旦完成很少修改的地方，如linux内核、git、apache服务器等
优点：极大的降低了程序的设计复杂度
缺点：可扩展性差，改动一个地方很可能要改多个地方，牵一发而动全身
面向对象编程：不是编程的全部，只是用来解决软件可扩展性的
核心是对象（上帝式思维），对象作为程序的基本单元，一个对象包含了数据和操作数据的函数。面向对象就是把计算机程序作为一个对象集合，每隔对象都能接收其他对象传来的消息，计算机程序的执行就是就是一系列消息在各个对象之间传递。主要应用在需求经常变化的软件，一般需求的变化都集中在用户层，互联网应用，企业内部软件，游戏等
优点：解决了程序的可扩展性差的问题，对某一个对象修改会立刻反映到整个程序体系，如lol对一个英雄属性的修改（万年削弱从未被加强）
缺点：可控性差，无法预测程序执行结果，如lol每局游戏的结果
类和对象
对象的概念
对象也叫做实例，是通过类产生的，对象就是数据属性和方法属性的结合体，比如lol中的英雄，一个英雄就是一个对象，具备生命值、蓝条攻击力等数据属性，又具备qwer四个技能属于方法属性。
类的概念
类包含了一组对象的相同属性部分，还是说lol中的英雄，所有的英雄都有名字、标签（坦克战士法师）、生命值、蓝条攻击力等，虽然具体的值不同，但是都可以包含在类中去生成。
在python中，用变量表示是数据属性，用函数表示方法属性。
在现实生活中，先有对象后有类，比如先有的人，后有的人类的概念，而在编程中，是先有的类，后有的对象，类生成对象。
声明一个类：和函数的定义类似
定义函数：通过def关键字
def functionName(args):
'函数文档字符串'
函数体 定义类：通过cless关键字，类的名字一般开头大写，为了和函数区分
'''
class 类名:
'类的文档字符串'
类体
'''
#我们创建一个类Data类，
class Data:
pass示例：定义一个中国人的类
首先分析中国人的特征，首先国籍必须是属于中国，然后还要是个人，那么人都会做什么（吃喝拉撒睡说话）等等，另外每个人还有自己特有的属性，比如名字身高生日等
伪代码分析（只是分析）：
chinese
# 例如共有属性有
country='china' #国籍中国
language='chinese' #语言为中文，地方语言、少数民族语言可列为特有属性
# 会的技能
def talk(self):
print('is talking')
def eat(self):
print('is eating')
def sleep(self):
print('is eating')
def work(self):
print('is working')
# 等一系列人类含有的技能
#特有属性
name=name
age=age
sex=sex代码定义：init函数和self会在下面说明
class Chinese:
# 共同的特征：国籍和语言
country = 'China'
language = 'chinese'
# __init__(p1, 'zhangsan', 'man', 73)
def __init__(self,name,sex,age):
#只用于初始化的活,不能有返回值，用于定义特有的属性
self.name=name #p1.name='zhangsan'
self.sex=sex #p1.sex='man'
self.age=age #p1.age=73
# 共同的技能
def talk(self):
print('is talking')
def eat(self):
print('is eating')
def sleep(self):
print('is eating')
def work(self):
print('is working')类的属性引用：
print(Chinese.__dict__) #以字典的方式返回Chinese的所有属性，或者用dir(类名)查询
print(Chinese.language) #查看Chinese的language属性
print(Chinese.work) #查看Chinese的work属性
Chinese.language='putonghua' #修改类的language属性
Chinese.complexion='yellow' #增加一条肤色属性
del Chinese.complexion #删除肤色属性实例化（生成实例）：init函数和self说明
p1=Chinese('zhangsan','man',73) #生成一个实例，name='zhangsan' sex='man' age=73
print(p1.__dict__) #以字典的方式返回p1的属性，不包含类的共同属性，只有name/sex/age类名加上括号就是一个实例化的过程，以上生成了一个叫做p1的对象
print(p1.__dict__,type(p1))
#输出结果为
{'name': 'zhangsan', 'sex': 'man', 'age': 73} <class '__main__.Chinese'>p1.dict输出的结果为init函数所执行后的结果，而init函数的位置参数有四个self,name,sex,age，实例化的过程中传入了’zhangsan’,’man’,73三个参数对应name,sex,age，而self也是一个位置参数，函数部分我们知道位置参数必须要传入值，这里代码自动会把值p1传入，也就是实例的名字p1。
而p1的类型为
print(p1.language) #p1本身并没有language属性，但是可以查到，自己本身虽然没有，但是从类里可以拿到
# print(p1.run()) #报错，因为自己和类里都没有这个属性
print(p1.work())
p1.city='beijing' #增加一条属性，只是针对与对象本身，会增加到p1的属性字典里，不会对Chinese有影响
del p1.city #删除一条属性结论：
类的数据属性可以增删查改
对象的数据属性可以增删查改
对象本身并没有函数属性，只有自有的数据属性（init函数初始化的属性或者手动添加的属性），但是可以通过类调用到，也就是共有的特征和属性
对象里通用的数据和函数是引用类的名称空间
对象的属性，优先从自己的dict字典里找，如果自己的字典里没有，访问类里的，如果类里也没有，报错，自己定义的属性对其他引用了类的相同属性没有影响
对象的用法：
class Chinese:
obj_list=[]
count=0
country = 'China'
language = 'chinese'
def __init__(self,name,sex,age):
self.name=name
self.sex=sex
self.age=age
self.obj_list.append(name) #每次实例化，实例都往pbj_list中添加一个名字
self.count+=1 #每次实例化，实例都将count+1
def sleep(self):
print('is eating')
def work(self):
print('is working')
p1=Chinese('bob','man',18)
p2=Chinese('natasha','woman',28)
p3=Chinese('hurry','man',10)
print(p1.obj_list,p1.__dict__)
print(p2.obj_list,p2.__dict__)
print(p3.obj_list,p3.__dict__)
print(Chinese.obj_list)
#######分割线君#######
print(p1.count,id(p1.count))
print(p2.count,id(p2.count))
print(p3.count,id(p3.count))
print(Chinese.count,id(Chinese.count))
输出结果：
['bob', 'natasha', 'hurry'] {'name': 'bob', 'sex': 'man', 'age': 18, 'count': 1}
['bob', 'natasha', 'hurry'] {'name': 'natasha', 'sex': 'woman', 'age': 28, 'count': 1}
['bob', 'natasha', 'hurry'] {'name': 'hurry', 'sex': 'man', 'age': 10, 'count': 1}
['bob', 'natasha', 'hurry']
1818604608
1818604608
1818604608
1818604576结果发现：每个实例都没有obj_list，但是却有count，一个是可变，一个是不可变，所以类里可变的数据obj_list可以直接被修改，内存id不会改变，而不可变的数据count只能被重新计算，开辟新的内存空间进行引用，是建立在对象的属性中，而非类的属性
class Chinese:
obj_list=[]
count=0
country = 'China'
language = 'chinese'
def __init__(self,name,sex,age):
self.name=name
self.sex=sex
self.age=age
Chinese.obj_list.append(name) #每次实例化，Chinese类都往obj_list中添加一个实例名字
Chinese.count+=1 #每次实例化，Chinese都将count+1
def sleep(self):
print('is eating')
def work(self):
print('is working')
p1=Chinese('bob','man',18)
p2=Chinese('natasha','woman',28)
p3=Chinese('hurry','man',10)
print(p1.obj_list,p1.__dict__)
print(p2.obj_list,p2.__dict__)
print(p3.obj_list,p3.__dict__)
print(Chinese.obj_list)
#######分割线君#######
print(p1.count,id(p1.count))
print(p2.count,id(p2.count))
print(p3.count,id(p3.count))
print(Chinese.count,id(Chinese.count))
输出结果
['bob', 'natasha', 'hurry'] {'name': 'bob', 'sex': 'man', 'age': 18}
['bob', 'natasha', 'hurry'] {'name': 'natasha', 'sex': 'woman', 'age': 28}
['bob', 'natasha', 'hurry'] {'name': 'hurry', 'sex': 'man', 'age': 10}
['bob', 'natasha', 'hurry']
3 1818604672
3 1818604672
3 1818604672
3 1818604672结果发现：在实例化的过程中，类本身做的属性修改操作，不会对对象造成任何影响，所有的对象都不包含count属性和obj_list属性，都是通过类去调用的。
class Chinese:
country = 'China'
language = 'chinese'
def __init__(self,name,sex,age):
self.name=name
self.sex=sex
self.age=age
def sleep(self):
print('%s is eating' %self.name)
def work(self):
print('%s is working' %self.name)
p1=Chinese('bob','man',18)
p2=Chinese('natasha','woman',28)
# Chinese.work() #抛出TypeError
p1.work()
p2.work()
#输出结果
bob is working
natasha is working结果发现：类里面定义的函数只是给对象用的，类本身无法使用这些函数。类定义的只是方法，而方法是给对象绑定的