SparkContext

SparkContext 是在 spark 库中定义的一个类,作为 spark 库的入口点;

它表示连接到 spark,在进行 spark 操作之前必须先创建一个 SparkContext 的实例,并且只能创建一个;

利用 SparkContext 实例创建的对象都是 RDD,这是相对于 SparkSession 说的,因为 它创建的对象都是 DataFrame;

创建 sc

class SparkContext(__builtin__.object):
def __init__(self, master=None, appName=None, sparkHome=None, pyFiles=None, environment=None, batchSize=0, serializer=PickleSerializer(), conf=None, gateway=None, jsc=None, profiler_cls=<cl
ass 'pyspark.profiler.BasicProfiler'>)
'''Create a new SparkContext. At least the master and app name should be set,
| either through the named parameters here or through C{conf}.
|
| :param master: Cluster URL to connect to
| (e.g. mesos://host:port, spark://host:port, local[4]). local 表示本地运行,4 表示使用4个 cpu核
| :param appName: A name for your job, to display on the cluster web UI.
| :param sparkHome: Location where Spark is installed on cluster nodes.
| :param pyFiles: Collection of .zip or .py files to send to the cluster
| and add to PYTHONPATH. These can be paths on the local file
| system or HDFS, HTTP, HTTPS, or FTP URLs.
| :param environment: A dictionary of environment variables to set on
| worker nodes.
| :param batchSize: The number of Python objects represented as a single
| Java object. Set 1 to disable batching, 0 to automatically choose
| the batch size based on object sizes, or -1 to use an unlimited
| batch size
| :param serializer: The serializer for RDDs.
| :param conf: A L{SparkConf} object setting Spark properties.
| :param gateway: Use an existing gateway and JVM, otherwise a new JVM
| will be instantiated.
| :param jsc: The JavaSparkContext instance (optional).
| :param profiler_cls: A class of custom Profiler used to do profiling
| (default is pyspark.profiler.BasicProfiler).
|
|
| >>> from pyspark.context import SparkContext
| >>> sc = SparkContext('local', 'test')
|
| >>> sc2 = SparkContext('local', 'test2') # doctest: +IGNORE_EXCEPTION_DETAIL
| Traceback (most recent call last):
| ...
| ValueError:...'''

示例代码

from pyspark import SparkContext, SparkConf
### method 1
conf = SparkConf().setAppName('myapp1').setMaster('local[4]') # 设定 appname 和 master
sc = SparkContext(conf=conf) ## method 2
sc = SparkContext("spark://hadoop10:7077")

创建 RDD

spark 最重要的一个概念叫 RDD,Resilient Distributed Dataset,弹性分布式数据集

spark 是以 RDD 概念为中心运行的,RDD 是一个容错的、可以被并行操作的元素集合。

创建 RDD 有三种方式:

1. 在驱动程序中并行化一个已经存在的集合    【内存中的数据】

2. 从外部存储系统引入数据,生成 RDD      【外部存储介质中的数据,注意 spark 本身没有存储功能】

  // 这个存储系统可以是一个共享文件系统,如 hdfs、hbase

3. 从一种 RDD 转换成 另一种 RDD

详见我的博客 RDD 认知

操作 RDD

RDD 的操作有两种方式:转换 和 行动,而且 转换 是 惰性的

可以根据 是否有返回 判断是哪个操作,行动 有返回值,转换无返回值

详见官网 RDD

RDD 的操作也叫 RDD 算子

转换 算子

惰性,无返回值

map(func[, preservesPartitioning=False]):把一个序列中的元素逐个送入 map,经 func 处理后,返回一个新的 序列

rdd = sc.parallelize([2, 3, 4])
rdd.map(lambda x: x + 1).collect() # [3, 4, 5]

filter(func):类似 map,func 是个过滤函数

rdd = sc.parallelize([2, 3, 4])
rdd.map(lambda x: x > 3).collect() # [False, False, True]

flatMap(func[, preservesPartitioning=False]):也类似 map,只是 它会把 每次经过 func 处理的结果进行 合并,输入和输出的 list 长度可能不同

rdd = sc.parallelize([2, 3, 4])
rdd.flatMap(lambda x: range(1, x)).collect() # [1, 1, 2, 1, 2, 3]
# range(1, 2): 1
# range(1, 3): 1, 2
# range(1, 4): 1, 2, 3 ### vs map
rdd.map(lambda x: range(1, x)).collect() # [[1], [1, 2], [1, 2, 3]]

mapPartitions(func [, preservesPartitioning=False]) :map的一个变种,map 是把序列的单个元素送入 func ,而 mapPartitions 是把 序列分区后 每个 分区 整体送入 func

rdd = sc.parallelize([1,2,3,4,5], 3)    # 分 3 个区
def f(iterator): yield sum(iterator) # 必须是生成器,即 yield,不能 return
rdd.mapPartitions(f).collect() # [1, 5, 9]

mapPartitionsWithIndex(func [, preservesPartitioning=False]) :func 有两个参数,分片的序号 和 迭代器,返回 分片序号,也必须是 迭代器

rdd = sc.parallelize(range(15), 13)    # 分 13 个区
def f(splitIndex, iterator): yield splitIndex
rdd.mapPartitionsWithIndex(f).collect() # [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]

cartesian(otherDataset):利用两个 序列 生成 笛卡尔內积 的数据集

x = sc.parallelize([1,2,3])
y = sc.parallelize([4,5])
x.cartesian(y).collect() # [(1, 4), (1, 5), (2, 4), (2, 5), (3, 4), (3, 5)]

groupBy(self, f, numPartitions=None, partitionFunc=portable_hash):输入一个 func,每个元素都用经过 func 处理,并对处理后的结果自动分组

## 条件是分组依据,条件不影响最后的输出格式,输出格式仍和原数据相同
## 如 原来是 [1, 2],经过分组后分到了 第 1 组,输出是 [1, [1, 2]], [1, 2] 完全保留 # 这个例子相当于求 奇偶数
rdd = sc.parallelize([1, 1, 2, 3, 5, 8])
result = rdd.groupBy(lambda x: x % 2).collect() # [(0, <pyspark.resultiterable.ResultIterable object at 0x7f2f76096890>),
# (1, <pyspark.resultiterable.ResultIterable object at 0x7f2f760965d0>)]
# 解析迭代器并排序
sorted([(x, sorted(y)) for (x, y) in result]) # [(0, [2, 8]), (1, [1, 1, 3, 5])]

keyBy(self, f):利于 func 为 rdd 中每个元素设置一个 key

x = sc.parallelize(range(0,3)).keyBy(lambda x: x*x).collect()
# [(0, 0), (1, 1), (4, 2)]

sortBy(self, keyfunc, ascending=True, numPartitions=None):根据指定函数进行排序

tmp = [('a', 1), ('b', 2), ('', 3), ('d', 4), ('', 5)]
sc.parallelize(tmp).sortBy(lambda x: x[0]).collect()
# [('1', 3), ('2', 5), ('a', 1), ('b', 2), ('d', 4)]
sc.parallelize(tmp).sortBy(lambda x: x[1]).collect()
# [('a', 1), ('b', 2), ('1', 3), ('d', 4), ('2', 5)]

cogroup(self, other, numPartitions=None):把 kv 对按 k 进行收集

x = sc.parallelize([("a", 1), ("b", 4)])
y = sc.parallelize([("a", 2)])
[(x, tuple(map(list, y))) for x, y in sorted(list(x.cogroup(y).collect()))]
[('a', ([1], [2])), ('b', ([4], []))]

以下方法只适用 key-value 数据

keys(self),values(self)

m = sc.parallelize([(1, 2), (3, 4)]).keys()
m.collect() # [1, 3]

mapValues(func):根据 func 处理 value

rdd = sc.parallelize([(1, [1,2,3]), (3, ['a', 'b'])])
rdd.mapValues(len).collect() # [(1, 3), (3, 2)] 计算 value 的长度

reduceByKey(func [, numPartitions=None, partitionFunc=<function portable_hash at 0x7fa664f3cb90>]):针对 k-v 对的处理方法,把 key 相同的 value 进行 reduce,然后重新组成 key-reduce 对

rdd = sc.parallelize([("a", 1), ("b", 1), ("a", 1)])
def f(x, y): return x + y
rdd.reduceByKey(f).collect() # [('a', 2), ('b', 1)]

groupByKey(self, numPartitions=None, partitionFunc=portable_hash):根据 key 进行分组

 rdd.groupByKey().collect()
# [('a', <pyspark.resultiterable.ResultIterable object at 0x7f16e3c0bd90>), ('b', <pyspark.resultiterable.ResultIterable object at 0x7f16e3c0bcd0>)]
sorted(rdd.groupByKey().mapValues(len).collect())
# [('a', 2), ('b', 1)]
sorted(rdd.groupByKey().mapValues(list).collect())
# [('a', [1, 1]), ('b', [1])]

sortByKey([ascending=True, numPartitions=None, keyfunc=<function <lambda> at 0x7fa665048c80>]):根据 key 进行排序,默认升序,numPartitions 代表分区数,keyfunc 是处理 key 的,在 排序过程中对 key 进行处理

tmp = [('a', 4), ('b', 3), ('c', 2), ('D', 1)]
sc.parallelize(tmp).sortByKey(True, 1).collect() # 升序[('D', 1), ('a', 4), ('b', 3), ('c', 2)] 1代表分区数
sc.parallelize(tmp).sortByKey(True, 2, keyfunc=lambda k:k.lower()).collect() # 升序[('a', 4), ('b', 3), ('c', 2), ('D', 1)] D跑到后面了 sc.parallelize(tmp).sortByKey(False, 2, keyfunc=lambda k:k.lower()).collect()# 降序[('D', 1), ('c', 2), ('b', 3), ('a', 4)]

keyfunc 只在 排序过程中起作用,在输出时 keyfunc 不起作用

join(otherDataset [, numPartitions=None]):将 两个 k-v RDD 中 共有的 key 的 value 交叉组合

x = sc.parallelize([("a", 1), ("b", 4)])
y = sc.parallelize([("a", 2), ("a", 3)])
x.join(y).collect() # [('a', (1, 2)), ('a', (1, 3))]

join 是内连接,也就是共有的 key 进行组合;

还有 leftOuterJoin 左连接,rightOuterJoin 右连接,fullOuterJoin 全连接

groupWith(other, *others):把多个 RDD 的 key 进行分组;输出 (key,迭代器)

分组后的数据是有顺序的,每个 key 对应的 value 是按 原本 RDD 的顺序的,如果原本 RDD 没有这个 key,留空

w = sc.parallelize([("a", 5), ("b", 6)])
x = sc.parallelize([("a", 1), ("b", 4)])
y = sc.parallelize([("a", 2)])
z = sc.parallelize([("b", 42)])
w.groupWith(x, y, z).collect() [(x, tuple(map(list, y))) for x, y in list(w.groupWith(x, y, z).collect())] # [('a', ([5], [1], [2], [])), ('b', ([6], [4], [], [42]))]

行动 算子

有返回值

count:返回 RDD 中元素个数

first:返回 RDD 中第一个元素

max. min.sum:不解释

take(n):返回 RDD 中 前 n 个元素

collect:返回 RDD 中的数据

要注意的是,collect 相当于把 worker 的数据转移给驱动程序来显示,如果数据量过大,可能导致驱动程序崩溃

takeOrdered(n [, key=None]):对 RDD 先进行排序,然后取排序后的 前 n 个数据,key 表示先经过 keyfunc 处理后再进行排序,最终返回的还是原数据

sc.parallelize([9,7,3,2,6,4]).takeOrdered(3)    # [2, 3, 4]
sc.parallelize([9,7,3,2,6,4]).takeOrdered(3, key=lambda x: -x) # [9, 7, 6]
## 过程如下
# 9, 7, 3, 2, 6, 4 ## 原数据
# -9, -7, -3, -2, -6, -4 ## 经过 keyfunc 处理后的数据
# -9, -7, -6, -4, -3, -2 ## 对处理后的数据升序排序
# -9, -7, -6 ## 取前3个
# 9, 7, 6 ## 对应到原数据

也就是说,keyfunc 只在排序时起作用,在输出时不起作用

foreach(func):运行 func 函数 并行处理 RDD 的所有元素

它与 map 的区别在于一个是 转换算子,一个是行动算子    【曾经面试被问过这个问题,从功能上讲两个函数好像一样的,当时没答上,心碎】

sc.parallelize([1, 2, 3, 4, 5]).foreach(print)  # 并行打印,不按顺序输出
#
#
#
#
#

reduce(func):把 RDD 中前两个元素送入 func,得到一个 value,把这个 value 和 下一个元素 送入 func,直至最后一个元素

sc.parallelize([1,2,3,4,5]).reduce(lambda x, y: x + y)  # 15 求和

fold:与 reduce 类似,fold 是有一个 基数,然后 把每个元素 和 基数 送入 func,然后替换该基数,循环,直到最后一个元素

x = sc.parallelize([1,2,3])
neutral_zero_value = 0 # 0 for sum, 1 for multiplication
y = x.fold(neutral_zero_value, lambda obj, accumulated: accumulated + obj) # computes cumulative sum
print(x.collect()) # [1,2,3]
print(y) #

aggregate:对每个分区进行聚合,然后聚合每个分区的聚合结果,详见我的博客 aggregate

countByValue:统计相同元素的个数

sc.parallelize([1,2,3,1,2,5,3,2,3,2]).countByValue().items()    # [(1, 2), (2, 4), (3, 3), (5, 1)]

# 输入 k-v 不按 value 统计,按 k-v 统计
sc.parallelize([('a', 1), ('b', 1)]).countByValue().items() # [(('a', 1), 1), (('b', 1), 1)]

saveAsTextFile(path [, compressionCodecClass=None]):把 RDD 存储到文件系统中

counts.saveAsTextFile('/usr/lib/spark/out')

输入必须是 路径,且该路径不能事先存在

以下方法只适用 key-value 数据

countByKey:统计相同 key 的个数,返回 key-count

sc.parallelize([("a",1), ("b",1), ("a", 3)]).countByKey()   # defaultdict(<type 'int'>, {'a': 2, 'b': 1})

dictdata= sc.parallelize([("a",1), ("b",1), ("a", 3)]).countByKey()
dictdata.items() # [('a', 2), ('b', 1)]

lookup(self, key):输入 key,返回对应的所有 value

rdd = sc.parallelize([('a', 1), ('b',3), ('a', 5)])
rdd.lookup('a') # [1, 5]

RDD 缓存

把 RDD 缓存到 内存中, 惰性执行

distFile = sc.textFile('README.md')
m = distFile.map(lambda x: len(x)) # map 是 转换 操作,并不立即执行
m.cache() # 把 map 的输出缓存到内存中,其实 cache 就是 执行 操作
# 或者 m.persist()

缓存除了存储到内存中,还有一个非常重要的作用,复用以提高效率;

缓存的 RDD 不仅可以直接拿来转换成新的 RDD,还可以多次利用;

我们知道 RDD 是有血缘关系的,即一个 RDD 由另一个 RDD 转换得来,而这种关系可能是多层的;

如果一个 RDD 缓存了,spark 会执行到目前为止所有转换操作,并为生成的 RDD 创建一个检查点,

但是由于 缓存 是惰性操作,缓存只会在第一次 行动 操作后创建,且第一次 行动 操作不受益,第二次三次直接调用缓存才受益;

缓存适合多次使用的数据,只用一次的无需缓存;

缓存适合大数据,小数据无需缓存

persist(self, storageLevel=StorageLevel.MEMORY_ONLY):这个方法加入了 存储等级,可以把 RDD 缓存在内存或者磁盘上,参数可选,如果没有,等于 cache,存于内存中

参数取值: MEMORY_ONLY、DISK_ONLY、MEMORY_AND_DISK 等

RDD 缓存可容错,即有备份的;

RDD 保存

保存到文件等存储介质中,行动操作

saveAsNewAPIHadoopDataset(self, conf, keyConverter=None, valueConverter=None)

saveAsNewAPIHadoopFile(self, path, outputFormatClass, keyClass=None, valueClass=None, keyConverter=None, valueConverter=None, conf=None)

saveAsHadoopDataset(self, conf, keyConverter=None, valueConverter=None)

saveAsHadoopFile(self, path, outputFormatClass, keyClass=None, valueClass=None, keyConverter=None, valueConverter=None, conf=None, compressionCodecClass=None)

saveAsSequenceFile(self, path, compressionCodecClass=None)

saveAsPickleFile(self, path, batchSize=10)

saveAsTextFile(self, path, compressionCodecClass=None)

参考资料:

https://www.cnblogs.com/yangzhang-home/p/6056133.html  快速入门

https://blog.csdn.net/kl28978113/article/details/80361452  较全教程

http://spark.apache.org/docs/latest/    spark 2.4.4 官网

http://spark.apache.org/docs/latest/api/python/index.html    spark 2.4.4 python API

https://www.cnblogs.com/Vito2008/p/5216324.html

https://blog.csdn.net/proplume/article/details/79798289

https://www.iteblog.com/archives/1396.html#aggregate  RDD 操作 API

https://www.cnblogs.com/yxpblog/p/5269314.html    RDD 操作 API

spark教程(四)-SparkContext 和 RDD 算子的更多相关文章

  1. Spark中普通集合与RDD算子的sortBy()有什么区别

    分别观察一下集合与算子的sortBy()的参数列表 普通集合的sortBy() RDD算子的sortBy() 结论:普通集合的sortBy就没有false参数,也就是说只能默认的升序排. 如果需要对普 ...

  2. Spark RDD 算子总结

    Spark算子总结 算子分类 Transformation(转换) 转换算子 含义 map(func) 返回一个新的RDD,该RDD由每一个输入元素经过func函数转换后组成 filter(func) ...

  3. spark教程(三)-RDD认知与创建

    RDD 介绍 spark 最重要的一个概念叫 RDD,Resilient Distributed Dataset,弹性分布式数据集,它是 spark 的最基本的数据(也是计算)抽象. 代码中是一个抽象 ...

  4. Spark性能调优-RDD算子调优篇(深度好文,面试常问,建议收藏)

    RDD算子调优 不废话,直接进入正题! 1. RDD复用 在对RDD进行算子时,要避免相同的算子和计算逻辑之下对RDD进行重复的计算,如下图所示: 对上图中的RDD计算架构进行修改,得到如下图所示的优 ...

  5. RDD编程 下(Spark自学四)

    3.5 常见的转化操作和行动操作 3.5.1 基本RDD 1. 针对各个元素的转化操作 两个最常用的转化操作是map()和filter().转化操作map()接受一个函数,把这个函数用于RDD中的每个 ...

  6. Spark踩坑记——从RDD看集群调度

    [TOC] 前言 在Spark的使用中,性能的调优配置过程中,查阅了很多资料,之前自己总结过两篇小博文Spark踩坑记--初试和Spark踩坑记--数据库(Hbase+Mysql),第一篇概况的归纳了 ...

  7. Spark 核心篇-SparkContext

    本章内容: 1.功能描述 本篇文章就要根据源码分析SparkContext所做的一些事情,用过Spark的开发者都知道SparkContext是编写Spark程序用到的第一个类,足以说明SparkCo ...

  8. RDD 算子补充

    一.RDD算子补充 1.mapPartitions         mapPartitions的输入函数作用于每个分区, 也就是把每个分区中的内容作为整体来处理.   (map是把每一行) mapPa ...

  9. RDD算子的使用

    TransformationDemo.scala import org.apache.spark.{HashPartitioner, SparkConf, SparkContext} import s ...

随机推荐

  1. su: Authentication failure 的解决方法

    su命令不能切换root,提示su: Authentication failure 原因是 没有设置过 root密码 sudo passwd root 会提示输入密码 重新输入密码 下次再su的时候只 ...

  2. TCP被动打开 之 第一次握手-接收SYN

    假定客户端执行主动打开,服务器执行被动打开,客户端发送syn包到服务器,服务器接收该包,进行建立连接请求的相关处理,即第一次握手:本文主要分析第一次握手中被动打开端的处理流程,主动打开端的处理请查阅本 ...

  3. 在linux下通过ssh运行X图形软件

    服务器端:编辑/etc/ssh/sshd_config中的以下内容启用AllowTcpForwarding启用X11Forwarding将X11DisplayOffset设定为10. 启用X11Use ...

  4. NullPointerException 没有堆栈

    周五在公司搭好的ELK上查看日志,组长让看看其中NullPointerException出现很多的原因. 通过NullPointerException搜索,点看其中一个查看,发现异常的信息就一行jav ...

  5. 前端Ajax跨域解决方案

    业务场景: 前后端分离需要对接数据接口. 接口测试是在postman做的,今天才开始和前端对接,由于这是我第一次做后端接口开发(第一次嘛,问题比较多)所以在此记录分享我的踩坑之旅,以便能更好的理解,应 ...

  6. 阶段3 3.SpringMVC·_03.SpringMVC常用注解_1 RequestParam注解

    新建param.jsp页面.里面一个a标签. 新建Controller 输出字符串 重新部署 传参数 接收这个username并输出 把username换成name 接收不到. 使用RequestPa ...

  7. linux配置信息收集

    CPU型号:# cat /proc/cpuinfo |grep "model name"# cat /proc/cpuinfo | grep name | cut -f2 -d: ...

  8. C基础知识(3):指针--概念、数组中指针的递增/递减、指针数组&数组指针、指向指针的指针

    指针是一个变量,其值为另一个变量的地址. 所有指针的值的实际数据类型,不管是整型.浮点型.字符型,还是其他的数据类型,都是一样的,都是一个代表内存地址的长的十六进制数. 下面从4个代码例子分别讲述以下 ...

  9. SQL:SQL优化

    1.对查询进行优化,应尽量避免全表扫描,首先应考虑在 where 及 order by 涉及的列上建立索引. 2.应尽量避免在 where 子句中对字段进行 null 值判断,否则将导致引擎放弃使用索 ...

  10. Data - 【转】数据统计、数据挖掘、大数据、OLAP的区别

    原文链接 数据分析 数据分析是一个大的概念,理论上任何对数据进行计算.处理从而得出一些有意义的结论的过程,都叫数据分析. 从数据本身的复杂程度.以及对数据进行处理的复杂度和深度来看,可以把数据分析分为 ...