2024-06-18 验证码、加密算法，多线程进程

一、4位验证码

import random

code = ''
for i in range(4):
    cur = random.randrange(0,4)
    if cur != i:
        temp = chr(random.randint(65,90))   //ASCII码显示
    else:
        temp = random.randint(0,9)
    code += str(temp)
print(code)

二、 加密算法

1、Md5 加密

一般用于密码加密和集合文章去重，查看文章是否修改。长度只有32位

import hashlib

md5 = hashlib.md5("你好".encode("utf-8"))      //实例化，将字符串2进制编码放在md5中

print(md5.hexdigest())                         //固定写法

md5.update('世界'.encode("utf-8"))             //将字符串'世界'进行2进制编码，更新到md5中

print(md5.hexdigest(),len(md5.hexdigest()))    //输出16进制表示和长度

2、sha1 加密 

h = hashlib.sha1("你好".encode())

resultBytes = h.digest()           //固定写法 产生哈希值对应的bytes对象

resultHex = h.hexdigest()          //固定写法

print(resultHex,len(resultHex))

三、多线程和多进程

进程包含一个或多个线程，相当于一个程序，线程是cpu分配资源的基本单位。

1.并发并行※

并发：一个时间段内做多个事情，多线程，有GIL全局锁的事件先执行。遇到需要等待的事件先执行其他事件。

并行：同一时间内做多个事情，多进程，多核操作。

2.多线程

多线程并不是越多越好。

1.函数创建线程

thread.Thread(group=Nore,targt=None,args=(),kwargs={},*,daemon=None)

~group：必须为None，于ThreadGroup类相关，一般不使用。

~target：线程调用的对象，就是目标函数。

~name：为线程起这个名字。

~args：为目标函数传递关键字参数，字典。

~daemon（守护进程）：用来设置线程是否随主线程退出而退出。

import time
import threading
def test (x,y):
 for i in range(x,y):
     time.sleep(1)
     print(i)
thread1 = threading.Thread(name='t1',target= test,args=(1,10))
thread2 = threading.Thread(name='t2',target= test,args=(11,20))
thread1.start()   #启动线程1
thread2.start()   #启动线程2

daemon（守护进程）：用来设置线程是否随主线程退出而退出。 当daemon设置False时，线程不会随主线程退出而退出，主线程会一直等着子线程执行完;。当daemon设置True时，线程会随主线程退出而退出，主线程结束其他的子线程会强制退出。主线程创建的所有线程不设置daemon属性，则默认都是daemon=False。

2.类创建线程

import time
import threading
class mythread(threading.Thread):
  def run(self):
    for i in range(1,10):
      print(i)
      time.sleep(1)
thread1 = mythread()
thread2 = mythread()
thread1.start()
thread2.start()

 3.阻塞线程

import time
import threading
def tes1():
 time.sleep(5)
 for i in range(10):
  print(i)
thread1=threading.Thread(target=tes1)
thread1.start()
thread1.join()
print('主线程完成了')

join(timeout-=None)

timeout 参数指定调用者等待多久，没有设置时，就一直等待被调用线程结束，才能执行下一个程序。

4.通信

引用multiprocessing模块中的q队列进行通信

3.多进程※

1.创建过程

1.导入包  少量进程，大量进程用进程池

import multiprocessing

2、通过进程类创建进程对象

进程对象 = multiprocessing.Process(target=*)  此处target的值可以是函数名称

3、启动进程执行任务

进程对象.start()

import multiprocessing
import time
def drink():
    for i in range(3):
        print("喝汤……")
        time.sleep(1)
def eat():
    for i in range(3):
        print("吃饭……")
        time.sleep(1)
if __name__ == '__main__':
    # target:指定函数名
    drink_process = multiprocessing.Process(target=drink)
    eat_process = multiprocessing.Process(target=eat)

    drink_process.start()
    eat_process.start()

2.进程池※

from multiprocessing import Pool

import time
from multiprocessing import Pool
def tes1(max):
    print(max)
    time.sleep(3)
if __name__ =='__main__':                       
    pool = Pool(processes=10)                   //创建进程池，同时间执行个数
    for i in range(100):                        //创建任务
        pool.apply_async(tes1,args=(i,))
    print('完成')
    pool.close()
    pool.join()