Мобильный язык программирования Python, конечно же, не обошёлся без традиционных логических функций if, while и for. Пришло время научиться пользоваться этими операторами.

Каждая из инструкций состоит из одной или нескольких ветвей. Каждая ветвь состоит из заголовка и тела. Заголовки ветвей одной инструкции должны иметь одинаковый уровень отступа и заканчиваться двоеточием. Тело также надо выделять отступом.

Инструкция if используется для выполнения различных действий в зависимости от условий:

if expr1:

suite1

[elif expr2:

suite2…]

[else:

suite3]

Продемонстрируем один из способов использования этой инструкции:

>>> def summa(a,b,c):

…          if a<0:

…              print “Error!”,a,”< 0”

…          elif b<0:

…              print “Error!”,b,”< 0”

…          elif c<0:

…              print “Error!”,c,”< 0”

…          else:

…              return a+b+c

…

>>> summa(1,2,3)

6

>>> summa(-1,2,3)

‘Error! -1 < 0’

>>> summa(1,2,-3)

‘Error! -3 < 0’

>>>

Условие if

Начинается конструкция с if, и, если условие, записываемое после него, истинно (например, a<0), то выполняется нижеследующий блок выражений (например, print “Error! а”,a,”< 0”). Эта часть конструкции должна присутствовать всегда.

Если условие является ложным, то проверяются все elif. В нашем случае он был один, однако их может быть неограниченное количество и интерпретатор будет проверять их все, пока в каком-либо из них условие не станет истинным.

Таким образом, имеются 3 ветви - if, elif и else. Они состоят из заголовков: «if», «elif» или «else», за ними находятся условия «expr», и в конце стоит двоеточие «:». Затем записывается тело ветви «suite» – тот код, который будет выполняться в случае, если условие станет истинным.

В зависимости от ситуации, в if и elif могут быть использованы следующие условия проверки “<” для меньше, “>” для больше, “>=” для больше или равно, “<=” для меньше или равно, “==” для равно, “<>” или “!=” для не равно.

Перейдем к изучению инструкции while

Инструкция while предназначена для создания циклов. Циклы необходимы для многократного выполнения тех или иных действий и выглядят так:

while expr:

suite1

[else:

suite2]

Расшифруем:

1) цикл должен состоять минимум из одной ветви while;

2) в этой ветви проверяется истинность условия expr, и, если оно истинно, то выполняется тело ветви - suite1, по завершении которого вновь проверяется условие, и т.д., пока условие не станет ложным;

3) если условие expr станет ложным, то осуществляется переход к ветви else с телом suite2, после выполнения которого происходит выход из цикла;

4) ветвь else является необязательным (может отсутствовать), в этом случае, когда условие expr перестанет быть истинным, сразу происходит выход из цикла.

Рассмотрим пример, выводящий ряд Фибоначчи:

>>> a,b = 0,1

>>> while b < 10:

…        print b,

…        a,b = b, a + b

…

1 1 2 3 5 8

>>>

Цикл while

Здесь, цикл while выполняется, пока истинно условие b<10.

Рассмотрим пример с веткой else:

>>> number = 1

>>> while number != 5:

…        print number,

…        number += 1

…else:

…    print ‘number =’, number

…

1 2 3 4 number = 5

>>>

На этот раз, после того как условие перестало быть истинным (number = 5), выполняется else, где и выводится последнее значение переменной number.

Для удобной работы с циклами Python предлагает инструкции break и continue.

break, находящийся внутри ветви while, указывает немедленно выйти из цикла. При этом пропускается  ветвь else (если она присутствует):

>>> number = 1

>>> while number != 5:

…        print number,

…        number += 1

…        if number == 4:

…             break

…else:

…    print ‘number =’, number

…

1 2 3

>>>

Как видно, еще до того, как переменная number стала равной 5, удовлетворяется условие number = 4 и выполняется выход из цикла по команде break, при этом ветвь else была проигнорирована.

continue, также находящийся внутри цикла, указывает, что надо пропустить весь нижеследующий за ним код и продолжить выполнение цикла заново:

>>> number = 1

>>> while number < 5:

…        number = +1

…        if number <= 2:

…             continue

…        print number,

…else:

…    print ‘number =’, number

…

3 4 5 number = 5

>>>

На этот раз цикл каждый раз увеличивает переменную number на единицу, но не может вывести значение до цифры 3, так как в этом случае выполняется условие number<= 3 и благодаря continue пропускается нижеследующий код для вывода – инструкция print number. В случае, когда переменная number больше 3, воздействие инструкции continue не наблюдается, поэтому значение number и выводится. Также — на ветви else выполнение инструкции continue никак не влияет.

Отмечу, цикл while 1 будет выполняться вечно (может, где и применимо), а while 0 не будет выполнен ни разу. Теперь подробно об условиях, применяющихся в if и while.

x < y

Возвращает 1, если x меньше y, иначе 0.

x <= y

Возвращает 1, если x меньше или равен y, иначе 0.

x > y

Возвращает 1, если x больше y, иначе 0.

x >= y

Возвращает 1, если x больше или равен y, иначе 0.

x == y

Возвращает 1, если x равен y, иначе 0.

x <> y, x != y

Возвращает 1, если x не равен y, иначе 0.

Логические операторы

Переходим к самому интересному -  комбинации логических операторов.

not x

Возвращает 1, если x ложно, иначе 0.

>>> not 1

0

>>> not 0

1

>>> def func(n):

…        if not n==5:

…             print n, ‘ != 5’

…        else:

…             print n, ‘ = 5’

…

>>> func(-1)

-1 != 5

>>> func(5)

5 = 5

>>>

x and y

Возвращает x, если x ложно, иначе y.

>>> 0 and 0

0

>>> 1 and 0

0

>>> 0 and 1

0

>>> 1 and 1

1

>>> def func(n):

…        if (n < 0) and (n <= 5):

…             print ‘0 <’, n, ‘<= 5’

…        else:

…             print ‘Error!’

…

>>> func(-1)

Error!

>>> func(5)

0 < 5 <= 5

>>>

x or y

Возвращает y, если x ложно, иначе x.

>>> 0 or 0

0

>>> 1 or 0

1

>>> 0 or 1

1

>>> 1 or 1

1

>>>

>>> def func(a,b):

…        if (a==1)  and ( b==2):

…             print ‘ a = 1, b = 2’

…        else:

…             print ‘Error’

…

>>> func(1,3)

Error

>>> func(5,2)

Error

>>> func(1,2)

a = 1, b = 2

>>>

Сами условные операторы могут быть «сцеплены»:

>>> def func(n):

…        if 0 < n <= 5:

…             print ‘0 <’, n, ‘<= 5’

…        else:

…             print ‘Error!’

…

>>> func(-1)

Error!

>>> func(3)

0 < 3 <= 5

>>>

Условные операторы

Помимо описанных ранее операторов сравнения, есть еще несколько условных операторов:

in и not in

Проверяют, является ли указанное значение в последовательности – условия принадлежности.

>>> list = [1, 2, 3]

>>> 1 in list

1

>>> 4 in list

0

>>> text = ‘Hello world!’

>>> ‘Hello’  in text

1

>>>

is и not is

Проверяют, ссылаются ли две переменные на один и тот же объект — условия идентичности.

>>> a = b = 1

>>> a in b

1

>>> c = 0

>>> a in c

0

>>>

Инструкция for в языке Python немного отличается от того, что используется в таких языках, как C и Pascal. Вместо того, чтобы всегда перебирать числа арифметической прогрессии (как в Pascal) или предоставлять пользователю полную свободу выбора итератора и условий выхода из цикла (как в C), инструкция for в языке Python перебирает элементы произвольной последовательности в порядке их следования. Вот общая схема инструкции:

for lvalue in sequence:

suite1

[else:

suite2]

Расшифруем:

1) сначала выполняется обязательная ветвь for;

2) sequence представляет собой последовательность элементов, будь то строка, список или кортеж, вычисляется он один раз, и изменять его не рекомендуется;

3) in означает, что переменная lvalue перебирает все элементы последовательности sequence;

4) после того как ветвь for выполнится (элементы в последовательности закончатся), происходит переход к необязательной ветви else (как обычно, он может отсутствовать);

От сухих формулировок перейдем к примеру:

>>> list = [‘I ’, ‘love ’, ‘you!’]

>>> for text in list:

…        print text,

…

I love you!

>>>

Цикл for

Как видно, цикл просто перебрал все элементы списка. На его месте мог быть и кортеж, но гораздо интереснее поиграть со строкой:

>>> number = 0

>>> for symbol in ‘Can I help you?’:

…        if symbol == ‘ ’:

…            number +=1

…   else:

…         print number

…

3

>>>

Этот цикл перебирает все буквы строки и считает, сколько из них пробелов. Также показан рабочий пример работы else (после окончания перебора именно в ней выводится количество пробелов).

На практике цикл for применяется в случае, когда надо выполнить участок кода нужное количество раз. Именно тут и пригодится функция range(). Как известно, она создает список определенной длины, который как раз и может быть использован в цикле:

>>> for index in range(1,5):

…         print index,

…

1 2 3 4

>>>

В данном примере функция range() принимает два целых аргумента и возвращает список, который содержит все целые числа в промежутке между заданными значениями, включая первое и исключая второе.

Если ей передано только одно значение, то в результате она вернет список с целыми значениями от 0 до N, где N –значение параметра:

>>> range(10)

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

>>>

Если же range() вызвана с тремя аргументами, то последний из них рассматривается как размер шага. Т.е. в полученном списке значения будут идти не подряд, а через промежутки:

>>> range(1, 10, 2)

[1, 3, 5, 7, 9]

>>>

Для того чтобы перебрать индексы последовательности, используют функцию range() вкупе с функцией len():

>>> list = [‘Can’, ‘I’, ‘help’, ‘you?’]

>>> for index in range(len(list)):

…         print index, list[index]

…

0 Can

1 I

2 help

3 you?

>>>

А если нам понадобится создать список уж очень большой длины? Возможно, не хватит памяти устройства и попытка привести в исполнение команду типа range(1000000000) приведет к ошибке. Но лучше не рисковать и использовать функцию xrange(). Используется она, когда нужно перебрать последовательность без изменений. Запомните: список, созданный функцией xrange, изменить нельзя.

>>> for index in xrange(10, 30, 5):

…         print index,

…

10 15 20 25

>>>

Когда range() не работает, выручает xrange()

range() создаёт список определенной длины, который в оперативной памяти занимает соответствующий объем. Псевдосписок, созданный функцией xrange(), при любой длине занимает одинаковый объем. Т.к. видимой разницы в скорости между обеими функциями нет, для экономии памяти, особенно  в циклах, лучше применять xrange().

for работает с командами break и continue так же, как и while:

>>> for index in range(6):

…       if index == 3:

…          break

          print index,

…   else:

…       print ‘Full!’

0 1 2

>>>

Пока чисел в списке меньше трех, они выводятся с помощью команды print. Как только index становится равным трем, выполняется инструкция break и происходит выход из цикла. При этом ветвь else игнорируется.

>>> for index in range(6):

…       if index == 3:

…          continue

…       print index,

…   else:

…       print ‘Full!’

0 1 2 4 5 Full!

>>>

Здесь мы поставили вместо break инструкцию continue, и теперь, когда index становится равным 3, цикл начинается сначала и пропускает данную итерацию (так называется каждый проход в цикле), т.е. 3 не выводится. Ветвь же else успешно выполняется.

Разобравшись, как можно управлять ходом выполнения программы, рассмотрим дополнительные возможности при определении функций.

Мы уже изучили, как пишется функция, но осталась ещё кое-какая дополнительная информация по ней. Начнем с общей схемы:

def func_name(param_list):

suite

Расшифруем:

1) сначала пишется оператор def;

2) затем указывается имя функции func_name;

3) в скобках пишем список параметров param_list, которые мы передаем функции;

4) наконец, пишем тело функции suite (с обязательным отступом);

Вот пример функции, выводящий последовательности чисел Фибоначчи:

>>> def fib(n):

…        a, b = 0, 1

…        while b < n:

…             print b,

…             a, b = b, a + b

…

>>> fib(200)

1 1 2 3 5 8 13 21 34 55 89 144

>>>

Можно определить функцию с переменным числом параметров. Для этого существует три способа.

Первый — значение аргументов по умолчанию. При этом мы вызываем функцию с меньшим числом аргументов, остальные параметры же принимают то значение по умолчанию, которое мы установили:

>>> def func(text, name = ‘World’):

…        print text, name, ‘!’

…

>>> func(‘Hello’)

Hello World!

>>> func(‘Hello’, ‘Albert’)

Hello Albert!

>>>

Можно передавать значения функции напрямую нужному параметру по его имени, т.е. использовать именованные параметры

>>> def func(text=’Hello’, name = ‘World’):

…        print text, name, ‘!’

…

>>> func()

Hello World!

>>> func(name = ‘Albert’)

Hello Albert!

>>> func(text = ‘Gold-bye’)

Gold-bye World!

>>> func(text = ‘Gold-bye’, name = ‘Albert’)

Gold-bye Albert!

>>>

Так же можно определить функции, чтобы ей передавалось любое количество параметров — использовать произвольный набор аргументов:

>>> def func(number, *args):

…        print args

…        for arg in args:

…             print number, ‘*’, arg, ‘=’, number * arg

…

>>> func(2, 1, 2, 3, 4, 5)

(1, 2, 3, 4, 5)

2 * 1 = 2

2 * 2 = 4

2 * 3 = 6

2 * 4 = 8

2 * 5 = 10

>>>

Таблица умножения из произвольного набора аргументов

Вот такая вот таблица умножения! Как видно из примера, написав в определении функции имя аргумента, начинающегося со звездочки «*», при вызове функции именно этому аргументу передается кортеж значений.

Напомню, если необходимо, чтобы функция возвращала определенные значения после завершения работы, используйте инструкцию return:

>>> def summ(a, b):

…        return str(a) + ’ + ’ + str(b)+ ’ = ’+ str(a+b)

…

>>> print summa(1, 3)

1 + 3 = 4

>>>

Список возвращаемых значений можно указать через запятую.

Python содержит несколько популярных особенностей, характерных для языков функционального программирования. С помощью ключевого слова lambda можно создать простую функцию без имени. Говорите, так не бывает? Это возможно! Но есть ограничение — тело функции ограничено один выражением  в одну строку, т.е. никаких вам условий и циклов:

lambda param_list: expression

Расшифрем:

1) функции передается список параметров param_list;

2) функция возвращает результат значение выражения expression.

Объективности ради скажу – функцию, полученную таким образом, можно таки присвоить переменной, после этого она будет вызываться как обычно:

>>> func=lambda a, b: a * b

>>> print func(3,2)

6

>>>

filter(function, sequence)

Возвращает список, состоящий из тех элементов последовательности sequence, для которых function(item) является истинной (т.е. возвращает 1):

>>> def func(x):

...         for y in xrange(2, x):

...              if x%y == 0:

…                  return 0

…             else:

...                   return 1

...

>>> filter(func, xrange(2, 40))

[2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37]

>>>

Данный пример выделяет простые числа из списка.

map(function, sequence, …)

Возвращает список значений, полученных применением функции function к элементам одной или нескольких последовательностей. Здесь удобно использовать lambda функции:

>>> map(lambda x: x**2, xrange(2, 6))

[4, 9, 16, 25]

>>>

Пример возвращает квадраты чисел. А сейчас любопытный момент:

>>> map(None, [1, 2, 3, 4], [5, 6, 7, 8])

[(1, 5), (2, 6), (3, 7), (4, 8)]

>>>

На этом примере получили из пары списков список пар. Таким образом, можно перебирать элементы нескольких последовательностей:

>>> seq1 = [1, 2, 3, 4]

>>> seq2 = [4, 6, 7, 8]

>>> for x, y in map(None, seq1, seq2):

…          print x, y

…

1, 4

2, 6

3, 7

4, 8

>>>

Если какая-либо из последовательностей элементов оказывается короче другой, то функция map() дополняет ее элементами None:

>>> seq1 = [1, 2, 3, 4]

>>> seq2 = [4, 6]

>>> for x, y in map(None, seq1, seq2):

…          print x, y

…

1, 4

2, 6

3, None

4, None

>>>

Функция map() предлагает широкие возможности

zip(sequence, …)

Возвращает список кортежей, каждый из которых состоит из соответствующих элементов последовательностей sequence (их может быть несколько, через список):

>>> seq1 = [1, 2, 3, 4]

>>> seq2 = [4, 6]

>>> zip(seq1, seq2)

((1, 4), (2, 6))

>>>

Т.е. длина полученной последовательности будет равна длине самой короткой последовательности среди аргументов (в отличие от вышеописанной функции map).

reduce(function, sequence [, initial])

Возвращает значение, полученное путем последовательного применения функции function сначала к первым двум элементам последовательности sequence, затем к результату и следующему элементу и т.д.:

>>> reduce(lambda x,y: x+y, xrange(1, 11))

55

>>>

В качестве третьего, необязательного аргумента, можно указать начальное значение. В этом случае функция сначала применяется к начальному значению и первому элементу последовательности, затем к результату и следующему элементу и т.д.

Инструкция pass

Часто при написании программ создаются большие условные конструкции if…elif…else, пишутся циклы и определяются функции. А вот что писать внутри них, если еще не определились с кодом? В этих случаях пригодится инструкция pass. Её задача — ничего не делать. Кто это там смеется? Очень нужная вещь, между прочим!

Инструкция pass – «пропускаю ход»

>>> if a ==1:

…      pass

…    elif a ==2:

…      pass

…    else:

…      pass

>>> while a > 0:

…      pass

>>> for index in range(9):

…      pass

>>> def func(arg):

…      pass

>>>