运算符重载
python中所有的数据类型都是类，数据都是对象所有的运算符的操作，本质都是在调用数据类型对应的魔法方法每个运算符都对应一个固定的魔法方法
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 __gt__(self, other):
return self.age > other.age
def __repr__(self):
return str(self.__dict__)
stu1 = Student('小敏', 25, 68)
stu2 = Student('小月', 23, 79)
print(stu1 + stu2)
print(stu1 * 10)
print(stu1 > stu2)
allstudent = [Student('小敏', 25, 68), Student('小月', 23, 79)]
allstudent.sort()
print(allstudent)
# 练习，让Student的对象支持乘法运算，运算规则是：
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):
resault = []
for _ in range(other):
resault.append(self)
return resault
# 重载大于
def __gt__(self, other):
return self.age > other.age
def __repr__(self):
return '<' + str(self.__dict__)[1:-1] + '>'
stu1 = Student('小敏', 25, 68)
stu2 = Student('小月', 23, 79)
print(stu1 + stu2)
print(stu1 > stu2)
allstudent = [stu1, stu2]
allstudent.sort()
print(allstudent)
# 练习，让Student的对象支持乘法运算，运算规则是：
stu3 = Student('小喵', 28, 82)
resault = stu3 * 2
print(resault)
stu3.name = '小狗'
print(resault)
resault[0].name = '李逵'
print(resault)
# 1.一个变量给另一个变量赋值：直接将地址赋值，赋完值后，两个变量只想同一块内存区域并且相互影响
print('++++++++直接赋值++++++')
stu4 = stu1
print(id(stu4), id(stu1))
stu1.age = 1000
print(stu4)
print(stu1)
深拷贝和浅拷贝
浅拷贝和深拷贝（面试点！）
a.浅拷贝
1.列表或字典的copy方法是浅拷贝、前片也是浅拷贝
2.copy.copy(对象) - 复制指定的对象，产生一个新的对象
浅拷贝原理：将被拷贝的对象复制一份，产生一个新的数据，然后将新的数据的地址返回（不会复制子对象）
b.深拷贝
copy.deepcopy(对象) - 复制指定的对象，产生一个新的对象，如果这个对象中还有其他对象，子对象也会被复制
print('++++++++浅拷贝++++++')
stu5 = copy.copy(stu1)
stu5.name = '大黄'
print(stu1)
print(stu5)
print('++++++++深拷贝++++++')
stu6 = copy.deepcopy(stu1)
stu1.name = '大脑虎'
print(stu1)
print(stu6)
内存管理
1.数据的存储（内存开辟）
python的所有的变量都存储在栈区间，对象都在堆区间
声明变量或者给变量赋值，是现在内存（堆）中开辟存储数据，然后将数据地址保存在变量中
但是数字和字符串，如果是用字符串或者数字给变量赋值，不会直接开辟空间保存数据，
而是现在内存中检查这个数据之前是否已经存储过，如果已经存储直接使用上次保存的数据，
没有存储才会开辟新的空间保存数据
2.内存的释放
管理原理：
1.引用计数：
python中每个对象都有一个属性叫引用计数，用来保存当前对象的引用的个数
2.python中的垃圾回收机制来判断一个对象是否销毁，就看这个对象的引用计数是否为0，
如果为0就会被销毁
list1 = [1, 2]
list2 = [1, 2]
print(id(list1), id(list2))
num1 = 10
num2 = 10
print(id(num1), id(num2))
print('=================引用计数==================')
list3 = [1, 2]
print(getrefcount(list3))
套接字
服务器端
from socket import *
"""
进行通信的两端就是套接字，有两种类型，分别是服务器套接字、客户端套接字
1.服务器套接字
"""
# 1.创建套接字对象
"""
family - 设置ip协议类型，AF_INET(ipv4),AF_INET6(ipv6)
type - 设置传输协议类型，SOCK_STREAM(TCP),SOCK_DGRAM(UDP)
"""
server = socket(family=AF_INET, type=SOCK_STREAM)
# 2.绑定ip地址和端口
"""
bind(（ip地址，端口）)
ip - 字符串，服务器对应的ip地址
端口号 - int，端口用来区分电脑上的不同的服务0 - 65535,0 - 1024是著名端口（避开）
同一时间一个端口只能绑定一个服务
"""
server.bind(('10.7.185.77', 8080))
# 3.开始监听请求
server.listen(512)
# 4.让服务器一直运行
while True:
print('监听状态.....')
# 代码运行到这个位置，会停下来，等到客户端给服务器发送请求位置
connect, addr = server.accept() # 5.接收请求
print(addr, '链接成功')
while True:
# 6.接收消息
"""
recv(bufsize) - 设置一次性能够接收的数据大小的最大值，单位是字节
"""
re_data = connect.recv(1024) # 保存接收到的数据，返回的是字节
print('客户端>>>', re_data.decode(encoding='utf-8'))
# 7.发送数据
message = input('>>>')
connect.send(message.encode())
# 8.关闭连接
connect.close()
客户端
from socket import *
# 1. 创建套接字对象
client = socket()
# 2.连接服务器
client.connect(('10.7.185.77', 8080))
while True:
# 3.发送数据
message = input('请输入：')
client.send(message.encode())
# 4.接收消息
re_data = client.recv(1024)
print('客户端>>>', re_data.decode(encoding='utf-8'))
