Pandas DataFrame உருவாக்கத்தின் கலையை மாஸ்டர் செய்யுங்கள். உலகளாவிய தரவு வல்லுநர்களுக்கான அகராதிகள், பட்டியல்கள், NumPy வரிசைகள் மற்றும் பலவற்றிலிருந்து DataFrames ஐ துவக்குவதை இந்த வழிகாட்டி உள்ளடக்குகிறது.
Pandas DataFrame உருவாக்கம்: தரவு அமைப்பு துவக்கத்தின் ஆழமான பார்வை
Python உடன் தரவு கையாளுதலின் உலகிற்கு வரவேற்கிறோம்! கிட்டத்தட்ட ஒவ்வொரு தரவு பகுப்பாய்வு பணியின் மையத்திலும் Pandas நூலகம் உள்ளது, மேலும் அதன் மூலக்கல் DataFrame ஆகும். உங்கள் Python சூழலில் வாழும் ஒரு விரிதாள் அல்லது தரவுத்தள அட்டவணையின் ஒரு ஸ்மார்ட், சக்திவாய்ந்த மற்றும் நெகிழ்வான பதிப்பாக DataFrame ஐ நினைத்துப் பாருங்கள். இது தரவை சுத்தம் செய்தல், மாற்றுதல், பகுப்பாய்வு செய்தல் மற்றும் காட்சிப்படுத்துவதற்கான முதன்மை கருவியாகும். ஆனால் இந்த தரவு மாயாஜாலத்தை நீங்கள் செய்வதற்கு முன், DataFrame ஐ உருவாக்கும் கலையில் நீங்கள் முதலில் தேர்ச்சி பெற வேண்டும். இந்த அடிப்படை தரவு கட்டமைப்பை நீங்கள் எவ்வாறு துவக்குகிறீர்கள் என்பது உங்கள் முழு பகுப்பாய்விற்கான களத்தை அமைக்கும்.
இந்த விரிவான வழிகாட்டி, ஆர்வமுள்ள மற்றும் பயிற்சி செய்யும் தரவு ஆய்வாளர்கள், விஞ்ஞானிகள் மற்றும் பொறியியலாளர்களின் உலகளாவிய பார்வையாளர்களுக்காக வடிவமைக்கப்பட்டுள்ளது. புதிதாக Pandas DataFrames ஐ உருவாக்குவதற்கான மிகவும் பொதுவான மற்றும் சக்திவாய்ந்த முறைகளை நாங்கள் ஆராய்வோம். உங்கள் தரவு ஒரு அகராதியில் இருந்தாலும், ஒரு பட்டியல், ஒரு NumPy வரிசை அல்லது வேறு வடிவில் இருந்தாலும், உங்கள் DataFrames ஐ நம்பிக்கையுடனும் திறமையுடனும் துவக்குவதற்கான அறிவையும் நடைமுறை உதாரணங்களையும் இந்த கட்டுரை உங்களுக்கு வழங்கும். எங்கள் அடித்தளத்தை உருவாக்குவோம்.
Pandas DataFrame என்றால் என்ன?
நாங்கள் கட்டத் தொடங்குவதற்கு முன், நாங்கள் என்ன கட்டுகிறோம் என்பதை தெளிவுபடுத்துவோம். Pandas DataFrame என்பது இரண்டு பரிமாண, அளவு மாற்றக்கூடிய மற்றும் சாத்தியமான மாறுபட்ட அட்டவணை தரவு அமைப்பு ஆகும். அதை உடைப்போம்:
- இரண்டு பரிமாணம்: இது ஒரு விரிதாள் போன்ற வரிசைகள் மற்றும் நெடுவரிசைகளைக் கொண்டுள்ளது.
- அளவு மாற்றக்கூடியது: DataFrame உருவாக்கப்பட்ட பிறகு நீங்கள் வரிசைகள் மற்றும் நெடுவரிசைகளைச் சேர்க்கலாம் அல்லது அகற்றலாம்.
- மாறுபட்டது: நெடுவரிசைகள் வெவ்வேறு தரவு வகைகளைக் கொண்டிருக்கலாம். உதாரணமாக, ஒரு நெடுவரிசையில் எண்கள் (முழு எண்கள் அல்லது மிதவைகள்) இருக்கலாம், மற்றொன்றில் உரை (சரம்) இருக்கலாம், மூன்றாவது தேதிகள் அல்லது பூலியன் மதிப்புகள் (உண்மை/தவறு) இருக்கலாம்.
DataFrame மூன்று முக்கிய கூறுகளைக் கொண்டுள்ளது:
- தரவு: அமைப்புக்குள் உள்ள உண்மையான மதிப்புகள், வரிசைகள் மற்றும் நெடுவரிசைகளில் ஒழுங்கமைக்கப்பட்டுள்ளன.
- குறியீட்டு: வரிசைகளுக்கான லேபிள்கள். நீங்கள் ஒரு குறியீட்டை வழங்கவில்லை என்றால், Pandas 0 இலிருந்து தொடங்கும் இயல்புநிலை ஒன்றை உருவாக்குகிறது. குறியீடானது தரவை அணுகுவதற்கும் சீரமைப்பதற்கும் ஒரு சக்திவாய்ந்த வழியை வழங்குகிறது.
- நெடுவரிசைகள்: நெடுவரிசைகளுக்கான லேபிள்கள். DataFrame க்குள் உள்ள குறிப்பிட்ட தரவுத் தொடர்களை அணுகுவதற்கு இவை முக்கியமானவை.
இந்த கட்டமைப்பைப் புரிந்துகொள்வது DataFrames ஐ திறம்பட உருவாக்குவது மற்றும் கையாளுவது எப்படி என்பதைப் புரிந்துகொள்வதற்கு முக்கியமாகும்.
அடித்தளம்: Pandas ஐ இறக்குமதி செய்தல்
முதல் விஷயங்கள் முதலில். Pandas ஐப் பயன்படுத்த, உங்கள் Python ஸ்கிரிப்ட் அல்லது நோட்புக்கில் நூலகத்தை இறக்குமதி செய்ய வேண்டும். உலகளவில் உள்ள வல்லுநர்கள் பின்பற்றும் உலகளவில் ஏற்றுக்கொள்ளப்பட்ட மாநாடு, அதை pd என்ற புனைப்பெயருடன் இறக்குமதி செய்வதாகும். இந்த எளிய புனைப்பெயர் உங்கள் குறியீட்டை மேலும் படிக்கக்கூடியதாகவும் சுருக்கமாகவும் ஆக்குகிறது.
import pandas as pd
import numpy as np # பெரும்பாலும் Pandas உடன் பயன்படுத்தப்படுகிறது, எனவே அதையும் இறக்குமதி செய்வோம்.
இந்த ஒற்றை வரியின் மூலம், Pandas நூலகத்தின் முழு சக்தியையும் நீங்கள் திறந்திருக்கிறீர்கள். இப்போது, இந்த வழிகாட்டியின் மையத்திற்குச் செல்வோம்: DataFrames ஐ உருவாக்குதல்.
முக்கிய உருவாக்கும் முறைகள்: எளிமையானது முதல் சிக்கலானது வரை
pd.DataFrame() கட்டமைப்பாளர் நம்பமுடியாத பல்துறை திறன் கொண்டவர். இது பலவிதமான உள்ளீட்டு வகைகளை ஏற்க முடியும். இப்போது நாம் மிகவும் பொதுவானது முதல் மிகவும் சிறப்பு வாய்ந்த வழக்குகள் வரை நகர்ந்து, மிக முக்கியமான முறைகளை ஆராய்வோம்.
1. பட்டியல்கள் அல்லது வரிசைகளின் அகராதியிலிருந்து DataFrame ஐ உருவாக்குதல்
DataFrame ஐ உருவாக்குவதற்கான மிகவும் பொதுவான மற்றும் உள்ளுணர்வு முறை இதுவாகும். நீங்கள் ஒரு Python அகராதியுடன் தொடங்குகிறீர்கள், அங்கு விசைகள் நெடுவரிசை பெயர்களாக மாறும், மேலும் ஒவ்வொரு நெடுவரிசைக்கும் தரவைக் கொண்ட பட்டியல்கள் (அல்லது NumPy வரிசைகள் அல்லது Pandas தொடர்கள்) மதிப்புகளாக இருக்கும்.
இது எப்படி வேலை செய்கிறது: Pandas ஒவ்வொரு அகராதி விசையையும் ஒரு நெடுவரிசை தலைப்புக்கும், ஒவ்வொரு மதிப்பு பட்டியலையும் அந்த நெடுவரிசையின் வரிசைகளுக்கும் வரைபடமாக்குகிறது. இங்கே ஒரு முக்கியமான தேவை என்னவென்றால், அனைத்து பட்டியல்களும் ஒரே நீளத்தைக் கொண்டிருக்க வேண்டும், ஏனெனில் ஒவ்வொரு பட்டியலும் தரவின் முழு நெடுவரிசையைக் குறிக்கிறது.
உதாரணமாக:
உலகெங்கிலும் உள்ள வெவ்வேறு நகரங்களைப் பற்றிய தகவல்களைக் கொண்ட DataFrame ஐ உருவாக்குவோம்.
# நெடுவரிசையின் படி ஒழுங்கமைக்கப்பட்ட தரவு
city_data = {
'City': ['Tokyo', 'Delhi', 'Shanghai', 'São Paulo', 'Mumbai'],
'Country': ['Japan', 'India', 'China', 'Brazil', 'India'],
'Population_Millions': [37.3, 32.0, 28.5, 22.4, 20.9],
'Is_Coastal': [True, False, True, False, True]
}
# DataFrame ஐ உருவாக்கவும்
df_from_dict = pd.DataFrame(city_data)
print(df_from_dict)
வெளியீடு:
City Country Population_Millions Is_Coastal
0 Tokyo Japan 37.3 True
1 Delhi India 32.0 False
2 Shanghai China 28.5 True
3 São Paulo Brazil 22.4 False
4 Mumbai India 20.9 True
முக்கிய கருத்து: உங்கள் தரவு இயற்கையாகவே அம்சம் அல்லது வகையால் ஒழுங்கமைக்கப்பட்டிருக்கும்போது இந்த முறை சரியானது. இது சுத்தமாகவும் படிக்கக்கூடியதாகவும் உள்ளது, மேலும் உங்கள் அகராதியின் கட்டமைப்பை ஒரு அட்டவணை வடிவமாக நேரடியாக மொழிபெயர்க்கிறது.
2. அகராதிகளின் பட்டியலிலிருந்து DataFrame ஐ உருவாக்குதல்
ஒவ்வொரு உறுப்பும் ஒரு அகராதியாக இருக்கும் ஒரு பட்டியலைப் பயன்படுத்துவது ஒரு மாற்று மற்றும் சமமான சக்திவாய்ந்த முறையாகும். இந்த கட்டமைப்பில், ஒவ்வொரு அகராதியும் ஒரு வரிசையைக் குறிக்கிறது, மேலும் அதன் விசைகள் அந்த வரிசையின் தரவுக்கான நெடுவரிசை பெயர்களைக் குறிக்கின்றன.
இது எப்படி வேலை செய்கிறது: Pandas பட்டியலின் மூலம் மீண்டும் மீண்டும் வருகிறது. ஒவ்வொரு அகராதிக்கும், இது ஒரு புதிய வரிசையை உருவாக்குகிறது. நெடுவரிசைகளைத் தீர்மானிக்க அகராதி விசைகள் பயன்படுத்தப்படுகின்றன. இந்த முறை நம்பமுடியாத அளவிற்கு நெகிழ்வானது, ஏனெனில் ஒரு அகராதியில் ஒரு விசை காணவில்லை என்றால், Pandas அந்த செல்லை அந்தந்த வரிசையில் NaN (எண் அல்ல) தானாக நிரப்பும், இது Pandas இல் காணாமல் போன தரவுகளுக்கான நிலையான குறிப்பான் ஆகும்.
உதாரணமாக:
அதே நகர தரவை பிரதிநிதித்துவப்படுத்துவோம், ஆனால் இந்த முறை பதிவுகளின் பட்டியலாக கட்டமைக்கப்பட்டுள்ளது.
# வரிசையின் படி (பதிவு) ஒழுங்கமைக்கப்பட்ட தரவு
records_data = [
{'City': 'Tokyo', 'Country': 'Japan', 'Population_Millions': 37.3, 'Is_Coastal': True},
{'City': 'Delhi', 'Country': 'India', 'Population_Millions': 32.0, 'Is_Coastal': False},
{'City': 'Shanghai', 'Country': 'China', 'Population_Millions': 28.5},
{'City': 'São Paulo', 'Country': 'Brazil', 'Population_Millions': 22.4, 'Is_Coastal': False},
{'City': 'Cairo', 'Country': 'Egypt', 'Timezone': 'EET'} # வேறுபட்ட கட்டமைப்பைக் கவனியுங்கள்
]
# DataFrame ஐ உருவாக்கவும்
df_from_list_of_dicts = pd.DataFrame(records_data)
print(df_from_list_of_dicts)
வெளியீடு:
City Country Population_Millions Is_Coastal Timezone
0 Tokyo Japan 37.3 True NaN
1 Delhi India 32.0 False NaN
2 Shanghai China 28.5 NaN NaN
3 São Paulo Brazil 22.4 False NaN
4 Cairo Egypt NaN NaN EET
Pandas முரண்பாடுகளை எவ்வாறு நேர்த்தியாகக் கையாண்டது என்பதை கவனியுங்கள். ஷாங்காய்க்கான 'Is_Coastal' மதிப்பு NaN ஆகும், ஏனெனில் அது அதன் அகராதியில் இல்லை. கெய்ரோவுக்கு ஒரு புதிய 'Timezone' நெடுவரிசை உருவாக்கப்பட்டது, மற்ற அனைத்து நகரங்களுக்கும் NaN உள்ளது. JSON பதில்கள் போன்ற அரை-கட்டமைக்கப்பட்ட தரவுடன் பணிபுரிவதற்கு இது ஒரு சிறந்த தேர்வாக அமைகிறது.
முக்கிய கருத்து: உங்கள் தரவு தொடர்ச்சியான பதிவுகள் அல்லது அவதானிப்புகளாக வரும்போது இந்த முறையைப் பயன்படுத்தவும். காணாமல் போன தரவு மற்றும் பதிவு கட்டமைப்பில் உள்ள மாறுபாடுகளை கையாளுவதில் இது வலுவானது.
3. NumPy வரிசையிலிருந்து DataFrame ஐ உருவாக்குதல்
அறிவியல் கம்ப்யூட்டிங், மெஷின் லேர்னிங் அல்லது அதிக எண் கணித செயல்பாடுகளை உள்ளடக்கிய எந்தவொரு துறையில் பணிபுரிபவர்களுக்கு, தரவு பெரும்பாலும் NumPy வரிசைகளில் இருந்து வருகிறது. Pandas NumPy இன் மேல் கட்டப்பட்டுள்ளது, இது இரண்டுக்கும் இடையிலான ஒருங்கிணைப்பை தடையற்றதாகவும் மிகவும் திறமையாகவும் ஆக்குகிறது.
இது எப்படி வேலை செய்கிறது: நீங்கள் 2D NumPy வரிசையை pd.DataFrame() கட்டமைப்பாளருக்கு அனுப்புகிறீர்கள். இயல்பாக, Pandas முழு எண் அடிப்படையிலான குறியீடுகள் மற்றும் நெடுவரிசைகளை உருவாக்கும். இருப்பினும், index மற்றும் columns அளவுருக்களைப் பயன்படுத்தி நீங்கள் அர்த்தமுள்ள லேபிள்களை வழங்கலாம் (மற்றும் வழங்க வேண்டும்).
உதாரணமாக:
சீரற்ற முறையில் உருவாக்கப்பட்ட 5x4 NumPy வரிசையிலிருந்து ஒரு DataFrame ஐ உருவாக்குவோம், இது காலப்போக்கில் சென்சார் அளவீடுகளைக் குறிக்கிறது.
# சீரற்ற தரவுகளுடன் 5x4 NumPy வரிசையை உருவாக்கவும்
data_np = np.random.rand(5, 4)
# நெடுவரிசை மற்றும் குறியீட்டு லேபிள்களை வரையறுக்கவும்
columns = ['Sensor_A', 'Sensor_B', 'Sensor_C', 'Sensor_D']
index = pd.to_datetime(['2023-10-27 10:00', '2023-10-27 10:01', '2023-10-27 10:02', '2023-10-27 10:03', '2023-10-27 10:04'])
# DataFrame ஐ உருவாக்கவும்
df_from_numpy = pd.DataFrame(data=data_np, index=index, columns=columns)
print(df_from_numpy)
வெளியீடு (உங்கள் சீரற்ற எண்கள் வேறுபடும்):
Sensor_A Sensor_B Sensor_C Sensor_D
2023-10-27 10:00:00 0.123456 0.987654 0.555555 0.111111
2023-10-27 10:01:00 0.234567 0.876543 0.666666 0.222222
2023-10-27 10:02:00 0.345678 0.765432 0.777777 0.333333
2023-10-27 10:03:00 0.456789 0.654321 0.888888 0.444444
2023-10-27 10:04:00 0.567890 0.543210 0.999999 0.555555
இந்த எடுத்துக்காட்டில், ஒரு சக்திவாய்ந்த அம்சத்தையும் நாங்கள் அறிமுகப்படுத்தியுள்ளோம்: நேரத் தொடர் தரவுகளுக்கு DatetimeIndex ஐப் பயன்படுத்துதல், இது Pandas இல் நேர அடிப்படையிலான பகுப்பாய்வு திறன்களின் பரந்த வரிசையைத் திறக்கிறது.
முக்கிய கருத்து: ஒரே மாதிரியான எண் தரவிலிருந்து DataFrame ஐ உருவாக்குவதற்கான மிகவும் நினைவக திறன் கொண்ட முறை இதுவாகும். NumPy, Scikit-learn அல்லது TensorFlow போன்ற நூலகங்களுடன் இடைமுகத்தை எடுக்கும்போது இது நிலையான தேர்வாகும்.
4. பட்டியல்களின் பட்டியலிலிருந்து DataFrame ஐ உருவாக்குதல்
இந்த முறை கருத்தியல் ரீதியாக NumPy வரிசையிலிருந்து உருவாக்குவதைப் போன்றது, ஆனால் நிலையான Python பட்டியல்களைப் பயன்படுத்துகிறது. ஒரு நெஸ்ட்டு பட்டியலில் சேமிக்கப்பட்ட அட்டவணை தரவை மாற்றுவதற்கான நேரடியான வழி இதுவாகும்.
இது எப்படி வேலை செய்கிறது: ஒவ்வொரு உள் பட்டியலும் தரவின் வரிசையைக் குறிக்கும் ஒரு பட்டியலை நீங்கள் வழங்குகிறீர்கள். NumPy வரிசைகளைப் போலவே, தெளிவுக்காக columns அளவுரு மூலம் நெடுவரிசை பெயர்களைக் குறிப்பிடுவது மிகவும் பரிந்துரைக்கப்படுகிறது.
உதாரணமாக:
# வரிசைகளின் பட்டியலாக தரவு
product_data = [
['P001', 'Laptop', 1200.00, 'Electronics'],
['P002', 'Mouse', 25.50, 'Electronics'],
['P003', 'Desk Chair', 150.75, 'Furniture'],
['P004', 'Keyboard', 75.00, 'Electronics']
]
# நெடுவரிசை பெயர்களை வரையறுக்கவும்
column_names = ['ProductID', 'ProductName', 'Price_USD', 'Category']
# DataFrame ஐ உருவாக்கவும்
df_from_list_of_lists = pd.DataFrame(product_data, columns=column_names)
print(df_from_list_of_lists)
வெளியீடு:
ProductID ProductName Price_USD Category 0 P001 Laptop 1200.00 Electronics 1 P002 Mouse 25.50 Electronics 2 P003 Desk Chair 150.75 Furniture 3 P004 Keyboard 75.00 Electronics
முக்கிய கருத்து: தலைப்புகள் இல்லாத ஒரு கோப்பு வடிவமைப்பிலிருந்து படிக்கும்போது, உங்கள் தரவு ஏற்கனவே வரிசைகளின் பட்டியலாக கட்டமைக்கப்பட்டிருக்கும்போது இது ஒரு எளிய மற்றும் பயனுள்ள முறையாகும்.
மேம்பட்ட துவக்கம்: உங்கள் DataFrame ஐத் தனிப்பயனாக்குதல்
மூல தரவை வழங்குவதைத் தவிர, pd.DataFrame() கட்டமைப்பாளர் அதன் உருவாக்கும் தருணத்திலிருந்து உங்கள் புதிய DataFrame இன் கட்டமைப்பு மற்றும் பண்புகளைக் கட்டுப்படுத்த பல அளவுருக்களை வழங்குகிறார்.
குறியீட்டைக் குறிப்பிடுதல்
`index` அளவுரு செயலில் இருப்பதை நாங்கள் ஏற்கனவே பார்த்திருக்கிறோம். DataFrame இன் ஒரு முக்கியமான பகுதியாக குறியீடானது வரிசைகளுக்கான லேபிள்களை வழங்குகிறது, அவை வேகமான தேடல்கள், தரவு சீரமைப்பு மற்றும் பலவற்றிற்காகப் பயன்படுத்தப்படுகின்றன. Pandas இயல்புநிலை எண் குறியீட்டை (0, 1, 2, ...) வழங்கும்போது, அர்த்தமுள்ள குறியீட்டை அமைப்பது உங்கள் தரவுடன் பணிபுரிவதை மிகவும் எளிதாக்கும்.
உதாரணமாக: எங்கள் பட்டியல்களின் அகராதி உதாரணத்தை மீண்டும் பயன்படுத்துவோம், ஆனால் உருவாக்கும்போது `City` நெடுவரிசையை குறியீடாக அமைப்போம்.
city_data = {
'Country': ['Japan', 'India', 'China', 'Brazil', 'India'],
'Population_Millions': [37.3, 32.0, 28.5, 22.4, 20.9],
'Is_Coastal': [True, False, True, False, True]
}
city_names = ['Tokyo', 'Delhi', 'Shanghai', 'São Paulo', 'Mumbai']
# தனிப்பயன் குறியீட்டுடன் DataFrame ஐ உருவாக்கவும்
df_with_index = pd.DataFrame(city_data, index=city_names)
print(df_with_index)
வெளியீடு:
Country Population_Millions Is_Coastal
Tokyo Japan 37.3 True
Delhi India 32.0 False
Shanghai China 28.5 True
São Paulo Brazil 22.4 False
Mumbai India 20.9 True
இப்போது, இந்த அர்த்தமுள்ள லேபிள்களைப் பயன்படுத்தி வரிசை தரவை அணுகலாம், உதாரணமாக, df_with_index.loc['Tokyo'] உடன்.
தரவு வகைகளைக் கட்டுப்படுத்துதல் (`dtype`)
தரவு வகைகளை (எ.கா., எண்கள், உரை மற்றும் பூலியன்களை அங்கீகரித்தல்) ஊகிப்பதில் Pandas மிகவும் சிறந்தது. இருப்பினும், சில சமயங்களில் நினைவகத் திறனை உறுதிப்படுத்த அல்லது குறிப்பிட்ட செயல்பாடுகளை இயக்க ஒரு நெடுவரிசைக்கு ஒரு குறிப்பிட்ட தரவு வகையை நீங்கள் செயல்படுத்த வேண்டும். `dtype` அளவுரு உங்களுக்கு இந்த கட்டுப்பாட்டை வழங்குகிறது.
உதாரணமாக: எங்களிடம் எண்களைப் போல் தோன்றும் தயாரிப்பு ஐடிகள் உள்ளன, ஆனால் அவை உரை (சரம்) ஆக கருதப்பட வேண்டும்.
data = {
'ProductID': [101, 102, 103],
'Stock': [50, 75, 0]
}
# 'ProductID' க்கான dtype ஐக் குறிப்பிடும்போது DataFrame ஐ உருவாக்கவும்
df_types = pd.DataFrame(data, dtype={'ProductID': str, 'Stock': 'int32'})
print(df_types.dtypes)
வெளியீடு:
ProductID object Stock int32 dtype: object
Pandas இல் `str` `object` ஆக குறிப்பிடப்படுகிறது என்பதை கவனியுங்கள். `dtype` ஐ வெளிப்படையாக அமைப்பதன் மூலம், `ProductID` ஐ ஒரு எண்ணாகக் கருதுவதிலிருந்து Pandas ஐத் தடுக்கிறோம், இது தவறான கணக்கீடுகளுக்கு வழிவகுக்கும் அல்லது வரிசைப்படுத்தும் சிக்கல்களை ஏற்படுத்தும். இயல்புநிலை `int64` க்கு பதிலாக `int32` போன்ற குறிப்பிட்ட முழு எண் வகைகளைப் பயன்படுத்துவது பெரிய தரவுத்தொகுப்புகளுடன் குறிப்பிடத்தக்க நினைவகத்தை சேமிக்க முடியும்.
நடைமுறை காட்சிகள் மற்றும் சிறந்த நடைமுறைகள்
சரியான உருவாக்கும் முறையைத் தேர்ந்தெடுப்பது உங்கள் தரவின் அசல் வடிவமைப்பைப் பொறுத்தது. இங்கே ஒரு எளிய முடிவு வழிகாட்டி உள்ளது:
- உங்கள் தரவு நெடுவரிசைகளில் உள்ளதா (எ.கா., ஒரு அம்சம் ஒன்றுக்கு ஒரு பட்டியல்)? பட்டியல்களின் அகராதியைப் பயன்படுத்தவும். இது ஒரு இயற்கையான பொருத்தம்.
- உங்கள் தரவு தொடர்ச்சியான பதிவுகளா (எ.கா., JSON API இலிருந்து)? அகராதிகளின் பட்டியல்யைப் பயன்படுத்தவும். இது பதிவுகளில் காணாமல் போன அல்லது கூடுதல் புலங்களைக் கையாளுவதில் சிறந்தது.
- உங்கள் தரவு எண் மற்றும் ஒரு கட்டத்தில் உள்ளதா (எ.கா., ஒரு அறிவியல் கணக்கீட்டிலிருந்து)? NumPy வரிசையைப் பயன்படுத்தவும். இந்த பயன்பாட்டிற்கான மிகவும் திறமையான விருப்பம் இதுவாகும்.
- உங்கள் தரவு தலைப்புகள் இல்லாத ஒரு எளிய வரிசை-வரிசை அட்டவணை வடிவத்தில் உள்ளதா? பட்டியல்களின் பட்டியல்யைப் பயன்படுத்தி நெடுவரிசை பெயர்களைத் தனித்தனியாக வழங்கவும்.
தவிர்க்க வேண்டிய பொதுவான தவறுகள்
- பட்டியல்களின் அகராதியில் சமமற்ற நீளங்கள்: இது ஒரு பொதுவான பிழை. பட்டியல்களின் அகராதியிலிருந்து DataFrame ஐ உருவாக்கும்போது, ஒவ்வொரு பட்டியலிலும் ஒரே எண்ணிக்கையிலான கூறுகள் இருக்க வேண்டும். இல்லையெனில், Pandas ஒரு `ValueError` ஐ உயர்த்தும். உருவாக்கும் முன் உங்கள் நெடுவரிசை தரவு சம நீளமாக இருப்பதை எப்போதும் உறுதிப்படுத்தவும்.
- குறியீட்டைப் புறக்கணித்தல்: இயல்புநிலை 0-அடிப்படையிலான குறியீட்டை நம்புவது பல சந்தர்ப்பங்களில் நல்லது, ஆனால் உங்கள் தரவில் இயற்கையான அடையாளங்காட்டி இருந்தால் (தயாரிப்பு ஐடி, பயனர் ஐடி அல்லது ஒரு குறிப்பிட்ட நேரக்குறி போன்றது), அதை ஆரம்பத்தில் இருந்து குறியீடாக அமைப்பது உங்கள் குறியீட்டை பின்னர் எளிதாக்கும்.
- தரவு வகைகளை மறந்துவிடுதல்: வகைகள் அனைத்தையும் யூகிக்க Pandas ஐ அனுமதிப்பது பெரும்பாலான நேரங்களில் வேலை செய்கிறது, ஆனால் பெரிய தரவுத்தொகுப்புகள் அல்லது கலப்பு வகைகளைக் கொண்ட நெடுவரிசைகளுக்கு, செயல்திறன் பாதிக்கப்படலாம். நினைவகத்தைச் சேமிக்கவும் பிழைகளைத் தடுக்கவும் வகைகள், சரங்கள் அல்லது குறிப்பிட்ட எண் வகைகளாகக் கருதப்பட வேண்டிய நெடுவரிசைகளுக்கு `dtype` ஐ அமைப்பதில் செயலூக்கத்துடன் இருங்கள்.
துவக்கத்திற்கு அப்பால்: கோப்புகளிலிருந்து DataFrames ஐ உருவாக்குதல்
இந்த வழிகாட்டி நினைவகத்தில் உள்ள Python ஆப்ஜெக்ட்களிலிருந்து DataFrames ஐ உருவாக்குவதில் கவனம் செலுத்துகிறது என்றாலும், பெரும்பாலான நிஜ உலக காட்சிகளில், உங்கள் தரவு வெளிப்புற கோப்பிலிருந்து வரும் என்பதை அறிந்து கொள்வது அவசியம். இந்த நோக்கத்திற்காக Pandas அதிகபட்சமாக மேம்படுத்தப்பட்ட ரீடர் செயல்பாடுகளின் தொகுப்பை வழங்குகிறது, இதில்:
pd.read_csv(): காற்புள்ளி பிரிக்கப்பட்ட மதிப்புகள் கோப்புகளுக்கு, தரவு இறக்குமதியின் பணிக்குதிரை.pd.read_excel(): Microsoft Excel விரிதாள்களிலிருந்து தரவைப் படிக்க.pd.read_json(): JSON கோப்புகள் அல்லது சரங்களிலிருந்து தரவைப் படிக்க.pd.read_sql(): ஒரு தரவுத்தள வினவலின் முடிவுகளை நேரடியாக ஒரு DataFrame க்குள் படிக்க.pd.read_parquet(): திறமையான, நெடுவரிசை சார்ந்த Parquet கோப்பு வடிவத்திலிருந்து படிக்க.
இந்த செயல்பாடுகள் உங்கள் Pandas பயணத்தில் அடுத்த தர்க்கரீதியான படி. அவற்றைக் கற்றுக்கொள்வது எந்த மூலத்திலிருந்தும் தரவை ஒரு சக்திவாய்ந்த DataFrame கட்டமைப்பில் உட்கொள்ள உங்களை அனுமதிக்கும்.
முடிவுரை: தரவு தேர்ச்சிக்கான உங்கள் அடித்தளம்
Pandas DataFrame என்பது Python இல் எந்த தீவிர தரவு வேலைக்கும் மைய தரவு அமைப்பு ஆகும். நாம் பார்த்தபடி, Pandas இந்த கட்டமைப்புகளை பல்வேறு வடிவங்களிலிருந்து துவக்குவதற்கு நெகிழ்வான மற்றும் உள்ளுணர்வு கருவிகளின் தொகுப்பை வழங்குகிறது. அகராதிகள், பட்டியல்கள் மற்றும் NumPy வரிசைகளிலிருந்து DataFrame ஐ எவ்வாறு உருவாக்குவது என்பதைப் புரிந்துகொள்வதன் மூலம், உங்கள் தரவு பகுப்பாய்வு திட்டங்களுக்கான உறுதியான அடித்தளத்தை நீங்கள் உருவாக்கியுள்ளீர்கள்.
உங்கள் தரவின் அசல் அமைப்புக்கு மிகவும் பொருத்தமான முறையைத் தேர்ந்தெடுப்பதே முக்கியமாகும். இது உங்கள் குறியீட்டை சுத்தமாகவும் படிக்கக்கூடியதாகவும் ஆக்குவது மட்டுமல்லாமல், மிகவும் திறமையாகவும் ஆக்குகிறது. இங்கிருந்து, தரவு சுத்தம் செய்தல், ஆய்வு செய்தல், மாற்றுதல் மற்றும் காட்சிப்படுத்துதல் போன்ற அற்புதமான பணிகளுக்கு செல்ல நீங்கள் தயாராக உள்ளீர்கள். மகிழ்ச்சியான குறியீடாக்கம்!