Структура программы в Python.

Содержание

Содержание. 3

Введение. 5

Основы программирования на Python. 7

Структура программы в Python. 7

Понятие данных. 7

Переменные. 8

Типы данных. 9

Операторы. 11

Выражения. 13

Строки. 15

Списки. 18

Управление потоком выполнения. 20

Оператор if. 20

Оператор While. 20

Оператор for. 21

Функция range(). 21

Операторы break, continue и условие else в циклах. 22

Оператор pass. 23

Функции. 24

Подробнее об определении функций. 26

Значения аргументов по умолчанию. 26

Аргументы с ключевым словом. 27

Произвольные списки аргументов. 28

Распаковка списков аргументов. 29

Lambda-выражения. 29

Строки документации. 30

Аннотации функций. 31

Структуры данных. 32

Подробнее о списках. 32

Использование списков в качестве стеков. 33

Использование списков в качестве очередей. 33

Генераторы списков. 34

Вложенные генераторы списков. 35

Оператор del. 36

Кортежи и последовательности. 36

Множества. 38

Словари. 39

Приемы использования цикла. 40

Подробнее об условиях. 41

Сравнение последовательностей и других типов. 42

Модули. 42

Подробнее о модулях. 44

Выполнение модулей как скриптов. 45

Путь поиска модуля. 45

"Скомпилированные" файлы Python. 46

Стандартные модули. 46

Функция dir(). 47

Пакеты. 48

Импортирование * из пакета. 50

Внутрипакетные ссылки. 51

Пакеты во множестве директорий. 51

Ввод и вывод. 52

Особенности форматирования вывода. 52

Старое форматирование строк. 55

Чтение и запись файлов. 55

Методы файловых объектов. 56

Сохранение структурированных данных с помощью json. 58

 

 

Введение

Процессы решения современных задач требуют значительных интеллектуальных затрат и переработки больших объемов информации в ограниченные сроки. С целью сократить расходы на решение задач и были созданы электронно-вычислительные машины (ЭВМ), а затем и персональные компьютеры (ПК).

 Однако у современных ПК отсутствует способность мышления. Чтобы иметь возможность перепоручить машине решение задачи, необходимо точно описать каждый шаг в процессе поиска ее решения. Для этого надо знать метод решения задачи, выбор которого зависит от построения формализованного описания задачи, ее математической модели. Однако для получения конкретных результатов недостаточно создание лишь метода, пригодного для решения задачи. Важно уметь применять его для решения заданных практических задач в определенных условиях.

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

­ умение правильно планировать структуру предстоящих действий для достижения заданной цели при помощи стандартного набора средств;

­ строить информационные структуры для описания объектов и процессов в конкретной предметной области;

­ правильно организовывать поиск информации, необходимой для решения задачи;

­ четко и однозначно формулировать способ решения задачи в общепринятой форме и правильно понимать способ решения, предложенный другим разработчиком;

­ формировать навыки анализа имеющейся информации, умения представлять ее в структурированном виде.

Формализованное алгоритмическое описание задачи является основой для ее кодированной формы записи, или иначе, программной. Для этого необходимо ввести обрабатываемые данные, указать, как их обрабатывать, задать способ вывода полученных результатов. С этой целью необходимо знать:

- как ввести информацию в память (ввод);

- как хранить информацию в памяти (данные);

- как указать правильные команды для обработки данных (операции);

- как передать обратно данные из программы пользователю (вывод);

- как упорядочить команды таким образом, чтобы:

o некоторые из них выполнялись только в том случае, если соблюдается определенное условие, или ряд условий (условное выполнение);

o  некоторые выполнялись повторно некоторое число раз (циклы);

o  некоторые выделялись в отдельные части, которые могут быть неоднократно выполнены в разных местах программы (подпрограммы).

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

- ввод – считывание значений, поступающих с клавиатуры или файла на диске;

- данные – константы, переменные, структуры, содержащие числа, текст или адреса;

- операции – осуществляют присваивание значений, их комбинирование (сложение, деление и т.д.) и сравнение значений;

- условное выполнение – выполнение определенного набора команд в зависимости от выполнения условия;

- циклы – организация повторного выполнения некоторого набора команд либо фиксированное число раз, либо в зависимости от ложности или истинности некоторого условия;

- подпрограммы – набор команд, который имеет собственное имя, и может быть вызван любое число раз из произвольного места основной программы;

- вывод – вывод результатов задачи в форме, доступной для восприятия пользователю.

Целью программирования является описание процессов обработки данных. Процесс можно определить и описать как последовательность сменяющих друг друга состояний некоторой информационной среды. Набор данных, содержащихся в какой-либо момент в информационной среде, определяет состояние этой информационной среды.

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

Основы программирования на Python.

Python – мощный высокоуровневый язык программирования, идеально подходящий для разработки самостоятельных программ и сценариев.

Python отличает простой и понятный синтаксис, благодаря которому писать код гораздо легче, чем на других языках. Разработчики на Python ценят красоту и ясность кода, что нашло отражение в их философии под названием «Дзен Питона». «Читаемость имеет значение», «Простое лучше, чем сложное» – вот некоторые положения этой философии.

Python поддерживает структурное, объектно-ориентированное, функциональное, императивное и аспектно-ориентированное программирование. Основные архитектурные черты — динамическая типизация, автоматическое управление памятью, полная интроспекция, механизм обработки исключений, поддержка многопоточных вычислений, высокоуровневые структуры данных.

В Python присутствует богатая библиотека модулей, возможность выбрать интерактивный или скриптовый режим, меньший объем вводимого кода и, как следствие, более высокая скорость разработки.

Понятие данных.

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

Для хранения данных, определенных в программе, транслятором языка программирования резервируется определенный участок оперативной памяти. Поскольку данные могут храниться только в двоичной (иначе машинной) форме, то в зависимости от типа данных, может резервироваться либо 1 байт памяти, слово (2 байта), двойное слово (4 байта) памяти.

Все формы представления данных, заложенные в язык «от рождения», называются базовыми типами данных. Это обычно целые и вещественные числовые типы, символьные и строковые типы. Помимо базовых типов можно конструировать свои формы представления данных - производные типы данных.

Переменные.

 

Переменная – это именованная область оперативной памяти, отведенная для временного хранения данных, которые могут изменяться при выполнении программы.

Переменная хранит определенные данные. Название переменной в Python должно начинаться с алфавитного символа или со знака подчеркивания и может содержать алфавитно-цифровые символы и знак подчеркивания. И кроме того, название переменной не должно совпадать с названием ключевых слов языка Python. Ключевых слов не так много, их легко запомнить: and, as, assert, break, class, continue, def, del, elif, else, except, False, finally, for, from, global, if, import, in, is, lambda, None, nonlocal, not, or, pass, raise, return, True, try, while, with, yield.

 

>>> name = ' Tom'

 

Здесь определена переменная name, которая хранит строку "Tom".

В Python применяется два типа наименования переменных: camel case и underscore notation.

Camel case подразумевает, что каждое новое подслово в наименовании переменной начинается с большой буквы. Например:

 

>>> userName = ' Tom'

 

Underscore notation подразумевает, что подслова в наименовании переменной разделяются знаком подчеркивания. Например:

 

>>> user_name = ' Tom'

И также надо учитывать регистрозависимость, поэтому переменные name и Name будут представлять разные объекты.

 

 

Типы данных.

 

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

 

Переменная хранит данные одного из типов данных. В Python существует множество различных типов данных, которые подразделяются на категории: числа, последовательности, словари, наборы:

 

· boolean - логическое значение True или False

 

· int - представляет целое число, для хранения которого использует 4 байта в памяти компьютера.

 

· float - представляет число с плавающей точкой, для хранения которого используется 8 байт, например, 1.2 или 34.76

 

· complex - комплексные числа

 

· str - строки, например "hello". В Python 3.x строки представляют набор символов в кодировке Unicode

 

· bytes - последовательность чисел в диапазоне 0-255

 

· byte array - массив байтов, аналогичен bytes с тем отличием, что может изменяться

 

· list - список

 

· tuple - кортеж

 

· set - неупорядоченная коллекция уникальных объектов

 

· frozen set - то же самое, что и set, только не может изменяться (immutable)

 

· dict - словарь, где каждый элемент имеет ключ и значение

 

Python поддерживает динамическую типизацию, то есть тип переменной определяется только во время исполнения. Поэтому вместо «присваивания значения переменной» лучше говорить о «связывании значения с некоторым именем». В Python имеются встроенные типы: булевый, строка, Unicode-строка, целое число произвольной точности, число с плавающей запятой, комплексное число и некоторые другие. Все значения являются объектами, в том числе функции, методы, модули, классы.

 

Добавить новый тип можно либо написав класс (class), либо определив новый тип в модуле расширения (например, написанном на языке C). Система классов поддерживает наследование (одиночное и множественное) и метапрограммирование. Возможно наследование от большинства встроенных типов и типов расширений.

 

Все объекты делятся на ссылочные и атомарные. К атомарным относятся int, long (в версии 3 любое число int, так как в версии 3 нет ограничения на размер), complex и некоторые другие. При присваивании атомарных объектов копируется их значение, в то время как для ссылочных копируется только указатель на объект, таким образом, обе переменные после присваивания используют одно и то же значение. Ссылочные объекты бывают изменяемые и неизменяемые. Например, строки и кортежи являются неизменяемыми, а списки, словари и многие другие объекты — изменяемыми.

 

Операторы.

Большинство предложений (логических строк) в программах содержат выражения. Простой пример выражения: 2 + 3. Выражение можно разделить на операторы и операнды.

 

Операторы – это некий функционал, производящий какие-либо действия, который может быть представлен в виде символов, как например +, или специальных зарезервированных слов. Операторы могут производить некоторые действия над данными, и эти данные называются операндами. В нашем случае 2 и 3 – это операнды.

 

Операторы:

+	Сложение	Суммирует два объекта   3 + 5 даст 8; 'a' + 'b' даст 'ab'
-	Вычитание	Даёт разность двух чисел; если первый операнд отсутствует, он считается равным нулю,    -5.2 даст отрицательное число, а 50 - 24 даст 26.
*	Умножение	Даёт произведение двух чисел или возвращает строку, повторённую заданное число раз. 2 * 3 даст 6. 'la' * 3 даст 'lalala'.
**	Возведение в степень	Возвращает число х, возведённое в степень y 3 ** 4 даст 81 (т.е. 3 * 3 * 3 * 3)
/	Деление	Возвращает частное от деления x на y 4 / 3 даст 1.3333333333333333.
//	Целочисленное деление	Возвращает неполное частное от деления 4 // 3 даст 1. -4 // 3 даст -2.
%	Деление по модулю	Возвращает остаток от деления 8 % 3 даст 2. -25.5 % 2.25 даст 1.5.
<<	Сдвиг влево	Сдвигает биты числа влево на заданное количество позиций. (Любое число в памяти компьютера представлено в виде битов - или двоичных чисел, т.е. 0 и 1) 2 << 2 даст 8. В двоичном виде 2 представляет собой 10. Сдвиг влево на 2 бита даёт 1000, что в десятичном виде означает 8.
>>	Сдвиг вправо	Сдвигает биты числа вправо на заданное число позиций. 11 >> 1 даст 5. В двоичном виде 11 представляется как 1011, что будучи смещённым на 1 бит вправо, даёт 101, а это, в свою очередь, не что иное как десятичное 5
&	Побитовое И	Побитовая операция И над числами 5 & 3 даёт 1.
|	Побитовое ИЛИ	Побитовая операция ИЛИ над числами 5 | 3 даёт 7
^	Побитовое ИСКЛЮЧИТЕЛЬНО ИЛИ	Побитовая операция ИСКЛЮЧИТЕЛЬНО ИЛИ 5 ^ 3 даёт 6
~	Побитовое НЕ	Побитовая операция НЕ для числа x соответствует -(x+1) ~5 даёт -6.
<	Меньше	Определяет, верно ли, что x меньше y. Все операторы сравнения возвращают True или False [1]. Обратите внимание на заглавные буквы в этих словах. 5 < 3 даст False, а 3 < 5 даст True.Можно составлять произвольные цепочки сравнений: 3 < 5 < 7 даёт True.
>	Больше	Определяет, верно ли, что x больше y 5 > 3 даёт True. Если оба операнда - числа, то перед сравнением они оба преобразуются к одинаковому типу. В противном случае всегда возвращается False.
<=	Меньше или равно	Определяет, верно ли, что x меньше или равно y x = 3; y = 6; x <= y даёт True.
>=	Больше или равно	Определяет, верно ли, что x больше или равно y x = 4; y = 3; x >= 3 даёт True.
==	Равно	Проверяет, одинаковы ли объекты    x = 2; y = 2; x == y даёт True. x = 'str'; y = 'stR'; x == y даёт False. x = 'str'; y = 'str'; x == y даёт True.
!=	Не равно	Проверяет, верно ли, что объекты не равны x = 2; y = 3; x!= y даёт True.
not	Логическое НЕ	Если x равно True, оператор вернёт False. Если же x равно False, получим True. x = True; not x даёт False.
and	Логическое И	x and y даёт False, если x равно False, в противном случае возвращает значение y x = False; y = True; x and y возвращает False, поскольку x равно False. В этом случае Python не станет проверять значение y, так как уже знает, что левая часть выражения ‘and’ равняется False, что подразумевает, что и всё выражение в целом будет равно False, независимо от значений всех остальных операндов. Это называется укороченной оценкой булевых (логических) выражений.
or	Логическое ИЛИ	Если x равно True, в результате получим True, в противном случае получим значение y

Выражения.

Выражение является полноправным оператором в Python.

Если выражение содержит несколько операторов, то значения компонентов выражения рассчитываются в определенном порядке. Такой порядок называют порядком старшинства или приоритетом операторов.

Оператор	Описание
lambda	Лямбда-выражение
or	Логическое “ИЛИ”
and	Логическое “И”
not x	Логическое “НЕ”
in, not in	Проверка принадлежности
is, is not	Проверка тождественности
<, <=, >, >=,!=, ==	Сравнения
|	Побитовое “ИЛИ”
^	Побитовое “ИСКЛЮЧИТЕЛЬНО ИЛИ”
&	Побитовое “И”
<<, >>	Сдвиги
+, -	Сложение и вычитание
*, /, //, %	Умножение, деление, целочисленное деление и остаток от деления
+x, -x	Положительное, отрицательное
~x	Побитовое НЕ
**	Возведение в степень
x.attribute	Ссылка на атрибут
x[индекс]	Обращение по индексу
x[индекс1:индекс2]	Вырезка
f(аргументы...)	Вызов функции
(выражения,...)	Связка или кортеж
[выражения,...]	Список
{ключ:данные,...}	Словарь

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

 

Вы можете записать:

 

>>> a = 2; a = a * 3

 

в виде:

 

>>> a = 2; a *= 3

Строки.

Кроме чисел Python также может манипулировать строками, которые могут быть описаны несколькими способами. Они могут быть заключены в одинарные кавычки ('...') или двойные кавычки ("...") с одинаковым результатом.

 

>>> 'spam eggs' # одинарные кавычки

'spam eggs'

>>> 'doesn\'t' # используйте \' для экранирования одиночной кавычки...

"doesn't"

>>> "doesn't" #...или вместо этого используйте двойные кавычки

"doesn't"

>>> '"Yes," he said.'

'"Yes," he said.'

>>> "\"Yes,\" he said."

'"Yes," he said.'

>>> '"Isn\'t," she said.'

'"Isn\'t," she said.'

В интерактивном интерпретаторе выводящаяся строка заключена в кавычки и специальные символы экранируются бэкслешами. В то же время это может иногда отличаться от ввода (заключающие кавычки могли измениться), две строки эквивалентны. Строка заключена в двойные кавычки, если она включает одинарные, при этом двойные кавычки отсутствуют, иначе она заключена в одинарные кавычки. Функция print() создает более читабельный вывод, опуская ограждающие кавычки и интерпретируя экранируемые и специальные символы:

>>> '"Isn\'t," she said.' '"Isn\'t," she said.' >>> print('"Isn\'t," she said.') "Isn't," she said.>>> s = 'First line.\nSecond line.' # \n означает новую строку >>> s # без print(), \n содержится в выводе 'First line.\nSecond line.' >>> print(s) # с print(), \n создает новую строку First line.Second line.

 

Если вы не хотите, чтобы символы, которым предшествует \, интерпретировались как специальные, то можете использовать raw string (сырые строки - прим. перев.), добавив r перед первой кавычкой:

 

>>> print('C:\some\name') # здесь \n означает новую строку! C:\someame>>> print(r'C:\some\name') # обратите внимание на r перед кавычкой C:\some\name

Строковые литералы могут охватывать множество строк. Один способ - это использование тройных кавычек: """...""" или '''...'''. Конец строки по-умолчанию обозначает переход на новою, но есть возможность предотвратить это, добавив \ в конец строки. Следующий пример:

print("""\ Usage: thingy [OPTIONS] -h                   Display this usage message -H hostname          Hostname to connect to """)

дает следующий вывод (заметьте, что начальная новая строка не включена):

Usage: thingy [OPTIONS] -h                   Display this usage message -H hostname          Hostname to connect to

Строки могут быть соединены (склеены вместе) оператором + и повторены с помощью *:

>>> # 3 раза 'un' с последующим 'ium' >>> 3 * 'un' + 'ium' 'unununium'

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

>>> 'Py' 'thon' 'Python'

Однако это работает только с двумя литералами, но не с переменными или выражениями:

>>> prefix = 'Py' >>> prefix 'thon' # не может соединить переменную и строковый литерал...SyntaxError: invalid syntax>>> ('un' * 3) 'ium'...SyntaxError: invalid syntax

Если вы хотите конкатенировать переменные или переменную и литерал, используйте +:

>>> prefix + 'thon' 'Python'

Это свойство особенно полезно, когда вы хотите разорвать длинную строку:

>>> text = ('Put several strings within parentheses '        'to have them joined together.')>>> text 'Put several strings within parentheses to have them joined together.'

Строка может быть проиндексирована, первый символ имеет индекс 0. Отдельный символьный тип отсутствует, символ - это просто строка единичной размерностью:

>>> word = 'Python' >>> word[0]   # символ в позиции 0 'P' >>> word[5] # символ в позиции 5 'n'

Индексы также могут быть отрицательными числами для начала отсчета справа:

>>> word[-1] # последний символ 'n' >>> word[-2] # второй с конца символ 'o' >>> word[-6] 'P'

Заметьте, что поскольку -0 - это тоже самое, что 0, то отрицательные индексы начинаются с -1.

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

>>> word[0:2] # символы от позиции 0 (включая) до 2 (исключая) 'Py' >>> word[2:5] # символы от позиции 2 (включая) до 5 (исключая) 'tho'

Заметьте, что начало всегда включается, а конец всегда исключается. Это обеспечивает то, что s[:i] + s[i:] всегда равно s:

>>> word[:2] + word[2:] 'Python' >>> word[:4] + word[4:] 'Python'

Индексация срезов имеет полезные свойства по умолчанию; опущенный первый индекс по умолчанию обозначает ноль, опущенный второй индекс по умолчанию обозначает размер строки, с которой берется срез.

>>> word[:2] # символ от начала до позиции 2 (исключая) 'Py' >>> word[4:] # символ от позиции 4 (включая) до конца 'on' >>> word[-2:] # символы от второго с конца (включая) до конца 'on'

Один из способов запомнить, как работают срезы, - это думать об индексах как указывающих между символами, левый край первого символа нумеруется 0. Тогда как правый край последнего символа строки из n символов имеет индекс n, например:

 + ---+---+---+---+---+---+ | P | y | t | h | o | n | + ---+---+---+---+---+---+ 0 1 2 3 4 5 6-6 -5 -4 -3 -2 -1

Первый ряд чисел дает позицию индексов 0...6 в строке; второй ряд дает соответствующие отрицательные индексы. Срез от i до j состоит из всех символов между краями, отмеченными i и j соответственно.

Для неотрицательных индексов длина среза представляет собой разность индексов, если оба находятся в границах. Например, длина word[1:3] равна 2.

Попытка использовать индекс, который является слишком большим, приведет к ошибке:

 

>>> word[42] # у word только 6 символов Traceback (most recent call last): File "<stdin>", line 1, in <module>IndexError: string index out of range

Однако индексы вне диапазона обрабатываются корректно при использовании для взятия среза:

>>> word[4:42] 'on' >>> word[42:] ''

Строки Python не могут быть изменены - они неизменяемы. Поэтому присвоение по индексированной позиции в строке приводит к ошибке:

>>> word[0] = 'J'...TypeError: 'str' object does not support item assignment>>> word[2:] = 'py'...TypeError: 'str' object does not support item assignment

Если вам нужна другая строка, следует создать новую строку:

>>> 'J' + word[1:] 'Jython' >>> word[:2] + 'py' 'Pypy'

Встроенная функция len() возвращает длину строки:

>>> s = 'supercalifragilisticexpialidocious' >>> len(s)34

 

Списки.

 

Python'у известно определенное количество сложных типов данных, используемых для группировки разных значений. Наиболее гибким является list (список - прим. пер.), который может быть описан как список разделенных запятой значений (элементов) между квадратными скобками. Списки могут включать элементы различных типов, но обычно все элементы имеют одинаковый тип.

>>> squares = [1, 4, 9, 16, 25]>>> squares[1, 4, 9, 16, 25]

Как строки (и все другие встроенные типы последовательностей) списки могут быть проиндексированы и из них можно брать срезы:

>>> squares[0] # индекс возвращает элемент 1>>> squares[-1]25>>> squares[-3:] # срез возвращает новый список [9, 16, 25]

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

 

>>> squares[:][1, 4, 9, 16, 25]

Списки также поддерживают такую операцию как конкатенацию:

 

>>> squares + [36, 49, 64, 81, 100][1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

В отличие от строк, которые неизменяемые, списки являются изменяемым типом, т. е. есть возможность изменить их содержание:

 

>>> cubes = [1, 8, 27, 65, 125] # что-то здесь не так >>> 4 ** 3 # 4 в кубе равно 64, а не 65! 64>>> cubes[3] = 64 # замена ошибочного значения >>> cubes[1, 8, 27, 64, 125]

Вы также можете добавить новый элемент в конец списка, используя метод append():

 

>>> cubes.append(216) # добавление куба 6-ти >>> cubes.append(7 ** 3) # и куба 7-ми >>> cubes[1, 8, 27, 64, 125, 216, 343]

Присвоение срезов также возможно, и этим можно даже изменить размер списка или полностью его очистить:

 

>>> letters = [ 'a', 'b', 'c', 'd', 'e', 'f', 'g' ]>>> letters[ 'a', 'b', 'c', 'd', 'e', 'f', 'g' ]>>> # замена нескольких значений >>> letters[2:5] = [ 'C', 'D', 'E' ]>>> letters[ 'a', 'b', 'C', 'D', 'E', 'f', 'g' ]>>> # теперь удалим их >>> letters[2:5] = []>>> letters[ 'a', 'b', 'f', 'g' ]>>> # очистим список, заменив все элементы на пустой список >>> letters[:] = []>>> letters[]

Встроенная функция len() также применима к спискам:

 

>>> letters = [ 'a', 'b', 'c', 'd' ]>>> len(letters)4

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

 

>>> a = [ 'a', 'b', 'c' ]>>> n = [1, 2, 3]>>> x = [a, n]>>> x[[ 'a', 'b', 'c' ], [1, 2, 3]]>>> x[0][ 'a', 'b', 'c' ]>>> x[0][1] 'b'

 

 

Оператор if.

Возможно наиболее хорошо известным типом оператора является if.

>>> x = int(input("Пожалуйста, введите число: "))Пожалуйста, введите число: 42>>> if x < 0:...     x = 0...     print('Отрицательное изменяется на 0')... elif x == 0:...     print('Ноль ')... elif x == 1:...     print('Один ')... else:...     print('Больше ')...Больше

Частей elif быть больше или не быть вообще, часть else также необязательна. Ключевое слово 'elif' есть сокращение от 'else if' и полезно для избежания излишних отступов. Последовательность if... elif... elif... есть замена для операторов switch или case, встречающихся в других языках

Оператор While.

Цикл while (“пока”) позволяет выполнить одну и ту же последовательность действий, пока проверяемое условие истинно. Условие записывается до тела цикла и проверяется до выполнения тела цикла. Как правило, цикл while используется, когда невозможно определить точное значение количества проходов исполнения цикла.

 

i = 0

while i < 10:

print(i)

i = i + 1

 

 

При выполнении цикла while сначала проверяется условие. Если оно ложно, то выполнение цикла прекращается и управление передается на следующую инструкцию после тела цикла while. Если условие истинно, то выполняется инструкция, после чего условие проверяется снова и снова выполняется инструкция. Так продолжается до тех пор, пока условие будет истинно. Как только условие станет ложно, работа цикла завершится и управление передастся следующей инструкции после цикла

 

Оператор for.

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

>>> # Измерить несколько слов:... words = [ 'cat', 'window', 'defenestrate' ]>>> for w in words:...     print(w, len(w))...cat 3window 6defenestrate 12

Если вам надо изменить последовательность, вы перебираете внутри цикла (например, для дублирования выбранных элементов), рекомендуется сначала сделать копию. Выполнение итерации над последовательностью безоговорочно не создает ее копию. Взятие среза делает это особенно удобным:

>>> for w in words[:]: # Цикл по срезу-копии целого списка....      if len(w) > 6:...         words.insert(0, w)...>>> words[ 'defenestrate', 'cat', 'window', 'defenestrate' ]

С for w in words: пример попытался бы создать бесконечный список, вставляя defenestrate опять и опять.

Функция range().

Если вам надо перебрать последовательность чисел, пригодится встроенная функция range(). Она генерирует арифметические прогрессии:

>>> for i in range(5):...     print(i)...01234

Заданная конечная точка никогда не входит в генерируемую последовательность; range(10) генерирует 10 значений, индексируемые как обычная последовательность длинной 10. Возможно установить другое число в качестве начала диапазона или указать другое приращение (даже отрицательное; иногда приращение называют "шагом"):

range(5, 10) от 5 по 9 range(0, 10, 3) 0, 3, 6, 9 range(-10, -100, -30) -10, -40, -70

Для перебора по индексам последовательности, вы можете сочетать range() и len() как в следующем примере:

>>> a = [ 'Mary', 'had', 'a', 'little', 'lamb' ]>>> for i in range(len(a)):...     print(i, a[i])...0 Mary1 had2 a3 little4 lamb

В большинстве подобных случаев, однако, удобно использовать функцию enumerate().

Странная вещь случится, если вы просто напечатаете диапазон:

>>> print(range(10))range(0, 10)

Во многих отношениях объект, возвращаемый range(), ведет себя так, как будто это список, но на самом деле это не так. Это объект, который возвращает последовательные элементы желаемой последовательности, когда вы перебираете его, но это на самом деле не список, тем самым экономится пространство.

Мы говорим, что объект является iterable, то есть подходит в качестве цели для функций и конструкций, которые ожидают что-то, из чего они могут получить последовательные элементы, пока они не исчерпаны. Мы видели, что оператор for именно такой iterator. Функций list() есть другой; она создает списки из итерируемых (перечисляемых) объектов:

>>> list(range(5))[0, 1, 2, 3, 4]

 

Оператор pass.

Оператор pass ничего не делает. Он может быть использован, когда синтаксически требуется какой-нибудь оператор, но программа не требует действия. Например:

>>> while True:...      pass # Занят ожиданием прерывания с клавиатуры (Ctrl+C)...

Обычно это используется при создании очень маленьких классов:

>>> class MyEmptyClass:...      pass...

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

>>> def initlog(*args):...      pass # Вспомните потом реализовать это!...

 

Функции.

Функции – это многократно используемые фрагменты программы. Они позволяют дать имя определённому блоку команд с тем, чтобы впоследствии запускать этот блок по указанному имени в любом месте программы и сколь угодно много раз. Это называется вызовом функции.

Функция в python - объект, принимающий аргументы и возвращающий значение. Мы можем создать функцию, которая выводит ряд Фибоначчи до произвольной границы:

>>> def fib(n): # выводит ряд Фибоначчи до n...      """Печатает ряд Фибоначчи вплоть до n."""...     a, b = 0, 1...      while a < n:...         print(a, end= ' ')...         a, b = b, a+b...     print()...>>> # Теперь вызовем функцию, которую мы только что определили:... fib(2000)0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597

Ключевое слово def вводит определение функции. За ним должно следовать имя функции и в круглых скобках список формальных параметров. Выражения, которые формируют тело функции, начинаются на следующей строке и должны быть с отступом.

Опционально (не обязательно) первое выражение тела функции может быть строковым литералом; этот строковый литерал является строкой документации функции, или docstring. Есть инструменты, которые используют строки документации для автоматического создания онлайн или печатной документации, или позволить пользователю интерактивно просматривать код; это хорошая практика включать строки документации в код, который вы пишите, так что сделайте это привычкой.

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

Фактические параметры (аргументы) при вызове функции вводятся в ее локальную таблицу имен; таким образом, аргументы передаются с помощью вызова по значению (где значение всегда ссылка на объект, не значение объекта). Когда функция вызывает другую функцию, создается новая локальная таблица имен для этого вызова.

Определение функции вводит ее имя в текущую таблицу обозначений. Значение имени функции имеет тип, который распознается интерпретатором как определенная пользователем функция. Это значение может быть связано с другим именем, которое затем может также быть использовано как функция. Это служит в качестве общего механизма переименования:

>>> fib<function fib at 10042ed0>>>> f = fib>>> f(100)0 1 1 2 3 5 8 13 21 34 55 89

Придя из других языков, вы можете подумать, что объект fib не функция, а процедура, поскольку она не возвращает значение. В действительности даже функции без оператора return делают возврат значения. Это значение называется None (это встроенное имя). Вывод значения None обычно подавляется интерпретатором, если это будет только записанное значение. Вы можете увидеть это, если захотите с помощью print():

>>> fib(0)>>> print(fib(0)) None

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

>>> def fib2(n): # возвращает ряд Фибоначчи вплоть до n...      """Возвращает список, включающий ряд Фибоначчи вплоть до n."""...     result = []...     a, b = 0, 1...      while a < n:...         result.append(a)    # смотри ниже...         a, b = b, a+b...      return result...>>> f100 = fib2(100) # вызов >>> f100           # вывод результата [0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89]