day1:
浅拷贝：a=b 两个列表id相同，用的是同一个堆和栈
深拷贝：a=copy.deepcopy(a) 两个列表id不同，用的是不同的堆和栈
查看任务管理器 ： Shift+Ctrl+Esc
阻塞状态：等待状态，代码都没有运行如input等待输入时
就绪状态：阻塞结束到运行之前
运行状态：
进程（1.进程的概念：一个程序的一次运行
2.导入process模块： from multiprocessing import Process 导入的是multiprocessing中的process模块 process就是进程模块
创建进程 ： p=Process(target=进程体，args=(参数元组)
3.进程子类继承：
from multiprocessing import Process
import os
class MyProcess(Process):
def __init__(self,num):
super().__init__()
self.num = num
def run(self):
self.num
print("当亲进程为子进程 ，子进程ID为%d"%os.getpid())
if __name__ == '__main__':
print(os.getpid())
for i in range(10):
m = MyProcess(5)
m.start()
继承multiprocessing包的Process模块，当启动start()方法是，会在类中触发run()方法创建子进程并调用
4.进程池:
进程池：有服务器预先创建的一组子进程（https://blog.csdn.net/hello_bravo_/article/details/52528283）
p=multiprocessing.Pool(进程池容量)
p.apply_async(子进程 进程体，参数元组） 异步执行进程（进程可同时运行）
p.apply(.....同上) 同步执行进程（运行完一个才能运行下一个）
进程池中的子进程：进程池在服务器启动之初就创建好了，所以每个子进程都相对"干净"，即它们没有打开不必要的文件描述符（从父进程继承而来）
也不会错误地使用大块的堆内存(从父进程复制得到)
进程池Pool中的apply方法与apply_async的区别（https://www.jianshu.com/p/0a55507f9d9e?open_source=weibo_search）
1.pool=Pool(3) #创建进程池 括号中填进程池的进程容量 不填默认为4个
2.apply（func,args）:同步执行
apply方法是阻塞的，意思就是等待当前子进程执行完毕后，在执行下一个进程。
因为apply是阻塞的，所以进入子进程执行后，等待当前子进程执行完毕，在继续执行下一个进程
首先主进程开始运行，碰到子进程，操作系统切换到子进程，等待子进程运行结束后，在切换到另外一个子进程，直到所有子进程运行完毕。 然后在切换到主进程，运行剩余的部分。
3.apply_async：异步执行
apply_async是异步非阻塞的，意思就是：不用等待当前进程执行完毕，随时根据系统调度来进行进程切换。
首先主进程开始运行，碰到子进程后，子进程运行，主进程说：让我先运行个够，等到操作系统进行进程切换的时候，在交给子进程运行。以为我们的
程序太短，然而还没等到操作系统进行进程切换，主进程就运行完毕了。
想要子进程执行，就告诉主进程：你等着所有子进程执行完毕后，在运行剩余部分。join()
4.join() （https://blog.csdn.net/qq_41020281/article/details/79561043）
join所完成的工作就是线程同步，即主线程任务结束之后，进入阻塞状态，一直等待其他的子线程执行结束之后，主线程再终止
5.进程间的通讯
必须先实例化Queue类 使用实例化的对象实现进程间的通讯
p=Queue(通讯容量)
如果要放进进程体
q.put('hello'） 写入
print(q.get()) 取出
q.size() 检测写入几个
q.full() 检测写满没有 满True
q.empty() 空True 非空False
day2:
线程（1.线程的概念
2.线程和进程的区别
3.线程的创建
4.线程子类的继承
5.线程间的全局变量是共享的
6.线程互斥锁【线程如果频繁修改全局变量，会对数据造成一定的误差】）
创建线程(两个方法：创建或类中继承创建)：import threading（导入thread模块的包）
t=threading.Thread(target=zxc,args=(,))
互斥锁：（https://blog.csdn.net/yanhuatangtang/article/details/75316644）
from threading import Lock
m=Lock()
n=m.acquire(False) #上锁 参数为False时，线程没取到共享变量也会继续运行，因此要加上if n
不写参数默认（True）,上锁时取不到共享变量的线程会进入阻塞状态，一直等待共享变量解锁取到为止,这种写法 不需要判断if n
if n:
num+=1
m.release()
协程：
协程的概念
复习迭代器
复习生成器
协程的编排（使用迭代器和生成器编辑的协程）
http://python.jobbole.com/86481/
生成器的编辑：(生成器中yield返回的值只能被迭代出来)
import time
def A():
while True:
print("=A=")
yield #记住这次运行到这，挂起函数，返回到迭代处，下次运行时从这里开始继续运行
time.sleep(1)
def B©:
while True:
print("=B=")
next(c（）)
time.sleep(1)
B(A())
列表推导式：
lists=[i for i in range(10)]
迭代器：
一般迭代生成器
next()
B(a)
或：
a=iter(迭代对象)
a.next()
greenlet:
from greenlet import greenlet
def A():
…
g2.switch()
…
def B():
…
g1.switch()
g1=greenlet(A)
g2=greenlet(B)
g1.switch()
单例
class Person(object):
__instanse = None
def new(cls,*asd,**sdf):
if cls.__instanse == None:
cls.__instanse = super().new(cls)
return cls.__instanse
def init(self):
print(“这是一个很寂寞的天”)
def start(self):
print(“下着有些伤心的雨”)
p=Person()
m=Person()
print(id§)
print(id(m))
进程线程总结（https://blog.csdn.net/a2011480169/article/details/74370184）
day4
套接字：
是支持网络通信的基本操作单元，可以看做是不同主机之间的进程进行双向通信的端点（可看作通信两方的一种约定）
通过套接字中的相关函数完成通信过程（Socket=Ip address+ TCP/UDP + port）port:端口号
UDP(数据报套接字): SOCK_DGRAM
TCP（流式套接字）: SOCK_STREAM
交互：（B：浏览器 C:客户端 S：服务器）
C/S: 客户端、服务器交互
B/S: 浏览器、服务器交互
IP：
查看IP:打开cmd,打ipconfig
内网：不能上网
外网：能上网
网络端口号：
协议：
udp:用户数据报协议：无连接的简单的面向数据报的传输层协议（通讯时只负责发送，是否接收并不负责，会发生丢包）
socket（from socket import *）socket.socket:
udp类型：用户数据报协议：无连接的简单的面向数据报的传输层协议（通讯时只负责发送，是否接收并不负责）
通讯只有两个客户端：【发送：udp_socket.sendto(send_data.encode("gb2312"),send_address
接收：get_data=udp_socket.recvfrom(1024))
】
发送：(核心：udp_socket.sendto(send_data.encode("gb2312"),send_address)）：
#创建socket类型： 1.UDP：数据报套接字 2.TCP：流式套接字
#创建UDP使用 SOCK_DGRAM 数据报套接字
#创建TCP使用 SOCK_STREAM 流式套接字
udp_socket=socket.socket(socket.AF_INET,socket.SOCK_DGRAM) #创建一个UDP的socket （通讯属性，socket类型）
#第一个参数：不同电脑间通讯选择AF_INET(socket包中的一个属性)
#第二个参数：type 创建的socket的类型（创建UDP使用 SOCK_DGRAM数据报套接字
#创建TCP使用 SOCK_STREAM 流式套接字）
send_address=('发送方端口号'，接收方端口号) #绑定要发送数据的IP和端口号 也就是接收方的IP地址和端口号 他是一个元组
send_data(变量名)=input(‘请输入要发送的数据’）
udp_socket.sendto(send_data.encode("gb2312"),send_address) #发送数据 使用UPD对象（dup_socket来发送数据
#使用对象中的sendto方法 内置两个参数
#第一个参数是发送的数据
#第二个参数是接收方的IP地址和端口号
udp_socket.close() #关闭资源
接收：（核心get_data=udp_socket.recvfrom(1024))：
from socket import *
udp_socket=socket(AF_INET,SOCK_DGRAM)
#如果对方要给我发信息 那么一定要知道我的IP地址和端口号
#IP地址是已知的 端口号
#当前应绑定我当前进程的端口号
#使用bind方法绑定当前进程的端口号和IP
#内置一个参数 参数是一个元组
address_family=("10.10.86.208",9988)
udp_socket.bind(address_family)
#接收信息使用recvfrom方法 内置一个参数
#参数是udp对象接收数据的最大值单位是字节
#然后recvfrom有一个返回值
#返回值是一个元组
#元组中有两个元素 第一个元素是接收的数据 第二个元素还是一个元组（元组里面是发送方的IP和端口号）
get_data=udp_socket.recvfrom(1024)
print(get_data)
#关闭资源
udp_socket.close()
udp_socket.bind()
tcp类型：传输控制协议：面向连接的协议（要连接也要断开。不会丢包，没发送或接收到会报错）
通讯时有服务器端（被动方）和客户端（主动方）
服务器端：
#编辑服务器 （#1.转被动；限制客户端接口量 listen(接口个数)
listen():函数不会阻塞，它主要做的事情为，将该套接字和套接字对应的连接队列长度告诉 Linux 内核，然后，listen()函数就结束。
#2.创建新socket；接收客户端地址 accept()
#3.接收客户端请求 recv(接收字节容量)
#4.输出请求 print(请求内容.解码)
#5.发送响应 send(响应内容.转码)
#6.关闭新socket close()
）
客户端：
#编辑客户端 (#1.连接地址 connect((ip,端口号))
#2.发送请求 send(请求内容.转码)
#3.接收响应 recv(接收字节容量)
#4.输出响应 print(响应内容.解码)
)
三次握手四次挥手
握手：
客户端向服务器:【0请求连接】
syn(0)---ack(1)
服务器向客户端：【同意连接+1，0确定是否连接】
+1,syn(0)---ack(1)
客户端向服务器：【确定连接+1】
+1,syn(0)---ack(1)
挥手：fin(0) ack(1)
客户端向服务器:【0关闭】
fin(0)---ack(1)
服务器向客户端：【确认关闭+1,0客户端关闭】
+1,fin(0)---ack(1)
服务器向客户端：【0请求获取资源】
fin(0)---ack(1)
客户端向服务器：【送还资源+1，服务器关闭资源】
+1,fin(0)---ack(1)
new()new方法:（https://www.cnblogs.com/kex1n/p/5991249.html）
class object:
@staticmethod # known case of __new__
def __new__(cls, *more): # known special case of object.__new__
""" T.__new__(S, ...) -> a new object with type S, a subtype of T """
pass
1.__new__() 函数：
只能用于从object继承的新式类
object将__new__()方法定义为静态方法，并且至少需要传递一个参数cls，cls表示需要实例化的类，此参数在实例化时由Python解释器自动提供。
实例化对象的时候，调用__init__()初始化之前，先调用了__new__()方法
__new__()必须要有返回值，返回实例化出来的实例
需要注意的是，可以return父类__new__()出来的实例，也可以直接将object的__new__()出来的实例返回。
2.与__init__()init方法：
__init__()有一个参数self，该self参数就是__new__()返回的实例
__init__()在__new__()的基础上可以完成一些其它初始化的动作，__init__()不需要返回值。
若__new__()没有正确返回当前类cls的实例，那__init__()将不会被调用，即使是父类的实例也不行。
我们可以将类比作制造商，__new__()方法就是前期的原材料购买环节，__init__()方法就是在有原材料的基础上，加工，初始化商品环节。
day5
python:
r:阻止转义，原字符串输出
正则表达式：(https://www.cnblogs.com/xiaxiaoxu/p/8436795.html)
import re
方法：
re.match()方法 参数2（'',string).group() 从头开始匹配
re.search()方法 全局查找
re.sub()方法 参数3（'被替换的字符串'，‘替换的字符串’，s（原字符串））替换
re.findall() 参数2（正则，string） 符合条件的收入列表
re.DOTALL :
re.M :re.M表示将字符串视为多行,从而^匹配每一行的行首,$匹配每一行的行尾
re.split2(":|;",string) 切割
普通转义字符（背）：
\ : 转义符（转义一下）
\d：匹配的是0--9任意一位数字
\D: 匹配的是任意一位非数字 除了数字以外的任意字符都可以
\w：匹配任意一位数字字母下划线
\W：匹配除了数字字母下划线任意一位字符
\s：匹配任意一位空白字符\r（换行？）,\n（空行？）,\t（制表符）,\v(垂直制表符)，\f(换页符)，空格
\S：匹配任意一位非空白字符
\b: 匹配字单词的边界
\B: 匹配除单词边界以外的部分
^或\A：放正则表达式第一位匹配字符串串首的原子，放原子第一位是“非”的意思，其他位置就是一个原子
$或\Z: 匹配字符串串尾的原子放结尾，固定了最后一位
？：匹配其前原子0次或一次（）
+ ：匹配其前原子1次或多次（匹配不上，不成功，会报错）
* ：匹配其前原子0次，1次或多次（没有匹配字符串，会匹配成功，结果为空，不会报错）
| ：或，匹配两个或多个选择。与逻辑或相同
. ：匹配除换行符以外的任意字符
.*: 无敌组合，没碰到换行\n，一直匹配
(): 整体表示一个原子 print(ret.group(2)) 输出第二个括号返回的值
：
:二进制
:八进制
:十进制
:十六进制
i:不区分大小写
原子表[]：原子表里面内置多个原子，在原子表中 每个原子都是平等的
贪婪匹配{}：在符合规则的情况下尽可能地多匹配
{m}:匹配其前原子m次
{m,}:匹配其前原子至少m次
{,n}：匹配其原子最多n次
{m,n}：匹配其前原子至少m次 匹配其前原子最多n次
\r：默认表示将输出的内容返回到第一个指针，这样的话，后面的内容会覆盖前面的内容
day6
URL:（协议、域名、端口、路径、锚）
U-协议http
R-域名www.com 可能跟端口
L-路径:可能跟参数 参数后可能跟锚
web：
编辑web服务器：(response_header = "Server: DogBrother" + "\r\n"
response_body = "hello 杨梦圆"
response = response_start_line + response_header + "\r\n" + response_body
new_socket.send(response.encode("gbk"))
)
#编辑web服务器
from socket import *
tpc_server_socket = socket(AF_INET,SOCK_STREAM)
tpc_server_socket.bind(('',8080))
tpc_server_socket.listen(128)
while True:
new_socket,client_address = tpc_server_socket.accept()
request_data = new_socket.recv(2048)
response_start_line = "HTTP/1.1 200 OK" + "\r\n"
response_header = "Server: DogBrother" + "\r\n"
response_body = "hello 杨梦圆"
response = response_start_line + response_header + "\r\n" + response_body
new_socket.send(response.encode("gbk"))
new_socket.close()
tpc_server_socket.close()
/:根目录
./：当前目录
../：上级目录
sum(num)函数传参：复制
问题： 套接字
类方法静态方法等
#\r,\n区别？
数字类型：4种
数据类型：6
join()
1.practice 29行（进程池）apply_sync(p_son)为什么不用加括号，也不能写target= Thread(zxc())
2.进程池子类继承？
3.Queue() 括号内表示的是什么的容量，怎么用
4.迭代器，生成器，装饰器描述
5.浅拷贝，深拷贝
6.正则中的r
7.# ?????????
# import re
# line = "IF_MIB::=Counter32: 12345\nIF_MIB::=Counter32: 1234556";
# result = re.findall(r'(?<=\:\s)\d+$', line, re.M)
# print(result)
8.匹配\home关键字：
re.findall(r"\\home","skjdfoijower \home \homewer")
结果：['\\home', '\\home'] 多出来的\不能消掉么
匹配邮箱：
匹配身份证：
9.listen(2):web服务器中被动监听2怎么理解 （os.pid(）)
复习： 互斥锁
进程池（）