பைதான் பட்டியலில் ஒரு பொருளின் குறியீட்டைக் கண்டறிதல்

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

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

எடுத்துக்காட்டாக, ["foo", "bar", "baz"] போன்ற பட்டியலையும், "bar" போன்ற ஒரு பொருளையும் கொடுத்தால், அதன் நிலையை எவ்வாறு திறமையாகக் கண்டறிவது என்பது அவசியம். பைத்தானின் உள்ளமைக்கப்பட்ட முறைகளைப் பயன்படுத்தி பட்டியலில் உள்ள ஒரு பொருளின் குறியீட்டைக் கண்டறியும் செயல்முறையை இந்த வழிகாட்டி விளக்குகிறது.

பைதான் ஸ்கிரிப்ட்களின் விரிவான விளக்கம்

முதல் ஸ்கிரிப்ட் பைத்தானைப் பயன்படுத்தி பட்டியலில் உள்ள ஒரு பொருளின் குறியீட்டைக் கண்டறிய ஒரு நேரடியான முறையைக் காட்டுகிறது. .index() முறை. பட்டியல் கொடுக்கப்பட்டது my_list போன்ற கூறுகளைக் கொண்டது ["foo", "bar", "baz"], தி .index() முறை உருப்படியுடன் அழைக்கப்படுகிறது "bar" அதன் நிலையை மீட்டெடுக்க. பட்டியலில் உருப்படி இருந்தால், முறை அதன் குறியீட்டை வழங்குகிறது, அது அச்சிடப்படும். பட்டியலில் உள்ள உருப்படி உத்தரவாதம் அளிக்கப்பட்ட எளிய பயன்பாட்டு நிகழ்வுகளுக்கு இந்த அணுகுமுறை பயனுள்ளதாக இருக்கும். இருப்பினும், உருப்படி கிடைக்கவில்லை என்றால், அது ஒரு உயர்த்தும் ValueError, இயக்க நேர பிழைகளைத் தவிர்க்க இது கையாளப்பட வேண்டும்.

இரண்டாவது ஸ்கிரிப்ட், பிழை கையாளுதலை இணைப்பதன் மூலம் முதல் ஸ்கிரிப்டை மேம்படுத்துகிறது try: மற்றும் except ValueError: தொகுதிகள். பட்டியலில் உருப்படி காணப்படவில்லை எனில், நிரல் செயலிழப்பதற்குப் பதிலாக தனிப்பயன் பிழை செய்தி திரும்புவதை இது உறுதி செய்கிறது. இந்த ஸ்கிரிப்ட் ஒரு செயல்பாட்டை வரையறுக்கிறது get_index(my_list, item) குறிப்பிட்ட பொருளின் குறியீட்டைக் கண்டறிய முயற்சிக்கிறது. உருப்படி கண்டுபிடிக்கப்பட்டால், அது குறியீட்டை வழங்குகிறது; இல்லை என்றால், அது பிடிக்கிறது ValueError மற்றும் உருப்படி கிடைக்கவில்லை என்பதைக் குறிக்கும் செய்தியை வழங்குகிறது. இது செயல்பாட்டை மிகவும் வலுவானதாகவும், பட்டியலில் உருப்படியின் இருப்பு நிச்சயமற்ற சூழ்நிலைகளுக்கு ஏற்றதாகவும் ஆக்குகிறது.

மூன்றாவது ஸ்கிரிப்ட் பல உருப்படிகளைக் கையாள வடிவமைக்கப்பட்டுள்ளது, இது மிகவும் சிக்கலான பயன்பாட்டு வழக்கை நிரூபிக்கிறது. இது ஒரு செயல்பாட்டை வரையறுக்கிறது get_indices(my_list, items) இது ஒரு பட்டியலையும் தேட வேண்டிய உருப்படிகளின் மற்றொரு பட்டியலையும் எடுக்கும். இது ஒரு வெற்று பட்டியலை துவக்குகிறது indices முடிவுகளை சேமிக்க. செயல்பாடு பின்னர் பொருட்களைப் பயன்படுத்தி மீண்டும் செயல்படுகிறது for item in items: லூப், முக்கிய பட்டியலில் ஒவ்வொரு பொருளின் குறியீட்டையும் கண்டுபிடிக்க முயற்சிக்கிறது. உருப்படி கண்டுபிடிக்கப்பட்டால், அது உருப்படியின் ஒரு துப்பிளையும் அதன் குறியீட்டையும் இணைக்கிறது indices. இல்லையெனில், அது உருப்படி மற்றும் சரத்தின் ஒரு துப்பினைச் சேர்க்கிறது "not found". இந்த அணுகுமுறையானது, பல தேடல் வினவல்களை ஒரே பாஸில் செயலாக்குவதற்கும், திறன் மற்றும் வாசிப்புத்திறனை மேம்படுத்துவதற்கும் பயனுள்ளதாக இருக்கும்.

ஒட்டுமொத்தமாக, இந்த ஸ்கிரிப்டுகள் பைத்தானில் பட்டியல்களைத் தேடுவதற்கான அடிப்படை நுட்பங்களைக் காட்டுகின்றன, ஒவ்வொன்றும் சிக்கலான தன்மை மற்றும் வலிமையுடன். பயன்பாடு .index() அடிப்படை மீட்டெடுப்பிற்காக, இணைந்து try: மற்றும் except பிழை கையாளுதல் மற்றும் பல பொருட்களை செயலாக்குவதற்கான சுழல்கள், பைத்தானின் பட்டியல் செயல்பாடுகளின் பல்துறை மற்றும் ஆற்றலை எடுத்துக்காட்டுகிறது. இந்த ஸ்கிரிப்ட்கள் பல்வேறு பயன்பாட்டுத் தேவைகளுக்கு ஏற்றவாறு மாற்றியமைக்கப்பட்டு விரிவாக்கப்படலாம், எளிமையான தேடல்கள் முதல் மேம்பட்ட தரவு செயலாக்க பணிகள் வரை.

my_list = ["foo", "bar", "baz"]
item = "bar"
index = my_list.index(item)
print(f"The index of '{item}' is {index}")

def get_index(my_list, item):
    try:
        index = my_list.index(item)
        return index
    except ValueError:
        return f"'{item}' not found in the list"

my_list = ["foo", "bar", "baz"]
item = "bar"
print(f"The index of '{item}' is {get_index(my_list, item)}")

def get_indices(my_list, items):
    indices = []
    for item in items:
        try:
            index = my_list.index(item)
            indices.append((item, index))
        except ValueError:
            indices.append((item, "not found"))
    return indices

my_list = ["foo", "bar", "baz"]
items = ["bar", "baz", "qux"]
print(f"Indices: {get_indices(my_list, items)}")

பைதான் பட்டியல்களில் குறியீடுகளைக் கண்டறிவதற்கான மேம்பட்ட நுட்பங்கள்

பைதான் பட்டியலில் ஒரு பொருளின் குறியீட்டைக் கண்டறிவதற்கான அடிப்படை முறைகளுக்கு அப்பால், சில சூழ்நிலைகளில் பலனளிக்கும் மேம்பட்ட நுட்பங்கள் உள்ளன. அத்தகைய ஒரு நுட்பம் குறியீடுகளை வடிகட்டுவதற்கும் கண்டறிவதற்கும் பட்டியல் புரிதல்களைப் பயன்படுத்துகிறது. ஒரு பட்டியல் புரிதல் பட்டியல்களை உருவாக்க ஒரு சுருக்கமான வழியை வழங்குகிறது மற்றும் பட்டியலில் பல முறை தோன்றினால் குறிப்பிட்ட உருப்படியின் அனைத்து குறியீடுகளையும் சேகரிக்க பயன்படுத்தலாம். உதாரணமாக, ஒரு பட்டியலில் ஒரு பொருளின் நகல் இருந்தால், பயன்படுத்தி [i for i, x in enumerate(my_list) if x == item] உருப்படி காணப்படும் அனைத்து குறியீடுகளின் பட்டியலை வழங்கும். இந்த முறை சுருக்கமானது மட்டுமல்ல, அத்தகைய பயன்பாட்டு நிகழ்வுகளுக்கு மிகவும் படிக்கக்கூடியது மற்றும் திறமையானது.

மற்றொரு மேம்பட்ட அணுகுமுறை பயன்பாட்டை உள்ளடக்கியது numpy நூலகம், இது பெரிய தரவுத்தொகுப்புகள் மற்றும் எண் செயல்பாடுகளுக்கு மிகவும் பயனுள்ளதாக இருக்கும். numpy வழங்குகிறது np.where() நேட்டிவ் பைதான் பட்டியல்களுடன் ஒப்பிடும்போது அதிக செயல்திறன் கொண்ட முறையில் குறியீடுகளைக் கண்டறிய பயன்படும் செயல்பாடு. உதாரணத்திற்கு, np.where(np.array(my_list) == item)[0] உருப்படி காணப்படும் குறியீட்டு வரிசையை வழங்கும். பெரிய வரிசைகளுடன் பணிபுரியும் போது அல்லது செயல்திறன் ஒரு முக்கியமான கவலையாக இருக்கும்போது இது மிகவும் சாதகமானது. இத்தகைய சிறப்பு வாய்ந்த நூலகங்களைப் பயன்படுத்துவதன் மூலம் குறியீட்டு தேடல் செயல்பாடுகளின் திறன் மற்றும் அளவிடுதல் ஆகியவற்றை கணிசமாக மேம்படுத்த முடியும்.