1. புரோகிராமிங் பைத்தான் பைத்தானில் லாம்ப்டா செயல்பாடுகளை எவ்வாறு பயன்படுத்துவது

எழுதியவர் ஆலன் ஷோவிக், ஜான் ஷோவிக்

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

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

பைத்தானுடன் ஒரு லாம்ப்டா வெளிப்பாட்டை (பெயர் இல்லாமல்) வரையறுப்பதற்கான குறைந்தபட்ச தொடரியல்:

லாம்ப்டா வாதங்கள்: வெளிப்பாடு

இதைப் பயன்படுத்தும் போது:

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

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

ஆடம்ஸ், மா, டிமியோலா, ஜண்டுஸ்கி

பெயர்களை ஒரு பட்டியலில் வைக்க, அதை வரிசைப்படுத்த, பின்னர் பட்டியலை அச்சிட பின்வரும் குறியீட்டை எழுதுங்கள் என்று வைத்துக்கொள்வோம்:

பெயர்கள் = ['ஆடம்ஸ்', 'மா', 'டிமியோலா', 'ஜண்டுஸ்கி']
names.sort ()
அச்சிட (பெயர்கள்)

இதிலிருந்து வெளியீடு:

['ஆடம்ஸ்', 'மா', 'ஜண்டுஸ்கி', 'டிமியோலா']

ஜான்டுஸ்கி சில தொடக்கக்காரர்களுக்கு தவறாகத் தெரிந்த பிறகு டிமியோலா வருவது. ஆனால் கணினிகள் எப்போதுமே நாம் செய்யும் விஷயங்களைப் பார்ப்பதில்லை. . எழுத்து ஒரு எண்ணால் குறிக்கப்படுகிறது.

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

இந்த விஷயங்களுக்கு உதவ, பைதான் வரிசை () முறை அடைப்புக்குறிக்குள் ஒரு விசை = வெளிப்பாட்டைச் சேர்க்க உங்களை அனுமதிக்கிறது, அங்கு எவ்வாறு வரிசைப்படுத்துவது என்று சொல்லலாம். தொடரியல்:

.sort (விசை = உருமாற்றம்)

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

names.sort (விசையை = லென்)

துரதிர்ஷ்டவசமாக எங்களுக்கு, சரத்தின் நீளம் அகரவரிசைக்கு உதவாது. எனவே நீங்கள் அதை இயக்கும்போது, ​​ஆர்டர் பின்வருமாறு:

['மா', 'ஆடம்ஸ்', 'டிமியோலா', 'ஜண்டுஸ்கி']

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

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

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

def low (anystring):
"" "அனைத்து சிறிய எழுத்துக்களுக்கும் சரம் மாற்றுகிறது" ""
anystring.lower () ஐத் தரவும்

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

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

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

பைத்தானில் தனிப்பயன் செயல்பாடு குறைவாக ()

சரி, எனவே இப்போது எந்தவொரு சரத்தையும் அனைத்து சிறிய எழுத்துக்களுக்கும் மாற்ற தனிப்பயன் செயல்பாடு உள்ளது. ஒரு வரிசை விசையாக அதை எவ்வாறு பயன்படுத்துகிறீர்கள்? எளிதானது, விசையைப் பயன்படுத்துங்கள் = முன்பு போலவே மாற்றவும், ஆனால் உங்கள் தனிப்பயன் செயல்பாட்டு பெயருடன் மாற்றத்தை மாற்றவும். இந்த செயல்பாடு சிறிய எழுத்து என பெயரிடப்பட்டுள்ளது, எனவே பின்வருவனவற்றில் காட்டப்பட்டுள்ளபடி .sort (key = lowercaseof) ஐப் பயன்படுத்துவீர்கள்:

def lowercaseof (anystring):
"" "அனைத்து சிறிய எழுத்துக்களுக்கும் சரம் மாற்றுகிறது" ""
anystring.lower () ஐத் தரவும்
 
பெயர்கள் = ['ஆடம்ஸ்', 'மா', 'டிமியோலா', 'ஜண்டுஸ்கி']
names.sort (விசையை = lowercaseof)

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

'ஆடம்ஸ்', 'டிமியோலா', 'மா', 'ஜண்டுஸ்கி'

இவை அனைத்தையும் படித்த பிறகும் நீங்கள் விழித்திருக்கிறீர்கள், விழிப்புடன் இருந்தால், “சரி, வரிசைப்படுத்தும் சிக்கலை நீங்கள் தீர்த்தீர்கள். ஆனால் நாங்கள் இங்கே லாம்ப்டா செயல்பாடுகளைப் பற்றி பேசுகிறோம் என்று நினைத்தேன். லாம்ப்டா செயல்பாடு எங்கே? ”இதுவரை லாம்ப்டா செயல்பாடு இல்லை.

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

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

லாம்ப்டா அளவுருக்கள்: வெளிப்பாடு

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

lambda anystring: anystring.lower ()

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

கீழேயுள்ள படம் முழுமையான குறியீட்டையும் அதை இயக்கும் முடிவையும் காட்டுகிறது. லோயர் கேஸ் () போன்ற வாடிக்கையாளர் வெளிப்புற செயல்பாட்டின் தேவை இல்லாமல் சரியான வரிசை வரிசையைப் பெறுவீர்கள். நீங்கள் எந்தவொரு சரத்தையும் பயன்படுத்துகிறீர்கள்: anystring.lower () (லாம்ப்டா என்ற வார்த்தையின் பின்னர்) வரிசை விசையாக.

பைதான் லாம்ப்டா வெளிப்பாடு

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

பெயர்கள் = ['ஆடம்ஸ்', 'மா', 'டிமியோலா', 'ஜண்டுஸ்கி']
names.sort (key = lambda s: s.lower ())
அச்சிட (பெயர்கள்)

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

எடுத்துக்காட்டாக, நாணயம் என்ற ஒரு லாம்ப்டா செயல்பாடு இங்கே எந்த எண்ணையும் எடுத்து நாணய வடிவத்தில் ஒரு சரத்தை திருப்பித் தருகிறது (அதாவது, ஒரு முன்னணி டாலர் அடையாளத்துடன், ஆயிரக்கணக்கானவர்களுக்கு இடையில் காற்புள்ளிகள் மற்றும் சில்லறைகளுக்கு இரண்டு இலக்கங்கள்):

நாணய = லாம்ப்டா n: f "$ {n:,. 2f}"

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

சதவீதம் = லாம்ப்டா n: f "{n: .2%}"

ஜூபிட்டர் கலத்தின் மேற்புறத்தில் வரையறுக்கப்பட்ட இரு செயல்பாடுகளின் எடுத்துக்காட்டுகளையும் பின்வரும் படம் காட்டுகிறது. ஒரு சில அச்சு அறிக்கைகள் செயல்பாடுகளை பெயரால் அழைக்கின்றன மற்றும் சில மாதிரி தரவை அவர்களுக்கு அனுப்புகின்றன. ஒவ்வொரு அச்சு () அறிக்கைகளும் விரும்பிய வடிவத்தில் எண்ணைக் காண்பிக்கும்.

பைதான் வடிவமைத்தல் எண்கள்

ஒற்றை வரி லாம்ப்டாக்கள் என்று நீங்கள் வரையறுக்கக் காரணம், நீங்கள் எல்லா வேலைகளையும் ஒரே வரியில் செய்ய முடியும், ஏனெனில் f "$ {n:,. 2f}" முதல் ஒரு மற்றும் f "{n: .2%}" இரண்டாவது. ஆனால் நீங்கள் அதை அவ்வாறு செய்ய முடியும் என்பதால், நீங்கள் வேண்டும் என்று அர்த்தமல்ல. நீங்கள் பின்வருமாறு வழக்கமான செயல்பாடுகளையும் பயன்படுத்தலாம்:

# நாணய வடிவத்தில் எண்ணைக் காட்டு.
def நாணயம் (n):
திரும்ப f "$ {n:,. 2f}"
 
def சதவீதம் (n):
# எண்ணை சதவீதம் வடிவத்தில் காட்டு.
திரும்ப f "{n: .2%}"

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

பைதான் வடிவமைப்பு செயல்பாடு நிலையான அகலம்

மேலே உள்ள படத்தில், இரண்டாவது அளவுரு விருப்பமானது மற்றும் தவிர்க்கப்பட்டால் இயல்புநிலையாக 15 ஆக இருக்கும். எனவே இதை இப்படி அழைத்தால்:

அச்சு (நாணய (9999))

… 15 எழுத்துகள் அகலமாக்க இடதுபுறத்தில் போதுமான இடைவெளிகளுடன் $ 9,999.00 திணிப்பைப் பெறுவீர்கள். அதற்கு பதிலாக இதை நீங்கள் அழைத்தால்:

அச்சு (நாணய (9999,20)

… நீங்கள் இன்னும், 9,999.00 பெறுகிறீர்கள், ஆனால் இடதுபுறத்தில் போதுமான இடைவெளிகளுடன் 20 எழுத்துக்கள் அகலமாக இருக்கும்.

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

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

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

  1. புரோகிராமிங் பைதான் பைதான் பட்டியல்களை எவ்வாறு வரையறுப்பது மற்றும் பயன்படுத்துவது

எழுதியவர் ஆலன் ஷோவிக், ஜான் ஷோவிக்

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

மதிப்பெண்கள் = [88, 92, 78, 90, 98, 84]

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

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

['மார்க்', 'அம்பர்', 'டாட்', 'அனிதா', 'சாண்டி']

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

பைதான் பட்டியல் உருப்படிகளை நிலை அடிப்படையில் குறிப்பிடுகிறது

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

listname [X]

நீங்கள் அணுகும் பட்டியலின் பெயருடன் பட்டியல் பெயரை மாற்றவும், நீங்கள் விரும்பும் உருப்படியின் நிலை எண்ணுடன் x ஐ மாற்றவும். நினைவில் கொள்ளுங்கள், முதல் உருப்படி எப்போதும் எண் பூஜ்ஜியமாகும், ஒன்று அல்ல. எடுத்துக்காட்டாக, கீழேயுள்ள முதல் வரியில், மாணவர்கள் என்ற பட்டியலை நான் வரையறுக்கிறேன், பின்னர் அந்த பட்டியலிலிருந்து உருப்படி எண் பூஜ்ஜியத்தை அச்சிடுகிறேன். இதன் விளைவாக, குறியீட்டை இயக்கும் போது, ​​மார்க் என்ற பெயர் காட்டப்படும்.
மாணவர்கள் = ["மார்க்", "அம்பர்", "டாட்", "அனிதா", "சாண்டி"]
அச்சு (மாணவர்கள் [0])
மார்க்

அணுகல் பட்டியல் உருப்படிகளைப் படிக்கும்போது, ​​தொழில் வல்லுநர்கள் எண்ணுக்கு முன் துணை என்ற வார்த்தையைப் பயன்படுத்துகிறார்கள். எடுத்துக்காட்டாக, மாணவர்கள் [0] மாணவர்கள் துணை பூஜ்ஜியமாக பேசப்படுவார்கள்.

இந்த அடுத்த எடுத்துக்காட்டு மதிப்பெண்கள் என்ற பட்டியலைக் காட்டுகிறது. அச்சு () செயல்பாடு பட்டியலில் கடைசி மதிப்பெண்ணின் நிலை எண்ணை அச்சிடுகிறது, இது 4 ஆகும் (ஏனெனில் முதல் ஒன்று எப்போதும் பூஜ்ஜியமாக இருக்கும்).

மதிப்பெண்கள் = [88, 92, 78, 90, 84]
அச்சு (மதிப்பெண்களை [4])
84

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

மதிப்பெண்கள் இல்லாததால் இது தோல்வியுற்றது மற்றும் பிழையை உருவாக்கியது [5]. மதிப்பெண்கள் [0], மதிப்பெண்கள் [1], மதிப்பெண்கள் [2], மதிப்பெண்கள் [3] மற்றும் மதிப்பெண்கள் [4] மட்டுமே உள்ளன, ஏனெனில் எண்ணிக்கை எப்போதும் பூஜ்ஜியத்தில் தொடங்குகிறது.

பைதான் குறியீட்டு வரம்பு

பைதான் பட்டியல் மூலம் சுழல்கிறது

ஒரு பட்டியலில் உள்ள ஒவ்வொரு உருப்படியையும் அணுக, இந்த தொடரியல் மூலம் ஒரு for loop ஐப் பயன்படுத்தவும்:

பட்டியலில் x க்கு:

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

மதிப்பெண்களில் மதிப்பெண் பெற:
அச்சு (ஸ்கோர்)

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

பைதான் பட்டியல் மூலம் சுழல்கிறது

பைதான் பட்டியலில் ஒரு உருப்படி உள்ளதா என்பதைப் பார்ப்பது

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

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

ஒரு உருப்படி பைதான் பட்டியலில் உள்ளதா என்பதைப் பார்ப்பது

பைதான் பட்டியலின் நீளத்தைப் பெறுதல்

ஒரு பட்டியலில் எத்தனை உருப்படிகள் உள்ளன என்பதைத் தீர்மானிக்க, லென் () செயல்பாட்டைப் பயன்படுத்தவும் (நீளத்திற்கு குறுகியது). அடைப்புக்குறிக்குள் பட்டியலின் பெயரை வைக்கவும். எடுத்துக்காட்டாக, பின்வரும் குறியீட்டை ஜூபிடர் நோட்புக் அல்லது பைதான் வரியில் அல்லது எதையாவது தட்டச்சு செய்க:

மாணவர்கள் = ["மார்க்", "அம்பர்", "டாட்", "அனிதா", "சாண்டி"]
அச்சிட (லென் (மாணவர்கள்))

அந்த குறியீட்டை இயக்குவது இந்த வெளியீட்டை உருவாக்குகிறது:

5

பட்டியலில் உண்மையில் ஐந்து உருப்படிகள் உள்ளன, இருப்பினும் கடைசியாக ஒன்று எப்போதும் எண்ணிக்கையை விட குறைவாகவே உள்ளது, ஏனெனில் பைதான் பூஜ்ஜியத்தில் எண்ணத் தொடங்குகிறது. எனவே கடைசியாக, சாண்டி, உண்மையில் மாணவர்களைக் குறிக்கிறது [4] மற்றும் மாணவர்கள் அல்ல [5].

பைதான் பட்டியலின் முடிவில் ஒரு பொருளைச் சேர்க்கிறது

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

உதாரணமாக, பின்வரும் படத்தில் மாணவர்களைப் படிக்கும் வரி. "(கூபர்") பட்டியலில் கூபர் பெயரைச் சேர்க்கிறது. Students.append (new_student) ஐப் படிக்கும் வரி புதிய_ஸ்டுடென்ட் என்ற பெயரில் மாறியில் சேமிக்கப்பட்டுள்ள எந்தப் பட்டியலையும் பட்டியலில் சேர்க்கிறது. .Apppend () முறை எப்போதும் பட்டியலின் முடிவில் சேர்க்கிறது. எனவே நீங்கள் பட்டியலை அச்சிடும்போது அந்த இரண்டு புதிய பெயர்களையும் இறுதியில் காணலாம்.

பைதான் இணைப்பு பட்டியல்

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

student_name = "அமண்டா"

# மாணவர்_பெயரைச் சேர்க்கவும், ஆனால் ஏற்கனவே பட்டியலில் இல்லை என்றால் மட்டுமே.
மாணவர்களில் மாணவர் பெயர் என்றால்:
    அச்சிடு (மாணவர்_பெயர் + "ஏற்கனவே பட்டியலில் உள்ளது")
வேறு:
    students.append (student_name)
    அச்சு (மாணவர்_பெயர் + "பட்டியலில் சேர்க்கப்பட்டது")

பைதான் பட்டியலில் ஒரு உருப்படியைச் செருகுவது

பட்டியலின் முடிவில் ஒரு பொருளைச் சேர்க்க append () முறை உங்களை அனுமதித்தாலும், செருகும் () முறை எந்தவொரு நிலையிலும் பட்டியலில் ஒரு பொருளைச் சேர்க்க உங்களை அனுமதிக்கிறது. செருகுவதற்கான தொடரியல் () ஆகும்

listname.insert (நிலை, உருப்படி)

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

எடுத்துக்காட்டாக, பின்வரும் குறியீடு லூப்பை பட்டியலில் முதல் உருப்படியாக மாற்றுகிறது:

# சரங்களின் பட்டியலை உருவாக்கவும் (பெயர்கள்).
மாணவர்கள் = ["மார்க்", "அம்பர்", "டாட்", "அனிதா", "சாண்டி"]

student_name = "லூப்"
# பட்டியலின் முன் மாணவர் பெயரைச் சேர்க்கவும்.
students.insert (0, student_name)

# புதிய பட்டியலை எனக்குக் காட்டு.
அச்சிட (மாணவர்கள்)

நீங்கள் குறியீட்டை இயக்கினால், புதிய பெயர் செருகப்பட்ட பின் அச்சு (மாணவர்கள்) பட்டியலைக் காண்பிக்கும், பின்வருமாறு:

['லூப்', 'மார்க்', 'அம்பர்', 'டாட்', 'அனிதா', 'சாண்டி']

பைதான் பட்டியலில் ஒரு உருப்படியை மாற்றுதல்

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

listname [குறியீட்டு] = newvalue

பட்டியல் பெயரை பட்டியலின் பெயருடன் மாற்றவும்; நீங்கள் மாற்ற விரும்பும் உருப்படியின் சந்தா (குறியீட்டு எண்) உடன் குறியீட்டை மாற்றவும்; பட்டியல் உருப்படியில் நீங்கள் வைக்க விரும்பும் புதிய மதிப்பை மாற்றவும். எடுத்துக்காட்டாக, இந்த குறியீட்டைப் பாருங்கள்:

# சரங்களின் பட்டியலை உருவாக்கவும் (பெயர்கள்).
மாணவர்கள் = ["மார்க்", "அம்பர்", "டாட்", "அனிதா", "சாண்டி"]
மாணவர்கள் [3] = "ஹோபார்ட்"
அச்சிட (மாணவர்கள்)

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

['மார்க்', 'அம்பர்', 'டாட்', 'ஹோபார்ட்', 'சாண்டி']

பைதான் பட்டியல்களை இணைத்தல்

நீங்கள் ஒரு பட்டியலில் இணைக்க விரும்பும் இரண்டு பட்டியல்கள் இருந்தால், தொடரியல் உடன் நீட்டிப்பு () செயல்பாட்டைப் பயன்படுத்தவும்:

original_list.extend (additional_items_list)

உங்கள் குறியீட்டில், புதிய பட்டியல் உருப்படிகளை நீங்கள் சேர்க்கும் பட்டியலின் பெயருடன் அசல்_ பட்டியலை மாற்றவும். முதல் பட்டியலில் நீங்கள் சேர்க்க விரும்பும் உருப்படிகளைக் கொண்ட பட்டியலின் பெயருடன் கூடுதல்_டிம்ஸ்_ பட்டியலை மாற்றவும். பட்டியல் 1 மற்றும் பட்டியல் 2 என பெயரிடப்பட்ட பட்டியல்களைப் பயன்படுத்தி ஒரு எளிய எடுத்துக்காட்டு இங்கே. List1.extend (list2) ஐ இயக்கிய பிறகு, முதல் பட்டியலில் இரு பட்டியல்களிலிருந்தும் உருப்படிகள் உள்ளன, ஏனெனில் இறுதியில் அச்சு () அறிக்கையின் வெளியீட்டில் நீங்கள் காணலாம்.

# பெயர்களின் இரண்டு பட்டியல்களை உருவாக்கவும்.
list1 = ["ஜாரா", "லூப்", "ஹாங்", "ஆல்பர்டோ", "ஜேக்"]
list2 = ["ஹூய்", "டீவி", "லூயி", "நாடர்", "பப்பா"]

# பட்டியல் 1 இல் பட்டியல் 2 பெயர்களைச் சேர்க்கவும்.
list1.extend (பட்டியல் 2)

# அச்சு பட்டியல் 1.
அச்சிட (பட்டியல் 1)

.

எளிதான பார்சீசி, இல்லையா?

பைதான் பட்டியல் உருப்படிகளை நீக்குகிறது

பைதான் ஒரு நீக்கு () முறையை வழங்குகிறது, எனவே நீங்கள் பட்டியலிலிருந்து எந்த மதிப்பையும் அகற்றலாம். உருப்படி பல முறை பட்டியலில் இருந்தால், முதல் நிகழ்வு மட்டுமே அகற்றப்படும். எடுத்துக்காட்டாக, பின்வரும் குறியீடு சி எழுத்துடன் சில முறை மீண்டும் மீண்டும் கடிதங்களின் பட்டியலைக் காட்டுகிறது. பட்டியலில் இருந்து C எழுத்தை நீக்க குறியீடு letter.remove ("C") ஐப் பயன்படுத்துகிறது:

# பட்டியலிலிருந்து "சி" ஐ அகற்று.
letters.remove ( "சி")

# புதிய பட்டியலை எனக்குக் காட்டு.
அச்சிட (கடிதங்கள்)

நீங்கள் உண்மையில் இந்த குறியீட்டை இயக்கி பின்னர் பட்டியலை அச்சிடும்போது, ​​முதல் எழுத்து C மட்டுமே அகற்றப்பட்டிருப்பதைக் காண்பீர்கள்:

['A', 'B', 'D', 'C', 'E', 'C']

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

# சரங்களின் பட்டியலை உருவாக்கவும்.
எழுத்துக்கள் = ["A", "B", "C", "D", "C", "E", "C"]

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

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

# சரங்களின் பட்டியலை உருவாக்கவும்.
எழுத்துக்கள் = ["A", "B", "C", "D", "E", "F", "G"]
 
# முதல் உருப்படியை அகற்று.
letters.pop (0)
# கடைசி உருப்படியை அகற்று.
letters.pop ()
 
# புதிய பட்டியலை எனக்குக் காட்டு.
அச்சிட (கடிதங்கள்)

குறியீட்டை இயக்குவது முதல் மற்றும் கடைசி உருப்படிகளைத் தூண்டுவது உண்மையில் வேலை செய்தது என்பதைக் காட்டுகிறது:

['பி', 'சி', 'டி', 'இ', 'எஃப்']

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

பைதான் பட்டியலிலிருந்து உருப்படிகளை அகற்று

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

# சரங்களின் பட்டியலை உருவாக்கவும்.
எழுத்துக்கள் = ["A", "B", "C", "D", "E", "F", "G"]
 
# உருப்படி துணை 2 ஐ அகற்று.
டெல் கடிதங்கள் [2]
 
அச்சிட (கடிதங்கள்)

அந்த குறியீட்டை இயக்குவது பின்வருமாறு பட்டியலை மீண்டும் காட்டுகிறது. சி எழுத்து நீக்கப்பட்டது, இது 0, 1, 2, 3 மற்றும் பல எழுத்துக்கள் எண்ணப்பட்டிருப்பதால் நீக்க சரியான உருப்படி.

['A', 'B', 'D', 'E', 'F', 'G']

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

பைதான் பட்டியலை நீக்கு

பைதான் பட்டியலை அழிக்கிறது

நீங்கள் ஒரு பட்டியலின் உள்ளடக்கங்களை நீக்க விரும்பினால், ஆனால் அந்த பட்டியலை அல்ல. தெளிவான () ஐப் பயன்படுத்தவும். பட்டியல் இன்னும் உள்ளது; இருப்பினும், அதில் எந்த உருப்படிகளும் இல்லை. வேறு வார்த்தைகளில் கூறுவதானால், இது ஒரு வெற்று பட்டியல். இதை நீங்கள் எவ்வாறு சோதிக்க முடியும் என்பதை பின்வரும் குறியீடு காட்டுகிறது. குறியீடு காட்சிகளை [] முடிவில் இயக்குவது, பட்டியல் காலியாக இருப்பதை உங்களுக்குத் தெரிவிக்கும்:

# சரங்களின் பட்டியலை உருவாக்கவும்.
எழுத்துக்கள் = ["A", "B", "C", "D", "E", "F", "G"]
 
# அனைத்து உள்ளீடுகளின் பட்டியலையும் அழிக்கவும்.
letters.clear ()
 
# புதிய பட்டியலை எனக்குக் காட்டு.
அச்சிட (கடிதங்கள்)

[]

பைதான் பட்டியலில் ஒரு உருப்படி எத்தனை முறை தோன்றும் என்பதைக் கணக்கிடுகிறது

ஒரு பட்டியலில் எத்தனை முறை தோன்றும் என்பதை எண்ண பைதான் எண்ணிக்கை () முறையைப் பயன்படுத்தலாம். மற்ற பட்டியல் முறைகளைப் போலவே, தொடரியல் எளிதானது:

listname.count (x) என்பது

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

.Count () இன் அடைப்புக்குறிக்குள் ஒரு நேரடி B ஐப் பயன்படுத்தி, கீழே உள்ள படத்தில் உள்ள குறியீடு எத்தனை முறை தோன்றும் என்பதைக் கணக்கிடுகிறது. இதே குறியீடு சி தரங்களின் எண்ணிக்கையையும் கணக்கிடுகிறது, ஆனால் அந்த மதிப்பு தொடரியல் வேறுபாட்டைக் காண்பிப்பதற்காக ஒரு மாறியில் சேமிக்கப்பட்டது. இரண்டு எண்ணிக்கையும் வேலை செய்தன, ஏனெனில் கீழே உள்ள நிரலின் வெளியீட்டில் நீங்கள் காணலாம். எந்தவொரு மாறிகளையும் பயன்படுத்தாமல், எஃப்’க்களை எண்ணுவதற்கு ஒன்று சேர்க்கப்பட்டது. செய்தியைக் காண்பிக்கும் குறியீட்டில் F கள் கணக்கிடப்பட்டன. எஃப் தரங்கள் எதுவும் இல்லை, எனவே வெளியீட்டில் நீங்கள் காணக்கூடியபடி இது பூஜ்ஜியத்தைத் தருகிறது.

பைதான் பட்டியல் உருப்படிகளை எண்ணுங்கள்

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

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

பைதான் ஒரு .index () முறையை வழங்குகிறது, இது ஒரு பட்டியலில் உள்ள ஒரு பொருளின் குறியீட்டு எண்ணின் அடிப்படையில் நிலையைக் குறிக்கும் எண்ணைத் தருகிறது. தொடரியல்:

listname.index (x) என்பது

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

பட்டியலில் எஃப் இல்லாததால், நிரல் f_index = grades.index (look_for) என்ற வரியில் செயலிழக்கும் ஒரு உதாரணத்தை பின்வரும் படம் காட்டுகிறது.

பைதான் பட்டியல் உருப்படி அட்டவணை

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

# சரங்களின் பட்டியலை உருவாக்கவும்.
தரங்கள் = ["சி", "பி", "ஏ", "டி", "சி", "பி", "சி"]
# எதைத் தேடுவது என்று முடிவு செய்யுங்கள்
look_for = "F"
# உருப்படி பட்டியலில் உள்ளதா என்று பாருங்கள்.
தரங்களாக இருந்தால்_
    # இது பட்டியலில் இருந்தால், குறியீட்டைப் பெற்று காண்பி.
    print (str (look_for) + "குறியீட்டில் உள்ளது" + str (grades.index (look_for)))
வேறு:
    # பட்டியலில் இல்லையென்றால், குறியீட்டு எண்ணுக்கு கூட முயற்சி செய்ய வேண்டாம்.
    அச்சிடு (str (look_for) + "பட்டியலில் இல்லை.")

பைதான் பட்டியல்களை அகரவரிசைப்படுத்துதல் மற்றும் வரிசைப்படுத்துதல்

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

listname.sort ()

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

பைதான் பட்டியலை வரிசைப்படுத்துங்கள்

உங்கள் பட்டியலில் பெரிய எழுத்துக்கள் மற்றும் சிறிய எழுத்துக்களின் கலவையுடன் சரங்கள் இருந்தால், மற்றும் வரிசை முடிவுகள் சரியாகத் தெரியவில்லை என்றால். .Sort () ஐ .sort (key = lambda s: s.lower ()) உடன் மாற்ற முயற்சிக்கவும். குறியீட்டை மீண்டும் இயக்குகிறது.

தேதிகள் கொஞ்சம் தந்திரமானவை, ஏனெனில் அவற்றை "12/31/2020" போன்ற சரங்களாக தட்டச்சு செய்ய முடியாது. சரியாக வரிசைப்படுத்த அவை தேதி தரவு வகையாக இருக்க வேண்டும். இதன் பொருள் ஒவ்வொரு தேதியையும் வரையறுக்க தேதிநேர தொகுதி மற்றும் தேதி () முறையைப் பயன்படுத்துதல். நீங்கள் வேறு எந்த பட்டியலையும் போல தேதிகளை பட்டியலில் சேர்க்கலாம். எடுத்துக்காட்டாக, பின்வரும் வரியில், குறியீடு நான்கு தேதிகளின் பட்டியலை உருவாக்குகிறது, மேலும் குறியீடு நன்றாக உள்ளது.

தேதிகள் = [dt.date (2020,12,31), dt.date (2019,1,31), dt.date (2018,2,28), dt.date (2020,1,1)]

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

datelist = []
பைத்தானில் காட்சி தேதிகள்

ஒரு நேரத்தில் ஒரு தேதி dt.date (ஆண்டு, மாதம், நாள்) தொடரியல் பயன்படுத்தி பட்டியலில் சேர்க்கப்பட்டது.

பட்டியல் உருவாக்கப்பட்ட பிறகு, குறியீடானது காலவரிசைப்படி வரிசைப்படுத்த டேட்டலிஸ்ட்.சார்ட் () ஐப் பயன்படுத்துகிறது (ஆரம்பத்திலிருந்து சமீபத்தியது வரை). அந்த குறியீட்டில் நீங்கள் அச்சு (தரவு பட்டியல்) பயன்படுத்த தேவையில்லை, ஏனெனில் இது போன்ற தரவு வகை தகவலுடன் தேதிகளை அந்த முறை காட்டுகிறது:

[datetime.date (2018, 2, 28), datetime.date (2019, 1, 31), datetime.date (2020, 1, 1), datetime.date (2020, 12, 31)]

படிக்க எளிதான பட்டியல் அல்ல. எனவே, முழு பட்டியலையும் ஒரு அச்சு () அறிக்கையுடன் அச்சிடுவதற்கு பதிலாக, நீங்கள் பட்டியலில் உள்ள ஒவ்வொரு தேதியையும் லூப் செய்யலாம், மேலும் ஒவ்வொன்றையும் f-string% m /% d /% Y உடன் வடிவமைக்கப்பட்டுள்ளது. இது ஒவ்வொரு தேதியையும் அதன் சொந்த வரியில் mm / dd / yyyy

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

பைதான் பட்டியலில் தலைகீழ் தகவலை வரிசைப்படுத்தவும்

பைதான் பட்டியலை மாற்றியமைக்கிறது

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

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

# சரங்களின் பட்டியலை உருவாக்கவும்.
பெயர்கள் = ["ஜாரா", "லூப்", "ஹாங்", "ஆல்பர்டோ", "ஜேக்"]
# பட்டியலை மாற்றியமைக்கவும்
names.reverse ()
# பட்டியலை அச்சிடுக
அச்சிட (பெயர்கள்)
 
['ஜேக்', 'ஆல்பர்டோ', 'ஹாங்', 'லூப்', 'ஜாரா']

பைதான் பட்டியலை நகலெடுக்கிறது

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

# சரங்களின் பட்டியலை உருவாக்கவும்.
பெயர்கள் = ["ஜாரா", "லூப்", "ஹாங்", "ஆல்பர்டோ", "ஜேக்"]
 
# பட்டியலின் நகலை உருவாக்கவும்
backward_names = names.copy ()
# நகலைத் திருப்புக
backward_names.reverse ()
 
# பட்டியலை அச்சிடுக
அச்சிட (பெயர்கள்)
அச்சிட (backward_names)
 
['ஜாரா', 'லூப்', 'ஹாங்', 'ஆல்பர்டோ', 'ஜேக்']
['ஜேக்', 'ஆல்பர்டோ', 'ஹாங்', 'லூப்', 'ஜாரா']

எதிர்கால குறிப்புகளுக்கு, பின்வரும் அட்டவணை நீங்கள் கற்றுக்கொண்ட முறைகளை சுருக்கமாகக் கூறுகிறது.