python分布式计算--概述

最新推荐文章于 2024-08-19 10:51:43 发布
SunChao3555
最新推荐文章于 2024-08-19 10:51:43 发布
阅读量5.7k
点赞数
分类专栏： Python 文章标签： python进程 mrjob
本文链接：https://blog.csdn.net/SunChao3555/article/details/81387521
版权
Python 专栏收录该内容
41 篇文章 1 订阅
订阅专栏
#coding:utf-8
import scrapy
import xlwt, lxml
import re, json,time,math
import matplotlib.pyplot as plt
import numpy as np
import pylab
from scipy import linalg

'''python 分布式计算

    Python 多进程与多线程
    python 使用Hadoop分布式计算库mrjob
    python 使用Spark分布式计算库PySpark
    E.G.分别使用MapReduce和Spark实现wordcount
    
  全局解释器锁GIL（Globl Interpreter Lock，其并不是python的特性，它是在实现python解析器（Cpython）时所引入的一个概念）
  GIL是一把全局排他锁，同一时刻只有一个线程在运行。
    毫无疑问GIL的存在会对多线程的效率有不小影响。甚至就几乎等于python是个单线程的程序
    multiprocessing库的出现很大程度是为了弥补thread库因GIL而低效的缺陷。它完整的复制了一套thread所提供的接口方便迁移。唯一的不同就是它使用了多进程而不是多线程。每个进程有自己独立的GIL，因此也不会出现进程之间的GIL争抢
    


'''

'''
#顺序执行单线程 与同时执行两个并发进程
from threading import Thread
import time

def my_counter():
    i=0
    for t in range(100000000):
        i+=1
    return 1
def mainseq():
    threadArray={}
    starttime=time.time()
    for tid in range(2):
        t1=Thread(target=my_counter)
        t1.start()
        t1.join()
    endtime=time.time()
    print('Totaltime:%s'%(endtime-starttime))
def main2():
    threadArray = {}
    starttime = time.time()
    for tid in range(2):
        t1 = Thread(target=my_counter)
        t1.start()
        threadArray[tid]=t1
    for i in range(2):
        threadArray[i].join()
    endtime=time.time()
    print('Totaltime:%s' % (endtime - starttime))

if __name__ == '__main__':
    mainseq()
    main2()
'''

'''Python多进程
fork操作：调用一次，返回两次。因为操作系统自动把当前进程（父进程）复制了一份（子进程），然后分别在父进程和子进程内返回。子进程永远返回0，而父进程返回子进程的ID。子进程只需要调用getppid()就可以拿到父进程的ID【由于Windows没有fork调用，下面代码无法在windows上运行】 linux   

'''
# import os
# print(os.getppid())
# pid=os.fork()
# if pid==0:
#     print('child%s,parent:%s'%(os.getpid(),os.getppid()))
# else:
#     print('child:%s,%s'%(os.getpid(),pid))

'''
from multiprocessing import Process

def f(n):
    time.sleep(1)
    print(n*n)


if __name__ == '__main__':
    for i in range(10):
        p = Process(target=f, args=[i, ])
        p.start()


'''

'''
#进程间通信Queue
#多进程安全的队列，可以使用Queue实现多进程之间的数据传递


from multiprocessing import Process,Queue

def write(q):
    for i in 'ABCDE':
        print('Put %s to queue'%i)
        q.put(i)
        time.sleep(0.5)
def read(q):
    while True:
        v=q.get(True)
        print('Get %s from queue'%v)
if __name__ == '__main__':
    q=Queue()
    pw=Process(target=write,args=(q,))
    pr=Process(target=read,args=(q,))
    pw.start()
    pr.start()
    pr.join()#等待
    pr.terminate()
'''

'''
#进程池Pool
# 用于批量创建子进程，可以灵活控制子进程

from multiprocessing import Pool
def f(x):
    print(x*x)
    time.sleep(2)
    return x*x
if __name__ == '__main__':
    pool=Pool(processes=5)#定义启动的进程数量
    res_list=[]
    for i in range(10):

        #以异步并行的方式启动进程，如果要同步等待的方式，可以在每次启动进城之后调用res.get()方法，也可以使用pool.apply()
        res=pool.apply_async(f,[i,])
        print('-------------',i)
        res_list.append(res)
    pool.close()
    pool.join()
    for r in res_list:
        print('result',(r.get(timeout=5)))
'''


'''
#多线程与多进程对比
#一般情况下，进程内存资源是相互独立的，而多线程可以共享同一个进程中的内存资源
from multiprocessing import Process
import threading

lock=threading.Lock()

def run(list,n):
    lock.acquire()
    list.append(n)
    lock.release()
    print('%s\n'%list)
if __name__ == '__main__':
    info=[]
    for i in range(10):
        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()
        
'''

'''
#函数式编程
    # 特性：
    # immutable data不可变数据
    # first class functions 函数像变量一样使用
    # 尾递归优化：每次递归都重用stack【python使用一个栈】
    # 优点：
    # parallelization并行
    # lazy evaluation惰性求值
    # determinism确定性
函数式编程技术：
    map &reduce
    pipeline
    recursing递归
    currying一个函数作为另一函数的参数
    def inc(x):
        def incx(y):
            return x+y
        return incx
    inc2=inc(2)#未给y传值，无输出结果
    print(inc2(5))输出7
    
    higer order function高阶函数
    
'''

'''
#python中的lambda和map、filter、reduce
# map(function,sequence):对sequence中的item依次执行function(item)，执行结果组成一个list返回
def toUpper(e):
    return e.upper()

alpha=map(toUpper,'haha')
# print(alpha.__next__())
print(list(alpha))

# filter(function,sequence):对sequence中的item依次执行function，将执行结果为True的item组成一个list/string/tuple(取决于可迭代对象的类型)返回
numbers=range(-5,5)
lessThanZero=list(filter(lambda x:x<0,numbers))
print(lessThanZero)

#reduce(function,sequence,starting_value):
#对sequence中的item顺序迭代调用function，如果有starting_value，还可以作为初始值调用

#python3中取消了全局命名空间的reduce()函数，需要从functools模块中调用
from functools import reduce
def add(x,y):
    return x+y
print(reduce(add,range(1,5)))
print(reduce(lambda x,y:x+y,range(1,5)))
print(reduce(add,range(1,5),10))
'''


'''
#Hadoop
# Hadoop是Apache开源组织的一个分布式计算开源框架
    #核心的设计就是：MapReduce和HDFS(Hadoop Distributed File System)
    #Zookeeper
    #  部署方式 Stand\YANR\MESOS
    
#MapReduce
    思想：任务的分解与结果的汇总
    流程：input->splitting->mapping->shuffling->reducing->final result
    
#基于Linux管道的MapReduce

Hadoop有Java和Streaming两种方式来编写MapReduce任务。
    java的优点是计算效率高，并且部署方便，直接打包成一个jar文件即可
    Hadoop Streaming 是Hadoop提供的一个编程工具，它允许用户使用任何可执行文件或脚本文件作为Mapper和Reducer
    [Linux管道]Streaming单机测试：cat input|mapper|sort|reducer->output
    
mrjob实质上就是在Hadoop Streaming的命令行上包了一层，有了统一的python界面。
'''


from mrjob.job import MRJob
'''

class MRWordFrequencyCount(MRJob):
    def mapper(self, key, line):
        # yield 'chars',len(line)
        yield 'words',len(line.split())
        # yield 'lines',1
    # def reducer(self, key, values):
    #     yield key,sum(values)
    def reducer(self, word, values):
        yield word,sum(values)
if __name__ == '__main__':
    MRWordFrequencyCount.run()

可在命令行运行：
首先cd C:\Users\SunChao\Desktop\untitled
然后执行 (python35) C:\Users\SunChao\Desktop\untitled>python 9_distributed_computation.py xx.txt
'''

'''
#多步任务

from mrjob.step import MRStep

#统计频率最高的词汇
word_pattern=re.compile(r'[\w]+')
class MRMostUseWord(MRJob):
    def steps(self):
        return [
            MRStep(mapper=self.mapper_get_words,
                   reducer=self.reducer_count_words,
                   combiner=self.combiner_count_words,
                   ),
            MRStep(reducer=self.reducer_find_max_word)
        ]
    def mapper_get_words(self,key,line):
        for word in word_pattern.findall(line):
            yield (word.lower(),1)
    def combiner_count_words(self,word,counts):
        yield (word,sum(counts))
    def reducer_count_words(self, word, counts):
        yield None,(sum(counts),word)
    def reducer_find_max_word(self,_,word_count_pairs):
        yield max(word_count_pairs)
if __name__ == '__main__':
    MRMostUseWord.run()

'''

'''
Spark 是基于map reduce算法实现的分布式计算框架：
    Spark的中间输出和结果输出可以保存在内存中，从而不再需要读写HDFS
    Spark能够更好的用于数据挖掘与机器学习等需要迭代的map reduce的算法中
    
Spark与Hadoop结合
    spark 可以直接对HDFS进行数据读写，同样支持spark on YARN。Spark可以与MapReduce运行于同集群中，共享存储资源与计算
    本地模式、Standalone模式、Mesoes模式、yarn模式
    
RDD
    弹性分布式数据集Resilient Distributed Datasets
        集群节点上不可变，已区分对象
        可序列化
        可以控制存储级别（内存、磁盘等）来进行重用
    计算特性：
        血统lineage
        惰性计算lazy evaluation
    生成方式：
        文件读取
        来自父RDD
'''
#PySpark实现WordCount
部分说明图示
1.Hadoop