பாண்டாஸ் டேட்டாஃபிரேம் மேம்படுத்தல்: நினைவகப் பயன்பாடு மற்றும் செயல்திறன் சரிசெய்தல்

பாண்டாஸ் என்பது தரவு கையாளுதல் மற்றும் பகுப்பாய்விற்கான ஒரு சக்திவாய்ந்த பைதான் நூலகமாகும். இருப்பினும், பெரிய தரவுத்தொகுப்புகளுடன் பணிபுரியும் போது, பாண்டாஸ் டேட்டாஃபிரேம்கள் குறிப்பிடத்தக்க அளவு நினைவகத்தைப் பயன்படுத்தலாம் மற்றும் மெதுவான செயல்திறனை வெளிப்படுத்தலாம். இந்தக் கட்டுரை, பாண்டாஸ் டேட்டாஃபிரேம்களை நினைவகப் பயன்பாடு மற்றும் செயல்திறன் இரண்டிற்கும் மேம்படுத்துவதற்கான ஒரு விரிவான வழிகாட்டியை வழங்குகிறது, இது பெரிய தரவுத்தொகுப்புகளை மிகவும் திறமையாகச் செயல்படுத்த உங்களுக்கு உதவுகிறது.

பாண்டாஸ் டேட்டாஃபிரேம்களில் நினைவகப் பயன்பாட்டைப் புரிந்துகொள்ளுதல்

மேம்படுத்தல் நுட்பங்களுக்குள் செல்வதற்கு முன், பாண்டாஸ் டேட்டாஃபிரேம்கள் நினைவகத்தில் தரவை எவ்வாறு சேமிக்கின்றன என்பதைப் புரிந்துகொள்வது முக்கியம். ஒரு டேட்டாஃபிரேமில் உள்ள ஒவ்வொரு நெடுவரிசைக்கும் ஒரு குறிப்பிட்ட தரவு வகை உள்ளது, இது அதன் மதிப்புகளைச் சேமிக்கத் தேவையான நினைவகத்தின் அளவைத் தீர்மானிக்கிறது. பொதுவான தரவு வகைகள் பின்வருமாறு:

• int64: 64-பிட் முழு எண்கள் (முழு எண்களுக்கான இயல்புநிலை)
• float64: 64-பிட் மிதக்கும் புள்ளி எண்கள் (மிதக்கும் புள்ளி எண்களுக்கான இயல்புநிலை)
• object: பைதான் பொருள்கள் (சரங்கள் மற்றும் கலப்பு தரவு வகைகளுக்குப் பயன்படுத்தப்படுகிறது)
• category: வகைப்படுத்தப்பட்ட தரவு (மீண்டும் மீண்டும் வரும் மதிப்புகளுக்கு திறமையானது)
• bool: பூலியன் மதிப்புகள் (True/False)
• datetime64: தேதிநேர மதிப்புகள்

object தரவு வகை பெரும்பாலும் அதிக நினைவகத்தைப் பயன்படுத்தும் ஒன்றாகும், ஏனெனில் இது பைதான் பொருள்களுக்கான சுட்டிகளைச் சேமிக்கிறது, இது முழு எண்கள் அல்லது மிதவைகள் போன்ற அடிப்படை தரவு வகைகளை விட கணிசமாக பெரியதாக இருக்கும். சரங்கள், சிறியதாக இருந்தாலும், `object` ஆக சேமிக்கப்படும்போது, தேவைக்கு அதிகமான நினைவகத்தைப் பயன்படுத்துகின்றன. இதேபோல், `int32` போதுமானதாக இருக்கும்போது `int64` ஐப் பயன்படுத்துவது நினைவகத்தை வீணாக்குகிறது.

எடுத்துக்காட்டு: டேட்டாஃபிரேம் நினைவகப் பயன்பாட்டை ஆய்வு செய்தல்

டேட்டாஃபிரேமின் நினைவகப் பயன்பாட்டை ஆய்வு செய்ய நீங்கள் memory_usage() முறையைப் பயன்படுத்தலாம்:

            import pandas as pd
import numpy as np

data = {
    'col1': np.random.randint(0, 1000, 100000),
    'col2': np.random.rand(100000),
    'col3': ['A', 'B', 'C'] * (100000 // 3 + 1)[:100000],
    'col4': ['This is a long string'] * 100000
}

df = pd.DataFrame(data)

memory_usage = df.memory_usage(deep=True)
print(memory_usage)
print(df.dtypes)

            

              
                Copy
              
            
          

deep=True என்ற வாதம், பொருள்கள் (சரங்கள் போன்றவை) நினைவகப் பயன்பாட்டைத் துல்லியமாகக் கணக்கிடுவதை உறுதி செய்கிறது. `deep=True` இல்லாமல், இது சுட்டிகளுக்கான நினைவகத்தை மட்டுமே கணக்கிடும், அடிப்படைத் தரவை அல்ல.

தரவு வகைகளை மேம்படுத்துதல்

நினைவகப் பயன்பாட்டைக் குறைப்பதற்கான மிகவும் பயனுள்ள வழிகளில் ஒன்று, உங்கள் டேட்டாஃபிரேம் நெடுவரிசைகளுக்கு மிகவும் பொருத்தமான தரவு வகைகளைத் தேர்ந்தெடுப்பதாகும். இங்கே சில பொதுவான நுட்பங்கள் உள்ளன:

1. எண் தரவு வகைகளை டவுன்காஸ்ட் செய்தல்

உங்கள் முழு எண் அல்லது மிதக்கும் புள்ளி நெடுவரிசைகளுக்கு 64-பிட் துல்லியத்தின் முழு வரம்பும் தேவையில்லை என்றால், நீங்கள் அவற்றை int32, int16, float32 அல்லது float16 போன்ற சிறிய தரவு வகைகளுக்கு டவுன்காஸ்ட் செய்யலாம். இது குறிப்பாக பெரிய தரவுத்தொகுப்புகளுக்கு நினைவகப் பயன்பாட்டை கணிசமாகக் குறைக்கும்.

எடுத்துக்காட்டு: வயதைக் குறிக்கும் ஒரு நெடுவரிசையைக் கவனியுங்கள், அது 120 ஐத் தாண்டுவதற்கு வாய்ப்பில்லை. இதை `int64` ஆக சேமிப்பது வீணானது; `int8` (வரம்பு -128 முதல் 127 வரை) மிகவும் பொருத்தமானதாக இருக்கும்.

            def downcast_numeric(df):
    """Downcasts numeric columns to the smallest possible data type."""
    for col in df.columns:
        if pd.api.types.is_integer_dtype(df[col]):
            df[col] = pd.to_numeric(df[col], downcast='integer')
        elif pd.api.types.is_float_dtype(df[col]):
            df[col] = pd.to_numeric(df[col], downcast='float')
    return df

df = downcast_numeric(df.copy())
print(df.memory_usage(deep=True))
print(df.dtypes)

            

              
                Copy
              
            
          

pd.to_numeric() செயல்பாடு downcast வாதத்துடன், நெடுவரிசையில் உள்ள மதிப்புகளைப் பிரதிநிதித்துவப்படுத்தக்கூடிய மிகச்சிறிய தரவு வகையை தானாகவே தேர்ந்தெடுக்கப் பயன்படுகிறது. `copy()` அசல் டேட்டாஃபிரேமை மாற்றுவதைத் தவிர்க்கிறது. தகவலை இழக்காமல் இருப்பதை உறுதிசெய்ய, டவுன்காஸ்ட் செய்வதற்கு முன் எப்போதும் உங்கள் தரவில் உள்ள மதிப்புகளின் வரம்பைச் சரிபார்க்கவும்.

2. வகைப்படுத்தப்பட்ட தரவு வகைகளைப் பயன்படுத்துதல்

ஒரு நெடுவரிசையில் வரையறுக்கப்பட்ட எண்ணிக்கையிலான தனிப்பட்ட மதிப்புகள் இருந்தால், அதை category தரவு வகையாக மாற்றலாம். வகைப்படுத்தப்பட்ட தரவு வகைகள் ஒவ்வொரு தனிப்பட்ட மதிப்பையும் ஒரு முறை மட்டுமே சேமித்து, பின்னர் நெடுவரிசையில் உள்ள மதிப்புகளைக் குறிக்க முழு எண் குறியீடுகளைப் பயன்படுத்துகின்றன. இது நினைவகப் பயன்பாட்டை கணிசமாகக் குறைக்கும், குறிப்பாக அதிக விகிதத்தில் மீண்டும் மீண்டும் வரும் மதிப்புகள் கொண்ட நெடுவரிசைகளுக்கு.

எடுத்துக்காட்டு: நாட்டுக் குறியீடுகளைக் குறிக்கும் ஒரு நெடுவரிசையைக் கவனியுங்கள். நீங்கள் வரையறுக்கப்பட்ட நாடுகளின் தொகுப்புடன் (எ.கா., ஐரோப்பிய ஒன்றியத்தில் உள்ள நாடுகள் மட்டும்) கையாளுகிறீர்கள் என்றால், இதை ஒரு வகையாக சேமிப்பது சரங்களாக சேமிப்பதை விட மிகவும் திறமையானதாக இருக்கும்.

            def optimize_categories(df):
    """Converts object columns with low cardinality to categorical type."""
    for col in df.columns:
        if df[col].dtype == 'object':
            num_unique_values = len(df[col].unique())
            num_total_values = len(df[col])
            if num_unique_values / num_total_values < 0.5:
                df[col] = df[col].astype('category')
    return df

df = optimize_categories(df.copy())
print(df.memory_usage(deep=True))
print(df.dtypes)

            

              
                Copy
              
            
          

ஒரு பொருள் நெடுவரிசையில் உள்ள தனிப்பட்ட மதிப்புகளின் எண்ணிக்கை மொத்த மதிப்புகளில் 50% க்கும் குறைவாக உள்ளதா என்பதை இந்த குறியீடு சரிபார்க்கிறது. அப்படியானால், அது நெடுவரிசையை ஒரு வகைப்படுத்தப்பட்ட தரவு வகையாக மாற்றுகிறது. 50% வரம்பு தன்னிச்சையானது மற்றும் உங்கள் தரவின் குறிப்பிட்ட பண்புகளின் அடிப்படையில் சரிசெய்யப்படலாம். இந்த அணுகுமுறை நெடுவரிசையில் பலமுறை மீண்டும் மீண்டும் வரும் மதிப்புகள் இருக்கும்போது மிகவும் பயனுள்ளதாக இருக்கும்.

3. சரங்களுக்கு பொருள் தரவு வகைகளைத் தவிர்த்தல்

முன்பு குறிப்பிட்டது போல, object தரவு வகை பெரும்பாலும் அதிக நினைவகத்தைப் பயன்படுத்துகிறது, குறிப்பாக சரங்களை சேமிக்கப் பயன்படுத்தும்போது. முடிந்தால், சர நெடுவரிசைகளுக்கு object தரவு வகைகளைப் பயன்படுத்துவதைத் தவிர்க்கவும். குறைந்த கார்டினாலிட்டி கொண்ட சரங்களுக்கு வகைப்படுத்தப்பட்ட வகைகள் விரும்பப்படுகின்றன. கார்டினாலிட்டி அதிகமாக இருந்தால், சரங்களை எண் குறியீடுகளுடன் குறிப்பிட முடியுமா அல்லது சரத் தரவை முற்றிலுமாகத் தவிர்க்க முடியுமா என்பதைக் கருத்தில் கொள்ளுங்கள்.

நெடுவரிசையில் சரச் செயல்பாடுகளைச் செய்ய வேண்டியிருந்தால், நீங்கள் அதை ஒரு பொருள் வகையாக வைத்திருக்க வேண்டியிருக்கலாம், ஆனால் இந்தச் செயல்பாடுகளை முன்கூட்டியே செய்துவிட்டு, பின்னர் மிகவும் திறமையான வகையாக மாற்ற முடியுமா என்பதைக் கருத்தில் கொள்ளுங்கள்.

4. தேதி மற்றும் நேரத் தரவு

தேதி மற்றும் நேரத் தகவலுக்கு `datetime64` தரவு வகையைப் பயன்படுத்தவும். தெளிவுத்திறன் பொருத்தமானது என்பதை உறுதிப்படுத்தவும் (நானோ விநாடி தெளிவுத்திறன் தேவையற்றதாக இருக்கலாம்). பாண்டாஸ் நேரத் தொடர் தரவை மிகவும் திறமையாகக் கையாளுகிறது.

டேட்டாஃபிரேம் செயல்பாடுகளை மேம்படுத்துதல்

தரவு வகைகளை மேம்படுத்துவதோடு மட்டுமல்லாமல், பாண்டாஸ் டேட்டாஃபிரேம்களில் நீங்கள் செய்யும் செயல்பாடுகளை மேம்படுத்துவதன் மூலம் அவற்றின் செயல்திறனை மேம்படுத்தலாம். இங்கே சில பொதுவான நுட்பங்கள் உள்ளன:

1. வெக்டரைசேஷன்

வெக்டரைசேஷன் என்பது தனிப்பட்ட உறுப்புகளை மீண்டும் மீண்டும் செய்வதை விட, முழு வரிசைகள் அல்லது நெடுவரிசைகளில் ஒரே நேரத்தில் செயல்பாடுகளைச் செய்வதாகும். பாண்டாஸ் வெக்டரைஸ்டு செயல்பாடுகளுக்கு மிகவும் உகந்ததாக உள்ளது, எனவே அவற்றைப் பயன்படுத்துவது செயல்திறனை கணிசமாக மேம்படுத்தும். முடிந்தவரை வெளிப்படையான சுழல்களைத் தவிர்க்கவும். பாண்டாஸின் உள்ளமைக்கப்பட்ட செயல்பாடுகள் பொதுவாக சமமான பைதான் சுழல்களை விட மிக வேகமாக இருக்கும்.

எடுத்துக்காட்டு: ஒவ்வொரு மதிப்பிற்கும் வர்க்கமூலம் கணக்கிட ஒரு நெடுவரிசை வழியாக மீண்டும் மீண்டும் செல்வதற்குப் பதிலாக, pow() செயல்பாட்டைப் பயன்படுத்தவும்:

            # Inefficient (using a loop)
import time

start_time = time.time()
results = []
for value in df['col2']:
    results.append(value ** 2)
df['col2_squared_loop'] = results
end_time = time.time()
print(f"Loop time: {end_time - start_time:.4f} seconds")

# Efficient (using vectorization)
start_time = time.time()
df['col2_squared_vectorized'] = df['col2'] ** 2
end_time = time.time()
print(f"Vectorized time: {end_time - start_time:.4f} seconds")


            

              
                Copy
              
            
          

வெக்டரைஸ்டு அணுகுமுறை பொதுவாக சுழற்சி அடிப்படையிலான அணுகுமுறையை விட பல மடங்கு வேகமாக இருக்கும்.

2. `apply()` முறையை எச்சரிக்கையுடன் பயன்படுத்துதல்

apply() முறையானது ஒரு டேட்டாஃபிரேமின் ஒவ்வொரு வரிசை அல்லது நெடுவரிசைக்கும் ஒரு செயல்பாட்டைப் பயன்படுத்த உங்களை அனுமதிக்கிறது. இருப்பினும், இது பொதுவாக வெக்டரைஸ்டு செயல்பாடுகளை விட மெதுவாக இருக்கும், ஏனெனில் இது ஒவ்வொரு உறுப்பிற்கும் ஒரு பைதான் செயல்பாட்டை அழைப்பதை உள்ளடக்குகிறது. வெக்டரைஸ்டு செயல்பாடுகள் சாத்தியமில்லாதபோது மட்டுமே apply() ஐப் பயன்படுத்தவும்.

நீங்கள் `apply()` ஐப் பயன்படுத்த வேண்டும் என்றால், நீங்கள் பயன்படுத்தும் செயல்பாட்டை முடிந்தவரை வெக்டரைஸ் செய்ய முயற்சிக்கவும். குறிப்பிடத்தக்க செயல்திறன் மேம்பாடுகளுக்கு, செயல்பாட்டை இயந்திரக் குறியீட்டிற்குத் தொகுக்க நும்பாவின் `jit` டெக்கரேட்டரைப் பயன்படுத்தவும்.

            from numba import jit

@jit(nopython=True)
def my_function(x):
    return x * 2  # Example function

df['col2_applied'] = df['col2'].apply(my_function)

            

              
                Copy
              
            
          

3. நெடுவரிசைகளைத் திறமையாகத் தேர்ந்தெடுத்தல்

ஒரு டேட்டாஃபிரேமிலிருந்து நெடுவரிசைகளின் துணைக்குழுவைத் தேர்ந்தெடுக்கும்போது, உகந்த செயல்திறனுக்காக பின்வரும் முறைகளைப் பயன்படுத்தவும்:

• நேரடி நெடுவரிசைத் தேர்வு: df[['col1', 'col2']] (ஒரு சில நெடுவரிசைகளைத் தேர்ந்தெடுக்க வேகமானது)
• பூலியன் அட்டவணையிடல்: df.loc[:, [True if col.startswith('col') else False for col in df.columns]] (ஒரு நிபந்தனையின் அடிப்படையில் நெடுவரிசைகளைத் தேர்ந்தெடுக்கப் பயனுள்ளது)

நெடுவரிசைகளைத் தேர்ந்தெடுக்க வழக்கமான வெளிப்பாடுகளுடன் df.filter() ஐப் பயன்படுத்துவதைத் தவிர்க்கவும், ஏனெனில் இது மற்ற முறைகளை விட மெதுவாக இருக்கலாம்.

4. இணைப்புகள் மற்றும் ஒன்றிணைப்புகளை மேம்படுத்துதல்

டேட்டாஃபிரேம்களை இணைப்பதும் ஒன்றிணைப்பதும் கணினி ரீதியாக செலவாகும், குறிப்பாக பெரிய தரவுத்தொகுப்புகளுக்கு. இணைப்புகள் மற்றும் ஒன்றிணைப்புகளை மேம்படுத்துவதற்கான சில குறிப்புகள் இங்கே:

• பொருத்தமான இணைப்பு விசைகளைப் பயன்படுத்தவும்: இணைப்பு விசைகள் ஒரே தரவு வகையைக் கொண்டிருப்பதையும் அட்டவணையிடப்பட்டிருப்பதையும் உறுதிப்படுத்தவும்.
• இணைப்பு வகையைக் குறிப்பிடவும்: உங்கள் தேவைகளின் அடிப்படையில் பொருத்தமான இணைப்பு வகையை (எ.கா., inner, left, right, outer) பயன்படுத்தவும். ஒரு உள் இணைப்பு பொதுவாக வெளிப்புற இணைப்பை விட வேகமாக இருக்கும்.
• `join()` க்கு பதிலாக `merge()` ஐப் பயன்படுத்தவும்: merge() செயல்பாடு மிகவும் பல்துறை மற்றும் பெரும்பாலும் join() முறையை விட வேகமானது.

எடுத்துக்காட்டு:

            df1 = pd.DataFrame({'key': ['A', 'B', 'C', 'D'], 'value1': [1, 2, 3, 4]})
df2 = pd.DataFrame({'key': ['B', 'D', 'E', 'F'], 'value2': [5, 6, 7, 8]})

# Efficient inner join
df_merged = pd.merge(df1, df2, on='key', how='inner')

print(df_merged)

            

              
                Copy
              
            
          

5. தேவையற்ற முறையில் டேட்டாஃபிரேம்களை நகலெடுப்பதைத் தவிர்த்தல்

பல பாண்டாஸ் செயல்பாடுகள் டேட்டாஃபிரேம்களின் நகல்களை உருவாக்குகின்றன, இது நினைவகத்தை அதிகம் பயன்படுத்தும் மற்றும் நேரத்தை எடுத்துக்கொள்ளும். தேவையற்ற நகலெடுப்பைத் தவிர்க்க, கிடைக்கும்போது inplace=True வாதத்தைப் பயன்படுத்தவும் அல்லது ஒரு செயல்பாட்டின் முடிவை அசல் டேட்டாஃபிரேமிற்கு மீண்டும் ஒதுக்கவும். `inplace=True` உடன் மிகவும் எச்சரிக்கையாக இருங்கள், ஏனெனில் இது பிழைகளை மறைத்து, பிழைத்திருத்தத்தை கடினமாக்கும். செயல்திறன் சற்றே குறைவாக இருந்தாலும், மீண்டும் ஒதுக்குவது பெரும்பாலும் பாதுகாப்பானது.

எடுத்துக்காட்டு:

            # Inefficient (creates a copy)
df_filtered = df[df['col1'] > 500]

# Efficient (modifies the original DataFrame in place - CAUTION)
df.drop(df[df['col1'] <= 500].index, inplace=True)

#SAFER - reassigns, avoids inplace
df = df[df['col1'] > 500]

            

              
                Copy
              
            
          

6. துண்டுகளாகப் பிரித்தல் மற்றும் மீண்டும் மீண்டும் செய்தல்

நினைவகத்தில் பொருந்தாத மிக பெரிய தரவுத்தொகுப்புகளுக்கு, தரவை துண்டுகளாக செயலாக்குவதைக் கருத்தில் கொள்ளுங்கள். கோப்புகளிலிருந்து தரவைப் படிக்கும்போது `chunksize` அளவுருவைப் பயன்படுத்தவும். துண்டுகள் வழியாக மீண்டும் மீண்டும் சென்று ஒவ்வொரு துண்டிலும் உங்கள் பகுப்பாய்வை தனித்தனியாக செய்யவும். சில செயல்பாடுகளுக்கு முழு தரவுத்தொகுப்பையும் ஒரே நேரத்தில் செயலாக்க வேண்டியிருப்பதால், பகுப்பாய்வு சரியாக இருப்பதை உறுதிசெய்ய கவனமாக திட்டமிடல் தேவை.

            # Read CSV in chunks
for chunk in pd.read_csv('large_data.csv', chunksize=100000):
    # Process each chunk
    print(chunk.shape)

            

              
                Copy
              
            
          

7. இணைச் செயலாக்கத்திற்கான டாஸ்க் பயன்படுத்துதல்

டாஸ்க் என்பது பாண்டாஸுடன் தடையின்றி ஒருங்கிணைக்கும் ஒரு இணை கணினி நூலகமாகும். இது பெரிய டேட்டாஃபிரேம்களை இணையாகச் செயல்படுத்த உங்களை அனுமதிக்கிறது, இது செயல்திறனை கணிசமாக மேம்படுத்தும். டாஸ்க் டேட்டாஃபிரேமை சிறிய பிரிவுகளாகப் பிரித்து அவற்றை பல கோர்கள் அல்லது இயந்திரங்களில் விநியோகிக்கிறது.

            import dask.dataframe as dd

# Create a Dask DataFrame
ddf = dd.read_csv('large_data.csv')

# Perform operations on the Dask DataFrame
ddf_filtered = ddf[ddf['col1'] > 500]

# Compute the result (this triggers the parallel computation)
result = ddf_filtered.compute()

print(result.head())

            

              
                Copy
              
            
          

வேகமான தேடல்களுக்கு அட்டவணையிடல்

ஒரு நெடுவரிசையில் ஒரு குறியீட்டை உருவாக்குவது தேடல்கள் மற்றும் வடிகட்டுதல் செயல்பாடுகளை கணிசமாக வேகப்படுத்தும். ஒரு குறிப்பிட்ட மதிப்புடன் பொருந்தக்கூடிய வரிசைகளை விரைவாகக் கண்டறிய பாண்டாஸ் குறியீடுகளைப் பயன்படுத்துகிறது.

எடுத்துக்காட்டு:

            # Set 'col3' as the index
df = df.set_index('col3')

# Faster lookup
value = df.loc['A']

print(value)

# Reset the index
df = df.reset_index()

            

              
                Copy
              
            
          

இருப்பினும், அதிகமான குறியீடுகளை உருவாக்குவது நினைவகப் பயன்பாட்டை அதிகரிக்கலாம் மற்றும் எழுதும் செயல்பாடுகளை மெதுவாக்கலாம். அடிக்கடி தேடல்கள் அல்லது வடிகட்டுதலுக்குப் பயன்படுத்தப்படும் நெடுவரிசைகளில் மட்டுமே குறியீடுகளை உருவாக்கவும்.

பிற பரிசீலனைகள்

• வன்பொருள்: நீங்கள் தொடர்ந்து பெரிய தரவுத்தொகுப்புகளுடன் பணிபுரிகிறீர்கள் என்றால், உங்கள் வன்பொருளை (CPU, RAM, SSD) மேம்படுத்துவதைக் கருத்தில் கொள்ளுங்கள்.
• மென்பொருள்: நீங்கள் பாண்டாஸின் சமீபத்திய பதிப்பைப் பயன்படுத்துவதை உறுதிப்படுத்திக் கொள்ளுங்கள், ஏனெனில் புதிய பதிப்புகள் பெரும்பாலும் செயல்திறன் மேம்பாடுகளை உள்ளடக்கியிருக்கும்.
• சுயவிவரம்: உங்கள் குறியீட்டில் செயல்திறன் தடைகளை அடையாளம் காண சுயவிவரக் கருவிகளை (எ.கா., cProfile, line_profiler) பயன்படுத்தவும்.
• தரவு சேமிப்பு வடிவம்: CSV க்கு பதிலாக Parquet அல்லது Feather போன்ற மிகவும் திறமையான தரவு சேமிப்பு வடிவங்களைப் பயன்படுத்துவதைக் கருத்தில் கொள்ளுங்கள். இந்த வடிவங்கள் நெடுவரிசை சார்ந்தவை மற்றும் பெரும்பாலும் சுருக்கப்பட்டவை, இது சிறிய கோப்பு அளவுகள் மற்றும் வேகமான வாசிப்பு/எழுதுதல் நேரங்களுக்கு வழிவகுக்கிறது.

முடிவுரை

பெரிய தரவுத்தொகுப்புகளுடன் திறமையாகப் பணிபுரிய, பாண்டாஸ் டேட்டாஃபிரேம்களை நினைவகப் பயன்பாடு மற்றும் செயல்திறனுக்காக மேம்படுத்துவது முக்கியம். பொருத்தமான தரவு வகைகளைத் தேர்ந்தெடுப்பதன் மூலமும், வெக்டரைஸ்டு செயல்பாடுகளைப் பயன்படுத்துவதன் மூலமும், உங்கள் தரவை திறம்பட அட்டவணையிடுவதன் மூலமும், நீங்கள் நினைவகப் பயன்பாட்டை கணிசமாகக் குறைத்து செயல்திறனை மேம்படுத்தலாம். செயல்திறன் தடைகளை அடையாளம் காண உங்கள் குறியீட்டை சுயவிவரம் செய்ய நினைவில் கொள்ளுங்கள் மற்றும் மிக பெரிய தரவுத்தொகுப்புகளுக்கு துண்டுகளாக்குதல் அல்லது டாஸ்க் பயன்படுத்துவதைக் கருத்தில் கொள்ளுங்கள். இந்த நுட்பங்களைச் செயல்படுத்துவதன் மூலம், தரவு பகுப்பாய்வு மற்றும் கையாளுதலுக்கான பாண்டாஸின் முழு திறனையும் நீங்கள் திறக்கலாம்.