标签: tuples

什么是Pythonic方法来实现以下目标？

# Original lists:

list_a = [1, 2, 3, 4]
list_b = [5, 6, 7, 8]

# List of tuples from 'list_a' and 'list_b':

list_c = [(1,5), (2,6), (3,7), (4,8)]

每个成员list_c都是一个元组,其第一个成员来自list_a,而第二个来自list_b.

我正在学习Python并创建数据库连接.在尝试添加到数据库时,我正在考虑从信息中创建元组,然后将它们添加到数据库中.

我在做什么:我从用户那里获取信息并将其存储在变量中.我可以将这些变量添加到元组中吗？你能帮我解释一下语法吗？

如果有一种有效的方法,请分享......

编辑 让我编辑一下这个问题...我只需要元组就可以在数据库中输入信息.将信息添加到数据库后,我应该删除元组吗？我的意思是我不再需要元组了.

假设我有一个Python函数,它在元组中返回多个值:

def func():
    return 1, 2

是否有一种很好的方法可以忽略其中一个结果,而不仅仅是分配给一个临时变量？如果我只对第一个值感兴趣,是否有比这更好的方法:

x, temp = func()

我喜欢元组.它们允许您快速将相关信息分组在一起,而无需为其编写结构或类.这在重构非常本地化的代码时非常有用.

然而,初始化它们的列表似乎有点多余.

var tupleList = new List<Tuple<int, string>>
{
    Tuple.Create( 1, "cow" ),
    Tuple.Create( 5, "chickens" ),
    Tuple.Create( 1, "airplane" )
};

有没有更好的方法？我希望得到一个类似于字典初始化器的解决方案.

Dictionary<int, string> students = new Dictionary<int, string>()
{
    { 111, "bleh" },
    { 112, "bloeh" },
    { 113, "blah" }
};

我们不能使用类似的语法吗？

可能重复:
Python中的转置/解压缩功能

我有一个元组列表,我想将这个列表解压缩到两个独立的列表中.我正在寻找Python中的一些标准化操作.

>>> l = [(1,2), (3,4), (8,9)]
>>> f_xxx (l)
[ [1, 3, 8], [2, 4, 9] ] 

我正在寻找一种简洁和pythonic的方法来实现这一目标.

基本上,我正在寻找zip()函数的逆运算.

在实例化和检索元素时,元组和列表之间是否存在性能差异？

有没有办法使用Tuple类,但提供其中的项目名称？

例如:

public Tuple<int, int, int int> GetOrderRelatedIds()

返回OrderGroupId,OrderTypeId,OrderSubTypeId和OrderRequirementId的id.

让我的方法的用户知道哪个是哪个是很好的.(当你调用方法时,结果是result.Item1,result.Item2,result.Item3,result.Item4.不清楚哪一个是哪个.)

(我知道我可以创建一个类来保存所有这些ID,但是这些ID已经拥有了他们自己的类,并为这个方法的返回值创建一个类看起来很傻.)

如果元组是不可变的,那为什么它可以包含可变项？

这似乎是一个矛盾,当一个可变项如列表被修改时,它所属的元组维持不可变.

我目前正在使用平铺地图为pygame中的游戏制作地图编辑器.该级别由以下结构中的块构建(尽管更大):

level1 = (
         (1,1,1,1,1,1)
         (1,0,0,0,0,1)
         (1,0,0,0,0,1)
         (1,0,0,0,0,1)
         (1,0,0,0,0,1)
         (1,1,1,1,1,1))

其中"1"是一个墙,而"0"是一个空的空间.

以下代码基本上是处理块类型更改的代码:

clicked = pygame.mouse.get_pressed()
if clicked[0] == 1:
    currLevel[((mousey+cameraY)/60)][((mousex+cameraX)/60)] = 1

但由于级别存储在元组中,我无法更改不同块的值.如何以简单的方式更改关卡中的不同值？

随着.net 4 中的Tuple类的增加,我一直试图决定在我的设计中使用它们是否是一个糟糕的选择.我看到它的方式,一个元组可以是编写结果类的快捷方式(我相信还有其他用途).

所以这:

public class ResultType
{
    public string StringValue { get; set; }
    public int IntValue { get; set; }
}

public ResultType GetAClassedValue()
{
    //..Do Some Stuff
    ResultType result = new ResultType { StringValue = "A String", IntValue = 2 };
    return result;
}

相当于:

public Tuple<string, int> GetATupledValue()
{
    //...Do Some stuff
    Tuple<string, int> result = new Tuple<string, int>("A String", 2);
    return result;
}

因此,抛开我错过了元组点的可能性,是一个Tuple设计选择不好的例子吗？对我来说,它似乎不那么混乱,但不像自我记录和干净.这意味着对于类型ResultType,后面很清楚类的每个部分意味着什么,但你有额外的代码来维护.随着Tuple<string, int>您将需要查找并弄清每一个 …