பைத்தானில் 'ஃபார்' லூப்களுடன் அகராதி மறு செய்கையைப் புரிந்துகொள்வது

பைதான் அகராதிகளின் மூலம் மீண்டும் கூறுதல்

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

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

அகராதி மறு செய்கை நுட்பங்களைப் புரிந்துகொள்வது

வழங்கப்பட்ட ஸ்கிரிப்ட்கள் பைத்தானில் உள்ள அகராதிகளை மீண்டும் மீண்டும் செய்வதற்கான வெவ்வேறு முறைகளை விளக்குகின்றன. முதல் ஸ்கிரிப்ட் ஒரு எளிய பயன்படுத்துகிறது for லூப் அகராதி மூலம் மீண்டும் செய்யவும் d. ஒவ்வொரு மறு செய்கைக்கும், மாறி key அகராதியில் உள்ள விசைகளில் ஒன்றின் மதிப்பை எடுத்துக்கொள்கிறது, மேலும் தொடர்புடைய மதிப்பைப் பயன்படுத்தி அணுகலாம் d[key]. இந்த முறை நேரடியானது மற்றும் அடிப்படை விசை மதிப்பை மீட்டெடுப்பதற்கு அடிக்கடி பயன்படுத்தப்படுகிறது. இரண்டாவது ஸ்கிரிப்ட் பயன்படுத்துகிறது items() முறை, இது ஒரு அகராதியின் முக்கிய மதிப்பு tuple ஜோடிகளின் பட்டியலைக் காண்பிக்கும் ஒரு பார்வைப் பொருளை வழங்குகிறது. பயன்படுத்தி for key, value in d.items(), ஸ்கிரிப்ட் விசைகள் மற்றும் மதிப்புகள் இரண்டையும் ஒரே மறு செய்கையில் நேரடியாக அணுக முடியும், இது மிகவும் திறமையானது மற்றும் படிக்கக்கூடியது.

மூன்றாவது எழுத்தில், தி keys() அகராதியில் உள்ள அனைத்து விசைகளின் பார்வைப் பொருளைப் பெறுவதற்கு முறை பயன்படுத்தப்படுகிறது, பின்னர் இது பட்டியலாக மாற்றப்படுகிறது list() செயல்பாடு. இந்தப் பட்டியல் மீண்டும் மீண்டும் கொடுக்கப்பட்டு, அகராதியிலிருந்து தொடர்புடைய மதிப்பை மீட்டெடுக்க ஒவ்வொரு விசையும் பயன்படுத்தப்படுகிறது. நீங்கள் தனித்தனியாக விசைகளை கையாள அல்லது அணுக வேண்டியிருக்கும் போது இந்த முறை பயனுள்ளதாக இருக்கும். நான்காவது ஸ்கிரிப்ட் ஒரு செயல்பாட்டை வரையறுக்கிறது def print_dict(d) ஒரு அகராதியை ஒரு வாதமாக எடுத்து அதன் உள்ளடக்கங்களை அச்சிடுகிறது. இது போன்ற செயல்பாடுகள் தர்க்கத்தை இணைத்து குறியீட்டை மீண்டும் பயன்படுத்த உதவுகின்றன. இறுதியாக, ஐந்தாவது ஸ்கிரிப்ட் ஒருங்கிணைக்கிறது list() மற்றும் range() ஒரு குறியீட்டுடன் அகராதியின் மீது மீண்டும் செயல்படும் செயல்பாடுகள். தி len() விசைகளின் எண்ணிக்கையை தீர்மானிக்க செயல்பாடு பயன்படுத்தப்படுகிறது, விசைகள் மற்றும் மதிப்புகள் இரண்டிற்கும் குறியீட்டு அணுகலை செயல்படுத்துகிறது. அட்டவணைப்படுத்தப்பட்ட செயல்பாடுகள் அல்லது கையாளுதல்கள் தேவைப்படும் சூழ்நிலைகளில் இந்த அணுகுமுறை உதவியாக இருக்கும்.

d = {'x': 1, 'y': 2, 'z': 3}
for key in d:
    print(key, 'corresponds to', d[key])

d = {'x': 1, 'y': 2, 'z': 3}
for key, value in d.items():
    print(f'{key} corresponds to {value}')

d = {'x': 1, 'y': 2, 'z': 3}
keys = d.keys()
for key in keys:
    print(f'Key: {key} -> Value: {d[key]}')

def print_dict(d):
    for key in d:
        print(f'{key} corresponds to {d[key]}')

d = {'x': 1, 'y': 2, 'z': 3}
print_dict(d)

d = {'x': 1, 'y': 2, 'z': 3}
keys = list(d.keys())
for i in range(len(keys)):
    print(f'{keys[i]} corresponds to {d[keys[i]]}')

அகராதி மறு செய்கையில் ஆழமாக மூழ்குதல்

பைத்தானில் அகராதிகளை மீண்டும் செய்வதன் மற்றொரு முக்கியமான அம்சம், பல்வேறு முறைகள் மற்றும் அவற்றின் பயன்பாட்டு நிகழ்வுகளை எளிமையாகப் புரிந்துகொள்வது. for சுழல்கள். உதாரணமாக, தி dict.get() விசை காணப்படவில்லை எனில், ஒரு KeyError ஐ உயர்த்தாமல், அகராதியிலிருந்து மதிப்புகளை மீட்டெடுக்க விரும்பும் போது இந்த முறை மிகவும் பயனுள்ளதாக இருக்கும். இந்த முறையானது, அகராதியில் விசை இல்லை என்றால், திரும்ப இயல்புநிலை மதிப்பைக் குறிப்பிட உங்களை அனுமதிக்கிறது. பயன்படுத்தி dict.get(key, default), விடுபட்ட விசைகளை நீங்கள் பாதுகாப்பாகக் கையாளலாம், இது தரவு செயலாக்கம் மற்றும் முழுமையற்ற தரவுத்தொகுப்புகளைக் கையாள்வதில் அவசியம்.

கூடுதலாக, அகராதி புரிதல்கள், மீண்டும் சொல்லக்கூடிய தரவுகளிலிருந்து அகராதிகளை உருவாக்க ஒரு சுருக்கமான வழியை வழங்குகிறது. பட்டியலிடப்பட்ட புரிதல்களைப் போலவே, அகராதி புரிதல்களும் தொடரியல் பயன்படுத்துகின்றன {key: value for item in iterable}. அகராதிகளை திறம்பட மாற்றுவதற்கு அல்லது வடிகட்டுவதற்கு இந்த முறை பயனுள்ளதாக இருக்கும். மற்றொரு மேம்பட்ட நுட்பம் இதில் அடங்கும் defaultdict இருந்து வர்க்கம் collections தொகுதி. உள்ளமைக்கப்பட்ட அகராதியின் இந்த துணைப்பிரிவு, அகராதிக்கான இயல்புநிலை வகையைக் குறிப்பிட உங்களை அனுமதிக்கிறது. int அல்லது list. இல்லாத ஒரு விசையை அணுகும்போது, defaultdict முன்னிருப்பு வகையுடன் தானாக ஒரு உள்ளீட்டை உருவாக்குகிறது, இது அகராதி உள்ளீடுகளை துவக்க வேண்டிய குறியீட்டு முறைகளை எளிதாக்குகிறது.