Язык Python и его особенности

1.1 Общие сведения о языке

В основном Python используется как интерпретатор, хотя существуют средства компиляции Python-программ.

Интерпретатор Python позволяет выполнять команды и операции средствами интерактивной оболочки Python (см. далее).

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

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

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

Модули подключаются в начале программы с помощью команды:

import имя_модуля

А отдельные функции — с помощью команды:

from имя_модуля import функция1, . . . функцияN

Присваивание в Python обозначается знаком "=", а равенство — знаком "==".

В Python разрешены "цепочки" присваиваний и сравнений, однако присваивания и сравнения нельзя смешивать. Выражения a=b=c=4 и a<b<5 допустимы, а выражение a<b=4 — недопустимо. Однако допустимо выражение a<b==4.

В Python отсутствуют "операторные скобки" типа begin ... end или DO ... LOOP. Вместо них в составных операторах (ветвления, циклы, определения функций) используются отступы от начала строки (пробелы).

И наконец, элементы структуры данных могут иметь отрицательные номера.

В следующих главах этой части даётся неполное и полуформальное введение в Python. Этого материала достаточно для выполнения заданий в пределах школьного курса. Для желающих узнать больше имеется список источников информации (раздел "Литература") и справка Python.

1.2 Типы и структуры данных

1.2.1 Типы данных

1.2.1.1 Числа

Числа в Python могут быть обычными целыми (тип int), длинными целыми (тип long), вещественными (тип float) и комплексными (они не будут рассматриваться и использоваться). Для всех задач в пределах школьного курса используются только целые и вещественные числа.

Для преобразования чисел из вещественных в целые и наоборот в Python определены функции int() и float(). Например, int(12.6) даст в результате 12, а float(12) даёт в результате 12.0 (десятичный разделитель — точка). Основные операции с числами приведены в табл. 1.1.

100/8 → 12,

100/8.0 → 12.5

100//8 → 12
101.8//12.5 → 8.0

101.8/12.5 → 8.1440000000000001)

10%4 → 2

2**3 → 8
2.3**(-3.5) → 0.05419417057580235

Кроме того, в Python для операций с числами используются функции abs() (вычисление абсолютного значения — модуля, abs(-3)→ 3), pow() (возведение в степень, pow(2,3) → 8), divmod() (вычисление результата целочисленного деления и остатка, divmod(17,5)→ (3,2)) и round() (округление, round(100.0/6) → 17.0). Эти функции являются "встроенными", что означает, что для их использования нет необходимости подключать дополнительные модули. Все прочие функции для работы с числами (математические), такие как вычисление квадратного корня, синуса и пр. требуют подключения модуля math.

1.2.1.2 Логические значения

Логические значения в Python представлены двумя величинами — логическими константами True (Истина) и False (Ложь).

Логические значения получаются в результате логических операций и вычисления логических выражений.

1.2.2 Структуры данных

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

Последовательности, в свою очередь, подразделяются на изменяемые и неизменяемые. Под изменяемостью (изменчивостью) последовательности понимается возможность добавлять или удалять элементы этой последовательности (т.е. изменять количество элементов последовательности).

Для структур данных в Python определены функции (операции) и методы, принципиального различия между которыми нет, а есть различие синтаксическое (в правилах написания). Основные функции и методы для каждого типа структур данных приводятся ниже.

1.2.2.1 Неизменяемые последовательности — строки

Строки (последовательности символов — букв и других значков, которые можно найти на клавиатуре компьютера) могут состоять из символов английского и любого другого алфавита. Для простоты и определённости в строковых значениях переменных в дальнейшем будем использовать только символы английского алфавита. В Python строки и символы нужно заключать в кавычки (одиночные или двойные). Элементы (символы) в строке нумеруются, начиная с нуля. Одиночный символ — буква — является "с точки зрения Python" строкой, состоящей из одного элемента.

Максимально возможное количество символов в строке (длина строки) в Python ограничивается только доступным объёмом памяти. Так что текст любого разумного размера (например, несколько тысяч страниц) может быть записан в одну строку Python.

Числа могут быть преобразованы в строки с помощью функции str(). Например, str(123) даст строку '123'. Если строка является последовательностью знаков-цифр, то она может быть преобразована в целое число в помощью функции int() (int('123') даст в результате число 123), а в вещественное — с помощью функции float() (float('12.34') даст в результате число 12.34). Для любого символа можно узнать его номер (код символа) с помощью функции ord() (например, ord('s') даст результат 115). И наоборот, получить символ по числовому коду можно с помощью функции chr() (например chr(100) даст результат 'd').

Таблица 1.3. Основные операции со строками

Функция или операция	Описание и результат
len(s)	Вычисляется длина строки s как число символов
s1 + s2	Конкатенация. К концу строки s1 присоединяется строка s2, в результате получается новая строка, например, 'вы' + 'года' → 'выгода'
s * n (или n * s)	n-кратное повторение строки s, в результате получается новая строка, например 'кан'*2 → 'канкан'
s[i]	Выбор из s элемента с номером i, нумерация начинается с 0 (первый элемент имеет номер 0). Результатом является символ. Если , отсчёт идёт с конца (первый символ строки имеет номер 0, последний имеет номер -1). Пример: s='дерево' s[2] → 'р' s[-2] → 'в'
s[i : j :k]	Срез — подстрока, содержащая символы строки s с номерами от до с шагом (элемент с номером входит в итоговую подстроку, а элемент с номером уже не входит). Если не указан (использован вариант s[i : j]), то символы идут подряд (равносильно s[i : j :1]). Примеры: s='derevo' s[3:5] → 'ev' s[1:5:2] → 'ee'
min(s)	Определяет и выводит (возвращает) символ с наименьшим значением (кодом – номером в кодовой таблице) Пример: s='derevo' min(s) → 'd'
max(s)	Возвращает символ с наибольшим значением (кодом) Пример: s='derevo' max(s) → 'v'

Строки, как объекты Python, обладают методами (т.е. функциями, которые выполняют сами объекты). Основные методы перечислены в следующей таблице. Пусть строка, к которой применяются эти методы, называется s1.

Таблица 1.4. Методы строк

Метод	Описание и результат
s1.center(n)	Возвращается строка s1, дополненная пробелами справа и слева до ширины в символов. Исходная строка не изменяется. Если , пробелы не добавляются. Пример: s1='Zoom-Zoom' s1.center(15) → ' Zoom_Zoom '
s1.ljust(n)	Строка s1 выравнивается по левому краю (дополняется пробелами справа) в пространстве шириной символов. Если , пробелы не добавляются. Пример: s1='Zoom_Zoom' s1.ljust(15) → 'Zoom-Zoom '
s1.rjust(n)	Строка s1 выравнивается по правому краю (дополняется пробелами слева) в пространстве шириной символов. Если n < len(s1), пробелы не добавляются. Пример: s1='Zoom_Zoom' s1.rjust(15) → ' Zoom-Zoom'
s1.count(s[, i, j])	Определяется количество вхождений подстроки s в строку s1. Результатом является число. Можно указать позицию начала поиска и окончания поиска (по тем же правилам, что и начало и конец среза). Примеры: s1='abrakadabra' s1.count('ab') → 2 s1.count('ab',1) → 1 s1.count('ab',1,-3) → 0, потому что s1[1:-3] → 'brakada'
s1.find(s[, i, j])	Определяется позиция первого (считая слева) вхождения подстроки s в строку s1. Результатом является число. Необязательные аргументы и определяют начало и конец области поиска (как в предыдущем случае). Пример: s1='abrakadabra' s1.find('br') → 1
s1.rfind(s[, i, j])	Определяется позиция последнего (считая слева) вхождения подстроки s в строку s1. Результатом является число. Необязательные аргументы и определяют начало и конец области поиска (как в предыдущем случае). Пример: s1='abrakadabra' s1.rfind('br') → 8
s1.strip()	Создаётся копия строки, в которой удалены пробелы в начале и в конце (если они есть или образовались в результате каких-то операций). Пример: s1=' breKeKeKeKs ' s2=s1.strip() s2 → 'breKeKeKeKs'
s1.lstrip()	Создаётся копия строки, в которой удалены пробелы в начале (если они есть или образовались в результате каких-то операций). Пример: s1=' breKeKeKeKs ' s2=s1.lstrip() s2 → 'breKeKeKeKs '
s1.rstrip()	Создаётся копия строки, в которой удалены пробелы в конце (если они есть или образовались в результате каких-то операций). Пример: s1=' breKeKeKeKs ' s2=s1.rstrip() s2 → ' breKeKeKeKs'
s1.replace(s2,s3[, n])	Создаётся новая строка, в которой фрагмент (подстрока) s2 исходной строки заменяется на фрагмент s3. Необязательный аргумент n указывает количество замен (если требуется заменить не все фрагменты). Пример: s1='breKeKeKeKs' ss=s1.replace('Ke','XoXo',2) ss → 'breXoXoXoXoKeKs'
s1.capitalize()	Создаётся новая строка, в которой первая буква исходной строки становится заглавной (прописной), а все остальные становятся маленькими (строчными). Пример: s1='breKeKeKeKs' s2=s1.capitalize() s2 → 'Brekekekeks'
s1.swapcase()	Создаётся новая строка, в которой прописные буквы исходной строки заменяются на строчные и наоборот. Пример: s1='breKeKeKeKs' s2=s1.swapcase() s2 → 'BREkEkEkEkS'
s1.upper()	Создаётся новая строка, в которой все буквы исходной строки становятся заглавными (прописными). Пример: s1='breKeKeKeKs' s2=s1.upper() s2 → 'BREKEKEKEKS'
s1.lower()	Создаётся новая строка, в которой все буквы исходной строки становятся маленькими (строчными). Пример: s1='breKeKeKeKs' s2=s1.lower() s2 → 'brekekekeks'

1.2.2.2 Неизменяемые последовательности — кортежи

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

Кортеж задаётся перечислением его элементов в круглых скобках через запятую, например

t =(12, 'b', 34.6, 'derevo ')

С использованием допустимой в Python цепочки присваиваний можно элементам кортежа сразу сопоставить какие-нибудь переменные:

t =(x, s1, y, s2) =(12, 'b', 34.6, 'derevo ')

В этом случае элемент кортежа и соответствующая переменная будут указывать на одни и те же значения, т.е. значение t[0] будет равно значению x, а t[3], соответственно, s2.

Однако эти переменные могут изменяться независимо от элементов кортежа. Присвоение нового значения переменной s1 никак не влияет на элемент t[1]. А вот для элементов кортежа значения изменить уже нельзя, поскольку для Python кортеж относится к неизменяемым последовательностям.

Кортеж может быть пустым (для его определения нужно написать t=()), а может содержать только один элемент (например, t=('domik',)). Для кортежа из одного элемента обязательно добавлять запятую после имени или значения этого элемента.

Кортежи могут получаться в результате работы функций Python, например, уже упоминавшаяся функция divmod() возвращает кортеж из двух элементов.

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

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

Таблица 1.5. Основные операции с кортежами

Функция или операция	Описание и результат
len(t)	Определяется количество элементов кортежа (результатом является число) t
t1 + t2	Объединение кортежей. Получается новый кортеж, в котором после элементов кортежа t1 находятся элементы кортежа t2. Пример: t1=(1,2,3) t2=('raz', 'dva') t3=t1+t2 t3 → (1, 2, 3, 'raz', 'dva')
t * n или(n * t)	n-кратное повторение кортежа t Пример: t2=('raz', 'dva') t2*3 → ('raz','dva', 'raz', 'dva', 'raz', 'dva')
t[i]	Выбор из t элемента с номером , нумерация начинается с 0 (первый элемент имеет номер 0) Если , отсчёт идёт с конца (первый элемент кортежа имеет номер 0, последний имеет номер -1). Пример: t3=(1, 2, 3, 'raz', 'dva') t3[2] → 3 t3[-2] → 'raz'
t[i : j :k]	Срез — кортеж, содержащий элементы кортежа t с номерами от до с шагом (элемент с номером входит в итоговый кортеж, а элемент с номером уже не входит). Если не указан (использован вариант t[i : j]), то элементы идут подряд (равносильно t[i : j :1]). Пример: t3=(1, 2, 3, 'raz', 'dva') t3[1:4] → (2, 3, 'raz')
min(t)	Определяется элемент с наименьшим значением в соответствии с алфавитным ("словарным") порядком. Пример: t3=(1, 2, 3, 'raz', 'dva') min(t3) → 1
max(t)	Определяется элемент с наибольшим значением в соответствии с алфавитным ("словарным") порядком. Пример: t3=(1, 2, 3, 'raz', 'dva') max(t3) → 'raz'

Важно понимать, что "словарный" порядок — сначала числа по возрастанию, затем строки, начинающиеся на цифры в порядке их возрастания, затем строки, начинающиеся на прописные буквы в алфавитном порядке, а затем строки, начинающиеся на строчные буквы также в алфавитном порядке – всегда используется в вычислительной технике при сортировке имён объектов. Строку можно преобразовать в кортеж с помощью функции tuple(), например:

s='amamam '
t=tuple(s)
t → ('a' , 'm', 'a', 'm', 'a', 'm')

1.2.2.3 Изменяемые последовательности — списки

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

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

lst=[12, 'b', 34.6, 'derevo ']

В дальнейшем в именах списков всегда будем использовать сочетание lst(от слова "list", т.е. "список").

С использованием допустимой в Python цепочки присваиваний можно элементам списка сразу сопоставить какие-нибудь переменные:

lst=[x, s1, y, s2]=[12, 'b', 34.6, 'derevo ']

В этом случае элемент списка и соответствующая переменная будут указывать на одни и те же значения, т.е. значение lst[0] будет равно значению x,, а lst[3]. соответственно, s2.

Однако эти переменные могут изменяться независимо от элементов списка. Присвоение нового значения переменной s1 никак не влияет на элемент lst[1]. В отличие от кортежа, значения элементов списка можно изменять, добавлять элементы в список и удалять их.

Список может быть пустым (создать его можно так: lst=[]), а может содержать только один элемент (например, lst=['domik']).

Таблица 1.6. Основные операции со списками

Функция или операция	Описание и результат
len(lst)	Определяется количество элементов списка lst. Результат — число.
lst1+ lst2	Объединение списков. Получается новый список, в котором после элементов списка lst1 находятся элементы списка lst2. Пример: lst1=[1,2,3] lst2=['raz', 'dva'] lst3=lst1+lst2 lst3→[1, 2, 3, 'raz', 'dva']
lst*n (или n* lst)	n-кратное повторение списка lst . Результат — новый список. Пример: lst2=['raz', 'dva'] lst2*3 →['raz','dva', 'raz', 'dva', 'raz', 'dva']
lst[i]	Выбор из lst элемента с номером , нумерация начинается с 0 (первый элемент имеет номер 0) Если , отсчёт идёт с конца (последний элемент списка имеет номер -1). Пример: lst3=[1, 2, 3, 'raz', 'dva'] lst3[2] → 3 lst3[-2] → 'raz'
lst[i : j :k]	Срез — список, содержащий элементы списка lst с номерами от до с шагом (элемент с номером входит в итоговый список, а элемент с номером уже не входит). Если не указан (использован вариант lst[i : j]), то символы идут подряд (равносильно lst[i : j :1]). Пример: lst3=[1, 2, 3, 'raz', 'dva'] lst3[1:4] →[2, 3, 'raz']
min(lst)	Определяется элемент с наименьшим значением в соответствии с алфавитным ("словарным") порядком. Пример: lst3=[1, 2, 3, 'raz', 'dva'] min(lst3) → 1
max(lst)	Определяется элемент с наибольшим значением в соответствии с алфавитным ("словарным") порядком. Пример: lst3=[1, 2, 3, 'raz', 'dva'] max(lst3) → 'raz'
lst[i]=x	Замена элемента списка с номером на значение x. Если x является списком, то на место элемента списка будет вставлен список. При этом новый список не создаётся. Примеры: lst3=[1, 2, 3, 'raz', 'dva'] lst3[2]='tri' lst3→[1, 2, 'tri', 'raz', 'dva'] lst3[2]=[7,8] lst3→[1, 2,[7, 8], 'raz', 'dva']
del lst[i]	Удаление из списка элемента с номером . Новый список не создаётся. Пример: lst3=[1, 2,[7, 8], 'raz', 'dva'] del lst3[2] lst3→[1, 2, 'raz', 'dva']
lst[i : j]=x	Замена среза списка lst на элемент или список x (несколько элементов заменяются на x). Примеры: lst3=[1, 2, 3, 'raz', 'dva'] lst3[2:4]='tri' lst3→[1, 2, 't', 'r', 'i', 'dva'] lst3[2:4]='a' lst3→[1, 2, 'a', 'i', 'dva'] Обратите внимание, что строка интерпретируется как список!
del lst[i : j]	Удаление элементов, входящих в указанный срез ("вырезание среза"). Пример: lst3=[1, 2, 'a', 'i', 'dva'] del lst3[2:4] lst3→[1, 2, 'dva']

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

Списки в Python, как и строки, являются объектами, поэтому для списков существуют методы.

lst=['raz','dva','tri',1,2]
lst.append(3)
lst→['raz','dva','tri',1,2,3]

lst1=[1,2,3]
lst2=['raz','dva']
lst1.extend(lst2)
lst1→[1,2,3,'raz','dva']

lst=[1,2,3,'raz','dva','raz','dva']
lst.count('raz') → 2

lst=[1,2,3,'raz','dva','raz','dva']
lst.index('dva') → 4

lst=[1,2,3,'raz','dva','raz','dva']
lst.remove('dva')
lst→[1,2,3,'raz','raz','dva']

lst=[1,2,3,'raz','raz','dva']
\ lstinline lst.pop(3)| → 'raz'|
lst→[1,2,3,'raz','dva']
\ lstinline lst.pop()| → 'dva'|
lst→[1,2,3,'raz']

lst=[1,2,3,'raz']
lst.insert(3,'tri')
lst→[1,2,3,'tri','raz']

lst=[1,2,3,'tri','raz']
lst.sort()
lst→[1,2,3,'raz','tri']

lst=[1,2,3,'raz','tri']
lst.reverse()
lst→['tri','raz',3,2,1]

Кроме перечисленных операций и методов, списки могут обрабатываться совместно (по номерам соответствующих элементов). Для этого в Python используются функции zip() и map().

Функция zip() позволяет получить из элементов различных списков список кортежей, состоящих из соответствующих элементов списков. Аргументами функции zip() являются два или более списков, а результатом — список кортежей, составленных из элементов исходных списков с одинаковыми номерами (первый кортеж составляется из элементов с номером 0, второй — из элементов с номером 1 и т.д.)

Пример:

lst1=[1, 2, 3, 4]
lst2=['tri', 'dva', 'raz']
lst=zip(lst1, lst2)
lst→[(1, 'tri'), (2, 'dva'), (3, 'raz')]

Количество элементов в итоговом списке равно количеству элементов в самом коротком исходном списке. "Лишние" элементы других списков игнорируются.

Функцию zip() можно применять и к кортежам, а также "смешивать" в её аргументах списки и кортежи.

Функция map() используется для применения одной и той же операции к элементам одного или нескольких списков или кортежей. Если списков (кортежей) несколько, они должны быть одинаковой длины (иметь одинаковое количество элементов). При использовании map() чаще всего применяются так называемые lambda-функции, т.е. безымянные функции, действующие только на время конкретной операции map().

При создании lambda-функции указывается ключевое слово lambda, затем пишутся переменные, для которых эта функция определяется и операции с этими переменными (что функция делает с переменными).

После описания lambda-функции, которая является первым аргументом функции map() пишутся остальные аргументы — имена списков (кортежей), с которыми надо выполнить операцию.

Примеры:

lst1=[1, 2, 3, 4]

lst=map(lambda x : x*2, lst1)

lst→[2, 4, 6, 8]

t1 =(1, 2, 3)

t2 =(5.0, 6.0, 7.0)

t=map(lambda x, y : x /y, t1, t2)

t →[0.20000000000000001, 0.33333333333333331,

0.42857142857142855]

В случае, если в функции map() в качестве первого аргумента используется специальная функция None, результат равносилен использованию функции zip(). Другими словами, map(None, lst1, lst2) равносильно zip(lst1, lst2).

Для списков и кортежей, состоящих только из чисел, возможно применение функции sum(), которая вычисляет сумму элементов списка (кортежа).

Примеры:

lst1=[1, 2, 3, 4]
sum(lst1) → 10
t1 =(1, 2, 3)
sum(t1) → 6

Для преобразования строки или кортежа в список используется функция list().

Примеры:

s='amamam'
lst=list(s)
lst→['a', 'm', 'a', 'm', 'a', 'm']
t =(5, 12, -3, 7)
lst2=list(t)
lst2→[5, 12, -3, 7]

Соответственно, с помощью функции tuple() список может быть преобразован в кортеж.

Также для взаимного преобразования строк и списков используются методы строк split() и join(). Метод split() делит строку по заданному символуразделителю и создаёт список из фрагментов строки.

Пример:

s='mama myla ramu'
lst=s.split(' ') # символ-разделитель — пробел
lst→['mama', 'myla', 'ramu']

Метод join() формирует строку из элементов списка, поставив между ними заданную строку (соединяет элементы списка с помощью заданной строки).

Пример:

lst=['1', '2', '3']
s='nea'.join(lst)
s→ '1nea2nea3'

Функция range() создаёт список как числовую арифметическую прогрессию. Полный вариант её использования:

range(x0, x1, d)

При этом создаётся список из чисел в полуоткрытом интервале[) с шагом , например,

range(0, 15, 3) →[0, 3, 6, 9, 12]

Минимальный вариант

range(n)

создаёт список чисел от 0 до - 1 с шагом 1.

Промежуточный вариант

range(k,n)

создаёт список чисел от k до - 1 с шагом 1.

Для списков, созданных с помощью функции range(), часто используются проверки принадлежности величины х списку range() (условие x in range(a,b,d)) или непринадлежности (условие x not in range(a,b,d)). Такие условия встречаются при организации циклов с переменной (см. раздел 2.3).

Применение функции sum() для списков, полученных с помощью range(), даёт сумму прогрессии.

Примеры:

sum(range(10)) → 45
sum(range(0,15,3)) → 30