БЕЛОРУССКИЙ ГОСУДАРСТВЕННЫЙ УНИВЕРСИТЕТ

Факультет прикладной математики и информатики

Центр профориентационной работы

Очно-заочная школа
по математике
и информатике

С. В. Шолтанюк

ОСНОВЫ
ПРОГРАММИРОВАНИЯ
НА ЯЗЫКЕ PYTHON
Методические указания
и контрольные работы
по информатике
для учащихся 7–11 классов

Минск
2019
УДК 004.424
ББК 32.973.26-018.1
Ш78

Рекомендовано cоветом
факультета прикладной математики и информатики
26 июня 2019 г. протокол № 8

Рецензент
доктор педагогических наук, кандидат физико-математических
наук, профессор В. В. Казаченок

Шолтанюк, С. В.
Ш78 Основы программирования на языке Python : метод. ука-
зания и контрольные работы по информатике для учащихся
7–11 кл. / С. В. Шолтанюк. – Минск : БГУ, 2019. – 40 с.

Предназначено для учащихся 7–11 классов специальности «Ин-

форматика, направление P» очно-заочной школы по математике и ин-
форматике Белорусского государственного университета.

УДК 004.424
ББК 32.973.26-018.1

© БГУ, 2019
 ВВЕДЕНИЕ

Если вы совершаете много работы на компьютере, вы рано или поздно

обнаружите, что некоторые задачи было бы неплохо автоматизировать.
Например, операции поиска и замены во множестве текстовых файлов или
переименование и сортировка множества документов каким-нибудь осо-
бым способом. Возможно, вам бы хотелось написать маленькую пользо-
вательскую базу данных или специализированное графическое приложе-
ние, или простенькую игру.
Язык программирования Python позволяет легко и быстро решать все
эти задачи. Будучи очень высокоуровневым языком, который располагает
гибкими типами данных (массивы, словари и др.) и множеством встроен-
ных модулей, способными решать самые разные задачи (ввод/вывод, си-
стемные вызовы, математические вычисления, построение графиков, ра-
бота с сетями и интернет-запросами, работа с мультимедиа, создание гра-
фического интерфейса для приложений), Python является простым в ис-
пользовании в силу ряда причин:
• Python является платформенно независимым, т.е. им можно пользо-
ваться на Windows, Mac OS, Linux и других операционных систе-
мах;
• встроенные типы данных и функции позволяют значительно сокра-
тить код, который должен выполнять сложные операции;
• упрощённый синтаксис облегчает читаемость кода (например, от-
сутствие точки с запятой в конце операторов; группировка операто-
ров путём отступа кода, а не путём их заключения в фигурные
скобки);
• упрощённое объявление переменных;
• Python является расширяемым, т. е. его можно использовать в соче-
тании с другими языками программирования;
• доступен интерактивный режим, позволяющий писать различные
команды и операции и сразу же выполнять их, что может быть по-
лезным, например, при тестировании кода или поиске ошибок в нём.
Разработано множество сред разработки, позволяющих работать с про-
граммным кодом на Python, например IDLE, PyCharm, Spyder, Jupyter
Notebook. Для изучения языка Python и выполнения заданий из данного
3
пособия рекомендуется использовать Jupyter Notebook. В этой среде реа-
лизован интерактивный режим языка Python, что позволяет сохранять
программный код и результат его выполнения вместе, в одном файле.
Кроме того, Jupyter Notebook имеет удобный и интуитивно понятный ин-
терфейс.
В данном издании изложены основы программирования на языке Py-
thon версии 3.7.3, которые включают в себя основные понятия языка, осо-
бенности синтаксиса, работы с основными типами данных и встроенными
функциями и многое другое. Приведены примеры программного кода,
оформленные в виде текста на тёмном фоне. После них, как правило, де-
монстрируются результаты выполнения приведённого кода (например,
вывод числа или текста в консоль).

4
 Тема 1. ОСНОВНЫЕ ОБЪЕКТЫ ЯЗЫКА PYTHON.
ОСНОВНЫЕ ОПЕРАЦИИ

К основным объектам Python относятся переменные, операторы, числа,

строки.
Переменная задаётся идентификатором, который может состоять из
букв различного регистра, цифр или знака подчёркивания, причём начи-
наться только с буквы или знака подчёркивания. Объявление переменной
осуществляется путём присваивания ей некоторого значения (оператор =).
Основные типы переменных: int (целочисленная), float (действи-
тельное число), str (строка), bool (логическая). В отличие от большин-
ства других языков программирования, в Python не нужно указывать тип
переменной при её объявлении:
n = 12
alpha = 3.2 # дробная часть от целой отделяется точкой
msg = "Hi kids!" # строка выделяется одинарными либо двойными
# кавычками
b = True # для обозначения логических констант используются
# зарезервированные слова True и False
print(n, alpha, msg, b)
print(type(n), type(alpha), type(msg), type(b))

12 3.2 Hi kids! True

<class 'int'> <class 'float'> <class 'str'> <class 'bool'>

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

Функция print выводит все свои аргументы в консоль, разделяя их про-
белом и осуществляя перенос строки после вывода. Более подробно ра-
бота этой функции будет рассмотрена ниже. Пояснения к коду, написан-
ные курсивом после символа #, называются комментариями. Они пишутся
прямо внутри программного кода, не влияя на его работоспособность.
Основными типами чисел являются int и float. Python позволяет ис-
пользовать различные форматы записи чисел:
# можно опускать целую либо дробную часть, при этом они будут
# равны 0
alpha = .34
beta = 3.
print(alpha, beta)
# экспоненциальная запись числа
5
avogadro = 6.02e23
print(avogadro)
# записи целого числа в двоичной, восьмеричной и
# шестнадцатеричной системах счисления
b_number = 0b1110001101
o_number = 0o7712403
h_number = 0x2c
print(b_number, o_number, h_number)
# можно вписывать между цифрами числа символы подчёркивания
chess_number = 18_446_744_073_709_551_615
print(chess_number)

0.34 3.0
6.02e+23
909 2069763 44
18446744073709551615

Запись 6.02е+23 означает число, равное 6.02⋅1023. Здесь 6.02 является

мантиссой, а 23 – порядком числа в экспоненциальной форме. Число, за-
писанное в экспоненциальной форме, имеет тип float.

Доступны следующие операторы арифметических операций: + (сложе-

ние), - (вычитание), * (умножение), / (деление), // (целая часть частного),
% (остаток при делении), ** (возведение в степень). Арифметические опе-
рации в Python имеют привычный приоритет, т.е. в сложном выражении
выполняется вначале возведение в степень, потом – умножение и деление,
потом – сложение и вычитание. Для изменения приоритета арифметиче-
ских операций используются круглые скобки.
# результат деления - число типа float
div = 37 / 23
print(div)
# результат оператора // - целая часть частного, т.е.
# наибольшее целое число, не большее частного
trunc_div_1 = 37 // 23
# оператор – может также использоваться для обозначения
# отрицательного или противоположного числа
trunc_div_2 = 37 // -23
print(trunc_div_1, trunc_div_2)
# остаток при целочисленном делении
reminder_1 = 37 % 23
reminder_2 = 37 % -23
print(reminder_1, reminder_2)
# числа обоих типов (int и float) можно сочетать в
# вычислениях, результат – число типа float

6
num_1 = 12 * 0.5 + 2
num_2 = 12 * (0.5 + 2)
print(num_1, num_2)

1.608695652173913
1 -2
14 -9
8.0 30.0

Python поддерживает длинную целочисленную арифметику:

print(2**250)

1809251394333065553493296640760748560207343510400633813116524
750123642650624

Следует отметить, что при оперировании числами типа float воз-

можны неточности вследствие их представления в памяти компьютера:
print(.1 + .1 + .1 + .1 + .1 + .1 + .1 + .1 + .1 + .1 + .1)

1.0999999999999999

Язык Python поддерживает также другие форматы чисел, такие как

Decimal и Fraction 1, позволяющие оперировать действительными чис-
лами с большей точностью, а также комплексные числа 2 и операции с
ними.
Для использования более сложных функций реализован модуль math:
# для использования модуля его необходимо вначале
# импортировать
import math
# вычисление квадратного корня
print(math.sqrt(37))

6.082762530298219

Операции над логическими переменными: and (логическое «и»), or

(логическое «или»), not (логическое отрицание).

1
Про то, как работают эти типы данных, можно прочитать здесь:
https://docs.python.org/3.7/library/decimal.html,
https://docs.python.org/3.7/library/fractions.html
2
Операции над комплексными числами рассмотрены здесь:
https://pythonworld.ru/tipy-dannyx-v-python/chisla-int-float-complex.html
7
a = True
b = False
print(a and b, a or b, not a, not b)

False True False True

Сравнение чисел и других объектов осуществляется посредством опе-

раторов == (равно), != (не равно), > (больше), < (меньше), >= (больше либо
равно), <= (меньше либо равно). При сравнении строк вначале сравнива-
ются первые символы (большим считается тот, у которого больше код по
стандарту Юникод), при их равенстве – вторые и т.д. Такой способ срав-
нения называется лексикографическим сравнением.
Результат операторов сравнения – значение типа bool. Возможно ком-
бинирование этих операций:
# сравнение строк из букв латиницы
sym = "B"
print(sym >= "A")
print(sym == "B")
print(sym >= "D")
print(sym >= "a")
print(2 <= 3 <= 5) # эквивалентно выражению 2 <= 3 and 3 <= 5
print("0" < "9" < "A" < "Z" < "a" < "z")

True
True
False
False
True
True

Тема 2. СТРОКИ. ОПЕРАЦИИ НАД СТРОКАМИ

Строки – объекты, представляющие собой последовательность симво-

лов, заключённых в одинарные либо двойные кавычки. Для представления
строки, в которой есть символ ' или ", нужно использовать кавычки дру-
гого типа или использовать символ \ (иногда говорят "экранировать сим-
вол").
print('поезд')
print('поезд \'Брест-Москва\'')
print("поезд 'Брест-Москва'")

8
поезд
поезд 'Брест-Москва'
поезд 'Брест-Москва'

Как видно из этого примера, нет разницы, в какие кавычки заключать

содержимое строки: одинарные либо двойные.
Python поддерживает некоторые спецсимволы, например, \n (переход
на новую строку), \t (табуляция)3.
print("Мой родны кут, як ты мне мілы!\nЗабыць цябе не маю",
"сілы!")

Мой родны кут, як ты мне мілы!

Забыць цябе не маю сілы!

Иногда используют символ r или R перед строкой во избежание экра-

нирования (так называемые сырые строки):
print('C:\some\name')
print(r'C:\some\name')

C:\some
ame
C:\some\name

При выводе первой строки был обнаружен спецсимвол \n, из-за чего
был осуществлён перенос на новую строку. Во втором случае эта же ком-
бинация символов интерпретируется просто как последовательность двух
символов из-за отсутствия экранирования.
Три подряд кавычки (одинарные или двойные) используют для объяв-
ления строковых переменных, занимающих несколько строк:
verse = """Вуж
паўзе
сабе
дарожкай,
не кране
ніводнай
ножкай.
Ён
пакратаў бы,

3
Более подробный список представлен здесь: https://pythonworld.ru/tipy-dannyx-v-
python/stroki-literaly-strok.html
9
 каб мог,
але вуж
не мае
ног."""
print(verse)

Вуж
паўзе
сабе
дарожкай,
не кране
ніводнай
ножкай.
Ён
пакратаў бы,
каб мог,
але вуж
не мае
ног.

Поддерживаются такие операторы строк, как + (конкатенация) и * (по-

вторение строки):
triple_name = "Андрей, "
single_name = "Пётр"
msg = "Знакомьтесь: " + 3 * triple_name + single_name
print(msg)

Знакомьтесь: Андрей, Андрей, Андрей, Пётр

Возможен и такой вариант конкатенации строк:

text = ("Какой-то длинный текст, не несущий смысла, однако "
"продемонстрированный в качестве наглядного примера")
print(text)

Какой-то длинный текст, не несущий смысла, однако

продемонстрированный в качестве наглядного примера

Этот способ работает только со строковыми константами, но не с пере-

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

10
msg = "Hi! My name is..."
# индексация в Python начинается с нуля
first = msg[0]
second = msg[1]
# поддерживается также отрицательная индексация
# первый с конца строки символ
last = msg[-1]
print(first + second + last)

Hi.

Результатом взятия символа строки является объект типа str, содержа-

щий один символ. В Python не существует отдельного типа данных для
символов.
Из строк можно извлекать не только отдельные элементы, но и их по-
следовательности, называемые срезами. Взятие среза строки осуществля-
ется путём использования оператора [x:y:z], где x – номер начального
элемента среза, y – номер элемента, до которого нужно завершить срез
(сам элемент в срез не войдёт), z – шаг среза. Некоторые или даже все эти
числа могут быть пропущены, при этом по умолчанию принимаются сле-
дующие значения: x – 0, y – длина строки, z – 1.
msg = "Hi! My name is..."
print(msg[7:11])
print(msg[4:11:2])
print(msg[3:11:2])
# взятие среза до конца строки
print(msg[4:])
# написание строки задом наперёд
print(msg[::-1])
# возможно совместное использование положительных и
# отрицательных индексов
print(msg[7:-4])
print(msg[12::-2])

name
M ae
ynm
My name is...
...si eman yM !iH
name i
iea M

Заметим, что при отрицательном значении шага среза индекс начала

должен быть больше индекса окончания среза. При этом по умолчанию
11
значение начала среза равно –1, окончания – длина строки плюс один, взя-
тая со знаком минус. Длину строки можно определить при помощи функ-
ции len:
print(len(msg))

17

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

строке, можно при помощи оператора in, который возвращает логическое
значение:
print("i" in msg)
print("name" in msg)

True
True

При работе со строками следует помнить о том, что они являются не-
изменяемыми объектами, т.е. нельзя изменять их элементы. Если нужно
изменить некоторую строку, то следует создать новую.
msg = "Здравствуй, Андрей"
# msg[-6:] = "Пётр" # если убрать решётку в начале этой
# строки, то выполнение этого оператора выдаст ошибку
# можно поступить, например, следующим образом:
new_msg = msg[:-6] + "Пётр"
print(new_msg)

Здравствуй, Пётр

Некоторые полезные методы строк4:

msg = "здравствуй, Андрей, здравствуй, Пётр."
print(msg.find("здрав")) # нахождение индекса начала первого
# вхождения заданной подстроки
print(msg.rfind("здрав")) # индекс начала последнего
# вхождения аргумента
print(msg.count("здрав")) # количество вхождений заданной
# подстроки
print(msg.replace("Пётр", "Кирилл")) # замена всех вхождений
# одной подстроки на
# другую
words = msg.split(",") # разбиение строки по заданному

4
Более подробный список методов приведён здесь: https://pythonworld.ru/tipy-
dannyx-v-python/stroki-funkcii-i-metody-strok.html
12
 # символу на несколько строк
print(msg.split(","))
print(" ".join(words)) # обратная операция - соединение строк
# из списка words в одну с заданным
# разделителем
print(msg.capitalize()) # первая буква строки переводится в
# верхний регистр, остальные - в
# нижний
print("88000".isdigit()) # состоит ли данная строка только из
# цифр?
print(msg.isalpha()) # состоит ли строка только из букв?
# (вернёт False, так как есть знаки
# препинания)

0
20
2
здравствуй, Андрей, здравствуй, Кирилл.
['здравствуй', ' Андрей', ' здравствуй', ' Пётр.']
здравствуй Андрей здравствуй Пётр.
Здравствуй, андрей, здравствуй, пётр.
True
False

Все эти методы оставляют исходную строку неизменной. Существуют

также две специальные функции, работающие с символами:
print(ord("p")) # возвращает код символа по стандарту Unicode
print(chr(113)) # по коду символа возвращает сам символ

112
q

Тема 3. КОНСОЛЬНЫЙ ВВОД И ВЫВОД. ПРИВЕДЕНИЕ К ДРУГОМУ

ТИПУ ДАННЫХ. ФОРМАТИРОВАНИЕ СТРОК

Для ввода используется функция input, которая в качестве параметра

может принимать сообщение, выводимое в консоль перед вводом.
msg = input("Введите Ваше сообщение: ")
print(msg)

Результат выполнения этого кода зависит от того, что пользователь вве-

дёт в консоль. При этом после нажатия клавиши Enter переменной msg

13
присвоится строка, введённая пользователем. Например, если ввели со-
общение Здравствуйте, то результат будет выглядеть следующим обра-
зом:
Введите Ваше сообщение: Здравствуйте
Здравствуйте

Результатом функции input является строка. Если необходимо ввести

данные другого типа, например, число, то следует производить приведе-
ние к нужному типу.
msg = input("Введите число: ")
number = int(msg) # приведение строки к целочисленному типу
print(number, "+ 2 =", number + 2)

Введите число: 4
4 + 2 = 6

К функциям приведения типов также относятся float, str.

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

функция print. По умолчанию эта функция осуществляет вывод своих
аргументов через пробел и последующий переход на новую строку (или,
другими словами, ставит в конце вывода символ \n), но эта функция имеет
дополнительные параметры:
print("Города Беларуси:", "Брест", "Витебск", "Гродно",
"Гомель", "Минск", "Могилёв")
# вывод аргументов через запятую
print("Города Беларуси:", "Брест", "Витебск", "Гродно",
"Гомель", "Минск", "Могилёв", sep=',')
# окончание строки пробелом
print("Города Беларуси:", end = ' ')
# дальнейший вывод в той же строке консоли
print("Брест", "Витебск", "Гродно", "Гомель", "Минск",
"Могилёв", sep=', ', end='.')

Города Беларуси: Брест Витебск Гродно Гомель Минск Могилёв

Города Беларуси:,Брест,Витебск,Гродно,Гомель,Минск,Могилёв
Города Беларуси: Брест, Витебск, Гродно, Гомель, Минск,
Могилёв.

Таким образом, у функции print, кроме аргументов, подлежащих вы-

воду, есть также ключевые аргументы sep и end. Для их использования
необходимо при вызове функции указать название ключевого аргумента
14
и его значение, как в примере выше. При этом порядок указания ключе-
вых аргументов не важен. Если в функции print ключевые параметры не
указаны, то они принимают значения sep=' ', end='\n'.
Часто результаты выполнения программы выводятся с использованием
определённого оформления, или форматирования, с целью более нагляд-
ного представления или описания. Python располагает несколькими сред-
ствами форматированного вывода в консоль. Одним из них является ис-
пользование форматированных строк.
Основные способы форматирования строк в Python – использование
оператора % и метода format.
name = input("Введите Ваше имя: ")
# вставка в нужное место строки-шаблона другой строки
print("Здравствуй, %s" % name)
a = int(input("Введите два целых числа. Первое: "))
b = int(input("Второе: "))
# вставка нескольких значений в соответствующие места строки-
# шаблона по порядку
print("a + b = %d, a - b = %d, a * b = %d, a / b = %.3f" %
(a + b, a - b, a * b, a / b))

Введите Ваше имя: Пётр

Здравствуй, Пётр
Введите два целых числа. Первое: 32
Второе: 9
a + b = 41, a - b = 23, a * b = 288, a / b = 3.556

Таким образом, для использования оператора % вначале нужно задать

строку-шаблон, содержащую спецификаторы, заменяемые на нужные зна-
чения. Спецификаторы всегда начинаются с символа %, после которого
обычно следует символ, указывающий тип данных, заменяющих данный
спецификатор, например, %s – строка, %d – целое число, %f – действитель-
ное число5. В спецификаторах могут использоваться и другие инструкции.
Например, в примере выше спецификатор %.3f позволяет вставить дей-
ствительное число, округлив его до 3 знаков после запятой. Если в строке-
шаблоне нужен сам символ %, то его можно задать при помощи специфи-
катора %%.

5
Более подробный список представлен здесь:
https://docs.python.org/3.7/library/stdtypes.html#old-string-formatting
15
a = 7
b = 23
print("%d составляет %.2f%% от %d" % (a, a / b * 100, b))

7 составляет 30.43% от 23

Обратите внимание, что в случае использования более одного значения

для использования в строке-шаблоне эти значения указываются после опе-
ратора % в круглых скобках. Таким образом в Python задаются объекты,
называемые кортежами, которые будут подробно рассмотрены далее в
теме 7.
Метод format используется следующим образом:
surname_1 = "Пахомов"
surname_2 = "Епифанцев"
sport = "шашки"
# вставка аргументов метода format в места, указанные
# фигурными скобками, по порядку
print("{} и {} играют в {}".format(surname_1, surname_2,
sport))
# в скобках можно указывать, какой по счёту аргумент следует
# сюда вставить
print("{1} и {0} играют в {2}".format(surname_1, surname_2,
sport))
points_1 = 1
points_2 = 2
print("Счёт {:d}:{:d} в пользу {}а".format(points_1,
points_2,
surname_1))
print("Счёт {1:d}:{0:d} в пользу {2}а".format(points_1,
points_2,
surname_1))

Пахомов и Епифанцев играют в шашки

Епифанцев и Пахомов играют в шашки
Счёт 1:2 в пользу Пахомова
Счёт 2:1 в пользу Пахомова

В данном примере строка-шаблон состоит из спецификаторов, задава-

емых в виде фигурных скобок {}, между которыми могут находиться сим-
волы, указывающие на тип вставляемых данных (если эти символы не за-
даны, то вставляется строковое представление нужных данных). Эти сим-
волы аналогичны тем, что используются при форматировании строк при
помощи оператора %.

16
 Тема 4. УСЛОВНЫЕ ОПЕРАТОРЫ

Для организации разветвления алгоритмов служит условный оператор

if, который имеет следующий синтаксис:

x = int(input("Введите целое число: "))

if x == 0:
print("x равен нулю")
elif x > 0:
print("x положительно")
else:
print("x отрицательно")

Непосредственно после ключевого слова if стоит выражение, которое

должно принимать логическое значение True либо False. Если выраже-
ние имеет значение True, выполняются все операторы, следующие в блоке
непосредственно после оператора if. Например, в примере выше для сра-
батывания операторов в блоке после if нужно, чтобы x равнялось нулю:
Введите целое число: 0
x равен нулю

Эти операторы должны быть написаны с одним и тем же отступом, ко-

торый задаётся пробелами либо табуляцией. Если выражение после опе-
ратора if принимает значение False, то отделённый отступами блок опе-
раторов после if выполняться не будет.
Непосредственно после оператора if и блока операторов после него
может следовать один или несколько операторов elif. Он выполняется в
случае несрабатывания предыдущих условных операторов и действует
аналогично оператору if:
Введите целое число: 4
x положительно

После последовательности условных операторов может следовать ещё

один условный оператор else, который выполняется тогда и только тогда,
когда все предыдущие операторы не сработали:
Введите целое число: -2
x отрицательно

Условные операторы могут также использоваться для задания значения

переменной:
17
a = Y if X else Z # присваивает переменной a значение Y, если
# X принимает значение True, либо Z, если X
# принимает значение False

Пример задания: Дима и Вова хвастаются своими коллекциями фи-

шек. Выяснить, у кого из них больше фишек, и выписать ответ в консоль.
Количество фишек у каждого задаётся с клавиатуры.
Решение: Количество фишек у каждого из мальчиков – натуральное
число, поэтому первоначально оно задаётся следующим образом:
d = int(input("Введите количество фишек у Димы: "))
v = int(input("Введите количество фишек у Вовы: "))

После чего следует сравнить два введённых числа. Возможно два слу-
чая: оба числа равны либо же одно из них больше другого. В первом слу-
чае нужно вывести сообщение о том, что у ребят равное число фишек:
if d == v:
print("У мальчиков поровну фишек")

Если же у кого-то из них больше фишек, то можно поступить следую-

щим образом:
else:
first_boy = "Димы" if d > v else "Вовы"
second_boy = "Вовы" if d > v else "Димы"
print("У %s больше фишек, чем у %s." % (first_boy,
second_boy))

То есть задаётся фраза-шаблон, куда на нужные места подставляются

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

Если, напротив, у Вовы окажется больше фишек, то в конце будет вы-

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

18
 Тема 5. СПИСКИ

Список – составной тип данных, представляющий собой несколько по-

следовательных объектов, как правило, одного типа. Список задаётся пу-
тём перечисления своих элементов через запятую внутри квадратных ско-
бок:
cities = ["Брест", "Витебск", "Гродно", "Гомель", "Минск",
"Могилёв"]

Списки могут содержать данные разного типа, а также вложенные

списки:
mixed_list = [4, 4.5, "Ноябрь", True, [1, 3, 4, 5], "Pizza"]

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

тому, как это реализовано со строками, а также конкатенация и повторе-
ние списков:
city = cities[2]
two_cities = cities[3:5]
# заключение в квадратные скобки переменной позволяет задать
# список из одного элемента
multiple_cities = [city] * 3 + two_cities
print(city, two_cities, multiple_cities)

Гродно ['Гомель', 'Минск'] ['Гродно', 'Гродно', 'Гродно',

'Гомель', 'Минск']

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

# замена одного из элементов списка
cities[1] = "Новый Витебск"
print(cities)
# замена нескольких последовательных элементов списка
cities[3:] = ["Добруш", "Смолевичи", "Чаусы"]
print(cities)
# можно заменить один срез другим, не обязательно равной
# длины
cities[2:4] = ["Свислочь", "Волковыск", "Брагин", "Речица"]
print(cities)
# убирать последовательности элементов списка можно следующим
# образом:
cities[:3] = []
print(cities)

19
['Брест', 'Новый Витебск', 'Гродно', 'Гомель', 'Минск',
'Могилёв']
['Брест', 'Новый Витебск', 'Гродно', 'Добруш', 'Смолевичи',
'Чаусы']
['Брест', 'Новый Витебск', 'Свислочь', 'Волковыск', 'Брагин',
'Речица', 'Смолевичи', 'Чаусы']
['Волковыск', 'Брагин', 'Речица', 'Смолевичи', 'Чаусы']

Заметим, что изменения каждый раз проводятся с обновленным спис-

ком. Иногда бывают случаи, когда из некоторого списка нужно получить
другой и при этом оставить исходный список неизменным. Для решения
подобных задач предварительно нужно сделать копию списка, после чего
можно проводить различные действия с копией, не затрагивая первона-
чальный список. Создание копии осуществляется методом copy:
new_cities = cities.copy() # или можно использовать cities[:]
new_cities[2:4] = ["Минск", "Брест", "Минск Восточный",
"Новый Минск"]
print(new_cities)
print(cities)

['Волковыск', 'Брагин', 'Минск', 'Брест', 'Минск Восточный',

'Новый Минск', 'Чаусы']
['Волковыск', 'Брагин', 'Речица', 'Смолевичи', 'Чаусы']

Длину списка можно узнать, используя функцию len:

print(len(cities))

Часто используются различные методы 6, позволяющие изменять спи-

сок или узнать некоторую информацию о нём:
print(cities)
# добавление нового элемента в конец списка
cities.append("Барановичи")
print(cities)
# приписывание другого списка к концу исходного списка
cities.extend(["Ляховичи", "Новогрудок", "Несвиж"])
print(cities)
# добавление нового элемента на нужную позицию
cities.insert(5, "Слоним")
print(cities)

Подробный список методов представлен здесь: https://pythonworld.ru/tipy-dannyx-

6

v-python/spiski-list-funkcii-i-metody-spiskov.html
20
# выяснить, содержится ли некоторое значение в списке, можно
# при помощи оператора in
print("Несвиж" in cities)

['Волковыск', 'Брагин', 'Речица', 'Смолевичи', 'Чаусы']

['Волковыск', 'Брагин', 'Речица', 'Смолевичи', 'Чаусы',
'Барановичи']
['Волковыск', 'Брагин', 'Речица', 'Смолевичи', 'Чаусы',
'Барановичи', 'Ляховичи', 'Новогрудок', 'Несвиж']
['Волковыск', 'Брагин', 'Речица', 'Смолевичи', 'Чаусы',
'Слоним', 'Барановичи', 'Ляховичи', 'Новогрудок', 'Несвиж']
True

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

ков различными способами7. Основными являются функция sorted, ре-
зультатом которой является новый, отсортированный список, и метод
sort, сортирующий данный список и тем самым изменяющий его. По
умолчанию производится сортировка элементов списка по возрастанию
согласно правилам сравнения в Python.
x = [-3, 5, 1, 0, 1, 2, -3]
print(sorted(x))
# сортировка в обратном порядке
print(sorted(x, reverse=True))
words = ["Здесь", "нужно", "руками", "кидать", "воду",
"вверх"]
print(sorted(words))
# сортировка по алфавитному порядку вне зависимости от
# регистра букв
print(sorted(words, key=str.lower))
# сортировка списка с его изменением
words.sort(key=str.lower)
print(words)

[-3, -3, 0, 1, 1, 2, 5]
[5, 2, 1, 1, 0, -3, -3]
['Здесь', 'вверх', 'воду', 'кидать', 'нужно', 'руками']
['вверх', 'воду', 'Здесь', 'кидать', 'нужно', 'руками']
['вверх', 'воду', 'Здесь', 'кидать', 'нужно', 'руками']

Таким образом, функция sorted поддерживает два ключевых аргу-

мента: reverse указывает, нужно ли сортировать список в порядке убы-
вания (по умолчанию равен False), а key позволяет указывать функцию

7
Подробное руководство по сортировке списков:
https://docs.python.org/3/howto/sorting.html
21
или метод, который будет применяться к каждому элементу списка для
его сортировки. При этом сортировка проводится в порядке возрастания
значений этой функции.
Поддерживается сортировка более сложных конструкций, например,
кортежей (см. темы 6, 7):
y = [2, 3, -1, 7, -2, -2, 1]
# генерация нового списка на основе ранее созданных двух
coords = [(x[i], y[i]) for i in range(7)]
print(coords)
print(sorted(coords))
print(sorted(coords, reverse=True))
print(sorted(coords, key=lambda coord:(-coord[0], coord[1])))

[(-3, 2), (5, 3), (1, -1), (0, 7), (1, -2), (2, -2), (-3, 1)]
[(-3, 1), (-3, 2), (0, 7), (1, -2), (1, -1), (2, -2), (5, 3)]
[(5, 3), (2, -2), (1, -1), (1, -2), (0, 7), (-3, 2), (-3, 1)]
[(5, 3), (2, -2), (1, -2), (1, -1), (0, 7), (-3, 1), (-3, 2)]

В данном примере продемонстрировано три способа сортировки. Вна-

чале производится сортировка по первому компоненту кортежей по воз-
растанию, а при равенстве первого компонента элементы списка сортиру-
ются по второму компоненту. При задании ключевого аргумента re-
verse=True происходит сортировка в порядке убывания (вначале по пер-
вой, а потом по второй компоненте).
Представляет интерес третий предложенный способ сортировки. Здесь
задаётся так называемая анонимная функция, которая для данного кор-
тежа из чисел возвращает тот же кортеж, только с противоположным пер-
вым компонентом. После этого сравниваются результаты этой функции
для всех элементов списка. Так, наименьшим полученным результатом
для данного примера будет (–5, 3), поэтому на первое место встанет кор-
теж (5, 3), вторым по возрастанию – (–2, –2), поэтому в отсортированном
списке будет дальше идти (2, –2) и т.д. Фактически задан способ сорти-
ровки вначале по первому компоненту в порядке убывания, затем – по вто-
рому в порядке возрастания. В общем случае сортировка по нескольким
критериям может производиться при помощи функции itemgetter сле-
дующим образом:
# импорт модуля, в котором определена функция itemgetter
import operator
name_and_age = [("Andrews, R.", 23), ("MacArthur, M.", 52),
("Coleman, T.", 32), ("Cummings, J.", 23),
22
 ("Zimmerman, A.", 29)]
# вначале производится сортировка по менее приоритетному
# компоненту
name_and_age.sort(key=operator.itemgetter(0))
print(name_and_age)
# затем по более приоритетному
name_and_age.sort(key=operator.itemgetter(1), reverse=True)
print(name_and_age)

[('Andrews, R.', 23), ('Coleman, T.', 32), ('Cummings, J.',

23), ('MacArthur, M.', 52), ('Zimmerman, A.', 29)]
[('MacArthur, M.', 52), ('Coleman, T.', 32), ('Zimmerman,
A.', 29), ('Andrews, R.', 23), ('Cummings, J.', 23)]

Таким образом, произведена сортировка кортежей вначале по второму

компоненту в порядке убывания, затем – по первому компоненту в алфа-
витном порядке.
Пример задания: Составить список имён заданной длины. Каждое имя
начинается с большой буквы. Все имена задаются с клавиатуры. Получен-
ный список отсортировать по возрастанию числа букв в них. Имена с рав-
ным числом букв сортировать в алфавитном порядке.
Решение: Задать список той или иной длины можно первоначальным
объявлением пустого списка и последующим его заполнением при по-
мощи цикла for (см. тему 6):
n = int(input("n = "))
names_list = []
# цикл на n итераций
for i in range(n):
# ввод очередного имени, для удобства и слежения в
# консоль выводится порядковый номер
new_name = input("Введите %d-ое имя: " % (i + 1))
# добавление введённого имени в список
names_list.append(new_name)

n = 6
Введите 1-ое имя: Галина
Введите 2-ое имя: Пётр
Введите 3-ое имя: Александр
Введите 4-ое имя: Никита
Введите 5-ое имя: Святослав
Введите 6-ое имя: Иван

23
 После этого можно отсортировать список согласно условию задачи.
Сделать это можно, например, при помощи задания анонимной функции:
# использование аргумента key для задания сортировки вначале
# по длине имени, а затем - по алфавиту, что является
# способом сортировки по умолчанию
names_list.sort(key=lambda name:(len(name), name))
print(names_list)

['Иван', 'Пётр', 'Галина', 'Никита', 'Александр',

'Святослав']

Если бы требовалось сортировать список по убыванию количества букв

в именах этого списка, то вместо len(name) нужно было бы использовать
противоположное число, -len(name). Для сортировки в порядке, обрат-
ном алфавитному, уже необходимо использовать либо аргумент re-
verse=True, либо функцию itemgetter, рассмотренную выше.

Тема 6. ОПЕРАТОРЫ ЦИКЛОВ

Цикл while с предусловием имеет следующий синтаксис:

x = int(input("Введите целое число: "))
while x >= 0:
print("Уменьшаю x на 1")
x = x - 1
print("Теперь x равно %d" % x)

Введите целое число: 4

Уменьшаю x на 1
Уменьшаю x на 1
Уменьшаю x на 1
Уменьшаю x на 1
Уменьшаю x на 1
Теперь x равно -1

При выполнении оператора while вначале проверяется значение логи-

ческого выражения, стоящего после него. Если оно равно True, то выпол-
няется блок цикла, после чего снова проверяется условие цикла. Таким
образом реализуется повторное выполнение одного и того же программ-
ного кода. Если при входе в цикл либо после окончания очередной итера-
ции оно стало равно False, то цикл пропускается (завершается), и выпол-
няются дальнейшие инструкции.
24
 Так, в примере выше было введено число x = 4. При входе в цикл
проверяется условие x >= 0. В данном случае оно принимает значение
True, поэтому далее выполняется блок операторов цикла, в результате ко-
торого x уменьшается на единицу и становится равным 3. После этого
снова проверяется условие цикла, которое опять равно True, и выполня-
ется последующий блок операторов. Выход из цикла осуществляется, как
только условие x >= 0 после очередной итерации цикла принимает зна-
чение False. В этом случае блок операторов цикла больше не выполня-
ется, и выполняются дальнейшие инструкции (в данном случае это вывод
окончательного значения x).
Цикл for осуществляет повторное выполнение некоторого программ-
ного блока для всех элементов заданной последовательности объектов,
например, строки или списка.
string = "Беларусь"
for sym in string:
print(sym)
cities = ["Брест", "Витебск", "Гродно", "Гомель", "Минск",
"Могилёв"]
for city in cities:
print(city)

Б
е
л
а
р
у
с
ь
Брест
Витебск
Гродно
Гомель
Минск
Могилёв

Цикл со счётчиком реализуется следующим образом:

for i in range(6):
if i % 2 == 0:
print("Число %d чётное" % i)
else:
print("Число %d нечётное" % i)
25
Число 0 чётное
Число 1 нечётное
Число 2 чётное
Число 3 нечётное
Число 4 чётное
Число 5 нечётное

Объект range представляет собой последовательность чисел. Отличие

объекта range от списков в том, что сама последовательность чисел не
хранится в памяти, а происходит вычисление элемента за элементом при
использовании, например, в циклах. Создать последовательность чисел
можно одним из трёх способов:
• range(stop) – числа от 0 до stop - 1;
• range(start, stop) – числа от start до stop - 1;
• range(start, stop, step) – числа от start включительно до stop
исключительно с шагом step.
Оператор break используется для немедленного выхода из цикла (for
или while). При этом после цикла может использоваться оператор else,
блок после которого будет выполняться в случае, если выход из цикла был
осуществлён "естественным образом", а не в результате выполнения опе-
ратора break.
x = int(input("Введите два целых числа. Первое: "))
y = int(input("Второе: "))
for i in range(x, y):
if i % 10 == 0:
print("%d делится на 10" % i)
break
else:
print("ни одно из чисел не делится на 10")

Если среди чисел x, x+1, …, y найдётся число, кратное 10, то при

выполнении этого кода будет выведено сообщение о том, что это число
делится на 10. Если таких чисел несколько, то будет выведено наименьшее
из них:
Введите два целых числа. Первое: 2
Второе: 28
10 делится на 10

В противном случае будет выведено сообщение о том, что такого числа

нет:
26
Введите два целых числа. Первое: 2
Второе: 7
ни одно из чисел не делится на 10

Если введённые числа x и y таковы, что x>=y, то последовательность

range(x, y) будет пустой, и выполнится блок операторов после опера-
тора else:
Введите два целых числа. Первое: 28
Второе: 2
ни одно из чисел не делится на 10

Срабатывание оператора continue в цикле приводит к прерыванию те-

кущей итерации цикла и переходу к новой:
for i in range(5):
if i == 0:
continue
print("1 / %d = %.2f" % (i, 1 / i))

1 / 1 = 1.00
1 / 2 = 0.50
1 / 3 = 0.33
1 / 4 = 0.25

В данном примере произошло досрочное прерывание итерации цикла

при i = 0, после чего остальные итерации выполнились до конца.
Кроме того, в Python реализованы некоторые функции, позволяющие
упростить написание циклов8:
cities = ["Брест", "Витебск", "Гродно", "Гомель", "Минск",
"Могилёв"]
# функция enumerate возвращает последовательность из пар
# (номер элемента в списке, сам элемент)
for i, city in enumerate(cities):
print(i, city)
populations = [350_616, 378_459, 373_547, 536_938, 1_992_685,
383_313]
# функция zip может служить для построения циклов сразу по
# нескольким спискам
for city, p in zip(cities, populations):
print("Население города %s составляет %d" % (city, p))

8
Более подробно они рассмотрены здесь:
https://docs.python.org/3.7/tutorial/datastructures.html#looping-techniques
27
0 Брест
1 Витебск
2 Гродно
3 Гомель
4 Минск
5 Могилёв
Население города Брест составляет 350616
Население города Витебск составляет 378459
Население города Гродно составляет 373547
Население города Гомель составляет 536938
Население города Минск составляет 1992685
Население города Могилёв составляет 383313

Пример задания: Два игрока играют в следующую игру. На столе ле-

жат 13 спичек. Каждый игрок по очереди берёт 1, 2 или 3 спички за ход.
Игра кончается, когда взята последняя спичка. Выигрывает тот, у кого
оказалось чётное количество спичек на руках. Определить, кто выиграет,
если количество спичек на данном ходу вводится с клавиатуры перед этим
же ходом.
Решение: Для решения этой задачи необходимо использовать цикл
while. Каждая итерация этого цикла имитирует очередной ход. Условие
выполнения этого цикла – наличие спичек на столе. При решении этой
задачи важно следить, кто сейчас ходит. Поэтому в цикле следует завести
переменную-счётчик итераций i:
# исходное количество спичек на столе
n = 13
# имена игроков
names = ["Первый игрок", "Второй игрок"]
# количество спичек на руках у первого и второго игрока
# соответственно
matches = [0, 0]
i = 0

Каждый ход представляет собой выбор количества спичек тем или

иным игроком, которое он будет брать из общей кучи. При этом важно
следить, у кого сколько спичек на руках, так как от этого зависит исход
игры:
while n > 0:
# переменная i определяет, чей сейчас ход: при чётном i
# ходит первый игрок, при нечётном - второй.
current_player = names[i % 2]
# на очередном ходу этот игрок решает, сколько спичек он

28
 # возьмёт со стола. Это число вводится с клавиатуры
n_i = int(input("Сколько спичек возьмёт %s? " %
current_player))
# это число вычитается из общего числа спичек и
# прибавляется к числу спичек на руках текущего игрока
n -= n_i
matches[i % 2] += n_i
# для слежения за игрой было бы неплохо выводить
# результат каждого хода
print(("На столе осталось %d спичек. %s имеет на руках "
"%d спичек, %s - %d спичек.") % (n, names[0],
matches[0],
names[1],
matches[1]))
# в конце хода нужно увеличить i
i += 1

В последнем вызове функции print используется конкатенация строк

при помощи скобок, которая позволяет применять форматирование к еди-
ной строке, подлежащей выводу. Обратите внимание, что все описанные
инструкции выполняются в пределах одной итерации, поэтому необхо-
димы отступы слева из пробелов либо табуляций.
По выходе из цикла, т.е. когда число спичек на столе станет равно
нулю, остаётся только проверить число спичек на руках у игроков и объ-
явить победителя:
if matches[0] % 2 == 0:
print("%s победил" % names[0])
else:
print("%s победил" % names[1])

Сколько спичек возьмёт Первый игрок? 3

На столе осталось 10 спичек. Первый игрок имеет на руках 3
спичек, Второй игрок - 0 спичек.
Сколько спичек возьмёт Второй игрок? 2
На столе осталось 8 спичек. Первый игрок имеет на руках 3
спичек, Второй игрок - 2 спичек.
Сколько спичек возьмёт Первый игрок? 1
На столе осталось 7 спичек. Первый игрок имеет на руках 4
спичек, Второй игрок - 2 спичек.
Сколько спичек возьмёт Второй игрок? 2
На столе осталось 5 спичек. Первый игрок имеет на руках 4
спичек, Второй игрок - 4 спичек.
Сколько спичек возьмёт Первый игрок? 1

29
На столе осталось 4 спичек. Первый игрок имеет на руках 5
спичек, Второй игрок - 4 спичек.
Сколько спичек возьмёт Второй игрок? 2
На столе осталось 2 спичек. Первый игрок имеет на руках 5
спичек, Второй игрок - 6 спичек.
Сколько спичек возьмёт Первый игрок? 1
На столе осталось 1 спичек. Первый игрок имеет на руках 6
спичек, Второй игрок - 6 спичек.
Сколько спичек возьмёт Второй игрок? 1
На столе осталось 0 спичек. Первый игрок имеет на руках 6
спичек, Второй игрок - 7 спичек.
Первый игрок победил

Тема 7. КОРТЕЖИ

Кортеж, как и список, также представляет собой последовательность

нескольких значений одного или различных типов. Кортеж задаётся в виде
последовательности элементов, перечисленных через запятую и заклю-
чённых в круглые скобки. Доступны те же операции, что и со строками и
со списками: взятие элемента и среза, конкатенация и повторение, вычис-
ление длины, проверка на наличие элемента в кортеже.
t_1 = ("Андрей", 14, "Кирилл")
# кортеж из одного элемента объявляется путём указания этого
# элемента и запятой после него
t_2 = (4,)
# возможно объявление кортежей без использования круглых
# скобок
t_3 = 4, 5, 6, "That's all"
t_4 = t_1 + t_2 * 3 + t_3
print(t_4)
print(t_4[3:7])
print(len(t_4))
print(5 in t_4)

('Андрей', 14, 'Кирилл', 4, 4, 4, 4, 5, 6, "That's all")

(4, 4, 4, 4)
10
True

Присваивание некоторой переменной кортежа можно рассматривать

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

30
# упаковка в кортеж
competition = ("Пахомов", "Епифанцев", "шашки")
# распаковка кортежа в разные переменные
name_1, name_2, sport = competition
print("Участники соревнования: %s и %s" % (name_1, name_2))
print("Они играют в %s" % sport)

Участники соревнования: Пахомов и Епифанцев

Они играют в шашки

Дополнительные возможности, предоставляемые кортежами:

# кортежи часто используются в различных операторах и
# функциях, например, при форматированном выводе
print("Меня зовут %s, мне %d лет. А это %s" % t_1)
# возможно присваивание значений сразу нескольким переменным
name_1, age, name_2 = "Денис", 13, "Михаил"
print("Меня зовут %s, мне %d лет. А это %s" % (name_1, age,
name_2))
# можно легко менять местами значения переменных
name_1, name_2 = name_2, name_1
print("Меня зовут %s, мне %d лет. А это %s" % (name_1, age,
name_2))

Меня зовут Андрей, мне 14 лет. А это Кирилл

Меня зовут Денис, мне 13 лет. А это Михаил
Меня зовут Михаил, мне 13 лет. А это Денис

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

Кортежи являются неизменяемыми, содержат обычно данные различных
типов, обращение к которым осуществляется через распаковку или по ин-
дексу. Списки – изменяемые объекты, содержат обычно данные одного
типа, доступ к которым, как правило, происходит последовательно, к од-
ному за другим (например, в циклах).
Пример задания: Вывести числа от 1 до n в порядке возрастания
суммы цифр. Числа с равной суммой цифр вывести в порядке возрастания.
Решение: Для решения этой задачи можно воспользоваться корте-
жами, каждый из которых имеет вид (i, digits_sum), где digits_sum –
сумма цифр числа i. Из этих кортежей составляется список, подлежащий
сортировке согласно условию задачи:
n = int(input("n = "))
# список кортежей с числами и суммами их цифр
tuples = []

31
for i in range(1, n + 1):
# подсчёт суммы цифр числа i
digits_sum = 0
ii = i
while ii > 0:
digits_sum += ii % 10
ii = ii // 10
# добавление очередного кортежа в список
tuples.append((i, digits_sum))
# сортировка списка кортежей вначале по второму компоненту,
# затем - по первому
tuples.sort(key=lambda t:(t[1], t[0]))

Искомый вывод можно осуществить следующим образом:

for t in tuples:
print(t[0])

n = 10
1
10
2
3
4
5
6
7
8
9

32
 ЗАДАНИЯ ДЛЯ САМОСТОЯТЕЛЬНОЙ РАБОТЫ

1. Для трёх действительных чисел a, b, c вывести число, равное ab/c.

Результат округлить до трёх знаков после запятой.
2. Составить список чисел от 1 до n включительно, у которых сумма
всех делителей, кроме самого числа (например, для 8 это число равно
1 + 2 + 4 = 7), превышает n/2. Для каждого элемента полученного списка
вывести сам элемент и сумму его делителей, кроме самого числа.
3. Дана строка, в которой слова разделены пробелами. Найти все слова
с 8 и более буквами, выписать их в порядке возрастания числа букв в них.
Слова равной длины выписать в алфавитном порядке.

Пояснения к заданиям для самостоятельной работы

1. Ввод действительных чисел организовывается следующим образом:

a = float(input("a = "))
b = float(input("b = "))
c = float(input("c = "))

Затем нужно вычислить a * b / c и вывести полученный результат,

используя форматирование:
result = a * b / c
# вывод действительного числа с тремя знаками после запятой
print("%.3f" % result)

a = 32.7
b = 3.8
c = 7.6
16.350

2. Для решения этой задачи будут использоваться два списка: искомый

с числами от 1 до n и список сумм делителей для каждого из них:
n = int(input("n = "))
# список искомых чисел
nums = []
# список сумм делителей этих чисел
sum_divs = []

33
 Для каждого числа от 1 до n вычисляется сумма всех делителей, кроме
самого числа, которая затем сравнивается с числом n / 2. Если сумма
делителей окажется больше, то само число записывается в первый список,
а сумма его делителей – во второй:
for i in range(1, n + 1):
# число i всегда делится на 1
summ = 1
# наибольший делитель числа i, не считая само число i,
# будет меньше числа i // 2 + 1
for div in range(2, i // 2 + 1):
if i % div == 0:
summ += div
# если число i подходит по условию задачи, то нужно его
# записать в один список, а сумму его делителей - в
# другой
if summ > n / 2:
nums.append(i)
sum_divs.append(summ)

После того, как оба списка заполнены, можно выписать все их эле-
менты. Для параллельного выписывания элементов списков хорошо по-
дойдёт функция zip:
# одновременный вывод соответственных элементов обоих списков
for i, sum_div in zip(nums, sum_divs):
print("Сумма делителей числа %d равна %d" % (i, sum_div))

n = 10
Сумма делителей числа 6 равна 6
Сумма делителей числа 8 равна 7
Сумма делителей числа 10 равна 8

3. Разделение строки на слова осуществляется посредством метода

split, который по умолчанию делит текст по пробелам. При этом если в
тексте встречаются знаки препинания, то они не будут игнорироваться.
В данной задаче нужно вначале составить список из слов длиной 8 или
более символов. При этом будем считать словом любую последователь-
ность символов между пробелами, в том числе слово с примыкающими к
нему знаками препинания.
string = input("Введите текст\n")
# список искомых слов
long_words = []
for word in string.split():
34
 if len(word) >= 8:
long_words.append(word)

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

признакам, в первую очередь по длине слова, а затем – по алфавитному
порядку. В языке Python для осуществления подобных действий следует,
наоборот, вначале отсортировать список по алфавиту, а затем полученный
список отсортировать по длине слов:
# вначале производится сортировка по менее приоритетному
# признаку. Признак сортировки str.lower позволяет
# игнорировать регистр букв, который по умолчанию влияет на
# сортировку
long_words.sort(key=str.lower)
# затем - по более приоритетному
long_words.sort(key=len)
print(*long_words, sep="\n")

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

В приведённом примере слово занятиях. выведено позже остальных

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

35
 КОНТРОЛЬНАЯ РАБОТА № 1

1. Найти максимальное среди 4 введённых чисел.

2. Для двух действительных положительных чисел вывести, сколько
процентов меньшее число составляет от большего. Результат округлить до
сотых долей процента.
3. Вводятся два числа: действительное из интервала (0,1) и натураль-
ное. Вывести результат возведения первого числа в степень другого в экс-
поненциальной форме. Мантиссу результата округлить до 4 знаков после
запятой.
4. Вводятся названия трёх городов. Вывести их в консоль в порядке,
обратном вводу, через запятую.
5. У Буратино n яблок. Некто попросил у него k яблок. Буратино согла-
сен дать тому яблоки только в том случае, если у него самого останется не
менее 6 яблок. В консоль вывести фразу, которую мог сказать Буратино в
ответ в зависимости от того, согласен он дать яблоки или нет (причём если
согласен, то он говорит, сколько яблок он даёт).
6. Решить квадратное уравнение ax2 + bx + c = 0. Вводятся действитель-
ные коэффициенты a ≠ 0, b, c. Вывод – все корни полученного уравнения
либо сообщение о том, что корней нет.
7. У Пети есть n рублей. Поход в кино стоит k рублей, пирожок – p
рублей. Сможет ли Петя пойти в кино на свои деньги? Купить пирожок?
И то, и другое сразу?
8. Некий ростовщик даёт взаймы денег при условии, что через год кли-
ент возвращает ему заём в двукратном размере. Однажды ростовщик ре-
шил поменять схему: за первые полгода подлежащая возврату сумма уве-
личивается в 3/2 раза, а за вторую половину года получившаяся сумма воз-
растает ещё в 3/2 раза. Таким образом, ростовщик получит прибыль, в 9/4
раза больше, чем заём, что, безусловно, более выгодно, чем обычное уве-
личение в 2 раза. Постепенно в голове ростовщика сложился ещё более
хитрый план: разбивать год не на 2, а на ещё большее число промежутков
n. По истечении каждого из них задолженность должна возрастать в (1 +
1/n) раз. «Наверное, это очень большое число», – решил ростовщик, при-
кидывая итоговую прибыль. Какая всё-таки будет выручка ростовщика по
отношению к исходному займу?
36
 КОНТРОЛЬНАЯ РАБОТА № 2

1. Дано натуральное число. Определить, является ли оно простым или

составным.
2. Для данного натурального числа n вывести все числа, меньшие n и
взаимно простые с n (взаимно простые числа – это числа, которые имеют
единственный общий делитель, равный 1).
3. Найти все пифагоровы тройки чисел p, q, r, каждое из которых не
превышает 50. Пифагоровыми называют натуральные числа p, q, r, для ко-
торых выполняется равенство p2 + q2 = r2.
4. Даны координаты четырёх точек на плоскости. Найти минимальный
прямоугольник со сторонами, параллельными координатным осям,
внутри которого (или на границах которого) располагаются все точки.
Например, для точек (1, 0), (2, 3), (1, –1) и (0, 2) искомый прямоугольник
задаётся следующими сторонами: x = 0, x = 2, y = –1, y = 3.
5. Два игрока играют в следующую игру. На столе лежат 25 спичек.
Каждый игрок по очереди берет 1, 2, 3 или 4 спички за ход. Выигрывает
тот, кто забирает последнюю спичку. Определить, кто выиграет, если ко-
личество взятых спичек на данном ходу вводится с клавиатуры перед этим
же ходом.
6. Пахомов и Епифанцев играют в шашки несколько партий. После пер-
вой партии проигравший отжимается один раз, после второй – два раза и
так далее. И так до тех пор, пока один из них не отожмётся 20 или более
раз. Выяснить, кто сколько раз в итоге отожмётся. Ввод данных произво-
дится перед началом очередной партии и определяет её исход. Например,
«0» может означать победу Пахомова, а «1» – победу Епифанцева. Число
партий неизвестно заранее.
7. Представить данное натуральное число в симметричной троичной
системе счисления. В ней используются цифры 1, 0 и i, где i означает вы-
читание соответствующего разряда. Например, 70 = 34 – 32 – 31 + 1, т. е.
искомая запись в этом случае выглядит так: 10ii1.
8. Составить список чисел от 1 до n включительно, у которых 6 или
более делителей. Для каждого элемента полученного списка вывести сам
элемент и все его делители.

37
 КОНТРОЛЬНАЯ РАБОТА № 3

1. Организовать составление списка заданной длины из фамилий лю-

дей, вводимых с клавиатуры (фамилии начинаются с прописной буквы).
Вывести полученный список, отсортировав его по алфавиту и пронумеро-
вав с единицы.
2. Организовать составление списка заданной длины из названий горо-
дов, вводимых с клавиатуры (названия начинаются с прописной буквы). В
полученном списке все города на букву П перенести в конец этого же
списка, не меняя порядок остальных элементов списка.
3. Ввести текст с клавиатуры, у каждого слова первую букву сделать
прописной. Слова отделены друг от друга пробелами, первым символом у
каждого слова является буква.
4. Введён некоторый текст, в котором встречаются целые числа. Найти
и вывести сумму всех этих чисел. Числа отделены от других слов и знаков
препинаний пробелами.
5. Дана строка, в которой упомянуты два имени. Имена начинаются с
прописных букв, остальные слова – со строчных. Поменять местами эти
два имени и вывести результат.
6. Дана строка, где упомянуто несколько имён. Все имена начинаются
с прописной буквы, остальные слова – со строчных. Выписать все имена,
встречающиеся в строке, в алфавитном порядке.
7. Даны координаты нескольких точек на плоскости. Отсортировать их
в порядке возрастания суммы их абсцисс и ординат.
8. Вывести числа от 1 до n в порядке убывания числа делителей. Числа
с равным количеством делителей вывести в порядке убывания.

38
 СПИСОК РЕКОМЕНДУЕМОЙ ЛИТЕРАТУРЫ

Основной
The Python Tutorial – Python 3.7.4 documentation. [Electronic resource]. –
2019. – Mode of access: https://docs.python.org/3.7/tutorial/ – Date of access:
31.08.2019.
Мусин, Д. Самоучитель Python / Д. Мусин [Электронный ресурс]. – 2017
Режим доступа: https://pythonworld.ru/uploads/pythonworldru.pdf – Дата до-
ступа: 31.08.2019.
Самоучитель Python. [Электронный ресурс]. – 2019 – Режим доступа:
https://pythonworld.ru/samouchitel-python – Дата доступа: 31.08.2019.
Златопольский, Д. М. Основы программирования на языке Python /
Д. М. Златопольский – М. : ДМК Пресс, 2017. – 284 с.
Дополнительный
Лутц, М. Изучаем Python. / М. Лутц; пер. с англ. – 4-е изд. – СПб.: Сим-
вол-Плюс, 2011. – 1280 с.
Федоров, Д. Ю. Программирование на языке высокого уровня Python :
учеб. пособие для прикладного бакалавриата / Д. Ю. Федоров. – 2-е изд.,
перераб. и доп. – М. : Юрайт, 2019. –161 с. – (Серия: Бакалавр. Прикладной
курс).
Питонтьютор. [Электронный ресурс]. – 2019 – Режим доступа:
https://pythontutor.ru/ – Дата доступа: 31.08.2019.
Бесплатные курсы. Python 3 для начинающих и чайников [Электронный
ресурс]. – 2019 – Режим доступа: https://pythonworld.ru/kursy/free.html –
Дата доступа: 31.08.2019.

39
 СОДЕРЖАНИЕ

ВВЕДЕНИЕ ...................................................................................................... 3
Тема 1. ОСНОВНЫЕ ОБЪЕКТЫ ЯЗЫКА PYTHON.
ОСНОВНЫЕ ОПЕРАЦИИ ............................................................................. 5
Тема 2. СТРОКИ. ОПЕРАЦИИ НАД СТРОКАМИ ..................................... 8
Тема 3. КОНСОЛЬНЫЙ ВВОД И ВЫВОД. ПРИВЕДЕНИЕ
К ДРУГОМУ ТИПУ ДАННЫХ. ФОРМАТИРОВАНИЕ СТРОК ............ 13
Тема 4. УСЛОВНЫЕ ОПЕРАТОРЫ............................................................ 17
Тема 5. СПИСКИ ........................................................................................... 19
Тема 6. ОПЕРАТОРЫ ЦИКЛОВ.................................................................. 24
Тема 7. КОРТЕЖИ......................................................................................... 30
ЗАДАНИЯ ДЛЯ САМОСТОЯТЕЛЬНОЙ РАБОТЫ ................................. 33
Пояснения к заданиям для самостоятельной работы .......................... 33
КОНТРОЛЬНАЯ РАБОТА № 1 ................................................................... 36
КОНТРОЛЬНАЯ РАБОТА № 2 ................................................................... 37
КОНТРОЛЬНАЯ РАБОТА № 3 ................................................................... 38
СПИСОК РЕКОМЕНДУЕМОЙ ЛИТЕРАТУРЫ ....................................... 39

40
 Учебное издание

Шолтанюк Станислав Витальевич

ОСНОВЫ
ПРОГРАММИРОВАНИЯ
НА ЯЗЫКЕ PYTHON

Методические указания
и контрольные работы
по информатике
для учащихся 7–11 классов

В авторской редакции

Ответственный за выпуск В. В. Казаченок

Подписано в печать 05.09.2019. Формат 60×84/16. Бумага офсетная.

Усл. печ. л. 2,32. Уч.- изд. л. 1,68. Тираж 50 экз. Заказ

Белорусский государственный университет.

Свидетельство о государственной регистрации издателя, изготовителя,
распространителя печатных изданий № 1/270 от 03.04.2014.
Пр. Независимости, 4, 220030, Минск.

Отпечатано с оригинал-макета заказчика

на копировально-множительной технике
факультета прикладной математики и информатики
Белорусского государственного университета.
Пр. Независимости, 4, 220030, Минск.