Quando usar um dicionário vs tupla em Python

O exemplo específico em mente é uma lista de nomes de arquivos e seus tamanhos. Não consigo decidir se cada item da lista deve ter o formato {"filename": "blabla", "size": 123}ou apenas ("blabla", 123). Um dicionário me parece mais lógico, porque acessar o tamanho, por exemplo, file["size"]é mais explicativo do que file[1]... mas eu realmente não tenho certeza. Pensamentos?

Eu usaria um namedtuple:

from collections import namedtuple
Filesize = namedtuple('Filesize', 'filename size')
file = Filesize(filename="blabla", size=123)

Agora você pode usar file.sizee file.filenameem seu programa, que é a forma mais legível de IMHO. O Note namedtuplecria objetos imutáveis, como tuplas, e eles são mais leves que os dicionários, conforme descrito aqui .

{"filename": "blabla", "size": 123} ou apenas ("blabla", 123)

Essa é a questão antiga: codificar seu formato / esquema dentro ou fora da banda.

Você troca alguma memória para obter a legibilidade e portabilidade resultantes da expressão correta do formato dos dados. Se você não fizer isso, o conhecimento de que o primeiro campo é o nome do arquivo e o segundo é o tamanho deve ser mantido em outro lugar. Isso economiza memória, mas custa legibilidade e portabilidade. O que vai custar mais dinheiro à sua empresa?

Quanto à questão imutável, lembre-se de imutável não significa inútil diante da mudança. Isso significa que precisamos pegar mais memória, fazer a alteração em uma cópia e usar a nova cópia. Isso não é gratuito, mas muitas vezes não é um disjuntor. Usamos cordas imutáveis ​​para mudar as coisas o tempo todo.

Outra consideração é a extensibilidade. Quando você armazena dados apenas em posição, sem codificar informações de formato, é condenado a apenas uma herança, o que realmente não passa de prática de concatenar campos adicionais após os campos estabelecidos. Posso definir um terceiro campo para ser a data de criação e ainda ser compatível com o seu formato, pois defino primeiro e segundo da mesma maneira.

No entanto, o que não posso fazer é reunir dois formatos definidos independentemente, com alguns campos sobrepostos, outros não, armazená-los em um formato e ser útil para coisas que só sabem sobre um ou outro formato.

Para fazer isso, preciso codificar as informações de formato desde o início. Eu preciso dizer "este campo é o nome do arquivo". Isso permite herança múltipla.

Você provavelmente está acostumado a herança apenas sendo expressa no contexto de objetos, mas as mesmas idéias funcionam para formatos de dados porque, bem, os objetos são armazenados em formatos de dados. É exatamente o mesmo problema.

Portanto, use o que achar mais provável. Busco flexibilidade, a menos que consiga apontar um bom motivo para não fazê-lo.

Eu usaria uma classe com duas propriedades. file.sizeé melhor que um file[1]ou outro file["size"].

Simples é melhor que complexo.

Os nomes de arquivo são exclusivos? Nesse caso, você pode descartar completamente a lista e usar apenas um dicionário puro para todos os arquivos. por exemplo (um site hipotético)

{ 
  "/index.html" : 5467,
  "/about.html" : 3425,
  "/css/main.css" : 9876
}

etc ...

Agora, você não recebe "nome" e "tamanho", apenas usa chave e valor, mas geralmente isso é mais natural. YMMV.

Se você realmente deseja um "tamanho" para maior clareza ou precisa de mais de um valor para o arquivo, então:

{ 
   "/index.html" : { "size": 5467, "mime_type" : "foo" },
   "/about.html" : { "size": 3425, "mime_type" : "foo" }
   "/css/main.css" : { "size": 9876, "mime_type" : "bar" }
}

Em python, dicionário é objeto mutável. Por outro lado, tupla é objeto imutável.

se você precisar alterar a chave do dicionário, par de valores frequentemente ou sempre. Eu sugiro dicionário para usar.

se você tiver dados fixos / estáticos, sugiro usar tupla.

# dictionary define.
a = {}
a['test'] = 'first value'

# tuple define.
b = ()
b = b+(1,)

# here, we can change dictionary value for key 'test'
a['test'] = 'second'

Mas, não é possível alterar os dados da tupla usando o operador de atribuição.