1.多继承
python中的类支持多继承，也就是让一个类有多个父类。
class Animal(object):
num = 100
def __init__(self):
self.age = 0
self.gender = '雌'
@classmethod
def func2(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) # 100 飞
print(Bird.num, Bird.name) # 100 飞
print(bird1.num, bird1.name) # 100 飞
print(bird1.gender) # 雌
print(bird1.speed) # AttributeError: 'Bird' object has no attribute 'speed'
当子类在继承多个父类的时候，只继承了第一个父类的属性(Animal),所以子类在调用speed属性的时候就会报错。
运算符
python中所有的类型都是类，所以所有的数据都是对象，python中使用的任意运算符都是在调用相应类中的相应的方法。每一个运算符对应的什么方法都是固定的，某种数据是否支持该运算符就看这个数据类型中是否实现了对应的方法。
默认情况下，类的对象支持 ==，!=
class Student:
def __init__(self, name, age, score=0):
self.name = name
self.age = age
self.score = score
def __repr__(self):
return '<%s, id:%s>' % (str(self.__dict__)[1:-1], hex(id(self)))
# 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):
list = []
for _ in range(other):
list.append(copy.copy(self))
return list
# a a.__lt__(b)
# 注意: <和>符号只需要重载其中一个就可以
def __lt__(self, other):
return self.score < other.score
stu1 = Student('小明', 19, 90)
stu2 = Student('小花', 20, 78)
# stu1.__add__(stu2)
print(stu1 + stu2)
# stu1.__add__(100)
# print(stu1 + 100)
print(stu1 * 2) # [<'name': '小明', 'age': 19, 'score': 90, id:0x16c61f4ed68>,
<'name': '小明', 'age': 19, 'score': 90, id:0x16c61f4ea20>]
# students = [stu1, stu2, Student('小红', 12, 100)]
# students.sort()
# print(students)
#
# print(stu1 < stu2)
# print(stu1 > stu2)
浅拷贝和深拷贝
1.直接赋值
将变量中的地址直接赋给新的变量，赋值后两个变量的地址相同
p1 = 20
p2 = p1
print(id(p1), id(p2)) #4537270848 4537270848
2.拷贝
不管是浅拷贝还是深拷贝都是会对原数据进行赋值产生新的地址，浅拷贝只是拷贝当前对象，不会拷贝当前对象中的子对象，深拷贝则是不仅拷贝当前对象，也拷贝当前对象中的所有子对象。
import copy
list1 = [1, 2, 3]
list2 = copy.copy(list1)
list3 = copy.deepcopy(list1)
print(id(list1), id(list2), id(list3))
3.浅拷贝
字符串、列表和元组的切片；对象.copy();copy模块中的copy方法都是浅拷贝，浅拷贝只拷贝当前对象，不会对子对象进行拷贝
4.深拷贝
深拷贝就是copy模块中的deepcopy方法
# 练习:
a = ['color', 'height', 'background']
b = [a, 'aaa', 'bbb']
c1 = b
c2 = copy(b)
c3 = deepcopy(b)
a[-1] = ['BG']
b.append('ccc')
# b = [['color', 'height', 'background'], 'aaa', 'bbb']
# 问题: print(c1), print(c2), print(c3)的结果分别是
# c1 = [['color', 'height', ['BG']], 'aaa', 'bbb', 'ccc']
# c2 = [['color', 'height', ['BG']], 'aaa', 'bbb']
# c3 = [['color', 'height', 'background'], 'aaa', 'bbb']
print(c1)
print(c2)
print(c3)
枚举
枚举值的特点：
1）可以通过有意义的属性名直接显示数据
2）每个数据的值不能修改
3）可以做到不同的数据值唯一
from enum import Enum, unique
@unique
class PokerNum(Enum):
J = 11
Q = 12
K = 13
A = 1
class Color:
RED = (255, 0, 0)
print(PokerNum.J)
print(PokerNum.K.value, PokerNum.J.value > PokerNum.Q.value)
内存管理
1.内存的开辟
内存区间分为栈区间和堆区间，栈区间的内存自动开辟自动释放，堆区间的内存需要手动来开辟以及释放；但是python已经将堆区间内存的开辟和释放自动化
a.在python中当每次给变量赋值的时候，系统会先在堆区间中开辟空间将数据存起来，然后再将数据在堆区间的地址存到变量中，变量存储在栈区间。
b.数字和字符串在开辟空间的时候，会先检查内存中之前是否存储过该数据，如果有就直接使用这个数据，没有则开辟新的空间来保存这个数据
2.内存的释放
栈区间：全局栈区间在程序结束后自动销毁，函数栈区间在函数调用结束后自动销毁。
堆区间：看一个对象是否被销毁，就看这个对象的引用计数是否为0，如果引用为0，那么这个对象就会被销毁（垃圾回收机制）
注意：python中针对对象的循环引用已经做了处理，程序员不需要写额外的代码来解决循环引用的问题
# 面试题：== 和 is的区别?
# 补充: is的使用 - 判断两个数据的地址是否一样
list1 = [1, 2, 3]
list2 = [1, 2, 3]
list3 = list1
print(list1 == list2, list1 == list3) # True, True
print(list1 is list2, list1 is list3) # False, True