标签: dictionary-comprehension

给定一个名为'x'的浮点列表,我想创建一个dict,使用dict理解将x [1:-1]中的每个x映射到它的邻居.我试过以下一行:

neighbours = {x1:(x0,x2) for (x0,x1,x2) in zip(x[:-2],x[1:-1],x[2:])}

但是,语法似乎无效.我究竟做错了什么？

我是Python的新手,我正在尝试解析一个文件.只有文件中的某些行包含感兴趣的数据,我想最终得到从文件中的有效匹配行解析的内容的字典.

下面的代码有效,但它有点难看,我正在尝试学习它应该如何完成,也许是理解,或者使用多行正则表达式.我正在使用Python 3.2.

file_data = open('x:\\path\\to\\file','r').readlines()
my_list = []
for line in file_data:
    # discard lines which don't match at all
    if re.search(pattern, line):
        # icky, repeating search!!
        one_tuple = re.search(pattern, line).group(3,2)
        my_list.append(one_tuple)
my_dict = dict(my_list)

你能建议更好的实施吗？

我有两个元组,详情如下:

t1 = [
['aa'],
['ff'],
['er']
]

t2 = [
['aa', 11,],
['er', 99,]
]

我想使用类似于SQL的LEFT OUTER JOIN的python方法获得如下所示的结果:

res = [
['aa', 11,],
['ff',  0,],
['er', 99,]
]

请帮我解决一下这个.

我正在尝试学习Python字典理解,我认为可以在一行中完成以下函数的功能.我无法n+1在第一个中使用range()as 或在第二个中避免使用.

是否可以使用在理解过程中自动递增的计数器,如test1()？

def test1():
    l = ['a', 'b', 'c', 'd']
    d = {}
    n = 1
    for i in l:
        d[i] = n
        n = n + 1
    return d

def test2():
    l = ['a', 'b', 'c', 'd']
    d = {}
    for n in range(len(l)):
        d[l[n]] = n + 1
    return d

我正在尝试使用python,并试图在我正在做的事情的背景下理解错误消息.

我正在玩弄理解并试图找到一个模式来创建一个包含多个输入集的列表/字典理解(假设这是可能的):

注意:这里单词输入集表示理解的输入区域.在setbuilder表示法中,python派生出它的理解[在LIST中为Y表示Y],Y是输出函数,X是变量,LIST是输入集.

假设我有以下工作代码:

from random import randint

mydict = {k: 0 for k in range(10)}
result = {randint(0,9): v + 1 for v in mydict.values()}

我不是想对它做任何特别的事情.这甚至不是有用的代码,因为它不会按预期工作.字典中的所有元素都将具有值1,而不是随机生成器指向的那些元素.我唯一的目标是有一个基础,从我开始尝试使用输入集的元组.

from random import randint

mydict = {k: 0 for k in range(10)}
result = {k: v + 1 for k, v in (randint(0,9), mydict.values())}

这个选项让我:TypeError: 'int' object is not iterable.

通过交换输入集和解压缩,我有:

result = {k: v + 1 for *v, k in (mydict.values(), randint(0,9))}

但是这个选项让我: TypeError: can …

其他语言(如Python)允许您使用字典理解来从数组中创建一个字典,但我还没有弄清楚如何在Swift中执行此操作.我以为我可以使用这样的东西,但它不能编译:

let x = ["a","b","c"]
let y = x.map( { ($0:"x") })
// expected y to be ["a":"x", "b":"x", "c":"x"]

在swift中从数组生成字典的正确方法是什么？

目标：表达的工作模拟

{k1: v1, k2: v2 for k1, k2, v1, v2 in data}

或更具体的情况{k1: v, k2: v for k1, k2, v, _ in data}

data仅迭代1 次（在给定的示例中data是 4 元组的可迭代对象）。

（以及关于列表理解的类似问题，例如[myfunc1(v1), myfunc2(v2) for v1, v2 in data]）。

我只能假设使用自己的迭代器的解决方案：

def getby(iterable_data, iterable_indexes):
    for indexed_data in iterable_data:
        for tupl in iterable_indexes:
            yield tuple(indexed_data[ind] for ind in tupl)
    raise StopIteration

工作示例：list(getby([('a', 'b', 'c'), ('d', 'e', 'f', 'g')], [(0, 1), (2, 1)]))return [('a', 'b'), ('c', 'b'), ('d', …

我绝对不是 mypy 的专家，但有一个我真的不明白的错误。

假设我有这本字典，我想解析它并通过字典理解创建另一本字典。

my_dict = {
    'type1': {
        'category1': [
            'subcategory1',
            'subcategory2',
        ],
    },
    'type2': {
        'category2': [
            'subcategory3',
        ],
        'category3': [],
    },
}

字典理解：

new_dict = {
    subcategory: {
        'category': category,
        'type': type,
    }
    for type, categories in my_dict.items()
    for category, subcategories in categories.items()
    for subcategory in subcategories
}

和预期输出：

{
    'subcategory1': {
        'category': 'category1',
        'type': 'type1'
    },
    'subcategory2': {
        'category': 'category1',
        'type': 'type1'
    },
    'subcategory3': {
        'category': 'category2',
        'type': 'type2'
    }
}

在这种情况下，mypy 会因为空而抱怨category3，但会出现'error:"object" …

我有一个包含重复的元组列表，我已经使用我在此处找到的代码将它们转换为字典：

/sf/answers/4284079411/

mylist = [(a,1),(a,2),(b,3)]    
result = {}
for i in mylist:  
   result.setdefault(i[0],[]).append(i[1])
print(result)
>>> result = {a:[1,2], b:[3]}

我记得了解到大多数 for 循环都可以重写为推导式，所以我想练习，但在过去的一个小时里我未能完成一项工作。

我读了这个：https : //stackoverflow.com/a/56011919/2415706，现在我还没有找到另一个这样做的库，但我也不确定我想写的这种理解是否是一个坏主意因为 append 会改变事物。

如果可能的话，我正在寻找对嵌套数据结构使用推导式的替代方法，或使用嵌套列表推导式的方法。

在没有理解的情况下，使用嵌套循环生成项目列表的工作方式如下：

combos = []
for a in iterable:
    for b in valid_posibilities(a):
        combos.append((a,b))

将其转换为理解保留了循环的顺序，这使得使用多行很好：

combos = [
    (a,b)
    for a in iterable
        for b in valid_posibilities(a)
    ]

但是，这会创建一个列表。如果我想要一些代码来生成嵌套数据结构，那么我会使用这样的东西：

# same as above but instead of list of (a,b) tuples,
# I want a dictionary of {a:[b]} structure
combos_map = {}
for a in iterable:
    options = []
    for b in valid_posibilities(a):
        options.append(b)
    combos_map[a] = options

（以下代码段具有使用普通列表的等效代码，适用于那些之前没有看过字典理解并且第一次看到它以奇怪的方式嵌套的人很难理解）

combos = []
for a in iterable:
    for b in valid_posibilities(a):
        combos.append((a,b))

现在将其转换为理解，我们得到： …