day19. 一. 进程

一. 进程

进程的概念

python中的多线程其实并不是真正的多线程，如果想要充分地使用多核CPU的资源，在python中大部分情况需要使用多进程。

进程的概念：
	 进程是程序的一次执行过程, 正在进行的一个过程或者说一个任务，而负责执行任务的则是CPU.
	
进程的生命周期：
	当操作系统要完成某个任务时，它会创建一个进程。当进程完成任务之后，系统就会撤销这个进程，收回它所占用的资源。从创建到撤销的时间段就是进程的生命期

进程之间存在并发性：
	在一个系统中，同时会存在多个进程。他们轮流占用CPU和各种资源

并行与并发的区别：
	无论是并行还是并发,在用户看来都是同时运行的，不管是进程还是线程，都只是一个任务而已， 
真正干活的是CPU，CPU来做这些任务，而一个cpu（单核）同一时刻只能执行一个任务。 
并行：多个任务同时运行，只有具备多个cpu才能实现并行，含有几个cpu，也就意味着在同一时刻可以执行几个任务。 
并发：是伪并行，即看起来是同时运行的，实际上是单个CPU在多道程序之间来回的进行切换。

同步与异步的概念：
	同步就是指一个进程在执行某个请求的时候，若该请求需要一段时间才能返回信息，那么这个进程将会一直等待下去，直到收到返回信息才继续执行下去。 
	异步是指进程不需要一直等下去，而是继续执行下面的操作，不管其他进程的状态。当有消息返回时系统会通知进行处理，这样可以提高执行的效率。 
	比如：打电话的过程就是同步通信，发短信时就是异步通信。

多线程和多进程的关系：
	对于计算密集型应用，应该使用多进程;
	对于IO密集型应用，应该使用多线程。线程的创建比进程的创建开销小的多。

创建进程

使用multiprocessing.Process

import multiprocessing
import time

def func(arg):
    pname = multiprocessing.current_process().name
    pid = multiprocessing.current_process().pid
    print("当前进程ID=%d,name=%s" % (pid, pname))

    for i in range(5):
        print(arg)
        time.sleep(1)

if __name__ == "__main__":
    p = multiprocessing.Process(target=func, args=("hello",))
    # p.daemon = True  # 设为【守护进程】（随主进程的结束而结束）
    p.start()

    while True:
        print("子进程是否活着？", p.is_alive())
        time.sleep(1)
    print("main over")

通过继承Process实现自定义进程

import multiprocessing
import os

# 通过继承Process实现自定义进程
class MyProcess(multiprocessing.Process):
    def __init__(self, name, url):
        super().__init__()
        self.name = name
        self.url = url  # 自定义属性

    # 重写run
    def run(self):
        pid = os.getpid()
        ppid = os.getppid()
        pname = multiprocessing.current_process().name
        print("当前进程name：", pname)
        print("当前进程id：", pid)
        print("当前进程的父进程id：", ppid)

if __name__ == '__main__':

    # 创建3个进程
    MyProcess("小分队1", "").start()
    MyProcess("小分队2", "").start()
    MyProcess("小分队3", "").start()
    print("主进程ID：", multiprocessing.current_process().pid)

    # CPU核数
    coreCount = multiprocessing.cpu_count()
    print("我的CPU是%d核的" % coreCount)

    # 获取当前活动的进程列表
    print(multiprocessing.active_children())

同步异步和进程锁

import multiprocessing
import random
import time

def fn():
    name = multiprocessing.current_process().name
    print("开始执行进程：", name)
    time.sleep(random.randint(1, 4))
    print("执行结束：", name)

# 多进程
# 异步执行进程
def processAsync():
    p1 = multiprocessing.Process(target=fn, name="小分队1")
    p2 = multiprocessing.Process(target=fn, name="小分队2")
    p1.start()
    p2.start()

# 同步执行
def processSync():
    p1 = multiprocessing.Process(target=fn, name="小分队1")
    p2 = multiprocessing.Process(target=fn, name="小分队2")
    p1.start()
    p1.join()
    p2.start()
    p2.join()

# 加锁
def processLock():
    # 进程锁
    lock = multiprocessing.Lock()
    p1 = multiprocessing.Process(target=fn2, name="小分队1", args=(lock,))
    p2 = multiprocessing.Process(target=fn2, name="小分队2", args=(lock,))
    p1.start()
    p2.start()

def fn2(lock):
    name = multiprocessing.current_process().name
    print("开始执行进程：", name)

    # 加锁
    # 方式一
    # if lock.acquire():
    #     print("正在工作...")
    #     time.sleep(random.randint(1, 4))
    #     lock.release()

    # 方式二
    with lock:
        print("%s:正在工作..." % name)
        time.sleep(random.randint(1, 4))

    print("%s:执行结束："% name)


if __name__ == '__main__':
    # processAsync() # 异步执行
    # processSync()  # 同步执行
    processLock()  # 加进程锁

使用Semaphore控制进程的最大并发

import multiprocessing
import time

def fn(sem):
    with sem:
        name = multiprocessing.current_process().name
        print("子线程开始：", name)
        time.sleep(3)
        print("子线程结束：", name)

if __name__ == '__main__':
    sem = multiprocessing.Semaphore(3)
    for i in range(8):
        multiprocessing.Process(target=fn, name="小分队%d"%i, args=(sem, )).start()

二. 高阶函数

1.map()

代码演示：

"""
map(function,iterable)
function:函数
iterable：可迭代对象
作用：将传入的函数依次作用于可迭代对象中的每一个元素，并把结果【Iterator】返回
"""
#需求1：给一个已知列表中的元素求平方
def square(x):
 return x ** 2
list1 = [1,2,3,4,5]
result1 = map(square,list1)
#注意:map是一个类，表示一种数据类型，集合或者序列，使用类似于list，tuple，set
print(result1)   #<map object at 0x000001EE25431DA0>
print(type(result1))   #<class 'map'>
print(list(result1))  #[1, 4, 9, 16, 25]

result2 = map(lambda x:x ** 2,list1)
print(list(result2))

#str = 10

#需求2：将整型元素的列表转换为字符串元素的列表
#举例：[1,2,3,4]------>["1","2","3","4"]
#str(1) ---- >字符串1
#注意：在使用系统函数之前，最好不要出现同名的变量
result3 = map(str,[1,2,3,4])
print(list(result3))


#需求3：已知两个整型列表，将两个列表中相同位置的元素相加，得到一个新的列表
def add(x,y):
 return  x  + y
l1 = [1,2,3,4,5]
l2 = [6,7,8,9,10]

result4 = map(add,l1,l2)
print(list(result4))

2.reduce()

代码演示：

from  functools  import  reduce

"""
reduce(function,Iterable)  :通过函数对参数列表中的元素进行累积
function:函数
Iterable：可迭代对象，一般使用列表
工作原理：用传给reduce的function先作用于list中第一个和第二个元素，用得到的结果和list中第三个元素计算。。。
reduce(add,[a,b,c,d])
add(add(add(a,b),c),d)---->递归
"""

#需求1;求一个已知列表中元素的和
list1 = [1,2,3,4,5]
def add(x,y):
 return x + y
result1 = reduce(add,list1)
print(result1)

result2 = reduce(lambda x,y:x + y,list1)
print(result2)

#需求2：将列表[1,3,5,7,9]变换成整数13579
"""
分析：
13 = 1 * 10 + 3
135 = 13 * 10 + 5
1357 = 135 * 10 + 7
13579 = 1357 * 10 + 9
"""
list2 = [1,3,5,7,9]
def fn(x,y):
 return x * 10 + y

result3 = reduce(fn,list2)
print(result3)

#需求3：
#结合map函数，实现一个将str转换为int的函数   int()

#思路：传进来一个字符串，返回一个对应的整数
def strToInt(s):
 digits = {"0":0,"1":1,"2":2,"3":3,"4":4}
 return digits[s]

#"23401"------>23401
r0 = map(strToInt,"23401")
print(list(r0))   #[2, 3, 4, 0, 1]

r1 = reduce(fn,map(strToInt,"23401"))
print(r1)   #23401
print(type(r1))   #<class 'int'>

3.filter()

代码演示：

"""
filter(function,序列)
作用：通过指定的条件过滤列表中的元素
工作原理：将传入的函数依次作用于列表中的每一个元素，根据返回的是True还是False决定元素是否需要保留
"""

#需求1：将列表中的偶数筛选出来
list1 = [1,2,3,4,5,6,7,8,9]
#作用：定义筛选的规则
def func(num):
 if num % 2 == 0:
     return  True
 return  False

result1  = filter(func,list1)
print(result1)
print(list(result1))  #[2, 4, 6, 8]

4.sorted()

代码演示：

#1.普通排序
#默认为升序排序，得到了的一个新的列表
list1 = [4,5,23,3,5,7]
result1 = sorted(list1)
print(list1)
print(result1)  #r[3, 4, 5, 5, 7, 23]

#2.按照绝对值进行排序
#默认为升序排序，排序的依据是所有元素的绝对值的大小
list2 = [4,5,-23,3,-5,7]
result2 = sorted(list2,key=abs)
print(result2)  #[3, 4, 5, -5, 7, -23]

#3.降序升序
list3 = [4,5,23,3,5,7]
result3 = sorted(list3,reverse=True)
print(result3)

#4.字符也可以实现排序
list4 = ["f","a","k","z"]
result4 = sorted(list4)
print(result4)

#5.自定义排序规则
#默认为升序排序
def myFunc(str):
 return len(str)
list5 = ["gsg","a","34535","efgg","562875678257fhjawhgj"]
result5 = sorted(list5,key=myFunc)
print(result5)