【七月Python入门】第七课并发编程以及系统常用模块

ゞ浴缸里的玫瑰 2022-06-03 09:28 180阅读 0赞

1.GIL全称为全局解释器锁(global interpreter lock)，GIL是实现python解析器时引入的一个概念。GIL也是一把全局排他锁，同一时刻只有一个线程在运行。

2.Multiprocessing库弥补thread库因为GIL而低效的缺陷，它是使用多进程而不是多线程，每个进程有自己独立的GIL，因此也不会出现线程之间的GIL争夺。

3.Queue是多进程安全的队列，可以使用它来实现多进程之间的数据传递。

4.Thread中，join（）方法的作用是调用线程等待该线程完成后，才能继续用下运行。

public static void main(String[] args) throws InterruptedException
        {
            System.out.println("main start");
    
            Thread t1 = new Thread(new Worker("thread-1"));
            t1.start();
            t1.join();
            System.out.println("main end");
        }

在上面的例子中，main线程要等到t1线程运行结束后，才会输出“main end”。如果不加t1.join(),main线程和t1线程是并行的。而加上t1.join(),程序就变成是顺序执行了。

5.多进程与多线程的对比

from multiprocessing import Process
    import threading
    import time
    lock = threading.Lock()
     
    def run(info_list,n):
        lock.acquire()
        info_list.append(n)
        lock.release()
        print('%s\n' % info_list)
        
    if __name__=='__main__':
        info = []
        for i in range(10):
            #target为子进程执行的函数，args为需要给函数传递的参数 
            p = Process(target=run,args=[info,i])
            p.start()
            p.join()
        time.sleep(1) #这里是为了输出整齐让主进程的执行等一下子进程
        print('------------threading--------------')
        for i in range(10):
            p = threading.Thread(target=run,args=[info,i])
            p.start()
            p.join()

6.函数式编程

（1）lambda:快速定义单行的最小函数，inline的匿名函数。

g = lambda x: x * 2
    print g(3)
    print (lambda x: x * 2)(4)

（2） map(function, sequence) ：对sequence中的item依次执行function(item)，执行结果组成一个List返回。

def toUpper(item):
          return item.upper()
     
    upper_name = map(toUpper, ["qi", "yue", "July"])
    print upper_name

（3） filter(function, sequence)：对sequence中的item依次执行function(item)，将执行结果为True的item组成一个List/String/Tuple（取决于sequence的类型）返回。

number_list = range(-5, 5)
    less_than_zero = list(filter(lambda x: x < 0, number_list))
    print(less_than_zero)

（4） reduce(function, sequence, starting\_value)：对sequence中的item顺序迭代调用function，如果有starting\_value，还可以作为初始值调用。

def add(x,y): return x + y
    print reduce(add, range(1, 5))
    print reduce(add, range(1, 5), 10)

一个example，计算数组中的平均数，综合利用以上函数。

# 正常写法：
    num =[2, -5, 9, 7, -2, 5, 3, 1, 0, -3, 8]
    positive_num_cnt = 0
    positive_num_sum = 0
    for i in range(len(num)):
        if num[i] > 0:
            positive_num_cnt += 1
            positive_num_sum += num[i]
     
    if positive_num_cnt > 0:
        average = positive_num_sum / positive_num_cnt
     
    print average
    # 输出 5

# 函数式写法：
    num =[2, -5, 9, 7, -2, 5, 3, 1, 0, -3, 8]
    positive_num = filter(lambda x: x>0, num)
    average = reduce(lambda x,y: x+y, positive_num) / len( positive_num )
    print average

7.mapreducer：

一个形象的例子：给在座的所有玩家中分配这摞牌；让每个玩家数自己手中的牌有几张是黑桃，然后把这个数目汇报给你；你把所有玩家告诉你的数字加起来，得到最后的结论

### MapReduce合并了两种经典函数： ###

### （1）映射（Mapping）对集合里的每个目标应用同一个操作。即，如果你想把表单里每个单元格乘以二，那么把这个函数单独地应用在每个单元格上的操作就属于mapping。 ###

### （2）化简（Reducing ）遍历集合中的元素来返回一个综合的结果。即，输出表单里一列数字的和这个任务属于reducing。 ###

![Center][]

8.spark：spark是基于map reduce 算法实现的分布式计算框架。spark的中间输出和结果输出可以保存在内存中，从而不再需要读写HDFS。

spark实现wordcount：

import sys
    from operator import add
    from pyspark import SparkContext
    sc = SparkContext()
    In [19]:
    lines = sc.textFile("stormofswords.csv")
    counts = lines.flatMap(lambda x: x.split(',')) \
                  .map(lambda x: (x, 1)) \
                  .reduceByKey(add)
    output = counts.collect()
    output = filter(lambda x:not x[0].isnumeric(), sorted(output, key=lambda x:x[1], reverse = True))
    for (word, count) in output[:10]:
        print "%s: %i" % (word, count)
    
    sc.stop()

9.正则表达式：对于做文本搜索，爬虫等非常有用。 两种模式匹配：搜索search()和匹配match()。

import re
    m = re.match(r'dog', 'dog cat dog')
    print m.group()
    print re.match(r'cat', 'dog cat dog')
    s = re.search(r'cat', 'dog cat dog')
    print s.group()
    print re.findall(r'dog', 'dog cat dog')

判断一个字符串是否是合法的email地址

# email example
    str = 'purple alice-b@google.com monkey dishwasher'
    match = re.search(r'\w+@\w+', str)
    if match:
        print match.group()  ## 'b@google',因为\w不能匹配到地址中的'-'和'.'
    b@google
    
    match = re.search(r'[\w.-]+@[\w.-]+', str)
    if match:
        print match.group()  ## 'alice-b@google.com'

[Center]: /images/20220603/8d5258e56fef4f28864885f984f6b035.png