Python 了解Spark for RDDs中的lambda函数输入

我正在上一门关于Spark的课程，我有点困惑

下面是代码。我知道第1行正在创建元组（word，1）。然后第2行是按字分组并对计数求和

我不明白的是，第2行的X和Y是什么。我们只有一个数值输入到lamda函数，这是wordcounts中的count列（所有的1），为什么是y

wordCounts = words.map(lambda x: (x, 1)) #outputs [('self', 1), ('employment', 1), ('building', 1)...
wordCounts2 = wordCounts.reduceByKey(lambda x, y: x + y) # outputs [('self', 111), ('an', 178), ('internet', 26)

wordCounts2 = wordCounts.reduceByKey(lambda x, y: x + y) # outputs [('self', 111), ('an', 178), ('internet', 26)

然后，我们有一段代码，它直接跟在后面。我知道它会对RDD进行排序。为了证实我的理解，X[1]是单词，X[2]是总数吗？我想是的，但我不是100%

很抱歉问了这么多愚蠢的问题，但我找不到一个清楚的解释

wordCountsSorted = wordCounts2.map(lambda x: (x[1], x[0])).sortByKey()

---

x和y是临时变量，就像java中的for循环一样。因此，您可以有任何变量名。当您执行排序时，它会按键对结果进行排序。

希望这有帮助

第一个λ-λx：（x，1） 在最初的步骤中，输入将如下所示

['self', 'employment', 'building',
'self', 'employment', 'building',
'self', 'employment', 'building', 
'self', 'employment' ]

这里，您的第一个lambda函数获取上面列表中的每一项，并在相应位置转换为下面的项

data = [('self', 1), ('employment', 1), ('building', 1),
('self', 1), ('employment', 1), ('building', 1),
('self', 1), ('employment', 1), ('building', 1),
('self', 1), ('employment', 1) ]

此lambda如下所示

def convert_word_to_key_value(word):
    return (word, 1)

例如：

'self'

转换为

（'self'，

）`

这个lambda的目标是将每个单词转换为（键、值）元组

第二个λ-λx，y:x+y 此lambda的目标是对单词进行分组，即使用相同的键累积值

请注意，我们使用的是

reduceByKey

，这意味着减少具有相同键名的值。因此，

x

和

y

将代表两个项目的键值，并且此操作仅对具有相同

键的项目发生

例如，如果有两个元组，如下所示

（'self'，1），（'self'，1）
将变成
（'self'，2）

第二个例子

（'self'，2），（'self'，1）
将变成
（'self'，1）

第三个例子

（'self'，12），（'self'，15）
将变成
（'self'，27）

你问题的最后一部分
首先，在这里您正在交换密钥和值

（键，值）
变为
（值，键）

示例（例如）

（'self'，1231）
变成
（1231，'self'）

现在，您将根据键对项目进行排序，采用新格式，即
1231
或该键的分组值（即词频）。
1。为什么是x和y？
创建一个键值对，如（word，1）

现在你的键是单词，值是1

当您执行reduceByKey时，它会将同一个键的所有值相加

reduceByKey（lambda x，y:x+y）
将通过作为第一个元素的键对rdd元素进行分组，并将值相加。在这个特定的语句中，x是一个元素，它累加RDD的所有值，y是同一关键字/字的其他元素。通过为同一单词或同一键添加值来减少值。
可能看起来像：

# [('This', 1), ('is', 2), ('a', 3), ('random', 1), ('sample.', 2), ('And', 2), ('world', 1), ('count', 2), ('word', 1), ('sample,', 1), ('that', 1), ('it', 1)]

2.让我们来分析下一个关于
wordcountsorted=wordCounts2.map（lambda x:（x[1]，x[0]）的问题。sortByKey（）
下面一行将交换元组的元素。基本上，位置0处的元素将移动到位置1，位置1处的元素将移动到位置0

reversed\u tup=wordCounts2.map（lambda x:（x[1]，x[0]））

输出将看起来像

# [(1, 'This'), (2, 'is'), (3, 'a'), (1, 'random'), (2, 'sample.'), (2, 'And'), (1, 'world'), (2, 'count'), (1, 'word'), (1, 'sample,'), (1, 'that'), (1, 'it')]

现在，当您执行
sortByKey
时，这些元组将使用如上所述的键（元组的第一个元素）进行排序。因此，rdd将按照单词的计数进行排序

wordCountsSorted = reversed_tup.sortByKey()
wordCountsSorted.collect()
# [(1, 'This'), (1, 'random'), (1, 'world'), (1, 'word'), (1, 'sample,'), (1, 'that'), (1, 'it'), (2, 'is'), (2, 'sample.'), (2, 'And'), (2, 'count'), (3, 'a')]

@基基1222

@Sampath和@pissal为您的所有问题提供了详细的解释，我认为我们缺少一个关键点，即一个（x）参数的作用类似于累加器

我不明白的是，第2行的X和Y是什么。我们只有一个数值输入到lamda函数，这是wordcounts中的count列（所有的1），为什么是y

wordCounts = words.map(lambda x: (x, 1)) #outputs [('self', 1), ('employment', 1), ('building', 1)...
wordCounts2 = wordCounts.reduceByKey(lambda x, y: x + y) # outputs [('self', 111), ('an', 178), ('internet', 26)

wordCounts2 = wordCounts.reduceByKey(lambda x, y: x + y) # outputs [('self', 111), ('an', 178), ('internet', 26)

在这里，你可以把x看作累加器，把y看作计数。累加器初始化为0，并与每个键的计数相加，生成该键的最终计数

[（'a'，1），（'b'，1），（'c'，1），（'b'，1），（'a'，1），（'a'，1）]

应用
reduceByKey后（lambda acum，count:acum+count）

您可以这样考虑迭代

#1 : accum = 0 , count = 1 =>(returns) 1
#2 : accum = 1, count = 1  => 2
#3 : accum = 2, count = 1  => 3

希望这有帮助
非常感谢。所以我可以考虑x+y成分对于每个x和y是什么样的？是的，我认为你是正确的。如果我可以建议的话，请探索（理解+实践）python lambda函数10-25分钟，以获得它的完整窍门。谢谢@pissall-所以我想我理解它就像每个X和Y一样，所以我们在减少时得到键值对？是的。减少后，对于同一个单词，您将对所有值求和。@kikee1222。随时与我联系以了解问题