每日分享

Anything's possible if you've got enough nerve.

如果你有足够的勇气，一切皆有可能。

小闫语录：

不知道鼓起勇气尝试之后是否成功，但是我晓得尝试了才有可能成功，不尝试肯定不成功。

python那些包

OS

OS模块提供了一些对文件或文件夹的操作，下面我们介绍一些常用的命令：

文件重命名：

1. os.rename('小闫笔记.txt','小闫笔记plus.txt')
   

删除文件：

1. os.remove('小闫笔记.txt')
   

创建文件夹：

1. os.mkdir('小闫工作目录')
   

获取当前目录：

1. os.getcwd()
   

切换到上一级目录：

1. os.chdir('../')
   

获取当前目录下的目录列表：

1. os.listdir('./')
   

删除文件夹：

1. os.rmdir('小闫工作目录')
   

获取当前进程编号：

1. os.getpid()
   

获取父进程编号：

1. os.getppid()
   

杀死进程：

1. os.kill()
   

sys

获取输入的命令行参数，第一个元素是程序本身路径：

1. sys.argv
   

返回已经导入的模块列表：

1. sys.modules.keys()
   

获取系统导入的模块字段：

1. sys.modules
   

key是模块名，value是模块

获取模块的搜索路径，初始化时使用PYTHONPATH环境变量的值：

1. sys.path
   

socket

socket是进程间通信的一个工具。下面看一下如何进行使用：

创建一个socket：

1. socket.socket(AddressFamily,Type)
   
2. # 用于UDP协议，数据报套接字,AddressFamily我们选用ipv4类型
   
3. udp_socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
   
4. # 用于TCP协议，基于字节流的套接字，AddressFamily我们选用ipv4类型
   
5. tcp_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
   

Address Family：IP地址类型；AFINET表示ipv4类型、AFINET6表示ipv6类型；

Type：套接字类型，可以是 SOCK_STREAM（流式套接字，主要用于 TCP 协议）或者 SOCK_DGRAM（数据报套接字，主要用于 UDP 协议）。

绑定端口：

1. udp_socket.bind((IP,端口号))
   
2. tcp_socket.bind((IP,端口号))
   

注意绑定时，IP和端口放在小括号里；IP的是一个字符串，如果填 ""空字符串表示绑定本机所有IP；端口号是int类型。

发送数据：

1. udp_socket.sendto(数据,指定地址)
   
2. tcp_socket.send(数据)
   

数据需要进行encode编码，指定地址是一个包含IP和端口的元组，同绑定端口时用到的地址。

接收数据：

1. recv_data = udp_socket.recvfrom(1024)
   
2. recv_data = tcp_socket.recv(1024)
   

1024是本次接收的最大字节数。

关闭套接字：

1. udp_socket.close()
   
2. tcp_socket.close()
   

TCP服务器用到的监听和接受连接：

tcp_server_socket是总服务器套接字，client_socket是创建出来服务客户端的临时套接字

1. # 设置监听
   
2. tcp_server_socket.listen(128)
   

使用socket创建的套接字默认的属性是主动的，使用listen将其变为被动的，这样就可以接收别人的连接了。

128:表示最大等待连接数。

1. client_socket, clientAddr = tcp_server_socket.accept()
   

如果有新的客户端来连接服务器，那么就产生一个新的套接字专门为这个客户端服务。client_socket就是用来为这个客户端服务。

tcp_server_socket就可以省下来专门等待其他新客户端的链接。

threading

创建线程：

1. sub_thread = threading.Thread(target=任务函数名)
   

注意任务函数名不加括号。

开启创建的线程：

1. sub_thrad.start()
   

开启守护主线程：

1. # 守护主线程方式1：
   
2. sub_thread = threading.Thread(target=show_info,daemon=True)
   
3. # 守护主线程方式2：
   
4. sub_thread = threading.Thread(target=show_info)
   
5. sub_thread = setDaemon(True)
   

设置为守护主线程之后，主线程退出后子线程直接销毁不再执行子线程的代码。

主线程等待某一子线程执行完成后代码再往下执行：

1. 子线程名称.join()
   

互斥锁：

1. # 创建锁
   
2. mutex = threading.Lock()
   
3. # 锁定
   
4. mutex.acquire()
   
5. # 释放锁
   
6. mutex.release()
   

加上互斥锁后，哪个线程抢到这个锁我们决定不了，抢到锁的线程先执行，没有抢到锁的线程需要等待。

加上互斥锁多任务瞬间变成单任务，性能会下降，也就是说同一时刻只能有一个线程去执行。

使用互斥锁能够保证多个线程访问共享数据不会出现资源竞争及数据错误。

死锁：一直等待对方释放锁的情景就是死锁。

multiprocessing

创建子进程：

1. sub_process = multiprocessing.Process(target=run_proc)
   

启动子进程：

1. sub_process.start()
   

获取当前进程的编号：

1. current_process.pid
   

给子进程指定的函数传递参数：

1. sub_process = multiprocessing.Process(target=show_info, name="myprocess",args=("小闫同学",18))
   

group：进程组，一般不用设置

target：执行目标函数名

name：进程名称

args：以元组的方式给函数传参

kwargs：以字典的方式给函数传参

创建消息队列：

1. queue = mltiprocessing.Queue(3)
   

3：表示队列中最大消息个数

为消息队列中放入数据：

1. queue.put(data)
   

data可以是任意数据类型。

如果队列满了，需要等待队列有空闲位置才能放入数据，否则一直等待。

1. queue.put()
   

如果队列满了，不需要等待队列有空闲位置，如果放入不成功直接崩溃。

1. queue.nowait()
   

查看队列是否满了：

1. queue.full()
   

查看队列是否空了：

1. queue.empty()
   

查看队列中的消息个数：

1. queue.qsize()
   

获取数据：

1. queue.get()
   

如果队列空了，再取值需要等待，只有队列有值以后才能获取队列中数据：

1. queue.get()
   

如果队列空了，不需要等待队列有值，直接崩溃：

1. queue.get_nowait()
   

创建进程池：

1. pool = multiprocessing.Pool(3)
   

3：进程池中进程的最大个数

同步执行任务，一个任务执行完成以后另外一个任务才能执行：

1. pool.apply(调用函数名)
   

异步执行任务，任务执行不会等待，多个任务一起执行：

1. pool.apply_async(调用函数名)
   

关闭进程池：

1. pool.close()
   

意思是告诉主进程以后不会有新的任务添加进来。

不管任务是否完成，立即终止：

1. pool.terminate()
   

主进程等待进程池执行完成以后程序再退出：

1. pool.join()
   

greentlet

greentlet：第三方模块，需要安装，创建协程。

创建协程并开启：

1. g1 = greenlet.greenlet(任务函数名)
   

切换到指定的协程，执行对应的任务：

1. g1.switch()
   

gevent

gevent：第三方模块，比上面的 greentlet（需要手动切换任务）要好，可以自动切换任务。

gevent内部封装的greenlet，其原理是当一个greenlet遇到IO(指的是input output 输入输出，比如网络、文件操作等)操作时，比如访问网络，就自动切换到其他的greenlet，等到IO操作完成，再在适当的时候切换回来继续执行。

由于IO操作非常耗时，经常使程序处于等待状态，有了gevent为我们自动切换协程，就保证总有greenlet在运行，而不是等待IO

获取当前协程：

1. gevent.getcurrent()
   

创建协程并开启：

1. g1 = gevent.spawn(目标函数名,需要的参数)
   

等待指定协程执行完成：

1. g1.join()
   

实现真正的多任务，打补丁，让gevent框架识别耗时操作：

1. from gevent import monkey
   
2. monkey.patch_all()
   

re

re：此模块可以进行正则匹配。

根据正则表达式从头开始匹配字符串数据：

1. result = re.match(正则表达式,要匹配的字符串)
   

提取匹配到的数据：

1. result.group()
   

根据正则表达式查找数据，匹配出第一次出现的符合要求数据：

1. re.search(正则表达式,要匹配的字符串)
   

根据正则表达式查找数据，匹配出所有符合要求的数据：

1. re.findall(正则表达式,要匹配的字符串)
   

将匹配到的数据进行替换：

1. re.sub(正则表达式,替换后的字符串,要匹配的字符串,count=替换次数)
   

替换次数默认是全部替换，count可以指定次数，让程序根据指定次数替换。

根据匹配进行切割字符串，并返回一个列表：

1. re.split(正则表达式,要匹配的字符串,maxsplit=分割次数)
   

random

random：随机模块

生成一个0-1之间的随机浮点数：

1. random.random()
   

生成[a,b]之间的浮点数：

1. random.uniform(a,b)
   

生成[a,b]之间的整数：

1. random.randint(a,b)
   

在指定的集合[a,b)中，以step为间隔随机取一个数：

1. random.randrange(a,b,step)
   

time

time：时间模块

等待指定时间后，再执行操作：

1. time.sleep(时间)
   

返回当前时间的时间戳（1970纪元年经过的浮点秒数）：

1. time.time()