一、运算符重载
1. 运算符
python中所有的类型都是类,所以所有的数据都是对象
python中使用任意的运算符都是在调用对应类中的对应方法
每一个运算符对应的方法是固定的
某种数据是否支持某个运算符操作,由这个数据类型中是否实现了对应的方法决定
2. 运算符重载
在不同的类中实现同样的运算符对应的函数
注意:类的对象默认情况下只支持:==, !=
class Student:
def __init__(self, name, age, score=0):
self.name = name
self.age = age
self.score = score
# self -> 当前类的对象,也是运算符前的数据
# other -> 运算符后面的数据,类型根据运算规则的设计可以是任何类型的数据
# a + b -> a.__add__(b)
def __add__(self, other):
# return self.age + other.age
# return self.score + other.score
# return self.score + other
return Student(self.name + other.name, self.age + other.age, self.score + other.score)
# a * b -> a.__mul__(b)
def __mul__(self, other: int):
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
# return [self for _ in range(other)]
# return Student(self.name * other, self.age * other, self.score * other)
def __repr__(self):
return ''.join(['<', str(self.__dict__)[1:-1], '>'])
stu1 = Student('小明', 19, 90)
stu2 = Student('小花', 20, 78)
print(stu1 + stu2)
print(stu1 * 3)
students = [stu1, stu2, Student('小红', 12, 100)]
students.sort()
# students.sort(key=lambda x: x.score)
print(students)
print(stu1 < stu2, stu1 > stu2)
二、浅拷贝和深拷贝
class Dog:
def __init__(self, name, color):
self.name = name
self.color = color
def __repr__(self):
return '<{}>, id = {}'.format(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 '<{}>, id = {}'.format(str(self.__dict__)[1:-1], hex(id(self)))
1. 直接赋值
将变量中的地址直接赋值给新的变量,赋值后两个变量的地址相同
p1 = Person('小明', 18, Dog('大黄', '黄色'))
p2 = p1
print(p1)
print(p2)
# <'name': '小明', 'age': 18, 'dog': <'name': '大黄', 'color': '黄色'>, id = 0x101d9f8d0>, id = 0x101d9f908
# <'name': '小明', 'age': 18, 'dog': <'name': '大黄', 'color': '黄色'>, id = 0x101d9f8d0>, id = 0x101d9f908
p1.name = '小花'
print(p1.name, p2.name) # 小花 小花
p2.dog.color = '绿色'
print(p1.dog.color) # 绿色
2. 拷贝
无论是浅拷贝还是深拷贝都会对原数据进行复制,产生新的地址
list1 = [1, 2, 3]
list2 = copy(list1)
list3 = deepcopy(list1)
print(id(list1), id(list2), id(list3)) # 4533504520 4533323464 4533504456
list1.append(100)
print(list2, list3) # [1, 2, 3] [1, 2, 3]
3. 浅拷贝
字符串、列表和元组的切片,对象.copy(),以及copy模块中的copy()都是浅拷贝
浅拷贝只拷贝当前对象,不会对子对象进行拷贝
p3 = copy(p1)
print(id(p1), id(p3)) # 4564163104 4564163384
print(id(p1.dog), id(p3.dog)) # 4564163048 4564163048
p1.name = 'Tom'
print(p1.name, p3.name) # Tom 小花
p1.dog.color = '红色'
print(p1.dog.color, p3.dog.color) # 红色 红色
4. 深拷贝
copy模块中的deepcopy方法是深拷贝
p4 = deepcopy(p1)
print(id(p1), id(p4)) # 4364675728 4364730776
print(id(p1.dog), id(p4.dog)) # 4364675672 4364730496
p1.name = 'Jack'
print(p1.name, p4.name) # Jack Tom
p1.dog.color = '黑色'
print(p1.dog.color, p4.dog.color) # 黑色 红色
三、枚举
枚举值的特点
1. 可以通过有意义的属性名直接显示数据
2. 每个数据的值不能修改
3. 可以做到不同数据的值唯一
from enum import Enum
from enum import unique
@unique
class PokerNum(Enum):
J = 11
Q = 12
K = 13
A = 1
print(PokerNum.J.name) # J
print(PokerNum.K.value, PokerNum.J.value > PokerNum.Q.value) # 13 False
四、内存管理
1. 内存的开辟
内存区间分为栈区间和堆区间
栈区间的内存自动开辟和释放，堆区间的内存需要程序员手动开辟和释放，但在python中已经将堆区间内存的开辟和释放过程自动化
当给变量赋值时,系统会先在堆区间中开辟空间将数据保存,然后再将数据在堆区的地址存到栈区间的变量中
数字和字符串数据在开辟空间时,会先检查内存中之前是否已经有当前数据,如果有则直接使用之前的数据,没有会开辟新的空间保存当前数据
2. 内存的释放
栈区间:全局栈区间在程序结束后销毁,函数栈区间在函数调用结束后销毁
堆区间:对象是否销毁是由这个对象的引用计数决定的,如果一个对象的引用计数为零,这个对象就会销毁(垃圾回收机制)
注意:python中针对对象的循环引用已经做了处理,程序员不需要针对循环引用问题写额外的代码
