云计算复习笔记

5个大类

单选 5题 * 2分
多选 2题 * 3分
程序阅读 10题 * 5分
简答 2题 * 8分
编程 2题（8分+10分）

私有云、公有云、混合云的概念

公有云

公有云通常指第三方提供商用户能够使使用的云，公有云一般可通过 Internet 使用，可能是免费或成本低廉的。公有云的最大意义是能够以低廉的价格，提供有吸引力的服务给最终用户，创造新的业务价值，公有云作为一个支撑平台，还能够整合上游的服务（如增值业务，广告）提供者和下游最终用户，打造新的价值链和生态系统。它使客户能够访问和共享基本的计算机基础设施，其中包括硬件、存储和带宽等资源。

公有云是为大众建的，所有入驻用户都称租户，不仅同时有很多租户，而且一个租户离开，其资源可以马上释放给下一个租户。

优点:

成本低
方便
易扩展

缺点:

安全顾虑
性能超卖问题
管理要复杂

私有云

是为一个客户单独使用而构建的，因而提供对数据、安全性和服务质量的最有效控制。该公司拥有基础设施，并可以控制在此基础设施上部署应用程序的方式。私有云可部署在企业数据中心的防火墙内(本地私有云)，也可以将它们部署在一个安全的主机托管场所（托管私有云）。

优点:

安全
自主可控

缺点:

成本高
远程访问困难

社区云

社区云的核心特征是云端资源只给两个或者两个以上的特定单位组织内的员工使用，除此之外的人和机构都无权租赁和使用云端计算资源。与私有云类似，社区云的云端也有两种部署方法，即本地部署和托管部署。

混合云

是两个或两个以上不同类型的云（私有云、社区云、公共云）服务的结合，这种结合可以是计算的、存储的，也可以两者兼而有之。

优点:

操作灵活
弹性
成本效益。混合云模式具有成本效益，因为企业可以根据需要决定使用成本更昂贵的云计算资源。

缺点:

安全性不强
费用高。公有云+私有云管理费用高昂
兼容性问题

访问远程Python时，接口是多少？

4040

区分哪些算子是窄依赖/宽依赖

RDD的依赖关系

在 Spark 中，RDD 分区的数据不支持修改，是只读的。如果想更新 RDD 分区中的数据，那么只能对原有 RDD 进行转化操作，也就是在原来 RDD 基础上创建一个新的RDD。

那么，在整个任务的运算过程中，RDD 的每次转换都会生成一个新的 RDD，因此 RDD 们之间会产生前后依赖的关系。

说白了，就是相当于将对原始 RDD 分区数据的整个运算进行了拆解，当运算中出现异常情况导致分区数据丢失时，Spark 可以还通过依赖关系从上一个 RDD 中重新计算丢失的数据，而不是对最开始的 RDD 分区数据重新进行计算。

在 RDD 的依赖关系中，我们将上一个 RDD 称为父RDD，下一个 RDD 称为子RDD。

如何区分宽窄依赖

宽依赖：父 RDD 中每个分区的数据都可以被子 RDD 的多个分区使用（涉及到了shuffle）；

宽依赖

窄依赖：父 RDD 中每个分区的数据最多只能被子 RDD 的一个分区使用。

窄依赖

常见的宽窄依赖算子

宽依赖的算子：groupByKey、partitionBy、join(非hash-partitioned)、reduceByKey

窄依赖的算子：map、filter、union、intersection、join(hash-partitioned)、mapPartitions、mapValues、distinct

阶段划分的依据

对于Spark来说，会根据DAG，按照宽依赖，划分不同的DAG

阶段划分依据:从后向前，遇到宽依赖就划分出一个阶段.称之为stage

stage划分

如图，在DAG中基于宽依赖将DAG划分成了2个stage。

在stage的内部，一定都是窄依赖

哪些算子可以对RDD进行分组？

groupBy

功能：将rdd的数据进行分组

from pyspark import SparkConf, SparkContext

if __name__='__main__':
# 构建Spark执行环境
conf = SparkConf() . setAppName ("create rdd") .\
	setMaster("local[*]")
sc = SparkContext (conf=conf)
rdd = sc.parallelize([1, 2, 3, 4, 5])

#分组，将数字分成偶数和奇数2个组
rdd2 = rdd. groupBy (lambda num: 'even' if (num % 2 == 0) else 'odd' )

#并rdd2的元素的value转换成list, 这样print可以输出内容.
print(rdd2. map(Lambda x: (x[0], list(x[1]))). collect())

结果：

[('even', [2，4])，('odd', [1, 3, 5])]

groupByKey

功能:针对KV型RDD,自动按照key分组

rdd = sc. parallelize([('a', 1),('a', 1),('b', 1),('b', 1), ('b', 1)])
grouped_rdd = rdd. groupByKey()
print(grouped_rdd.map(lambda x: (x[0],list(x[1]))) . collect())

结果:

[('b',[1, 1, 1]),('a',[1， 1])]

coalesce

功能:对分区进行数量增减

from pyspark import SparkContext

# 创建 SparkContext 对象
sc = SparkContext("local", "Coalesce Example")

# 创建一个包含整数 1 到 10 的 RDD，分为 4 个分区
data = sc.parallelize(range(1, 11), 4)

# 使用 coalesce 算子将分区数缩减为 2
coalesced = data.coalesce(2)

# 输出新的 RDD 中的分区数
print("Number of partitions: ", coalesced.getNumPartitions())

# 关闭 SparkContext 对象
sc.stop()

结果：

Number of partitions: 2

repartition

功能:对RDD的分区执行重新分区(仅数量)

from pyspark import SparkContext

# 创建 SparkContext 对象
sc = SparkContext("local", "Repartition Example")

# 创建一个包含整数 1 到 10 的 RDD，分为 4 个分区
data = sc.parallelize(range(1, 11), 4)

# 使用 repartition 算子将分区数增加到 6
repartitioned = data.repartition(6)

# 输出新的 RDD 中的分区数
print("Number of partitions: ", repartitioned.getNumPartitions())

# 关闭 SparkContext 对象
sc.stop()

结果：

Number of partitions: 6

partitionBy

功能:对RDD进行自定义分区操作

from pyspark import SparkContext
from pyspark.sql import SparkSession

# 创建 SparkSession 对象
spark = SparkSession.builder.appName("PartitionBy Example").getOrCreate()

# 创建一个包含 (key, value) 对的 RDD
data = spark.sparkContext.parallelize([(1, "a"), (2, "b"), (3, "c"), (4, "d"), (5, "e")])

# 使用 partitionBy 算子按照 key 进行重新分区
partitioned = data.partitionBy(2)

# 输出新的 RDD 中的分区数和每个分区中的元素
print("Number of partitions: ", partitioned.getNumPartitions())
for i, part in enumerate(partitioned.glom().collect()):
    print(f"Partition {i}: {part}")

# 关闭 SparkSession 对象
spark.stop()

结果：

Number of partitions: 2
Partition 0: [(2, 'b'), (4, 'd')]
Partition 1: [(1, 'a'), (3, 'c'), (5, 'e')]

云计算特点

资源池化

大部分云计算资源，都是池化了的资源。什么叫池化？池化就是物理资源的基础上，通过软件平台，封装成虚拟的计算资源，也就是我们常说的虚拟化。

弹性伸缩

云计算的计算资源，可以按需付费。你想要用多少，就租多少，想什么时候要就什么时候要，配置是支持自定义的。

安全可靠

而云计算，从物理角度来说，所有的计算资源都汇集在大型互联网数据中心（IDC），那里有严格的安保、抗震的建筑、安全的供电，有非常全面的容灾设计和应急方案，能够更好地保护计算资源，不会轻易地中断服务。

从软件上来说，云计算服务提供商有更专业的技术团队，更成熟的技术储备，能够更好地保护计算资源不被入侵或破坏。

RDD 的5大特性

RDD是有分区的
RDD的方法会作用在其所有的分区上
RDD之间是有依赖关系的（RDD有学员关系）
key-value型的RDD可以有分区器
RDD的分区规划，会尽量靠近数据所在的服务器

对RDD特性进行缓存，有哪些方法？这些方法有什么区别和相同点？

缓存特点：其保留RDD之间的血缘(依赖)关系

方法：

Cache
Checkpoint

区别：

Cache是轻量化保存RDD数据, 可存储在内存和硬盘, 是分散存储, 设计上数据是不安全的(保留RDD 血缘关系)
CheckPoint是重量级保存RDD数据, 是集中存储, 只能存储在硬盘(HDFS)上, 设计上是安全的(不保留 RDD血缘关系)

性能对比：

Cache性能更好, 因为是分散存储, 各个Executor并行执行, 效率高, 可以保存到内存中(占内存),更快
CheckPoint比较慢, 因为是集中存储, 涉及到网络IO, 但是存储到HDFS上更加安全(多副本)

RDD中，xxx和xxxbykey有什么区别？

groupBy 和 groupByKey

groupBy和groupByKey是在Spark中用于对数据进行分组操作的两个函数。

groupBy和groupByKey的主要区别在于它们的性能和用法：

性能：groupByKey在处理大数据集时可能会出现性能问题，因为它需要在网络中将所有具有相同键的值对进行混洗（shuffle），然后将它们组合在一起。相比之下，groupBy不需要混洗操作，因此在处理大数据集时通常比groupByKey更快。
用法：groupBy和groupByKey的语法略有不同。groupBy需要一个函数作为参数，该函数将每个元素映射到一个键，然后将具有相同键的元素分组在一起。例如，如果我们有一个包含（姓名，年龄）对的RDD，并希望按年龄对其进行分组，则可以使用以下代码：

rdd.groupBy(lambda x: x[1])

相比之下，groupByKey只需要指定一个键，然后将RDD中所有具有相同键的值对分组在一起。例如，如果我们有一个包含（姓名，年龄）对的RDD，并希望按姓名对其进行分组，则可以使用以下代码：

rdd.groupByKey().map(lambda x: (x[0], list(x[1])))

在上面的代码中，map函数用于将每个分组转换为一个（键，值）对（其中值是一个列表，包含所有具有相同键的元素）。

因此，总的来说，groupBy和groupByKey都是用于对数据进行分组操作的函数，但它们的性能和用法略有不同。在处理大数据集时，通常建议使用groupBy而不是groupByKey，以获得更好的性能。

sortBy 和 sortByKey

sortBy和sortByKey是在Spark中用于对RDD中的元素进行排序操作的两个函数。

它们之间的区别在于：

参数：sortBy需要传入一个函数来指定排序规则，而sortByKey则直接按照键进行排序。
返回值：sortBy返回排序后的元素列表，而sortByKey返回排序后的键值对列表。

下面是它们的用法示例：

使用sortBy对包含整数的RDD进行降序排序：

rdd = sc.parallelize([3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5])
sorted_rdd = rdd.sortBy(lambda x: x, ascending=False)

使用sortByKey对包含键值对的RDD按键进行升序排序：

rdd = sc.parallelize([(1, 'one'), (4, 'four'), (2, 'two'), (3, 'three')])
sorted_rdd = rdd.sortByKey()

需要注意的是，sortBy和sortByKey都会对RDD中的所有元素进行排序，因此在处理大数据集时需要注意其性能影响。如果只需要对RDD中的部分元素进行排序，可以使用takeOrdered函数，它只返回指定数量的排序后的元素。

aggregate 和 aggregateByKey

aggregate和aggregateByKey是在Spark中用于对RDD中的元素进行聚合操作的两个函数。

它们之间的区别在于：

参数：aggregate需要传入一个初始值和两个函数，其中一个函数用于在每个分区中聚合元素，另一个函数用于在所有分区的聚合结果上进行最终聚合；而aggregateByKey只需要传入一个初始值和两个函数，其中一个函数用于在每个分区中按键聚合元素，另一个函数用于在所有分区的聚合结果上进行最终聚合。
返回值：aggregate和aggregateByKey都返回最终聚合结果，但是aggregate返回的是任意类型的对象，而aggregateByKey返回的是键值对列表。

下面是它们的用法示例：

使用aggregate计算RDD中所有元素的和：

rdd = sc.parallelize([1, 2, 3, 4, 5])
sum = rdd.aggregate(0, lambda x, y: x + y, lambda x, y: x + y)

使用aggregateByKey计算包含键值对的RDD中每个键对应的值的和：

rdd = sc.parallelize([(1, 2), (2, 3), (1, 4), (3, 1), (2, 1)])
sum_by_key = rdd.aggregateByKey(0, lambda x, y: x + y, lambda x, y: x + y)

在上面的代码中，第一个参数是初始值，第二个参数是在每个分区中聚合元素的函数，第三个参数是在所有分区的聚合结果上进行最终聚合的函数。
需要注意的是，aggregate和aggregateByKey都可以用于对RDD中的元素进行聚合操作，但是它们的用法略有不同，需要根据具体的需求选择合适的函数。

combine 和 combineByKey

combine 和 combineByKey 是 Apache Spark 中用于聚合操作的两个函数。

combine 函数是一个简单的聚合函数，用于将两个值合并成一个值。它的语法如下：

def combine(self, other):
    ...

其中，self 和 other 是要合并的两个值。这个函数只能用于合并两个值，因此在使用时需要先对数据进行分组，然后在每个分组内使用 reduce 函数将所有的值合并成两个值，再使用 combine 函数将这两个值合并成一个最终的值。

combineByKey 函数则是一个更加通用的聚合函数，可以在每个分组内使用不同的合并函数进行聚合。它的语法如下：

def combineByKey(self, createCombiner, mergeValue, mergeCombiners):
    ...

其中，createCombiner 函数用于创建一个新的累加器；mergeValue 函数用于将一个新的值合并到一个累加器中；mergeCombiners 函数用于将两个累加器合并成一个。这个函数可以用于任意类型的聚合操作，例如求和、计数、平均值等。在使用时，需要先对数据进行分组，然后使用 combineByKey 函数对每个分组进行聚合。

reduce 和 reduceByKey

reduce 和 reduceByKey 都是 Apache Spark 中用于聚合操作的函数，但它们的使用方式和效果略有不同。

reduce 函数用于将一个 RDD 中的所有元素逐个合并成一个结果。具体的过程是，先将 RDD 中的第一个元素和第二个元素作为参数传递给 reduce 函数，得到一个结果；然后将这个结果和第三个元素作为参数再次传递给 reduce 函数，得到一个新的结果；以此类推，直到将 RDD 中的所有元素都合并成一个结果。reduce 函数的语法如下：

def reduce(self, f):
    ...

其中，f 是一个用于合并两个元素的函数。这个函数必须是一个二元函数，即接受两个参数并返回一个结果。

reduceByKey 函数则是用于将一个 RDD 中相同键的元素逐个合并成一个结果。在使用 reduceByKey 函数前，需要先将 RDD 中的元素按照键进行分组。具体的过程是，将 RDD 中的每个元素的键和值作为参数传递给 reduceByKey 函数，将相同键的值合并成一个结果，并将结果与键组成一个新的键值对。reduceByKey 函数的语法如下：

def reduceByKey(self, f):
    ...

其中，f 和 reduce 函数的 f 参数一样，都是用于合并两个元素的函数。不同的是，reduceByKey 函数会对相同键的值进行合并，因此要求 f 函数必须满足结合律和交换律。

下面是一个使用 reduceByKey 函数计算每个键的总和的示例代码：

rdd = sc.parallelize([(1, 2), (1, 4), (2, 1), (2, 3), (2, 5)])
sumByKey = rdd.reduceByKey(lambda x, y: x + y)

在这个例子中，我们首先创建了一个包含多个键值对的 RDD。然后使用 reduceByKey 函数对每个键进行分组，并指定了一个用于合并值的函数。这个函数将两个值相加，从而得到每个键的总和。最终，我们得到了一个包含每个键的总和的 RDD。

需要注意的是，reduceByKey 函数只能用于合并相同键的值，不能用于合并不同键的值。如果需要对整个 RDD 的所有元素进行聚合操作，应该使用 reduce 函数。另外，reduceByKey 函数的合并操作是在每个分区内进行的，因此需要保证每个键的所有值都在同一个分区内。如果数据分布不均匀，可能会导致某些键的数据被分到不同分区中，从而影响聚合结果。因此，为了更好地利用 Spark 的并行计算能力，最好在使用 reduceByKey 函数前先进行数据重分区。

word count 程序

import一定要写进去！

from pyspark import SparkConf, SparkContext

if __name__ == '__main__':
    conf = SparkConf().setAppName("wordcount").setMaster("LocaL[*]")
    
# 构建SparkContext执行环境入口对象
sc = SparkContext(conf=conf)

# 需求:做一个单词统计
fileRDD = sc.textFile("textfile")
wordsRDD = fileRDD.flatMap(lambda x: x.split(' '))

# print (wordsRDD. collect())
wordWithOneRDD = wordsRDD.map(lambda x: (x, 1))

# print (wordWithOneRDD . collect())
result = wordWithOneRDD.reduceByKey(lambda a, b: a + b).collect()
print(result)

北京地区销售商品程序默写

from pyspark import SparkConf, SparkContext
import json

if __name__ == '__main__':
    conf = SparkConf().setAppName("test").setMaster("local[*]")
    sc = SparkContext(conf=conf)

    # 读取数据文件
    file_rdd = sc.textFile("order.txt")

    # 进行rdd数据的split 按照|符号进行, 得到一个个的json数据
    jsons_rdd = file_rdd.flatMap(lambda line: line.split("|"))

    # 通过Python 内置的json库, 完成json字符串到字典对象的转换
    dict_rdd = jsons_rdd.map(lambda line: json.loads(line))

    # 过滤数据, 只保留北京的数据
    beijing_rdd = dict_rdd.filter(lambda x: x['areaName'] == "北京")
    
    #组合北京和商品类型
    result_rdd = beijing_rdd.map(lambda x: x['areaName'] + "_" + x['categories'])

    # 输出
    print(result_rdd.collect())

几个算子

groupByKey

功能:针对KV型RDD,自动按照key分组,相当于合并同类项

rdd = sc. parallelize([('a', 1),('a', 1),('b', 1),('b', 1), ('b', 1)])
grouped_rdd = rdd. groupByKey()
print(grouped_rdd.map(lambda x: (x[0],list(x[1]))) . collect())

结果:

[('b',[1, 1, 1]),('a',[1， 1])]

集合运算

union

功能：对两个 RDD 进行并集操作

from pyspark import SparkContext

# 创建 SparkContext 对象
sc = SparkContext("local", "Union Example")

# 创建两个包含整数的 RDD
data1 = sc.parallelize([1, 2, 3, 4, 5])
data2 = sc.parallelize([4, 5, 6, 7, 8])

# 使用 union 算子对两个 RDD 进行并集操作
unioned_data = data1.union(data2)

# 输出新的 RDD 中的元素
for element in unioned_data.collect():
    print(element)

# 关闭 SparkContext 对象
sc.stop()

结果：

intersection

功能：对两个 RDD 进行交集操作

from pyspark import SparkContext

# 创建 SparkContext 对象
sc = SparkContext("local", "Intersection Example")

# 创建两个包含整数的 RDD
data1 = sc.parallelize([1, 2, 3, 4, 5])
data2 = sc.parallelize([4, 5, 6, 7, 8])

# 使用 intersection 算子对两个 RDD 进行交集操作
intersected_data = data1.intersection(data2)

# 输出新的 RDD 中的元素
for element in intersected_data.collect():
    print(element)

# 关闭 SparkContext 对象
sc.stop()

结果：

4
5

subtract

功能：对两个 RDD 进行差集操作

from pyspark import SparkContext

# 创建 SparkContext 对象
sc = SparkContext("local", "Subtract Example")

# 创建两个包含整数的 RDD
data1 = sc.parallelize([1, 2, 3, 4, 5])
data2 = sc.parallelize([4, 5, 6, 7, 8])

# 使用 subtract 算子对两个 RDD 进行差集操作
subtracted_data = data1.subtract(data2)

# 输出新的 RDD 中的元素
for element in subtracted_data.collect():
    print(element)

# 关闭 SparkContext 对象
sc.stop()

结果：

1
2
3

groupBy

功能：将rdd的数据进行分组

from pyspark import SparkConf, SparkContext
if __name__='__main__':
# 0.构建Spark执行环境
conf = SparkConf() . setAppName ("create rdd") .\
	setMaster("local[*]")
sc = SparkContext (conf=conf)
rdd = sc.parallelize([1, 2, 3, 4, 5])

#分组，将数字分成偶数和奇数2个组
rdd2 = rdd. groupBy (lambda num: 'even' if (num % 2 == 0) else 'odd' )

#并rdd2的元素的value转换成list, 这样print可以输出内容.
print(rdd2. map(Lambda x: (x[0], list(x[1]))). collect())

结果：

[('even', [2，4])，('odd', [1, 3, 5])]

reduceByKey

功能：针对KV型RDD,自动按照key分组，然后根据你提供的聚合逻辑，完成组内数据(value)的聚合操作.

from pyspark import SparkContext

# 创建 SparkContext 对象
sc = SparkContext("local", "ReduceByKey Example")

# 创建一个包含键值对的 RDD
data = sc.parallelize([(1, 2), (2, 3), (2, 4), (3, 5), (3, 6)])

# 使用 reduceByKey 算子对 RDD 中的值进行聚合
reduced_data = data.reduceByKey(lambda x, y: x + y)

# 输出新的 RDD 中的元素
for element in reduced_data.collect():
    print(element)

# 关闭 SparkContext 对象
sc.stop()

结果：

(1,2)
(2,7)
(3,11)

reduce

功能：对RDD数据集按照你传入的逻辑进行聚合

from pyspark import SparkContext

# 创建 SparkContext 对象
sc = SparkContext("local", "Reduce Example")

# 创建一个包含整数的 RDD
rdd = sc.parallelize([1, 2, 3, 4, 5])

# 使用 reduce 算子对 RDD 中的元素进行累加操作
sum = rdd.reduce(lambda x, y: x + y)

# 输出累加结果
print("Sum of RDD elements is:", sum)

# 关闭 SparkContext 对象
sc.stop()

结果：

Sum of RDD elements is:15

map

功能：将RDD的数据一条条处理(处理的逻辑基于map算子中接收的处理函数),返回新的RDD

from pyspark import SparkContext

# 创建 SparkContext 对象
sc = SparkContext("local", "Map Example")

# 创建一个包含整数 1 到 5 的 RDD
data = sc.parallelize([1, 2, 3, 4, 5])

# 使用 map 算子对每个元素进行平方操作
squared = data.map(lambda x: x ** 2)

# 输出新的 RDD 中的元素
for num in squared.collect():
    print(num)

# 关闭 SparkContext 对象
sc.stop()

结果：

takeOrdered

功能：对RDD进行排序取前N个

用法：rdd.takeOrdered(参数1，参数2) -参数1：要几个数据 -参数2：对排序的数据进行更改(不会更改数据本身，只是在排序的时候换个样子) 这个方法使用安装元素自然顺序升序排序，如果你想逆序，需要用参数2来对排序的数据进行处理

from pyspark import SparkContext, SparkConf

# 创建SparkConf对象，设置应用名称和Master地址
conf = SparkConf().setAppName("takeOrdered example").setMaster("local[*]")

# 创建SparkContext对象
sc = SparkContext(conf=conf)

# 创建一个包含数字的RDD
rdd = sc.parallelize([4, 7, 1, 9, 2, 5])

# 使用takeOrdered操作选择前三个最小的元素
result = rdd.takeOrdered(3)

# 打印结果
print(result)  # [1, 2, 4]

# 使用takeOrdered操作选择前三个最大的元素
result = rdd.takeOrdered(3, key=lambda x: -x)

# 打印结果
print(result)  # [9, 7, 5]

# 关闭SparkContext对象
sc.stop()

结果：

[1,2,4]
[9,7,5]

fold

功能：和reduce一样,接受传入逻辑进行聚合，聚合是带有初始值的

from pyspark import SparkContext, SparkConf

if __name__ == '__main__':
    conf = SparkConf().setAppName("helLoworld").setMaster("LocaL[*]")
    sc = SparkContext(conf=conf)
    rdd1 = sc.parallelize(range(1, 10), 9)
    print("rdd1的各个分区：", rdd1.glom().collect())
    result = rdd1.fold(10, lambda a, b: a + b)
    print(result)

结果：

rdd1的各个分区： [[1], [2], [3], [4], [5], [6], [7], [8], [9]]

这表示rdd1被分为9个分区，每个分区包含一个元素。

接下来，fold操作将在每个分区上应用给定的函数（在这里是a + b），并将一个初始值（在这里是10）添加到每个分区的结果中。因此，每个分区的结果将分别是：

1+10=11
2+10=12
3+10=13
4+10=14
5+10=15
6+10=16
7+10=17
8+10=18
9+10=19

然后，fold操作将这些结果再次合并。由于初始值为10，所以在合并时还要加上这个值：

11 + 12 + 13 + 14 + 15 + 16 + 17 + 18 + 19 + 10 = 145

因此，最终的输出将是：

注意每个分区的数据是什么
2个分区，10个数据；9个数据，3个分区（前三个数据在第一个分区）（一定可以整除）