python高级3

Python中的多线程

1.创建线程

print("*********主线程开始*********")
import threading
import time
def f1():
    print("**********f1开始*********")
    time.sleep(2)
    print("**********f1结束*********")
def f2():
    print("**********f2开始*********")
    time.sleep(3)
    print("**********f2结束*********")
# 创建线程
# target 指定这个线程执行那个函数中的代码,只写函数名即可，不要写括号
th1 = threading.Thread(target=f1)
th2 = threading.Thread(target=f2)
# 启动线程
th1.start()
th2.start()
print("*********主线程结束*********")

2.入口函数带参数

print("*********主线程开始*********")
from threading import Thread
import time
def f1(s):
    print("**********f1开始*********")
    time.sleep(s)
    print("**********f1结束*********")
def f2(s):
    print("**********f2开始*********")
    time.sleep(s)
    print("**********f2结束*********")
# 创建线程
# target 指定这个线程执行那个函数中的代码,只写函数名即可，不要写括号
# args 后面指定的是一个元组，
th1 = Thread(target=f1, args=(2,))
th2 = Thread(target=f2, args=(3,))
# 启动线程
th1.start()
th2.start()
print("*********主线程结束*********")

3.设置等待

# 设置主线程等待子线程执行结束之后在执行
print("*********主线程开始*********")
from threading import Thread
import time
def f1(s):
    print("**********f1开始*********")
    time.sleep(s)
    print("**********f1结束*********")
def f2(s):
    print("**********f2开始*********")
    time.sleep(s)
    print("**********f2结束*********")
# 创建线程
# target 指定这个线程执行那个函数中的代码,只写函数名即可，不要写括号
# args 后面指定的是一个元组，
th1 = Thread(target=f1, args=(2,))
th2 = Thread(target=f2, args=(3,))
# 启动线程
th1.start()
th2.start()
# 设置等待
th1.join()
th2.join()
print("*********主线程结束*********")

4.共享对象

from threading import Thread
from time import sleep
# 存储支付宝账号余额
zhifubao = {
    'zhangsan': 10000,
    'liming': 5000,
    'wanghong': 3000,
    'zhaolei': 5000
}
# 申请一把锁
# 线程1 ： 滴滴打车处理，参数是用户账户和扣款金额
def thread1_didi_pay(account,amount):
    print('* t1: 即将开始操作')
    balance = zhifubao[account]
    # 下面的sleep(2) 表示一些处理过程需要花上2秒钟
    print('* t1: 完成交易需要2s中')
    sleep(2)
    print('* t1: deduct')
    zhifubao[account] = balance - amount
# 线程2 ： 余额宝可以赚取利息，参数是用户账户和扣款金额
def thread2_yue_pay(account,amount):
    print('* t2: 即将开始操作')
    balance = zhifubao[account]
    # 下面的sleep(2) 表示一些处理过程需要花上2秒钟
    print('* t2: 完成交易需要2s中')
    sleep(2)
    print('* t2: deduct')
    zhifubao[account] = balance + amount
# 分别创建两个线程
t1 = Thread(target=thread1_didi_pay, args=('zhangsan', 2000))
t2 = Thread(target=thread2_yue_pay, args=('zhangsan', 2000))
# 启动线程
t1.start()
t2.start()
# 设置等待
t1.join()
t2.join()
# 输出账户余额
print("_________________________")
print(zhifubao["zhangsan"])

锁机制

from threading import Thread, Lock
from time import sleep
# 存储支付宝账号余额
zhifubao = {
    'zhangsan': 10000,
    'liming': 5000,
    'wanghong': 3000,
    'zhaolei': 5000
}
# 申请一把锁
zhifu_lock = Lock()
# 线程1 ： 滴滴打车处理，参数是用户账户和扣款金额
def thread1_didi_pay(account,amount):
    print('* t1: 即将开始操作')
    # 上锁
    zhifu_lock.acquire()
    balance = zhifubao[account]
    # 下面的sleep(2) 表示一些处理过程需要花上2秒钟
    print('* t1: 完成交易需要2s中')
    sleep(2)
    print('* t1: deduct')
    zhifubao[account] = balance - amount
    # 释放锁
    zhifu_lock.release()
# 线程2 ： 余额宝可以赚取利息，参数是用户账户和扣款金额
def thread2_yue_pay(account,amount):
    print('* t2: 即将开始操作')
    # 上锁
    zhifu_lock.acquire()
    balance = zhifubao[account]
    # 下面的sleep(2) 表示一些处理过程需要花上2秒钟
    print('* t2: 完成交易需要2s中')
    sleep(2)
    print('* t2: deduct')
    zhifubao[account] = balance + amount
    # 释放锁
    zhifu_lock.release()
# 分别创建两个线程
t1 = Thread(target=thread1_didi_pay, args=('zhangsan', 2000))
t2 = Thread(target=thread2_yue_pay, args=('zhangsan', 2000))
# 启动线程
t1.start()
t2.start()
# 设置等待
t1.join()
t2.join()
# 输出账户余额
print("_________________________")
print(zhifubao["zhangsan"])

5.生成器

通过列表生成式（列表推导式），我们可以创建一个列表，但是，受到内存限制，列表容量肯定是受限的。而且创建一个包含上百万个元素的列表，不仅占用很大的存储空间，如果我们只需要访问前面几个元素，那么后面绝大多数元素占用的空间都白白浪费了。所以，如果列表元素可以按照某种算法推荐出来，那我们是否可以在循环的过程中不断推算出后续的元素呢？这样就不必创建完整的list，从而节省大量的空间。在python中，这种一边循环一边计算的机制，成为生成器（generator）

# list1 = []
# for i in range(1, 11):
#     list1.append(i)
#
# print(list1)
# 列表推导式
list1 = [i for i in range(1, 101) if i > 5]
print(type(list1))
# 创建生成器
g = (i for i in range(1, 11) if i > 5)
# generator
print(type(g))
# 生成器是无法直接输出的 直接输出显示的是<generator object <genexpr> at 0x000002073C2F9548>
# print(g)
# 取值
print(g.__next__()) # 6
print(g.__next__()) # 7
print(g.__next__()) # 8
print(g.__next__()) # 9
print(g.__next__()) # 10
print(g.__next__())
# 如果报错显示StopIteration 则表示生成器无法在产生值

# 创建生成器
g = (i for i in range(1, 11) if i > 5)
# generator
print(type(g))
print(next(g)) # 6
print(next(g)) # 7
print(next(g)) # 8
print(next(g)) # 9
print(next(g)) # 10
print(next(g))

方式二：

def f1():
    n = 0
    while True:
        n += 1
        # yield是返回加停止的作用
        yield n
# <class 'generator'>
g = f1()
print(type(g))
print(g.__next__())
print(g.__next__())
print(g.__next__())
print(g.__next__())

6.迭代器

可以被next()函数调用并不断返回下一个值的对象称为迭代器：Iterator

生成器就是一个迭代器

from collections.abc import Iterable
# 判断列表
list1 = [12, 23, 45, "serf"]
# 列表、字典、元组、字符串、虽然是可迭代的对象，但不是迭代器，通过next取值会报错
# print(next(list1))
# 将可迭代的对象转换为迭代器
g = iter(list1)
print(next(g))
print(next(g))
print(next(g))
print(next(g))
# # 判断
# print(isinstance(list1, Iterable))
# 判断字符串
# a = "hello"
# print(isinstance(a, Iterable))
# 判断 整数
# i = 24234
# print(isinstance(i, Iterable))