making - work with dictionary in python




Crie um dicionário com compreensão de lista em Python (8)

Crie um dicionário com compreensão de lista em Python

Eu gosto da sintaxe de compreensão de lista do Python.

Pode ser usado para criar dicionários também? Por exemplo, iterando sobre pares de chaves e valores:

mydict = {(k,v) for (k,v) in blah blah blah}

Assumindo blah blah blah é um iterável de duas tuplas - você está tão perto. Vamos criar alguns "blahs" assim:

blahs = [('blah0', 'blah'), ('blah1', 'blah'), ('blah2', 'blah'), ('blah3', 'blah')]

Sintaxe de compreensão de ditado:

Agora a sintaxe aqui é a parte do mapeamento. O que torna isso uma compreensão de dict invés de uma compreensão de set (que é o que seu pseudo-código se aproxima) é o cólon, como abaixo:

mydict = {k: v for k, v in blahs}

E agora quando você faz:

>>> mydict
{'blah0': 'blah', 'blah1': 'blah', 'blah3': 'blah', 'blah2': 'blah'}

Adicionando um filtro:

Assim como as compreensões de lista, você pode adicionar uma parte do filtro ao final:

>>> mydict = {k: v for k, v in blahs if not int(k[-1]) % 2}
>>> mydict
{'blah0': 'blah', 'blah2': 'blah'}

Aqui testamos se o último caractere é divisível por 2.

Eu gosto da sintaxe de compreensão de lista do Python.

Pode ser usado para criar dicionários também? Por exemplo, iterando sobre pares de chaves e valores:

mydict = {(k,v) for (k,v) in blah blah blah}  # doesn't work

Apenas para lançar outro exemplo. Imagine que você tenha a seguinte lista:

nums = [4,2,2,1,3]

e você quer transformá-lo em um dict onde a chave é o índice e o valor é o elemento na lista. Você pode fazer isso com a seguinte linha de código:

{index:nums[index] for index in range(0,len(nums))}

De fato, você não precisa nem iterar sobre o iterável se ele já compreende algum tipo de mapeamento, o construtor dict o faz graciosamente por você:

>>> ts = [(1, 2), (3, 4), (5, 6)]
>>> dict(ts)
{1: 2, 3: 4, 5: 6}
>>> gen = ((i, i+1) for i in range(1, 6, 2))
>>> gen
<generator object <genexpr> at 0xb7201c5c>
>>> dict(gen)
{1: 2, 3: 4, 5: 6}

No Python 2.6 e anterior, o construtor dict pode receber um iterável de pares chave / valor:

d = dict((key, value) for (key, value) in iterable)

Do Python 2.7 e 3 em diante, você pode simplesmente usar a sintaxe de compreensão de dit diretamente:

d = {key: value for (key, value) in iterable}

É claro, você pode usar o iterável da maneira que quiser (tuplas e listas literais, compreensões de geradores, compreensões de lista, funções geradoras, composição funcional ... parecerão criativas) desde que cada elemento seja um iterável de dois elementos:

d = {value: foo(value) for value in sequence if bar(value)}

def key_value_gen(k):
   yield chr(k+65)
   yield chr((k+13)%26+65)
d = dict(map(key_value_gen, range(26)))

No Python 3 e no Python 2.7+, as compreensões de dicionário se parecem com as abaixo:

d = {k:v for k, v in iterable}

Para o Python 2.6 ou anterior, veja a resposta do fortran .


Para adicionar à resposta de key_list , se você quiser iterar sobre uma lista de chaves key_list , bem como uma lista de valores value_list :

d = dict((key, value) for (key, value) in zip(key_list, value_list))

ou

d = {(key, value) for (key, value) in zip(key_list, value_list)}

Para a versão do python <2.7, faça o seguinte:

d = dict((i,True) for i in [1,2,3])

Para a versão python> = 2.7, faça o seguinte:

d = {i: True for i in [1,2,3]}

>>> {k: v**3 for (k, v) in zip(string.ascii_lowercase, range(26))}

Python suporta dict compreensões, que permitem expressar a criação de dicionários em tempo de execução usando uma sintaxe concisa similar.

Uma compreensão do dicionário assume o formato {chave: valor para (chave, valor) em iterável}. Esta sintaxe foi introduzida no Python 3 e backported até o Python 2.7, então você deve ser capaz de usá-la independentemente da versão do Python que você tenha instalado.

Um exemplo canônico é pegar duas listas e criar um dicionário onde o item em cada posição na primeira lista se torna uma chave e o item na posição correspondente na segunda lista se torna o valor.

A função zip usada dentro dessa compreensão retorna um iterador de tuplas, onde cada elemento na tupla é obtido da mesma posição em cada um dos iteráveis ​​de entrada. No exemplo acima, o iterador retornado contém as tuplas (“a”, 1), (“b”, 2) etc.

Saída:

{'i': 512, 'e': 64, 'o': 2744, 'h': 343, 'l': 1331, 's: 5832,' b ': 1,' w ': 10648,' c ': 8,' x ': 12167,' y ': 13824,' t ': 6859,' p ': 3375,' d ': 27,' j ': 729,' a ': 0,' z ' : 15625, 'f': 125, 'q': 4096, 'u': 8000, 'n': 2197, 'm': 1728, 'r': 4913, 'k': 1000, 'g': 216 , 'v': 9261}







dict-comprehension