Comment importer des données à partir de mongodb pour les pandas?

Vous pouvez charger votre mongodb données aux pandas DataFrame l'aide de ce code. Il fonctionne pour moi. J'espère pour vous aussi.

import pymongo
import pandas as pd
from pymongo import MongoClient
client = MongoClient()
db = client.database_name
collection = db.collection_name
data = pd.DataFrame(list(collection.find()))

Comme par PEP, simple est le mieux que compliqué:

import pandas as pd
df = pd.DataFrame.from_records(db.<database_name>.<collection_name>.find())

Vous pouvez inclure des conditions, comme vous le feriez de travail régulière de la base de données mongoDB ou même utiliser find_one() pour obtenir un seul élément de la base de données, etc.

et le tour est joué!

Pour traiter les out-of-core (pas de montage dans la RAM) les données de façon efficace (c'est à dire avec l'exécution en parallèle), vous pouvez essayer Python Blaze écosystème: Blaze /Dask /Odon.

Blaze (et Odon) a out-of-the-box fonctions de traiter avec MongoDB.

Quelques articles utiles pour commencer:

• L'Introduction De Blaze Expessions (avec MongoDB exemple de requête)
• ReproduceIt: Reddit nombre de mots
• Différence entre Dask Tableaux et Blaze

Et un article qui montre ce qu'est incroyable de choses sont possibles avec le Blaze de la pile: L'analyse de 1,7 Milliard de Reddit Commentaires avec Blaze et Impala (essentiellement, l'interrogation 975 Go de Reddit commentaires en secondes).

P. S. je ne suis pas affilié avec aucun de ces technologies.

À l'aide de

pandas.DataFrame(list(...))

permettra de consommer beaucoup de mémoire si l'itérateur/générateur de résultat est de grande

mieux pour générer petits morceaux et concat à la fin

def iterator2dataframes(iterator, chunk_size: int):
"""Turn an iterator into multiple small pandas.DataFrame
This is a balance between memory and efficiency
"""
records = []
frames = []
for i, record in enumerate(iterator):
records.append(record)
if i % chunk_size == chunk_size - 1:
frames.append(pd.DataFrame(records))
records = []
if records:
frames.append(pd.DataFrame(records))
return pd.concat(frames)

La suite de cette grande réponse par waitingkuo je voudrais ajouter la possibilité de le faire à l'aide de chunksize en ligne avec .read_sql() et .read_csv(). Je agrandir la réponse de Deu Leung en évitant d'aller un par un chaque "enregistrement" de la "itérateur' /'curseur'.
Je vais emprunter précédente read_mongo fonction.

def read_mongo(db, 
collection, query={}, 
host='localhost', port=27017, 
username=None, password=None,
chunksize = 100, no_id=True):
""" Read from Mongo and Store into DataFrame """
# Connect to MongoDB
#db = _connect_mongo(host=host, port=port, username=username, password=password, db=db)
client = MongoClient(host=host, port=port)
# Make a query to the specific DB and Collection
db_aux = client[db]
# Some variables to create the chunks
skips_variable = range(0, db_aux[collection].find(query).count(), int(chunksize))
if len(skips_variable)<=1:
skips_variable = [0,len(skips_variable)]
# Iteration to create the dataframe in chunks.
for i in range(1,len(skips_variable)):
# Expand the cursor and construct the DataFrame
#df_aux =pd.DataFrame(list(cursor_aux[skips_variable[i-1]:skips_variable[i]]))
df_aux =pd.DataFrame(list(db_aux[collection].find(query)[skips_variable[i-1]:skips_variable[i]]))
if no_id:
del df_aux['_id']
# Concatenate the chunks into a unique df
if 'df' not in locals():
df =  df_aux
else:
df = pd.concat([df, df_aux], ignore_index=True)
return df