目录
4.1 RDD对象概念:PySpark支持多种数据的输入,完成后会返回RDD类的对象;
4.2 Python数据容器转RDD对象.parallelize(数据容器对象)
4.4 读取文件转RDD对象:通过SparkContext入口对象来读取文件,构建RDD对象;
5.1 给Spark设置环境变量(不设置的时候,控制台会报错,出现找不到python.exe解释器的情况)
5.2 RDD的map方法:将RDD的数据根据函数进行一条条处理
5.3 RDD的flatMap方法:基本和map一样,但是多一个功能:将嵌套list给转成单list;[[1, 2, 3], [4, 5, 6]]转成[1, 2, 3, 4, 5, 6]
5.4 RDD的reduceByKey方法:将key分组后进行value逻辑处理;
6. 数据计算案例(一):完成使用PySpark进行单词技术的案例
7.1 RDD的filter方法:传入T泛型数据,返回bool,为false 的数据丢弃,为true的数据保留;(函数对RDD数据逐个处理,得到True的保留至返回值的RDD中)
7.2 RDD的distinct方法:对RDD数据进行去重,返回新RDD;
7.3 RDD的sortBy方法:对RDD的容器按照指定规则排序,返回新RDD;
8.5 需求三实现:过滤除北京的数据,并只返回一个参数category,是list列表,并进行去重,去重后的结果进行collect输出;
导航:
Python第二语言(一、Python start)-CSDN博客
Python第二语言(二、Python语言基础)-CSDN博客
Python第二语言(三、Python函数def)-CSDN博客
Python第二语言(四、Python数据容器)-CSDN博客
Python第二语言(五、Python文件相关操作)-CSDN博客
Python第二语言(九、Python第一阶段实操)-CSDN博客
Python第二语言(十、Python面向对象(上))-CSDN博客
Python第二语言(十一、Python面向对象(下))-CSDN博客
Python第二语言(十二、SQL入门和实战)-CSDN博客
Python第二语言(十三、PySpark实战)-CSDN博客
1.开篇
- PySpark大数据计算第三方库,Spark是大数据开发的核心技术;
- python的spark中使用map时 Python worker exited unexpectedly (crashed):
- 将原本的python12解释器降低版本到python10版本解释器,降低python解释器版本,因为版本不兼容;
- 记得下载使用的包;
2. PySpark介绍
- Apache Spark是用于大规模数据(large-scala data)处理的统一(unifield)分析引擎;
- Spark是一款分布式的计算框架,用于调度成百上千的服务器集群,计算TB、PB乃至EB级别的海量数据;
- Python On Spark:Python语言,是Spark重点支持的方向;
PySpark第三方库:
- PySpark是由Spark官方开发的Python语言第三方库;
- Python开发者可以使用pip程序快速安装PySpark并像其它第三方库一样使用;
- 主要作用:
- 进行数据处理;
- 提交至Spark集群,进行分布式集群计算;
3. PySpark基础准备
3.1 PySpark安装
安装命令: pip install pyspark
加速下载命令:pip install -i
https://pypi.tuna.tsinghua.edu.cn/simple pyspark
3.2 掌握PySpark执行环境入口对象的构建
- PySpark是分布式集群的操作,
setMaster(xxx).\setAppName(xxx)
是用来控制集群的代码,图中代码用的是单机的; setAppName
是Spark任务的名称;- PySpark的执行环境入口对象是:类SparkContext的类对象,所有PySpark的功能都是从SparkContext对象作为开始;
# 导包
from pyspark import SparkConf, SparkContext
# 创建SparkConf类对象
conf = SparkConf().setMaster("local[*]").\
setAppName("test_spark_app")
# 基于SparkConf类对象创建SparkContext类对象
sc = SparkContext(conf=conf)
# 打印PySpark的运行版本
print(sc.version)
# 停止SparkContext对象的运行
sc.stop()
3.3 理解PySpark的编程模型
SparkContext类对象,是PySpark编程中一切功能的入口;
- PySpark的编程三大步骤:
- 数据输入:通过SparkContex类对象的成员方法完成数据的读取操作,读取后得到RDD类对象;
- 数据处理计算:通过RDD类对象的成员方法,完成各种数据计算的需求;
- 数据输出:将处理完成后的RDD对象,调用各种成员方法完成,写出文件,转换位list等操作;
4. PySpark:RDD对象数据输入
- RDD就是PySpark计算后返回的对象容器;
4.1 RDD对象概念:PySpark支持多种数据的输入,完成后会返回RDD类的对象;
RDD全称为:弹性分布式数据集(Resilient Distributed Datasets);
- PySpark针对数据的处理,都是以RDD对象作为载体;
- 数据存储在RDD内;
- 各类数据的计算方法,也都是RDD的成员方法;
- RDD的数据计算方法,返回值依旧是RDD对象;
- 比如说JSON文件、文本文件、数据库数据,都是可以通过SparkContext类对象,经过RDD对象的处理,并返回给文件文件或JSON文件,或者数据库;
4.2 Python数据容器转RDD对象.parallelize(数据容器对象)
- 提示:
- 字符串会被拆分出1个个的字符,存入RDD对象;
- 字典仅有key会被存入RDD对象;
- RDD对象返回的是容器,与list一样结果;
from pyspark import SparkConf, SparkContext
conf = SparkConf().setMaster("local[*]").setAppName("test_spark_app")
sc = SparkContext(conf=conf)
# 通过parallelize方法将Python对象加载到Spark内,称为RDD对象
rdd1 = sc.parallelize([1, 2, 3, 4, 5])
rdd2 = sc.parallelize((1, 2, 3, 4, 5))
rdd3 = sc.parallelize("abcdefg")
rdd4 = sc.parallelize({1, 2, 3, 4, 5})
rdd5 = sc.parallelize({"key1": "value1", "key2": "value2"})
# 使用collect方法查看RDD中的内容
print(rdd1.collect())
print(rdd2.collect())
print(rdd3.collect())
print(rdd4.collect())
print(rdd5.collect())
sc.stop()
4.3 RDD存在很多计算的方法
4.4 读取文件转RDD对象:通过SparkContext入口对象来读取文件,构建RDD对象;
from pyspark import SparkConf, SparkContext
conf = SparkConf().setMaster("local[*]").setAppName("test_spark_app")
sc = SparkContext(conf=conf)
# 通过textFile方法,读取文件数据加载到Spark内,成为RDD对象
rdd = sc.textFile("dataText")
# 打印RDD内容
print(rdd.collect())
sc.stop()
小结:
- RDD对象称之为分布式弹性数据集,是PySpark中数据计算的载体,可以:
- 提供数据存储;
- 提供数据计算的各类方法;
- 数据计算的方法,返回值依旧是RDD(RDD迭代计算);
5. PySpark:RDD对象数据计算(一)
- 可以对list容器计算,可以对dict字典容器计算,可以对str字符串进行计算,所有的容器都可以通过RDD计算;
5.1 给Spark设置环境变量(不设置的时候,控制台会报错,出现找不到python.exe解释器的情况)
os.path.exists
返回值为True或False;
from pyspark import SparkConf, SparkContext
import os
# 配置Spark环境变量
os.environ['PYSPARK_PYTHON'] = 'C:/Users/Administrator/AppData/Local/Programs/Python/Python310/python.exe'
# 检查PYSPARK_PYTHON路径
print(os.path.exists('C:/Users/Administrator/AppData/Local/Programs/Python/Python310/python.exe'))
# 检查PYSPARK_DRIVER_PYTHON路径
print(os.path.exists('C:/Users/Administrator/AppData/Local/Programs/Python/Python310/python.exe'))
5.2 RDD的map方法:将RDD的数据根据函数进行一条条处理
1. 介绍:
- RDD对象内置丰富的:成员方法(算子)
- map算子:是将RDD的数据一条条处理(处理的逻辑是将python中的函数作为参数进行传递,这个函数,参数会将RDD种的每条数据都进行处理)最终返回一个新的RDD对象;
- map()中的参数
(T) → U
:T代表传入一个参数,U代表一个返回值;(意思代表传入的参数是一个,还有一个返回值,T是泛型,不用指定数据类型) - map()中的参数
(T) → T
:T代表传入一个参数,T代表一个返回值;(意思代表传入的参数是一个,还有一个返回值,T是泛型,传入的是什么值,那么返回的就是什么类型)
- map()中的参数
2. func函数传递:
func函数作为参数:代表的是RDD中的每个值,都会进行func函数的处理;是RDD中的每一个元素都会被RDD处理一遍;
可以简写成:rdd2 = rdd.map(lambda x: x * 10) # 简写的函数
;
3. 案例:
- 这里存在一个大坑,如果是python312版本去使用map函数,会报错
Python worker exited unexpectedly (crashed)
,降低版本即可,我用的版本10; - 结果:RDD中的每一个元素都会被传递给func进行处理,*10操作;
from pyspark import SparkConf, SparkContext
import os
# 配置Spark环境变量
os.environ['PYSPARK_PYTHON'] = 'C:/Users/Administrator/AppData/Local/Programs/Python/Python310/python.exe'
conf = SparkConf().setMaster("local[*]").setAppName("test_spark_app")
sc = SparkContext(conf=conf)
# 准备一个RDD
rdd = sc.parallelize([1, 2, 3, 4, 5])
rdd2 = rdd.map(lambda x: x * 10) # 简写的函数
print(rdd2.collect())
sc.stop()
4. map链式调用:
from pyspark import SparkConf, SparkContext
import os
# 配置Spark环境变量
os.environ['PYSPARK_PYTHON'] = 'C:/Users/Administrator/AppData/Local/Programs/Python/Python310/python.exe'
conf = SparkConf().setMaster("local[*]").setAppName("test_spark_app")
sc = SparkContext(conf=conf)
rdd = sc.parallelize([1, 2, 3, 4, 5])
rdd2 = rdd.map(lambda x: x * 10).map(lambda x: x + 5) # 链式调用:将map进行第一个*10数据计算,再进行map+5数据计算
print(rdd2.collect())
5. 小结:
- map算子(成员方法):
- 接受一个处理函数,可用lambda表达式快速编写;
- 对RDD内的元素逐个处理,并返回一个新的RDD;
- 链式调用:对于返回值是新RDD的算子,可以通过链式调用的方式多次调用算子;
5.3 RDD的flatMap方法:基本和map一样,但是多一个功能:将嵌套list给转成单list;[[1, 2, 3], [4, 5, 6]]转成[1, 2, 3, 4, 5, 6]
from pyspark import SparkConf, SparkContext
import os
if __name__ == '__main__':
os.environ['PYSPARK_PYTHON'] = 'C:/Users/Administrator/AppData/Local/Programs/Python/Python310/python.exe'
conf = SparkConf().setMaster("local[*]").setAppName("test_spark_app")
sc = SparkContext(conf=conf)
rdd = sc.parallelize(["zhangSan lisi yiyi", "zhangSan yiyi wangWu", "wangWu yiyi zhangSan"])
print(rdd.map(lambda x: x.split(" ")).collect())
print("-----------------------------------------")
print(rdd.flatMap(lambda x: x.split(" ")).collect()) # 将嵌套list转成单list,对数据接触嵌套
5.4 RDD的reduceByKey方法:将key分组后进行value逻辑处理;
-
二元元组:
[('a', 1), ('a', 1), ('b', 1)]
这就是二元元组,元组中只有两个元素; -
自动按照key分组,完成组内数据(value)的聚合操作:就是会按照元组中的key,就是
'a', 'a', 'b'
进行key的value聚合,1, 1, 1
是value;(value聚合的逻辑是,按照传入的func函数逻辑来进行聚合)假设这是二元元组数据要进行reduceByKey算子处理:
reduceByKey计算方式:
1. 思路:
- 先分组,key值等于a和a一组,b和b一组:然后在进行函数
lambda a, b: a+b
进行处理,也即是分组后,a=a+a, b=b+b+b;结果[('b', 3), ('a', 2)]
- 再解释:b有三个值,那么
lambda a, b: a+b
中表示的是b:1, 1, 1
的三个值,去进行函数处理的时候,先是第一个1和第二1进行相加,这时候相加是a+b
,分组后与key无关系,那么第一个1和第二个1相加后等于2,这时候发现还有第三个1,这时候再次把第一次相加的结果,与第三个1进行a+b
处理,2+1
;是前后者参数的相加处理;最终得到按照key分组聚合value的结果; - 最终解释:将数据分组后,每个组的数据进行
lambda a, b: a + b
操作,每个组中的数据,进行a + b操作,意思就是将当前组的所有value进行相加操作;
2. 实现:
- 功能:针对KV型RDD,自动按照key分组,然后根据提供的聚合逻辑,完成组内数据(value)的聚合操作;
- rdd.reduceByKey(func):
from pyspark import SparkConf, SparkContext import os if __name__ == '__main__': os.environ['PYSPARK_PYTHON'] = 'C:/Users/Administrator/AppData/Local/Programs/Python/Python310/python.exe' conf = SparkConf().setMaster("local[*]").setAppName("test_spark_app") sc = SparkContext(conf=conf) rdd = sc.parallelize([('a', 1), ('a', 1), ('b', 1), ('b', 1), ('b', 1)]) result = rdd.reduceByKey(lambda a, b: a + b) # 分组计算 print(result.collect())
6. 数据计算案例(一):完成使用PySpark进行单词技术的案例
- 题目:读取文件,求出文件中单词出现的次数;
- 文件:
-
思路:
先将字符串进行读取,然后按照空格分割
['key', 'key']
,在进行分割后的数组重组为(key, 1)
的形式,后面利用rdd的reduceByKey方法,将分组后的key,进行聚合操作,因为value都是1,所以可以得出对单词出现的次数,进行统计操作; -
根据
(key, 1)
重组后的数据应该是:[('key1', 1), ['key1', 1], ('key2', 1), ['key2', 1]]
- 然后得出最终结果:
from pyspark import SparkConf, SparkContext import os if __name__ == '__main__': os.environ['PYSPARK_PYTHON'] = 'C:/Users/Administrator/AppData/Local/Programs/Python/Python310/python.exe' conf = SparkConf().setMaster("local[*]").setAppName("test_spark_app") sc = SparkContext(conf=conf) # 1.读取数据文件 """ 假设你有一个大文件,里面有 300MB 的数据,如果你指定分区数为 3,Spark 会尝试将这个文件分成 3 个分区,每个分区大约 100MB。 如果你的集群有 3 个节点,每个节点可以并行处理一个分区,这样就可以更快地完成任务。 """ file = sc.textFile("word", 3) # ("xx" , 3):3是指文件被分成的最小分区数(partitions) # 2.将所有单词读取出来 words = file.flatMap(lambda line: line.split(' ')) # 结果:['python', 'java', ...] # 3.将所有单词加1做value word_one = words.map(lambda x: (x, 1)) # 结果:[('python', 1), ('java', 1), ('php', 1), ('c#', 1),...] # 4.分组并求和 result = word_one.reduceByKey(lambda a, b: a + b) # 5.打印结果 print(result.collect())
7. PySpark:RDD对象数据计算(二)
7.1 RDD的filter方法:传入T泛型数据,返回bool,为false 的数据丢弃,为true的数据保留;(函数对RDD数据逐个处理,得到True的保留至返回值的RDD中)
- 功能:过滤想要的数据进行保留;
- filter算子作用:
- 接受一个处理函数,可用lambda快速编写;
- 函数对RDD数据逐个处理,得到True的保留至返回值的RDD中;
from pyspark import SparkConf, SparkContext
import os
if __name__ == '__main__':
os.environ['PYSPARK_PYTHON'] = 'C:/Users/Administrator/AppData/Local/Programs/Python/Python310/python.exe'
conf = SparkConf().setMaster("local[*]").setAppName("test_spark_app")
sc = SparkContext(conf=conf)
rdd = sc.parallelize([1, 2, 3, 4, 5])
# 保留基数
print(rdd.filter(lambda x: x % 2 == 1).collect())
7.2 RDD的distinct方法:对RDD数据进行去重,返回新RDD;
from pyspark import SparkConf, SparkContext
import os
if __name__ == '__main__':
os.environ['PYSPARK_PYTHON'] = 'C:/Users/Administrator/AppData/Local/Programs/Python/Python310/python.exe'
conf = SparkConf().setMaster("local[*]").setAppName("test_spark_app")
sc = SparkContext(conf=conf)
rdd = sc.parallelize([1, 1, 2, 3, 4, 5, 4, 5])
# 对rdd对象进行去重
print(rdd.distinct().collect())
7.3 RDD的sortBy方法:对RDD的容器按照指定规则排序,返回新RDD;
func: (T) → U
:告知按照rdd中的哪个数据进行排序,比如lambda x: x[1]
表示按照rdd中的第二列元素进行排序;numPartitions
:目前默认就为1;
结果:
按照元组tople中的第二位元素进行排序,按照降序;
lambda x: x[1]
:计算规则,将所有容器的每一个元素按照函数规则处理,x是遍历的元组,x[1]
是传入的元组的第二位元素,所以规则就是按照元组的第二位元素进行降序排序;
from pyspark import SparkConf, SparkContext
import os
if __name__ == '__main__':
os.environ['PYSPARK_PYTHON'] = 'C:/Users/Administrator/AppData/Local/Programs/Python/Python310/python.exe'
conf = SparkConf().setMaster("local[*]").setAppName("test_spark_app")
sc = SparkContext(conf=conf)
rdd = sc.parallelize([("zhangSan", 99), ("lisi", 88), ("wangWu", 100)])
# 对结果进行排序
final_rdd = rdd.sortBy(lambda x: x[1], ascending=False, numPartitions=1)
print(final_rdd.collect())
- sortBy算子小结:
- 接收一个处理函数,可用lambda快速编写;
- 函数表示用来决定排序的依据;
- 可以控制升序或降序;
- 全局排序需要设置分区数为1;
8. 数据计算案例(二):计算城市中的商品以及销售额
8.1 需求
-
需求一:各个城市销售额排名,从大到小;
先按行读取文件,并对json进行split分割,按照|符号,得到最终的字典,使用Spark.reduceByKey进行分组,分组时传递func计算函数,将所有分组后的城市销售额进行a+b的形式,聚合起来,最终得到结果,并按照降序的排序方式排序输出;
-
需求二:全部城市,有哪些商品类别在售卖;
文件读取后,将城市的categpry商品类别,distinct使用去重;
-
需求三:北京市有哪些商品类别在售卖;
将除了北京市的所有数据进行filter过滤,过滤后只留下category并进行去重得到结果;
8.2 文件数据
{"id":1,"timestamp":"2024-06-01T01:03.00Z","category":"电脑","areaName":"杭州","money":"3000"}|{"id":2,"timestamp":"2024-06-01T01:03.00Z","category":"电脑","areaName":"杭州","money":"3500"}
{"id":3,"timestamp":"2024-06-01T01:03.00Z","category":"食品","areaName":"杭州","money":"3000"}|{"id":4,"timestamp":"2024-06-01T01:03.00Z","category":"食品","areaName":"杭州","money":"3700"}
{"id":5,"timestamp":"2024-06-01T01:03.00Z","category":"服饰","areaName":"北京","money":"3000"}|{"id":6,"timestamp":"2024-06-01T01:03.00Z","category":"服饰","areaName":"北京","money":"3900"}
8.3 需求一实现:处理结果自动返回的是一个二元元组;
from pyspark import SparkConf, SparkContext
import os
if __name__ == '__main__':
os.environ['PYSPARK_PYTHON'] = 'C:/Users/Administrator/AppData/Local/Programs/Python/Python310/python.exe'
conf = SparkConf().setMaster("local[*]").setAppName("test_spark_app")
sc = SparkContext(conf=conf)
# 1.读取文件得到RDD
file_rdd = sc.textFile("orders")
# 2. 取出一个个JSON字符串
json_str_rdd = file_rdd.flatMap(lambda x: x.split("|"))
# 3. 将一个个JSON字符串转换为字典
dict_rdd = json_str_rdd.map(lambda x: json.loads(x))
# print(dict_rdd.collect())
# 4.取出城市和销售额数据
city_with_money_rdd = dict_rdd.map(lambda x: (x['areaName'], int(x['money'])))
# 5.按城市分组按销售额聚合
city_result_rdd = city_with_money_rdd.reduceByKey(lambda a, b: a + b)
# 6.按销售额聚合结果进行排序
result_rdd = city_result_rdd.sortBy(lambda x: x[1], ascending=False, numPartitions=1)
print("需求1的结果:", result_rdd.collect())
前三步数据结果:
完整数据结果:
8.4 需求二实现:将字典中的数据处理,返回一个list;
from pyspark import SparkConf, SparkContext
import os
if __name__ == '__main__':
os.environ['PYSPARK_PYTHON'] = 'C:/Users/Administrator/AppData/Local/Programs/Python/Python310/python.exe'
conf = SparkConf().setMaster("local[*]").setAppName("test_spark_app")
sc = SparkContext(conf=conf)
# 1.读取文件得到RDD
file_rdd = sc.textFile("orders")
# 2. 取出一个个JSON字符串
json_str_rdd = file_rdd.flatMap(lambda x: x.split("|"))
# 3. 将一个个JSON字符串转换为字典
dict_rdd = json_str_rdd.map(lambda x: json.loads(x))
# 4.取出全部的商品类别
category_rdd = dict_rdd.map(lambda x: x['category']).distinct()
print("需求2的结果:", category_rdd.collect())
8.5 需求三实现:过滤除北京的数据,并只返回一个参数category,是list列表,并进行去重,去重后的结果进行collect输出;
from pyspark import SparkConf, SparkContext
import os
if __name__ == '__main__':
os.environ['PYSPARK_PYTHON'] = 'C:/Users/Administrator/AppData/Local/Programs/Python/Python310/python.exe'
conf = SparkConf().setMaster("local[*]").setAppName("test_spark_app")
sc = SparkContext(conf=conf)
# 1.读取文件得到RDD
file_rdd = sc.textFile("orders")
# 2. 取出一个个JSON字符串
json_str_rdd = file_rdd.flatMap(lambda x: x.split("|"))
# 3. 将一个个JSON字符串转换为字典
dict_rdd = json_str_rdd.map(lambda x: json.loads(x))
# 4. 过滤北京的数据
beijing_data_rdd = dict_rdd.filter(lambda x: x['areaName'] == '北京')
# 5.取出全部商品类别
result_rdd = beijing_data_rdd.map(lambda x: x['category']).distinct()
print("需求3的结果:", result_rdd.collect())
9. 将RDD的结果数据输出为Python对象的各类方法
- 数据输出:将RDD输出的值转成文件或Python对象;
- collect算子:将各个分区内的数据,统一收集到Driver中,形成一个list对象;
- reduce算子:对RDD数据集按照你传入的逻辑进行聚合;
- task算子:取出RDD的前N个元素,组合成list返回;
- count算子:计算RDD有多少条数据,返回值是一个数字;
from pyspark import SparkConf, SparkContext
import os
os.environ['PYSPARK_PYTHON'] = 'C:/Users/Administrator/AppData/Local/Programs/Python/Python310/python.exe'
conf = SparkConf().setMaster("local[*]").setAppName("test_spark_app")
sc = SparkContext(conf=conf)
if __name__ == '__main__':
rdd = sc.parallelize([1, 2, 3, 4, 5])
# collect算子,输出RDD为list对象
rdd_list: list = rdd.collect()
print("collect算子结果:", rdd_list)
print("collect算子类型是:", type(rdd_list))
# reduce算子,对RDD进行两两聚合
num = rdd.reduce(lambda a, b: a + b)
print("reduce算子结果:", num)
# take算子,取出RDD前N个元素,组成list返回
take_list = rdd.take(3)
print("take算子结果:", take_list)
# count,统计rdd内有多少条数据,返回值为数字
num_count = rdd.count()
print("count算子结果:", num_count)