பைத்தானில் இரண்டு பட்டியல்களை இணைத்தல்: முறைகள் மற்றும் எடுத்துக்காட்டுகள்

பைத்தானில் பட்டியல் ஒருங்கிணைப்பைப் புரிந்துகொள்வது

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

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

பட்டியல் ஒருங்கிணைப்பு நுட்பங்களைப் புரிந்துகொள்வது

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

மூன்றாவது முறை பட்டியல் புரிதலைப் பயன்படுத்துகிறது, உறுப்புகளைச் செயலாக்குவதற்கும் புதிய பட்டியலைத் திரும்பப் பெறுவதற்கும் ஒரு சிறிய மற்றும் திறமையான வழி. இந்த அணுகுமுறை மிகவும் தனிப்பயனாக்கக்கூடியது, இது ஒரு ஒற்றை வரி குறியீட்டிற்குள் சிக்கலான செயல்பாடுகளை அனுமதிக்கிறது. நான்காவது முறை இதில் அடங்கும் itertools.chain() itertools தொகுதியிலிருந்து, இது திறமையான மறு செய்கைக்காக வடிவமைக்கப்பட்டுள்ளது. இது பன்மடங்கு இட்டேரபிள்களை எடுத்து, ஒவ்வொரு செயலியிலிருந்தும் தனிமங்களை வரிசையாக அளிக்கும் ஒற்றை இட்டேட்டரை உருவாக்குகிறது. பெரிய தரவுத்தொகுப்புகளைக் கையாளுவதற்கு இந்த முறை மிகவும் பயனுள்ளதாக இருக்கும். இறுதி முறை பயன்படுத்தப்படுகிறது numpy.concatenate() NumPy நூலகத்திலிருந்து, எண் செயல்பாடுகளுக்கான சக்திவாய்ந்த கருவி. இது ஏற்கனவே இருக்கும் அச்சில் வரிசைகளின் வரிசையுடன் இணைகிறது tolist() இதன் விளைவாக வரும் வரிசையை மீண்டும் பைதான் பட்டியலுக்கு மாற்றும் முறை. இந்த முறை எண் தரவு சம்பந்தப்பட்ட காட்சிகளுக்கு உகந்தது மற்றும் NumPy இன் செயல்திறன் நன்மைகள் தேவை.

listone = [1, 2, 3]
listtwo = [4, 5, 6]
joinedlist = listone + listtwo
print(joinedlist)

listone = [1, 2, 3]
listtwo = [4, 5, 6]
listone.extend(listtwo)
print(listone)

listone = [1, 2, 3]
listtwo = [4, 5, 6]
joinedlist = [item for sublist in [listone, listtwo] for item in sublist]
print(joinedlist)

import itertools
listone = [1, 2, 3]
listtwo = [4, 5, 6]
joinedlist = list(itertools.chain(listone, listtwo))
print(joinedlist)

import numpy as np
listone = [1, 2, 3]
listtwo = [4, 5, 6]
joinedlist = np.concatenate((listone, listtwo)).tolist()
print(joinedlist)

பட்டியல் இணைப்புக்கான மேம்பட்ட நுட்பங்கள்

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

மற்றொரு மேம்பட்ட முறை பயன்படுத்துவதை உள்ளடக்கியது map() இணைந்து செயல்படும் lambda செயல்பாடுகள். தி map() செயல்பாடு உள்ளீட்டு பட்டியலில் உள்ள அனைத்து உருப்படிகளுக்கும் கொடுக்கப்பட்ட செயல்பாட்டைப் பயன்படுத்துகிறது, மேலும் lambda செயல்பாடு இந்த செயல்பாட்டை இன்லைனில் வரையறுக்கலாம். பட்டியலிலிருந்து ஒவ்வொரு ஜோடி உறுப்புகளுக்கும் சிக்கலான மாற்றங்களைப் பயன்படுத்துவதற்கு இந்த அணுகுமுறை சக்தி வாய்ந்தது. கூடுதலாக, பெரிய அளவிலான தரவு கையாளுதல், போன்ற நூலகங்களை மேம்படுத்துதல் pandas பயனளிக்க முடியும். தி pandas.concat() செயல்பாடு ஒரு குறிப்பிட்ட அச்சில் பட்டியல்களை (அல்லது தொடர் மற்றும் டேட்டாஃப்ரேம்கள்) இணைக்க அனுமதிக்கிறது, குறிப்பாக அட்டவணை தரவுகளுடன் பணிபுரியும் போது அதிக அளவிலான கட்டுப்பாடு மற்றும் செயல்திறனை வழங்குகிறது.

பட்டியல் இணைப்பு பற்றிய இறுதி எண்ணங்கள்

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