如果您对如何过滤一组感兴趣，那么本文将是一篇不错的选择，我们将为您详在本文中，您将会了解到关于如何过滤一组的详细内容，我们还将为您解答int，str元组，以仅在第一个元素中返回具有最小值的元组？的相关

如果您对如何过滤一组感兴趣，那么本文将是一篇不错的选择，我们将为您详在本文中，您将会了解到关于如何过滤一组的详细内容，我们还将为您解答int，str元组，以仅在第一个元素中返回具有最小值的元组？的相关问题，并且为您提供关于.net – 为什么C#4.0中的元组中只有七个元素,第八个是另一个元组？、C++以k个元素为一组，从n个元素中取r个元素的排列、PostgreSQL psycopg2返回一个字符串元组而不是元组元组？、Python - 将元组列表中的第一个元素按第二个元素进行分组的有价值信息。

• 如何过滤一组（int，str）元组，以仅在第一个元素中返回具有最小值的元组？
• .net – 为什么C#4.0中的元组中只有七个元素,第八个是另一个元组？
• C++以k个元素为一组，从n个元素中取r个元素的排列
• PostgreSQL psycopg2返回一个字符串元组而不是元组元组？
• Python - 将元组列表中的第一个元素按第二个元素进行分组

如何过滤一组（int，str）元组，以仅在第一个元素中返回具有最小值的元组？

假设我有一组用“分数”表示URL的元组：

{(0.75, ''http://www.foo.com''), (0.33, ''http://www.bar.com''), (0.5,''http://www.foo.com''), (0.66, ''http://www.bar.com'')}。

对于我来说，筛选出重复的URL，仅返回分数最低的URL的简洁方法是什么？也就是说，从上面的示例集合中，我想获得以下集合，其中每个URL仅出现一次，并且对应分数比原始集合最低：

{(0.5, ''http://www.foo.com''),(0.33, ''http://www.bar.com'')}

我想出了以下解决方案：

from collections import defaultdictseen = defaultdict(lambda:1)for score, url in s:    if score < seen[url]:        seen[url] = scorefiltered = {(v,k) for k,v in seen.items()}

…但是我觉得可能有一些更简单，更有效的方法来执行此操作，而无需使用中介指令来跟踪max元素，然后从中重新生成该集合。按第一个元素的最小值/最大值过滤一组元组的最佳方法是什么？

答案1

您已经实现了我能想到的最简单的方法。我唯一要进行的更改就是对循环进行修改-正在使用更简洁的版本min。

seen = defaultdict(lambda: 1)  # `lambda: float(''inf'')` if scores can be > 1for score, url in s:    seen[url] = min(seen[url], score){(v,k) for k,v in seen.items()}# {(0.33, ''http://www.bar.com''), (0.5, ''http://www.foo.com'')}

如我所说，如果您真的想要一个更短的解决方案，这不是最简单的方法，但是它是一个简单的方法。大部分挑战是交换URL和分数，以便在删除重复项时可以将URL用作密钥。不用说，排序是这里的前提条件（这就是为什么我不喜欢上面的解决方案的原因）。

{(v, k) for k, v in dict(sorted(((v, k) for k, v in s), reverse=True)).items()}# {(0.33, ''http://www.bar.com''), (0.5, ''http://www.foo.com'')}

如果s看起来像这样，此解决方案将变得更短：

s2 = {(v,k) for k, v in s}s2 # {(''http://www.bar.com'', 0.33), (''http://www.bar.com'', 0.66), ...}

您只需要这样做

list(dict(sorted(s2, reverse=True)).items())# [(''http://www.foo.com'', 0.5), (''http://www.bar.com'', 0.33)]

.net – 为什么C#4.0中的元组中只有七个元素,第八个是另一个元组？

C++以k个元素为一组，从n个元素中取r个元素的排列

给定n、r、k，现在我们必须找出如何从n中选择r个物品，以便特定的k个物品总是一起出现，例如。

Input : n = 8, r = 5, k = 2

Output : 960


Input : n = 6, r = 2, k = 2

Output : 2

我们需要一些知识来解决这个问题，因为这个问题要求我们找到n和r的排列，使得k个物体聚在一起。

解决方法

我们需要为这个问题制定一个公式，这将给我们答案。

例子

#include <bits/stdc++.h>
using namespace std;
int fact(int n){ // function to calculate factorial of a number
    if(n <= 1)
        return 1;
    return n * fact(n-1);
}
int npr(int n, int r){ // finding permutation
    int pnr = fact(n) / fact(n - r);
    return pnr;
}
int countPermutations(int n, int r, int k){ // the formula that we came up with
    return fact(k) * (r - k + 1) * npr(n - k, r - k);
}
int main(){
    int n = 8;
    int r = 5;
    int k = 2;
    cout << countPermutations(n, r, k);
    return 0;
}

输出

960

上述代码的解释

在上面的方法中，我们尝试设计我们的公式来计算这个问题的答案，我们设计的公式是 (k!) * (r - k + 1) * P(n-k, r-k)。 （ P(x, y) 是从 x 中选择 y 的排列数），因此我们提出公式，并计算答案。

立即学习“C++免费学习笔记（深入）”；

结论

在本教程中，我们解决一个问题，找到一次将 r 个事物与 k 个事物放在一起的排列。我们还学习了该问题的C++程序以及解决该问题的完整方法（Normal）。

我们可以用其他语言编写相同的程序，例如C、java、python等语言。我们希望本教程对您有所帮助。

以上就是C++以k个元素为一组，从n个元素中取r个元素的排列的详细内容，更多请关注php中文网其它相关文章！

PostgreSQL psycopg2返回一个字符串元组而不是元组元组？

def queryFeeds(db):
   sql = """SELECT ngo.n_id,Feeds.url FROM ngo 
    JOIN Feeds ON ngo.n_id = Feeds.n_id;"""

   db.c.execute(sql)

   Feeds = db.c.fetchall()

   return Feeds

Feeds[0]
('(277,http://resultsuk.wordpress.com/Feed)',)

Feeds[0][0]
'(277,http://resultsuk.wordpress.com/Feed)'

type(Feeds[0][0])
<type 'str'>

Feeds[0][0][0:10]
'(277,http:'

SELECT (ngo.n_id,Feeds.url)

SELECT ngo.n_id,Feeds.url

Python - 将元组列表中的第一个元素按第二个元素进行分组

在 Python 中，可以使用各种方法根据第二个元素的值对元组列表中的元素进行分组，例如使用字典或使用 itertools.groupby() 方法以及使用集合中的 defaultdict。元组列表中的第一元素按第二元素分组意味着具有相同第二元素的元组可以被分组为单个元素组。在本文中，我们将讨论如何实现这些方法，以便我们能够轻松地根据元组列表中的第二个元素对第一个元素进行分组。

方法一：使用字典

此方法涉及使用字典对元素进行分组。这种方法利用字典的键值对来存储第一个元素，并使用第二个元素作为键。

语法

dict_name[key]

这里，方括号表示法用于将值分配给字典中的特定键。如果键已经存在，则将该值附加到与该键关联的列表中；否则，将创建一个新的键值对。

示例

在下面的示例中，我们首先初始化一个空字典 grouped_data。然后，对于数据列表中的每个元组，我们提取第二个元素作为键（item[1]），并提取第一个元素作为值（item[0]）。然后，我们检查该键是否已存在于 grouped_data 中。如果是，我们将该值附加到与该键关联的现有值列表中。否则，我们创建一个新的键值对，其中键是第二个元素，值是包含第一个元素的新列表。最后，我们迭代 grouped_data 字典并打印每个键及其相应的值。

立即学习“Python免费学习笔记（深入）”；

点击下载“修复打印机驱动工具”；

# Sample tuple list
data = [(''Apple'', ''Fruit''), (''Banana'', ''Fruit''), (''Carrot'', ''Vegetable''), (''Potato'', ''Vegetable'')]

# Grouping elements using a dictionary
grouped_data = {}
for item in data:
    key = item[1]
    value = item[0]
    if key in grouped_data:
        grouped_data[key].append(value)
    else:
        grouped_data[key] = [value]

# Printing the grouped data
for key, values in grouped_data.items():
    print(key, ":", values)

输出

Fruit : [''Apple'', ''Banana'']
Vegetable : [''Carrot'', ''Potato'']

方法2：使用itertools.groupby()

itertools.groupby() 函数提供了另一种根据特定标准对元素进行分组的有效方法。该方法要求输入数据根据第二个元素进行排序。

语法

   groups[key]

这里，itertools 模块中的 groupby() 函数迭代 groupby 对象。该函数返回键和一组具有相同值的连续项。然后使用键和组在组字典中创建键值对，其中键是唯一值，值是分组项的列表。

示例

在下面的示例中，我们从 itertools 模块导入 groupby() 函数。 groupby() 函数要求根据分组键对输入数据进行排序。因此，我们使用sorted()函数对数据列表进行排序，并提供一个lambda函数作为关键参数来指定基于第二个元素（x[1]）的排序。然后，我们迭代 groupby() 函数的输出，它返回一个键和一个分组元素的迭代器。对于每个组，我们提取密钥并创建相应第一个元素 (item[0]) 的列表。

from itertools import groupby

# Sample tuple list
data = [(''Apple'', ''Fruit''), (''Banana'', ''Fruit''), (''Carrot'', ''Vegetable''), (''Potato'', ''Vegetable'')]

# Sorting the data based on the second element
sorted_data = sorted(data, key=lambda x: x[1])

# Grouping elements using itertools.groupby()
grouped_data = {}
for key, group in groupby(sorted_data, key=lambda x: x[1]):
    grouped_data[key] = [item[0] for item in group]

# Printing the grouped data
for key, values in grouped_data.items():
    print(key, ":", values)

输出

Fruit : [''Apple'', ''Banana'']
Vegetable : [''Carrot'', ''Potato'']

方法3：使用集合中的defaultdict

集合模块中的 defaultdict 类提供了一种对元组列表中的元素进行分组的便捷方法。它会自动创建一个新列表作为每个键的默认值，从而简化分组过程。

语法

groups[item].append(item)

这里，语法使用集合模块中的 defaultdict() 函数初始化一个名为 groups 的 defaultdict 对象，其默认值为空列表。第二行代码使用键（项目）来访问组字典中与该键关联的列表，并将该项目附加到列表中。

示例

在下面的示例中，我们从集合模块导入defaultdict类。初始化 grouped_data 字典时，我们使用 defaultdict(list) 将默认值设置为空列表。然后，我们迭代数据列表，提取第二个元素作为键 (item[1])，提取第一个元素作为值 (item[0])。通过使用defaultdict，我们可以直接将值附加到与该键关联的列表中。

from collections import defaultdict

# Sample tuple list
data = [(''Apple'', ''Fruit''), (''Banana'', ''Fruit''), (''Carrot'', ''Vegetable''), (''Potato'', ''Vegetable'')]

# Grouping elements using defaultdict
grouped_data = defaultdict(list)
for item in data:
    grouped_data[item[1]].append(item[0])

# Printing the grouped data
for key, values in grouped_data.items():
    print(key, ":", values)

输出

Fruit : [''Apple'', ''Banana'']
Vegetable : [''Carrot'', ''Potato'']

结论

在本文中，我们讨论了如何使用 Python 中的不同方法对元组列表中的第一个元素和第二个元素进行分组。通过使用字典，我们可以轻松地存储和访问分组数据。 itertools.groupby() 函数提供了有效的解决方案，但需要对数据进行排序。此外，defaultdict 类通过自动创建列表作为每个键的默认值来简化分组过程。

以上就是Python - 将元组列表中的第一个元素按第二个元素进行分组的详细内容，更多请关注php中文网其它相关文章！

关于如何过滤一组和int，str元组，以仅在第一个元素中返回具有最小值的元组？的问题我们已经讲解完毕，感谢您的阅读，如果还想了解更多关于.net – 为什么C#4.0中的元组中只有七个元素,第八个是另一个元组？、C++以k个元素为一组，从n个元素中取r个元素的排列、PostgreSQL psycopg2返回一个字符串元组而不是元组元组？、Python - 将元组列表中的第一个元素按第二个元素进行分组等相关内容，可以在本站寻找。