தீர்க்கப்பட்டது: பாண்டாஸ் தொடர்கள் தொடரில் உள்ள ஒவ்வொரு உருப்படிக்கும் சொல் சேர்க்கிறது

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

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

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

import pandas as pd

data = ['item1', 'item2', 'item3']
series = pd.Series(data)

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

word_to_add = "example"

இப்போது நாம் பயன்படுத்துவதன் மூலம் தொடர்வோம் .விண்ணப்பிக்கவும்() தொடரில் உள்ள ஒவ்வொரு உறுப்புக்கும் தேவையான வார்த்தையை சேர்க்கும் முறை.

series_with_added_word = series.apply(lambda x: x + ' ' + word_to_add)
print(series_with_added_word)

இது பின்வரும் வெளியீட்டை வழங்கும்:

0    item1 example
1    item2 example
2    item3 example
dtype: object

இப்போது நாம் இலக்கை வெற்றிகரமாக அடைந்துவிட்டோம், குறியீடு மற்றும் அதன் கூறுகளை இன்னும் விரிவாக விவாதிப்போம்.

பாண்டாஸ் தொடர்

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

Lambda செயல்பாடுகள் மற்றும் விண்ணப்பிக்க () முறை

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

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

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

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