Где я: Главная страница » Форум Smart-Planet.ru

Файл. архив №1 :: Файл. архив №2
Обменник :: Статьи :: Форум :: Блоги

Файловый архив №1:



Наш чат

Форум Smart-Planet.ru » Общие темы » Программирование » Python на Symbian S60: циклы и функции


    Python на Symbian S60: циклы и функции
   Новичкам!
Быстрый ответ Ответить
#1
Написал: ultralin :: 7 января 2009 08:31
Новичок
  • 17

Группа: Гости
Награды: нет
На сайте: offline


Подняться в начало страницы   
Репутация: 0
Пол: -----
Предупреждения:
Предупреждения:  из 5
Сообщений: 0
Публикаций: 0
Регистрация: 1.01.1970
Камень на распутье

Мобильный язык программирования 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, и, если условие, записываемое после него, истинно (например, 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 выполняется, пока истинно условие 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!

>>>

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

>>> 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(), при любой длине занимает одинаковый объем. Т.к. видимой разницы в скорости между обеими функциями нет, для экономии памяти, особенно в циклах, лучше применять 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

>>>

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. Её задача — ничего не делать. Кто это там смеется? Очень нужная вещь, между прочим!

>>> if a ==1:

… pass

… elif a ==2:

… pass

… else:

… pass

>>> while a > 0:

… pass

>>> for index in range(9):

… pass

>>> def func(arg):

… pass

>>>
       
  
Быстрый ответ Ответить
1 чел. читают эту тему (гостей: 1)
Пользователей: 0

 Информация
Посетители, находящиеся в группе Гости, не могут оставлять ответы в данном форуме.


Smart-Planet.ru - сайт посвящённый мобильным устройствам на: Android, Symbian и Windows Mobile. За время существования с 2007-2020 год мы собрали огромное количество контента на различную тематику (игры, программы, темы, видео). Сейчас насчитывается около 25 тыс. приложений доступных к скачиванию бесплатно.

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