内存管理和拷贝
一、类的多继承
python中的类支持多继承（让一个类同时继承多个类）；
多继承的时候，子类只能继承第一个父类的属性和方法，后面的父类只有字段和方法可以被继承
class Animal(object):
num = 100
def __init__(self):
self.age = 0
self.gender = '雌'
@classmethod
def func1(cls):
print('动物类的类方法')
class Fly(object):
name = '飞行器'
def __init__(self):
self.height = 100
self.time = 5
self.speed = 100
def func2(self):
print('飞行的对象方法')
class Bird(Animal, Fly):
pass
bird1 = Bird()
# 字段都能继承
print(Bird.num, Bird.name)
Bird.func1()
bird1.func2()
二、运算符重载
python所有的类型都是类，所以所有的数据都是对象；
python中使用任意的运算符都是在调用相应类中的相应方法，每一个运算符对应什么方法是固定的，某种数据是否支持某个运算符操作就看这个数据类型中是否实现了对应方法
运算符重载指的是在不同的类中实现同样的运算符对应的函数
类的对象默认情况下只支持：==， !=
class Student:
def __init__(self, name, age, score=0):
self.name = name
self.age = age
self.score = score
# a + b = c -> a:self, b:other
# self -> 当前类的对象，也是+前面的那个数据
# other -> + 后面的那个数据，类型根据运算规则的设计可以是任何类型的数据
def __add__(self, other):
return self.age + other.age
# <, > 只需要重载一个，另一个自动支持
def __lt__(self, other):
return self.score < other.score
stu1 = Student('小明', 19, 20)
stu2 = Student('小花', 20, 78)
# stu1 + stu2 TypeError: unsupported operand type(s) for +: 'Student' and 'Student'
print(stu1 == stu2) # False
print(stu2 + stu1)
三、浅拷贝和深拷贝
from copy import copy, deepcopy
class Dog:
def __init__(self, name, color):
self.name = name
self. color = color
def __repr__(self):
return '<%s, id:%s>' % (str(self.__dict__)[1:-1], hex(id(self)))
class Person:
def __init__(self, name, age, dog):
self.name = name
self.age = age
self.dog = dog
def __repr__(self):
return '<%s, id:%s>' % (str(self.__dict__)[1:-1], hex(id(self)))
p1 = Person('小明', 18, Dog('大黄', '黄色'))
1.直接赋值
将变量中的地址直接付给新的变量；赋值后两个变量的地址相同
p2 = p1
print(p1) # <'name': '小明', 'age': 18, 'dog': <'name': '大黄', 'color': '黄色', id:0x11c0dd0>, id:0x2d8ec90>
print(p2)
p1.name = '小花' # <'name': '小明', 'age': 18, 'dog': <'name': '大黄', 'color': '黄色', id:0x11c0dd0>, id:0x2d8ec90>
print(p1.name, p2.name) # 小花 小花
2.拷贝
不管是浅拷贝还是深拷贝都会对原数据进行赋值产生新地址
list1 = [1, 2, 3]
list2 = copy(list1)
list3 = deepcopy(list1)
print(id(list1), id(list2), id(list3)) # 47853936 47853896 47853856
p3 = copy(p1)
p4 = deepcopy(p1)
print(id(p1), id(p3), id(p4)) # 47770768 48318064 48318032
3.浅拷贝
字符串、列表和元组的切片；对象.copy（）；copy模块中的copy方法都是浅拷贝
浅拷贝只拷贝当前对象，不会拷贝子对象
p3 = copy(p1)
print(id(p1), id(p3)) # 47770768 48318192
print(id(p1.dog), id(p3.dog)) # 18615760 18615760
4.深拷贝
list5 = [1, 2, [1, 2, [1, 2]]]
list6 = deepcopy(list5)
list5[2][2].append(3)
print(id(list5[2][2]), id(list6[2][2]))
print(list5, list6)
四、枚举
枚举的特点：
1.可以通过有意义的属性名直接显示数据
2.每个数据的值不能修改
3.可以做到不同数据的值是唯一的
from enum import Enum, unique
@unique
class PokerNum(Enum):
J = 11
Q = 12
K = 13
A = 14
print(PokerNum.J)
print(PokerNum.J.value > PokerNum.Q.value)
nums = ['2', '3', '4', '5', '6', '7', '8', '9', '10', 'J', 'Q', 'K', 'A']
a = 100
print(id(a))
五、内存管理
1.内存的开辟
内存区间分为栈区间和堆区间，栈区间的内存自动开辟，自动释放，堆区间的内存需要程序员手动开辟，手动释放；但是python已经将堆区间内存的开辟和释放自动化。
当给变量赋值的时候，系统会先在堆区间中开辟空间将数据存起来，然后再将数据在堆中的地址存到变量中，变量存在栈区间；数字和字符串数据在开辟空间的时候，会先检查内存中之前是否已经有这个数据，如果有就直接使用之前的数据，没有才开辟空间保存新数据。
a = [1, 2, 3]
b = [1, 2, 3]
print(id(a), id(b)) # 10372600 10373760
a1 = 100
b1 = 100
print(id(a1), id(b1)) # 2081516256 2081516256
a2 = 'hello'
b2 = 'hello'
print(id(a2), id(b2)) # 44146624 44146624
a3 = 100
b3 = deepcopy(a3)
print(id(a3), id(b3))
a4 = -9
b4 = -9
print(id(a4), id(b4))
2.内存的释放
栈区间：全局栈区间在程序结束后才会销毁，函数栈区间在函数调用结束后销毁（自动）
堆区间：看一个对象是否销毁，就看这个对象的引用计数是否为0；如果一个对象的引用为0，这个对象就会销毁(垃圾回收机制)。注意：python中针对对象的循环引用已经做了处理，程序员不需要写额外的代码来解决循环引用问题
def func1():
a5 = -5
print(id(a5))
func1()
b5 = -5
print(id(b5))
a6 = 300
b6 = 300
print(id(a6), id(b6))
a7 = {'name': '小明', 'age': 18}
print(getrefcount(a7))