Компания ALT Linux
Опубликован: 05.04.2015 | Доступ: свободный | Студентов: 2090 / 344 | Длительность: 05:48:00
ISBN: 978-5-905167-02-7
Специальности: Программист, Преподаватель
Лекция 1:

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

Лекция 1: 123 || Лекция 2 >
Аннотация: Эта глава полезна для общего развития, её можно прочитать, но совершенно необязательно сразу пытаться понять. Лучше вернуться к ней ещё раз после выполнения всех практических заданий.

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.

Таблица 1.1. Операции с числами
Операция Описание
x + y Сложение (сумма x и y)
x - y Вычитание (разность x и y)
x * y Умножение (произведение x и y)
x/y Деление x на y (частное). Внимание! Если x и y целые, то результат всегда будет целым числом! Для получения вещественного результата хотя бы одно из чисел должно быть вещественным. Пример:
100/8 → 12,
а вот
100/8.0 → 12.5
x//y Целочисленное деление (результат — целое число). Если оба числа в операции вещественные, получается вещественное число с дробной частью, равной нулю. Пример:
100//8 → 12
101.8//12.5 → 8.0
(для сравнения
101.8/12.5 → 8.1440000000000001)
x%y Остаток от целочисленного деления x на y Пример:
10%4 → 2
x**y Возведение в степень (x в степени y). Работает и для вещественных чисел. Примеры:
2**3 → 8
2.3**(-3.5) → 0.05419417057580235
-x Смена знака числа

Кроме того, в 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. Основные логические операции и выражения
Операция или выражение Описание
> Условие "больше" (например, проверяем, что a > b)
< Условие "меньше" (например,проверяем, что a < b)
== Условие равенства (проверяем, что a равно b)
!= Условие неравенства (проверяем, что a не равно b)
not x Отрицание (условие x не выполняется)
x and y Логическое "И" (умножение). Чтобы выполнилось условие x and y, необходимо, чтобы одновременно выполнялись условия x и y.
x or y Логическое "ИЛИ" (сложение). Чтобы выполнилось условие x or y, необходимо, чтобы выполнилось одно из условий.
x in A Проверка принадлежности элемента x множеству (структуре) A (см. "Структуры данных").
a < x < b Эквивалентно (x > a) and (x < b)

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). Результатом является символ. Если i < 0, отсчёт идёт с конца (первый символ строки имеет номер 0, последний имеет номер -1). Пример:
s='дерево'
s[2] → 'р'
s[-2] → 'в'
s[i : j :k] Срез — подстрока, содержащая символы строки s с номерами от i до j с шагом k (элемент с номером i входит в итоговую подстроку, а элемент с номером j уже не входит). Если k не указан (использован вариант 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, дополненная пробелами справа и слева до ширины в n символов. Исходная строка не изменяется. Если n \le len(s1), пробелы не добавляются. Пример:
s1='Zoom-Zoom'
s1.center(15) → '   Zoom_Zoom   '
s1.ljust(n) Строка s1 выравнивается по левому краю (дополняется пробелами справа) в пространстве шириной n символов. Если n < len(s1), пробелы не добавляются. Пример:
s1='Zoom_Zoom'
s1.ljust(15) → 'Zoom-Zoom      '
s1.rjust(n) Строка s1 выравнивается по правому краю (дополняется пробелами слева) в пространстве шириной n символов. Если n < len(s1), пробелы не добавляются. Пример:
s1='Zoom_Zoom'
s1.rjust(15) → '      Zoom-Zoom'
s1.count(s[, i, j]) Определяется количество вхождений подстроки s в строку s1. Результатом является число. Можно указать позицию начала поиска i и окончания поиска j (по тем же правилам, что и начало и конец среза). Примеры:
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. Результатом является число. Необязательные аргументы i и j определяют начало и конец области поиска (как в предыдущем случае). Пример:
s1='abrakadabra'
s1.find('br') → 1
s1.rfind(s[, i, j]) Определяется позиция последнего (считая слева) вхождения подстроки s в строку s1. Результатом является число. Необязательные аргументы i и j определяют начало и конец области поиска (как в предыдущем случае). Пример:
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 элемента с номером i, нумерация начинается с 0 (первый элемент имеет номер 0) Если i < 0, отсчёт идёт с конца (первый элемент кортежа имеет номер 0, последний имеет номер -1). Пример:
t3=(1, 2, 3, 'raz', 'dva')
t3[2] → 3
t3[-2] → 'raz'
t[i : j :k] Срез — кортеж, содержащий элементы кортежа t с номерами от i до j с шагом k (элемент с номером i входит в итоговый кортеж, а элемент с номером j уже не входит). Если k не указан (использован вариант 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']).

Списки являются очень полезными структурами данных в Python, и с использованием списков, их методов и операций с ними можно эффективно решать самые разнообразные задачи.
Таблица 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 элемента с номером i, нумерация начинается с 0 (первый элемент имеет номер 0) Если i < 0, отсчёт идёт с конца (последний элемент списка имеет номер -1). Пример:
lst3=[1, 2, 3, 'raz', 'dva']
lst3[2] → 3
lst3[-2] → 'raz'
lst[i : j :k] Срез — список, содержащий элементы списка lst с номерами от i до j с шагом k (элемент с номером i входит в итоговый список, а элемент с номером j уже не входит). Если k не указан (использован вариант 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 Замена элемента списка с номером i на значение 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] Удаление из списка элемента с номером 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, как и строки, являются объектами, поэтому для списков существуют методы.

Таблица 1.7. Основные методы списков
Метод Описание и результат
lst.append(x) Добавление элемента x в конец списка lst. x не может быть списком. Создания нового списка не происходит. Пример:
lst=['raz','dva','tri',1,2]
lst.append(3)
lst→['raz','dva','tri',1,2,3]
lst.extend(t) Добавление кортежа или списка t в конец списка lst (похоже на объединение списков, но создания нового списка не происходит). Пример:
lst1=[1,2,3]
lst2=['raz','dva']
lst1.extend(lst2)
lst1→[1,2,3,'raz','dva']
lst.count(x) Определение количества элементов, равных x, в списке lst. Результат является числом. Пример:
lst=[1,2,3,'raz','dva','raz','dva']
lst.count('raz') → 2
lst.index(x) Определение первой слева позиции элемента x в списке lst. Если такого элемента нет, возникает сообщение об ошибке. Пример:
lst=[1,2,3,'raz','dva','raz','dva']
lst.index('dva') → 4
lst.remove(x) Удаление элемента x в списке lst в первой слева позиции. Если такого элемента нет, возникает сообщение об ошибке. Пример:
lst=[1,2,3,'raz','dva','raz','dva']
lst.remove('dva')
lst→[1,2,3,'raz','raz','dva']
lst.pop(i) Удаление элемента с номером i из списка lst. При этом выдаётся значение этого элемента ("извлечение" элемента из списка). Если номер не указан, удаляется последний элемент. Новый список не создаётся. Примеры:
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.insert(i,x) Вставка элемента или списка x в позицию i списка lst. Если i<=0, вставка идёт в начало списка. Если i>len(lst), вставка идёт в конец списка. Новый список не создаётся. Пример:
lst=[1,2,3,'raz']
lst.insert(3,'tri')
lst→[1,2,3,'tri','raz']
lst.sort() Сортировка списка по возрастанию (в алфавитном порядке). Новый список не создаётся. Пример:
lst=[1,2,3,'tri','raz']
lst.sort()
lst→[1,2,3,'raz','tri']
lst.reverse() Замена порядка следования элементов на обратный. Новый список не создаётся. Пример:
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)

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

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

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

range(n)

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

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

range(k,n)

создаёт список чисел от k до n - 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
Лекция 1: 123 || Лекция 2 >
Ольга Курыло
Ольга Курыло
Александр Кудлаев
Александр Кудлаев

Ознакомился с курсом "Практика по алгоритмизации и программированию на Python". Хотел сдать экзамен. Вместо традиционного тестирования было предложено написать курсовую работу. Написал. Отослал.Ответ на следующий день: "Задание не прверено". Сколько ожидать результата проверки работы?

Алексей Егоров
Алексей Егоров
Украина, Киев
Мария Аверкина
Мария Аверкина
Россия, Москва