一 什么是面向对象，面向对象与类的关系。
面向对象的程序设计是用来解决扩展性。
面向过程：根据业务逻辑从上到下写垒代码
函数式：将某功能代码封装到函数中，日后便无需重复编写，仅调用函数即可
面向对象：对函数进行分类和封装，让开发“更快更好更强...”
简单的来说，如果程序的功能都是由类和对象来实现的，那么就是面向对象编程了。
二 对象与类的关系
对象是特征与技能的结合体。
类是一系列对象共同的特征与技能的结合体。
三 类的基本格式
classPeople:def __init__(self):pass
deffoo(self):pass
defbar(self):pass这就定义了一个People类。
四 类的说明
1.类的定义：关键字 class
2 实例化：类名+( )，产生一个类的对象或实例。
classPeople:def __init__(self):pass
deffoo(self):pass
defbar(self):passp=People()print(p)输出：
3 实例化本质，调用__init__函数。
classPeople:def __init__(self,name):pass
deffoo(self):pass
defbar(self):passp=People()print(p)输出：
TypeError: __init__() missing 1 required positional argument: 'name'
因为实际是调用__init__函数，有一个name参数，需要传参。
传一个参数就ok了
classPeople:def __init__(self,name):pass
deffoo(self):pass
defbar(self):passp=People('egon')print(p)4 类的作用
1 实例化
2 属性引用 __dict__方法。
五 类与对象的namespace
1 namespace用__dict__方法。
是字典格式
classPeople:def __init__(self,name):
self.name=namedeffoo(self):pass
defbar(self):passp1=People('egon')print(People.__dict__)输出：
{'__module__': '__main__', '__init__': , 'foo': , 'bar': , '__dict__': , '__weakref__': , '__doc__': None}
类的名称空间内有很多，定义的foo，bar函数，包括__init__初始化函数。
对象的namespace
classPeople:
model='person'
def __init__(self,name):
self.name=namedeffoo(self):pass
defbar(self):passp1=People('egon')print(p1.__dict__)输出：
{'name': 'egon'}
对象的本身并没有动态属性(函数属性)，也没有静态属性(类的数据属性)，对于这两个，只有绑定关系。 对象只有属于自己的静态属性，即__init__函数初始化的数据。
总结：类有属于自己的名称空间，每一个生成的对象也都有属于自己的名称空间。类的名称空间里有各种动态属性，静态属性，而对象的名称空间只有属于它自己的静态属性。
对象的名称空间在类的名称空间之下。对象找不到的静态属性或者动态属性可以去类的名称空间中寻找。
对象与类的静态属性和动态属性的关系是绑定关系。 详见第六条
2 类和对象的名称空间都是字典，所以可以对字典进行增删改查。
1 增
classPeople:
model='person'
def __init__(self,name):
self.name=namedeffoo(self):pass
defbar(self):passp1=People('egon')print(p1.__dict__)
p1.age=35
print(p1.__dict__)输出：
{'name': 'egon'}
{'name': 'egon', 'age': 35}
2 改
classPeople:
model='person'
def __init__(self,name):
self.name=namedeffoo(self):pass
defbar(self):passp1=People('egon')print(p1.__dict__)
p1.name='alex'
print(p1.__dict__)输出：
{'name': 'egon'}
{'name': 'alex'}
六 对象与类的动态属性和静态属性的关系。
1 动态属性
classPeople:
model='person'
def __init__(self,name):
self.name=namedeffoo(self):passdefbar(self):passp1=People('egon')print('对象调用foo时地址',p1.foo)print('类调用foo时地址',People.foo)
输出：
对象调用foo时地址 >类调用foo时地址
可以看到类调用函数时 是正儿八经的函数地址，所以需要正常传值，一个参数都不能少，少了就会报错。
对象调用函数时，对象与函数的关系是绑定关系，实现了自动传值。谁调用，就将这个对象自动传给函数的第一个参数。
2静态属性
首先强调的一点是：类的静态属性对象一般不要调用。
类的静态属性是不可变类型时。
classPeople:
x=1
def __init__(self,name):
self.name=namedeffoo(self):pass
defbar(self):passp1=People('egon')
p1.x=2
print('p1.x:',p1.x,id(p1.x))
print('People.x:',People.x,id(People.x))输出：
p1.x: 2 1980286672
People.x: 1 1980286640
实际上相当去p1在自己的名称空间内新建了一个x的变量。对类的名称空间内的x 完全不一样。
类的静态属性是可变类型是，对象就能够直接调用了。
classPeople:
l=[1]def __init__(self,name):
self.name=namedeffoo(self):pass
defbar(self):passp1=People('egon')
p1.l.append(2)print('p1.l:',p1.l,id(p1.l))print('People.l:',People.l,id(People.l))输出：
p1.l: [1, 2] 2917779341960People.l: [1, 2] 2917779341960
七 类与基本数据类型的关系。
classPeople:def __init__(self,name):
self.name=namedeffoo(self):passp1=People('egon')print(type(p1))print(People)print(int)print(type(1))print(str)print(type('123'))输出：
之前学的剧本数据类型就是本质上就是和现在学习的类是一样的。在python3中统一起来的。
现在再来回顾基本数据类型的用法。
l1=[1,2,3]
l2=list([1,2,3])print(l1)print(l2)l2就是类的实例化过程。 类名+ ( 传参) 。
举个例子：列表的追加
l1=[1,2,3]
l2=list([1,2,3])
l1.append(4)
list.append(l2,4)
print(l1,l1.append)
print(l2,list.append)输出：
[1, 2, 3, 4] [1, 2, 3, 4]
分析：l1 就是作为列表list的一个对象，调用列表的动态属性(函数属性)，自动传值。
l2是类调用动态属性，没有自动传值，必须手动传值。
两者实现了同样的效果。
八 对象的属性
1 一开始，通过__init__方法初始化而来的
2 在类内调用对象的属性， self.属性名
3 在类外调用对象的属性，对象名.属性名
九 举例
__init__的作用，在实例化的时候就已经生效了。
classFather:
def __init__(self):
self.name='bb'
defsay(self):
print('from bb',self.name)
classMother:
def __init__(self):
self.name='mm'
deftalk(self):
print('from mm',self.name)
classSon(Father,Mother):
passs=Son()
s.talk()输出：
from mm bb
这个例子说明：
实例化，先执行__init__方法，以此从自己的，父类的， 多个父类时顺序找第一个有__init__方法的父类。走到这一步时，如果能找到__init__,对象已经有了自己的名称空间，如果都没有那就没有自己的名称空间。
对象调用方法，如果自己名称空间内有，先从自己名称空间内找。
厉害了，这个例子。
