Cuándo usar un diccionario vs tupla en Python

El ejemplo específico en mente es una lista de nombres de archivo y sus tamaños. No puedo decidir si cada elemento de la lista debe tener la forma {"filename": "blabla", "size": 123}, o simplemente ("blabla", 123). Un diccionario me parece más lógico porque acceder al tamaño, por ejemplo, file["size"]es más explicativo que file[1]... pero no estoy seguro. Pensamientos?

Yo usaría un namedtuple:

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

Ahora puede usar file.sizey file.filenameen su programa, que en mi humilde opinión es la forma más legible. Note namedtuplecrea objetos inmutables como tuplas, y son más livianos que los diccionarios, como se describe aquí .

{"filename": "blabla", "size": 123}, o simplemente ("blabla", 123)

Esta es la vieja pregunta de si codificar su formato / esquema dentro de banda o fuera de banda.

Cambia un poco de memoria para obtener la legibilidad y portabilidad que resulta de expresar el formato de los datos directamente en los datos. Si no lo hace, el conocimiento de que el primer campo es el nombre del archivo y el segundo es el tamaño debe mantenerse en otro lugar. Eso ahorra memoria pero cuesta legibilidad y portabilidad. ¿Qué le costará más dinero a su empresa?

En cuanto al problema inmutable, recuerde que inmutable no significa inútil ante el cambio. Significa que necesitamos obtener más memoria, hacer el cambio en una copia y usar la nueva copia. Eso no es gratis, pero a menudo no es un factor decisivo. Usamos cadenas inmutables para cambiar las cosas todo el tiempo.

Otra consideración es la extensibilidad. Cuando almacena datos solo posicionalmente, sin codificar información de formato, entonces está condenado a una sola herencia, que realmente no es más que la práctica de concatenar campos adicionales después de los campos establecidos. Puedo definir un tercer campo para que sea la fecha de creación y seguir siendo compatible con su formato, ya que defino primero y segundo de la misma manera.

Sin embargo, lo que no puedo hacer es reunir dos formatos definidos de manera independiente que tengan algunos campos superpuestos, algunos no, almacenarlos en un formato y hacer que sean útiles para cosas que solo conocen uno u otro formato.

Para hacer eso, necesito codificar la información de formato desde el principio. Necesito decir "este campo es el nombre del archivo". Hacer eso permite la herencia múltiple.

Probablemente esté acostumbrado a que la herencia solo se exprese en el contexto de los objetos, pero las mismas ideas funcionan para los formatos de datos porque, bueno, los objetos se almacenan en formatos de datos. Es exactamente el mismo problema.

Así que usa lo que creas que es más probable que necesites. Alcanzo la flexibilidad a menos que pueda señalar una buena razón para no hacerlo.

Usaría una clase con dos propiedades. file.sizees mejor que cualquiera de los dos file[1]o file["size"].

Simple es mejor que complejo.

¿Son únicos los nombres de archivo? Si es así, puede eliminar la lista por completo y simplemente usar un diccionario puro para todos los archivos. por ejemplo (un sitio web hipotético)

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

etc ...

Ahora, no obtienes "nombre" y "tamaño", solo usas clave y valor, pero a menudo esto es más natural. YMMV.

Si realmente desea un "tamaño" para mayor claridad, o necesita más de un valor para el archivo, entonces:

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

En python, el diccionario es un objeto mutable. Por otro lado, la tupla es un objeto inmutable.

Si necesita cambiar la clave del diccionario, par de valores a menudo o siempre. Sugiero diccionario para usar.

Si tiene datos fijos / estáticos, sugiero usar tuplas.

# 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'

Pero no se pueden cambiar los datos de tupla usando el operador de asignación.