filtrar itens em um dicionário python onde as chaves contêm uma string específica

Sou um programador C desenvolvendo algo em python. Eu sei como fazer o seguinte em C (e, portanto, em lógica semelhante a C aplicada a python), mas estou me perguntando qual é a maneira 'Python' de fazer isso.

Eu tenho um dicionário d, e gostaria de operar em um subconjunto de itens, apenas aqueles cuja chave (string) contém uma substring específica.

ou seja, a lógica C seria:

for key in d:
    if filter_string in key:
        # do something
    else
        # do nothing, continue

Estou imaginando que a versão python seria algo como

filtered_dict = crazy_python_syntax(d, substring)
for key,value in filtered_dict.iteritems():
    # do something

Eu encontrei muitos posts aqui sobre filtragem de dicionários, mas não consegui encontrar um que envolvesse exatamente isso.

Meu dicionário não está aninhado e estou usando o python 2.7

Que tal uma compreensão de dicionário :

filtered_dict = {k:v for k,v in d.iteritems() if filter_string in k}

Se você ver, deve ser autoexplicativo, já que se parece muito bem com o inglês.

Esta sintaxe requer Python 2.7 ou superior.

No Python 3, existe apenas dict.items(), não iteritems()então você usaria:

filtered_dict = {k:v for (k,v) in d.items() if filter_string in k}

Escolha o que for mais legível e de fácil manutenção. Só porque você pode escrever em uma única linha, não significa que você deve. Sua solução existente é próxima do que eu usaria, exceto iteritems de usuário para pular a pesquisa de valor, e odeio ifs aninhados se eu puder evitá-los:

for key, val in d.iteritems():
    if filter_string not in key:
        continue
    # do something

No entanto, se você realmente deseja algo que permita a iteração por meio de um dicionário filtrado, então eu não faria o processo de duas etapas de construção do dicionário filtrado e, em seguida, iterá-lo, mas em vez disso, usaria um gerador, porque o que é mais pythônico (e incrível) do que um gerador?

Primeiro, criamos nosso gerador, e um bom design exige que o tornemos abstrato o suficiente para ser reutilizável:

# The implementation of my generator may look vaguely familiar, no?
def filter_dict(d, filter_string):
    for key, val in d.iteritems():
        if filter_string not in key:
            continue
        yield key, val

E então podemos usar o gerador para resolver seu problema de forma limpa e simples com um código simples e compreensível:

for key, val in filter_dict(d, some_string):
    # do something

Resumindo: os geradores são fantásticos.

Você pode usar a função de filtro embutida para filtrar dicionários, listas, etc. com base em condições específicas.

filtered_dict = dict(filter(lambda item: filter_str in item[0], d.items()))

A vantagem é que você pode usá-lo para diferentes estruturas de dados.

input = {"A":"a", "B":"b", "C":"c"}
output = {k:v for (k,v) in input.items() if key_satifies_condition(k)}

Jonathon deu a você uma abordagem usando compreensões de dicionário em sua resposta . Aqui está uma abordagem que lida com sua parte de fazer algo .

Se você quiser fazer algo com os valores do dicionário, não precisa de uma compreensão de dicionário:

Estou usando iteritems() já que você marcou sua pergunta compython-2.7

results = map(some_function, [(k,v) for k,v in a_dict.iteritems() if 'foo' in k])

Agora o resultado estará em uma lista com some_functionaplicada a cada par chave / valor do dicionário, que possui fooem sua chave.

Se você deseja apenas lidar com os valores e ignorar as chaves, basta alterar a compreensão da lista:

results = map(some_function, [v for k,v in a_dict.iteritems() if 'foo' in k])

some_function pode ser qualquer chamável, então um lambda também funcionaria:

results = map(lambda x: x*2, [v for k,v in a_dict.iteritems() if 'foo' in k])

A lista interna não é necessária, pois você também pode passar uma expressão geradora para mapear:

>>> map(lambda a: a[0]*a[1], ((k,v) for k,v in {2:2, 3:2}.iteritems() if k == 2))
[4]