Программы на языке Python можно разложить на такие составляющие, как

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

1. Программы делятся на модули.
2. Модули содержат инструкции.
3. Инструкции состоят из выражений.
4. Выражения создают и обрабатывают объекты.

Базовые типы данных в языке Python

.1.04.22

Числа

Числа в Python поддерживают набор самых обычных математических

операций. Например, символ
«плюс» (+) означает сложение, символ «звездочка» (*) – умножение, а два
символа «звездочка» (**) – возведение в степень.

в составе Python есть несколько полезных модулей:

>>> import math
>>> math.pi
3.1415926535897931
>>> math.sqrt(85)
9.2195444572928871

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

Операции над последовательностями

В языке Python индексы реализованы в виде смещений от начала и потому

индексация начинается с 0: первый элемент имеет индекс 0, второй – 1 и так
далее.

В языке Python предусмотрена возможность индексации в обратном порядке,

от конца к началу – положительные индексы откладываются от левого конца
последовательности, а отрицательные – от правого:

внутри квадратных скобок допускается использовать не только жестко

заданные числовые литералы, но и любые другие выражения – везде, где
Python ожидает получить значение, можно использовать литералы,
переменные или любые выражения.

В дополнение к простой возможности индексирования по номеру позиции,

последовательности поддерживают более общую форму индексирования,
известную как получение среза (slicing), которая обеспечивает возможность
извлечения за одну операцию целого сегмента (среза).
В общем виде синтаксис операции получения среза выглядит как: X[I:J], и
означает: «извлечь из X все, начиная со смещения I и до смещения J, но не
включая его». В качестве результата возвращается новый объект.

Строки поддерживают операцию конкатенации, которая записывается в виде

знака плюс (объединение двух строк в одну строку), и операцию повторения
(новая строка создается за счет многократного повторения другой строки):

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

Методы, специфичные для типа

Метод строк find выполняет поиск подстроки в строке (он возвращает

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

Строки поддерживают операции подстановки, известные как

форматирование и доступные как в виде выражений (существовали
изначально), так и в виде методов строк (появились в версиях 2.6 и 3.0):

Получение помощи

Чтобы получить дополнительную информацию, вы всегда можете

воспользоваться функцией dir, которая возвращает список всех доступных
атрибутов заданного объекта.
Чтобы узнать назначение того или иного метода, можно передать его имя
функции help:

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

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

операции над последовательностями. Единственное отличие состоит в том,
что результатом таких операций являются списки, а не строки.

Методы, специфичные для типа

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

метод append увеличивает размер списка и вставляет в конец новый элемент.

Метод pop (или эквивалентная ему инструкция del) удаляет из списка
элемент с заданным смещением, что приводит к уменьшению списка.
Другие методы списков позволяют вставлять новые элементы в произвольное
место списка (insert), удалять элемент, заданный значением (remove), и так
далее. Так как списки являются изменяемыми, большинство методов списков
не создают новый список, а изменяют оригинальный список.

Метод sort, использованный в этом примере, по умолчанию упорядочивает

элементы списка по возрастанию, а метод reverse – по убыванию. В обоих
случаях происходит непосредственное изменение самого списка.

Проверка выхода за границы

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

Вложенные списки
Одна из замечательных особенностей базовых типов языка Python состоит в
том, что они поддерживают возможность создания вложенных конструкций
произвольной глубины и в любых комбинациях (например, можно создать
список, содержащий словарь, который содержит другой список, и так далее).
Одно из очевидных применений этой особенности – представление матриц,
или «многомерных массивов» в языке Python. Делается это с помощью
списка, содержащего вложенные списки:

Генераторы списков
Помимо обычных операций над последовательностями и методов списков
Python предоставляет возможность выполнять более сложные операции над
списками, известные как выражения генераторов списков (list comprehension 
expression), которые представляют эффективный способ обработки таких
структур, как приведенная в примере матрица. Предположим, например, что
нам требуется извлечь из нашей матрицы второй столбец. Строку легко
можно получить, выполнив операцию индексирования, потому что матрица
хранится в виде строк
Генераторы списков заключены в квадратные скобки (чтобы отразить тот
факт, что они создают список) и составлены из выражения и конструкции
цикла, которые используют одно и то же имя переменной (в данном случае
row). Генератор списков интерпретируется так: «Получить элементы row[1]
из каждой строки матрицы M и создать из них новый список». Результатом
является новый список, содержащий значения из второго столбца матрицы.
На практике генераторы списков могут приобретать еще более сложную
форму:

Первая операция в этом примере прибавляет 1 к значениям всех отобранных

элементов, а вторая использует условный оператор if для исключения из
результата нечетных чисел с помощью операции деления по модулю – %
(остаток от деления).

В последних версиях Python можно также использовать конструкции

генераторов списков, заключенные в круглые скобки, для создания
генераторов, которые воспроизводят результаты по требованию.

Словари
Словари в языке Python – это отображения. Отображения – это коллекции
объектов, но доступ к ним осуществляется не по определенным смещениям
от начала коллекции, а по ключам. В действительности отображения вообще
не подразумевают какого-либо упорядочения элементов по их позиции, они
просто отображают ключи на связанные с ними значения. Словари –
единственный тип отображения в наборе базовых объектов Python – также
относятся к классу изменяемых объектов они могут изменяться
непосредственно и в случае необходимости могут увеличиваться и
уменьшаться в размерах подобно спискам.
Операции над отображениями
Когда словарь определяется как литерал, программный код определения
заключается в фигурные скобки и состоит из последовательности пар «ключ:
значение». Словари удобно использовать всегда, когда возникает
необходимость связать значения с ключами, например чтобы описать
свойства чеголибо. В качестве примера рассмотрим следующий словарь,
состоящий из трех элементов (с ключами «food» (продукт питания),
«quantity» (количество) и «color» (цвет)):

Мы можем обращаться к элементам этого словаря по ключам и изменять

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

На практике чаще встречаются другие способы создания словарей.

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

Здесь мы опять имеем словарь, содержащий три ключа верхнего уровня

(ключи «name» (имя), «job» (должность) и «age» (возраст)), однако значения
имеют более сложную структуру: для описания имени человека используется
вложенный словарь, чтобы обеспечить поддержку имен, состоящих из
нескольких частей, и для перечисления занимаемых должностей
используется вложенный список, что обеспечит возможность расширения в
будущем. К компонентам этой структуры можно обращаться почти так же,
как мы делали это в случае с матрицей, но на этот раз вместо числовых
индексов мы используем ключи словаря:

Сортировка по ключам: циклы for

В последних версиях Python можно реализована новая встроенная функция

sorted . Эта функция сортирует объекты разных типов и возвращает
результат:
Цикл for представляет собой самый простой и эффективный способ
произвести обход всех элементов в последовательности и выполнить блок
программного кода для каждого из элементов. Переменная цикла,
определяемая пользователем (в данном случае key), служит для ссылки на
текущий элемент.

В этом примере выводятся ключи и значения несортированного словаря в

отсортированном по ключам виде. Цикл for и родственный ему цикл while –
это основные способы реализации повторяющихся действий в сценариях.

Цикл for способен работать с любыми объектами, являющимися

последовательностями, а также с некоторыми объектами, которые
последовательностями не являются.Пример обхода всех символов в строке и
вывод их в верхнем регистре:

Цикл while в языке Python представляет собой более универсальный

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

Несмотря на то, что операция присваивания значений элементам с

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

Применительно к словарям оператор in, проверки на членство, позволяет

определить наличие ключа и с помощью условного оператора if выполнить
тот или иной программный код (как и в случае инструкции for, необходимо
дважды нажать клавишу Enter после ввода инструкции if в интерактивной
оболочке):
Кортежи
Объект-кортеж (tuple ) в общих чертах напоминает список, который
невозможно изменить – кортежи являются последовательностями, как
списки, но они являются неизменяемыми, как строки. Синтаксически литерал
кортежа заключается в круглые, а не в квадратные скобки. Они также
поддерживают включение объектов различных типов, вложение и операции,
типичные для последовательностей:

В Python 3.0 кортежи обладают двумя методами, которые также имеются у

списков:

Основное отличие кортежей – это невозможность их изменения после

создания.

Подобно спискам и словарям кортежи способны хранить объекты разных

типов и допускают возможность вложения, но в отличие от них, не могут
изменять свои размеры, так как являются неизменяемыми объектами:
Для чего нужны кортежи?

Если коллекция объектов передается между компонентами программы в виде

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

Файлы
Объекты-файлы – это основной интерфейс между программным кодом на
языке Python и внешними файлами на компьютере. Файлы являются одним
из базовых типов, но они представляют собой нечто необычное, поскольку
для файлов отсутствует возможность создания объектов в виде литералов.
Вместо этого, чтобы создать объект файла, необходимо вызвать встроенную
функцию open, передав ей имя внешнего файла и строку режима доступа к
файлу. Например, чтобы создать файл для вывода данных, вместе с именем
файла функции необходимо передать строку режима ‘w’:

Чтобы прочитать то, что было записано в файл, его нужно открыть в режиме
‘r’ (этот режим используется по умолчанию, если строка режима в вызове
функции опущена). Затем прочитать содержимое файла в строку и
отобразить ее. Содержимое файла для сценария всегда является строкой
независимо от типов данных, фактически хранящихся в файле:
Множества

Множества, совсем недавно появившиеся в языке, – которые не являются ни

последовательностями, ни отображениями. Множества – это
неупорядоченные коллекции уникальных и неизменяемых объектов.
Множества создаются встроенной функцией set или с помощью новых
синтаксических конструкций определения литералов и генераторов
множеств, появившихся в версии 3.0, и поддерживают типичные
математические операции над множествами (выбор синтаксической
конструкции {...} для определения литералов множеств в версии 3.0 не
случаен, поскольку множества напоминают словари, в которых ключи не
имеют значений):