പൈത്തണിലെ ലൂപ്പിനായി. വാക്യഘടന, ലിസ്റ്റ് ആവർത്തനം, ബ്രേക്ക്, തുടരുക, മറ്റ് സവിശേഷതകൾ

Цപൈത്തൺ ഐക്ക് ഐ.കെ.എൽ സൈക്കിൾ അതേസമയം - പ്രസ്താവനകൾ സോഫ്റ്റ്വെയർ ഭാഷ, അതായത്: ആവർത്തന ഓപ്പറേറ്റർമാർ, അനുവദിക്കുകസജീവമാക്കുന്നതിന് കോഡ് ആവർത്തിക്കുക നൽകിയ നമ്പർ സമയം.

Цഉദാഹരണത്തിന് - сintaxis

ഇതിനകം വിശദീകരിച്ചതുപോലെ, സിപൈത്തണിൽ ഉൾപ്പെടുത്തുന്നത് അടിസ്ഥാനമാക്കിയുള്ള ഒരു ആവർത്തനമാണ്й ഓരോ സൈക്കിളുംഐഡന്റിറ്റി. അവനാണോ പ്രവൃത്തികൾ ട്യൂപ്പിൾ മൂലകങ്ങൾ വഴി и പട്ടിക, പദാവലി കീകളും മറ്റ് ആവർത്തിക്കാവുന്ന വസ്തുക്കൾ.

പൈത്തണിലെ ഒരു ലൂപ്പ് ഫോർ കീവേഡിൽ ആരംഭിക്കുന്നു, തുടർന്ന് നൽകിയിരിക്കുന്ന ശ്രേണിയിൽ അടുത്ത ഒബ്‌ജക്റ്റിന്റെ മൂല്യം സംഭരിക്കുന്ന ഒരു അനിയന്ത്രിതമായ വേരിയബിൾ നാമം. ഇൻ പൈത്തണിനുള്ള പൊതു വാക്യഘടന ഇതുപോലെ കാണപ്പെടുന്നു:

ഇതിനായി: else:      

ഘടകങ്ങൾ "ക്രമങ്ങൾ" ലിസ്റ്റുചെയ്തിരിക്കുന്നു ഒന്നിനുപുറകെ ഒന്നായി സൈക്കിൾ വേരിയബിൾ. അല്ലെങ്കിൽ, വേരിയബിൾ പോയിന്റുകൾ അത്തരം ഘടകങ്ങൾ. ഏവർക്കുമായി അവയിൽ "പ്രവർത്തനം" നടത്തുന്നു.

ഒരു നിർദ്ദിഷ്‌ട ഉദാഹരണം ഉപയോഗിച്ച് പൈത്തണിലെ ലൂപ്പിനുള്ള ലളിതം:

>>> ഭാഷകൾ = ["C", "C++", "Perl", "Python"] >>> ഭാഷകളിൽ x ന്: ... print(x) ... C C++ Perl Python >>>

മറ്റ് ബ്ലോക്ക് പ്രത്യേകമാണ്th. അത് അങ്ങിനെയെങ്കിൽ പ്രോഗ്രാമർыഅധ്വാനിക്കുന്ന с പേൾ പരിചിതമാണ്ы അവനോടൊപ്പം, ആ ഇടപഴകുന്നവർക്ക് с C, C++ — ഇതൊരു പുതുമയാണ്. അർത്ഥപരമായി അത് ഫംഗ്ഷനുകളും тസമാനമായി ലൂപ്പ് സമയത്ത്.

ബ്രേക്ക് സ്‌റ്റേറ്റ്‌മെന്റ് വഴി ലൂപ്പ് "നിർത്താതിരിക്കുമ്പോൾ" മാത്രമേ എക്‌സിക്യൂട്ട് ചെയ്യൂ. അതായത്, എല്ലാ ഘടകങ്ങളും നിർദ്ദിഷ്ട ശ്രേണിയിലൂടെ കടന്നതിനുശേഷം മാത്രമേ ഇത് നടപ്പിലാക്കുകയുള്ളൂ.

പൈത്തണിലെ ബ്രേക്ക് ഓപ്പറേറ്റർ - ബ്രേക്ക്

പ്രോഗ്രാമിന് ഫോർ ലൂപ്പ് ഉണ്ടെങ്കിൽ അത്യാവശ്യമാണ് തടസ്സപ്പെടുത്തുകThe ബ്രേക്ക് പ്രസ്താവന, he പൂർണ്ണമായഅത് പോകുന്നുഒപ്പം പ്രോഗ്രാം ഒഴുകുക ഉദ്ദേശിക്കുന്ന കണ്ടംആയിരിക്കാൻ കൂടാതെ സജീവമാക്കൽ വേറെ നിന്ന്.

കൂടുതൽ പലപ്പോഴും പൈത്തണിലെ ശൈലികൾ തകർക്കുകയുത്സ്യ സോപാധിക പ്രസ്താവനകളോടെ.

എഡിബിൾസ് = ["ചോപ്‌സ്", "ഡംപ്ലിംഗ്‌സ്", "മുട്ട", "നട്ട്‌സ്"] ഭക്ഷ്യവസ്തുക്കളിലെ ഭക്ഷണത്തിന്: ഭക്ഷണം == "പറച്ചിൽ": പ്രിന്റ് ("ഞാൻ പറഞ്ഞല്ലോ!") ബ്രേക്ക് പ്രിന്റ് ("മികച്ചത്, രുചികരമായ " + ഭക്ഷണം) മറ്റെന്തെങ്കിലും: പ്രിന്റ് ("ഡംപ്ലിംഗ്സ് ഇല്ലാതിരുന്നത് നല്ലതാണ്!") പ്രിന്റ്("അത്താഴം കഴിഞ്ഞു.")

നിങ്ങൾ ഈ കോഡ് പ്രവർത്തിപ്പിക്കുകയാണെങ്കിൽ, നിങ്ങൾക്ക് ഇനിപ്പറയുന്ന ഫലം ലഭിക്കും:

മികച്ച, രുചികരമായ ചോപ്സ്. ഞാൻ പറഞ്ഞല്ലോ കഴിക്കില്ല! അത്താഴം കഴിഞ്ഞു.

നിലവിലുള്ള ഡാറ്റാ ലിസ്റ്റിൽ നിന്ന് ഞങ്ങൾ "ഡംപ്ലിംഗ്സ്" നീക്കം ചെയ്യുകയും നേടുകയും ചെയ്യുന്നു:

മികച്ച, രുചികരമായ ചോപ്‌സ് മികച്ചത്, സ്വാദിഷ്ടമായ മുട്ടകൾ മികച്ചത്, രുചികരമായ അണ്ടിപ്പരിപ്പ് പറഞ്ഞല്ലോ ഉണ്ടായിരുന്നില്ല! അത്താഴം കഴിഞ്ഞു.

python skip operator - തുടരുക

അത്തരം ഉൽപ്പന്നങ്ങളോടുള്ള ഉപയോക്താവിന്റെ വിരോധം അവയുടെ ഉപഭോഗം പൂർണ്ണമായും ഉപേക്ഷിക്കുന്ന തരത്തിൽ വലുതല്ലെന്ന് നമുക്ക് പറയാം. തൽഫലമായി, ലൂപ്പ് ഓപ്പറേറ്ററുമായി തുടരുന്നു continue. ഇനിപ്പറയുന്ന സ്ക്രിപ്റ്റ് പ്രസ്താവന ഉപയോഗിക്കുന്നു continue, "ഡംപ്ലിംഗ് കോൺടാക്റ്റ്" എന്നതിലെ പട്ടികയിലൂടെ ആവർത്തിക്കുന്നത് തുടരാൻ.

ഭക്ഷ്യവസ്തുക്കൾ = ["ചോപ്‌സ്", "ഡംപ്ലിംഗ്‌സ്", "മുട്ട", "നട്ട്‌സ്"] ഭക്ഷ്യവസ്തുക്കളിലെ ഭക്ഷണത്തിന്: ഭക്ഷണമാണെങ്കിൽ == "പറഞ്ഞല്ലോ": പ്രിന്റ്("ഞാൻ പറഞ്ഞല്ലോ കഴിക്കില്ല!") പ്രിന്റ് തുടരുക("കൊള്ളാം, രുചികരമായ " + ഭക്ഷണം) # ഇത് ഭക്ഷണം ആസ്വദിക്കുന്നതിനുള്ള കോഡായിരിക്കാം :-) വേറെ: പ്രിന്റ്("ഞാൻ പറഞ്ഞല്ലോ വെറുക്കുന്നു!") പ്രിന്റ്("അത്താഴം കഴിഞ്ഞു.")

താഴത്തെ വരി:

മികച്ച, രുചികരമായ ചോപ്സ്. ഞാൻ പറഞ്ഞല്ലോ കഴിക്കില്ല! കൊള്ളാം, രുചികരമായ മുട്ടകൾ കൊള്ളാം, രുചികരമായ പരിപ്പ് ഞാൻ പറഞ്ഞല്ലോ വെറുക്കുന്നു! അത്താഴം കഴിഞ്ഞു.

ശ്രേണി() ഫംഗ്‌ഷൻ ഉപയോഗിച്ച് ലിസ്‌റ്റുകളുടെ മേൽ ആവർത്തനം ചെയ്യുന്നു

നിങ്ങൾക്ക് ഒരു ലിസ്റ്റിന്റെ സൂചികകൾ ആക്‌സസ് ചെയ്യണമെങ്കിൽ, ഈ ആവശ്യത്തിനായി ഒരു ഫോർ ലൂപ്പ് എങ്ങനെ ഉപയോഗിക്കണമെന്ന് വ്യക്തമല്ല. എല്ലാ ഘടകങ്ങളും ആക്സസ് ചെയ്യാൻ കഴിയും, എന്നാൽ മൂലകത്തിന്റെ സൂചിക ആക്സസ് ചെയ്യാൻ കഴിയില്ല. എന്നിരുന്നാലും, മൂലകത്തിന്റെ സൂചികയും മൂലകവും ആക്സസ് ചെയ്യുന്നതിന് ഒരു രീതിയുണ്ട്. ഈ ആവശ്യത്തിനായി, ഫംഗ്ഷൻ ഉപയോഗിക്കുന്നു range() നീളം ഫംഗ്ഷനുമായി സംയോജിപ്പിച്ചിരിക്കുന്നു len():

fibonacci = [0,1,1,2,3,5,8,13,21] for i എന്ന ശ്രേണിയിൽ(len(fibonacci)): പ്രിന്റ്(i,fibonacci[i])

നേടുക:

0 0 1 1 2 1 3 2 4 3 5 5 6 8 7 13 8 21 XNUMX

ശ്രദ്ധ! പ്രയോഗിക്കുമ്പോൾ len() к list or tuple, തന്നിരിക്കുന്ന ശ്രേണിയുടെ മൂലകങ്ങളുടെ അനുബന്ധ എണ്ണം ലഭിക്കുന്നു.

ലിസ്റ്റുകൾ ആവർത്തിക്കുന്നതിനുള്ള ബുദ്ധിമുട്ടുകൾ

ഒരു ലിസ്റ്റിൽ ആവർത്തിക്കുമ്പോൾ, ലൂപ്പ് ബോഡിയിൽ ലിസ്റ്റ് ഡൈനാമിക്സ് ഒഴിവാക്കാൻ ശുപാർശ ചെയ്യുന്നു. വ്യക്തതയ്ക്കായി, ഞങ്ങൾക്ക് ഇനിപ്പറയുന്ന ഓപ്ഷൻ വാഗ്ദാനം ചെയ്യാൻ കഴിയും:

നിറങ്ങൾ = ["ചുവപ്പ്"] എന്നതിന് നിറങ്ങളിൽ: i == "ചുവപ്പ്": നിറങ്ങൾ += ["കറുപ്പ്"] എങ്കിൽ == "കറുപ്പ്": നിറങ്ങൾ += ["വെളുപ്പ്"] പ്രിന്റ് (നിറങ്ങൾ)

അപേക്ഷിക്കുമ്പോൾ എന്ത് സംഭവിക്കും print(colours)?

['ചുവപ്പ്', 'കറുപ്പ്', 'വെളുപ്പ്']

ഇത് ഒഴിവാക്കാൻ, ചുവടെയുള്ള ഉദാഹരണത്തിലെന്നപോലെ സ്ലൈസുകൾ ഉപയോഗിച്ച് പകർപ്പുമായി സംവദിക്കാൻ ശുപാർശ ചെയ്യുന്നു:

നിറങ്ങൾ = ["ചുവപ്പ്"] എന്നതിന് നിറങ്ങളിൽ[:]: എങ്കിൽ == "ചുവപ്പ്": നിറങ്ങൾ += ["കറുപ്പ്"] എങ്കിൽ == "കറുപ്പ്": നിറങ്ങൾ += ["വെളുപ്പ്"] പ്രിന്റ്(നിറങ്ങൾ )

ഫലമായി:

['ചുവന്ന കറുപ്പ്']

പട്ടിക മാറ്റി colours, എന്നാൽ ഈ പ്രവർത്തനം ലൂപ്പിനെ ബാധിച്ചില്ല. ലൂപ്പ് എക്‌സിക്യൂഷൻ സമയത്ത് ആവർത്തിക്കേണ്ട ഡാറ്റ മാറ്റമില്ലാതെ തുടർന്നു.

പൈത്തൺ 3 ൽ എണ്ണുക

Enumerate ഒരു അന്തർനിർമ്മിത പൈത്തൺ ഫംഗ്‌ഷനാണ്. മിക്ക തുടക്കക്കാർക്കും പരിചയസമ്പന്നരായ ചില പ്രോഗ്രാമർമാർക്കും അതിന്റെ അസ്തിത്വത്തെക്കുറിച്ച് അറിയില്ല. ലൂപ്പിന്റെ ആവർത്തനങ്ങൾ സ്വയമേവ എണ്ണാൻ ഇത് നിങ്ങളെ അനുവദിക്കുന്നു. ഉദാഹരണത്തിന്:

കൗണ്ടറിനായി, എണ്ണിയെടുക്കലിലെ മൂല്യം(ചില_ലിസ്റ്റ്): പ്രിന്റ്(കൗണ്ടർ, മൂല്യം)

ഫംഗ്ഷൻ enumerate ഒരു ഓപ്ഷണൽ ആർഗ്യുമെന്റും എടുക്കുന്നു (ഉത്ഭവത്തിന്റെ മൂല്യം, ഡിഫോൾട്ടായി എടുത്തത് 0). ഇത് കൂടുതൽ കാര്യക്ഷമമാക്കുന്നു.

my_list = സി എന്നതിനായുള്ള ['ആപ്പിൾ', 'വാഴപ്പഴം', 'ചെറി', 'പീച്ച്'], എണ്ണത്തിൽ മൂല്യം(എന്റെ_ലിസ്റ്റ്, 1): പ്രിന്റ്(സി, മൂല്യം) # ഫലം: # 1 ആപ്പിൾ # 2 വാഴപ്പഴം # 3 ചെറി # 4 പീച്ച്