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())
复习: 互斥锁
进程池()