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

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。

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'