一、多继承
1.多继承
python中的类支持多继承（让一个类同时继承多个类）
多继承的时候，子类只能继承第一个父类的所有属性和方法，后面的父类中只有字段和方法被继承
class Animal(object):
num = 100
def __init__(self):
self.age = 10
self.gender = '公'
@classmethod
def func1(cls):
print('动物类的类方法')
# def func2(self):
# print('动物类的func2')
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()
print(bird1.age, bird1.gender)
# print(bird1.speed, bird1.height, bird1.time)
# AttributeError: 'Bird' object has no attribute 'speed'
二、运算符重载
1.运算符
- python中所有的类型都是类，所以所有的数据都是对象；
- python使用任意的运算符都是在调用相应类中的方法，每一个运算符对应什么方法是固定的
- 某种数据是否支持某个运算符操作符就看这个数据中是否实现了对应的方法
def func1():
pass
def func1(a):
pass
def func1(a, b): # 只有这个函数才能被调用，上述两个都无法调用
pass
2.运算符重载指的是在不同的类中实现同样的运算符对应的函数
类的对象默认情况下支持： ==和!=
import copy
10 + 20
'abc' + '123'
[1, 2] + [2, 3, 4]
# {'a': 10} + {'b': 20} # 字典不支持加法
dict
class Student:
def __init__(self, name, age, score=0):
self.name = name
self.age = age
self.score = score
# a + b -> a.__add(b)
# self ->当前对象，也是 + 前面的那个数据
# other -> + 后面的那个数据，类型根据运算符规则的设计可以是任何类型的数据
def __add__(self, other):
# return self.age + other.age
# return self.score + other.score
# return Student(self.name+other.name, self.age+other.age, self.score+other.score)
return self.score + other
# a*b -> a.__mul__(b)
def __mul__(self, other):
list1 = []
for _ in range(other):
list1.append(copy.copy(self))
return list1
# a<b -> a.__lt__(b)
# 注意：'<'和'>'符号只需要重载其中一个就可以
def __lt__(self, other):
return self.score < other.score
def __repr__(self):
return '<' + str(self.__dict__)[1:-1] + ', ' + hex(id(self)) + '>'
stu1 = Student('小明', 19, 90)
stu2 = Student('小花', 20, 78)
# stu1.__add__(stu2)
# print(stu1 + stu2)
# TypeError: unsupported operand type(s) for +: 'Student' and 'Student'
print(stu1 == stu2) # False, object都支持(==)和(!=)
# stu2 = stu1
# print(stu1 == stu2) # True
# print(stu1 > stu2)
# TypeError: '>' not supported between instances of 'Student' and 'Student'
print(stu1 * 3)
students = [stu1, stu2, Student('小红', 12, 100)]
students.sort()
# TypeError: '<' not supported between instances of 'Student' and 'Student'
print(students)
print(stu2 < stu1)
print(stu1 < stu2)
三、浅拷贝和深拷贝
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=None):
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('大黄', 'yellow'))
1.直接复制
将变量中的地址直接赋值给新的变量，复制后两个变量的地址相同
p2 = p1
print(p1)
print(p2)
print(id(p1), id(p2))
p1.name = '小花'
print(p2.name, p1.name) # 小花 小花
p2.dog.color = 'green'
print(p1.dog.color, p2.dog.color)
2.拷贝
不管是浅拷贝还是深拷贝都会对原数据进行复制产生新的地址
list1 = [1, 2, 3]
list2 = copy(list1)
list3 = deepcopy(list1)
print(id(list1), id(list2), id(list3))
list1.append(100)
print(list2, list3)
p3 = copy(p1)
p4 = deepcopy(p1)
print(id(p1), id(p3), id(p4))
p1.name = '小红'
print(p3.name, p4.name)
3.浅拷贝
- 字符串、列表和元组的切片；
对象.copy()；copy模块中的copy方法都是浅拷贝 - 浅拷贝只拷贝当前对象，不会对子对象进行拷贝
print('====================浅拷贝======================')
p3 = copy(p1)
print(id(p1), id(p3)) # 38461192 38493256
print(id(p1.dog), id(p3.dog)) # 34725576 34725576
p1.name = 'Tom'
print(p1.name, p3.name) # Tom 小红
p1.dog.color = 'red'
print(p1.dog.color, p3.dog.color) # red red
4.深拷贝
copy模块中的deepcopy方法是深拷贝
print('====================深拷贝======================')
p4 = deepcopy(p1)
print(id(p1), id(p4)) # 39633352 39800136
print(id(p1.dog), id(p4.dog)) # 39633288 39800456
p1.name = 'Bob'
print(p1.name, p4.name) # Bob Tom
p1.dog.color = 'orange'
print(p1.dog.color, p4.dog.color) # orange red
练习
a = ['color', 'height', 'background']
b = [a, 'aaa', 'bbb']
c1 = b
c2 = copy(b)
c3 = deepcopy(b)
a[-1] = ['BG']
b.append('ccc')
# 问题：print(c1), print(c2), print(c3)的结果分别是
# b = [['color', 'height', 'BG'], 'aaa', 'bbb', 'ccc']
c1 = [['color', 'height', 'BG'], 'aaa', 'bbb', 'ccc']
c2 = [['color', 'height', 'BG'], 'aaa', 'bbb']
c3 = ['color', 'height', 'background', 'aaa', 'bbb']
四、枚举
枚举的特点：
- 可以通过有意义的属性名直接显示数据
2.每个数据的值不能修改
3.可以做到不同的数据的值唯一
from enum import Enum, unique
@unique
class PokerNum(Enum):
J = 11
Q = 12
K = 13
A = 1
# A = 11
# ValueError: duplicate values found in < enum 'PokerNum' >: A -> J
print(PokerNum.J.value + PokerNum.K.value) # 24
print(PokerNum.J.value > PokerNum.K.value) # False
print(PokerNum.J) # PokerNum.J
print(PokerNum.J.value) # 11
# PokerNum.J = 12 # AttributeError: Cannot reassign members.
@unique
class Color(Enum):
RED = (255, 0, 0)
GREEN = (0, 255, 0)
BLUE = (0, 0, 255)
WHITE = (255, 255, 255)
nums = ['2', '3', '4', '5', '6', '7', '8', '9', '10', 'J', 'Q', 'K', 'A']
五、内存管理
1.内存开辟
内存区间分为栈区间和堆区间；栈区间的内存自动开辟自动释放，堆区间的内存需要程序员手动开辟，手动释放；
但是python已经将堆区间内存的开辟和释放自动化
当每次给变量赋值的时候，系统会在堆区间中开辟空间将数据存起来，然后再将数据在堆中的地址存到变量中，变量存在栈区间；
数字和字符串数据在开辟空间的时候会检查内存中之前是否已经有这个数据，如果有就直接使用之前的数据，没有才开辟新的空间保存数据
from copy import copy, deepcopy
from sys import getrefcount
a = [1, 2, 3] # [0xff, 0xee, 0xcc]
b = [1, 2, 3] # [0xff, 0xee, 0xcc]
print(id(a), id(b))
# 41904008 41903752
print(id(a[0]), id(b[0]))
# 8791287558400 8791287558400
a = [1, 2, 3, [1, 2]]
b = [1, 2, 3, [1, 2]]
print(id(a[0]), id(b[0]))
# 8791287558400 8791287558400
print(id(a[3]), id(b[3]))
# 41904008 41903752
print(id(a[3][0]), id(b[3][0]))
# 8791287558400 8791287558400
a1 = 100
b1 = 100
print(id(a1), id(b1))
# 8791287561568 8791287561568
a2 = 'hello'
b2 = 'hello'
print(id(a2), id(b2))
# 34329520 34329520
a3 = {'a': 10}
b3 = {'a': 10}
print(a3 == b3) # True
print(a3 is b3) # False
a4 = 200
b4 = deepcopy(a4)
print(id(a4), id(b4)) # 8791287564768 8791287564768
a5 = 'assecrcrdfseccffffffffffffffffffffffffffffffffff'
b5 = 'assecrcrdfseccffffffffffffffffffffffffffffffffff'
print(id(a5), id(b5)) # 4925680 4925680
2.内存的释放
栈区间：全局栈区间在程序结束后销毁，函数栈区间在函数调用结束后销毁（自动）
堆区间：看一个对象是否销毁，就看这个对象的引用计数是否为0，如果一个对象的引用为0，这个对象就会销毁（垃圾回收机制）
注意：python中针对对象的循环引用已经做了处理，程序员不需要写额外的代码来解决循环引用问题
from copy import copy, deepcopy
from sys import getrefcount
a6 = {'name': '小明', 'age': 18}
b6 = a6
print(getrefcount(a6)) # 2
b6 = 100
print(getrefcount(a6)) # 2
del a6
print(getrefcount(b6)) # 9
# def ly_getrefcount(obj):
# # obj = a6
# print('打印')
class Person:
def __init__(self, name):
self.name = name
self.dog = None
class Dog:
def __init__(self, name):
self.name = name
self.owner = None
dog1 = Dog('大黄')
p1 = Person('小明')
p1.dog = dog1
dog1.owner = p1
del p1
del dog1
