பைத்தானில் வளையத்திற்கு எப்படி பயன்படுத்துவது

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

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

---

---

பைத்தானில் சுழல்களுக்கான வேலை எப்படி

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

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

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

for new_variable in parent_variable:
execute some statements


முன்பு கூறியது போல், a போலல்லாமல் போது வளையம், தி க்கான லூப் மிகவும் சக்தி வாய்ந்தது, ஏனெனில் இது ஒரு ஓட்டத்தில் அதிக கட்டுப்பாட்டை வழங்குகிறது.

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

---

---

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

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

---

---

பைத்தானை வளையத்திற்கு பயன்படுத்துவது எப்படி: நடைமுறை உதாரணங்கள்

இப்போது a ஐ எவ்வாறு பயன்படுத்துவது என்பதற்கான சில நடைமுறை உதாரணங்களைப் பார்ப்போம் க்கான பைத்தானில் வளைய.

கீழே உள்ள குறியீடு துண்டு பட்டியலில் உள்ள ஒவ்வொரு உருப்படியையும் வெளியிடுகிறது:

items = ['shoe', 'bag', 'shirts', 'lamp']
for i in items:
print(i)


மேலே உள்ள குறியீட்டை மாற்றியமைத்து, 'a' என்ற எழுத்தைக் கொண்ட எந்தப் பொருளையும் வெளியீடு செய்யலாம்:

வார்த்தையில் ஒரு பக்க இடைவெளியை எப்படி நீக்குவது

items = ['shoe', 'bag', 'shirts', 'lamp']
for i in items:
if 'a' in i:
print(i)


TO க்கான பைத்தானில் உள்ள வளையமும் நேரடியாக எடுத்துக்கொள்கிறது வேறு அறிக்கை:

b=[2, 3, 5, 6]
for i in b:
print(i)
else:
print('Loop has ended')


நீங்கள் ஒரு பயன்படுத்த முடியும் இடைவேளை ஒரு ஓட்டத்தை மாற்றுவதற்கான அறிக்கை க்கான வளையமும்:

ஆண்ட்ராய்டுக்கான சிறந்த இலவச இசை பயன்பாடு

b=[2, 3, 5, 6]
for i in b:
if i>3:
break
print(i)


நீங்கள் இதைப் பயன்படுத்தலாம் தொடரும் a உடன் முக்கிய சொல் க்கான வளையம்:

b=[2, 3, 5, 6]
for i in b:
if i>3:
continue
print(i)


பைத்தானில் பட்டியல் மற்றும் சரம் இலக்கியங்களுடன் ஒரு லூப்பைப் பயன்படுத்துதல்

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

for x in range(1, 101):
print(x)


1 மற்றும் 100 க்கு இடையில் உள்ள அனைத்து ஒற்றைப்படை எண்களையும் வெளியிடுவதற்கான நிபந்தனை அறிக்கையை அறிமுகப்படுத்துவதன் மூலம் அந்த குறியீட்டை நீங்கள் மாற்றலாம்:

for x in range(1, 101):
if x%2==1:
print(x)


இருப்பினும், மேலே உள்ள குறியீட்டின் வெளியீட்டின் '2 by output' பெருக்கல் அட்டவணையை நீங்கள் உருவாக்கலாம். இதை அடைய, நீங்கள் இன்னும் சில அறிக்கைகளை மட்டுமே சேர்க்க வேண்டும்:

for x in range(1, 101):
if x%2==1:
print(x, 'x', 2, '=', x * 2)


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

கீழே உள்ள குறியீடு ஒரு வாக்கியத்தில் ஒவ்வொரு சரத்தின் வரிசையையும் அளிக்கிறது:

a = 'How to use a for loop in Python'
for i in a:
print(i)


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

a = ['How to use a for loop in Python']
for i in a:
print(i.count(''))
Output: 32


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

a=['How to use a for loop in Python']
c=[b.count('') for b in a]
print(c)
Output: [32]


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

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

a=['How to use a for loop in Python']
for i in a:
print(i.count(' ') + 1)
Output: 8


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

a = ['How to use a for loop in Python']
c=[b.count(' ') + 1 for b in a]
print(c)
Output: [8]


அடைப்புக்குறிக்குள் உள்ள மேற்கோள்களுக்கு இடையில் இருக்கும் ஒற்றை இடைவெளியில் கவனம் செலுத்துங்கள்.

தொடர்புடையது: பைத்தானில் உங்கள் சொந்த தொகுதியை எவ்வாறு உருவாக்குவது மற்றும் மீண்டும் பயன்படுத்துவது

ஒரு வரிசையுடன் ஒரு பைத்தானை லூப் பயன்படுத்துதல்

நீங்கள் ஒரு பயன்படுத்த முடியும் க்கான வரிசையிலிருந்து ஒரு குறிப்பிட்ட உறுப்பைப் பெற வளைய.

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

எச்டிஎம்ஐ உடன் டிவியை வை வை இணைப்பது எப்படி

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

array = [{'name':'Sheep1', 'healthy':'Yes'},
{'name':'Sheep3', 'healthy':'No'},
{'name':'Sheep4', 'healthy':'Yes'},
{'name':'Sheep5', 'healthy':'Yes'},
{'name':'Sheep8', 'healthy':'No'},
{'name':'Sheep7', 'healthy':'No'},
{'name':'Sheep9', 'healthy':'No'}
]
for sheeps in array:
if sheeps['healthy']=='No':
print('Quarantine', sheeps['name'])


பைத்தானில் நெஸ்ட்டு ஃபார் லூப்பைப் பயன்படுத்துதல்

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

nested_list = [[1, 2, 4, 5], {'name':'Python', 'method':'write'}]
for dict in nested_list:
for i in dict:
print(i)


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

சுழல்களுக்கு அல்லது சுழல்களுக்கு, எது சிறந்தது?

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

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

பகிர் பகிர் ட்வீட் மின்னஞ்சல் பைத்தானில் ஒரு நேர சுழற்சியை எவ்வாறு பயன்படுத்துவது

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

அடுத்து படிக்கவும் தொடர்புடைய தலைப்புகள்

• நிரலாக்க
• பைதான்

எழுத்தாளர் பற்றி இடிசோ ஒமிசோலா(94 கட்டுரைகள் வெளியிடப்பட்டன)

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

இடோவு ஒமிசோலாவில் இருந்து மேலும்

எங்கள் செய்திமடலுக்கு குழுசேரவும்

தொழில்நுட்ப குறிப்புகள், மதிப்புரைகள், இலவச மின் புத்தகங்கள் மற்றும் பிரத்யேக ஒப்பந்தங்களுக்கு எங்கள் செய்திமடலில் சேரவும்!

குழுசேர இங்கே சொடுக்கவும்