मैं पांडा के साथ एक बड़ी सीएसवी फ़ाइल कैसे पढ़ूं?

Question

मैं पांडा में एक बड़ी सीएसएसवी फाइल (aprox। 6 GB) पढ़ने की कोशिश कर रहा हूं और मुझे एक मेमोरी त्रुटि मिल रही है:

MemoryError                               Traceback (most recent call last)
<ipython-input-58-67a72687871b> in <module>()
----> 1 data=pd.read_csv('aphro.csv',sep=';')

...

MemoryError: 

इस पर कोई मदद?

Comments

उत्सुकता से, एक बहुत ही समान प्रश्न इस से लगभग एक साल पहले पूछा गया था ...

— DarkCygnus

पंडों के साथ बड़ी पाठ फ़ाइलों

— अनकोड करें

क्या इससे आपके सवाल का जवाब मिलता है? "बड़े डेटा" का काम पांडा का उपयोग करके बहता है

— एएमसी

Answer 1

त्रुटि से पता चलता है कि एक समय में पूरे CSV को DataFrame में पढ़ने के लिए मशीन के पास पर्याप्त मेमोरी नहीं है। यह मानते हुए कि आपको एक समय में मेमोरी में संपूर्ण डेटासेट की आवश्यकता नहीं है, समस्या से बचने का एक तरीका यह होगा कि आप CSV को चंक्स ( chunksizeपैरामीटर निर्दिष्ट करके ) में संसाधित करें :

chunksize = 10 ** 6
for chunk in pd.read_csv(filename, chunksize=chunksize):
    process(chunk)

chunksizeपैरामीटर हिस्सा प्रति पंक्तियों की संख्या निर्दिष्ट करता है। (अंतिम चंक में chunksizeपंक्तियों की तुलना में कम हो सकता है , निश्चित रूप से।)

Comments

आपको आम तौर पर कुछ में पढ़ने के लिए 2X की अंतिम मेमोरी की आवश्यकता होती है (सीएसवी से, हालांकि अन्य फॉर्मेट में मेमोरी की आवश्यकता कम होती है)। FYI करें यह एक साथ लगभग सभी कुछ करने की कोशिश करने के लिए सच है। इसे चंक करने के लिए बेहतर है (जिसमें निरंतर मेमोरी का उपयोग होता है)।

— जेफ

@altabq: यहाँ समस्या यह है कि हमारे पास इतना डेटा रखने के लिए पर्याप्त मेमोरी नहीं है कि सभी डेटा को सुरक्षित रख सके। ऊपर दिए गए समाधान इस स्थिति से निपटने की कोशिश करता है ताकि एक बार में एक ही हिस्सा - इस तरह से मेमोरी को बचाने के लिए (जैसे कुल जानकारी को एकत्र करके या केवल वांछित जानकारी निकालकर) घटाया जा सके। आप जो भी करते हैं, DF.append(chunk)लूप के अंदर नहीं बुलाते हैं । कि O(N^2)नकल संचालन का उपयोग करेगा । यह समेकित डेटा संलग्न करने के लिए बेहतर है एक सूची के लिए , और फिर साथ सूची से DataFrame निर्माण एक कॉल करने के लिए pd.DataFrameया pd.concat(समेकित डेटा के प्रकार पर निर्भर करता है)।

— १bu'१६ को

@altabq: DF.append(chunk)एक लूप में कॉल O(N^2)करने के लिए ऑपरेशनों की प्रतिलिपि बनाने की आवश्यकता होती Nहै, जहां विखंडू का आकार होता है, क्योंकि प्रत्येक कॉल DF.appendएक नया डेटाफ़्रेम लौटाता है। लूप के बाहर pd.DataFrameया pd.concat एक बार कॉल करने से कॉपी करने की मात्रा कम हो जाती है O(N)।

— अनटुब

@Pyderman: हां, chunksizeपैरामीटर प्रति पंक्ति की संख्या को संदर्भित करता है। अंतिम चंक में chunksizeपंक्तियों की तुलना में कम हो सकता है , निश्चित रूप से।

— ११:१६ पर unutbu

@Pyderman: हाँ; pd.concat([list_of_dfs]) एक बार कॉल करने के बाद लूप कॉलिंग की तुलना में बहुत तेज होता है pd.concatया df.appendलूप के भीतर कई बार होता है। बेशक, आपको पूरे 6 जीबी सीएसवी को एक डेटाफ़्रेम के रूप में रखने के लिए काफी मात्रा में मेमोरी की आवश्यकता होगी।

— unutbu

Answer 2

इस समस्या के लिए चंकिंग हमेशा कॉल का पहला पोर्ट नहीं होना चाहिए।

1. क्या बार-बार गैर-संख्यात्मक डेटा या अवांछित कॉलम के कारण फ़ाइल बड़ी है?

   यदि ऐसा है, तो आप कभी-कभी स्तंभों को श्रेणियों के रूप में पढ़कर और pd.read_csv usecols पैरामीटर के माध्यम से आवश्यक स्तंभों का चयन करके बड़े पैमाने पर मेमोरी बचत देख सकते हैं ।

2. क्या आपके वर्कफ़्लो में स्लाइसिंग, हेरफेर, निर्यात की आवश्यकता है?

   यदि हां, तो आप स्लाइस के लिए dask.dataframe का उपयोग कर सकते हैं , अपनी गणना कर सकते हैं और पुनरावृत्ति निर्यात कर सकते हैं । चुस्किंग चुपचाप डस्क द्वारा की जाती है, जो पांडा एपीआई के एक सबसेट का भी समर्थन करता है।

3. यदि बाकी सब विफल हो जाता है, तो लाइन को लाइन के माध्यम से पढ़ें।

   एक अंतिम उपाय के रूप में पंडों के माध्यम से या सीएसवी पुस्तकालय के माध्यम से चंक ।

Comments

मुझे डैस्क की जानकारी नहीं थी। +100 उसके लिए!

— दोपहर

Answer 3

मैं इस तरह आगे बढ़ा:

chunks=pd.read_table('aphro.csv',chunksize=1000000,sep=';',\
       names=['lat','long','rf','date','slno'],index_col='slno',\
       header=None,parse_dates=['date'])

df=pd.DataFrame()
%time df=pd.concat(chunk.groupby(['lat','long',chunk['date'].map(lambda x: x.year)])['rf'].agg(['sum']) for chunk in chunks)

Comments

क्या कोई कारण है जिससे आप स्विच read_csvकरते हैं read_table?

— पाइडरमैन 22

Answer 4

बड़े डेटा l के लिए आपको लाइब्रेरी "डैस्क" का उपयोग करने की सलाह देते हैं
जैसे:

# Dataframes implement the Pandas API
import dask.dataframe as dd
df = dd.read_csv('s3://.../2018-*-*.csv')

आप यहाँ प्रलेखन से अधिक पढ़ सकते हैं ।

मोडिन का उपयोग करने के लिए एक और बढ़िया विकल्प होगा क्योंकि सभी कार्यक्षमता पांडा के समान है फिर भी यह वितरित डेटाफ्रेम पुस्तकालयों जैसे डस्क पर लाभ उठाता है।

Comments

पांडा पर कोई लाभ, कुछ और संकेत जोड़कर सराहना कर सकता है

— PirateApp

मैंने बहुत लंबे समय तक Dask का उपयोग नहीं किया है, लेकिन मेरे उपयोग के मामलों में मुख्य लाभ यह था कि Dask कई मशीनों पर समानांतर चल सकता है, यह डेटा को स्लाइस के रूप में मेमोरी में भी फिट कर सकता है।

— सिंबराशी टिमोथी मोत्सी

धन्यवाद! पांडा के लिए एक प्रतिस्थापन है या यह एक परत के रूप में पांडा के शीर्ष पर काम करता है

— PirateApp

स्वागत है, यह Numpy, Pandas और Scikit-Learn के लिए एक आवरण के रूप में काम करता है।

— सिंबराशी टिमोथी मोत्सी

मैंने डैस्क के साथ कई समस्याओं का सामना करने की कोशिश की है और हमेशा हर चीज के लिए एक त्रुटि फेंकता है। यहां तक ​​कि विखंडू के साथ यह मेमोरी त्रुटियों को भी फेंकता है। देखें stackoverflow.com/questions/59865572/...

— Genarito

Answer 5

उपरोक्त उत्तर पहले से ही विषय को संतुष्ट कर रहा है। वैसे भी, यदि आपको मेमोरी में सभी डेटा की आवश्यकता है - bcolz पर एक नज़र डालें । मेमोरी में डेटा को कंप्रेस करना। मुझे इसके साथ वास्तव में अच्छा अनुभव रहा है। लेकिन इसके कई पांडा सुविधाओं को याद कर रहे हैं

संपादित करें: मुझे लगभग 1/10 या मूल आकार में संपीड़न दरें मिलीं, जो निश्चित रूप से डेटा के प्रकार पर निर्भर करता है। अनुपलब्ध महत्वपूर्ण सुविधाएँ समुच्चय थीं।

Comments

कृपया हमें यह बताकर सुधारें कि क) आपको कौन सा कम्प्रेशन अनुपात मिला है और ख) पंडों की मुख्य विशेषताएं क्या हैं? क्या यह NAs को संभाल सकता है? तार? categoricals? खजूर?

— smci

है ना? क्या यह NAs को संभाल सकता है? तार? categoricals? खजूर? ये चीजें हैं जो पांडा सीएसवी पढ़ने को धीमा और पिलपिला बना देती हैं। NA और ऑब्जेक्ट्स जैसे स्ट्रिंग्स (यहां तक ​​कि शॉर्ट्स) एक हत्यारा है। Btw .ipynb आपके ब्लॉग से संदर्भित है नीचे है।

— smci

@smci मैं आपको पढ़ रहा था ध्यान दें। लेकिन मेरा सुझाव है कि आप डॉक्स पर एक नजर है। मुझे उन्हें स्वयं पढ़ने की आवश्यकता होगी।

— प्लेगटैग

ठीक है तो यह NAs, स्ट्रिंग्स या डेट्स को हैंडल नहीं कर सकता। मुझे संदेह है कि यह या तो फ़्लोट्स को संभाल सकता है।

— स्मिकी

मुझे लगता है कि आप chunksबताए गए तरीके का उपयोग करके पांडा के साथ प्रीप्रोसेस कर सकते हैं , फिर एक विश्लेषण करने के लिए मेमोरी में सभी डेटा की आवश्यकता होने पर bcolz का उपयोग करें। सिर्फ एक विचार।

— जेककोटन

Answer 6

आप डेटा को चंक्स के रूप में पढ़ सकते हैं और प्रत्येक चंक को अचार के रूप में सहेज सकते हैं।

import pandas as pd 
import pickle

in_path = "" #Path where the large file is
out_path = "" #Path to save the pickle files to
chunk_size = 400000 #size of chunks relies on your available memory
separator = "~"

reader = pd.read_csv(in_path,sep=separator,chunksize=chunk_size, 
                    low_memory=False)    


for i, chunk in enumerate(reader):
    out_file = out_path + "/data_{}.pkl".format(i+1)
    with open(out_file, "wb") as f:
        pickle.dump(chunk,f,pickle.HIGHEST_PROTOCOL)

अगले चरण में आप अचार में पढ़ते हैं और प्रत्येक अचार को अपने वांछित डेटाफ़्रेम में जोड़ते हैं।

import glob
pickle_path = "" #Same Path as out_path i.e. where the pickle files are

data_p_files=[]
for name in glob.glob(pickle_path + "/data_*.pkl"):
   data_p_files.append(name)


df = pd.DataFrame([])
for i in range(len(data_p_files)):
    df = df.append(pd.read_pickle(data_p_files[i]),ignore_index=True)

Comments

यदि आपका अंतिम dfपूरी तरह से मेमोरी में निहित है (जैसा कि निहित है) और आपके इनपुट में डेटा की समान मात्रा शामिल है, तो निश्चित रूप से आपको बिल्कुल भी धोखा देने की आवश्यकता नहीं है?

— जेपी

उदाहरण के लिए, यदि आपकी फ़ाइल बहुत चौड़ी (100 से अधिक स्तंभों के साथ बहुत अधिक स्ट्रिंग स्तंभ वाली) है, तो आपको इस मामले में चंक करने की आवश्यकता होगी। यह मेमोरी में df को होल्ड करने के लिए आवश्यक मेमोरी को बढ़ाता है। यहां तक ​​कि 4 जीबी फ़ाइल भी 64 जीबी रैम वाले बॉक्स पर 20 से 30 जीबी रैम का उपयोग कर सकती है।

— cdabel

Answer 7

फ़ंक्शन read_csv और read_table लगभग समान है। जब आप अपने प्रोग्राम में read_table फ़ंक्शन का उपयोग करते हैं तो आपको सीमांकक "，" असाइन करना होगा।

def get_from_action_data(fname, chunk_size=100000):
    reader = pd.read_csv(fname, header=0, iterator=True)
    chunks = []
    loop = True
    while loop:
        try:
            chunk = reader.get_chunk(chunk_size)[["user_id", "type"]]
            chunks.append(chunk)
        except StopIteration:
            loop = False
            print("Iteration is stopped")

    df_ac = pd.concat(chunks, ignore_index=True)

Comments

यह बताने में मदद मिलेगी कि इस पोस्ट में आपका प्रश्न क्या है। जैसे "read_csv और read_table के बीच अंतर क्या है?" या "रीड टेबल को एक सीमांकक की आवश्यकता क्यों है?"

— nate_weldon

यह निर्भर करता है कि आपकी फ़ाइल कैसी दिखती है। कुछ फाइलों में सामान्य सीमांकक हैं जैसे "," या "|" या "\ t" लेकिन आप अन्य फ़ाइलों को देख सकते हैं जैसे कि 0x01, 0x02 (इसे बनाना) आदि जैसे सीमांकक के साथ। इसलिए read_table असामान्य delimiters के लिए अधिक अनुकूल है लेकिन read_csv केवल उतना ही अच्छा काम कर सकता है।

— नौफाल

Answer 8

समाधान 1:

बड़े डेटा के साथ पांडा का उपयोग करना

समाधान 2:

TextFileReader = pd.read_csv(path, chunksize=1000)  # the number of rows per chunk

dfList = []
for df in TextFileReader:
    dfList.append(df)

df = pd.concat(dfList,sort=False)

Comments

यहां फिर से हम 6 जीबी फ़ाइल को पूरी तरह से मेमोरी में लोड कर रहे हैं, क्या कोई विकल्प है, हम वर्तमान चंक को संसाधित कर सकते हैं और फिर अगले चंक को पढ़ सकते हैं

— debaonline4u

बस मत करो dfList.append, बस प्रत्येक chunk ( df) अलग से प्रक्रिया

— gokul_uf

Answer 9

एक उदाहरण इस प्रकार है:

chunkTemp = []
queryTemp = []
query = pd.DataFrame()

for chunk in pd.read_csv(file, header=0, chunksize=<your_chunksize>, iterator=True, low_memory=False):

    #REPLACING BLANK SPACES AT COLUMNS' NAMES FOR SQL OPTIMIZATION
    chunk = chunk.rename(columns = {c: c.replace(' ', '') for c in chunk.columns})

    #YOU CAN EITHER: 
    #1)BUFFER THE CHUNKS IN ORDER TO LOAD YOUR WHOLE DATASET 
    chunkTemp.append(chunk)

    #2)DO YOUR PROCESSING OVER A CHUNK AND STORE THE RESULT OF IT
    query = chunk[chunk[<column_name>].str.startswith(<some_pattern>)]   
    #BUFFERING PROCESSED DATA
    queryTemp.append(query)

#!  NEVER DO pd.concat OR pd.DataFrame() INSIDE A LOOP
print("Database: CONCATENATING CHUNKS INTO A SINGLE DATAFRAME")
chunk = pd.concat(chunkTemp)
print("Database: LOADED")

#CONCATENATING PROCESSED DATA
query = pd.concat(queryTemp)
print(query)

Answer 10

आप sframe की कोशिश कर सकते हैं, जिसमें पंडों के समान सिंटैक्स है लेकिन आपको उन फ़ाइलों को हेरफेर करने की अनुमति देता है जो आपकी रैम से बड़ी हैं।

Comments

SFrame डॉक्स से लिंक करें: turi.com/products/create/docs/generated/graphlab.SFrame.html

— akostis

"SFrame में डेटा को ग्राफलैब सर्वर साइड पर कॉलम-वार संग्रहीत किया जाता है" यह एक सेवा या एक पैकेज है?

— डैनी वांग

Answer 11

यदि आप पंडों का उपयोग बड़ी फाइल को चंक में पढ़ते हैं और फिर पंक्ति द्वारा पंक्ति बनाते हैं, तो यहां मैंने किया है

import pandas as pd

def chunck_generator(filename, header=False,chunk_size = 10 ** 5):
   for chunk in pd.read_csv(filename,delimiter=',', iterator=True, chunksize=chunk_size, parse_dates=[1] ): 
        yield (chunk)

def _generator( filename, header=False,chunk_size = 10 ** 5):
    chunk = chunck_generator(filename, header=False,chunk_size = 10 ** 5)
    for row in chunk:
        yield row

if __name__ == "__main__":
filename = r'file.csv'
        generator = generator(filename=filename)
        while True:
           print(next(generator))

Answer 12

मैं पहले से ही प्रदान किए जाने वाले अधिकांश संभावित समाधानों के आधार पर अधिक व्यापक उत्तर देना चाहता हूं। मैं एक और संभावित सहायता को इंगित करना चाहता हूं जो पढ़ने की प्रक्रिया में मदद कर सकती है।

विकल्प 1: dtypes

"dtypes" एक बहुत शक्तिशाली पैरामीटर है जिसका उपयोग आप readतरीकों के मेमोरी प्रेशर को कम करने के लिए कर सकते हैं । यह और यह देखें जवाब को । पंडों, डिफ़ॉल्ट रूप से, डेटा के dtypes अनुमान लगाने की कोशिश करते हैं।

डेटा संरचनाओं का उल्लेख करते हुए, संग्रहीत प्रत्येक डेटा, एक मेमोरी आवंटन होता है। बुनियादी स्तर पर नीचे दिए गए मानों को देखें (नीचे दी गई तालिका C प्रोग्रामिंग भाषा के लिए मूल्यों को दर्शाती है):

The maximum value of UNSIGNED CHAR = 255                                    
The minimum value of SHORT INT = -32768                                     
The maximum value of SHORT INT = 32767                                      
The minimum value of INT = -2147483648                                      
The maximum value of INT = 2147483647                                       
The minimum value of CHAR = -128                                            
The maximum value of CHAR = 127                                             
The minimum value of LONG = -9223372036854775808                            
The maximum value of LONG = 9223372036854775807

का संदर्भ लें इसNumPy और C प्रकारों के बीच मिलान देखने के पृष्ठ का ।

मान लीजिए कि आपके पास अंकों के पूर्णांकों की एक सरणी है । आप सैद्धांतिक रूप से और व्यावहारिक रूप से असाइन कर सकते हैं, 16-बिट पूर्णांक प्रकार की सरणी कह सकते हैं, लेकिन फिर आप उस मेमोरी को संग्रहीत करने की आवश्यकता से अधिक मेमोरी आवंटित करेंगे। इसे रोकने के लिए, आप dtypeविकल्प पर सेट कर सकते हैं read_csv। आप सरणी आइटम को लंबे पूर्णांक के रूप में संग्रहीत नहीं करना चाहते हैं जहां वास्तव में आप उन्हें 8-बिट पूर्णांक ( np.int8या np.uint8) के साथ फिट कर सकते हैं ।

निम्नलिखित dtype मानचित्र का निरीक्षण करें।

स्रोत: https://pbpython.com/pandas_dtypes.html

आप dtypeपंडों के तरीकों पर एक पैरामीटर के रूप में पैरामीटर को read{कॉलम: प्रकार} जैसे पर पारित कर सकते हैं ।

import numpy as np
import pandas as pd

df_dtype = {
        "column_1": int,
        "column_2": str,
        "column_3": np.int16,
        "column_4": np.uint8,
        ...
        "column_n": np.float32
}

df = pd.read_csv('path/to/file', dtype=df_dtype)

विकल्प 2: विखंडू द्वारा पढ़ें

चंक्स में डेटा को पढ़ने से आप इन-मेमोरी में डेटा का एक हिस्सा एक्सेस कर सकते हैं, और आप अपने डेटा पर प्रीप्रोसेसिंग कर सकते हैं और कच्चे डेटा के बजाय प्रोसेस्ड डेटा को संरक्षित कर सकते हैं। यह बेहतर होगा यदि आप इस विकल्प को पहले एक, dtypes के साथ जोड़ दें ।

मैं उस प्रक्रिया के लिए पांडा कुकबुक सेक्शन को इंगित करना चाहता हूं, जहां आप इसे यहां पा सकते हैं । उन दो वर्गों पर ध्यान दें;

• एक सीएसवी चंक-बाय-चंक पढ़ना
• एक सीएसवी चंक-बाय-चंक की केवल कुछ पंक्तियों को पढ़ना

विकल्प 3: Dask

Dask एक ढाँचा है जिसे Dask की वेबसाइट में इस प्रकार परिभाषित किया गया है :

Dask एनालिटिक्स के लिए उन्नत समानता प्रदान करता है, जो आपके द्वारा पसंद किए जाने वाले उपकरणों के लिए बड़े पैमाने पर प्रदर्शन को सक्षम करता है

यह उन जरूरी हिस्सों को ढंकने के लिए पैदा हुआ था, जहां पांडा नहीं पहुंच सकते। Dask एक शक्तिशाली ढांचा है जो आपको वितरित तरीके से संसाधित करके बहुत अधिक डेटा एक्सेस की अनुमति देता है।

आप अपने डेटा को पहले से तैयार करने के लिए डैस्क का उपयोग कर सकते हैं, डैस्क चैंकिंग वाले हिस्से की देखभाल करता है, इसलिए पांडा के विपरीत आप बस अपने प्रोसेसिंग स्टेप्स को परिभाषित कर सकते हैं और डैस्क को काम करने देते हैं। इससे पहले कि यह स्पष्ट रूप से धकेल दिया जाए computeऔर / या persistइसका उत्तर देखें, इससे पहले डस्क अभिकलन को लागू नहीं करता है अंतर के लिए ) ।

अन्य एड्स (विचार)

• ETL प्रवाह डेटा के लिए डिज़ाइन किया गया। केवल वही रखना जो कच्चे डेटा से आवश्यक है।
  • सबसे पहले, ETL को Dask या PySpark जैसे चौखटे के साथ पूरे डेटा पर लागू करें, और संसाधित डेटा निर्यात करें।
  • फिर देखें कि क्या संसाधित डेटा पूरे के रूप में मेमोरी में फिट हो सकता है।
• अपनी रैम बढ़ाने पर विचार करें।
• क्लाउड प्लेटफ़ॉर्म पर उस डेटा के साथ काम करने पर विचार करें।

Answer 13

उपरोक्त उत्तरों के अलावा, जो CSV को प्रोसेस करना चाहते हैं और फिर csv, parquet या SQL में निर्यात करना चाहते हैं, d6tstack एक और अच्छा विकल्प है। आप कई फाइलें लोड कर सकते हैं और यह डेटा स्कीमा परिवर्तन (जोड़े / हटाए गए कॉलम) से संबंधित है। कोर समर्थन से बाहर पहले से ही बनाया गया है।

def apply(dfg):
    # do stuff
    return dfg

c = d6tstack.combine_csv.CombinerCSV([bigfile.csv], apply_after_read=apply, sep=',', chunksize=1e6)

# or
c = d6tstack.combine_csv.CombinerCSV(glob.glob('*.csv'), apply_after_read=apply, chunksize=1e6)

# output to various formats, automatically chunked to reduce memory consumption
c.to_csv_combine(filename='out.csv')
c.to_parquet_combine(filename='out.pq')
c.to_psql_combine('postgresql+psycopg2://usr:pwd@localhost/db', 'tablename') # fast for postgres
c.to_mysql_combine('mysql+mysqlconnector://usr:pwd@localhost/db', 'tablename') # fast for mysql
c.to_sql_combine('postgresql+psycopg2://usr:pwd@localhost/db', 'tablename') # slow but flexible

Answer 14

यदि कोई व्यक्ति अभी भी कुछ इस तरह की तलाश कर रहा है, तो मैंने पाया कि इस नई लाइब्रेरी को मॉडिन कहा जा सकता है। यह वितरित कंप्यूटिंग का उपयोग करता है जो पढ़ने में मदद कर सकता है। यहाँ पांडा के साथ इसकी कार्यक्षमता की तुलना करते हुए एक अच्छा लेख दिया गया है । यह अनिवार्य रूप से पांडा के समान कार्यों का उपयोग करता है।

import modin.pandas as pd
pd.read_csv(CSV_FILE_NAME)

Comments

क्या आप इस बारे में टिप्पणी कर सकते हैं कि यह नया मॉड्यूल किस modinतरह से स्थापित है dask.dataframe? उदाहरण के लिए, सभी स्थानीय सीपीयू कोर का उपयोग करने के लिए पांडा से डस्क की ओर कदम देखें ।

— जेपी

Answer 15

यदि आप प्रक्रिया फ़ंक्शन के बारे में निश्चित होना चाहते हैं, तो चंक्साइज़ विकल्प का उपयोग करने से पहले, आप @unutbu द्वारा बताए गए अनुसार चूनिंग लूप के अंदर लिखना चाहते हैं।

small_df = pd.read_csv(filename, nrows=100)

एक बार जब आपको यह सुनिश्चित हो जाता है कि प्रक्रिया ब्लॉक तैयार है, तो आप इसे पूरे डेटाफ़्रेम के लिए लूप के लिए चैंकिंग में डाल सकते हैं।