Day 18 类的继承、访问权限、拷贝和内存管理

Day 18 类的继承、访问权限、拷贝和内存管理

1.类的继承

1.什么是继承？

子类直接拥有父类的属性和方法的过程就是继承

子类：继承者

父类：被继承，父类又叫超类（super）

2.怎么继承

class 子类(父类)：
    pass

class Person:
    num = 61
    def __init__(self):
        self.name = '小红'
        self.age =18
        self.gender = '男'
    
    def eat(self.food)
        print(f'{self.name}在吃{food}')
        
    @classmethod
    def show_num(cls):
        print('人类的数量'，cls.num)
        
class Student(Person):
    # Student是子类，Person是父类，子类继承了父类的三个属性
    pass

stu1 = Student()
print(stu1.name, stu1.age, stu1.gender)  # 继承父类的三个对象属性
print(Student.number)    # 继承类属性
stu1.eat('包子')

注意：a.如果定义类的时候没有添加父类，默认继承python的基类object

​ b.同一个子类可以同时继承多个父类：class子类（父类1，父类2，父类3…）

​ c. python中子类可以继承父类所有的属性和方法

3.在子类中添加属性和方法

1. 添加类属性：直接在子类中定义新的类属性

2. 添加方法：直接在子类中定义新的方法

在子类中添加方法的时候可以对父类的方法进行重写，

在子类中可以通过’super().方法’的形式来调用父类中的方法（注意：不能在静态方法中使用super(）调用父类的方法）

总结：super 的用法

可以通过super 在子类中调用父类的方法

super().方法() ------ 直接调用当前类父类的指定方法

super(类,对象).方法() ----- 调用指定类的父类的指定方法（要求对象必须是前面类的对象）

3)添加对象属性

在子类的__init__方法中通过super()去调用父类的__init__

class A:
    x=100

class B(A):
    y = 20

class C(B):
    pass
print(A.x)
print(B.x)

print(B.y)
print(A.y)   # 会报错，因为A是父类不能用子类的属性

class Animal:
    def __init__(self):
        self.age = 0
        self.gender = '雌'

class Cat(Animal):
    def __init__(self):
        super().__init__()
        self.color = '白色'
        self.price = 2000
        self.breed = '野猫'
    pass

cat = Cat()
print(cat.age, cat.gender)
print(cat.color)

4.对象属性的添加问题

class A:
    def __init__(self, a, b=10):
        # a = 200, b=10
        self.a = a    # 200
        self.b = b    # 10
        self.c = 0    # 0


class B(A):
    def __init__(self, d, a):
        # d = 100, a = 200
        # super().__init__(100)
        super(B, self).__init__(a)   # A: __init__(200)
        self.d = d    # 100


bb = B(100, 200)    # B: __init__(100, 200)
print(bb.a, bb.b, bb.c, bb.d)

练习：
创建一个人类有属性：姓名、年龄、性别，要求创建人的对象的时候姓名和年龄必须赋值，性别可以赋值也可以不赋（默认是男）
创建学生类有属性：姓名、年龄、性别、学号、学分和电话，要求创建学生对象的时候，姓名和电话必须赋值。
年龄和性别可以赋值也可以不赋（默认是18和年），学分和学号创建的时候不能赋值，默认值分别是’000’和0

class Person:
    def __init__(self, name, age, gender='男'):
        self.name = name
        self.age = age
        self.gender = gender

class Student(Person):
    def __init__(self, name, tel, age=18, gender='男'):
        super(Student, self).__init__(name, age,gender)
        self.stu_id = '000'
        self.score = 0
        self.tel = tel

stu2 = Student('小明', 188)
print(stu2.name)        

5.多继承

多继承的时候子类可以继承所有父类的类属性和方法，但是只能继承第一个父亲的对象属性

class Animal:
    num = 61
    def __init__(self):
        self.age =0
        self.gender = '雄'
        
    @classmethod
    def show(cls):
        print('数量：'.cls.num)
        
class Fly:
    def __init__(self):
        self.height = 100
        self.time = 3
        
    @staticmethod
    def message():
        print('飞行鹰')
        
class Bird(Animal, Fly):
    pass

Bird.show()
Bird.message()
# 类属性和方法都能继承

b = Bird()
print(b.age, b.gender)    # 不报错
print(b.height, b.time)   # 会报错
# 对象属性只能继承第一个，原因是有顺序问题只能继承第一个对象属性

2.访问权限（编程常识）

公开的：在类的内部可以使用，类的外部也可以使用还可以被继承（Python中所有的属性和方法都是公开的）

保护的：在类的内部可以使用、继承

私有的：只能在类的内部可以使用

python的私有化

方法：在属性名或者方法名前加__就可以让属性或者方法变成私有的

原理：假的私有化；在__开头的名字前加’__类名’

class A:
    num = 100
    __x = 10     # 在前面加__,x变成私有的
    def __init__(self, a, b=10):
        self.a = a
        self.b = b
        self.__c = 0

3.拷贝

浅拷贝和深拷贝的区别：

不管浅拷贝还是深拷贝都是复制被拷贝的对象产生一个新的对象，然后用新的对象来复制

区别：如果被拷贝的对象中有子对象，浅拷贝不复制子对象用原来的，深拷贝会复制子对象产生新的子对象

from copy import copy,deepcopy

class Dog:
    def __init__(self):
        self.name = '旺财'
        self.gender = '公狗'

    def __repr__(self):
        return f'<{str(self.__dict__)[1:-1]},id:{id(self)}>'

class Person:
    def __init__(self,name,age=18,gender='女')：
        self.name =name
        self.age = age
        self.gender = gender
        self.dog = Dog()

    def __repr__(self):
        return f'<{str(self.__dict__)[1:-1]}, id:{id(self)}>'

p1 =Person('小明',20,'男')
p2 =p1  # 直接赋值，将p1中的地址赋给p2
p3 = copy(p1)  # 浅拷贝，赋值p1产生一个新对象，用新对象给p3赋值
p4 = deepcopy(p1 # 深拷贝，赋值p1产生一个新对象，用新对象给p4赋值
print(p1, p2, p3, p4)

from copy import copy,deepcopy
A = [10, 20, 30, ['abc', '123']]
B = A
C = copy(A)
D = deepcopy(A)

A.append(100)
A[3].pop()

print(B)  # [10, 20, 30, ['abc'], 100]赋值变化完全相同
print(C)  # [10, 20, 30, ['abc']]浅拷贝子对象用原来的，子对象跟着原序列变化
print(D)  # [10, 20, 30, ['abc', '123']]深拷贝大，小列表都是新的，没有改动

4.内存管理

c语言都是手动内存管理

内存管理分为内存的开辟和释放

1.内存的开辟 ---- 使用数据的时候就申请内存保存数据

python内存管理，分为栈和堆，栈自动销毁，栈里只保存数据地址

python中所有的类型都是类，所有数据都是对象，对象都保存在堆里

堆在保存数据的时候，相同的不可变数据内存中只保存一份，相同的可变数据在内存中一定会保存多份

2.内存释放 — 垃圾回收制

python中内存的某个数据是否销毁（对应的内存是否释放），看这个数据在程序中的引用个数，当引用个数大于0的时候数据不会被销毁，当数据的引用个数为0的时候数据会被自动销毁。