tamaño - Dividir tuplas en Python: ¿la mejor práctica?

qué son las tuplas en python

Question

Tengo un método en mi código de Python que devuelve una tupla: una fila de una consulta SQL. Digamos que tiene tres campos: (Id de trabajo, etiqueta, nombre de usuario)

Para facilitar el traspaso entre funciones, he estado pasando toda la tupla como una variable llamada ''trabajo''. Eventualmente, sin embargo, quiero obtener los bits, así que he estado usando un código como este: (Id. De trabajo, etiqueta, nombre de usuario) = trabajo

Sin embargo, me he dado cuenta de que esto es una pesadilla de mantenimiento, porque ahora nunca puedo agregar nuevos campos al conjunto de resultados sin romper todo mi código existente. ¿Cómo debería haber escrito esto?

Aquí están mis dos mejores suposiciones: (Id de trabajo, etiqueta, nombre de usuario) = (trabajo [0], trabajo [1], trabajo [2]) ... pero eso no escala bien cuando tiene 15 ... 20 campos

o convertir los resultados de la consulta SQL a un diccionario de inmediato y pasar eso (no tengo control sobre el hecho de que comienza la vida como una tupla, eso está arreglado para mí)

Answer 1

@Staale

Hay una mejor manera:

job = dict(zip(keys, values))

Answer 2

Qué tal esto:

class TypedTuple:
    def __init__(self, fieldlist, items):
       self.fieldlist = fieldlist
       self.items = items
    def __getattr__(self, field):
       return self.items[self.fieldlist.index(field)]

Entonces podrías hacer:

j = TypedTuple(["jobid", "label", "username"], job)
print j.jobid

Debería ser fácil intercambiar self.fieldlist.index(field) con una búsqueda de diccionario más adelante ... simplemente edite su método __init__ ! Algo como Staale hace.

Answer 3

Tal vez esto sea excesivo para su caso, pero me sentiría tentado de crear una clase "Trabajo" que tome la tupla como su argumento constructor y tenga las propiedades respectivas en ella. En su lugar, pasaría instancias de esta clase.

Answer 4

Yo diría que un diccionario es definitivamente la mejor manera de hacerlo. Es fácilmente extensible, le permite dar a cada valor un nombre razonable, y Python tiene muchas características de lenguaje integradas para usar y manipular diccionarios. Si necesita agregar más campos más adelante, todo lo que necesita cambiar es el código que convierte la tupla en un diccionario y el código que realmente usa los nuevos valores.

Por ejemplo:

job={}
job[''jobid''], job[''label''], job[''username'']=<querycode>

Answer 5

Yo usaría un diccionario. Puede convertir la tupla a un diccionario de esta manera:

values = <querycode>
keys = ["jobid", "label", "username"]
job = dict([[keys[i], values [i]] for i in xrange(len(values ))])

Esto primero creará una matriz [["jobid", val1], ["label", val2], ["username", val3]] y luego la convertirá en un diccionario. Si el orden o conteo de resultados cambia, solo necesita cambiar la lista de claves para que coincida con el nuevo resultado.

PD todavía está fresco en Python, por lo que podría haber mejores formas de hacerlo.

Answer 6

Una vieja pregunta, pero como nadie lo mencionó, agregaré esto del libro de cocina de Python:

Receta 81252: Usar dtuple para acceder a los resultados de consultas flexibles

Esta receta está específicamente diseñada para tratar los resultados de la base de datos, y la solución dtuple le permite acceder a los resultados por nombre O número de índice. Esto evita tener que acceder a todo mediante un subíndice que es muy difícil de mantener, como se indica en su pregunta.

Answer 7

Esta es una vieja pregunta, pero ...

Sugeriría usar una tupla nombrada en esta situación: collections.namedtuple

Esta es la parte, en particular, que le sería útil:

La subclasificación no es útil para agregar nuevos campos almacenados. En su lugar, simplemente cree un nuevo tipo de tupla con nombre del atributo _fields.

Answer 8

Si está utilizando el paquete MySQLdb, puede configurar sus objetos de cursor para devolver dicts en lugar de tuplas.

import MySQLdb, MySQLdb.cursors
conn = MySQLdb.connect(..., cursorclass=MySQLdb.cursors.DictCursor)
cur = conn.cursor() # a DictCursor
cur2 = conn.cursor(cursorclass=MySQLdb.cursors.Cursor) # a "normal" tuple cursor

Answer 9

Con una tupla siempre será una molestia agregar o cambiar campos. Tienes razón en que un diccionario será mucho mejor.

Si quieres algo con una sintaxis ligeramente más amigable, tal vez quieras echar un vistazo a las respuestas a esta pregunta sobre un objeto simple ''similar a una estructura''. De esta forma, puede pasar alrededor de un objeto, digamos job , y acceder a sus campos incluso más fácilmente que una tupla o dict:

job.jobId, job.username = jobId, username