文章目录
网络编程基础概念
# 打基础
# 了解一些网络的基础知识
# 简单的了解一些底层的网络通信
# 网络的概念
# 基于原生的网络模块来实现通信
# 概念
# 不变的：mac地址 能够唯一表示你这台机器的
# 变化的：ip地址 能够更好地更方便的找到你的机器
# 局域网：网段 交换机 不能理解IP地址，只能理解mac地址
# 局域网和局域网之间通信了：
# 网管 路由器 可以理解IP地址
# IP地址
# 0.0.0.0-255.255.255.255
#
# 公网地址：需要我们申请购买的地址
# 内网地址：保留字段
# 192.168.0.0- 192.168.255.255 内网地址
# 172.16.0.0- 172.31.255.255 内网地址
# 10.0.0.0- 10.255.255.255 内网地址
# 特殊的ip地址：
# 127.0.0.1 本地回环地址 测试的时候用的
# 子网掩码也是一个ip地址，用来判断两台机器在不在一个局域网内
# ipv6 0:0:0:0:0:0-FFFFFF:FFFFFF:FFFFFF:FFFFFF:FFFFFF:FFFFFF:192.168.12.3
# ip/mac 确认机器的
# 端口 0-65535 确认机器上的具体应用
# 概念整理
# 局域网的概念
# 交换机
# 在同一个局域网内的机器有交换机负责通信
# 交换机只认识mac地址
# 可以完成广播 组播 单薄
# 单播 -- mac地址（在网卡上）
# 局域网之间通信
# 路由器
# 提供网关ip，同一个局域网的所有机器共享一个网关
# 我们不能访问除了本局域网之外的其他内网的ip地址
# 子网掩码
# 用来判断两台机器是不是在一个网段内
# ip地址：ipv4协议， ipv6协议
# mac地址：arp协议（通过ip找mac）
# 端口port：0-65535， 用来确认机器上的具体应用
# 网络开发结构
# C/S架构
# client客户端 我们用的 需要安装的
# server服务端
# B/S架构：百度，博客园
# browser浏览器
# server服务端
# C/S架构和B/S架构什么关系？
# B/S架构也是C/S架构中的一种
# C/S架构的好处；
# 可以离线使用/功能更完善/安全性更高
# B/S架构的好处：（发展的方向）
# 不用安装就可以使用
# 统一PC端用户的入口
#
第一个网络通信
- 永远是服务端先启动，客户端才能启动
server端
import socket
sk = socket.socket()
sk.bind(('192.168.121.1', 9000)) # 绑定 ip + 端口
sk.listen() # 监听
conn, adder = sk.accept()
conn.send(b'hello') # 发送信息
msg = conn.recv(1024) # 接收的最大字节
print(msg)
conn.close()
sk.close()
client端
import socket
sk = socket.socket()
sk.connect(('192.168.121.1', 9000))
msg = sk.recv(1024)
print(msg)
sk.send(b'byebye')
sk.close()
协议概念
# 5层协议
# 应用层 python
# 传输层 port 四层路由器 （四层交换机）
# 网络层 ipv4 ipv6 路由器 （三层交换机）
# 数据链路层 mac arp协议 网卡 （二层交换机）
# 物理层
# 7层协议
# 应用层 （表示层 会话层）
# 传输层 port
# 网络层 ipv4 ipv6 路由器
# 数据链路层 mac arp协议 交换机
# 物理层
# tcp 和 udp
# tcp 打电话 - 线下缓存高强视频/qq远程控制/发邮件
# 需要先建立链接，然后才能通信
# 占用连接/可靠（消息不会丢失）/实时性高/慢
# 建立链接 - 三次握手
# 断开链接 - 四次握手
# 什么是三次握手？什么是四次握手？为什么握手是三次/四次？这个过程都传递了哪些信号
# udp 发短信 - 在线播放视频
# 不需要建立链接，就可以通信
# 不占用连接/不可靠（消息因为网络不稳定丢失）/快
udp
- server
import socket
sk = socket.socket(type=socket.SOCK_DGRAM)
sk.bind(('127.0.0.1', 8666))
while True:
msg, adder = sk.recvfrom(1024) # 接收 , adder为对方地址 ip+port
# if msg.decode('utf-8').lower() == 'q':
# print('会话结束')
# break
if msg.decode('utf-8').lower() == 'q':
continue
print(msg.decode('utf-8'))
send_msg = input('请输入：')
sk.sendto(send_msg.encode('utf-8'), adder)
# if send_msg.lower() == 'q':
# print('会话结束')
# break
- client
import socket
sk = socket.socket(type=socket.SOCK_DGRAM)
server = ('127.0.0.1', 8666)
while True:
send_msg = input('请输入：')
sk.sendto(send_msg.encode('utf-8'), server) # 发送
if send_msg.lower() == 'q':
print('会话结束')
break
msg = sk.recv(1024).decode('utf-8') # 接收
if msg.lower() == 'q':
print('会话结束')
break
print(msg)
tcp
初识
- server
import socket
sk = socket.socket()
sk.bind(('192.168.121.1', 9000)) # 申请操作系统的资源
sk.listen() # 监听
# while True: # 可以和多个客户端建立连接
# conn, adder = sk.accept() # conn里储存的是一个客户端和我server端连接信息
# conn.send(b'hello') # 发送信息
# msg = conn.recv(1024) # 接收的最大字节
# print(msg)
# conn.close() # 挥手 断开连接
conn, adder = sk.accept() # conn里储存的是一个客户端和我server端连接信息
while True:
send_msg = input('请输入：')
conn.send(send_msg.encode('utf-8')) # 发送信息
if send_msg.upper() == 'Q':
break
msg = conn.recv(1024).decode('utf-8') # 接收的最大字节
if msg.upper() == 'Q':
break
print(msg)
conn.close() # 挥手 断开连接
sk.close() # 归还申请的操作系统的资源
- client
import socket
sk = socket.socket()
sk.connect(('192.168.121.1', 9000))
while True:
msg2 = sk.recv(1024).decode("utf-8")
if msg2.upper() == 'Q':
break
print(msg2)
send_msg = input("请输入：")
sk.send(send_msg.encode('utf-8'))
if send_msg.upper() == 'Q':
break
sk.close()
tcp中的现象
- 不知道对方传输的字节大小
- 使用struct模块，转换为4字节
-
- 转：struct.pack(‘i’, len(msg2))
-
- 现接收字节大小：le = sk.recv(4)
-
- 再转为原来字节：struct.unpack(‘i’, le)[0] (注意返回的是元组， 所以取第一个)
- 每条信息都要转
- server
import socket
import struct
sk = socket.socket()
sk.bind(('127.0.0.1', 8666)) # 地址绑定
sk.listen() # 监听
conn, adder = sk.accept() # 建立连接
msg1 = input(">>>").encode('utf-8')
msg2 = input('>>>').encode('utf-8')
# num1 = str(len(msg1)) # 不能超过 9999字节
# ret = num1.zfill(4) # 转为4位 用 0 补字节
blen = struct.pack('i', len(msg1)) # 可以把两个g的内容转化为4个字节
conn.send(blen) # 先发送传输的字节大小
conn.send(msg1)
blen = struct.pack('i', len(msg2)) # 可以把两个g的内容转化为4个字节
conn.send(blen) # 先发送传输的字节大小
conn.send(msg2)
conn.close()
sk.close()
# 粘包现象 只出现在tcp协议中，因为tcp协议 多条信息之间没有边界，并且还有一大堆优化算法
# 发送端：两条消息很短且发送的间隔很短
# 接收端：接收消息不及时
# 导致粘包问题的本质：
- client
import socket
import struct
sk = socket.socket()
sk.connect(('127.0.0.1', 8666))
le = sk.recv(4) # 先接收传输的字节大小
le = struct.unpack('i', le)[0] # 解字节 ，返回元组
msg1 = sk.recv(le).decode('utf-8')
print(msg1)
le = sk.recv(4) # 先接收传输的字节大小
le = struct.unpack('i', le)[0] # 解字节 ，返回元组
msg2 = sk.recv(le).decode('utf-8')
print(msg2)
sk.close()
struct模块
import struct
num = 1234568
num2 = 123
num3 = 8
ret = struct.pack('i', num) # 可以把两个g的内容转化为4个字节
print(len(ret))
de = struct.unpack('i', ret) # 解字节 返回元组
print(de)
ret = struct.pack('i', num2) # 可以把两个g的内容转化为4个字节
print(len(ret))
de = struct.unpack('i', ret) # 解字节 返回元组
print(de)
ret = struct.pack('i', num3) # 可以把两个g的内容转化为4个字节
print(len(ret))
de = struct.unpack('i', ret) # 解字节 返回元组
print(de)
-----------------------------
4
(1234568,)
4
(123,)
4
(8,)
-----------------------------
tcp文件传输
- server
import json
import socket
import struct
# 解决粘包问题
sk = socket.socket()
sk.bind(('127.0.0.1', 9696))
sk.listen()
conn, _ = sk.accept()
msg_len = conn.recv(4) # 接收四个字节
msg_len = struct.unpack('i', msg_len)[0] # 解字节，返回的值是元组，取第一个，就是原来的数据大小
msg = conn.recv(msg_len)
msg = json.loads(msg) # 加载msg
with open(msg['filename'], 'wb') as f: # msg['filename'] 文件名字
while msg['filesize'] > 0: # msg['filesize'] 文件大小
content = conn.recv(1024)
# 传输的过程中，接收的不一定是1024个字节，因为要过转建站交换机
msg['filesize'] -= len(content) # 收多少减多少
f.write(content)
conn.close()
sk.close()
- client
import json
import socket
import os
import struct
# 发送
sk = socket.socket()
sk.connect(('127.0.0.1', 9696))
# 文件名
# 文件大小
abs_path = r'D:\PyCharmProject\python-核心编程\hehe'
filename = os.path.basename(abs_path) # 拿到文件名
filesize = os.path.getsize(abs_path) # 文件大小 xxx字节
dic = {'filename': filename, 'filesize': filesize}
str_dic = json.dumps(dic) # 将dic转为字符串json
b_dic = str_dic.encode('utf-8')
mlen = struct.pack('i', len(b_dic)) # 转化为四字节
sk.send(mlen) # 4个字节表示字典长度
sk.send(b_dic) # 具体的字典数据
with open(abs_path, 'rb') as f: # 打开文件
while filesize > 0:
content = f.read(1024) # 一次发送文件的大小
filesize -= 1024 # 文件的大小改变
sk.send(content) # 发送1024大小的文件
sk.close()
验证客户端的合法性
# # 随机生成一个字符串
# import os
# ret = os.urandom(16)
# print(ret)
#
# import hashlib
# sha = hashlib.sha1(秘钥)
# sha.update(随机字符串)
# result = sha.hexdigest()
# 第二种方法
import hashlib
import hmac # 替代hashlib模块
import os
# 秘钥+随机字符串
h = hmac.new(b'alex_sb', os.urandom(32), hashlib.sha256)
ret = h.digest()
print(ret)
-
server
import hashlib import os import socket secret_key = b'alex_sb' sk = socket.socket() sk.bind(('127.0.0.1', 9696)) sk.listen() conn, adder = sk.accept() # 创建一个随机的字符串 rand = os.urandom(32) # 发送随机字符串 conn.send(rand) # 根据发送的字符串+ secrete key 进行摘要 sha = hashlib.sha1(secret_key) sha.update(rand) res = sha.hexdigest() # 等待接收客户端的摘要结果 res_client = conn.recv(1024).decode('utf-8') # 做对比 if res_client == res: print('是合法客户端') # 如果一致， 就显示合法客户端 # 并继续操作 conn.send(b'hello') else: conn.close() # 如果不一致立即关闭连接 -
client
import socket
import hashlib
secret_key = b'alex_sb'
sk = socket.socket()
sk.connect(('127.0.0.1', 9696))
# 接收客户端发送的随机字符串
rand = sk.recv(32)
# 根据发送的字符串 + secrete key 进行摘要
sha = hashlib.sha1(secret_key)
sha.update(rand)
res = sha.hexdigest()
# 根据结果发送会server端
sk.send(res.encode('utf-8'))
# 继续和server端进行通信
msg = sk.recv(1024).decode('utf-8')
print(msg)
socketserver
- server
import time
import socketserver
class MyServer(socketserver.BaseRequestHandler):
# 必须要重写handel方法， 内部类规定的
def handle(self): # 所有的客户端都经过这个程序（每个客户端都有自己的handel）
conn = self.request # requests 是和客户端的连接
while True:
try:
content = conn.recv(1024).decode('utf-8')
conn.send(content.upper().encode('utf-8'))
time.sleep(0.5)
except ConnectionError:
break
server = socketserver.ThreadingTCPServer(('127.0.0.1', 9696), MyServer)
server.serve_forever() # 不关闭
- client
import socket
sk = socket.socket()
sk.connect(('127.0.0.1', 9696))
while True:
sk.send('i love you'.encode('utf-8'))
msg = sk.recv(1024).decode('utf-8')
print(msg)
多线程
进程
1.概念
# 进程的三状态图
# 就绪 运行 阻塞
# 进程的调度算法
# 给所有的进程分配资源或者分配cpu使用权的一种方法
# 短作业优先
# 先来先服务
# 多级反馈算法
# 多个任务队列，优先级从高到低
# 新来的任务总是优先级最高
# 每一个新任务几乎会立即获得一个时间片时间
# 执行完一个时间片之后会下降到下一个队列中
# 总是优先级高的任务都执行完，才执行优先级低的任务
# 并且优先级越高时间片越高
# 进程的开启和关闭
# multiple 多元化的
# processing 进程
# multiprocessing 多远的处理进程的模块
# from multiprocessing import Process
# import os
#
#
# def func():
# print(os.getpid(), os.getppid())
# # pid process id 进程id
# # ppid parent process id 父进程id
#
#
# if __name__ == '__main__':
# # 只会在子主进程中执行所有的代码，你写在name=main下
# print('main:', os.getpid(), os.getppid())
# p = Process(target=func)
# p.start()
# 为什么要用if __name__ == '__main__':
# a = 1
# 能不能给子进程传递参数
# from multiprocessing import Process
# import os
#
#
# def func(name, age):
# print(os.getpid(), os.getppid(), name, age)
#
#
# if __name__ == '__main__':
# # 只会在子主进程中执行所有的代码，你写在name=main下
# print('main:', os.getpid(), os.getppid())
# p = Process(target=func, args=('李锦彪', 84)) # 传参
# p.start()
# 能不能获取子进程的返回值
# 不能
# 能不能同时开启多个子进程
# 可以
# import time
# from multiprocessing import Process
# import os
#
#
# def func(name, age):
# print('%s start' % name)
# time.sleep(1)
# print(os.getpid(), os.getppid(), name, age)
#
#
# if __name__ == '__main__':
# # 只会在子主进程中执行所有的代码，你写在name=main下
# print('main:', os.getpid(), os.getppid())
# arg_lit = [('ljn', 54), ('jv', 12), ('hdhd', 11)]
# for i in arg_lit:
# p = Process(target=func, args=i) # 传参
# p.start() # 异步非阻塞
# join的用法
# import time
# from multiprocessing import Process
#
# def func(name, age):
# print('%s 的年龄： %d' % (name, age))
# time.sleep(1)
# print('发送完毕')
#
# if __name__ == '__main__':
# arg_lit = [('李锦彪', 18), ('黄欣宇', 12), ('锦欣宇', 11)]
# p_lst = []
# for i in arg_lit:
# p = Process(target=func, args=i) # 传参
# p.start() # 异步非阻塞
# p_lst.append(p)
# for p in p_lst:
# p.join() # 阻塞：直到p这个进程执行完，才继续执行代码
# print('所有的邮件发送完毕')
# 同步阻塞，异步非阻塞
# 同步阻塞：join
# 异步非阻塞：start
# 多进程之间的数据是否隔离 是
# from multiprocessing import Process
# n = 0
# def func():
# global n
# n += 1
#
# if __name__ == '__main__':
# p_1 = []
# for i in range(0, 100):
# p = Process(target=func)
# p.start()
# p_1.append(p)
# for p in p_1:
# p.join()
# print(n)
# 使用多进程实现一个并发的socket的server
#
2.多进程实现一个并发的socket的server
server：
import socket
from multiprocessing import Process
def talk(conn):
while True:
msg = conn.recv(1024).decode('utf-8')
print(msg)
ret = msg.upper().encode('utf-8')
conn.send(ret)
conn.close()
if __name__ == '__main__':
sk = socket.socket()
sk.bind(('127.0.0.1', 9999))
sk.listen()
while True: # 来一个开一个子进程
conn, adder = sk.accept()
Process(target=talk, args=(conn, )).start()
sk.close()
client:
import socket
import time
sk = socket.socket()
sk.connect(('127.0.0.1', 9999))
while True:
sk.send(b'hello')
msg = sk.recv(1024).decode('utf-8')
print(msg)
time.sleep(0.5)
sk.close()
3.开启进程的另一种方法
import os
import time
from multiprocessing import Process
class MyProcess(Process):
def __init__(self, a, b, c):
self.a = a
self.b = b
self.c = c
super().__init__()
def run(self):
time.sleep(1)
print(os.getpid(), os.getppid(), self.a, self.b, self.c)
if __name__ == '__main__':
print('-->', os.getpid())
for i in range(10):
p = MyProcess(11, 2, 3)
p.start()
4.process类的其他方法
import os
import time
from multiprocessing import Process
class MyProcess(Process):
def __init__(self, a, b, c):
self.a = a
self.b = b
self.c = c
super().__init__()
def run(self):
time.sleep(1)
print(os.getpid(), os.getppid(), self.a, self.b, self.c)
if __name__ == '__main__':
print('-->', os.getpid())
p = MyProcess(11, 2, 3)
p.start()
print(p.pid, p.ident)
print(p.name)
print(p.is_alive()) # 查看进程是否还活着
p.terminate() # 强制结束一个子进程 同步 异步非阻塞
print(p.is_alive())
time.sleep(0.01)
print(p.is_alive())
5.守护进程
import time
from multiprocessing import Process
def son1():
while True:
print('-->is son1')
time.sleep(1)
def son2():
for i in range(10):
print('in son2')
time.sleep(1)
if __name__ == '__main__':
p1 = Process(target=son1)
p1.daemon = True # 表示设置p1 是一个守护进程
p1.start()
p2 = Process(target=son2)
p2.start()
time.sleep(3) # 守护进程只进行3秒，3秒后回收资源
print('in main 守护进程结束')
# p2.join() # 等待p2结束，守护进程结束
# 主进程会等待所有的子进程结束，是为了回收子进程的资源
# 守护进程会等待主进程的代码执行结束之后再结束, 而不是等待整个主进程结束
# 主进程的代码什么时候结束
6.锁
# 进程之间安全的问题
import time
from multiprocessing import Process, Lock
import json
def search(i):
with open('ticket', encoding='utf-8') as f:
ticket = json.load(f)
print('%s :当前的余票是%s张' % (i, ticket['count']))
def buy_ticket(i):
with open('ticket', encoding='utf-8') as f:
ticket = json.load(f)
if ticket['count'] > 0:
ticket['count'] -= 1
print('%s 买到票了' % i)
time.sleep(0.1)
with open('ticket', mode='w', encoding='utf-8') as f:
json.dump(ticket, f)
def get_lock(i, lock): # 加锁
with lock: # 代替acquire和release 并且在此基础上做一些异常处理， 保证即便一个进程的代买出错退出了，也会归还钥匙
search(i)
buy_ticket(i)
if __name__ == '__main__':
lock = Lock()
for i in range(10):
Process(target=get_lock, args=(i, lock)).start()
# import time
# from multiprocessing import Lock, Process
#
#
# def func(n, lock):
# lock.acquire() # 拿钥匙
# print('%s 被锁起来的码' % n)
# time.sleep(1)
# lock.release() # 换钥匙
#
#
# if __name__ == '__main__':
# lock = Lock()
# for i in range(10):
# Process(target=func, args=(i, lock)).start()
7.队列
生产者消费者模型
# 进程之间的数据隔离
# 进程之间的通信（IPC）Inter Process communication
# 基于文件：同一台机器上的多个进程之间通信
# 基于socket的文件级别的通信来完成数据传递的
# 基于网络：同一台机器或者多台机器上的多进程通信
# 第三方工具（消息中间件）
# memcache
# redis
# rabbitmq
# # kafka
# from multiprocessing import Queue, Process
#
#
# def pro(q):
# for i in range(10):
# print(q.get())
#
#
# def son(q):
# for i in range(10):
# q.put('hello %s' % i)
#
#
# if __name__ == '__main__':
# q = Queue()
# p = Process(target=son, args=(q, ))
# p.start()
# p = Process(target=pro, args=(q,))
# p.start()
# 生产者消费者模型
# 爬虫的时候
# 分布式操作：celery
# 本质：就是让生产数据和消费数据的效率达到平衡并且最大话的效率
import random
import time
from multiprocessing import Process,Queue
def consumer(q, name): # 消费者:通常取得数据后还要进行某些操作
while True:
food = q.get()
if food:
print('%s 吃了 %s' % (name, q.get()))
else: break
def producer(q, name, food): # 生产者：通常在放数据之前需要先通过某些代码来获取数据
for i in range(10):
foodi = '%s%s' % (food, i)
print('%s 生产了 %s' % (name, foodi))
time.sleep(random.random())
q.put(foodi)
if __name__ == '__main__':
q = Queue()
p = Process(target=consumer, args=(q, '李锦彪'))
p1 = Process(target=producer, args=(q, '黄欣宇', '黄金'))
p2 = Process(target=producer, args=(q, '锦欣宇', '西瓜'))
p.start()
p1.start()
p2.start()
p1.join()
p2.join()
q.put(None)
8.异步阻塞
生产者消费者模型
线程
1.threading模块
# import time
# from threading import Thread
#
#
# def func(i):
# print('start %s' % i)
# time.sleep(1)
# print('end%s' % i)
#
#
# if __name__ == '__main__':
# p_1 = []
# for i in range(10):
# t = Thread(target=func, args=(i,))
# t.start()
# p_1.append(t)
# for i in p_1:
# i.join()
# print('所有的线程都执行完了')
#
#
# # 线程不能从外部关闭terminate
# # 所有的子线程只能是自己执行完代码之后就关闭
# # current_thread() 获取当前所在线程的对象，current_thread（）.ident 获取线程的id
# # enumerate 列表， 储存了所有活着的线程的对象，包括主线程
# # active_count 数字，储存了所有活着的线程个数
#
# 面向对象的方式起线程
# from threading import Thread
#
#
# class MyThread(Thread):
# def __init__(self, a, b):
# self.a = a
# self.b = b
# super().__init__()
#
# def run(self):
# print(self.ident)
#
#
# t = MyThread(1, 2)
# t.start() # 开启线程中执行run（）方法
# print(t.ident)
# 线程之间的数据
from threading import Thread
n = 100
def func():
global n
n -= 1
t_1 = []
for i in range(100):
t = Thread(target=func)
t.start()
t_1.append(t)
for i in t_1:
i.join()
print(n)
2.守护线程
import time
from threading import Thread
def son():
while True:
print('in son')
time.sleep(1)
def sons():
for i in range(10):
print('in sons****')
time.sleep(1)
if __name__ == '__main__':
t = Thread(target=son)
t.daemon = True # 守护线程
t.start()
Thread(target=sons).start()
# 主线程会等待子线程结束之后才结束
# 为什么？
# 主线程结束进程就会结束
# 守护线程随着主线程的结束而结束
# 守护线程会在主线程的代码结束之后继续守护其他子线程
# 守护进程会随着主进程的代码结束而结束，如果主进程代码结束之后还有其他子进程在运行，守护进程不守护
# 守护线程 随着主线程的结束而结束，如果主线程代码结束之后还有其他子线程在运行，守护线程也守护
3.线程锁
import time
from threading import Thread, Lock
n = 0
def add(lock):
with lock:
for i in range(5520000):
global n
n += 1
def sub(lock):
with lock:
for i in range(5520000):
global n
n -= 1
if __name__ == '__main__':
t_1 = []
lock = Lock()
for i in range(2):
t1 = Thread(target=add, args=(lock,))
t1.start()
t2 = Thread(target=sub, args=(lock,))
t2.start()
t_1.append(t1)
t_1.append(t2)
for i in t_1:
i.join()
print(n)
4.单例模式
import time
from threading import Thread
class A:
from threading import Lock
__instance = None
lock = Lock()
def __new__(cls, *args, **kwargs):
with cls.lock:
if not cls.__instance:
time.sleep(0.00001) # cpu 轮转
cls.__instance = super().__new__(cls)
return cls.__instance
def func():
a = A()
print(a)
if __name__ == '__main__':
for i in range(10):
Thread(target=func).start()
# 不要操作全局变量， 不要在类里操作静态变量
# queue logging 数据安全的
5.递归锁和死锁
import time
from multiprocessing import Process, RLock, Lock
from threading import Thread
# Lock 互斥锁 效率高 多把锁容易出现死锁现象
# RLock递归（recursion）锁 效率相对低 解决死锁现象好
# l = Lock()
# l.acquire()
# print('haha') # 希望被锁住的内容
# l.release()
# r = RLock() # 在同一个线程中可以被acquire()多次
# r.acquire()
# print('希望被锁住的内容')
# r.release()
# def func(i, lock):
# lock.acquire()
# print(i, '：start')
# lock.release()
#
#
# if __name__ == '__main__':
# lock = Lock()
# for i in range(5):
# p = Thread(target=func, args=(i, lock)).start()
# ******************死锁现象****************
noodle_lock = Lock()
fork_lock = RLock()
def eat(name):
fork_lock.acquire()
print(name, '抢到面了')
print(name, '抢到叉子了')
print(name, '吃面')
time.sleep(1)
fork_lock.release()
print(name, '放下叉子了')
print(name, '放下面了')
def eat2(name):
fork_lock.acquire()
print(name, '抢到叉子了')
print(name, '抢到面了')
print(name, '吃面')
fork_lock.release()
print(name, '放下面了')
print(name, '放下叉子了')
if __name__ == '__main__':
Thread(target=eat, args=('李锦彪',)).start()
Thread(target=eat2, args=('黄欣宇',)).start()
Thread(target=eat, args=('锦欣宇',)).start()
Thread(target=eat2, args=('二蛋',)).start()
6.队列
import queue # 线程之间的数据安全的容器队列
q = queue.Queue(4) # fifo 先进先出的队列
q.put(1)
q.put(2)
q.put(3)
print(q.get())
print(q.get())
print(q.get())
try:
q.get_nowait()
except Exception as e:
print(e)
print('队列为空继续其他内容')
print('*' * 50)
from queue import LifoQueue # last in first out 后进先出
lq = LifoQueue()
lq.put(1)
lq.put(2)
lq.put(3)
print(lq.get())
print(lq.get())
print(lq.get())
print('*' * 50)
from queue import PriorityQueue # 优先级队列
priq = PriorityQueue()
priq.put((1, 'a'))
priq.put((5, 'b'))
priq.put((6, 'x'))
priq.put((4, 'y'))
print(priq.get())
print(priq.get())
print(priq.get())
print(priq.get())
7.池
# 什么是池
# 要在程序开始的时候，还没提交任务先创建几个线程或者进程
# 放在一个池子里，这就是池
# 为什么要用池
# 如果先开好进程/线程，那么有任务之后就可以直接使用池中的数据了
# 并且开好后的线程或者进程会一直存在池中，可以被多个任务反复利用
# 这样极大地减少了开启/关闭/调度线程/进程 的时间开销
# 池中的线程/进程个数控制了操作系统需要调度的任务个数，控制池中的单位
# 有利于提高操作系统的效率，减轻操作系统的负担
import random
import time
from concurrent.futures import ThreadPoolExecutor, ProcessPoolExecutor
from threading import current_thread
def func(name, n):
print(name, current_thread().ident, n)
time.sleep(random.randint(1, 3))
tp = ThreadPoolExecutor(20)
for i in range(20):
tp.submit(func, '李锦彪', 2)
# 向池中传数据，一次加入即可
协程
1.协程概述
# 协程
# 是操作系统不可见的
# 协程本质就是一条协程，多个任务在一条线程上来回切换，来规避io操作，就达到我们将一条线程中的io操作降到最低的目的
# gevent = 利用 greenlet 底层模块完成的切换 + 自动规避io的功能
# asynico = 利用 yield(让步) 底层语法完成的切换 + 自动规避io的功能
# tornado 异步的web框架
# yield from 更好的实现协程
# send 更好的实现协程
# 进程 数据隔离 数据不安全 操作系统级别 开销非常大 能利用多核
# 线程 数据共享 数据不安全 操作系统级别 开销小 不能利用多核
# 一些和文件操作相关的io只有系统能感知到
# 协程 数据共享 数据安全 用户级别 更小 不能利用多核
# 协程的所有的切换都基于用户，只有在用户级别能够感知到的io操作才会用协程模块做切换来规避（socket， 请求网页）
# 用户级别的协程还有什么好处：
# 减轻了操作系统的负担
# 一条线程下如果开了多个协程，那么给操作系统的印象是线程很忙，这样能争取一些时间片时间来被cpu执行，程序的效率就提高了
数据库
1.初识
# Innodb存储引擎 mysql5.6之后的默认存储引擎
# 支持事务：为了保证数据的完整性，将多个操作变成原子性操作 ： 保持数据安全
# 支持行级锁：修改的行少的时候 ： 修改数据频繁的操作
# 表级锁：批量修改多行时 ： 对于大量数据得到同时修改
# 支持外键：约束两张表中的关联字段不能随意的添加/删除 ： 能够降低数据增删改的出错率
# 写入数据
# insert into 表 values（1,2,3,4,5）
# insert into 表 （1,2,3）value（1,2,3）
# 数据类型
# float(5, 2) 保留2位小数，并四舍五入（一共多少位， 小数后多少位）
# 数据类型-时间
# 写入标准 表示
# date ：20220312 YYYY-MM-DD 年月日
# time ：121953 HH:MM:SS 时分秒
# datetime：20220312213512 YYYY-MM-DD HH:MM:SS 年月日时分秒
# 数据类型-字符串
# char(18) 最多只能表示255个字符
# 定长存储 存取速度快
# ‘alex’ ‘alex ’
# 身份证号、手机号码、QQ号、username、password、银行卡号
# varchar(18) 最多表示65535个字符
# 变长存储， 节省空间，存取速度慢
# ‘alex’ ‘alex4’
# 评论、朋友圈、微博
# set和enum
# enum：单选行为
# set ：多选行为
# 表的完整性约束
# 无符号的：unsigned
# 不能为空：not null
# 默认 值：default xx
# 不能重复：unique
# 主键（非空+唯一）：primary key （一张表只有一个）
# 联合主键：primary key（字段1，字段2.。。）
# 自增：auto_increment
# 外键：foreign_key(本表的外键键) references (其他的表)
# cascade方式：在父表上update/delete记录时，同步update/delete掉子表的匹配记录
# on update cascade
# 表与表之间的关系
# 一对多
# 电脑 软件
# 订单 商品
# 多对一
# 学生 班级
# 学院 学校
# 多对多 （第三张表 两个外键）
# 学生 班级 多对一
# 多个学生是一个班级
# 一对一
# 客户 学生
# unique foreign key
2.表操作
# 增 insert into 表(字段。。。) values (值。。。) 或 insert into 表 values (值。。。)
# 删
# delete from 表 where 条件;
# truncate table 表; 完全删除表
# 改 update 表 set 字段=xx, 字段=xx where 条件
# 查***********************************************
# 简单查询
# select 字段 from 表;
# 字段重命名为name：select 字段 ‘name’ from 表;
# 避免重复：select distinct 字段 from 表;
# 避免重复：select distinct 字段,字段 from 表;
# concat（'a', 'v', 'b'） 拼接：avb ：select concat(id, ':', name) from 表;
# 默认自动拼接：avb ：select concat_ws('':, id, name, on) from 表; id:name:on
# where 筛选所有符合条件的行**************************
# 比较运算符 <>!=
# 范围
# between 1 and 2000
# in
# 模糊匹配
# like
# % 通配符n个字符
# _ 通配符1个字符
# regexp
# 逻辑运算
# and not or
# 判断是否为空：
# select * from 表 where name is not null; 不为空
# select * from 表 where name is null; 为空
# 分组 ********************************************
# 根据谁分组，可以求最大小值，数量，平均值，总和，但是这个求出来的值只是和分组字段对应
# 并不和其他任何字段对应，这个时候查出来的其他字段都不生效
# group by 分组：select * from 表 group by 分组条件;
# 聚合函数：count max min sum avg
# select count(字段) from 表 group by 分组条件;
# having 过滤语句
# 在having条件中可以使用条件函数
# select 字段，count(salary) from 表 group by 分组条件 having count(salary) > 1000;
# order by 排序 默认从小到大； order by desc 从大到小排
# select * from 表 order by 字段;
# select * from 表 order by 字段，字段; 字段一相同时按字段二排
# limit m，n = limit n offset m
# 从m+1项开始，取 n 项
# 如果不写m，默认为0
# select * from 表 limit m，n;
# 多表查询****************************************
# 连表查询（快，比子查询好）
# select * from 表1，表2 where 条件; 列：（表1.字段=表2.字段）
# 表与表之间的连接方式
# 内连接：select * from 表1 inner join 表2 on 条件;
# 外连接：
# 左外连接：优先显示左边的表内容
# select * from 表1 left join 表2 on 条件;
# 右外连接：优先显示右边的表内容
# select * from 表1 right join 表2 on 条件;
# 全外连接： full join
# select * from 表1 left join 表2 on 条件 union select * from 表1 right join 表2 on 条件;
# 子查询
# select * from 表 where 条件 in （select 条件 from 表）;
3.索引
4.pymysql模块
必须的步骤
conn = pymysql.connect(host='',user='',password='',database=''); # 连接数据库
cur = conn.cursor() # 游标，为了执行mysql语句准备
ret = cur.execute('sql....') # 执行SQL语句，有返回值加参数ret
cur.execute('sql....') # 没有返回值，修改表内容
cur.commit() # 需要提交执行
print(cur.rowcount) # 获取操作影响的行数
cur.close()
conn.close()
import pymysql
conn = pymysql.connect(host='127.0.0.1', user='root', password='187365', database='ljb')
# cursor=pymysql.cursors.DictCursor拿到的值放在字典中
cur = conn.cursor(cursor=pymysql.cursors.DictCursor) # cursor游标, cur 准备操作
# 通常执行异常操作
# cur.execute('select * from gds_goods;') # 执行mysql语句
# print(cur.rowcount) # 获取操作影响的行数
# try:
# cur.execute('insert into gds_goods (gds_memo, gds_name, gds_no, gds_price) '
# 'values ("大傻子","二傻子","22222","88888");')
# conn.commit() # 修改表数据，需要提交
# except:
# conn.rollback() # 回滚：第一条语句出错时，回滚执行第二条
# ret = cur.fetchone() # 拿某一个值
# print(ret)
#
# ret = cur.fetchmany(2) # 拿多个值
# print(ret)
# ret = cur.fetchall() # 拿所有的值
# for i in ret:
# print(i)
# username = input('请输入账号：')
# password = input('请输入密码：')
#
# sql = 'select * from personal_information where username=%s and password=%s;'
# cur.execute(sql, (username, password)) # sql语句 + 参数（元组或列表）
#
# print(cur.fetchone())
#
# cur.close()
# conn.close()
5.事务、锁
# 锁
# 防止同时执行
# begin; 开始任务
# 执行sql语句
# commit; 提交任务
web服务
1.初识http
服务器
import socket
sk = socket.socket()
sk.bind(('127.0.0.1', 9696))
sk.listen()
while 1:
conn, adder = sk.accept()
mvg = conn.recv(1024).decode('utf-8')
print(mvg)
conn.send(b'HTTP/1.1 200 ok\r\n\r\n') # http请求信息
with open('my.html', 'rb') as f: # 读取html
data = f.read()
conn.send(data) # 发送html
html
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>Title</title>
</head>
<body>
<h1>你好！世界</h1>
</body>
</html>
get方法
- a标签、form表单
post方法
- 一般用来提交数据
2、web框架
import socket
from threading import Thread
import time
sk = socket.socket()
sk.bind(('127.0.0.1', 9696))
sk.listen()
def html(conn):
time_target = str(time.time())
with open('my-2.html', 'r', encoding='utf-8') as f: # 读取html,以字符串形式读取，以便后续操作（动态）
data = f.read() # 读取字符串
data = data.replace('$xxoo$', time_target) # 替换
data = data.encode('utf-8')
conn.send(data) # 发送html
conn.close()
def css(conn):
with open('test.css', 'rb') as f:
data = f.read()
conn.send(data)
conn.close()
def js(conn):
with open('javascript.js', 'rb') as f:
data = f.read()
conn.send(data)
conn.close()
def jpg(conn):
with open('1.jpg', 'rb') as f:
data = f.read()
conn.send(data)
conn.close()
def ico(conn):
with open('1.ico', 'rb') as f:
data = f.read()
conn.send(data)
conn.close()
def jqurey(conn):
with open('jquery-3.6.0.js', 'rb') as f:
data = f.read()
conn.send(data)
conn.close()
urlpatterns = [ # 反射准备
('/', html),
('/test.css', css),
('/1.jpg', jpg),
('/1.ico', ico),
('/javascript.js', js),
('/jquery-3.6.0.js', jqurey)
]
while 1:
conn, adder = sk.accept() # 等待接收信息
request_mvg = conn.recv(1024).decode('utf-8') # 接收信息
path = request_mvg.split('\r\n')[0].split(' ')[1] # 网页需要请求的路径
conn.send(b'HTTP/1.1 200 ok\r\n\r\n') # http请求信息：协议/版本 状态码 状态码原因短语
for i in urlpatterns:
if path == i[0]:
print(path)
Thread(target=i[1], args=(conn,)).start() # 线程处理并发
ket
from threading import Thread
import time
sk = socket.socket()
sk.bind((‘127.0.0.1’, 9696))
sk.listen()
def html(conn):
time_target = str(time.time())
with open(‘my-2.html’, ‘r’, encoding=‘utf-8’) as f: # 读取html,以字符串形式读取，以便后续操作（动态）
data = f.read() # 读取字符串
data = data.replace(‘
x
x
o
o
xxoo
xxoo’, time_target) # 替换
data = data.encode(‘utf-8’)
conn.send(data) # 发送html
conn.close()
def css(conn):
with open(‘test.css’, ‘rb’) as f:
data = f.read()
conn.send(data)
conn.close()
def js(conn):
with open(‘javascript.js’, ‘rb’) as f:
data = f.read()
conn.send(data)
conn.close()
def jpg(conn):
with open(‘1.jpg’, ‘rb’) as f:
data = f.read()
conn.send(data)
conn.close()
def ico(conn):
with open(‘1.ico’, ‘rb’) as f:
data = f.read()
conn.send(data)
conn.close()
def jqurey(conn):
with open(‘jquery-3.6.0.js’, ‘rb’) as f:
data = f.read()
conn.send(data)
conn.close()
urlpatterns = [ # 反射准备
(‘/’, html),
(‘/test.css’, css),
(‘/1.jpg’, jpg),
(‘/1.ico’, ico),
(‘/javascript.js’, js),
(‘/jquery-3.6.0.js’, jqurey)
]
while 1:
conn, adder = sk.accept() # 等待接收信息
request_mvg = conn.recv(1024).decode(‘utf-8’) # 接收信息
path = request_mvg.split('\r\n')[0].split(' ')[1] # 网页需要请求的路径
conn.send(b'HTTP/1.1 200 ok\r\n\r\n') # http请求信息：协议/版本 状态码 状态码原因短语
for i in urlpatterns:
if path == i[0]:
print(path)
Thread(target=i[1], args=(conn,)).start() # 线程处理并发
