Python на Symbian S60 циклы и функции

[Yerdna]

Python на Symbian S60: циклы и функции ?

Камень на распутье

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

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

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

if expr1:

suite1

[elif expr2:

suite2…]

[else:

suite3]

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

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

… if a 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 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 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 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 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

>>>