pyspark 对RDD的相关api

1、aggregate，可以用来求平均值

如下示例

rdd2 = spark.sparkContext.parallelize([1,2,3,4,5,6,7,8,9,10])

seqop = (lambda x,y: (x[0]+ y, x[1]+ 1))        #0+1 0+1 1+2 1+1 3+3 2+1
cpmop= (lambda  x,y: (x[0]+ y[0], x[1]+ y[1]))   #用于分布式计算时的聚合

res = rdd2.aggregate((0,0), seqop, cpmop)       #这样可以求平均数
return float(res[0]) / res[1]

2、coalesce   聚合分区，glom视为可以方便看出有几个分区

3、cogroup   取出一个key在自身存在，在另外一个也存在，则返回同一个key对应的所有的values，以touple的形式返回

4、collectAsMap    将元组形式的rdd返回为一个  字典形式，如果参数不是2个，这个方法则不适用，会报错

报错如下，需要长度为2的参数

5、combineByKey     对同一个rdd相同的key的value进行合并为一个list，并返回为一个新的RDD

理解：append针对key  因为append加入的是一个obj  相同的key只会存在一个

          extend针对value  因为相同的key的value会进行重复添加，到我们的列表里，不会因为存在而不追加

6、countByKey     和reduceByKey的用法一样，但是countbykey是action算子，reducebykey是tranformation,不会立即执行，通常用reducebykey这个操作，  等价于  data.reduceByKey(_+_).collectAsMap()

7、countbyvalue       如下返回每个value在  序列中出现的次数

8、distinct    去重，这个用过sql应该就知道的

9、filter     过滤，返回表达式为true的值

10、flatMap   这个记住，这是一个1对多的算子，rdd的一个参数进来，根据表达式，会有多个返回值，相当于展开，如下

每个参数都会有不同的返回值，可以看最后一个flatmap的形式 等价于map(lambda x: (x, x)).collect()

11、fold    如下    rdd为[1,2,3,4,5]   给定一个初始值，按照cmp方式，对元素进行折叠，这里为add

12、foldbykey     对相同的key的values进行相应的fold计算，   如下操作

13、foreach(f)     对rdd每个元素进行相应的函数操作

14、foreachpartition    对rdd每个分区的每个元素进行操作

15、fullOuterJoin        返回两个RDD 相同的key,和对应的value组成的touple(key,(value1,value2)),没有则返回None

16、getCheckpointFile(filepath)        得到checkpoint下来的数据，并返回rdd

17、getNumPartitions()     getStorageLevel()     得到一个rdd的分区，和缓存的级别

18、groupby     对一个RDD的每一个value,做一个函数操作，根据对应的返回值，对其进行分组，并返回新的RDD

19、groupByKey      对touple形式的rdd按key值进行聚合  返回为（key,[value1,value2]）,然后对value的list求长度，就可以做到和wordcount一样的效果、但是如果是做聚合操作尽量用reducebykey和aggregatebykey

mapvalues(f)      对每个touple形式的元素的value进行f(value) => (key，f(value))

20、intersection(other)       两个rdd取交集，同样适用于dataframe,取表中完全相同的行

21、isEmpty()    判断RDD是否为空，常用于  第一次unionall的时候对dataframe进行判断，选择相应的操作

22、leftOuterJoin(other),rightOuterJoin(other),   跟fullOuterJoin一样，这里left以左表为驱动表没有join上则换回none,right一样

23、lookup(key)        根据对应的key 返回对应的value，   如下所示，如果是有序的key,找起来会更快

24、map(f)       map返回的是一对一的关系，一个元素返回f(x)     常用于转换我们的数据格式

25、mapPartitions(f)      对每个分区的元素惊醒 f(values)操作      yield用法  参考http://python.jobbole.com/87613/

26、mapValues(f)      对value进行f(value) =>   (key,f(value))的形式

27、reduce(f)   对元素做相应的折叠操作   2 for _ in range(10)   这里就相当于取10次2

28、reduceByKey(f)         对同一个key的values   进行f(value)操作    (key,values) => (key,f(value1,value2))  => 下一次迭代

29、repartition(num)      对rdd的重新分区,分为num个分区

30、repartitionAndSortWithinPartitions(num,function)   对一个RDD进行重分区num 分区内部有排序，分区规则为function的返回结果为分区个数，如果分区个数大于，function的返回结果个数，则会存在空的元素  => []

31、sortedBy(index)        对RDD内部进行升序排序 ，按照我们给定的规则

32、sortByKey(ascending=True, numPartitions=None, keyfunc=<function RDD),第一个参数默认为true，num为分区个数，keyfunc按照对key处理后的结果进行排序，如下图 为对key全部小写后再进行排序

33、subtract(other, numPartitions=None)， 按照元素的全部内容进行去重，保留自身存在  other不存在的元素，同样适用于dataframe的相关行的去重

34、subtractByKey(other, numPartitions=None)，  按照key值取反集

35、union(rdd)    只适用于同一种数据格式的rdd,不然后面的rdd转换操作，不好进行，找不到合适的方法，对RDD进行有效的处理

36、values    返回touple的values

37、zip     拉链操作，  对两个rdd进行压缩，但是元素个数要一致，和list的压缩一致

38、zipWithIndex     根据value => (value,index)

39、读取json字符串的dataframe

      df = spark.createDataFrame([['{"a":"b"}']],['c'])

     res = spark.read.json(df.rdd.map(lambda row: row.c))            

     res -> schema a:string

 

40，foreachPartition之写入数据库

 

# encoding=utf-8
import sys, os
from pyspark import SparkConf
from pyspark.sql import SparkSession
from pyspark.sql.functions import *
from pyspark.sql.types import *
import time, copy, re, math
from datetime import datetime, timedelta
import json
import logging, pymysql
from collections import OrderedDict
from elasticsearch import Elasticsearch
from elasticsearch.helpers import bulk

logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s: %(message)s')
logger = logging.getLogger(__name__)


warehouse_location = '/user/hive/warehouse/'
conf = SparkConf().set('spark.driver.maxResultSize', '10g')
conf.set('spark.executor.memoryOverhead', '30g')
conf.set('spark.yarn.am.cores', 5)
conf.set('spark.executor.memory', '50g')
conf.set('spark.executor.instances', 80)
conf.set("spark.sql.shuffle.partitions",2000)
conf.set('spark.executor.cores', 8)
conf.set('spark.executor.extraJavaOptions', '-XX:+PrintGCDetails -XX:+PrintGCTimeStamps -XX:+UseG1GC')
conf.set("spark.sql.warehouse.dir", warehouse_location)
conf.set("spark.sql.crossJoin.enabled", "true")
conf.set("spark.security.credentials.renewalRaio", "0.000000000007")

spark = SparkSession \
    .builder \
    .config(conf=conf) \
    .enableHiveSupport() \
    .getOrCreate()
from sparkDemo.common import *
commonUtil = CommonUdf(spark)

def forecah_insert(rows):
    edges = []
    for row in rows:
        edges.append((row.user_id,row.target_num,row.start_time,row.end_time))
        if len(edges) == 10000:
            insert_data(edges)
            edges *= 0
    insert_data(edges)
    
    
def forecah_bulk(rows):
    edges = []
    es = Elasticsearch(['12.68.1.31','12.68.1.32','12.68.1.33'],port=9200)
    for row in rows:
        edges.append((row.user_id,row.target_num,row.start_time,row.end_time))
        if len(edges) == 10000:
            bulk_data('makenodes','search_edge',es,edges)
            edges *= 0
    bulk_data('makenodes','search_edge',es,edges)
        

def insert_data(edges):
    conn = pymysql.connect(host='12.68.2.21', port=3306, user='root', passwd='BBDerscom!@#', db='mysql', charset='utf8')
    cursor = conn.cursor()
    sql = ''' insert into pangu.edge_test (user_id, target_num, start_time, end_time) values (%s, %s, %s, %s) '''
    cursor.executemany(sql,edges)
    conn.commit()
    print('insert success')
    conn.close()
    
    
def bulk_data(index,doc_type,es,edges):
    ACTIONS = []
    for line in edges:
        action = {
            '_index': index,
            '_type': doc_type,
            '_source':{
                'user_id':line[0],
                'target_num':line[1],
                'start_time':line[2],
                'end_time':line[3]
                }
        }
        ACTIONS.append(action)
    success, _ = bulk(es,ACTIONS,index=index,raise_on_error=True)
    logger.info('bulkload success %d data'%success)
    
def do_filter():
    # df = spark.read.orc('/user/bbd/dev/extension_relation/edge_person_search_target').limit(500000)
    df = spark.createDataFrame([(1, 2, 2, 1), (2, 3, 4, 5)], schema=['user_id', 'target_num', 'start_time', 'end_time'])
    #df.foreachPartition(forecah_insert)
    df.foreachPartition(forecah_bulk)


if __name__ == '__main__':
    do_filter()



# spark-submit --py-files /home/bbd/workspace/online/common.py --master yarn \
#     --deploy-mode  cluster \
#     --archives hdfs://hacluster/user/bbd/dev/qindong/extension_relation/mini.zip#mini \
#     --conf "spark.executorEnv.PYSPARK_PYTHON=mini/mini/bin/python" \
#     --conf "spark.executorEnv.PYSPARK_DRIVER=mini/mini/bin/python" \
#     --conf "spark.yarn.appMasterEnv.PYSPARK_PYTHON=mini/mini/bin/python" \
#     --conf "spark.yarn.appMasterEnv.PYSPARK_DRIVER=mini/mini/bin/python" \
#     --name partition_test \
#     --driver-memory 40g \
#     --queue bbd_01 my_partition_test.py
#