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

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

原文地址：https://www.cnblogs.com/liyunjie/p/9059748.html