python-类

类和对象 

class people:
    def __init__(self, id):  #初始化函数
        #id是创建对象时要输入的参数
        self.id = id    #self.id  是对象属性

    def display(self):  #对象函数
        print(self.id)
    def addition(self, height):
        #height调用函数时要输入的参数
        return height


aa=people(1001)   #创建对象
aa.display()      #调用对象函数
i=aa.addition(1.66)
print(i)

画图理解类和对象 

 

 

 

 动态增加对象属性：

class A:
    pass

s=A()
s.num=10  #动态增加一个对象属性
s.name='张三'
s.age=18
print(s.num)
print(s.__dict__)  #返回对象的所有属性,不包含类属性
#{'num': 10, 'name': '张三', 'age': 18}
del s.age   #删除属性

 

s.__dict__={'name':'lm','num':1001}        #动态增加属性

#A.__dict__={'wuli':78}  #这是错误的   这种方式可以增加对象属性，不能增加和修改类属性

类.__dict__   是只读的，不能写

对象__dict__   是可读可写的

 

限制对象属性的添加：

class A:
    __slots__ = ['age','id']  #这个类只能添加的属性
    age=18   #增加一个类属性
    id=1001

d=A()

 

跨类调用

class Person:  #人类
    def __init__(self, name):
        self.name = name
        self.car = Car()  # 在Person类中调用Car类

    def driver(self):
        print(self.name,"驾驶去东北")
        self.car.run()

class Car:  #车类
    def run(self):
        print("汽车在行驶")


lz=Person("老张")
lz.driver()

 

class Person:  #人类
    def __init__(self, name):
        self.name = name

    def driver(self,car):
        print(self.name,"驾驶去东北")
        car.run()

class Car:  #车类
    def run(self):
        print("汽车在行驶")


lz=Person("老张")
car=Car()
lz.driver(car)

 

动态创建类

#动态创建类:利用元类创建类对象
def func(self):
    print('函数')

AAA=type('Dog',(),{'age':18,'func':func})
#AAA   类的对象名
#参数1 类名称      参数2 元组-父类
#参数3  字典：属性和方法

d=AAA()
print(d.age)
d.func()

 视频教程  https://www.bilibili.com/video/av50407114/

 

 私有属性和受保护属性：

私有属性

前面加二个下划线是私有属性   __x      只能在类内访问

class people:
    def __init__(self, id,name):
        self.id = id
        self.name = name

    def display(self):
        car=Car("宝马","白色")
        print(self.name+"正在驾驶"+car.brand)


class Car:
    def __init__(self, brand,colour):
        self.brand = brand
        self.__colour = colour  #前面加二个下划线是私有属性，只能在类内访问
        #在car和car1对象中不能使用colour属性

maoqi=people(1001,"毛奇")
maoqi.display()

car1=Car()

函数也可以私有

 

 

受保护属性

前面加一个下划线是受保护属性   _x         只能在类内和子类中访问

 

 

 

单继承：只有1个父类

class A():
    pass
class B():
    pass
class A1(A,B):
    pass

print(A1.__bases__)  #返回类A1的基类
#(<class '__main__.A'>, <class '__main__.B'>)

初始化函数：如果子类本身有就执行子类的，如果子类没有就执行父类的 

 

class A():
    def __init__(self,name,age):
        self.name=name
        self.age=age
    def eat(self):
        print('吃药')

class A1(A):
    def __init__(self,name,age,jinqian):
        #子类继承了父类的方法

        #A.__init__(self,name,age)  #执行父类初始化函数--方法一
        #只有执行父类初始化函数，子类才有self.name、self.age属性

        #super(A1,self).__init__(name,age)  #执行父类初始化函数--方法二
        super().__init__(name, age)  # 执行父类初始化函数--方法三
        #A1,self  可以省略


        self.jinqian=jinqian  #派生属性(父类没有的属性)

class A2(A):
    def __init__(self,name,age,jinqian):
        #子类继承了父类的方法
        A.__init__(self,name,age)  #执行父类初始化函数
        #只有执行父类初始化函数，子类才有self.name、self.age属性
        self.jinqian=jinqian  #派生属性(父类没有的属性)
    def eat(self):  #重写父类方法
        #父类子类都有就执行子类自己的，子类没有才到父类寻找
        print('吃饭')

        #如果还想执行父类的同名方法，就需要调用
        A.eat(self)

d1=A1('张三',24,100)
d1.eat()
d2=A2('李四',24,100)
d2.eat()

 

 

关系判定 

s=isinstance(a,A)判断a是不是类A的对象

是  返回true，不是返回false

class Person:   #父类
    def say(self):
        print("讲话")

class Student(Person):  #子类  继承父类
    def play(self):
        self.say()   #调用父类函数
        print("玩耍")


class Teacher(Person):
    def teach(self):
        print("教学")

t=Teacher()
t.say()

p=Person()

s=isinstance(t,Person)   #判断t是不是类Person的对象
#是  返回true，不是返回false
#返回True，说明子类对象属于父类
print("S=",s)

s1=isinstance(p,Teacher)
#返回False，说明父类对象不属于子类
print("s1=",s1)

 

isinstance() 与 type() 区别：

type() 不会认为子类是一种父类类型，不考虑继承关系。

isinstance() 会认为子类是一种父类类型，考虑继承关系。

class Person:   #父类
    def say(self):
        print("讲话")

class Student(Person):  #子类  继承父类
    def play(self):
        self.say()   #调用父类函数
        print("玩耍")


class Teacher(Person):
    def teach(self):
        print("教学")

t=Teacher()
t.say()

p=Person()

a=type(t)
# <class '__main__.Teacher'>
print(a)
print(type(t) == Teacher)
#True  t是Teacher
print(type(t) == Person)
#False   t不是Person类  不考虑继承关系

 

 

 

issubclass(class, classinfo) 判断class 是否是classinfo的子类

如果 class 是 classinfo 的子类返回 True，否则返回 False。

 

 print(d.__class__)  #返回对象中的类

 

构造函数的继承 

class Person:   #父类
    def __init__(self, name="",age=0):
        self.name = name
        self.age = age


#当子类没有构造函数时，直接使用父类构造函数
class Teacher(Person):
    pass

#当子类有构造函数时，不使用父类构造函数
class Student(Person):
    def __init__(self, name="",age=0,score=0):
        #子类构造函数的参数：父类+子类
        super().__init__(name,age)  #调用父类构造函数
        self.score = score


qtx=Teacher("齐大圣",26)
print(qtx.name)

rc=Student("任聪",25,99)
print(rc.name)

 有继承关系时，父类代码在上 

 视频教程

 

重写 

在子类写与父类同名函数 

 

 

多继承 

函数继承调用关系

class A:
    def func(self):
        print("A")

class B:
    def func(self):
        print("B")

class C:
    def func(self):
        print("C")


class D(A,B,C):
    pass

d=D()
d.func()
"""
子类自己有func函数，就用自己的
子类自己没有func函数，就用父类的；第一个父类A有func函数，就用第一个父类A的；第一个父类没有就用第二个父类B的，以此类推

"""

 

钻石继承

 

class A:
    def func(self):
        print("A")

class B(A):
    # def func(self):
    #     print("B")
    pass

class C(A):
    # def func(self):
    #     print("C")
    pass

class D(B,C):
    # def func(self):
    #     print("D")
    pass

d=D()
d.func()
"""
钻石继承:
子类自己有func函数，就用自己的
子类自己没有func函数，就用父类的:
    第一个父类有func函数，就用第一个父类的；第一个父类没有就用第二个父类的，以此类推（A和B都是A的子类）
    如果父类没有，就用爷爷的，以此类推

调用关系：横向优先(必须相同父类支路，就是亲兄弟父类优先)；横向没有再纵向
"""

 

多层多继承 

 

 调用关系看序号：1没有用2,2没有用3，以此类推

class A:
    # def func(self):
    #     print("A")
    pass

class E:
    def func(self):
        print("E")


class B(A):
    # def func(self):
    #     print("B")
    pass

class C(E):
    def func(self):
        print("C")
    pass

class D(B,C):
    # def func(self):
    #     print("D")
    pass

d=D()
d.func()

print(D.mro())   #返回调用顺序

 

再理解调用顺序

 

 

多继承顺序视频教程

多继承super继承顺序实例 

class A:
    def func(self):
        print('A')

class B(A):
    def func(self):
        super().func()
        print('B')

class C(A):
    def func(self):
        super().func()
        print('C')

class D(B,C):
    def func(self):
        super().func()
        print('D')
d=D()
d.func()

 分析图

 

 

多态 

 

 

 

 

 

 

 类属性：

 

class A:
    age=18   #增加一个类属性
    id=1001

A.num = 100  #动态增加一个类属性
del A.id     #删除类属性

 

 

 方法：

 实例方法(对象方法)：方法的第一个参数一般是self

类方法：

 

 

静态方法：