python loops while
Toto video tutoriál vysvětluje roli smyček v Pythonu, jejich typy: For, While, Nested Loops se syntaxí a příklady praktického programování:
Dozvěděli jsme se o čtyřech různých Podmíněné příkazy v Pythonu v našem předchozím tutoriálu.
Smyčky jsou výkonné programovací koncepty podporované téměř všemi moderními programovacími jazyky. Umožňuje programu implementovat iterace, což v podstatě znamená provádění stejného bloku kódu dvakrát nebo vícekrát.
Ačkoli jsou podporovány všemi moderními programovacími jazyky a poskytují podobné základní funkce, jejich implementace a syntaxe se mohou lišit.
The Celá řada školení o Pythonu vám dá krátkou představu o čem je Python.
Co se naučíte:
- Výukový program Python Loops Video
- Co jsou to pythonové smyčky
- Pro smyčku v Pythonu
- The While Loop
- Vnořená smyčka
- Python Infinite Loops
- Závěr
Výukový program Python Loops Video
Co jsou to pythonové smyčky
V Pythonu se příkazy provádějí sekvenčním způsobem, tj. Je-li náš kód tvořen několika řádky kódu, bude spuštění spuštěno na prvním řádku, následovaném druhým atd.
Budou však existovat případy, kdy můžeme chtít blok kódu spustit několikrát, dokud nebude splněna podmínka. Díky příkazům smyčky to dokážeme.
Níže je uveden vývojový diagram, který ilustruje, jak funguje příkaz smyčky.
Na základě výše uvedeného diagramu začne program Python v Start [circle] a provedení bude pokračovat do příkazu podmínky [Diamond], pokud je podmínka TRUE, program provede blok kódu.
Provedení bude pokračovat znovu k příkazu podmínky a stejný proces pokračuje pokaždé, když je podmínka PRAVDA. Vylomí se pouze ze smyčky nebo zastaví provádění bloku kódu, pokud je podmínka FALSE, a v tomto případě bude program pokračovat v provádění postupně.
Python má dva typy smyček.
# | Typ smyčky | Popis |
---|---|---|
1 | pro smyčku | Je smyčka založená na iterátoru, která prochází položkami iterovatelných objektů, jako jsou seznamy, n-tice, řetězce a opakovaně provádí část kódu na základě počtu položek v tomto iterovatelném objektu. |
dva | zatímco smyčka | Provádí blok příkazů opakovaně, pokud je podmínka TRUE. |
Tyto dva typy smyček lze použít ke generování uvnitř sebe vnořené smyčky (více o tom později).
Obecné použití smyček Pythonu
V Pythonu lze smyčky použít k řešení úžasných a složitých problémů. Pravděpodobně narazíte na problémy, které by vyžadovaly opakování akce, dokud není splněna podmínka (zatímco smyčka funguje nejlépe zde), nebo problém, který vyžaduje, abyste provedli akci se spoustou položek (pro smyčku funguje nejlépe zde).
Pro smyčku v Pythonu
The pro smyčku funguje dobře s iterovatelnými objekty jako seznamy , n-tice , struny Tímto způsobem můžeme procházet položky těchto objektů a manipulovat s jejich hodnotami na základě našeho propojení.
The pro smyčku má nulový index a má následující syntaxi.
for in n:
Stav v pro smyčku zůstane PRAVDA pouze v případě, že iterace neproběhla všemi položkami v iterovatelném objektu (n). Abychom lépe porozuměli pro smyčku , budeme se věnovat několika příkladům a nakonec budeme pracovat na praktickém příkladu.
Příklad 1:Tisk čísel od začátku do konce
K dosažení tohoto cíle použijeme Python rozsah funkce.
Takto bude vývojový diagram vypadat:
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ýstup
Ve výše uvedeném příkladu jsme použili rozsah Pythonu, což je funkce, která vrací posloupnost čísel počínaje a Start number (0 in default), increments by a krok (1 ve výchozím nastavení) a zastaví se před konec číslo.
Pro tento příklad, máme následující:
Parametry a hodnoty pro funkci rozsahu Pythonu
Parametry | Hodnota |
---|---|
Start | 1 |
konec | dvacet |
krok | 1 (výchozí hodnota) |
Takže naše pro smyčku bude iterovat posloupností čísel od 1 do 20 a pro každou iteraci toto číslo vytiskne. Když byla navštívena všechna čísla v pořadí, iterace se zastaví.
Příklad 2:Určete, zda je číslo prvočíslo.
V tomto příkladu uvidíme, proč pro smyčku je tak silný a užitečný. Zde budeme iterovat posloupností čísel a pro každé číslo provedeme nějaký výpočet, abychom zjistili, zda je podmínka TRUE nebo FALSE.
Může to pomoci znát podmínky pro prvočíslo čísla.
- Číslo je vždy kladné, větší než 1.
- Nemá žádné kladné dělitele kromě 1 a sebe sama.
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, když je vstup 13
Výstup, když je vstup 10
Poznámka: The kdyby-jinak použitý ve výše uvedeném příkladu je podmíněný příkaz a ne smyčka. Ale stejně jako zatímco smyčka (kterému se brzy budeme věnovat), používá pro svůj stav operátory porovnání.
Příklad - Najděte počet slov v textu pomocí smyčky for
Tento příklad je o počítání, kolikrát se každé slovo vyskytuje v textu. Existuje tolik způsobů, jak toho lze dosáhnout, ale pro tento příklad použijeme pro smyčku .
Počítáme slova z níže uvedeného textu.
Dobrý den, vítejte v nápovědě k testování softwaru. V tomto článku: „Smyčky v Pythonu“ se o smyčkách dozvíte na praktických příkladech. Skvělé, že? Postupujte, jak se učíme společně.
Šťastné programování!
První věcí, kterou musíme udělat, je odstranit interpunkci, mezery a všechna malá písmena. Interpunkci odstraníme tradičním způsobem tak, že určíme, která interpunkce v našem textu existuje, a poté použijeme pro smyčku nahradit je prázdným řetězcem.
Jelikož toho textu není moc, vidíme, že interpunkce jsou čárky (,), doba (.), otazník (?), dvojtečka (:), uvozovky (') a apostrof („).
Níže je uveden kód, který je nahradí prázdným řetězcem. Všimněte si, ž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ýstup
Dále text rozdělíme na seznam slov oddělených mezerami.
# Split text into list of words separated by whitespaces(tab, newline) text = text.split()
Výstup
Nakonec spočítáme a uvidíme, kolikrát se každé slovo objeví v rozděleném textu.
# 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ýstup
Můžeme jasně vidět, že některá slova se objevují dvakrát a některá jen jednou. Pojďme seřadit tento slovník podle jeho hodnoty v sestupném pořadí, abychom mohli jasně rozlišovat. Zde jsme použili Python tříděná funkce , výraz lambda , a porozumění slovníku .
špičkové společnosti zabývající se průzkumem trhu na světě
# Sort dictionary by value, in descending order wordsCount = {w: c for w, c in sorted(wordsCount.items(), key=lambda item: item[1], reverse=True)}
Nakonec jsme použili pro smyčku vyčistit, spočítat a třídit slova v našem textu.
Níže 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 zatímco smyčka provádí blok příkazů opakovaně, pokud je podmínka TRUE. Všimli jsme si, že je to trochu podobné pokud prohlášení . Na rozdíl od zatímco smyčka , příkaz if se provede pouze jednou, pokud je jeho podmínka PRAVDA.
Smyčka while má následující syntaxi:
While condition: expression(block of code)
Na rozdíl od pro smyčku , zatímco smyčka ne iteruje přes sekvenci. Pro svůj stav používá operátory porovnání a booleans.
Podívejme se na několik příkladů, abychom lépe pochopili, jak se používá.
Příklad 1:Vytisknout „Ahoj světe!“ početrát
The zatímco smyčka zkontroluje stav (počet
Takto bude vývojový diagram vypadat:
def print_count_times(n): # set count to 0 count = 0 while count Výstup:
Příklad 2:Najděte faktoriál čísla
Faktoriál čísla je reprezentován jako n! a má vzorec
1*2*...*(n-1)
Program zkontroluje, zda je číslo 0, a vrátí 1 (faktoriál 0 je 1). Pak zatímco smyčka zkontroluje podmínku (n> = 1), aby zjistil, zda je naše n rovné 1 nebo větší než 1. Pokaždé, když je tato podmínka PRAVDA, náš program vypočítá vzorec v bloku smyčky
Použijme smyčku while k vyřešení faktoriálního problému
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ýstup
Příklad - Najděte sekvenci Fibonacci až do n. Termínu pomocí smyčky While
Fibonacciho sekvence má vzorec.
0,1,1,...((n-1)th + (n-2)th)
První dvě čísla jsou 0 a 1, další čísla jsou součtem dvou předchozích čísel (n-1) th a (n-2) th.
Fibonacciho sekvence 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ýstup
dobrý mp3 stahovač hudby pro Android
Náš program nejprve definuje první n-tou hodnotu (n1 = 0), poté zkontroluje, zda se n_term předaný jako argument rovná 1. Pokud má hodnotu TRUE, vrátí hodnotu 0.
Jinak definuje dvě proměnné:
- count = 0: Toto bude použito v zatímco smyčka zkontrolovat podmínku, pokud je počet menší než n_term (count
- n2 = 1: Toto je naše druhá n-ta hodnota.
Zatím máme 0,1 v naší posloupnosti (n1, n2). Zatímco podmínka je PRAVDA:
- Hodnota n2 se přiřadí dočasné proměnné (temp = n2).
- Vypočítá se součet dvou předchozích čísel a přiřadí se n2 (n2 = n1 + n2).
- Naše dočasná hodnota (stará hodnota n2) je přiřazena k n1 (n1 = teplota).
- Náš počet se zvýší (počet + = 1) a podmínka se znovu zkontroluje.
Na konci první iterace máme 0,1,1, kde:
- n1 = 1 (první 1)
- n2 = 1 (druhá 1)
Tato operace se bude opakovat, dokud se stav nezapočítá Vnořená smyčka
Skvělá věc na smyčkách Pythonu je, že mohou být vnořeny, tj. Můžeme použít jednu nebo více smyček uvnitř jiné smyčky. To nám umožňuje řešit ještě složitější problémy.
# 1) Vnoření pro smyčky
pro smyčky mohou být vnořeny do sebe. Syntaxe níže ukazuje 1-úroveň vnořenou pro smyčku.
for in n: # piece of code goes here for in n: # piece of code goes here
Příklad 1:Použijte vnořenou smyčku pro tisk čísel ve vzorech
Použijme vnořenou smyčku for k vytištění následujícího vzoru:
1 2 2 3 3 3 4 4 4 4 5 5 5 5 5
Každé číslo je vytištěno několikrát, což odpovídá jeho samotnému číslu.
Takto bude vývojový diagram vypadat:
Vývojový diagram vnořené smyč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ýstup
Náš program funguje následovně:
- Vnější smyčka iteruje v rozsahu od 1 do 6 a pro každou položku v této sekvenci.
- Vstupuje do vnitřní smyčky, kde iteruje v rozsahu dané položky.
- Pro každou iteraci této položky se položka vytiskne.
- Opustí vnitřní smyčku, pouze když zcela iteruje rozsahem této položky.
- Když opustí vnitřní smyčku, vrátí se zpět do vnější smyčky a proces pokračuje, dokud zcela iteruje svou sekvenci.
Příklad 2:Manipulujte s položkami vnořeného seznamu pomocí vnořené smyčky for
V Pythonu se pravděpodobně setkáme s přístupem k položkám vnořeného seznamu.
Vezměte si například vnořený seznam níže.
>>> [[3,4.0,2,8.4,6],[0,2,0.2,4,6],[9,3.5,0.32,5,4]]
V tomto příkladu Pojďme napsat program, který spočítá počet celých čísel a plováků v tomto vnořeném seznamu.
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ýstup
Náš program funguje takto:
- Vnější smyčka přistupuje k prvním vnitřním seznamům [3,4,0,2,8,4,6] v našem vnořeném seznamu.
- Vnitřní smyčka přistupuje ke každé položce v tomto prvním vnitřním seznamu. U každé položky zkontroluje, zda se jedná o float nebo integer. Pokud se jedná o celé číslo, zvýší počet celých čísel (int_count). Jinak, pokud se jedná o float, zvýší počet float (float_count).
- Jakmile dokončí iteraci prostřednictvím tohoto prvního vnitřního seznamu, přesune se zpět do vnější smyčky a přistupuje k druhému seznamu [0,2,0,2,4,6] a stejný proces pokračuje, dokud nemá přístup ke všem vnitřním seznamům.
# 2) Vnoření do smyček
Zatímco smyčky mohou být vnořeny do sebe.
Syntaxe níže ukazuje 1-úroveň vnořenou while smyčku.
while condition: # piece of code goes here while condition: # piece of code goes here
Příklad 3:Pomocí smyčky nested while můžete tisknout hvězdičky (*) ve vzorech
Pojďme pomocí smyčky nested while vytvořit následující vzor:
* * * * * * * * * * * * * * *
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ýstup
Náš program funguje následovně:
- Proměnné jsou inicializovány (i = 0, j = 0, n = 5)
- Naše vnější smyčka kontroluje stav (0<= 5) which is obviously TRUE.
- Naše vnitřní smyčka kontroluje stav (0<0) which is obviously FALSE, so our program breaks out of the inner loop.
- i se zvýší a vnější smyčka znovu zkontroluje jeho stav (1<= 5) which is TRUE.
- Naše vnitřní smyčka kontroluje stav (0<1) which is TRUE. So a star( * ) se vytiskne a j se zvýší a stav vnitřní smyčky se zkontroluje pomocí (1<1) which is FALSE, thus breaks out of the inner loop.
Výše uvedený proces pokračuje, dokud se podmínka vnější smyčky nestane NEPRAVDA.
Příklad - hra s pravopisem čísel
Zaokrouhlit na a vnořená smyčka „Postavíme vzrušující hru, která pomůže při hodnocení schopnosti dítěte rozpoznávat a hláskovat čísla.
Program zobrazuje náhodná čísla na obrazovce a požadavky na pravopis tohoto čísla. Zkontroluje, zda je vstup správný, a poté zobrazí další číslo. Pokud je vstup špatný, odešle chybovou zprávu a požádá o další odpověď.
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ýstup
Hlavní funkce naší smyčky for-loop a while-loop jsou:
- The pro smyčku iteruje seznamem čísel, která jsou uživateli předána k hláskování.
- The zatímco smyčka zkontroluje, zda byl překročen počet pokusů. Tímto způsobem je uživateli dán maximální počet pokusů, aby to bylo správné.
Viděli jsme dva nové koncepty while-else , přestávka (více o tom později). The zatímco smyčka a pro smyčku původně mají prohlášení else který se provede pouze jednou, když je podmínka FALSE.
Python Infinite Loops
Pokud nejsme opatrní s tím, jak implementujeme naše smyčky, pak to může vést k nekonečná smyčka tj. program provede blok kódu navždy, dokud náš počítač nevyčerpá zdroje, jako je paměť CPU.
Příklad 1:Nekonečná smyčka while
def infinit_loop_1(): numb = 0 while numb <5: print(numb) if __name__ == '__main__': infinit_loop_1()
Výstup
Poznámka : Chcete-li zastavit spuštění tohoto programu, použijte Ctrl + z nebo Ctrl + C na terminálu, který jste použili ke spuštění kódu.
Náš výše uvedený kód implementuje nekonečná while smyčka . Je to však omylem, protože naše zatímco smyčka zkontroluje stav znecitlivění<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.
Způsob, jak to opravit, je poskytnout prostředky ke zvýšení hodnoty znecitlivění.
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ýstup
Může vyvstat otázka tak, jak je nekonečné smyčky opravdu nutné? Upozornění na spoiler: Ano, jsou. Server může být naprogramován tak, aby běžel nepřetržitě a současně sloužil potřebám klientů. Ve hře může událost běžet, dokud si uživatel nevybere akci k ukončení nebo přerušení smyčky.
Věřte tomu nebo ne, skutečně jsme použili nekonečná smyčka v posledním praktickém příkladu výše. Jak se tedy máme vypořádat nekonečné smyčky ?
Python Přerušit a pokračovat výpisy
Jak jsme vysvětlili výše, existují případy, kdy budeme muset psát úmyslně nekonečné smyčky . V těchto případech uvidíme, že přestávka a pokračovat klíčová slova jsou páteří nekonečné smyčky .
The přestávka a pokračovat klíčová slova se v Pythonu běžně používají pokud prohlášení kde příkaz if kontroluje podmínku a je-li to PRAVDA, buď se vymaníme ze smyčky, ve které byl volán náš příkaz if, nebo pokračujeme přeskočením celého kódu pod ním a vrátíme se na začátek smyčky.
Příklad - hromadit čísla, dokud není splněna prahová hodnota
Uvažujme o programu, který získává čísla z náhodně generovaného zdroje a hromadíme je, dokud není dosaženo prahové hodnoty.
Důvod, proč tento příklad vyžaduje nekonečnou smyčku, je ten, že nevíme přesně, kolik iterací bude náš program muset provést, aby akumulované počty dosáhly prahové hodnoty.
Náš jediný zachránce je Python pokud prohlášení společně s prohlášení o přestávce . Náš příkaz if zkontroluje, zda je dosažena prahová hodnota, pak se vymaní ze smyčky, pokud má hodnotu TRUE.
Náš program také vyžaduje, aby se neshromažďovala omezená čísla. Pokud tedy náš program narazí na tato čísla, měl by přeskočit všechny kódy a vrátit se na začátek smyčky. Toho je možné dosáhnout pomocí pokračovat v prohlášení .
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ýstup
Často kladené otázky
Otázka č. 1) Jak ovládáte smyčku v Pythonu?
Odpovědět: V Pythonu můžete ovládat smyčku pomocí následujících řídicích příkazů:
- The přestávka klíčové slovo se vymyká ze smyčky.
- The pokračovat klíčové slovo přeskočí všechny kódy pod ním a vrátí se na začátek smyčky.
Tato klíčová slova se většinou používají v pokud prohlášení nejprve zkontroluje, zda je podmínka PRAVDA nebo NEPRAVDA.
Otázka 2) Jaký je rozdíl mezi smyčkou for a while?
Odpovědět: NA pro smyčku je smyčka založená na iterátoru , který prochází položkami iterovatelných objektů jako seznamy , n-tice atd. Zatímco zatímco smyčka je podmínková smyčka , který provádí blok příkazů opakovaně, pokud je jeho podmínka PRAVDA.
Otázka č. 3) Podporuje Python podporu až do smyčky?
Odpovědět: Python bohužel nepodporuje smyčka do-while .
Otázka č. 4) Jaké jsou dva typy smyček v Pythonu?
Odpovědět: Python obecně podporuje dva typy smyček: pro smyčku a zatímco smyčka . Třetí smyčka [ vnořená smyčka ] lze generovat vnořením dvou nebo více těchto smyček.
Více o Python Loops
Smyčkové příkazy v pythonu se používají k opakovanému provádění bloku příkazů nebo kódu několikrát podle zadání uživatele.
Python nám poskytuje 2 typy smyček, jak je uvedeno níže:
- Zatímco smyčka
- Pro smyčku
# 1) Zatímco smyčka:
Zatímco smyčka v pythonu se používá k opakovanému provádění více příkazů nebo kódů, dokud není daná podmínka pravdivá.
Když neznáme počet opakování, použijeme smyčku while.
Syntax:
while (expression): block of statements Increment or decrement operator
Ve smyčce while zkontrolujeme výraz, pokud se výraz stane pravdivým, provede se pouze blok příkazů uvnitř smyčky while. Pro každou iteraci zkontroluje podmínku a provede blok příkazů, dokud se podmínka nestane nepravdivou.
Příklad:
number = 5 sum = 0 i = 0 while (i Výstup:
10
Výstup:
# 2) Pro smyčku:
Pro smyčku v pythonu se používá k provádění bloku příkazů nebo kódu několikrát, dokud se daná podmínka nestane nepravdivou.
Smyčku for používáme, když známe počet opakování.
Syntax:
for var in sequence: Block of code
Zde var vezme hodnotu ze sekvence a bude ji provádět, dokud nebudou provedeny všechny hodnoty v sekvenci.
Příklad:
language = [‘Python’, ‘Java’, ‘Ruby’] for lang in language: print(“Current language is: “, lang)
Výstup:
Aktuální jazyk je: Python
Aktuální jazyk je: Java
Aktuální jazyk je: Ruby
Výstup:
Pro smyčku pomocí funkce range ():
Funkce Range () se používá ke generování posloupnosti čísel.
Například, range (5) vygeneruje čísla od 0 do 4 (5 čísel).
Příklad:
language = [‘Python’, ‘Java’, ‘Ruby’] for lang in range(len(language)): print(“Current language is: “, language[lang])
Výstup:
Aktuální jazyk je: Python
Aktuální jazyk je: Java
Aktuální jazyk je: Ruby
Výstup:
jaký je váš přístup při testování mobilních aplikací
Závěr
V tomto kurzu jsme viděli definici smyček, typy smyček Pythonu, použití pro smyčku, a zatímco smyčka s několika příklady.
Také jsme se naučili jak vnořené smyčky jsou generovány a konečné smyčky stejně a my jsme věděli, jak používat přestávka a pokračovat klíčová slova.
=> Zkontrolujte VŠECHNY výukové programy pro Python zde
Výukový program PREV | DALŠÍ výuka
Doporučené čtení
- Ovládací příkazy Pythonu (Python Continue, Break and Pass)
- Proměnné Pythonu
- Výukový program pro Python pro začátečníky (praktické školení v Pythonu ZDARMA)
- Podmíněné příkazy Pythonu: if_else, elif, nested if Statements
- Operátoři Pythonu
- Funkce řetězce Python
- Výukový program Python DateTime s příklady
- Funkce Pythonu