Comment gérer les grands ensembles de données dans Python qui ne rentrent pas dans la mémoire?

Lors du traitement de grands ensembles de données qui dépassent la mémoire dans Python, ils ne peuvent pas être chargés en RAM en même temps. Au lieu de cela, des stratégies telles que le traitement de la chasse, le stockage du disque ou le streaming doivent être adoptées; Les fichiers CSV peuvent être lus en morceaux via le paramètre ChunkSize de Pandas et le bloc traité par bloc. La daste peut être utilisée pour réaliser la parallélisation et la planification des tâches similaires à la syntaxe Pandas pour prendre en charge les opérations de données de mémoire importantes. Écrire des fonctions du générateur pour lire les fichiers texte ligne par ligne pour réduire l'utilisation de la mémoire et utiliser la mémoire colonnelle du parquet Le format de stockage combine Pyarrow pour lire efficacement des colonnes ou des groupes de lignes spécifiques, utilise la demande Memmap de Numpy pour la mémoire de la mémoire telles que SQLite ou DuckDB pour effectuer des quai effectieuses; En résumé, les méthodes appropriées doivent être sélectionnées en fonction du format de données, du mode d'accès et des besoins de calcul. Le principe de base est d'éviter de charger toutes les données à la fois, mais de traiter, de remettre en question ou de streaming à la demande, et de combiner généralement plusieurs méthodes pour obtenir de meilleurs résultats.

Lorsque vous travaillez avec de grands ensembles de données dans Python qui dépassent la mémoire disponible, vous ne pouvez pas tout charger en RAM à la fois. Au lieu de cela, vous avez besoin de stratégies et d'outils qui vous permettent de traiter les données en morceaux ou d'utiliser efficacement le stockage basé sur le disque. Voici des approches pratiques pour gérer de tels scénarios:

Utilisez un traitement en morceaux avec des pandas

Pour les grands fichiers CSV ou texte, vous pouvez lire et traiter les données dans des morceaux plus petits à l'aide de pandas.read_csv() avec le paramètre chunksize .

 Importer des pandas en tant que PD

chunk_size = 10000
Pour Chunk dans PD.Read_csv ('Large_file.csv', ChunkSize = Chunk_Size):
    # Processez chaque morceau
    proced_chunk = chunk.groupby ('colonne'). sum ()
    # Agrégat ou enregistrer les résultats

De cette façon, seule une petite partie des données est en mémoire à tout moment. Vous pouvez agréger les résultats entre les morceaux ou les écrire sur le disque progressivement.

Tirer une prise en charge pour l'informatique évolutive

La prise en charge étend les pandas et Numpy pour gérer les ensembles de données plus grands que la mémoire en divisant les opérations en tâches et en les traitant en parallèle.

 importer dask.dataframe comme dd

# Lire le grand CSV comme un dask dataframe
df = dd.read_csv ('Large_file.csv')

# Effectuer des opérations (évaluation paresseuse)
result = df.groupby ('colonne'). valeur.mean (). calcul ()

Dask gère automatiquement les opérations de section et de planification et de support comme GroupBy, Merge et Resemple sur de grands ensembles de données.

Utilisez des générateurs et des itérateurs

Écrivez des générateurs personnalisés pour produire des données une pièce à la fois, minimisant l'empreinte de la mémoire.

 def read_large_file (file_obj):
    Bien que vrai:
        data = file_obj.readline ()
        Si ce n'est pas des données:
            casser
        data de rendement.strip ()

avec Open ('énorme_file.txt') comme f:
    pour la ligne dans read_large_file (f):
        # Processus ligne par ligne
        processus (ligne)

Ceci est particulièrement utile pour le traitement de texte, les fichiers journaux ou les données de streaming.

Travaillez avec Apache Parquet et Arrow

Parquet est un format de stockage en colonnes efficace pour les grands ensembles de données. Combiné avec pyarrow ou pandas , il permet des lectures partielles rapides et partielles.

 importer pyarrow.parquet comme pq

table = pq.read_table ('data.parquet', colonnes = ['Col1', 'Col2'])
df = table.to_pandas ()

Vous ne pouvez lire que des colonnes ou des groupes de lignes spécifiques, réduisant considérablement l'utilisation de la mémoire.

Utilisez la cartographie de la mémoire avec Numpy

Pour les grands tableaux numériques, numpy.memmap vous permet d'accéder aux données sur le disque comme s'il était en mémoire.

 Importer Numpy comme NP

# Créer ou accéder à un tableau mappé par la mémoire
MMAPT_Arr = np.MemMap ('Large_Array.Dat', dtype = 'Float32', mode = 'R', forme = (100000, 1000))

# Accès aux tranches sans charger l'ensemble du tableau
sous-ensemble = MMAPP_ARR [: 1000 ,:]

Ceci est utile pour l'apprentissage automatique ou l'informatique scientifique avec de grands tableaux.

Stocker les données dans les bases de données

Utilisez SQLite, DuckDB ou d'autres bases de données légères pour interroger efficacement les sous-ensembles de données.

 Importer DuckDB

con = Duckdb.Connect ('Large_data.db')
résultat = con.execute ("" "
    Sélectionnez la catégorie, AVG (valeur)
    De Big_Table
    Groupe par catégorie
"" ") .fetch_df ()

DuckDB est particulièrement bon pour les requêtes analytiques sur les grands fichiers CSV / parquet sans les charger complètement.

Résumé

• Chunking avec des pandas fonctionne bien pour les fichiers structurés.
• Dask vous donne une syntaxe de type pandas pour les mégadonnées.
• Les générateurs aident à la logique de streaming personnalisée.
• Parquet Arrow permet un stockage et un accès en colonnes efficaces.
• La cartographie de la mémoire est idéale pour les grandes données numériques.
• Les bases de données (en particulier DuckDB) offrent une requête puissante avec une mémoire basse.

Choisissez la méthode en fonction de votre format de données, de votre modèle d'accès et de vos besoins de calcul. Souvent, en combinant quelques-uns donnent les meilleurs résultats.

Fondamentalement, évitez de tout charger à la fois: traiter, remettre en question ou diffuser ce dont vous avez besoin.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!