Qual é a sintaxe preferida para inicializar um dict: literais entre chaves {} ou a função dict ()?

Estou fazendo algum esforço para aprender Python e prestando muita atenção aos padrões comuns de codificação. Isso pode parecer uma pergunta inútil, mas estou tentando me concentrar nas melhores práticas à medida que aprendo, para não precisar desaprender nenhum hábito "ruim".

Eu vejo dois métodos comuns para inicializar um ditado:

a = {
    'a': 'value',
    'another': 'value',
}

b = dict( 
    a='value',
    another='value',
)

Qual é considerado "mais pitônico"? Qual você usa? Por quê?

Aparelhos encaracolados. Passando argumentos de palavra-chave paradict() , embora funcione perfeitamente em muitos cenários, só pode inicializar um mapa se as chaves forem identificadores Python válidos.

Isso funciona:

a = {'import': 'trade', 1: 7.8}

a = dict({'import': 'trade', 1: 7.8})

Isso não vai funcionar:

a =                  dict(import='trade', 1=7.8)
>> SyntaxError: invalid syntax  ^

O primeiro aparelho, encaracolado. Caso contrário, você terá problemas de consistência com chaves com caracteres estranhos, como =.

# Works fine.
a = {
    'a': 'value',
    'b=c': 'value',
}

# Eeep! Breaks if trying to be consistent.
b = dict( 
    a='value',
    b=c='value',
)

A primeira versão é preferível:

• Funciona para todos os tipos de chaves, para que você possa, por exemplo, dizer {1: 'one', 2: 'two'}. A segunda variante funciona apenas para (algumas) chaves de sequência. Usar diferentes tipos de sintaxe, dependendo do tipo das chaves, seria uma inconsistência desnecessária.

• É mais rápido:

  $ python -m timeit "dict(a='value', another='value')"
  1000000 loops, best of 3: 0.79 usec per loop
  $ python -m timeit "{'a': 'value','another': 'value'}"
  1000000 loops, best of 3: 0.305 usec per loop

• Se a sintaxe especial para literais de dicionário não fosse usada, provavelmente não existiria.

Eu acho que a primeira opção é melhor porque você acessará os valores como um ['a'] ou um ['another']. As chaves do seu dicionário são cadeias de caracteres e não há razão para fingir que não são. Para mim, a sintaxe da palavra-chave parece inteligente a princípio, mas obscura em uma segunda olhada. Isso só faz sentido para mim se você estiver trabalhando __dict__e as palavras-chave se tornarem atributos mais tarde, algo assim.

Para sua informação, caso você precise adicionar atributos ao seu dicionário (itens anexados ao dicionário, mas que não são uma das chaves), será necessário o segundo formulário. Nesse caso, você pode inicializar seu dicionário com chaves com caracteres arbitrários, um de cada vez, da seguinte forma:

    class mydict(dict): pass
    a = mydict()        
    a["b=c"] = 'value'
    a.test = False

Às vezes dict()é uma boa escolha:

a=dict(zip(['Mon','Tue','Wed','Thu','Fri'], [x for x in range(1, 6)]))

mydict=dict(zip(['mon','tue','wed','thu','fri','sat','sun'],

[random.randint (0,100) para x no intervalo (0,7)]))

Eu quase sempre uso suspensórios; no entanto, em alguns casos em que estou escrevendo testes, faço a compactação / descompactação de palavras-chave e, nesses casos, dict () é muito mais sustentável, pois não preciso alterar:

a=1,
b=2,

para:

'a': 1,
'b': 2,

Também ajuda em algumas circunstâncias em que acho que posso transformá-lo em uma instância nomeada de casal ou classe posteriormente.

Na implementação em si, devido à minha obsessão com a otimização, e quando não vejo um benefício particularmente grande de manutenção, sempre farei favor de chaves.

Nos testes e na implementação, eu nunca usaria dict () se houver uma chance de que as chaves adicionadas então, ou no futuro, sejam:

• Nem sempre seja uma string
• Não contêm apenas dígitos, letras ASCII e sublinhados
• Comece com um número inteiro ( dict(1foo=2)gera um SyntaxError)