多线程和多进程

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

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()