越来越难了....现在啥也不想说了，撸起袖子干。
1 面向对象
先来个例子：
比如人狗大战
需要有狗，人
所以创建两个类别模子
def Person(name,sex,hp,dps):
dic = {"name":name,"sex":sex,"hp":hp,"dps":dps,"bag",[]}
return dic
def Dog(name,kind,hp,dps):
dic = {"name":name,"kind":sex,"hp":hp,"dps":dps}
return dic
alex = Person("alex","geil")
ha2 = Dog("","",)
造模子 ---面向对象
规范了一个类别
概念：
类 具有相同属性和相同动作的一类事物，组成一个类
对象 具体的某一个具有实际属性 和具体动作的一个实体
类是抽象的，对象是具体的
类的语法：
类：
1 定义：
class 类名:
静态属性 = None
def 动态属性(self):
pass
2 类的第一个功能;查看
# 只要是写在类名中的名字，不管是变量还是函数名，都不能在类的外部直接调用
# 只能通过类名来使用：类名.静态属性
可以修改静态属性
类名.静态属性 = 345
可以增加静态属性
类名.静态属性2 = "abc"
可以删除静态属性
del 类名.静态属性2
动态属性：
定义动态属性时要加个self
def func(self):
print("--->",self)
类名可以查看某个方法，但是一般情况下 我们不直接使用类名来调用方法
而是使用对象来调用方法。
3 类的第二个功能：实例化（创造对象）
class Person:pass
alex = Person()
# 对象 = 类名() 类名加上括号就是实例化，
在实例化的过程中，发生了很多事情是外部看不到的步骤：
1 创建了一个对象
2 自动调用__init__方法
3 这个被创造的对象会被当作一个实际参数传到__init__方法中，并且传给第一个参数self
4 然后执行init方法中的内容
5 自动的吧self作为返回值，返回给实例化的地方
__dict__ # 记录了必要的默认值之外，还记录了程序员在类中定义的所有名字
print(alex.__dict__)
alex.__dict__["name"] = "alex"
alex.__dict__["hp"] = "alex"
alex.__dict__["dps"] = "alex"
可以简写为:
alex.name = "alex"
alex.hp = 250
alex.dps = 5
初始化方法：
上面是在类外面创建对象的属性，能不能在类里面直接生成属性？
这个被创造的对象会被当作一个实际参数传到__init__方法中，并且传给第一个参数self
能不能这样：alex = Person("alex","boy",250,5)
class Person:
def __init__(self，name,hp,dps):
self.name = name
self.hp = hp
self.dps = dps
alex = Person("alex",250,5)
print(alex.__dict__)
print(alex.name)
对象名.方法名 相当于调用类的函数，同时第一个参数是对象名，第二个参数是
当一个类创建一个对象的时候，就产生了一个这个实例和类之间的联系
可以通过实例 对象找到实例化他的类。
但是类无法找到他实例化了多少个对象。
所以：
对象可以访问类的空间
类无法访问对象的空间
命名空间问题： 类命名空间与对象实例的命名空间
alex.country = "印度人"
在访问变量的时候，都先使用自己的命名空间中的变量，如果自己的空间中没有
再到类的空间去找
在使用对象修改静态变量的过程中，相对于在自己的空间中创建了一个新的变量
alex.country[0] = "印度人"
在类的静态变量的操作中，应该使用类名来直接进行操作。就不会出现乌龙问题
思考题
创建一个类，能够计算这个类创建了多少个实例
组合
一个类的对象，作为另外一个类的属性
比如 人有武器
圆环有圆
2 面向对象的三大特性
1 继承 占了2/1
为什么会有继承： 是为了解决代码冗余的问题。
怎么继承？
单继承：
class Parent:
pass
class sun(Parent): 这就代表sun这个类 继承Parent类
pass
产生很多名词：父类，基类，超类 --- parent类
子类 派生类 ----- sun类
多继承,有多个父类:
class Parent1:pass
class Parent2:pass
class sun(Parent1,Parent2):pass
先找对象的内存空间，再找创建这个对象的类的内存空间，如果还没有 再找创建这个类的父类内存空间。
class Animal:
def __init__(self,name,hp,dps)
self.name = name
self.hp = hp
self.dps = dps
def cat()
print("%s吃药回血了",%self.name)
class Person(Animal):
def __init__(self,name,hp,dps,sex)
Animal.__init__(self,name,hp,dps) # 或者写为 super().__init__(name,hp.dps) ，但是如果是多继承要写这个。
self.sex = sex # 派生属性
def attack(self):
pass
class Dog(Animal):
def __init__(self,name,hp,dps,kind)
Animal.__init__(self,name,hp,dps)
self.kind = kind
def bite():
pass
面试题：
class Foo;
def __init__(self):
self.func()
def func(self):
print("in Foo")
class Son(Foo):
def func(self):
print("in Son")
Son() # 先调用self自己的方法。所以是in Son
多继承：
钻石继承问题：
A 4
/ \
/ \
2 B C 3
\ /
\ /
1 D
优先级：D,B,C,A
小乌龟模型：
A 6
/ \
/ \
3 B C 5
| |
| |
2 D E 4
\ /
\ /
F 1
优先级：F,D,B,E,C,A
遍历算法 ： 广度优先算法
python3 都遵循广度优先算法
python3有2种类
1 经典类 Python3已经灭绝了，在python2中还存在，在py2中只要程序员不主动继承object，这个类就是经典类
就遵循深度优先算法。 一条道走到黑。
2 新式类 Python3所有的类都是新式类，所有新式类都继承自object--- 在多继承成中遵循广度优先算法。
super注意：
在单继承中 super就是找父类
在多级继承 super的轨迹 是根据整个模型的起始点而展开的一个广度优先循序，遵循mro规则
抽象类与接口类 主要是针对java的，略
2 多态
在Python当中，处处都是多态。 略 还没讲
3 封装
略 还没讲