Python_Weekend_多线程和多进程

之前我们打游戏经常会看到敏感词汇的屏蔽，那么我们就写一段代码来简单执行：

import re

def main():
sentence = 'Cao你大爷日顶Fuck马化腾shitfuck'
pure = re.sub('[cao艹草肏日干顶]|马化腾|fuck|shit','*',sentence,flags=re.IGNORECASE)
# []这个里面的是任取字  |  竖线是分支的意思     flags=re.IGNORECASE 大小写都包括

print(pure)
sentence = 'you go your way ,I will go mine !'
mylist = re.split(r'[\s,]',sentence)
## re.split 拆分的意思 [\s,} 遇到空格就拆分一个
print(mylist)

if __name__ == '__main__':
main()

这样就简单的屏蔽了相关的关键字，结果如下：

*你大爷******

讲一句英文拆分成单词：

import re
def main():

print(pure)
sentence = 'you go your way ,I will go mine !'
mylist = re.split(r'[\s,]',sentence)      ## re.split 拆分的意思 [\s,} 遇到空格就拆分一个
print(mylist)

if __name__ == '__main__':
main()

输出结果：

['you', 'go', 'your', 'way', '', 'I', 'will', 'go', 'mine', '!']

取a开头b结尾的一串：

def main():

sentence = 'abbzzaaabb'
m = re.match(r'a.*?b',sentence)
# r'a.*?b' 其中的问号代表尽可能的少取到 整体表示取a开头b结尾的*表示中间有任意个
print(m)

if __name__ == '__main__':
main()

输出结果：

<_sre.SRE_Match object; span=(0, 2), match='ab'>

一串字符里面取数字 然后算平均值 然后再放回去

from re import  findall,sub

def foo(mo):
val = int(mo.group())
return str(val ** 2)   # str是变回成字符串

def main():
content = 'abc123dsafghjf566ghrt895ffhhdd'
mylist = findall(r'\d+',content)     # findall 拿到列表容器
# print(mylist)
mylist = list (map(int,mylist))    ## 对每一个mylist的元素都来一个int  ，得到新的宿主
print(mylist)
print(sum(mylist)/len(mylist))

print(sub(r'\d+',foo,content))      ## 高阶函数 往函数里面传函数

if __name__ == '__main__':
main()

[123, 566, 895]
528.0
abc15129dsafghjf320356ghrt801025ffhhdd

接下来是关于多进程和多线程的相关代码：

进程：操作系统要分配内存的一个基本单位 进程之间的内存是相互隔离的 如果进程之间要隔离就ipc机制

线程：一个进程又可以进一步划分为多个线程，线程是进程的执行单位，也是操作系统分配CUP的基本单元。

多进程的作用：

如果一个任务执行时间很长，我们就可以利用多进程，缩短程序的执行时间。改善程序的性能

改善用户体验，让用户更好体验

import  time
from  multiprocessing import Process   ## 多进程
import  os
# process 进程
# thread 线程

def output():
while True:
print('Pong',end = '',flush=True)
time.sleep(0.01)

def main():
print(os.getpid())                     # 查看进程pid号
Process(target = output).start()         #  起动进程
while True:
print('Ping',end='',flush = True)   # flush 表示每有一个输出就显示出来，避免缓存
time.sleep(0.1)
output()

if __name__ == '__main__':
main()

这个结果就是这样输出的不断。。。。

5568
PingPingPongPongPongPongPongPongPongPongPingPongPongPongPongPongPongPongPongPongPongPingPongPongPongPongPongPongPongPongP.......

子进程可以进行调用程序或者文件：

# 起子进程

import  subprocess   # 子进程
# marine 海
# submarine 潜水艇

def main():
subprocess.call('calc')
subprocess.call('python test4.py')   # 调用刚刚的上面的文件

if __name__ == '__main__':
main()

结果输出的是打开计算机程序 和执行上面的程序。

多线程的输出：

from time import  sleep
from threading import Thread

def output(string):
while True:
# print('pong',end='',flush= True)
print(string, end='', flush=True)
sleep(0.001)

def main():
# t = Thread(target=output)
# t.start()
# while True:
#     print('ping',end ='',flush = True)
#     sleep(0.001)
t = Thread(target=output,args=('ping',),daemon =True)
# 守护线程 - 不值得保留的线程，主线程结束了就跟着结束
t.start()
t2 = Thread(target=output, args=('pong',),daemon =True)
# pong , 加逗号是因为站位 放置报错未传参
t2.start()
# daemon =True - 将线程设置为守护线程
sleep(0.001)

if __name__ == '__main__':
main()

结果是ping 和pong随机的出现输出

# 创建线程的两种方式
# 1.直接创建Thread对象并通过target参数指定线程启动后要执行的任务
# 2.继承Thread自定义线程 通过重写run方法指定线程启动后执行的任务

from time import  sleep
from threading import Thread

count = 0
def output(string):
global count
inner_count = 0
while count < 10:
print(string,end ='',flush= True)
count += 1
inner_count += 1
print('\n%s打印了%d次\n' % (string,inner_count))

def main():
t = Thread(target=output,args=('ping',),daemon =True)   # 守护线程 - 不值得保留的线程，主线程结束了就跟着结束
t.start()
t2 = Thread(target=output, args=('pong',),daemon =True)  # pong , 加逗号是因为站位 放置报错未传参
t2.start()                                    # daemon =True - 将线程设置为守护线程
sleep(0.001)

if __name__ == '__main__':
main()

# homework:1. 起五个线程 都往同一个列表容器追加内容，每个加10000个元素，最后统计列表里面是不是五万个东西
#  2.赛车游戏 五个颜色方块 五个线程分别控制五个赛车 ，颜色速度不一样 跑过终点