Python基础重点复习(类和对象)

基本语法

class Turtle:
    head = 1
    eyes = 2
    legs = 4
    shell = True

    def crawl(self):
        print("crawl")

    def run(self):
        print("run")

    def bite(self):
        print("bite")

    def eat(self):
        print("eat")

    def sleep(self):
        print("sleep")

t1 = Turtle()
print(t1.head, t1.legs)
t1.crawl()

t2 = Turtle()
print(t2.legs)
t2.legs = 3
print(t2.legs)
print(t1.legs)

print("--------------------------------")

t1.mouth = 1  # 可以添加属性
print(t1.mouth)

print("--------------------------------")

class C:
    def get_self(self):
        print(self)

c = C()
c.get_self()

继承

class A:
    x = 200
    def hello(self):
        print("我是A")

class B(A):  # B继承A
    pass

b = B()
print(b.x)
b.hello()

print("-----------------------------")

class B(A):
    x = 500
    def hello(self):
        print("我是B")

b = B()
print(b.x)
b.hello()
print(isinstance(b, B))  # 判断对象是否属于某个类
print(isinstance(b, A))

print(issubclass(A, B))
print(issubclass(B, A))  # 检测一个类是否为某个类的子类

print("-----------------------------")

"""
class A:
    x = 200
    def hello(self):
        print("我是A")
"""
class B:
    x = 100
    y = 300
    def hello(self):
        print("我是B")

class C(A, B):  # 多重继承, 如果有相同属性或函数，先继承谁就优先用谁的，没有的再去后面的父类找
    pass

c = C()
print(c.x)  # 200
c.hello()  # 我是A
print(c.y)  # 300

print("-----------------------------")

class Turtle:
    def say(self):
        print("Turtle")

class Cat:
    def say(self):
        print("Cat")

class Dog:
    def say(self):
        print("Dog")

class Garden:
    t = Turtle()
    c = Cat()
    d = Dog()
    def say(self):  # self的作用是实例对象跟类的方法进行绑定
        self.t.say()
        self.c.say()
        self.d.say()

g = Garden()
g.t.say()  # Turtle
g.say()  # Turtle Cat Dog

设置值的作用域

class C:
    x = 100
    def set_x(self, v):
        # x = v
        self.x = v

c = C()
c.set_x(200)
print(c.x)  # 200
print(C.x)  # 100

C.x = 500
print(c.x)  # 200
print(C.x)  # 500

print("----------------------------------")
class C:
    pass

C.x = 100
C.y = "aaa"
C.z = [1, 2, 3]
print(C.x, C.y, C.z)

d = {}
d['x'] = 100
d['y'] = "ZRC"
d['z'] = [1, 2, 3]
print(d['x'])
print(d['y'])
print(d['z'])

print("----------------------------------")

class C:
    pass

c = C()
c.x = 100
c.y = "ZRC"
c.z = [1, 2, 3]

构造函数

class C:
    def __init__(self, x, y):  # 构造函数
        self.x = x
        self.y = y
    def add(self):
        return self.x + self.y
    def mul(self):
        return self.x * self.y

c = C(2, 3)
print(c.add())
print(c.mul())
print(c.__dict__)  # {'x': 2, 'y': 3}

d = C(4, 5)
print(d.__dict__)
print(d.add())
print(d.mul())

print("----------------------------")

class D(C):
    def __init__(self, x, y, z):
        C.__init__(self, x, y)  # 调用C的函数 self.x = x self.y = y
        self.z = z
    def add(self):
        return C.add(self) + self.z
    def mul(self):
        return C.mul(self) * self.z

d = D(2, 3, 4)
print(d.add())
print(d.mul())

class A:
    def __init__(self):
        print("我是A")

class B1(A):
    def __init__(self):
        A.__init__(self)
        print("我是B1")

class B2(A):
    def __init__(self):
        A.__init__(self)
        print("我是B2")

class C(B1, B2):
    def __init__(self):
        B1.__init__(self)
        B2.__init__(self)
        print("我是C")

c = C()  # 钻石继承

print("**************")

class B1(A):
    def __init__(self):
        super().__init__()  # super方法会避免重复调用
        print("我是B1")

class B2(A):
    def __init__(self):
        super().__init__()
        print("我是B2")

class C(B1, B2):
    def __init__(self):
        super().__init__()
        print("我是C")

c = C()

print(C.mro())  # 方法解析顺序
print(B1.__mro__)

私有变量

class C:
    def __init__(self, x):
        self.__x = x  # __开头表示私有变量
    def set_x(self, x):
        self.__x = x
    def get_x(self):
        print(self.__x)

c = C(200)
#  print(c.__x) 无法直接访问私有变量
c.get_x()  # 200
c.set_x(100)
c.get_x()  # 100

print(c.__dict__)
print(c._C__x)  # 这种可以访问到私有变量

print("-----------------------------------")

class D:
    def __fun(self):
        print("hhhh")

d = D()
d._D__fun()

print("-----------------------------------")

c.__y = 300
print(c.__dict__)

#单个_ 开头的变量是仅供内部使用的变量；单个_ 结尾的变量 例如 class_  int_  if_当变量用

print("-----------------------------------")

class C:
    def __init__(self, x):
        self.x = x

c = C(250)
print(c.x)
print(c.__dict__)

c.y = 500
print(c.__dict__)

c.__dict__['a'] = 55
print(c.__dict__)  # {'x': 250, 'y': 500, 'a': 55}
print(c.a)

print("-----------------------------------")

class C:
    __slots__ = ["x", "y"]  # slots用于防止空间浪费
    def __init__(self, x):
        self.x = x

c = C(200)
c.y = 500
# c.z = 666  无法添加
print(c.y)

class D:
    __slots__ = ["x", "y", "z"]
    def __init__(self, x, y, z):
        self.x = x
        self.y = y
        self.z = z

d = D(3, 4, 5)
print(d.z)

print("--------------------------------------")

class E(C):  # 继承父类的slots，子类不会生效
    pass

e = E(700)
print(e.x)
e.y = 800
print(e.y)
e.z = 999
print(e.z)
print(e.__slots__)