KotazIO
Я расскажу о циклах for и while, операторах break и continue, а также о слове else, которое, будучи употребленное с циклом, может сделать программный код несколько более понятным.
Цикл while
While — один из самых универсальных циклов в Python, поэтому довольно медленный. Выполняет тело цикла до тех пор, пока условие цикла истинно.
Цикл for
Общее понятие
Цикл for уже чуточку сложнее, чуть менее универсальный, но выполняется гораздо быстрее цикла while. Этот цикл проходится по любому итерируемому объекту (например строке или списку), и во время каждого прохода выполняет тело цикла. Цикл for используется в том случае, когда необходимо выполнить некоторую часть кода до тех пор, пока не будет выполнено заданное условие. Цикл for также называют циклом c предусловием. Лучше использовать цикл for, если количество итераций известно заранее.
range()
Мы используем встроенную функцию Python range. Функция range создаст список длинной в «n» элементов. В Python версии 2.Х существует другая функция под названием xrange, которая является генератором чисел и не такая ресурсоемкая, как range. Ранее разработчики сменили xrange на range в Python 3. Вот пример:
Как вы видите, функция range взяла целое число и вернула объект range. Функция range также принимает начальное значение, конечное значение и значение шага. Вот еще два примера:
В пером примере показано, что вы можете передать начальное и конечное значение, и функция range вернет числа, начиная с начального значения вплоть до (но не включая) последнее значение. Например, при запросе 5-10 мы получим 5-9. Во втором примере видно, как использовать функцию списка (list) для того, чтобы функция range вернула каждый второй элемент, между 1 и 10. Так что она начинает с 1, пропускает 2 и так далее. Теперь вы, наверное, гадаете, что же именно она будет делать с циклами? Что-ж, есть один простой способ показать, как работает цикл с использованием функции range! Давайте взглянем:
Что здесь произошло? Давайте почитаем слева на право, чтобы понять это. Для каждого числа в диапазоне 5 мы вводим число. Мы знаем, что если мы вызываем range со значением 5, мы получим список из 5 элементов. Так что каждый раз, проходя через цикл, она выводит каждый из элементов. Цикл for, показанный выше, может быть эквивалентом следующего:
Мы попробуем применить цикл в функции range, но нам нужно вывести только целые числа. Чтобы сделать это, нам нужно использовать условный оператор вместо параметра шага range. Это можно сделать следующим образом:
Вы наверное гадаете, что вообще здесь происходит? Что еще за знак процента? В Python, % называется оператором модуля. Когда вы используете оператор модуля, он возвращает остаток. Когда вы делите целое число на два, вы получаете число без остатка, так что мы выводим эти числа. Вам, возможно, не захочется использовать оператор модуля часто в будущем, но в моей работе он нередко помогает. Теперь мы можем взглянуть на цикл while.
Словари
Функция range лишь делает результат несколько меньшим. Цикл for может обходить любой итератор Python. Мы уже видели, как именно он может работать со списком. Давайте взглянем, может ли он выполнять итерацию со словарем.
Когда вы используете for в словаре, вы увидите, что он автоматически перебирает ключи. Вам не нужно указывать ключ for в a_dict.keys() (впрочем, это также работает). Python делает только нужные нам вещи. Вы возможно думаете, почему ключи выводятся в другом порядке, отличном от того, какой был указан в словаре? Как мы знаем из соответствующей статьи, словари не упорядочены, так что мы можем выполнять итерацию над ними, при этом ключи могут быть в любом порядке. Теперь, зная, что ключи могут быть отсортированы, вы можете отсортировать их до итерации. Давайте немного изменим словарь, чтобы увидеть, как это работает.
Давайте остановимся и разберемся с тем, что делает этот код. Во-первых, мы создали словарь, в котором ключи выступают в качестве целых чисел, вместо строк. Далее, мы извлекли ключи из словаря. Каждый раз, когда вы взываете метод keys(), он возвращает неупорядоченный список ключей. Если вы выведите их, и увидите, что они расположен в порядке по возрастанию, то это просто случайность. Теперь у нас есть доступ к ключам словаря, которые хранятся в переменной, под названием keys. Мы сортируем наш список, после чего используем цикл for в нем. Теперь мы готовы к тому, чтобы сделать все немного интереснее.
Оператор continue
Оператор continue начинает следующий проход цикла, минуя оставшееся тело цикла (for или while)
Оператор break
Оператор break досрочно прерывает цикл.
Волшебное слово else
Слово else, примененное в цикле for или while, проверяет, был ли произведен выход из цикла инструкцией break, или же “естественным” образом. Блок инструкций внутри else выполнится только в том случае, если выход из цикла произошел без помощи break.
4. More Control Flow Tools¶
Besides the while statement just introduced, Python uses the usual flow control statements known from other languages, with some twists.
4.1. if Statements¶
Perhaps the most well-known statement type is the if statement. For example:
There can be zero or more elif parts, and the else part is optional. The keyword ‘ elif ’ is short for ‘else if’, and is useful to avoid excessive indentation. An if … elif … elif … sequence is a substitute for the switch or case statements found in other languages.
If you’re comparing the same value to several constants, or checking for specific types or attributes, you may also find the match statement useful. For more details see match Statements .
4.2. for Statements¶
The for statement in Python differs a bit from what you may be used to in C or Pascal. Rather than always iterating over an arithmetic progression of numbers (like in Pascal), or giving the user the ability to define both the iteration step and halting condition (as C), Python’s for statement iterates over the items of any sequence (a list or a string), in the order that they appear in the sequence. For example (no pun intended):
Code that modifies a collection while iterating over that same collection can be tricky to get right. Instead, it is usually more straight-forward to loop over a copy of the collection or to create a new collection:
4.3. The range() Function¶
If you do need to iterate over a sequence of numbers, the built-in function range() comes in handy. It generates arithmetic progressions:
The given end point is never part of the generated sequence; range(10) generates 10 values, the legal indices for items of a sequence of length 10. It is possible to let the range start at another number, or to specify a different increment (even negative; sometimes this is called the ‘step’):
To iterate over the indices of a sequence, you can combine range() and len() as follows:
In most such cases, however, it is convenient to use the enumerate() function, see Looping Techniques .
A strange thing happens if you just print a range:
In many ways the object returned by range() behaves as if it is a list, but in fact it isn’t. It is an object which returns the successive items of the desired sequence when you iterate over it, but it doesn’t really make the list, thus saving space.
We say such an object is iterable , that is, suitable as a target for functions and constructs that expect something from which they can obtain successive items until the supply is exhausted. We have seen that the for statement is such a construct, while an example of a function that takes an iterable is sum() :
Later we will see more functions that return iterables and take iterables as arguments. In chapter Data Structures , we will discuss in more detail about list() .
4.4. break and continue Statements, and else Clauses on Loops¶
The break statement, like in C, breaks out of the innermost enclosing for or while loop.
Loop statements may have an else clause; it is executed when the loop terminates through exhaustion of the iterable (with for ) or when the condition becomes false (with while ), but not when the loop is terminated by a break statement. This is exemplified by the following loop, which searches for prime numbers:
(Yes, this is the correct code. Look closely: the else clause belongs to the for loop, not the if statement.)
When used with a loop, the else clause has more in common with the else clause of a try statement than it does with that of if statements: a try statement’s else clause runs when no exception occurs, and a loop’s else clause runs when no break occurs. For more on the try statement and exceptions, see Handling Exceptions .
The continue statement, also borrowed from C, continues with the next iteration of the loop:
4.5. pass Statements¶
The pass statement does nothing. It can be used when a statement is required syntactically but the program requires no action. For example:
This is commonly used for creating minimal classes:
Another place pass can be used is as a place-holder for a function or conditional body when you are working on new code, allowing you to keep thinking at a more abstract level. The pass is silently ignored:
4.6. match Statements¶
A match statement takes an expression and compares its value to successive patterns given as one or more case blocks. This is superficially similar to a switch statement in C, Java or JavaScript (and many other languages), but it’s more similar to pattern matching in languages like Rust or Haskell. Only the first pattern that matches gets executed and it can also extract components (sequence elements or object attributes) from the value into variables.
The simplest form compares a subject value against one or more literals:
Note the last block: the “variable name” _ acts as a wildcard and never fails to match. If no case matches, none of the branches is executed.
You can combine several literals in a single pattern using | (“or”):
Patterns can look like unpacking assignments, and can be used to bind variables:
Study that one carefully! The first pattern has two literals, and can be thought of as an extension of the literal pattern shown above. But the next two patterns combine a literal and a variable, and the variable binds a value from the subject ( point ). The fourth pattern captures two values, which makes it conceptually similar to the unpacking assignment (x, y) = point .
If you are using classes to structure your data you can use the class name followed by an argument list resembling a constructor, but with the ability to capture attributes into variables:
You can use positional parameters with some builtin classes that provide an ordering for their attributes (e.g. dataclasses). You can also define a specific position for attributes in patterns by setting the __match_args__ special attribute in your classes. If it’s set to (“x”, “y”), the following patterns are all equivalent (and all bind the y attribute to the var variable):
A recommended way to read patterns is to look at them as an extended form of what you would put on the left of an assignment, to understand which variables would be set to what. Only the standalone names (like var above) are assigned to by a match statement. Dotted names (like foo.bar ), attribute names (the x= and y= above) or class names (recognized by the “(…)” next to them like Point above) are never assigned to.
Patterns can be arbitrarily nested. For example, if we have a short list of points, we could match it like this:
We can add an if clause to a pattern, known as a “guard”. If the guard is false, match goes on to try the next case block. Note that value capture happens before the guard is evaluated:
Several other key features of this statement:
Like unpacking assignments, tuple and list patterns have exactly the same meaning and actually match arbitrary sequences. An important exception is that they don’t match iterators or strings.
Sequence patterns support extended unpacking: [x, y, *rest] and (x, y, *rest) work similar to unpacking assignments. The name after * may also be _ , so (x, y, *_) matches a sequence of at least two items without binding the remaining items.
Mapping patterns: <"bandwidth": b, "latency": l>captures the "bandwidth" and "latency" values from a dictionary. Unlike sequence patterns, extra keys are ignored. An unpacking like **rest is also supported. (But **_ would be redundant, so it is not allowed.)
Subpatterns may be captured using the as keyword:
will capture the second element of the input as p2 (as long as the input is a sequence of two points)
Most literals are compared by equality, however the singletons True , False and None are compared by identity.
Patterns may use named constants. These must be dotted names to prevent them from being interpreted as capture variable:
For a more detailed explanation and additional examples, you can look into PEP 636 which is written in a tutorial format.
4.7. Defining Functions¶
We can create a function that writes the Fibonacci series to an arbitrary boundary:
The keyword def introduces a function definition. It must be followed by the function name and the parenthesized list of formal parameters. The statements that form the body of the function start at the next line, and must be indented.
The first statement of the function body can optionally be a string literal; this string literal is the function’s documentation string, or docstring. (More about docstrings can be found in the section Documentation Strings .) There are tools which use docstrings to automatically produce online or printed documentation, or to let the user interactively browse through code; it’s good practice to include docstrings in code that you write, so make a habit of it.
The execution of a function introduces a new symbol table used for the local variables of the function. More precisely, all variable assignments in a function store the value in the local symbol table; whereas variable references first look in the local symbol table, then in the local symbol tables of enclosing functions, then in the global symbol table, and finally in the table of built-in names. Thus, global variables and variables of enclosing functions cannot be directly assigned a value within a function (unless, for global variables, named in a global statement, or, for variables of enclosing functions, named in a nonlocal statement), although they may be referenced.
The actual parameters (arguments) to a function call are introduced in the local symbol table of the called function when it is called; thus, arguments are passed using call by value (where the value is always an object reference, not the value of the object). 1 When a function calls another function, or calls itself recursively, a new local symbol table is created for that call.
A function definition associates the function name with the function object in the current symbol table. The interpreter recognizes the object pointed to by that name as a user-defined function. Other names can also point to that same function object and can also be used to access the function:
Coming from other languages, you might object that fib is not a function but a procedure since it doesn’t return a value. In fact, even functions without a return statement do return a value, albeit a rather boring one. This value is called None (it’s a built-in name). Writing the value None is normally suppressed by the interpreter if it would be the only value written. You can see it if you really want to using print() :
It is simple to write a function that returns a list of the numbers of the Fibonacci series, instead of printing it:
This example, as usual, demonstrates some new Python features:
The return statement returns with a value from a function. return without an expression argument returns None . Falling off the end of a function also returns None .
The statement result.append(a) calls a method of the list object result . A method is a function that ‘belongs’ to an object and is named obj.methodname , where obj is some object (this may be an expression), and methodname is the name of a method that is defined by the object’s type. Different types define different methods. Methods of different types may have the same name without causing ambiguity. (It is possible to define your own object types and methods, using classes, see Classes ) The method append() shown in the example is defined for list objects; it adds a new element at the end of the list. In this example it is equivalent to result = result + [a] , but more efficient.
4.8. More on Defining Functions¶
It is also possible to define functions with a variable number of arguments. There are three forms, which can be combined.
4.8.1. Default Argument Values¶
The most useful form is to specify a default value for one or more arguments. This creates a function that can be called with fewer arguments than it is defined to allow. For example:
This function can be called in several ways:
giving only the mandatory argument: ask_ok(‘Do you really want to quit?’)
giving one of the optional arguments: ask_ok(‘OK to overwrite the file?’, 2)
or even giving all arguments: ask_ok(‘OK to overwrite the file?’, 2, ‘Come on, only yes or no!’)
This example also introduces the in keyword. This tests whether or not a sequence contains a certain value.
The default values are evaluated at the point of function definition in the defining scope, so that
Important warning: The default value is evaluated only once. This makes a difference when the default is a mutable object such as a list, dictionary, or instances of most classes. For example, the following function accumulates the arguments passed to it on subsequent calls:
This will print
If you don’t want the default to be shared between subsequent calls, you can write the function like this instead:
4.8.2. Keyword Arguments¶
Functions can also be called using keyword arguments of the form kwarg=value . For instance, the following function:
accepts one required argument ( voltage ) and three optional arguments ( state , action , and type ). This function can be called in any of the following ways:
but all the following calls would be invalid:
In a function call, keyword arguments must follow positional arguments. All the keyword arguments passed must match one of the arguments accepted by the function (e.g. actor is not a valid argument for the parrot function), and their order is not important. This also includes non-optional arguments (e.g. parrot(voltage=1000) is valid too). No argument may receive a value more than once. Here’s an example that fails due to this restriction:
When a final formal parameter of the form **name is present, it receives a dictionary (see Mapping Types — dict ) containing all keyword arguments except for those corresponding to a formal parameter. This may be combined with a formal parameter of the form *name (described in the next subsection) which receives a tuple containing the positional arguments beyond the formal parameter list. ( *name must occur before **name .) For example, if we define a function like this:
It could be called like this:
and of course it would print:
Note that the order in which the keyword arguments are printed is guaranteed to match the order in which they were provided in the function call.
4.8.3. Special parameters¶
By default, arguments may be passed to a Python function either by position or explicitly by keyword. For readability and performance, it makes sense to restrict the way arguments can be passed so that a developer need only look at the function definition to determine if items are passed by position, by position or keyword, or by keyword.
A function definition may look like:
where / and * are optional. If used, these symbols indicate the kind of parameter by how the arguments may be passed to the function: positional-only, positional-or-keyword, and keyword-only. Keyword parameters are also referred to as named parameters.
4.8.3.1. Positional-or-Keyword Arguments¶
If / and * are not present in the function definition, arguments may be passed to a function by position or by keyword.
4.8.3.2. Positional-Only Parameters¶
Looking at this in a bit more detail, it is possible to mark certain parameters as positional-only. If positional-only, the parameters’ order matters, and the parameters cannot be passed by keyword. Positional-only parameters are placed before a / (forward-slash). The / is used to logically separate the positional-only parameters from the rest of the parameters. If there is no / in the function definition, there are no positional-only parameters.
Parameters following the / may be positional-or-keyword or keyword-only.
4.8.3.3. Keyword-Only Arguments¶
To mark parameters as keyword-only, indicating the parameters must be passed by keyword argument, place an * in the arguments list just before the first keyword-only parameter.
4.8.3.4. Function Examples¶
Consider the following example function definitions paying close attention to the markers / and * :
The first function definition, standard_arg , the most familiar form, places no restrictions on the calling convention and arguments may be passed by position or keyword:
The second function pos_only_arg is restricted to only use positional parameters as there is a / in the function definition:
The third function kwd_only_args only allows keyword arguments as indicated by a * in the function definition:
And the last uses all three calling conventions in the same function definition:
Finally, consider this function definition which has a potential collision between the positional argument name and **kwds which has name as a key:
There is no possible call that will make it return True as the keyword ‘name’ will always bind to the first parameter. For example:
But using / (positional only arguments), it is possible since it allows name as a positional argument and ‘name’ as a key in the keyword arguments:
In other words, the names of positional-only parameters can be used in **kwds without ambiguity.
4.8.3.5. Recap¶
The use case will determine which parameters to use in the function definition:
Use positional-only if you want the name of the parameters to not be available to the user. This is useful when parameter names have no real meaning, if you want to enforce the order of the arguments when the function is called or if you need to take some positional parameters and arbitrary keywords.
Use keyword-only when names have meaning and the function definition is more understandable by being explicit with names or you want to prevent users relying on the position of the argument being passed.
For an API, use positional-only to prevent breaking API changes if the parameter’s name is modified in the future.
4.8.4. Arbitrary Argument Lists¶
Finally, the least frequently used option is to specify that a function can be called with an arbitrary number of arguments. These arguments will be wrapped up in a tuple (see Tuples and Sequences ). Before the variable number of arguments, zero or more normal arguments may occur.
Normally, these variadic arguments will be last in the list of formal parameters, because they scoop up all remaining input arguments that are passed to the function. Any formal parameters which occur after the *args parameter are ‘keyword-only’ arguments, meaning that they can only be used as keywords rather than positional arguments.
4.8.5. Unpacking Argument Lists¶
The reverse situation occurs when the arguments are already in a list or tuple but need to be unpacked for a function call requiring separate positional arguments. For instance, the built-in range() function expects separate start and stop arguments. If they are not available separately, write the function call with the * -operator to unpack the arguments out of a list or tuple:
In the same fashion, dictionaries can deliver keyword arguments with the ** -operator:
4.8.6. Lambda Expressions¶
Small anonymous functions can be created with the lambda keyword. This function returns the sum of its two arguments: lambda a, b: a+b . Lambda functions can be used wherever function objects are required. They are syntactically restricted to a single expression. Semantically, they are just syntactic sugar for a normal function definition. Like nested function definitions, lambda functions can reference variables from the containing scope:
The above example uses a lambda expression to return a function. Another use is to pass a small function as an argument:
4.8.7. Documentation Strings¶
Here are some conventions about the content and formatting of documentation strings.
The first line should always be a short, concise summary of the object’s purpose. For brevity, it should not explicitly state the object’s name or type, since these are available by other means (except if the name happens to be a verb describing a function’s operation). This line should begin with a capital letter and end with a period.
If there are more lines in the documentation string, the second line should be blank, visually separating the summary from the rest of the description. The following lines should be one or more paragraphs describing the object’s calling conventions, its side effects, etc.
The Python parser does not strip indentation from multi-line string literals in Python, so tools that process documentation have to strip indentation if desired. This is done using the following convention. The first non-blank line after the first line of the string determines the amount of indentation for the entire documentation string. (We can’t use the first line since it is generally adjacent to the string’s opening quotes so its indentation is not apparent in the string literal.) Whitespace “equivalent” to this indentation is then stripped from the start of all lines of the string. Lines that are indented less should not occur, but if they occur all their leading whitespace should be stripped. Equivalence of whitespace should be tested after expansion of tabs (to 8 spaces, normally).
Here is an example of a multi-line docstring:
4.8.8. Function Annotations¶
Function annotations are completely optional metadata information about the types used by user-defined functions (see PEP 3107 and PEP 484 for more information).
Annotations are stored in the __annotations__ attribute of the function as a dictionary and have no effect on any other part of the function. Parameter annotations are defined by a colon after the parameter name, followed by an expression evaluating to the value of the annotation. Return annotations are defined by a literal -> , followed by an expression, between the parameter list and the colon denoting the end of the def statement. The following example has a required argument, an optional argument, and the return value annotated:
4.9. Intermezzo: Coding Style¶
Now that you are about to write longer, more complex pieces of Python, it is a good time to talk about coding style. Most languages can be written (or more concise, formatted) in different styles; some are more readable than others. Making it easy for others to read your code is always a good idea, and adopting a nice coding style helps tremendously for that.
For Python, PEP 8 has emerged as the style guide that most projects adhere to; it promotes a very readable and eye-pleasing coding style. Every Python developer should read it at some point; here are the most important points extracted for you:
Use 4-space indentation, and no tabs.
4 spaces are a good compromise between small indentation (allows greater nesting depth) and large indentation (easier to read). Tabs introduce confusion, and are best left out.
Wrap lines so that they don’t exceed 79 characters.
This helps users with small displays and makes it possible to have several code files side-by-side on larger displays.
Use blank lines to separate functions and classes, and larger blocks of code inside functions.
When possible, put comments on a line of their own.
Use spaces around operators and after commas, but not directly inside bracketing constructs: a = f(1, 2) + g(3, 4) .
Name your classes and functions consistently; the convention is to use UpperCamelCase for classes and lowercase_with_underscores for functions and methods. Always use self as the name for the first method argument (see A First Look at Classes for more on classes and methods).
Don’t use fancy encodings if your code is meant to be used in international environments. Python’s default, UTF-8, or even plain ASCII work best in any case.
Likewise, don’t use non-ASCII characters in identifiers if there is only the slightest chance people speaking a different language will read or maintain the code.
Actually, call by object reference would be a better description, since if a mutable object is passed, the caller will see any changes the callee makes to it (items inserted into a list).
Циклы в Python: виды и примеры
Что это такое? Циклы в Python – инструменты, упрощающие работу с кодом. В программировании все циклично и последовательно. Написание любой программы состоит из прохождения определенных этапов, задачи в которых могут повторяться. Вот чтобы не тратить время на повторяющиеся элементы и были придуманы циклы. К слову, они есть в любом языке программирования, не только в Python.
Какие бывают? В Python основных циклов всего два – «while» и «for». Первый используется тогда, когда заранее известно количество итераций, а второй – когда нужно выполнить перебор элементов. Но мало знать принципы работы циклов, в работе необходимы еще и операторы, которые делают «while» и «for» бесконечными или вложенными, прерывают их или меняют. Ниже в статье постарались объяснить все это доступным языком с примерами.
Что такое циклы в языке программирования Python
Цикличные задачи имеют место даже в повседневной жизни. Например, различные списки продуктов, целей на день, назначенных встреч и т. д. Приходя в супермаркет, человек ориентируется на список, покупая все товары, которые в нем указаны.
Циклы в языке программирования Python
В сфере программирования циклы дают возможность осуществлять повтор тех или иных действий в зависимости от соблюдения имеющегося условия. Тем самым обеспечивается выполнение многократной последовательности инструкции.
В рамках данной темы можно выделить ряд базовых понятий:
- Единоразовое выполнение — так называемая итерация.
- Тело цикла — последовательность кода, которую можно исполнить многократно.
Используя Python, вы можете создавать вложенные циклы. В этом случае программа произведет запуск внешнего цикла и в первой его итерации перейдет во вложенный. После этого она вновь вернётся к началу внешнего и опять запустит внутренний. Эти действия будут выполняться вплоть до момента, когда последовательность не завершится или не прервется. Циклы очень полезны для выполнения задач, связанных с перебором определенного количества элементов в заданном списке.
Зачем нужны циклы в Python
Циклы в Python позволяют сделать из сложных задач более простые. С помощью них вы можете настроить поток программы так, чтобы код повторялся определенное количество раз. Иными словами, вам не придется постоянно прописывать один и тот же код. Допустим, что перед вами стоит задача вывода первых 20 натуральных чисел. Вы, конечно, можете применить оператор «print» 20 раз, но гораздо более удобный вариант — вывести их внутри цикла, который выполняет до 20 итераций.
Применительно к Python можно выделить следующие плюсы использования циклов:
- Возможность перебора элементов структур данных (массивов или связанных списков).
- Возможность многократного использования кода.
- Отсутствие необходимости прописывать один и то же код несколько раз.
Скачивайте и используйте уже сегодня:
Топ-30 самых востребованных и высокооплачиваемых профессий 2023
Поможет разобраться в актуальной ситуации на рынке труда
Подборка 50+ ресурсов об IT-сфере
Только лучшие телеграм-каналы, каналы Youtube, подкасты, форумы и многое другое для того, чтобы узнавать новое про IT
ТОП 50+ сервисов и приложений от Geekbrains
Безопасные и надежные программы для работы в наши дни
Эти преимущества циклов присущи и другим языкам.
2 цикла в Python
Теперь стоит понять, какие циклы существуют в Python. Выделяют две разновидности: «for» и «while». «For» чаще всего применяется в ситуациях, когда необходимо разработать программу, состоящую из множества уровней при наличии большого количества условий.
| Оператор цикла | Описание |
| «For» | Данный цикл применяется в том случае, если нужно выполнять тот или иной фрагмент вплоть до момента, когда будет исполнено заданное условие. Цикл «for», который иногда называют циклом с предусловием, рекомендуется применять в тех ситуациях, когда вы заранее знаете численность итераций. |
| «While» | Этот цикл применяется в тех случаях, когда численность итераций заранее не известна. Блок операторов выполняется до тех пор, пока не будет выполнено условие, указанное в цикле. У него есть альтернативное название — цикл с предварительной проверкой условия. |
| «do-while» | Он продолжается вплоть до момента, когда будет выполнено заданное условие. Альтернативное название — цикл с постусловием в Python. Применяется в ситуациях, при которых стоит задача как минимум однократного выполнения цикла. |
Примеры циклов в Python
Цикл «for»
Данный цикл в языке Python осуществляет поворотное выполнение сформированного кода на основе переменной или счетчика. Он применяется, только если нужно перебрать элементы заранее известное количество раз. Допустим, что у вас есть список. Сначала из него будет взят первый элемент, затем второй и т. д. При этом с каждым из этих элементов будет выполняться действие, заранее предписанное в теле «for». Приведем пример цикла в Python:
for [элемент] in [последовательность]:
«For» может также включать в себя различные виды данных: цифры, слова и т. д. К примеру:
Loops In python — Why Should You Use One
Dealing with redundant code and repetitive commands can be a nightmare for any programmer. Python makes use of loops, control and conditional statements to overcome this hurdle. This article will help you understand loops in python and all the terminologies that surround loops.
- What are Loops in Python?
- What is for loop and while loop?
- Loop control statements
What Are Loops In Python?
Loops in Python allow us to execute a group of statements several times. Let's take an example to understand why loops are used in python.
Suppose, you are a software developer and you are required to provide a software module for all the employees in your office. So, you must print the details of the payroll of each employee separately. Printing the details of all the employees will be a tiresome task, instead you can use the logic for calculating the details and keep on iterating the same logic statement. This will save your time and make your code efficient.
The illustration below is the flowchart for a loop:
The execution starts and checks if the condition is True or False. A condition could be any logic that we want to test in our program. If its true it will execute the body of the loop and if its false, It will exit the loop.
Conditional Statements
Conditional statements in Python support the usual logical conditions from mathematics.
- Equals: a == b
- Not Equals: a != b
- Less than: a < b
- Less than or equal to: a <= b
- Greater than: a > b
- Greater than or equal to : a >= b
These statements can be used in several ways, most commonly in if statement.
Let us understand the concept of if statements.
‘if’ Statement
An if statement is written using the ‘if’ keyword, The syntax is the keyword ‘if’ followed with the condition.
Below is the flowchart of the if statement:
As you can see, the execution encounters the if condition and acts accordingly. If it is true, it executes the body and if it is false, it exits the if statement.
Above code snippet illustrates the basic example of how a condition is used in the if statement.
When it reaches the if statement it checks whether the value of b is greater or not. If b is greater, it prints “b is greater“. Now if the condition is false, it exits the if statement and executes the next statement. In order to print the next statement, we can add a keyword ‘else’ for the alternate result that we wish to execute. Lets move to the else statement for better understanding.
‘else’ Statement
The else keyword catches anything that is not caught by the preceding conditions. When the condition is false for the if statement, the execution will move to the else statement.
Let's take a look at the flowchart of else statement below:
As you can see, when the if statement was false the execution moved to the body of else. Let's understand this with an example.
The first condition is not true, so we will move to the next statement which is the else statement and print “b is greater”.
In case we have more conditions to test, we can also use elif statement.
‘elif’ Statement
elif statement in layman term means “try this condition instead”. Rest of the conditions can be used by using the elif keyword.
Let us look at the code below:
“When the if statement is not true, the execution will move to the elif statement and check if it holds true. And in the end, the else statement if and elif are false.
Since a != b, “b is greater” will get printed here.
Note: python relies on indentation, other programming languages use curly brackets for loops.
What Is ‘for’ Loop and ‘while’ Loop
A for loop is used to execute statements, once for each item in the sequence. The sequence could be a list, a Dictionary, a set or a string.
A for loop has two parts, the block where the iteration statement is specified and then there is the body which is executed once every iteration.
Unlike while loop, we already specify the number of times the iterations must execute. for loop syntax takes three fields, a Boolean condition, initial value of the counting variable and the increment of the counting variable.
Look at the example to understand this better:
Here we were iterating through the list. To iterate through a code for a specified number of times we could use the range() function.
Range Function
Range function requires a specific sequence of numbers. It starts at 0 and then the value increments by 1 until the specified number is reached.
It will print from 0–2, the output will look like
Note: the range (3) does not mean the values from 0–3 but the values from 0–2.
Below is another example using the condition statements:
‘while’ Loop
The ‘while’ loop executes the set of statements as long as the condition is true.
It consists of a condition block and the body with the set of statements, It will keep on executing the statement until the condition becomes false. There is no guarantee to see how long the loop will keep iterating.
Following is the flowchart for while loop:
To understand this let’s take a look at the example below.
Output: it will print 1 2 3 4 5
The execution will continue until value of i reaches 6.
The while loop requires the relevant variable to be ready, here we need an indexing variable, which could be any value.
Let's consider another example:
Note: remember to iterate i or the loop will continue forever. if there is no control statement here, loop will continue forever. try removing the break statement and run again.
We might need to control the flow of the execution to favor a few conditions in some cases, so let’s understand the loop control statements in Python.
Loop Control Statements
To control the flow of the loop or to alter the execution based on a few specified conditions we use the loop control statements discussed below. The control statements are used to alter the execution based on the conditions.
In Python we have three control statements:
Break
Break statement is used to terminate the execution of the loop containing it. As soon as the loop comes across a break statement, the loop terminates and the execution transfers to the next statement following the loop.
As you can see the execution moves to the statement below the loop, when the break returns true.
Let us understand this better with an example:
Output:
Here the execution will stop as soon as the string “i” is encountered in the string. And then the execution will jump to the next statement.
Continue
The continue statement is used to skip the rest of the code in the loop for the current iteration. It does not terminate the loop like the break statement and continues with the remaining iterations.
When continue is encountered it only skips the remaining loop for that iteration only.
It will skip the string “i” in the output and the rest of the iterations will still execute. All letters in the string except “i” will be printed.
The pass statement is a null operation. It basically means that the statement is required syntactically but you do not wish to execute any command or code.
Take a look at the code below:
Output:
The execution will not be affected and it will just print the pass block once it encounters the “a” string. And the execution will start at “a” and execute the rest of the remaining iterations.
‘while’ Loop Using The Break Statement
Let's understand how we use a while loop using a break statement with an example below:
Output: it will print 1 2
The execution will be terminated when the iteration comes to 3 and the next statement will be executed.
Using Continue Statement
Let’s take an example for continue statement in a while loop:
Here the execution will be skipped, and the rest of the iterations will be executed.
Nested Loops
Python allows us to use one loop inside another loop, Following are a few examples
Nested for loop
An example to use a for loop inside another for loop:
Output:
Nested ‘while’ loop
Below is the basic syntax to use a nested while loop:
An example to show a nested while and for loop:
In this program we have used a while loop and inside the body of the while loop, we have incorporated a for loop.
The concepts discussed in this blog will help you understand the loops in Python. This will be very handy when you are looking to master Python and will help you make your code efficient. Python is a widely used high-level language. If you wish to check out more articles on the market’s most trending technologies like Artificial Intelligence, DevOps, Ethical Hacking, then you can refer to Edureka’s official site.
Do look out for other articles in this series which will explain the various other aspects of Python and Data Science.