210225 class inheritance

210225 class inheritance


1. Definition of inheritance

The process of letting subclasses directly own the properties and methods of the parent class
**Subclass** Successor
**Parent class: * * inheritee, also known as superclass

2. Inheritance method

Class subclass (parent class)
**Note: * * if no parentheses are added, the base class object is inherited by default
A subclass can have multiple parent classes and subclasses at the same time (parent class 1, parent class 2,...)
Python subclasses can inherit all the properties of their parent classes and methods

class Person:
    num = 61

    def __init__(self):
        self.name = 'Xiao Hong'
        self.age = 18
        self.sex = 'female'

    def eat(self, food):

    # Class method
    def show_num(cls):
        print('Number of humans:', cls.num)

    # Static method
    def info():
        print('Human destruction of the environment!')

class Student(Person):

stu1 = Student()
print(stu1.age, stu1.name, stu1.sex)
# 18 little red girl
# 61
stu1.eat('steamed stuffed bun')
# Xiao Hong is eating steamed stuffed buns
# Number of humans: 61
# Human beings destroy the environment!

Subclass override

1. Add attributes and methods to subclasses

1) Add class properties

You can directly define a new class attribute in the subclass

2) Override: you can add the same method as the parent class in the child class

Call: call directly when rewriting the part with each
When using both overridden and superclass methods, use super() Method (except static method)
Summary: usage of super
super(). Method () directly calls the specified method of the current parent class
Super (class, object) Method ()
Call the specified method of the parent class of the specified class (the object must be the object of the previous class)

3) Add object properties

In subclass_ init _ _ Method to call the _ofthe parent class through super()_ init _ _

class A:
    x = 100

    def func1():

    def funca(cls):

    def func4(self):
        print('A Object method 1')

    def func5(self):
        print('A Object method 2')

class B(A):
    y = 20

    def func2(cls):

    def func1():

    def funca(cls):

    def func4(self):
        print('B Object method of')

    def func3():
        # super().func1()  # report errors
        super(B, B()).func1()
        print('B Static state of')

class C(B):

print(A.x)  # 100
print(B.x)  # 100
print(C.x)  # 100

print(B.y)  # 20
# print(A.y)
print(C.y)  # 20

B.func1()   # BB
A.func1()   # A

B.funca()  # A1 B2

b = B()
b.func4()  # Object method of A 1 object method of A 2 object method of B

B.func3()  # Static of a and B

class X:
    def fx(self):

class Y(X):
    def fy(self):
        """super(Y, self).fx()"""

    def f(self):
        super(N, N()).fm()

class M:
    def fm(self):

class N(M):
    def fn(self):

x = X()
y = Y()
y.fy()  # x y
y.f()   # x m


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

class Cat(Animal):
    def __init__(self):
        self.color = 'white'
        self.price = 2000
        self.breed = 'wildcat'

cat = Cat()
print(cat.age, cat.gender)  # 0 female
print(cat.color)  # white

Adding object properties

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)
# 200 10 0 100

Create a human with attributes: name, age, gender,
The name and age must be assigned when the creator's object is required,
Gender can be assigned or not assigned (male by default)
The created student class has attributes: name, age, gender, student number, credit and telephone,
When it is required to create a student object, the name and phone number must be assigned.
Age and gender can be assigned or not assigned (18 and years by default),
Credit and student number cannot be assigned when they are created. The default values are'000'And 0

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

class Students(Person):
    def __init__(self, name, tel, age=18, gender='male'):
        super(Students, self).__init__(name, age, gender)
        self.study_id = '007'
        self.score = 0
        self.tel = tel

p = Person('Xiao Ming', 18)
stu = Students('Xiao Hong', '1110', 20, 'female')
print(stu)  # <__main__.Students object at 0x000000000255B160>

Multiple inheritance

In case of multiple inheritance, subclasses can inherit the class properties and methods of all parent classes,
However, only the object properties of the first parent class can be inherited
_ _ mro _ _ The model is applicable to multi inheritance (understand)

class Animal:
    num = 61

    def __init__(self):
        self.age = 0
        self.gender = 'male'

    def show(cls):
        print('number:', cls.num)

class Fly:
    name = 'Aerocraft'

    def __init__(self):
        self.height = 100
        self.time = 3

    def message():

class Bird(Fly, Animal):

print(Bird.num, Bird.name)


b = Bird()
# print(b.age, b.gender)
print(b.height, b.time)


Access rights:

1) Public: it can be used and inherited both inside and outside the class

(all properties in Python are public)

2) Protected: it can be used and inherited inside the class

3) Private: used inside a class and cannot be inherited

Add 2 underscores before the attribute name or method name in the Python class__
Property or method can be privatized
Python privatization is a pseudo concept. Adding two underscores is equivalent to changing a storage location
Equivalent to adding 'at the beginning of 2 underscores_ Class name ',
If you want to be inherited, add before_ Class name is enough The essence is public

class A:
    num = 100
    __x = 200    # __ x is private

    def __init__(self):
        self.name = 'Xiao Ming'
        self.__age = 18   # __ age is private

    def info(self):
        print('Information:', self.__age)

    def show(cls):
        print(cls.num, cls.__x)

    def __f1(self):
        print('Object method')


# print(A.__x)

a = A()
# print(a.__age)


# a.__f1()

print(a.__dict__)   # {'name': 'Xiao Ming', '_a_age': 18}
print(a._A__age)    # 18


Light copy and deep copy

**The same point: * * will copy the copied object, generate a new object, and then assign a value with the new object
**Differences: * * if the copied object has subclasses, the shallow copy copies only the parent class, and the deep copy copies both

# Import copy module
from copy import copy, deepcopy
class Dog:
    def __init__(self):
        self.name = 'Wangcai'
        self.gender = 'male dog'

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

class Person:
    def __init__(self, name, age=18, gender='female'):
        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('Xiao Ming', 20, 'male')
p2 = p1     # Direct assignment, assign the address in p1 to p2
p3 = copy(p1)   # Light copy. Copy p1 to generate a new object, and assign a value to p3 with the new object
p4 = deepcopy(p1)  # Deep copy. Copy p1 to generate a new object and assign p4 a value with the new object
print('Original data:', p1)
print('Direct assignment:', p2)
print('Shallow copy:', p3)
print('Deep copy:', p4)

p1.name = 'floret'
p1.dog.gender = 'Bitch'
print('Original data:', p1)
print('Direct assignment:', p2)
print('Shallow copy:', p3)
print('Deep copy:', p4)

# practice:
A = [10, 20, 30, ['abc', '123']]
B = A
C = copy(A)
D = deepcopy(A)

A.append(100)  # A=[10, 20, 30, ['abc', '123'], 100]
A[3].pop()  # A=[10, 20, 30, ['abc'], 100]

print(B)  # [10, 20, 30, ['abc'], 100]
print(C)  # [10, 20, 30, ['abc']]
print(D)  # [10, 20, 30, ['abc', '123']]

memory management

Memory management is divided into memory development and release

1. The development of memory. When using data, apply for memory in the heap, and the value corresponds to the name in the stack

All types in Python are classes, all data are objects, and all data is stored in the heap
When the heap saves data, only one copy of the same immutable data is saved
Save multiple copies of the same variable data

2. Garbage collection mechanism for memory release

Whether a data in Python memory is released depends on the number of references of this data in the program
If it is greater than 0, it will not be destroyed, otherwise it will be destroyed


a = 100
age = 100
list1 = [100, 200]
print(id(a), id(age), id(list1[0]))

a = [10, 20]
b = [10, 20]
c = [100, [10, 20]]
print(id(a), id(b), id(c[-1]))

A = 100
del A
# B = A   # NameError: name 'A' is not defined

Tags: Python

Posted by Pottsy on Fri, 15 Apr 2022 19:21:39 +0930