Python на Symbian S60: циклы и функции
Камень на распутьеМобильный язык программирования Python, конечно же, не обошёлся без традиционных логических функций if, while и for. Пришло время научиться пользоваться этими операторами.
Каждая из инструкций состоит из одной или нескольких ветвей. Каждая ветвь состоит из заголовка и тела. Заголовки ветвей одной инструкции должны иметь одинаковый уровень отступа и заканчиваться двоеточием. Тело также надо выделять отступом.
Инструкция ifИнструкция 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 предназначена для создания циклов. Циклы необходимы для многократного выполнения тех или иных действий и выглядят так:
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Инструкция 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
>>>
Список возвращаемых значений можно указать через запятую.
lambda функции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
>>>
Рекомендуемый контент
Радиолюбителю