python loops while
Tento videonávod vysvetľuje úlohu Loops v Pythone, ich typy: For, While, Nested Loops so syntaxou a praktickými príkladmi programovania:
Dozvedeli sme sa o štyroch rôznych Podmienené vyhlásenia v Pythone v našom predchádzajúcom návode.
Smyčky sú výkonné programovacie koncepty podporované takmer všetkými modernými programovacími jazykmi. Umožňuje programu implementovať iterácie, čo v podstate znamená vykonať ten istý blok kódu dvakrát alebo viackrát.
Aj keď sú podporované všetkými modernými programovacími jazykmi a poskytujú podobné základné funkcie, ich implementácia a syntax sa môžu líšiť.
The Celá školiaca séria o Pythone vám poskytne krátku predstavu o čom je Python.
Čo sa dozviete:
- Výučbový program Python Loops
- Čo sú to pythonové slučky
- Pre slučku v Pythone
- The While Loop
- Vnorená slučka
- Python Infinite Loops
- Záver
Výučbový program Python Loops
Čo sú to pythonové slučky
V Pythone sa príkazy vykonávajú sekvenčným spôsobom, t. J. Ak je náš kód zložený z niekoľkých riadkov kódu, potom sa spustenie spustí od prvého riadku, za ktorým nasleduje druhý atď.
Existujú však prípady, kedy môžeme chcieť, aby sa blok kódu vykonal niekoľkokrát, kým nebude splnená podmienka. Vďaka príkazom loop to dokážeme.
Ďalej je uvedený vývojový diagram, ktorý ilustruje, ako funguje príkaz slučky.
Na základe vyššie uvedeného diagramu sa program Python začne o Štart [kruh] a vykonanie prejde k príkazu podmienky [Diamant], ak je podmienka PRAVDA, potom program vykoná blok kódu.
Spustenie bude pokračovať znova k príkazu podmienky a rovnaký proces bude pokračovať zakaždým, keď bude podmienka PRAVDA. Vypadne zo slučky alebo zastaví vykonávanie bloku kódu, iba ak je podmienka FALSE, a v takom prípade bude program pokračovať v vykonávaní postupne.
Python má dva typy slučiek.
# | Typ slučky | Popis |
---|---|---|
jeden | pre slučku | Je slučka založená na iterátore, ktorá prechádza položkami iterovateľných objektov, ako sú zoznamy, n-tice, reťazce a opakovane viackrát vykonáva kód, na základe počtu položiek v tomto iterovateľnom objekte. |
dva | zatiaľ čo slučka | Vykonáva blok príkazov opakovane, pokiaľ je podmienka TRUE. |
Tieto dva typy slučiek sa môžu na generovanie použiť navzájom v sebe vnorené slučky (viac o tom neskôr).
Všeobecné použitie slučiek Python
V Pythone možno slučky použiť na riešenie úžasných a zložitých problémov. Pravdepodobne sa stretnete s problémami, ktoré by vyžadovali opakovanie akcie, kým nebude splnená podmienka (zatiaľ čo tu funguje slučka najlepšie), alebo problémom, ktorý si vyžaduje vykonanie akcie s hromadou položiek (tu slučka funguje najlepšie).
Pre slučku v Pythone
The pre slučku funguje dobre s iterovateľnými objektmi ako zoznamy , n-tice , struny Týmto spôsobom môžeme prechádzať položkami týchto objektov a manipulovať s ich hodnotami na základe nášho prepojenia.
The pre slučku je bez indexovania a má nasledujúcu syntax.
for in n:
Stav v pre slučku zostane PRAVDA, iba ak neprešlo iteráciou cez všetky položky v opakovateľnom objekte (n). Pre lepšie pochopenie pre slučku , venujeme sa niekoľkým príkladom a nakoniec sa dopracujeme k praktickému príkladu.
Príklad 1:Tlačte čísla od začiatku do konca
Aby sme to dosiahli, použijeme Python rozsah funkcie.
Takto bude vývojový diagram vyzerať:
def range_from_start_to_end(start, end): for i in range(start, end+1): print(i) if __name__ == '__main__': start = int(input('Enter a start number: ')) end = int(input('Enter an end number: ')) # Call our function to print the ranges range_from_1_to_20(start, end)
Výkon
Vo vyššie uvedenom príklade sme použili rozsah Pythonu, čo je funkcia, ktorá vracia postupnosť čísel počnúc od a začať číslo (predvolene 0), prírastky o a krok (Predvolene 1) a zastaví sa pred koniec číslo.
Pre tento príklad, máme nasledujúce:
Parametre a hodnoty pre funkciu rozsahu Pythonu
Parametre | Hodnota |
---|---|
začať | jeden |
koniec | dvadsať |
krok | 1 (predvolená hodnota) |
Takže náš pre slučku bude opakovať postupnosť čísel od 1 do 20 a pre každú iteráciu toto číslo vytlačí. Keď boli navštívené všetky čísla v poradí, iterácia sa zastaví.
Príklad 2:Určte, či je číslo prvočíslo.
V tomto príklade uvidíme, prečo pre slučku je tak silný a užitočný. Tu budeme iterovať postupnosťou čísel a pre každé číslo vykonáme nejaký výpočet, aby sme zistili, či je podmienka TRUE alebo FALSE.
Môže to pomôcť poznať podmienky, aby mohlo byť číslo prvočíslo.
- Číslo je vždy kladné, väčšie ako 1.
- Nemá žiadne kladné delitele okrem 1 a seba samého.
def isPrime(number): # rule 1: number should be positive, and greater than 1. if number > 1: # iterate over a range from 2 to half the number. for i in range(2, number//2): # rule 2: shouldn't have any positive divisor # order than 1 and itself. if(number % i) ==0: return False return True else: return False if __name__ == '__main__': number = int(input('Enter number to check if it's prime: ')) if isPrime(number): print('{} is a prime number'.format(number)) else: print('{} is not a prime number'.format(number))
Výstup, keď je vstup 13
Výstup, keď je vstup 10
Poznámka: The keby-inak použitý vo vyššie uvedenom príklade je podmienený príkaz a nie slučka. Ale rovnako ako zatiaľ čo slučka (ktorej sa čoskoro budeme venovať), používa pre svoj stav operátory porovnania.
Príklad - nájdite počet slov v texte pomocou slučky for
Tento príklad je zameraný na počítanie počtu výskytov každého slova v texte. Existuje toľko spôsobov, ako to možno dosiahnuť, ale pre tento príklad použijeme pre slučku .
Budeme počítať slová z textu nižšie.
Dobrý deň, vitajte v Pomocníkovi pre testovanie softvéru. V tomto článku: „Smyčky v Pythone“ sa dozviete o slučkách na praktických príkladoch. Skvelé, že? Keď sa budeme učiť spolu, nezabudnite ich sledovať.
Šťastné programovanie!
Prvá vec, ktorú urobíme, je odstránenie interpunkcie, medzier a všetkých malých písmen. Interpunkciu odstránime tradičným spôsobom tak, že identifikujeme, ktoré interpunkčné znamienka existujú v našom texte, a potom použijeme znak pre slučku nahradiť ich prázdnym reťazcom.
Keďže textu nie je veľa, vidíme, že interpunkčné znamienka sú čiarky (,), obdobie (.), otáznik (?), dvojbodka (:), dvojitá úvodzovka („) A apostrof („).
Ďalej je uvedený kód na ich nahradenie prázdnym reťazcom. Upozorňujeme, že apostrof nenahradíme.
# replace punctuation(except apostrophe) and white spaces for punc in '.,
?!'': text = text.replace(punc, '') # lowercase all letters. text = text.lower()
Výkon
Ďalej text rozdelíme na zoznam slov oddelených medzerami.
# Split text into list of words separated by whitespaces(tab, newline) text = text.split()
Výkon
Na záver spočítame a uvidíme, koľkokrát sa každé slovo vyskytne v rozdelenom texte.
# initialize a dictionary to hold words:count wordsCount = {} # if a word is already a key in our dictionary, increment it's value. # If not, initialize it's value to 1. for word in text: wordsCount[word] = wordsCount.get(word, 0) + 1
Výkon
Jasne vidíme, že niektoré slová sa objavujú dvakrát, iné iba raz. Zoraďme tento slovník podľa jeho hodnoty v zostupnom poradí, aby sme ho mohli jasne rozlíšiť. Tu sme použili Python triedená funkcia , lambda výraz a slovníkové porozumenie .
ako zobraziť súbor bin
# Sort dictionary by value, in descending order wordsCount = {w: c for w, c in sorted(wordsCount.items(), key=lambda item: item[1], reverse=True)}
Nakoniec sme použili pre slučku na čistenie, počítanie a triedenie slov v našom texte.
Nižšie je uvedený kompletný kód.
def word_count(text): # initialize a dictionary to hold words:count wordsCount = {} # replace punctuation(except apostrophe) and white spaces for punc in '.,
?!'': text = text.replace(punc, '') # lowercase all letters. text = text.lower() # Split text into list of words separated by whitespaces(tab, newline) and apostrophe(') text = text.split() # if a word is already a key in our dictionary, increment it's value. # If not, initialize it's value to 1. for word in text: wordsCount[word] = wordsCount.get(word, 0) + 1 # Sort dictionary by value, in descending order wordsCount = {w: c for w, c in sorted(wordsCount.items(), key=lambda item: item[1], reverse=True)} print(wordsCount) if __name__ == '__main__': text = 'Hello, welcome to Software Testing Help. In this article: 'Loops in Python', you'll learn about loops with practical examples. Great right? Make sure to follow along as we learn together.
Happy coding!' word_count(text)
Konečný výstup
The While Loop
Python zatiaľ čo slučka vykoná blok výpisov opakovane, pokiaľ je podmienka TRUE. Všimli sme si, že je to trochu podobné ako v ak vyhlásenie . Avšak na rozdiel od zatiaľ čo slučka , príkaz if sa vykoná iba raz, ak je jeho podmienka PRAVDA.
Cyklus while má nasledujúcu syntax:
While condition: expression(block of code)
Na rozdiel od pre slučku , zatiaľ čo slučka ne iteruje nad postupnosťou. Pre svoj stav používa operátory porovnania a booleans.
Pozrime sa na niekoľko príkladov, aby sme lepšie pochopili, ako sa používa.
Príklad 1:Vytlačiť „Hello World!“ počet krát
The zatiaľ čo slučka skontroluje stav (počet
Takto bude vývojový diagram vyzerať:
def print_count_times(n): # set count to 0 count = 0 while count Výkon:
otvorte xml súbor v programe Excel
Príklad 2:Nájdite faktoriál čísla
Faktoriál čísla je reprezentovaný ako n! a má to vzorec
1*2*...*(n-1)
Program skontroluje, či je číslo 0, a vráti hodnotu 1 (faktoriál 0 je 1). Potom zatiaľ čo slučka skontroluje podmienku (n> = 1), aby zistil, či je naše n rovné 1 alebo väčšie ako 1. Zakaždým, keď je táto podmienka PRAVDA, náš program vypočíta vzorec v bloku slučky
Poďme pomocou cyklu while vyriešiť problém s faktoriálmi
def factorial(n): if n == 0: # The factorial of 0 is 1. return 1 else: fac = 1 while n >= 1: # while this condition is TRUE # 1*2*3*...*(n-1) fac *= n # same as 'fac = fac * n' n -= 1 # same as 'n = n - 1' return fac if __name__ =='__main__': n = int(input('Find factorial of: ')) fac = factorial(n) print('Factorial of {} is {} '.format(n,fac))
Výkon
Príklad - Nájdite sekvenciu Fibonacci až do n. Termínu pomocou cyklu While
Fibonacciho sekvencia má vzorec.
0,1,1,...((n-1)th + (n-2)th)
Prvé dve čísla sú 0 a 1, ďalšie čísla sú súčtom dvoch predchádzajúcich čísel (n-1) th a (n-2) th.
Fibonacciho sekvencia 8 bude 0,1,1,2,3,5,8,13
def fibonacci(n_term): n1 = 0 # (n-1)th if n_term == 1: # if n_term term is 1, print 0 print(n1) else: count = 0 n2 = 1 # (n-2)th # Loop while 'count Výkon
Náš program najskôr definuje prvú n-tú hodnotu (n1 = 0), potom skontroluje, či sa n_term odovzdaný ako argument rovná 1. Ak má hodnotu TRUE, vráti hodnotu 0.
Inak definuje dve premenné:
- count = 0: Toto sa použije v zatiaľ čo slučka skontrolovať stav, ak je počet menší ako n_term (počet
- n2 = 1: Toto je naša druhá n-ta hodnota.
Zatiaľ máme v našej sekvencii 0,1 (n1, n2). Aj keď je podmienka TRUE:
- Hodnota n2 sa priradí dočasnej premennej (temp = n2).
- Vypočíta sa súčet dvoch predchádzajúcich čísel a priradí sa k n2 (n2 = n1 + n2).
- Naša dočasná hodnota (stará hodnota n2) je priradená k n1 (n1 = teplota).
- Náš počet sa zvýši (počet + = 1) a stav sa znova skontroluje.
Na konci prvej iterácie máme 0,1,1, kde:
- n1 = 1 (prvá 1)
- n2 = 1 (druhá 1)
Táto operácia sa bude opakovať, kým sa stav nepočíta Vnorená slučka
Skvelé na slučkách Python je, že sa dajú vnoriť, t. J. Môžeme použiť jednu alebo viac slučiek vo vnútri inej slučky. To nám umožňuje riešiť ešte zložitejšie problémy.
# 1) Vnorenie pre slučky
pretože slučky môžu byť vnorené do seba. Syntax nižšie ukazuje 1-úrovňovú vnorenú slučku for.
for in n: # piece of code goes here for in n: # piece of code goes here
Príklad 1:Na tlač čísel do vzorov použite vnorené slučky
Použijme vnorenú slučku for na vytlačenie nasledujúceho vzoru:
1 2 2 3 3 3 4 4 4 4 5 5 5 5 5
Každé číslo je vytlačené toľkokrát, koľko zodpovedá jeho číslu samotnému.
Takto bude vývojový diagram vyzerať:
Vývojový diagram vnorenej slučky for def print_numbers(): for i in range(1, 6): # outer loop for j in range(i): # 1st level inner loop print(i, end=' ') print('
') if __name__ == '__main__': print_numbers()
Výkon
Náš program funguje nasledovne:
- Vonkajšia slučka iteruje v rozmedzí od 1 do 6 a pre každú položku v tomto poradí.
- Vstupuje do vnútornej slučky, kde iteruje v rozsahu danej položky.
- Pri každej iterácii danej položky sa položka vytlačí.
- Vnútornú slučku opúšťa iba vtedy, keď úplne iteruje celým rozsahom tejto položky.
- Keď opustí vnútornú slučku, vráti sa späť do vonkajšej slučky a proces pokračuje, kým sa v priebehu svojej sekvencie úplne iteruje.
Príklad 2:Manipulujte s položkami vnoreného zoznamu pomocou vnorenej slučky for
Situácia, s ktorou sa v Pythone pravdepodobne stretneme, je prístup k položkám vnoreného zoznamu.
Vezmite si napríklad vnorený zoznam uvedený nižšie.
>>> [[3,4.0,2,8.4,6],[0,2,0.2,4,6],[9,3.5,0.32,5,4]]
Pre tento príklad Poďme napísať program, ktorý spočíta počet celých čísel a plavákov v tomto vnorenom zozname.
def float_and_int_count(nested_list): float_count = 0 # set our float count to zero int_count = 0 # set our integer count to zero for l in nested_list: # outer loop accesses each list in the nested list for item in l: # inter loop accesses each item in the list if isinstance(item, int): # if item is an instance of int int_count += 1 # increment integer count elif isinstance(item, float): # if item is an instance of float float_count += 1 # increment float count # return a tuple return float_count, int_count if __name__ == '__main__': nested_list = [[3,4.0,2,8.4,6],[0,2,0.2,4,6],[9,3.5,0.32,5,4]] float_n, int_n = float_and_int_count(nested_list) print('Float count: {}
Integer count: {}'.format(float_n, int_n))
Výkon
Náš program funguje takto:
- Vonkajšia slučka pristupuje k prvým vnútorným zoznamom [3,4,0,2,8,4,6] v našom vnorenom zozname.
- Vnútorná slučka pristupuje ku každej položke v tomto prvom vnútornom zozname. U každej položky skontroluje, či ide o float alebo integer. Ak je to celé číslo, zvýši sa počet celých čísel (int_count). Pokiaľ to nie je float, zvyšuje sa počet float (float_count).
- Akonáhle dokončí iteráciu cez tento prvý vnútorný zoznam, presunie sa späť do vonkajšej slučky a sprístupní druhý zoznam [0,2,0,2,4,6] a rovnaký proces pokračuje, kým nepristúpi na všetky vnútorné zoznamy.
# 2) Vnorenie do slučiek
Zatiaľ čo slučky môžu byť vnorené do seba.
Syntax nižšie zobrazuje 1-úrovňovú vnorenú while slučku.
while condition: # piece of code goes here while condition: # piece of code goes here
Príklad 3:Pomocou slučky vnorené while môžete do vzorov tlačiť hviezdičky (*)
Použijme slučku nested while na zostrojenie nasledujúceho vzoru:
* * * * * * * * * * * * * * *
def print_pattern(n): i = 0 # initialize to zero for outer loop j = 0 # initialize to zero for inner loop while i <= n: # outer loop runs n times while j < i: # inner loop runs i times print('*', end=' ') j += 1 # increment before checking inner loop condition j = 0 # re-initialize after leaving inner loop i += 1 # increment before checking outer loop condition print('') if __name__ == '__main__': n = 5 print_pattern(5)
Výkon
Náš program funguje nasledovne:
- Premenné sú inicializované (i = 0, j = 0, n = 5)
- Naša vonkajšia slučka kontroluje stav (0<= 5) which is obviously TRUE.
- Naša vnútorná slučka kontroluje stav (0<0) which is obviously FALSE, so our program breaks out of the inner loop.
- i sa zvýši a vonkajšia slučka znova skontroluje jej stav (1<= 5) which is TRUE.
- Naša vnútorná slučka kontroluje stav (0<1) which is TRUE. So a star( * ) sa vytlačí a j sa zvýši a stav vnútornej slučky sa skontroluje pomocou (1<1) which is FALSE, thus breaks out of the inner loop.
Vyššie uvedený proces pokračuje, kým sa podmienka vonkajšej slučky nestane NEPRAVDA.
Príklad - Pravopisná hra s číslami
Na zaokrúhlenie na a vnorená slučka , postavíme vzrušujúcu hru, ktorá pomôže pri hodnotení schopnosti dieťaťa rozpoznávať a hláskovať čísla.
Program zobrazuje na obrazovke náhodné čísla a žiadosti o pravopis tohto čísla. Skontroluje, či je vstup správny, a potom zobrazí ďalšie číslo. Ak je vstup nesprávny, odošle chybovú správu a požiada o ďalšiu odpoveď.
import random # random contain 'shuffle' used to shuffle our list def word_spelling(): print('HELLO, WELCOME TO THE WORD SPELLING GAME.
') print('SPELL AS MUCH NUMBERS AS YOU CAN TO GET MARKS
') print('-----------------------------------------------
') correct_score = 0 # keep record of correct spellings wrong_score = 0 # keep record of wrong spellings exceeding number of trials max_trials = 3 # maximum number of trials # A dictionary of numbers as keys and spellings as values. This can be expanded to increase its level of difficulty. number_spell = {0:'zero',1:'one',2:'two',3:'three',4:'four',5:'five',6:'six', 7:'seven',8:'eight',9:'nine',10:'ten'} # get the list of keys from the dict and shuffle them so that random numbers are displayed on the screen. number_spell_keys = list(number_spell.keys()) random.shuffle(number_spell_keys) # Our game starts here for number in number_spell_keys: # outer loop is a for loop which iterate through the keys trial_count = 0 # keeps track of number of trials while trial_count Výkon
Hlavné funkcie našich cyklov for-loop a while-loop sú:
- The pre slučku iteruje zoznamom čísel, ktoré sa používateľovi predkladajú na hláskovanie.
- The zatiaľ čo slučka kontroluje, či nebol prekročený počet pokusov. Týmto spôsobom je používateľovi pridelený maximálny počet pokusov, aby bol v poriadku.
Videli sme dva nové koncepty zatiaľ čo inak , prestávka (viac o tom neskôr). The zatiaľ čo slučka a pre slučku pôvodne majú iné vyhlásenie ktorá sa vykoná iba raz, keď je podmienka FALSE.
Python Infinite Loops
Ak nie sme opatrní s tým, ako implementujeme svoje slučky, môže to viesť k nekonečná slučka tj. program vykoná blok kódu navždy, kým nášmu počítaču nedôjde dostatok zdrojov, ako je pamäť CPU.
Príklad 1:Nekonečná slučka while
def infinit_loop_1(): numb = 0 while numb <5: print(numb) if __name__ == '__main__': infinit_loop_1()
Výkon
Poznámka : Ak chcete zastaviť spustenie tohto programu, použite Ctrl + z alebo Ctrl + c na termináli, ktorý ste použili na spustenie kódu.
Náš vyššie uvedený kód implementuje nekonečná while slučka . Je to však omylom, pretože naše zatiaľ čo slučka skontroluje stav znecitlivený<5, but there is nowhere in the code that actually increments the numb’s value. Hence the value of numb is always zero and the condition keeps returning TRUE.
Spôsob, ako to vyriešiť, je poskytnúť prostriedky na zvýšenie hodnoty necitlivosti.
def infinit_loop_1(): numb = 0 while numb <5: print(numb) numb += 1 # fix by incrementing numb's value if __name__ == '__main__': infinit_loop_1()
Výkon
Môže vzniknúť otázka tak, ako je nekonečné slučky naozaj nevyhnutné? Varovanie spojlera: Áno, sú. Server môže byť naprogramovaný tak, aby bežal nepretržite a súčasne slúžil potrebám klientov. V hrách môže udalosť prebiehať, kým si používateľ nevyberie akciu na ukončenie alebo prelomenie slučky.
Verte tomu alebo nie, skutočne sme použili nekonečná slučka v poslednom praktickom príklade vyššie. Ako na to? nekonečné slučky ?
Vyhlásenia o zlomení a pokračovaní Pythonu
Ako sme už vysvetlili vyššie, existujú prípady, kedy budeme musieť písať zámerne nekonečné slučky . V týchto prípadoch uvidíme, že prestávka a ďalej kľúčové slová sú chrbtovou kosťou nekonečné slučky .
The prestávka a ďalej kľúčové slová sa v Pythone bežne používajú ak vyhlásenie kde príkaz if kontroluje podmienku a ak je PRAVDA, buď sa vymaníme zo slučky, v ktorej bol volaný náš príkaz if, alebo pokračujeme preskočením celého kódu pod ním a vrátime sa na začiatok cyklu.
Príklad - Zhromažďujte čísla, kým nedosiahnete prahovú hodnotu
Uvažujme o programe, ktorý získava čísla z náhodne generovaného zdroja a hromadíme ich, kým sa nedosiahne prahová hodnota.
Dôvod, prečo tento príklad vyžaduje nekonečnú slučku, je ten, že nevieme presne, koľko iterácií bude náš program musieť vykonať, aby nahromadené počty dosiahli prahovú hodnotu.
Náš jediný záchranca je Python ak vyhlásenie spolu s zlomové vyhlásenie . Náš príkaz if kontroluje, či je dosiahnutá prahová hodnota, potom sa vymaže zo slučky, ak je TRUE.
Náš program tiež vyžaduje, aby sa nemuselo hromadiť obmedzené množstvo. Takže ak náš program narazí na tieto čísla, mal by preskočiť všetky kódy a vrátiť sa na začiatok slučky. To je možné dosiahnuť pomocou pokračovať vo vyhlásení .
import random def acc_numbers(): acc_numb = 0 # initialize our accumulator threshold = 45 # define our threshold value Rejected_numbers = [4,0,1] # define our rejected numbers while True: # This is an uncontrolled condition. # our infinite while loop # return random integer number within 0 and 10. numb = random.randint(0, 10) # check if the number is in the list of rejected numbers if numb in Rejected_numbers: print('Not accepting ', numb) continue # skip all code blow it and return to the beginning of the while loop # add random number to our store acc_numb += numb # check if the accumulated number has reached threshold if acc_numb >= threshold: print('Threshold attended') break # break out of the loop. if __name__ == '__main__': acc_numbers()
Výkon
často kladené otázky
Otázka č. 1) Ako ovládate slučku v Pythone?
Odpoveď: V Pythone môžete riadiť slučku pomocou nasledujúcich riadiacich príkazov:
- The prestávka kľúčové slovo vypadne zo slučky.
- The ďalej kľúčové slovo preskočí všetky kódy pod ním a vráti sa na začiatok slučky.
Tieto kľúčové slová sa väčšinou používajú v ak vyhlásenie ktorý najskôr skontroluje, či je podmienka TRUE alebo FALSE.
Otázka 2) Aký je rozdiel medzi cyklami for a while?
Odpoveď: TO pre slučku je slučka založená na iterátore , ktorý prechádza položkami opakovateľných objektov ako zoznamy , n-tice atď. Zatiaľ čo a zatiaľ čo slučka je a podmienková slučka , ktorý vykonáva blok výpisov opakovane, pokiaľ je jeho stav TRUE.
Otázka 3) Podporuje Python podporu až do slučky?
Odpoveď: Python, bohužiaľ, nepodporuje slučka do-while .
Otázka č. 4) Aké sú dva typy slučiek v Pythone?
Odpoveď: Python všeobecne podporuje dva typy slučiek: pre slučku a zatiaľ čo slučka . Tretia slučka [ vnorená slučka ] možno vygenerovať vnorením dvoch alebo viacerých z týchto slučiek.
Viac informácií o slučkách Python
Smyčkové príkazy v pythone sa používajú na vykonávanie bloku príkazov alebo kódu opakovane, a to niekoľkokrát, ako špecifikuje používateľ.
Python nám poskytuje dva typy slučiek, ako je uvedené nižšie:
- Zatiaľ čo slučka
- Pre slučku
# 1) Zatiaľ čo slučka:
Zatiaľ čo slučka v pythone sa používa na opakované vykonávanie viacerých príkazov alebo kódov, kým nie je splnená daná podmienka.
Ak neznáme počet opakovaní, použijeme while.
Syntax:
while (expression): block of statements Increment or decrement operator
V cykle while skontrolujeme výraz, ak sa stane skutočným, vykoná sa iba blok príkazov nachádzajúcich sa vo vnútri cyklu while. Pri každej iterácii skontroluje podmienku a vykoná blok výpisov, kým sa podmienka nestane nepravdivou.
Príklad:
number = 5 sum = 0 i = 0 while (i Výkon:
10
Výkon:
# 2) Pre slučku:
For loop v pythone sa používa na vykonanie bloku príkazov alebo kódu niekoľkokrát, kým sa daná podmienka nestane nepravdivou.
Smyčku for používame, keď vieme, koľkokrát máme iterovať.
Syntax:
for var in sequence: Block of code
Tu var vezme hodnotu zo sekvencie a bude ju vykonávať, kým nebudú hotové všetky hodnoty v sekvencii.
Príklad:
language = [‘Python’, ‘Java’, ‘Ruby’] for lang in language: print(“Current language is: “, lang)
Výkon:
Aktuálny jazyk je: Python
Aktuálny jazyk je: Java
Aktuálny jazyk je: Ruby
Výkon:
Pre slučku pomocou funkcie range ():
bezplatný zálohovací program pre Windows 7
Funkcia Range () sa používa na generovanie postupnosti čísel.
Napríklad, rozsah (5) vygeneruje čísla od 0 do 4 (5 čísel).
Príklad:
language = [‘Python’, ‘Java’, ‘Ruby’] for lang in range(len(language)): print(“Current language is: “, language[lang])
Výkon:
Aktuálny jazyk je: Python
Aktuálny jazyk je: Java
Aktuálny jazyk je: Ruby
Výkon:
Záver
V tomto tutoriáli sme videli definíciu slučiek, typy Pythonových slučiek, použitie pre slučku, a zatiaľ čo slučka s niekoľkými príkladmi.
Dozvedeli sme sa tiež ako vnorené slučky sú generované a konečné slučky rovnako a prišli sme vedieť, ako používať prestávka a ďalej Kľúčové slová.
=> Skontrolujte VŠETKY návody pre Python tu
Výukový program PREV | NEXT Tutorial
Odporúčané čítanie
- Kontrolné príkazy Pythonu (Python Continue, Break and Pass)
- Premenné Pythonu
- Výukový program pre Python pre začiatočníkov (praktické školenie v jazyku Python ZDARMA)
- Podmienené príkazy Pythonu: if_else, elif, vnorené, ak sú príkazy
- Operátory Pythonu
- Funkcie reťazca Python
- Výukový program pre Python DateTime s príkladmi
- Pythonove funkcie