"""author = 陈俊龙"""
==============运算符的重载==============
1. 运算符
python中所以的数据类型本质都是类，所以所有的数据本质都是对象
使用运算符对数据进行操作的时候，实际是调用运算符对应的魔法方法
运算符前面的数据类型决定了函数调用哪个类中对应的魔法方法
10+20 # class int
'abc'+'123' # class str
[1, 2, 3]+[1] # class list
每个运算符都有自己固定的魔法方法,看某种类型的数据是否支持某种运算符就看这个类型中有没有实现对应的魔法方法
例如：
‘+’ -- _ add _
‘>’ -- _ gt _
class Student:
def __init__(self, name, age, score):
self.name = name
self.age = age
self.score = score
# +号对应的魔法方法,实现两个对象求和
def __add__(self, other):
return self.age+other.age
# 定制乘法运算，实现对象乘数字
def __mul__(self, other):
return self.age * other
def __repr__(self):
return '<%s>' % str(self.__dict__)[1:-1]
# 定制比较运算，实现对象成绩的比较(比较多的情况）
def __lt__(self, other):
return self.score < other.score
def __gt__(self, other):
return self.score > other.score
stu1 = Student('小明', 18, 90)
stu2 = Student('小李', 18, 92)
print(stu1 == stu2) # False 支持相等比较，其他的比较都不支持，如果需要，只有自己去写__add__这个魔法方法
# 自己实现加法运算的魔法方法后的效果：
print(stu1+stu2)
# 自己实现乘法运算的魔法方法后的效果：
print(stu1*2)
all_student = [
Student('stu1', 17, 90),
Student('stu2', 17, 91),
Student('stu3', 17, 92),
Student('stu4', 17, 93)
]
#all_student.sort()TypeError: '<' not supported between instances of 'Student' and 'Student'
# 解决方法1：
all_student.sort(key=lambda item: item.score)
print(all_student)
# 解决方法2：运算符重载
print(stu1 < stu2)
# 还可以找出最大值：
print(max(all_student)) # <'name': 'stu4', 'age': 17, 'score': 93>
=================内存管理==============
from sys import getrefcount
手动内存管理:
c语言：内存分为栈区间和堆区间，栈区间的内存是自动开辟自动释放，堆区间的内存需要程序员写代码申请和释放
1.内存的开辟：
python所有的数据都是对象，对象都是保存在堆区间，变量是保存在栈区间，变量中实际存储的是堆中对应的数据的地址（变量的本质就是指针）
注意：
如果数据是数字和字符串就属于特殊情况：除了数字和字符串对象，其他的对象都是每次需要数据的时候直接在堆中开辟空间
数字和字符串会先检查这个数据之前是否保存过，如果保存过就直接用之前的数据，否则才会开辟新的空间
num1 = 100
num2 = 100
print(id(num1), id(num2)) # 1385658480 1385658480 地址相同
2.内存的释放:
python中内存的释放采用的是'垃圾回收机制'自动释放
a.垃圾回收机制：
1）看一个数据是否需要销毁，就看这个对象的引用计数是否为0（引用：就是看没有其他变量或者数据在用它）
2）如果这个对象引用计数不为零，就临时删除一下他，然后看会不会有其他的对象因为他的消失而消失，如果有那就把他们真正的删除
b.循环引用：
在堆区间两个数据互相的引用，而没有栈区间的变量引用他们，两个数据互相引用，这种情况就属于循环引用
释放栈区间的变量只有用del来删除释放
面试题：== 和 is 的区别：
！补充：is 的使用 -- 判断两个数据的地址是否相等，注意和 == 区分！
list1 = [1,2,3]
list2 = [1,2,3]
print(list1 == list2) True
print(list1 is list2) False
list1 = [1, 2, 3]
list2 = [1, 2, 3]
# 打印它的引用计数
print(getrefcount(list1)) # 2 问题：不是说除数字和字符串以外都会从新开辟数据空间吗？list1 = [1,2,3] list2 = [1,2,3]
print(id(list1), id(list2))
list3 = list1
=============深拷贝和浅拷贝============
import copy
使用变量的三种情况：
1.直接赋值 - 附的是地址，赋完值后两个变量一模一样
变量1 = 变量2
如果对变量1数据进行修改，变量的数据也是会修改
list1 = [1, 2, 3]
list2 = list1
list1.remove(1) # 修改list1
print(list2) # [2, 3] 打印list2，数据也有变化
2.浅拷贝
copy.copy(原变量)
列表[:],列表.copy()都属于浅拷贝
将数据复制一遍到一个新的内存空间，有一个新的地址，将这个新地址赋给这个新的变量，但是如果这个数据还引用了子对象，那么这个复制出来的新对象还是引用的原来的那个子对象，！不会把子对象也复制一遍！，所以有子对象的情况下改变子对象还是会影响原来的变量
class Student:
def __init__(self, name, age, score):
self.name = name
self.age = age
self.score = score
def __repr__(self):
return '<%s>' % str(self.__dict__)[1:-1]
stu1 = Student('tom', 18, 90)
stu2 = copy.copy(stu1)
stu2.name = 'bob'
print(stu1, stu2)
3.深拷贝
copy.deepcopy(原变量)
将数据复制一遍到一个新的内存空间，有一个新的地址，
将这个新地址赋给这个新的变量，但是如果这个数据还引用了子对象，会把子对象也复制一遍，所以完全不会影响原来的其他变量
stu3 = copy.deepcopy(stu1)
