python修炼第六天

越来越难了....现在啥也不想说了，撸起袖子干。

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 封装
　　略 还没讲