Python第二语言(十三、PySpark实战)

目录

1.开篇

2. PySpark介绍

3. PySpark基础准备

3.1 PySpark安装

3.2 掌握PySpark执行环境入口对象的构建

3.3 理解PySpark的编程模型

4. PySpark:RDD对象数据输入

4.1 RDD对象概念:PySpark支持多种数据的输入,完成后会返回RDD类的对象;

4.2 Python数据容器转RDD对象.parallelize(数据容器对象)

4.3 RDD存在很多计算的方法

4.4 读取文件转RDD对象:通过SparkContext入口对象来读取文件,构建RDD对象;

5. PySpark: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. PySpark:RDD对象数据计算(二)

7.1 RDD的filter方法:传入T泛型数据,返回bool,为false 的数据丢弃,为true的数据保留;(函数对RDD数据逐个处理,得到True的保留至返回值的RDD中)

7.2 RDD的distinct方法:对RDD数据进行去重,返回新RDD;

7.3 RDD的sortBy方法:对RDD的容器按照指定规则排序,返回新RDD;

8. 数据计算案例(二):计算城市中的商品以及销售额

8.1 需求

8.2 文件数据

8.3 需求一实现:处理结果自动返回的是一个二元元组;

8.4 需求二实现:将字典中的数据处理,返回一个list;

8.5 需求三实现:过滤除北京的数据,并只返回一个参数category,是list列表,并进行去重,去重后的结果进行collect输出;

9. 将RDD的结果数据输出为Python对象的各类方法


导航:

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第二语言(九、Python第一阶段实操)-CSDN博客

Python第二语言(十、Python面向对象(上))-CSDN博客

Python第二语言(十一、Python面向对象(下))-CSDN博客

Python第二语言(十二、SQL入门和实战)-CSDN博客

Python第二语言(十三、PySpark实战)-CSDN博客

Python第二语言(十四、高阶基础)-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的编程三大步骤:
    1. 数据输入:通过SparkContex类对象的成员方法完成数据的读取操作,读取后得到RDD类对象;
    2. 数据处理计算:通过RDD类对象的成员方法,完成各种数据计算的需求;
    3. 数据输出:将处理完成后的RDD对象,调用各种成员方法完成,写出文件,转换位list等操作;

4. PySpark:RDD对象数据输入

  • RDD就是PySpark计算后返回的对象容器;
4.1 RDD对象概念:PySpark支持多种数据的输入,完成后会返回RDD类的对象;

RDD全称为:弹性分布式数据集(Resilient Distributed Datasets);

  • PySpark针对数据的处理,都是以RDD对象作为载体;
    1. 数据存储在RDD内;
    2. 各类数据的计算方法,也都是RDD的成员方法;
    3. RDD的数据计算方法,返回值依旧是RDD对象;
  • 比如说JSON文件、文本文件、数据库数据,都是可以通过SparkContext类对象,经过RDD对象的处理,并返回给文件文件或JSON文件,或者数据库;
4.2 Python数据容器转RDD对象.parallelize(数据容器对象)
  • 提示:
    1. 字符串会被拆分出1个个的字符,存入RDD对象;
    2. 字典仅有key会被存入RDD对象;
    3. 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中数据计算的载体,可以:
    1. 提供数据存储;
    2. 提供数据计算的各类方法;
    3. 数据计算的方法,返回值依旧是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是泛型,传入的是什么值,那么返回的就是什么类型)

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. 小结:

  1. map算子(成员方法):
    • 接受一个处理函数,可用lambda表达式快速编写;
    • 对RDD内的元素逐个处理,并返回一个新的RDD;
  2. 链式调用:对于返回值是新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 需求
  1. 需求一:各个城市销售额排名,从大到小;

    先按行读取文件,并对json进行split分割,按照|符号,得到最终的字典,使用Spark.reduceByKey进行分组,分组时传递func计算函数,将所有分组后的城市销售额进行a+b的形式,聚合起来,最终得到结果,并按照降序的排序方式排序输出;

  2. 需求二:全部城市,有哪些商品类别在售卖;

    文件读取后,将城市的categpry商品类别,distinct使用去重;

  3. 需求三:北京市有哪些商品类别在售卖;

    将除了北京市的所有数据进行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)

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值