Python MySQLDB: Obtenir le résultat de fetchall dans une liste

Je voudrais obtenir le résultat de la fetchall opération dans une liste au lieu de tuple tuple ou tuple de dictionnaires.
Par exemple,

cursor = connection.cursor() #Cursor could be a normal cursor or dict cursor
query = "Select id from bs"
cursor.execute(query)
row = cursor.fetchall()

Maintenant, le problème est la résultante de la ligne est soit ((123,),(234,)) ou ({'id':123}, {'id':234})
Ce que je cherche, c'est (123,234) ou [123,234]. Si je peux économiser sur l'analyse de la resulset. Merci d'avance

Probablement fournir un Curseur personnalisé classe pour ce faire. Le django db backends ce faire, de sorte que vous pourriez chercher l'inspiration là. Par exemple, django.db.backends.mysql.base.CursorWrapper est utilisé sur le dessus de la base de Curseur, mais je ne sais pas où c'est inscrit. Il peut fournir une coutume db backend qui renvoie votre Curseur personnalisé. Il sera probablement plus facile à analyser les données dont vous avez besoin lorsque vous y accédez.

InformationsquelleAutor Raunak Agarwal | 2012-10-12

51

Et ce sur les interprétations de la liste? Si le résultat est ((123,), (234,), (345,)):
```
>>> row = [item[0] for item in cursor.fetchall()]
>>> row
[123, 234, 345]
```
Si le résultat est ({'id': 123}, {'id': 234}, {'id': 345}):
```
>>> row = [item['id'] for item in cursor.fetchall()]
>>> row
[123, 234, 345]
```
- Mec je l'ai mentionné, je suis en train d'essayer d'éviter cela. J'espérais curseur peut être programmé de manière à ce que le résultat pourrait être puisée dans la liste directement.
- Donc, si ce scénario est juste un exemple, comment pensez-vous qu'avec des requêtes qui ont plus d'un champ? C'est pourquoi vous obtenez un tuple de tuples dans la première place
- Qui a dit que son exemple? Je veux juste récupérer une seule colonne d'identifiants et de nombre de ligne est en millions. Je veux faire un post-traitement sur les données et c'est pourquoi j'essaie de trouver un moyen pour éviter cette opération coûteuse.
- s'il vous plaît être civile - vous de ne pas mentionner les contraintes étaient sous dans votre question, de sorte qu'il est parfaitement raisonnable pour quelqu'un suggère de dérouler la nidification côté client. Vous devriez avoir dit que vous ont été traiter avec des millions de lignes.
- peut-être vous pouvez utiliser les générateurs électriques au lieu de les interprétations de la liste. Je ne pense pas que ça soit si cher car les générateurs d'évaluation différée
- Oui, cela pourrait être une chose à faire. Mais les générateurs seulement m'aider à contrôler la quantité d'articles que je veux charger qui pourraient être obtenus à partir du curseur lui-même. Probablement, je dois faire le calcul au niveau de la base de données elle-même. Mais Merci quand même.
InformationsquelleAutor César

Je suis sûr que, après tout ce temps, vous avez résolu ce problème, cependant, pour certaines personnes qui ne savent pas comment obtenir les valeurs d'un curseur comme un dictionnaire à l'aide de MySQLdb, vous pouvez utiliser cette méthode à la ici:

import MySQLdb as mdb

con = mdb.connect('localhost', 'testuser', 'test623', 'testdb')

with con:

    cur = con.cursor(mdb.cursors.DictCursor)
    cur.execute("SELECT * FROM Writers LIMIT 4")

    rows = cur.fetchall()

    for row in rows:
        print row["Id"], row["Name"]

InformationsquelleAutor onetwopunch

11

Ce vieux Q vient sur Google lors de la recherche pour l'aplatissement des requêtes db, donc voici d'autres suggestions...

Envisager une rapide liste-aplatissement de l'itérateur.

D'autres réponses utilisez fetchall() qui se charge tout d'abord toutes les lignes dans la mémoire, puis parcourt que de faire une nouvelle liste. Peut être inefficace. Peut se combiner avec MySQL soi-disant curseur côté serveur:
```
# assume mysql on localhost with db test and table bs
import itertools
import MySQLdb
import MySQLdb.cursors

conn = MySQLdb.connect(host='localhost',db='test', 
          cursorclass=MySQLdb.cursors.SSCursor ) 
cursor = conn.cursor()
# insert a bunch of rows
cursor.executemany('INSERT INTO bs (id) VALUES (%s)',zip(range(1,10000)) )
conn.commit()
# retrieve and listify
cursor.execute("select id from bs")
list_of_ids = list(itertools.chain.from_iterable(cursor))
len(list_of_ids)
#9999
conn.close()
```
Mais la question est aussi marqués de Django, qui a une belle seul champ de la requête de l'aplatissement
```
class Bs(models.Model):
    id_field = models.IntegerField()

list_of_ids = Bs.objects.values_list('id_field', flat=True)
```
- Quelques années de retard, mais c'est ce que l'OP a été de demander - créer une liste sans l'aide d'extraire tous les() en raison du nombre de ses points de données.
- Solution testée avec sqlite3. Il fonctionne parfaitement!
InformationsquelleAutor billspat

Si il n'y a qu'un seul champ, je peux l'utiliser pour faire une liste à partir de la base de données:

def getFieldAsList():
    kursor.execute("Select id from bs")
    id_data = kursor.fetchall()
    id_list = []
    for index in range(len(id_data)):
        id_list.append(id_data[index][0])
    return id_list

InformationsquelleAutor pupil

1

Faire votre curseur objet de cette manière:
```
db = MySQLdb.connect("IP", "user", "password", "dbname")

cursor = db.cursor(MySQLdb.cursors.DictCursor)
```
Puis lorsque vous effectuez curseur.fetchall() dans une requête, un n-uplet de dictionnaires sera obtenu, que vous pourrez ensuite convertir en liste.
```
data = cursor.fetchall()

data = list(data)
```
InformationsquelleAutor Sahana Joshi

-5

cursor.execute("""Select * From bs WHERE (id = %s)""",(id))

cursor.fetchall()

InformationsquelleAutor user2395682

Vous devez vous connecter pour publier un commentaire.