/
Автор: МакГрат М.
Теги: программирование на эвм компьютерные программы программирование информационные технологии языки программирования компьютерные технологии
ISBN: 978-5-04-213835-5
Год: 2025
Текст
PY
• ЦВЕТНОЕ ИЗДАНИЕ
•ЧЕТКИЕ ПОШАГОВЫЕ
ИНСТРУКЦИИ
• СОЗДАЙТЕ ПРОГРАММУ
С НУЛЯ
• ОПЫТ В РАЗРАБОТКЕ
НЕНУЖЕН
ПРОГРАММИРОВАНИЕ
ДЛЯ НАЧИНАЮЩИХ
------ОСНОВНЫЕ ПРИНЦИПЫ
Майк МакГрат
ПРОГРАММИРОВАНИЕ
ДЛЯ НАЧИНАЮЩИХ
Mike McGrath
PY
CODING
FOR BEGINNERS
-- - IN EASY STEPS
Майк МакГрат
• ЦВЕТНОЕ ИЗДАНИЕ
• ЧЕТКИЕ ПОШАГОВЫЕ
ИНСТРУКЦИИ
• СОЗДАЙТЕ программу
С НУЛЯ
• ОПЫТ В РАЗРАБОТКЕ
НЕ НУЖЕН
U
ОСНОВНЫЕ ПРИНЦИПЫ
БОМБОРА
ИЗДАТЕЛЬСТВО
Москва
УДК 004.42
ББК .32.973.2-018
М15
CODING FOR BEGINNERS:
MODERN PROGRAMMING FOR ALL AGES
2nd Edition
by Mike McGrath
Copyright a 2022
Translated and reprinted under a licence agreement from the Publisher: In Easy Steps, 16 Hamilton Terrace,
Holly Walk. Leamington Spa. Warwickshire. U.K. CV32 4LY
МакГрат. Майк.
M15 Программирование для начинающих : основные принципы / Майк
МакГрат ; [перевод с английского В. В. Краснянской]. — 2-е издание. —
Москва: Эксмо, 2025. — 192 с. — (Программирование для начинающих).
ISBN 978-5-04-213835-5
Открывать новое бывает непросто, но с «Программированием для начинаю-
щих» вы легко погрузитесь в мир ПТ даже при отсутствии опыта. Следуйте понят-
ным инструкциям, выполняйте интересные практические задания. Внутри есть
вся необходимая информация, рассмотрены ключевые концепции разработки
и подобраны наглядные цветные примеры. Вы научитесь: писать программный
код на Python, хранить информацию в структурах данных и создавать алгоритмы
в рамках объектно-ориентированного программирования. Смело воплощайте
свои идеи в код!
УДК 004.42
ББК 32.973.2-018
ISBN 978-5-04-213835-5
© Краснянская В. В., перевод на русский язык. 2025
© Оформление. ООО «Издательство «Эксмо», 2025
2
3
Содержание
Начнем! 9
Программный код 10
Установка и настройка Setting Up 12
Знакомство с IDLE 14
Справочная служба 1G
Сохранение программ 18
Хранение переменных 20
Добавление комментариев 22
Правила именования 23
краткие итоги 24
Сохранение данных 25
Хранение данных ввода 26
Управление данными на выходе 27
Распознавание типов данных 2.8
Преобразование типов данных 30
Игра-угадайка 32
Исправление ошибок 34
Краткие итоги 36
Выполнение операций 37
Выполнение арифметических действий 38
Присваивание значений 40
Сравнение значений 42
В поисках истинности 44
Провеока условий 46
Порядок выполнения действий 48
Краткие итоги 50
Работа со списками 51
Создание списков 52
Изменение списков 54
Неизменяемые списки 56
Список с уникальными значениями 58
Именованные элементы списка 60
Краткие итоги 62
Блоки управления 63
Ветвление и выборы 64
Циклы со сче)чиком 66
Циклы с условием 68
11ропуск итерации 70
Ловим ошибки 72
Краткие ито!и 74
Создание функций 75
Объявление функций 76
Добавление параметров 78
Возврат результатов 80
Сохранение функций 82
Импорт функций 84
Краткие ию!и 86
Алгоритмы сортировки 87
Сортировка с копированием 88
Сортировка выбором 90
Сортировка вставками 92
Сортировка пузырьком 94
Сортировка слиянием 96
Сортировка с разделением 98
краткие итоги 100
Python в подробностях 102
Математические расчеты 104
Вычисления с десятичными дробями 106
Котооый час? 108
Запуск таймеров 110
Краткие ит01 и 112
Управление текстом 113
Обработка строк 114
Форматирование строк 116
Изменение строк 118
Доступ к файлам 120
Обработка содержимого файлов 122
Обновление содержимого файлов 124
Краткие итоги 126
10 Программные объекты 127
Объявление классов 128
Копирование экземпляров классов 130
Обращение к свойствам классов 132
наследование классов 134
Переопределение методов 136
Действовать схожим образом 138
Краткие итоги 140
11 Создание интерфейсов 141
Запуск интерфейсов 142
Реагирующие кнопки 144
вывод сообщений 146
Сбор входных данных 148
Список опций 150
Радиокнопки 152
Флажки или чекбоксы 154
Добавление изображений 156
Краткие итоги 158
12 Разработка приложений 159
Генерация случайных чисел 160
Планирование готребностей 162
Разработка компоновки виджетов 164
Работа со статикой 166
Загоузка динамических данных 167
Добавление функционала 168
Тестирование программ 170
Внедрение приложений 172
Краткие итоги 174
ЯЬь
13 Расширяя навыки 175
Что такое компиляторы 176
Компиляция кода 178
Код на С 180
Код на С+н 182
Код на C# 184
Код на Java 186
Краткие итоги 188
L Предметный указатель 189
Как пользоваться этой книгой
Эта книга дала мне, Майку МакГрату, уникальную возможность — познакомить
с разработкой программ читателей, у которых нет никакого опыта программирования.
Это издание предназначено для начинающих, но выходит за рамки минимального
набора понятий, поэтому, возможно, некоторые темы легче понять после того, как
у читателя появится некоторый опыт разработки простых программ, перечисленных
в книге. В примерах иллюстрируются характерные особенности работы с кодом па
примере популярного языка программирования Python,
Условные обозначения, принятые в книге
Чтобы приведенный в каждом примере код выглядел понятным на каждом шаге,
я применил систему цветовых условных обозначений, которая по умолчанию
используется в редакторе кода Python. Ключевые слова языка программирования
выделены оранжевым цветом, названия стандартных функций — фиолетовым,
функции, названия которым дал разработчик, — синим, текстовые строки — зеленым,
комментарии — красным, а весь остальной код — черным:
# Функция для вывода на экран приветствия
def greet( reader ) :
printf 'Welcome to Coding for Beginners in easy steps*, reader)
Дополнительно для того, чтобы обозначить каждый описанный
в пошаговых инструкциях файл с исходным кодом, на полях рядом с ним
указаны значки и имена файлов (см. илл. справа).
prograrr.py
Скачивание исходного кода
Для удобства я поместил в один zip- архив все файлы с исходным кодом из примеров,
приведенных в этой книге. Вы можете скачать весь архив, следуя этим простым шагам:
Пройдите по адресу www.ineasysteps.com, затем перейдите на Free Resources
(Бесплатные ресурсы) и выберите раздел Downloads (Загрузки).
Найдите в списке название книги Coding for Beginners in easy steps, 2nd edition,
перейдите по ссылке и, чтобы загрузить архив, нажмите на ссылку All code
examples (Все примеры кода).
Затем распакуйте содержимое архива в любом удобном месте на вашем
компьютере.
На приведенных в книге скриншотах показаны реальные результаты
выполнения приведенного в шаге кода. Если у вас не получился
результат, описанный в примере, просто сравните ваш код с образцом
из файла, который вы загрузили, и найдите, где ошиблись.
Начнем!
10 Программный код
гшжалмлть 12 Установка и настройка
14 Знакомство с IDLE
программирования! 1 £
В этой главе
18
рассказывается
Справочная служба
Сохранение программ
о там, кап саздать
гео*) 4<»б<таенную
ipedy разработки
20 Хранение переменных
22 Добавление комментариев
и написать первую 23 ПрЭВИЛЭ ИМеНОВЗНИЯ
программу.
24 Краткие итоги
Программный код
Компьютер — это всего лишь машина, которая может
очень быстро обрабатывать простой набор команд.
Такой набор инструкций и называется программой,
а сами инструкции — кодом.
Людей, которые пишут компьютерные программы,
называют программистами или разработчиками.
Именно их работа делает компьютеры полезными
практически в каждой сфере современной жизни.
В руках — компьютеры находятся в мобильных
устройствах, чтобы мы могли общаться
с помощью голосовой связи, текстовых сообщений
и социальных сетей.
В доме — компьютеры находятся в таких бытовых
приборах, как телевизоры, игровые приставки
и стиральные машины.
В офисе — компьютеры находятся в настольных
устройствах, служащих для обработки
текстов, составления зарплатных ведомостей
и графического дизайна.
В магазине — компьютеры находятся в устройствах
для розничной торговли, таких как автоматические
кассовые аппараты и сканеры штрихкодов.
В автомобиле — компьютеры находятся
в устройствах управления, отвечающих за работу
двигателя, антиблокировочную систему
и безопасность.
В небе — компьютеры находятся в самолетах,
осуществляя пилотирование, а также в диспетчерских
центрах, управляющих воздушным движением.
Это еще далеко не все примеры того, как компьютеры
влияют на современную жизнь. Но на самом деле
компьютеры очень глупы! Они совершенно не могут
думать сами.
Компьютер — это всего лишь набор электронных
компонентов, которые обычно называют «аппаратным
обеспечением» или «железом». Чтобы компьютер что-то
делал, ему нужно выдать программные инструкции,
то есть «программное обеспечение».
Важно, чтобы у каждой машины были четкие пошаговые
инструкции, которые компьютер можег выполнить без
ошибок. Таким образом, разработчик должен разбить
задачу на простые недвусмысленные шаги. Например,
программа движения мобильного робота из помещения
на улицу должна включать в себя инструкции,
позволяющие роботу обнаружить дверной проем и обойти
любые препятствия. Поэтому разработчик должен всегда
принимать во внимание все возможные неожиданные
трудности, с которыми может столкнуться программа.
Программные инструкции следует предоставлять
компьютер) на языке, который он может понять.
На самом простом уровне компьютер способен
воспринимать «машинный код», перемещающий
элементы памяти так, чтобы машина могла выполнить
поставленные задачи. С этим неудобочитаемым
низкоуровневым кодом очень утомительно работать,
поскольку для того, чтобы компьютер справился с самой
простой работой, требуется множество строк инструкций.
К счастью, с течением времени появилось
большое количество высокоуровневых языков
программирования, позволяющих разработчику
составлять инструкции в более понятной для человека
форме. Компилятор или интерпретатор автоматически
переводит эти современные высокоуровневые
программы в машинный код, понятный для
компьютера. Чтобы стать разработчиком, вам нужно
изучить по крайней мере один из перечисленных ниже
высокоуровневых языков программирования:
С — мощный компилируемый язык
программирования, точно отражающий
машинный код и использующийся для разработки
операционных систем.
C++ — усовершенствованный компилируемый
язык программирования, разработанный
на основе С с поддержкой классов для объектно-
ориентированного программирования (ООП).
C# — современный компилируемый язык
программирования, разработанный компанией
Microsoft для программной платформы. NET Framework
и спецификации обшеязыковой инфраструктуры
(Common Language Infrastructure, CLI).
Java — переносимый компилируемый язык,
разработанный для того, чтобы работать на любой
платформе независимо от архитектуры аппаратного
обеспечения.
Python — динамически интерпретируемый
язык программирования, допускающий как
функциональное, так и объектно-ориентированное
программирование.
У всех естественных языков, на которых люди говорят
между собой, можно найти определенное сходство —
например, в них есть iлаголы и существительные.
Так и в языках программирования имеются схожие
особенности: в каждом из них имеются «структуры данных»
для хранения информации и «структуры управления»,
определяющие то, как программа выполняется.
В этой книге я привожу примеры, показывающие,
как писать компьютерные программы, используя
язык программирования Python, поскольку он имеет
простой синтаксис, не требует компиляции, включает
мощную библиотеку стандартных функций и может
использоваться как для консольных программ, так
и для многооконных приложений с графическим
пользовательским ин герфейсом.
Программы, написанные
на интерпретируемом
языке, можно запустить
сразу, но программы на
компилируемых языках
вначале должны быть
скомпилированы.
В целом Python — это
продукт, поставляемый
в полном комплекте, по
принципу «батарейки
поилагаготся»
Установка и настройка
Прежде чем вы сможете писать программы на Python,
необходимо установить на компьютер среду разработки,
в том числе интерпретатор Python и стандартную
библиотеку модулей кода, поставляемую вместе
с интерпретатором. Все это можно за1рузить бесплатно
на странице Python Software Foundation.
Запустите браузер и перейдите на страницу
python.org/downloads, затем
нажмите кнопку Download
(Загрузить), чтобы загрузить
последнюю версию для вашей
операционной системы.
В данном примере мы
используем инструмент установки для Windows
из файла под названием python-3.10.4-amd64.exe.
Инструменты для
установки Python на macOS
и других платформах
также бесплатно доступны
на python.org/downloads.
Когда загрузка закончится, найдите в папке
Downloads (Загрузки) исполняемый файл
с расширением .ехе и запустите его, в результате
чего появится диалоговое окно установки.
СО^'
После добавления
Python в системную
переменную Path язык
программирования
становится доступным
из любого каталога.
Завершив установку,
вы можете ввести
в командной строке
команду python -V
и увидеть ответ
интерпретатооа
и его версию.
Python 3. ЮЛ (Ы-ЬЙ) Setup
Include* CLF pip and documentation
CtcUet tJwrtCut* and file MtociMion*
Install Now
C.\lke«'knA*_\AppD»u\lo<*hP«>g<*iw\Pytbo rtXPyihonl 10
Install Python 3.10.4 (64 bit)
detect Install Now to tnsial Python with default settings or choose
Customize to enable or disable features.
python
for
windows
-> Customize installation
Cbocn* kxationand ftifo»ts
0 instal Jaunener for al users (recommended)
Я Ana Д.Ч to PAir-
О
о
Далее не забудьте отметить опцию Add Python
3.10 to PATH (Добавить Python 3.10 в системную
переменную PATH).
Теперь нажмите Customize installation
(Настроить параметры установки), чтобы
открыть диалоговое окно Optional Features
(Дополнительные функции) и выбрать
необходимые параметры.
0
Нажмите Next (Далее), чтобы открыть диалог
дополнительных параметров Advanced Options,
и выберите там Associate files (Ассоциированные
файлы), Create shortcuts (Создавать ярлыки)
и Add Python to environment variables (Добавить
Python к переменным среды).
Python 3.104 (64-ЬЙ) Setup - X
python
for
windows
Optional Features
О jjpcurrwntatiorj
Installs th* Python documentation fil*.
ffP
Installs рф. те* ch c*n download and mi tab oth*r Python paCutgts.
td/tfc mdlDtE
Insults tkintar and th* IDLE d*vWBpm*m arrvironmanL
Q Python i«t cult*
InttaMs th* itandare ebrary tact curt*. "
О py launcher О for al users (r*qu<w elevation
Installs the global 'p/ launcher to make it easier to start Python.
Ыел к £anen
Убедитесь, что вы
установили менеджер
управления пакетами
pip. Далее в книге мы
будем им пользоваться,
чтобы установить
пакет Pylnstaller,
с помощью которого
вы сможете создавать
распространяемые
приложения.
Выберите место установки в каталог
C:\Python, затем нажмите кнопку Install
(Установить).
Если вам предложат, выберите опцию
Disable path length limit (Отключить
ограничение длины пути), чтобы избежать
каких-либо проблем с путями.
Чт обы завершить установку Python, нажмите
кнопку Close (Закрыть).
После завершения
установки в меню
Start/All Apps
(Пуск/Все приложения)
добавится группа
Python. Самое важное
приложение в этой
группе — IDLE (Python
Integrated DeveLopment
Environment),
запускающее
интегрированную среду
разработки Python.
All apps
Python 3.10 (64-bit)
New
Python 3.10 Manuals (64-bit)
New
Python 3.10 Module Docs (64-bit)
New
Python 3.10
New
IDLE (Python 3.10 64-bit)
New
Вы часто будете
пользоваться IDLE, так что
нажмите на ярлык правой
кнопкой мыши и выберите
«Дополнительно ->
Закрепить на панели
задач», чтобы программу
было проще найти
на рабочем столе Windows.
Знакомство с IDLE
В установленный пакет программного обеспечения
Python входит среда разработки Integrated Development
Environment (IDLE), где вы с легкостью можете писать
код и запускать программы или фрагменты кода,
написанные на Python. IDLE фактически состоит из двух
частей, предназначенных для программной разработки:
Интерактивная оболочка Shell.
Редактор кода.
После запуска IDLE открывается новое окно, где вы
можете видеть строку меню, заголовок, где указана
версия ПО, и строку »>. Это интерактивная оболочка
Shell, где можно взаимодействовать непосредственно
с интерпретатором Python, вводя команды в строку.
строка меню
заголовок с указанием
версии программы
интерактивная
командная строка
В большинстве языков
программирования
текстовые строки требуется
заключать в кавычки, чтобы
отделить от программного
кода. Обычно Python-
разработчики используют
одинарные кавычки.
Если интерпретатор поймет строку, которую вы ввели,
он даст соответствующий ответ, в ином случае —
сообщит об ошибке.
Интерпретатор может вывести строку текста, если
использовать в командной строке функцию Python
с именем print(). Текст вводится внутри скобок
со знаками кавычек с обеих сторон.
Также интерпретатор может вывести результ аты
простых арифметических действий, если ввести
в командную строку правильное выражение.
Если же выражение будет неправильным, например
таким, где число пытаются делить на 0, интерпретатор
выдаст ошибку, где будет подробно описана суть
возникшей проблемы.
Откройте интерактивную командную строку
и точно введите в нее следующее выражение:
print( Hello World#*)
Далее нажмите на клавишу ввода, чтобы
увидеть ответ интерпретатора.
(_0®еЛ
Теперь введите в командную строку выражение
суммы:
8 + 4
Пробелы в выражениях
игнорируются. С таким
же успехом вы можете
ввести выоажение 8+4
без пробелов.
Нажмите ввод, и вы увидите, что интерпретатор
выведет результат.
Введите в командную строку неверное
выражение:
8/0
Нажмите ввод, и интерпретатор выведет
сообщение об ошибке.
Интерактивная оболочка
Shell чаще всего
используемся для
проверки фрагментов кода.
Справочная служба
В интерактивной оболочке Shell имеется прекрасная
справочная служба, где Python-разработчик может
найти информацию по любой теме, связанной
с программированием на Python. Вызвать эту
справочную службу можно, написав в командной
строке >» help(). Появится приветственное сообщение,
и строка будет начинаться с help>, указывая, что
программа теперь находится в справочном режиме.
О
Откройте интерактивную оболочку' Shell
и точно введите в командную строку следующее
сообщение:
help()
Далее нажмите клавишу ввода, чтобы перейти
в справочный режим.
Приветственное сообщение
справочной службы также
содержит полезные советы,
но сейчас мы не будем на
них останавливаться для
краткости.
О
Теперь введите в командную строку название
следующей темы:
keywords
Ключевые слова —
это словарь языка
программирования.
Заметим, что в Python
регисто имеет значение
при вводе ключевых
слов. Все они пишутся
со строчной буквы, за
исключением False, None
и True
Нажмите ввод, и вы получите список всех
ключевых слов языка программирования Python.
о
Теперь введите в командную строку справочной
службы слово quit.
О
Нажмите клавишу ввода, чтобы выйти из
справочной службы, и вернитесь в командную
строку интерактивной оболочки Shell.
После инструкции quit
круглые скобки не нужны,
поскольку это команда
справочной службы,
а не выражение языка
программирования Python.
Если у вас возник вопрос по какой-то конкретной
теме, вы можете просто ввести ее название без кавычек
внутри скобок в выражении help() в командной строке.
О
Точно введите это выражение в командную
строку:
help( )
О
Нажмите клавишу ввода, и вы получите список
всех ключевых слов языка программирования
Python. При этом вы останетесь в командной
строке интерактивной оболочки Shell.
Ключевые слова имеют
особое значение в языке
программирования Их
нельзя использовать для
названия объектов в коде.
Сохранение программ
Описанная здесь процедура
будет использоваться для
демонстрации примеров
кода на протяжении всей
книги.
Интерактивная оболочка Shell, описанная на страницах
14-15, хорошо подходит для того, чтобы попробовать
написать маленькие кусочки кода, но сохранить
программу в ней не получится. К счастью, в IDLE
также имеется редактор кода, где можно создавать
более длинные программы, которые можно сохранить
в файлах с расширением ,ру на компьютере. Это
означает, что вы сможете легко перезапустить код, не
набирая заново все инструкции в командной строке
оболочки Shell, а также сможете редактировать свои
программы, если у вас появятся новые идеи. Процедура
создания, сохранения и запуска кода выглядит
следующим образом:
Открыть окно редактора можно из окна
интерактивной оболочки Shell, выбрав пункты
File -> New File (Файл -» Новый файл) из строки
меню или нажав «быстрые» клавиши Ctrl + N.
Наберите код в окне редактора, затем сохраните
написанное, выбрав пункты File -» Save (Файл ->
Сохранить) в строке меню редактора или нажав
«быстрые» клавиши Ctrl + S.
Запустите сохраненный код из редактора, выбрав
в меню Run > Run Module (Запустить -» Запустить
модуль) или нажав клавишу быстрого доступа F5.
Если программа запустится, результат ее работы
появился в окне интерактивной оболочки Shell. Если же
интерпретатор обнаружит ошибки в коде, вы увидите
сообщение об ошибке.
Откройте окно интерактивной оболочки Shell
и выберите пункт меню File -» New File (Файл
Новый файл), чтобы запустить окно редактора
кода.
Отметим, что пункты
меню File, Орел (Файл ->
Открыть), File, Open Module
(Файл -> Открыть модуль)
и File, Recent Files (Файл
Недавние файлы) можно
также использовать для
запуска ранее сохраненного
кода программы.
Теперь в окне редактора IDLE точно введите
следующую строку кода:
printf V )
helloworld.ру
Далее в том же окне редактора IDLE
выберите пункты меню File -> Save (Файл ->
Сохранить), чтобы открыть диалоговое окно
Save As (Сохранить как), затем сохраните код
программы как файл с именем helloworld.ру.
Наконец, в окне редактора IDLE выберите
пункты меню Run -> Run Module (Запустить >
Запустить модуль), чтобы запустить код
программы и увидеть результат, который
появится в окне интерактивной оболочки Shell.
Код npoi раммы можно
сохранить в любом
удобном месте в памяти
компьютера. В данном
примере он сохраняется
в каталоге, созданном на
диске C:\MyCode, который
будет использоваться
в примерах на протяжении
всей книги.
Отметим, что
интерактивная оболочка
Shell запускается
каждый раз, когда
в ней выполняется код
программы.
Хранение переменных
При статической
типизации тип переменной
проверяется во воемя
компиляции, а при
динамической типизации
в Python гип переменной
провеояется во воемя
выполнения программы.
Одна их важнейших особенностей всех языков
программирования — возможность сохранять значения
данных через код программы. Сделать это позволяет
простая структура данных под названием «переменная».
Она представляет собой нечто вроде контейнера, где
можно сохранить объект данных, как, скажем, какую-то
вещь из реального мира можно хранить в коробке.
Создавая переменную, вы даете ей название по своему
выбору, соблюдая соглашение об именовании, принятое
в том или ином языке программирования, и это название
служит чем-то вроде этикетки на коробке. В дальнейшем
единицу данных, сохраненную в переменной, можно
отыскать так же, как мы находим вещь в реальной жизни,
читая этикетку на коробке, где она лежит.
В программе на Python данные, хранящиеся
в переменной, можно определить с помощью оператора
присваивания Например, для того, чтобы сохранить
числовое значение «восемь» в переменной «а», мы пишем:
а = 8
Сохраненное значение можно найти с помощью
имени переменной, поэтому в результате выполнения
команды print(a) выводится сохраненное значение
8. Впоследствии переменной можно присваивать
другие значения, так что ее значение может меняться
в процессе выполнения программы, на что и указывает
само название термина «переменная».
В языке программирования Python переменной должно
быть приписано начальное значение (опа должна
быть инициализирована), иначе ее значение останется
неопределенным, и интерпретатор сообщит об ошибке
«значение не определено».
В одном выражении можно инициализировать сразу
несколько переменных с общим значением. Эю
делается с помощью последовательности операторов
присваивания =. Например, переменные а, b и с,
каждая из которых имеет числовое значение 8, можно
инициализировать через следующее выражение:
а = b = с = 8
В некоторых языках программирования, таких как Java,
при объявлении переменной требуется указать, какого
типа данные она может содержать. Таким образом, для
переменной резервируется определенное количество
памяти. Эта особенность называется статической
типизацией. В Python же таких ограничений нет,
и выделение памяти подстраивается так, чтобы
подходить к различным типам данных, которые могут
быть приписаны переменной (динамическая типизация).
Следовательно, в переменных могут храниться целые
числа, числа с плавающей точкой (с дробной частью,
отделенной от целого десятичной точкой), текстовые
строки или булевы значения True или False.
Откройте окно редактора IDLE и введите код,
чтобы создать переменную «var», в которой
будет храниться целое число:
var = 8
О
о
о
0
0
Далее добавьте выражение, чтобы вывести на
экран сохраненное целочисленное значение:
printf var)
Присвойте переменной числовое значение
с плавающей точкой, затем добавьте выражение,
чтобы вывести на экран сохраненное значение:
var = 3.142
print( var )
Присвойте переменной текстовое строковое
значение, затем добавьте выражение, чтобы
вывести на экран сохраненное значение:
var = 'Coding for Beginners in easy steps'
print( var )
Наконец, присвойте переменной логическое
значение истины, затем добавьте выражение,
чтобы вывести на экран сохраненное значение:
var = True
print( var )
Сохраните файл (File -> Save), затем
запустите программу (Run -> Run Module),
чтобы посмотреть, как в результате ее
работы в командной строке будут выведены
сохраненные значения
firstvar ,ру
Текстовые строковые
данные должны
заключаться в кавычки,
чтобы вь.делигь конец
и начало отдельной строки.
Начнем'
Добавление комментариев
При написании более длинных программ полезно
добавлять в начале каждой части кода комментарии,
описывающие, что именно происходит в том или ином
отрывке программы. Это делает код более понятным для
других людей и для вас самих, если вы спустя какое-то
время вернетесь к нему. В языке программирования
Python интерпретатор игнорирует всю строку,
находящуюся после символа решетки #. Это означает,
что однострочный комментарий можно вставить после
этого символа.
comment.ру
Откройте редактор кода IDLE, затем введите
закомментированный код, инициализирующий
переменную и выводящий ее значение:
# Инициализация статуса программы
running = True
print( , running)
Сохраните файл, затем запустите программу,
и вы увидите, что комментарий игнорируется,
а сохраненное значение выводится в результатах
работы.
Чтобы с легкостью распознавать различные части
кода, IDLE автоматически отображает их различными
цветами как в интерактивной оболочке Shell, так
и в окне редактора. Цвета по умолчанию перечислены
в таблице ниже:
В коде, приведенном, на
страницах этой книги,
для единообразия
используются те же цвета,
что и в IDLE по умолчанию.
Названия встроенных функций
Строки в кавычках
Символы, числа и названия
Ключевые слова
Описание
Комментарии в окне редактора
Ошибки в командной строке Shell
Вывод резулыатов в командной
строке Shell, созданные
разработчиком названия при
объявлении функций
print()
'Hello Worldl'
Hello World!
my_function()
True
b Му comments
Zero division Error
I Правила именования
False None True
and as assert
async await break
class continue def
del ehf else
except finally for
from global if
import in is
lambda nonlocal not
or pass raise
return try wmle
with yield
Хороший тон
в программировании —
давать значимые названия,
отражающие сущность
содержимого переменных.
Вы можете давать переменным, которые создаете в коде
для хранения информации, любые названия, но при этом
не должны использовать какие либо ключевые слова языка
программирования, то есть все ключевые слова Python,
перечисленные в таблице выше. 1акже название должно
соответствовать правилам именования, приведенным
в таблице ниже:
Правило именования Пример
HE МОЖЕТ Е>ЫТЬ ключевым словом True
НЕ МОЖЕТ содержать арифметические операторы a+b*c
НЕ МОЖЕТ содержать символы
НЕ МОЖЕТ содержать пробелы no spaces
НЕ МОЖЕТ начинаться с цифры 2bad
МОЖЕТ содержать цифры в любом месте, кроме начала goodl
МОЖЕТ содержать заглавные и строчные буквы UPdown
МОЖЕТ содержать подчеркивания is_ok
В Python имена переменных
чувствительны к регистру.
Переменные VAR, Var и var
будут восприниматься как
различные переменные.
Краткие итоги
Компьютерная программа — это набор написанных
разработчиком инструкций, делающих компьютеры
полезными.
Электронные компоненты компьютера называются
аппаратным обеспечением, а программные
инструкции — программным обеспечением (ПО).
Компьютеры понимают низкоуровневый
машинный код.
Высокоуровневые языки программирования
имеют удобную для понимания людей форму. Они
автоматически транслируются в низкоуровневый
машинный код.
Языки программирования имеют структуры
данных, чтобы хранить информацию, и структуры
управления, определяющие то, как программа
выполняется.
В языке программирования Python простой
синтаксис, он не требует компиляции вручную
и включает в себя библиотеку функций.
Среда разработки на Python называется IDLE
(Integrated DeveLopment Environment).
В IDLE имеется интерактивная оболочка Shell
с командной строкой для тестирования и редактор
кода для написания программ
Доступ к справочной службе IDLE можно
получить, если ввести в командную строку
интерактивной оболочки Shell команду help().
После того как вы наберете код в окне редактора
IDLE, написанное нужно вначале сохранить как
файл, а уже потом можно запустить программу.
После выполнения программы, запущенной в окне
редактора, результат ее работы появляется в окне
интерактивной оболочки Shell. Если программа
не выполняется, вы увидите подробное сообщение
об ошибке.
Переменная — это именованный контейнер,
позволяющий хранить отдельную единицу данных
для использования программой.
Данные, сохраненные в переменных, можно найти
с помощью имен переменных. Их можно заменить,
присвоив переменным новые значения.
Переменные в программах на Python могут хранить
данные любого типа.
К протраммному коду полезно добавит ь коммент арии,
которые начинаются с символа решетки #.
Имена переменных не должны содержать ключевые
слова языка программирования и должны
соответствовать правилам именования.
Сохранение
данных
В этой главе
26 Хранение данных ввода
показано, как
создавать код для
использования
27 Управление данными на выходе
28 Распознавание типов данных
различных
типов данных,
хранящихся
30 Преобразование типов данных
32 Игра-угадайка
в программе.
34 Исправление ошибок
36 Краткие итоги
Сохранение данных
cD
ГМ
input.ру
Не обязательно добавлять
пробелы в разделенный
запятыми список:
интерпретатор их
игнооирует. Здесь пробелы
показаны для наглядности.
Хранение данных ввода
Способность сохранять и заменять вложенные
в программу данные внутри переменной — это
прекрасно, но ее можно использовать и для того,
чтобы хранить данные, введенные пользователем, что
позволяет программе быть интерактивной.
В языке программирования Python можно использовать
встроенную функцию inputf), чтобы принять введенные
пользователем данные с клавиатуры и присвоить их
переменной. При необходимости в функцию можно
передать строку — в кавычках внутри круглых
скобок, — которая будет служить приглашением к вводу
данных. Программа будет ждать, пока пользователь
не нажмет клавишу ввода, а потом присвоит значение
переменной и продолжит работу.
Сохраненные значения переменных могут быть
выведены с помощью встроенной функции printf),
для чего имя переменной указывается внутри скобок
функции. Несколько значений можно указать внутри
скобок в виде разделенного запятыми списка.
Откройте окно редактора IDLE, затем введите
код, приглашающий пользователя ввести данные
для инициализации переменной:
name = inputf 'Пожалуйста, введите имя:')
Затем добавьте выражение, чтобы вывести
на экран строку и значение, сохраненное
в переменной:
printf ip , name )
Теперь добавьте выражение, чтобы вывести
еще одну строку, а затем — строку, к которой
с помощью конкатенации добавлено
сохраненное в переменной значение:
printf 'До )
printf 'Желаю как следует повеселиться*, name , 'Г)
Сохраните и запустите программу, введите свое
имя и нажмите клавишу ввода, чтобы увидеть
по,тученный на выходе результат.
& OLE Shell 3.10.4 -OX
File Edit Shell Debug Options Window Help
======== RESTART: C:\MyCode\inputpy =======
Please enter youi name: Mike
Hi Mike
Welcome to Coding tor Beginners in easy steps
Remember to have fun Mike I
Управление данными на выходе
Как видно из примера на предыдущей странице,
сохраненное в переменной значение остается доступным
для повторного использования, пока оно не будет заменено
другим значением или пока npoi рамма не завершит работу.
Есть еще два момента, которые следует отметить,
когда речь идет о результате работы программы из
приведенного выше примера. Во-первых, функция print()
автоматически добавляет невидимый символ перевода
строки \п после выходных данных, поэтому результат
выполнения следующей функции print() по умолчанию
появляется на следующей строке ниже. Во-вторых,
функция pnnt() автоматически добавляет пробел после
каждого элемента, если в качестве выходных данных
передается разделенный запятыми список переменных.
Избежать автоматического перехода на новую строку7
можно, если указать, что строка должна кончаться
пробелом, а не добавляемым по умолчанию символом
\п. От автоматического добавления пробелов можно
избавиться, если добавлять элементы с помощью
конкатенации, используя символ +, а не запятую.
От кройте окно редактора IDLE, затем введите
код, приглашающий пользователя ввести данные
для инициализации переменной:
name = input( 'Пожалуйста, введите имя: ')
О
concat.py
О
Затем добавьте выражение, чтобы вывести на экран
строку и значение, сохраненное в переменной, но
без добавления новой строки в конце:
print( + name , end = )
Теперь добавьте выражение, чтобы вывести
еще одну строку, а затем — строку, к которой
с помощью конкатенации добавлено
сохраненное в переменной значение:
print( 'Добро пожаловать')
print( 'Желаю как следует повеселиться + name + '!')
Сохраните и запустите программу, введите свое
имя и нажмите клавишу ввода, чтобы увидеть
полученный на выходе результат.
IDLE Shell 3.10.4
[J x
File Edit Shell Debug Options Window Help
»>
======= RESTART- C:\MyCode\concatpy =======
Please enter your name: Sally
Hi Sally - Welcome to Coding foi Beginners in easy steps
Remember to have fun Sally!
Отметим, что строки были
изменены, чтобы коасиво
отформатировать результат.
Сохранение данных
Распознавание типов
данных
В компьютерных программах встречаются
четыре основных типа данных, которые можно
сохранить в переменные. Хотя переменные в языке
программирования Python способны хранить
любой тип данных, важно понимать, что эти типы
могут отличаться, поэтому иногда вам придется
преобразовывать один тип данных в другой:
Описание Пример
данных
00
гм
Целые числа типа mt не
должны содержать каких-
либо знаков пунктуации.
Вписывайте в код одну
тысячу как «1000», а не как
«1.000» или «1,000».
str Строка символов, среди которых могут быть буквы, цифры, пробелы и другие символы 'Daytona 500*
int Целое число, в котором нет части, отделенной десятичной точкой или запятой 1000
float Число с плавающей точкой, у которого есть отделенная точкой или запятой десятичная часть 98.6
bool Булево логическое значение истины, может принимать значения True или False True
Строковые значения str
должны всегда заключаться
в кавычки.
Строки — это просто набор символов, которые вводятся
с клавиатуры компьютера и ограничиваются кавычками.
Переменные определяют, что присвоенное значение
принадлежит к «классу» str, именно по тому, что оно
находится в кавычках.
Числа — это любые числовые значения, которые
можно ввести с клавиатуры, но они разграничиваются
по наличию или отсутствию десятичной точки.
Переменные относят присвоенное значение к классу
int, если в нем нет десятичной точки. Если же точка
имеется, то значение относится к классу float.
Булевы значения — это логические значения истины.
Переменные относят присвоенное значение к типу bool
по ключевым словам True или False либо если значение
оценивается как True или False.
В языке программирования Python вы легко можете
определить тип данных, сохраненных в переменные,
передав имя переменной (указав его в скобках) во
встроенную функцию type().
о
о
Откройте окно редактора IDLE
и инициализируйте переменную, приписав ей
строковое значение, затем выведите на экран это
значение и тип данных:
race =
print( race , , type( race ))
Далее инициализируйте переменную, приписав
ей целочисленное значение, затем выведите на
экран эго значение и тип данных:
kilo = 1000
print( kilo , , type( kilo I )
datatypes.ру
О
о
о
о
Теперь инициализируйте переменную, приписав
в качестве значения десятичную дробь, затем
выведите на экран это значение и тип данных;
temp = 98.6
print( temp , , type( temp ) )
Инициализируйте переменную, приписав ей
логическое значение истины, затем выведите на
экран это значение и тип данных:
flag = True
print! flag , , type( Aa8 ))
Наконец, замените значение последней
переменной на неверный результат сравнения,
затем вновь выведите на экран это значение
и тип данных:
flag = 4 > 8
print! flag , , type( flag ))
Сохраните программу, затем запустите ее, чтобы
посмотреть, какие типы данных сохранены
в переменных, которые вы создали.
М
О
Рассмотренное выше
сравнение, где 4 больше
8, разумеется, не является
верным О сравнениях мы
более подробно поговорим
в главе 3
Сохранение данных
Преобразование типов
данных
Часто для того, чтобы произвести в программе какие-
то действия, например арифметические операции или
конкатенацию, необходимо преобразовать данные.
Арифметические действия возможны только для числовых
типов данных, таких как int или float, а конкатенация —
только для строковых данных, таких как str.
В Python имеется несколько встроенных функций,
позволяющих с легкостью преобразовывать различные
типы данных. Они не изменяют оригинальное конкретное
значение, но возвращают преобразованное представление
этого значения. В терминах программирования эта
операция называется приведением типов:
О
m
Функция Описание
int( х) Преобразует х в целое число
flcatf х) Преобразует х в число с плавающей точкой
str( х) Преобразует х в строку
Числовые значения в коде
не следует заключать
в кавычки-числа в казычках
воспринимаются как
строковые значения!
Результат арифметических
действий надданными
типа int и float
автоматически приводится
к типу float. Такое
преобразование позволяет
получать на выходе
десятичные дроби.
Числовые значения, вручную присвоенные переменным
в коде, автоматически относятся к соответствующему
типу данных int или float. Тем не менее значения,
присвоенные переменным пользователем в результате
работы встроенной функции inputf), всегда
автоматически относятся к строковым данным str,
даже если они являются числовыми значениями! Это
означает, что их придется преобразовать (привести)
в соответствующий числовой тип int или float до того,
как производить арифметические операции.
Верно и обратное: числовые значения, присвоенные
переменным вручную в коде, автоматически относятся
к типам int или float и не могут быть использованы при
конкатенации со строковыми значениями. Это означает,
что для соединения со строкой они должны быть
преобразованы в тип данных str.
В Python, как и во многих других языках
программирования, символ + может выполнять
различные функции в зависимости от контекста. Если
он используется между7 двумя числовыми значениями,
то выполняет операцию сложения (рассматривается как
«оператор сложения»), но если символ + используется
между двумя строковыми значениями, он выполняет
конкатенацию (рассматривается как «оператор
конкатенации»). Переменные, которым присваивается
результат той или иной операции, будут автоматически
отнесены к соответствующему типу данных.
о
о
о
о
о
о
Откройте окно редактора IDLE
и инициализируйте две переменные, приписав
им вводимые пользователем числовые значения:
numl= input( 'Пожалуйста, введите целое число: *)
num2= input( Теперь введите еще одно целое число:')
Далее выведите на экран тип каждой
переменной, чтобы убедиться: на самом деле
числовые значения сохраняются как строки:
print( , type( numl), type( num2 ))
Теперь используйте оператор +, чтобы
попытаться сложить числа и увидеть, что
результат конкатенируется как строковые
данные:
total = numl + num2
print( , total, type( total ) )
Снова используйте оператор +, чтобы сложить
числа, но выполните приведение типов
сохраненных значений и проверьте, относится
ли получившийся результат к типу int:
total = int( numl) + int( num2 )
printf , total, type( total ) )
Наконец, приведите сохраненные значения
к типу float и конкатенируйте полученное
в результате значение типа float со строкой
типа str, получившейся в итоге:
total = floatf numl ) + float( num2 )
printf + str( total ), type( total ))
Сохраните программу, затем запустите ее, чтобы
посмотреть, какие типы данных получились
после преобразования типов с помощью
встроенных функций.
iOlE Shell 3.104 - □ X
File Edit Shell Debug Options Window Help
======== RESTART C\MyCode\casLpy ========
Please entet a whole number: 3
Now enter another whole number 9
input is: cclass 'str'> cclass 'str'>
Total: 39 <class rstr'>
Total-12 <class 'int'>
Total: 12.0 <class ‘float’>
cast.py
Если вы забудете
выполнить приведение
к правильному типу
данных, интерпретатор
сообщит об ошибке. Чтобы
увидеть такое сообщение,
попробуйте прибавить
значение типа int к строке
str.
Сохранение данных
Игра-угадайка
CN
СП
guess.ру
Во многих языках
программирования для
того, чтобы группировать
инструкции, используются
такие символы, как
фигурные скобки {}, но
в Python для этой цели
применяются отступы,
поэтому показанные
в примере отступы должны
сохраниться в вашей
программе.
В приведенных выше простых примерах вы видели,
как можно использовать переменные для хранения
в программах текстовых строковых значений, целых
чисел, чисел с плавающей точкой и булевых логических
значений. Теперь мы используем их, чтобы создать
программу с игрой-угадайкой, где сохраняется
случайное целое число, чье значение должен угадать
пользователь. В конце игры появляется логическое
булево значение истины, если пользователь угадал
верно, и строка, содержащая его догадки.
Код этого примера включает некоторые особенности,
о которых мы будем говорить далее в этой книге,
но Python — простой для понимания язык
программирования, так что вы сможете понять, как
работает программа.
О
О
О
о
Откройте окно редактора IDLE. Начнем мы
с того, что Ихмпортпруем библиотечный класс
random, содержащий функцию для генерации
случайных чисел:
import random
Теперь инициализируем три переменных:
случайное число от ] до 20, булево значение,
которое будет оставаться True, пока игра
продолжается, и значение 0, которое будет хранить
количество попыток пользователя отгадать число:
num = random, randint) 1,20 )
flag = True
guess = 0
Далее выведем на экран обращенное
к пользователю приглашение отгадать число:
print) 'Отгадай число от 1 до 20: 1, end = ' )
Затем точно скопируйте этот код, где
предположения пользователя сравниваются
с сохраненным случайным числом:
while flag : # пока переменная flag сохраняет значение
True.
guess = input) )
if not guess.isdigit)) :
print) 'Ошибка! Вводите только числа от 1 до 20*)
break
elif int( guess ) < num :
print) 'Слишком мало, попробуйте еще раз:', end = )
elit int) guess ) > num :
print) 'Слишком много, попробуйте еще раз:', end = )
else :
print) 'Правильно, мое число ' + guess )
flag = False
Сохраните программу, затем запустите ее,
и вы сможете вводить числа и наблюдать, как
ваши догадки сравниваются с сохраненным
случайным числом.
ft IDLE Shell 3.10.4 - U X
File Edit Shell Debug Options Windom Help
======== RESTART: CAMyCodeXguess.py =======
Guess My Number 1-2C ten
Invalid! Enter only digits 1-20
>»
======== RESTART C:\MyCode\guess.py =======
Guess My Number 1-20 10 L
Invalidl Enter only digits 1-20
>»
======== RESTART: C:\MyCode\guess.py =======
Guess My Number 1-20 10
To > high, try again 5
Too low, try again 7
Too low, tiy again 8
Correct... My number is 8
>» I
Обратите внимание, что
программа отклоняет
пользовательский ввод,
когорь1Й не может быть
приведен к типу int.
Ln: 19 Col:0
Угадайка на Python — анализ программы
• В скобках функции randint() библиотечного класса
random определяется верхняя и нижняя граница
диапазона чисел.
• Переменная flag определяет первоначальное
условие программы, которое позволяет начать
анализировать данные, введенные пользователем.
• Ключевое слово while определяет структуру
управления под названием «цикл», которая
повторяет содержащиеся в ней инструкции, пока
указанное условие не перестанет выполняться.
• Проверка if not guess.isdigitf) определяет действие,
прерывающее (break) цикл, если введенные
пользователем символы не являются целым числом.
• Проверка elif int( guess ) < num определяет
альтернативное действие в том случае, если
пользователь ввел число меньше, чем сохраненное
случайное число.
• Проверка elif int( guess ) > num определяет
альтернативное действие в том случае, если
пользователь ввел число меньше, чем сохраненное
случайное число.
• Ключевое слово else определяет последнее
альтернативное действие, изменяющее условие
программы и таким образом завершающее ее
работу.
Вам не обязательно
понимать все детали этой
программы, каждую из
них мы будем разбирать
на примерах далее в этой
книге.
Ou
Сохранение данных
Исправление ошибок
Ошибки б программах
часто называют багами,
а процесс их поиска —
дебагом.
При написании программ встречаются три самых
распространенных вида ошибок. В программировании
на Python полезно распознавать эти три типа ошибок,
что облегчает их исправление.
• Синтаксическая ошибка (Syntax error).
Происходит, когда интерпретатор находит
код, не соответствующий правилам языка
программирования Python, например
отсутствующий знак кавычки в конце строки.
Интерпретатор останавливается и сообщает об
ошибке, не выполняя программу.
• Ошибка времени выполнения программы
(Runtime error). Происходит во время выполнения
программы, когда она запускается, например,
когда переменная позднее была отнесена к
неправильному типу, поэтому ее невозможно
опознать. Интерпретатор запускает программу, но
останавливается на ошибке и сообщает о ее сути
как об исключении (Exception).
• Семантическая ошибка (Semantic error).
Происходит, когда программа выполняется не так,
как этого ожидал разработчик, например, когда
последовательность выполнения операций явно не
определена в выражении. Интерпретатор запускает
программу и не сообщает об ошибке.
syntax ру
Исправлять синтаксические ошибки и ошибки времени
выполнения программы достаточно просто, поскольку
интерпретатор сообщает, 1де произошла ошибка и в чем
она заключалась, но семантические ошибки требуют
изучения кода.
Откройте окно редактора IDLE, затем добавьте
выражение для вывода на экран строки, где
отсутствует закрывающая кавычка:
print( 'Coding for Beginners in easy steps )
О
Сохраните программу, запустите ее, и вы
увидите, как интерпретатор цветом выделит
синтаксическую ошибку и объяснит, в чем ее
«л®'
Индикатор синтаксической
ошибки красного цвета
указывает место в строке,
где произошла ошибка
конца строки (End of
Line, EOI), позволяя
легко определить строку
с незакрытой кавычкой
суть.
о
о
Поставьте кавычку перед закрывающей крутлой
скобкой, чтобы закрыть строку. Сохраните
изменение, снова запустите программу, и вы
увидите, что ошибка исправлена.
Далее начните новую программу,
инициализировав переменную, затем
попытайтесь вывести ее значение с
неправильным именем переменной, и вы
увидите сообщение интерпретатора об ошибке
времени выполнения программы:
title = 'Coding for Beginners in easy steps'
print( titel)
runtime.py
R. iDIE Shell 3.10.4 -OX
File Edit Shell Ceoug Options Window Help
»>
======= RESTART- C:\MyCode\runtime.py ======
Traceback (most recent call last):
File "C:\MyCode\runtime.py'. line 2. in <module>
prinr( titel)
NameError: name 'titel' is not defined. Did you mean: 'title'?
0
0
Исправьте имя переменной в вызове функции
гак, чтобы оно соответствовало ее имени
при объявлении, сохраните и перезапустите
программу, и вы увидите, что ошибка исправлена.
Теперь начните новую программу,
инициализировав переменную, затем
попытайтесь найти значение выражения,
использовав переменную, но не определяя
последовательность действий. Вы увидите
несколько неожиданный результат 28.
num 3
print( , num * 8 + 4 }
Подробно о том, как
обработать исключение
ошибки времени
выполнения прсргммы
в коде, можно прочитать
на странице 72
сл
Добавьте кр)тлые скобки, чтобы сгруппировать
выражение следующим образом: num * (8 + 4), затем
сохраните файл, перезапустите программу, и вы
увидите тот результат, который ждали, — 36. Таким
образом вы исправили семантическую ошибку.
semantic.ру
Сохранение данных
чО
m
Краткие итоги
• Переменные можно использовать для того, чтобы
хранить данные, определенные в программном
коде, и данные, введенные пользователем.
• Сохраненное в переменной значение остается
доступным для повторного использования, пока
не будет замещено другим значением или пока
программа не закончит работу.
• Встроенная функция input() может присваивать
переменной введенные пользователем данные.
Опционально в ней можно определить строку,
которая будет отображаться пользователю.
• В скобках встроенной функции printf) можно
указать значения различных типов, представив их
как разделенный занятыми список.
• По умолчанию функция print() автоматически
добавляет после выводимых данных символ
перевода строки \п, если только не определен
какой-либо другой конец строки end.
• Оператор конкатенации + может соединять вместе
две строки.
• Типы данных — это фактически текстовые строки
str, целые числа int, десятичные дроби float и булевы
логические значения bool.
• Булевы значения — это логические значения
истины, которые в Python представлены
ключевыми словами True и False.
• Встроенная функция type() может определить,
к каком)' типу данных принадлежит значение
любой переменной.
• Значения, присвоенные переменным с помощью
встроенной функции input(), всегда относятся
к строковому типу данных str.
• Типы данных могут быть преобразованы для
дальнейших действий с помощью встроенных
функций приведения типов int(), floatf) и str().
• В результате арифметических действий с целым
числом типа int и десятичной дробью типа float
получается результат, относящийся к типу float.
• Интерпретатор распознает связанные
с неправильным написанием кода синтаксические
ошибки до выполнения программы.
• Интерпретатор распознает связанные
с исключениями ошибки времени выполнения
программы во время ее исполнения.
Интерпретатор не распознает семантические ошибки,
связанные с неожиданным поведением программы.
1
Выполнение
операций
В этой главе
показано, как
использовать
символы
операторов
в коде.
38 Выполнение
арифметических действий
40 Присваивание значений
42 Сравнение значений
44 В поисках истинности
46 Проверка условий
48 Порядок выполнения
действий
50 Краткие итоги
Выполнение операций
Выполнение
арифметических
действий
Арифметические «операторы» часто используются при
написании компьютерных программ. Как и следовало
ожидать, для сложения применяется символ +, а
для вычитания символ Обычно для умножения
используется не крестик * , а символ звездочки *, а для
деления — не +, а наклонная черта вправо /.
Используемые в коде программ на Python
арифметические операторы перечислены в следующей
таблице вместе с соответствующими им операциями:
со
СП
Значения, использующиеся
в выражениях вместе
с операторами, называются
операндами В выражении
2 + 3 числовые значения 2
и 3 являются операндами.
Оператор + складывает два числа, а оператор —
вычитает второе число из первого.
Оператор * умножает первое число на второе,
а оператор / делит первое число на второе.
Оператор деления % с остатком делит первое число
на второе и возвращает остаток, получившийся
в результате этой операции. Его полезно использовать
для того, чтобы определить, является ли число четным
или нечетным.
Оператор деления нацело // действует так же, как
и операт ор /, но отсекает результат, оказавшийся
за десятичной точкой, убирая всю десятичную часть
числа из ответа.
Оператор степени ** возвращает первое число,
возведенное в степень, указанную во втором числе.
Начните новую программу с создания двух
переменных, содержащих целые числа:
а = 8
b = 2
Далее выведите на экран результат сложения
чисел:
printf ’Сло , а , , b , , а + b )
Теперь выведите результат вычитания чисел:
printf , а , , b . , а - b )
Теперь выведите результат умножения:
printf 'Умножс , а , , b, , а * b )
Выведите результат деления с десятичной частью
и без нее:
printf . а , , b , , а / b )
printf 'Целочисленное делениеДГ, а, Ч', Ь, , а // Ь)
Далее выведите на экран остаток от деления
чисел:
printf , а , , Ь , , а % b )
Наконец, выведите результат возведения первого
числа в степень второго:
printf 'Возведение в creneHb:\t\f, а,12 = , а ** b, sep = )
Сохраните программу, затем запустите ее, и вы
увидите результаты арифметических операций.
arithmetic ру
Здесь использована
управляющая
последова гельнос i ь
специальных символов \t,
которая добавляет
невидимую табуляцию,
чтобы отформатировать
результаты. Чтобы изучить
специальные символы,
обратите внимание на
утилиту Microsoft Windows
Карта символов. («Пуск» ->
«Стандартные» -> «Таблица
символов»). Выберите
шрифт, затем скопируйте
и вставьте символ в код.
Параметр sep можно
использовать для того,
чтобы явно обозначить
разделение в результатах
на выходе Здесь он
определяет отсутст вие
пробелов, поскольку
параметру присвоено
значение двух не
разделенных пробелами
одинарных кавычек.
Выполнение операций
Присваивание значений
Обычно для присваивания значений переменным при
написании компьютерных программ используется просто
символ =. Иногда его соединяют с арифметическим
оператором, чтобы одновременно выполнить
арифметическое действие и присвоить значение.
В следующей таблице перечислены операторы
присваивания в Python вместе с операциями, которые
они выполняют.
Важно не забывать, что
оператор = означает
«присваивание», а не
«равенство», и его
не следует путать
с оператором равенства ==.
В примере а = b переменной а присваивается значение,
сохраненное в переменной Ь, так что это значение
становится новым значением переменной а
Оператор += служит для того, чтобы прибавить какое-
то значение к существующему значению, сохраненному
в переменной а, таким образом, переменной
присваивается совокупное общее значение.
В приведенном выше примере оператор += вначале
прибавляет значение, содержащееся в переменной а,
к значению, содержащемуся в переменной Ь. Затем он
присваивает результат, который становится новым
значением, хранимым в переменной а.
Все остальные операторы работают подобным образом,
вначале выполняя арифметическую операцию между
двумя значениями, а затем присваивая результат операции
в качестве значения первой переменной, чтобы этот
результат стал новым сохраненным значением.
При использовании оператора %= первый операнд э
делится на второй операнд Ь, затем получившийся
в результате остаток присваивается переменной а.
о
о
о
о
о
Начните новую программу с создания двух
переменных, содержащих целые числа. Выведите
оба присвоенных значения на экран:
а = 8
b = 4
printf 'Присвоенные значения^', 'а =', а, *\tb - , b)
Далее прибавьте к первой переменной вторую
и присвойте новое значение. Выведите
сохраненное значение на экран:
а + - b
print( 'Сложить & ПрисвоитьДГ ,'а =', а , '\t(8 += 4)')
Теперь вычтите из первой переменной вторую
и присвойте первой переменной новое значение.
Выведите сохраненное значение на экран,
затем выполните умножение, присвойте новое
значение первой переменной и выведите
сохраненное значение,
а -= Ь
print( 'Вычесть & ПрисвоитьДГ, 'а =', а, '\t(12 - 4)')
а *= Ь
print( 'Вычесть & Присвоить^', 'а =', а, '\t(8 х 4)')
Наконец, выполните деление, присвойте новое
значение первой переменной и выведите на
экран сохраненное значение, затем поделите
с остатком, присвойте остаток новой переменной
и выведите на экран сохраненное значение:
а /= b
print( 'Разделить & ПрисвоитъДГ, 'а =', а, ^(32 + 4)')
а %= Ь
print( Найти остаток & Присвоитъ:\Г, 'а - , а, V(8 % 4)')
Сохраните программу, затем запустите ее, чтобы
увидеть результаты операций присваивания.
ass'gn.py
В отличие от оператора
присваивания оператор
□авенства == сравнивает
операнды. О нем вы
сможете прочитать на
странице 4?.
& IDIE Shell 3.10.4 - □ X
File Edit Shell Debug Options Window Help
======= RESTART C:\MyCode\assign.py =======
Assign Values a - и b = 4
Add & Assign: a = 12 (8 += 4)
Subtract & Assign: a = 8 (12 4j
Multiply & Assign: a = 32 (8x4]
Divide & Assign: a = 80 (32 * 4)
»> Modulus & Assign: a = 00 (8 % 4]
Выполнение операций
Сравнение значений
Операторы, которые обычно используются в языке
программирования Pvthon для сравнения значений двух
операндов, перечислены в таблице ниже:
<о®еЛ
В кодовой таблице Unicode
символы верхнего регистра
A-Z имеют значения
65-90, а символы нижнего
оегистра a-z — значения
97-122.
Оператор равенства == сравнивает два операнда
и возвращает True, если их значения равны. В ином
случае он возвращает False Если оба операнда
представлены одним и тем же числом, они равны. Если
оба являются строками, то для того, чтобы получить
результат сравнения, их значения в кодовой таблице
Unicode сравниваются численно.
И наоборот, оператор неравенства!^, используя те же
правила сравнения, что и оператор равенства ==,
возвращает True, если два операнда не равны, в ином же
случае он возвращает False. Операторы равенства
и неравенства полезны при проверке состояния двух
переменных, чтобы выполнить в программе условное
ветвление в зависимости от результатов сравнения.
Оператор > «больше чем» сравнивает два операнда
и возвращает True, если значение первого больше, чем
значение второго. Он возвращает False, если значения
равны или значение первого операнда меньше.
Оператор < «меньше чем» делает такое же сравнение,
но возвращает True, если значение первого операнда
меньше, чем значение второго, иначе он возвращает
False. Операторы > «больше чем» и < «меньше чем»
часто используются, чтобы проверить значение счетчика
итераций (повторений) в цикле.
Если добавить оператор - после оператора > «больше
чем» или < «меньше чем», то выражение будет
возвращать True, если значения операндов равны.
Начните новую программу, инициализировав
пять переменных со значениями для сравнения:
nil «О
num -
Юр = 1
cap = А
low =
О
Далее добавьте выражения, выводящие на экран
результаты сравнения с равенством чисел и
символов:
printf , nil, , num , nil == num )
printf , cap , , low , cap == low )
Теперь добавьте выражение, выводящее на экран
результат сравнения с неравенством:
printf , nil, , top , nil 1= tcp |
О
Теперь добавьте выражение, выводящее на экран
результат сравнения с неравенством:
print! . nil, , top , nil > top )
printf , nil, , top , nil < top )
0
Наконец, добавьте выражения, чтобы вывести
на экран результаты сравнения «больше или
равно — меньше или равно»:
printf 'Больше или равно :\t', nil, ’>= , num, nil >= num)
printf Меньше или равно :\t*, top, '<= , num, top <= num)
Сохраните программу, затем запустите ее, чтобы
увидеть результаты операций сравнения.
comparison ру
Управляющая
последовательность \t
в данных примерах
добавляет невидимый
символ табуляции,
чтобы отформатировать
результаты работы
программы.
В кодовой таблице Unicode
символ верхнего регистра
«А» имеет значение 65, а
символ нижнего регистра
«а» — 97, поэтому их
сравнение возвращает
False.
Выполнение операций
Термин «булевы значения»
восходит к теории логики,
разработанной английским
математиком Джорджем
Булем (1815-1864).
В поисках истинности
Логические операторы, которые чаще всего
используются в программах на Python, перечислены
в таблице ниже:
Оператор Операция
and Логическое И
or Логическое ИЛИ
not Логическое НЕ
Логические операторы используются с операндами,
имеющими булевы значения True или False или значения,
которые преобразуются в True или False.
Оператор and (логическое И) оценивает два операнда
и возвращает True, если оба операнда имеют значение
True. В ином случае оператор and возвращает False.
В программировании это полезно для выполнения
«условного ветвления», где направление развития
программы определяется проверкой двух условий: если
оба условия выполняются, программа движется в одном
направлении, если не выполняются — в другом.
В отличие от оператора and, которому необходимо,
чтобы оба операнда имели значение True, оператор пг
(логическое ИЛИ) оценивает два операнда и возвращает
True, если один из операндов имеет значение True. Если
ни один из операндов не возвращает True, то оператор or
вернет False. В программировании это полезно для того,
чтобы выполнить определенное действие, если одно
из проверяемых условий выполняется.
Оператор not (логическое НЕ) — это унарный оператор,
который используется перед одним операндом. Он
возвращает значение, обратное значению данного
операнда. То есть если переменная имеет значение
True, оператор not вернет False. В программировании
оператор not полезен, чтобы переключать значение
переменной в последовательных итерациях цикла
с выражением наподобие а = not а. Эго позволяет
удостовериться, что в каждой итерации булево значение
будет меняться на противоположное, как будто мы
включаем и выключаем свет, щелкая переключателем.
о
Начните новую программу, инициализировав
две переменных с булевыми значениями для
логической оценки:
а = True
b = False
о
Добавьте выражения, чтобы вывести на экран
результаты оценки с оператором AND:
printf )
printf , a and а )
printf , a and b J
printf , b and b )
logic, ру
о
Добавьте выражения, чтобы вывести на экран
результаты оценки с оператором OR:
printf '\пЛогическое или:' )
printf , а та)
printf , а г b )
printf , b и D )
Добавьте выражения, чтобы вывести на экран
результаты оценки с оператором NOT:
printf пЛ )
printf , а , , not а )
printf , b , , not b )
Сохраните программу, затем запустите ее, чтобы
увидеть результаты логических операций.
В программировании на
Python булевы значения
могут быть представлены
числами: True как 1, False
как 0 (нуль).
Отметим, что выражение
False и False возвращает
не True, a False. Возможно,
это яркая иллюстрация
пословицы «Два
заблуждения — еще не
правда».
8 целом в программировании
выражение всегда
возвращает значение,
а инструкция может ничего
не возвращать, но при этом
включать в себя несколько
выражений.
Можно сказать, что
в условных выражениях
имеются три операнда:
выражение для проверки
и два возможных
возвращаемых значения.
Проверка условий
Во многих языках программирования, таких как C++ и Java,
имеется «тернарный» оператор, оценивающий выражение
на соответствие или несоответствие условию (True или False),
а затем возвращающий одно из двух определенных условий
в зависимости от результатов оценки. Тернарный оператор ?:
имеет следующий синтаксис:
( тестовое выражение } ? если true, вернуть это : если false,
вернуть то
В отличие от других языков программирования в Python
нет тернарного оператора ?:. Вместо него используются
«условные выражения», которые работают подобным
образом с помощью ключевых слов if и else и имеют
следующий синтаксис:
если-1гие-вернуть-это if ( тестовое выражение ) else если-
false-вернуть-то
Хотя синтаксис условных выражений на первый
взгляд может показаться запутанным, с ними стоит
познакомиться поближе, поскольку с их помощью при
минимуме кода можно добиться сложного ветвления
в программах. Например, можно создать ветвление кода,
если переменная имеет значение, отличное от единицы:
еслитгие-делайэто if ( var != 1) else всли^аке-делай-то
В Python условное выражение можно использовать для
того, чтобы присвоить максимальное или минимальное
значение двух переменных третьей. Например, мы
можем присвоить переменной с минимальное значение:
с = a if ( а < b ) else b
Выражение в круглых скобках возвращает True,
когда значение переменной а меньше, чем значение
переменной Ь, в этом случае меньшее значение
переменной а присваивается переменной с.
Подобным же образом замена в тестовом выражении
оператора меньше оператором больше позволит
приписать большее значение переменной Ь к
переменной с.
Также условные выражения часто используются
с оператором деления с остатком в тестовом выражении,
чтобы отнести значение переменной к четным или
нечетным числам;
если-^ие(нечетное)-делай-это if ( var % 2 I- О ) else если-
false(4eTHoe)-flwafi-TO
Если в результате деления значения переменной на
два имее тся остаток, то число нечетное, если остатка
нет — четное. Тестовое выражение (var % 2 ==1) будет
иметь гот же эффект, но предпочтительнее проверять на
неравенство: легче обнаружить отличия, чем одинаковость.
о
о
condition.ру
Начните новую программу, инициализировав две
переменных с целочисленными значениями для
оценки условий:
а = 1
Ь = 2
Далее добавьте инструкции для вывода на экран
результатов условной оценки, описывающей
значение первой переменной:
print( *\Переме1 a Is, 'Е, гница' if (а = 1) else 'Н гица')
print( I Is, *4 гая' if (а % 2 == 0) else 'Н гая )
Теперь добавьте инструкции для вывода на экран
результатов условной оценки, описывающей
значение второй переменной:
printf *\Г1еременнг a Is, 'Единица' if (b = 1) else 'Не I 1ица')
print( , 'Ч я' if (Ь % 2 == 0) else 'Нечетная )
Далее добавим инструкцию для того, чтобы
присвоить новой переменной результат условной
оценки:
top = a if ( а > b ) else Ь
Наконец, добавим инструкцию, чтобы вывести
на экран присвоенный результат, определив,
какое из двух значений больше:
print( '\пБольше значение:', top )
Сохраните программу, затем запустите ее, чтобы
увидеть результаты операций с условными
выражениями.
Возможно, вы обнаружите,
что некоторые Python-
разработчики не любят
условные выражения,
поскольку считают, что их
синтаксис поотиворечит
принципу легкой
читаемости кода.
Выполнение операций
Порядок выполнения
действий
Приоритет выполнения операторов определяет
порядок, в котором происходит вычисление выражения.
Например, в выражении 3 * 8 + 4 по умолчанию вначале
выполняется умножение с оператором умножения *,
поэтому в результате получается 28 (24 + 4).
В таблице ниже перечислены операторы Python в
порядке убывания: чем ниже оператор в таблице,
гем ниже его приоритет. Все вычисления в Python
выполняются слева направо. Если рядом встречаются
операторы с одинаковым приоритетом, первым
выполняется левый. Исключением является оператор
возведения в степень — из двух операторов сначала
выполнится правый, а потом левый.
Оператор умножения *
имеет более высокий
приоритет, чем опера гор
сложения +, поэтому
в выражении 3*8 + 4
умножение выполняется
первым, до сложения.
Побитовые операторы
используются для
низкоуровневых
манипуляций.
Об операторах
тождественности
и принадлежности мы
поговорим позднее. Все
они включены в 1аблицу,
чтобы показать более
полную картину.
Оператор целочисленного
деления // отсекает часть
числа, находящуюся за
десятичной точкой, тогда
как оператор деления /
сохраняет ее
Оператор Описание
** Степень
+ Унарный плюс
- Унарный минус
Побитовый оператор NOT
* Умножение
/ Деление
// Целочисленное деление
% Деление с остатком
+ Сложение
- Вычитание
1 Побитовый оператор OR
л Побитовый оператор XOR
& Побитовый оператор AND
» Побитовый сдвиг вправо
« Побитовый сдвиг влево
>, >-> <=» ==, != Сравнение
= *+= Поисваивание
is, is not Опеоаторы тождественности
in , not in Опеиаторы гричадлежности
not Логический оператор N01
and Логический операюр AND
or Логический оператор OR
Начните новую программу, инициализировав две
переменных с целочисленными значениями для
демонстрации приоритета выполнения операторов:
а - 2
Ь = 4
с = я
Далее добавьте инструкции, чтобы вывести
на экран результаты выполнения выражений
с приоритетом по умолчанию и принудительным
выполнением сложения до умножения:
order.py
printf ДпПорядок выполнения по умолчанию:\Г, а, , с, , b, , а * с + Ь )
printf 'Принудительный порядок выполненияДГ, а, '• (', с,'+', Ь,') =', а * ( с + Ь))
Теперь добавьте инструкции, чтобы вывести
на экран результаты выполнения выражений
с приоритетом по умолчанию и принудительным
выполнением вычитания до деления:
printf ДпПорядок выполнения по умолчанию:\Г, с, ’//*» Ь,а, '=•, с // Ь - а )
printf 'Принудительный порядок выполнения:^', с,'// (', Ь,'-', а,') =', с // ( Ь - а ))
Наконец, добавьте выражения, чтобы вывести
на экран результаты выполнения выражений
с приоритетом по умолчанию и принудительным
выполнением сложения до деления с остатком
и возведения в степень:
printf > nio:\t', с, '%', а, , Ь, , с % а + b )
printf 'Принудительный порядок выполнения:^', с,'% (', а,'+', Ь,') =', с % (а + Ь ))
printf \пПорядок выпаян <я по умолчанию:\€, с, , а, , Ь, , с ** а + Ь)
printf 'Принудительный ния:\Г, с, '**(', а, , Ь, , с ** f а + Ь))
Сохраните программ)*, затем запустите ее, чтобы увидеть
результаты выражений, выполненных с приоритетом
операторов по умолчанию и с приоритетом операторов,
заданным принудительно.
Не полагайтесь на
заданный по умолчанию
приоритет операторов,
зсегда используйте круглые
скобки, чтобы задать
порядок выполнения
операторов в выражениях
Выполнение операций
О
ш
Краткие итоги
• Арифметические операторы формируют
выражения с двумя операндами для сложения +,
вычитания -, умножения *, деления /,
целочисленного деления //, деления с остатком %
и возведения в степень **.
Оператор деления с остатком % используется для
того, чтобы определить, является ли число четным
или нечетным.
• Оператор целочисленного деления И отсекает
от результата десятичную часть.
Оператор присваивания = может использоваться
вместе с арифметическим оператором, чтобы
производить арифметические расчеты, а затем
присваивать значение результата переменной.
• Оператор += полезно использовать, чтобы
прибавить какое-то значение к уже сохраненному
в переменной значению, чтобы получить их
суммарное значение.
Операторы сравнения могут формировать
выражения, где два операнда проверяются
по признакам равенства ==, неравенства!^
больше >, меньше с, больше или равно >-,
меньше или равно <=.
Логические операторы and и or формируют
выражения, оценивающие два операнда
и возвращающие булево значение True или False.
Логический оператор not возвращает значение,
обратное булеву значению одного операнда,
превращая True в False и наоборот.
Оператор not полезно использовать, чтобы
переключать значения между True и False
в последовательных итерациях цикла.
Условные выражения if-else позволяют оценить
данное выражение на истинность (True) или
ложность (False) и в зависимости от результата
вернуть один из операндов.
Выражения с несколькими операторами
выполняются в соответствии с приоритетом этих
операторов по умолчанию, если только иной
порядок выполнения явно не обозначен с помощью
круглых скобок ().
• Обычно сложение + и вычитание — выполняются
после умножения * и деления /, если явно не указан
иной порядок выполнения.
Работа
со списками
В этой главе
показывается.
как писать код
для хранения
данных в списках
и как пользоваться
52 Создание списков
54 Изменение списков
56 Неизменяемые списки
58 Список с уникальными
значениями
данными
60 Именованные элементы
из списков.
списка
62 Краткие итоги
Работа со списками
Создание списков
[0] [1] [2]
В некоторых языках программирования есть
возможность объявлять переменные без начального
значения, но в программировании на Python переменной
должно быть присвоено какое-либо начальное значение
(она должна быть инициализирована) в выражении,
объявляющем ее, иначе интерпретатор сообщит
об ошибке «значение не определено».
Несколько переменных можно инициализировать
общим значением в одном выражении, использовав
последовательность операторов присваивания.
Например, определить общее значение одновременно
для трех переменных можно следующим образом:
а = b = с = 10
Или же можно одним выражением присвоить нескольким
переменным разные значения, перечислив их через
запятую. Например, определить разные значения
одновременно для трех переменных можно так:
а, Ь, с = 1, 2, 3
В отличие от обычной переменной, где может храниться
только один элемент данных, переменная типа «список»
(list) может хранить множество элементов данных.
Данные хранятся в определенной последовательности,
все элементы списка имеют свой номер или индекс,
начинающийся с 0. Таким образом, первое значение
хранится в ячейке 0, второе — в ячейке 1 и г. д. Список
можно создать как и любую другую переменную. Для этого
используются квадратные скобки []. внутри которых через
запятую перечисляются элементы. К пример)’, давайте
создадим список с именем nums
nums = [0, 1, 2, 3, 4, 5]
Доступ к отдельному элементу списка можно получить,
указав имя списка, после которого в квадратных скобках
указывается индекс элемента. То есть с помощью записи
numsfl] мы обращаемся ко второму (не к первому!)
элементу приведенного выше списка. Еще раз повторим,
что нумерация индексов начинается с 0, то есть,
чтобы обратиться к первому элементу, следует указать
индекс 0: nums[0l.
В списках может быть более одного индекса для того,
чтобы представить несколько измерений, а не одно, как
в обычном списке. Многомерные списки с тремя и более
индексами не слишком распространены, но двумерные
используются часто и полезны для того, чтобы хранить
данные, основанные на сетке, например координаты X, У.
Список строковых значений в принципе можно
рассматривать как многомерный список, поскольку
каждая строка сама по себе является списком символов.
Таким образом, к каждому символу можно обратиться
по его индексу внутри отдельно взятой строки.
о
Начните новую программу, инициализировав
список из трех элементов, содержащих
строковые значения:
quarter = [ 'Январь', 'Февраль', 'Март' ]
О
Теперь добавьте инструкции, чтобы вывести
на экран значения, содержащиеся в каждом
элементе списка:
print( , quarter!01 )
print} , quarter[l] )
print( , quarter[2] )
О
Теперь добавьте выражение, создающее
многомерный список из двух элементов, которые
сами по себе являются списками из трех
элементов и содержат целые числа:
coords = [[1,2,3],[4,5,6]]
О
Добавьте инструкции, чтобы вывести на экран
значения, содержащиеся в двух конкретных
элементах внутренних списков:
print} '\пЛевый верхний 0,0 , coords[0][0] )
print} i 1,2 , coords[l][2] )
О
list.py
Строковые индексы могут
быть и отрицательными’,
это указывает на то, что
отсчет идет справа налево.
Напримео, индекс-1
ссылается на последнюю
букву строки
Наконец, добавим инструкцию, чтобы вывести
на экран один символ строкового значения:
print} *\пПервая буква названия второго месяца :', quarter[l][O])
СП
О
Сохраните программу, затем перезапустите ее, и вы
увидите на экране отображение элементов списков.
Для того чтобы пройти
по элементам списка,
часто используются циклы,
о которых мы поговооим
в главе 5.
*Это справедливо
для индексов любых
упорядоченных
последовательностей —
в том числе списка
и кортежа. — Прим.ред
Работа со списками
Изменение списков
Переменные типа «список», содержащие
множество элементов данных, часто используются
в программировании на Python, поэтому в стандартной
библиотеке имеется набор методов, которые можно
добавить с помощью записи через точку к имени списка,
чтобы управлять его элементами.
Методы списков Описание
fet.append(x) Добавляет элемент x в конец списка
fct.extend(L) Добавляет все элементы списка L в конец списка
fct.insertp» Добавляет элемент х, вставляя его на i-ю позицию
fetremove(x) Удаляет первый встретившийся в списке элемент со значением х
/;st.pop(i) Удаляет элемент с индексом / и возвращает его как результат
list index(x) Возвращает индекс первого встретившегося в списке элемента х
fct.count(x) Возвращает количество вхождений элемента х в список
list sortO Сортирует список
list, reverse() Переставляет элементы списка в обратном порядке
В списках, где содержатся
числовые и строковые
значения, метод sort()
возвращает список
элементов, где вначале
отсортированы числовые
значения, а затем —
строковые в алфавитном
порядке, например 1,2,3,
А, В. С.
В Python также
имеется функция int(s),
возвращающая строковое
значение s в числовом
формате.
Также в Python имеется полезная функция len(L),
возвращающая длину списка L, то есть общее
количество элементов, которые он содержит. Как
и результаты работы методов indexf) и coontf),
возвращаемое значение функции 1еп() является целым
числом, поэтому его нельзя конкатенировать с текстовой
строкой при выводе данных.
Для то) о чтобы представить числовые значения
как строки, пригодные для конкатенации, в Python
используется функция str(n), преобразующая числовое
значение п в строковый формат. Подобным же образом
строковый формат списка можно получить с помощью
функции str(L). После этого список можно конкатенировать
с другими строками. В обоих случаях помните, что
первоначальная версия списка не изменяется, поскольку
функция возвращает только ее копии.
Отдельные элементы списка можно удалить, указав
имя списка и индекс после ключевого слова del. Таким
образом можно удалить один элемент с конкретным
индексом i или срез элементов, использовав запись
il: 12, где указываются индексы первого и последнего
элементов. В таком случае будет удален элемент
с индексом il и все элементы до индекса 12, не включая
элемент с индексом i2.
о
Начните новую программу, инициализировав
два списка из трех элементов со строковыми
значениями:
basket = [ 'Яблоко', 'Було а', 'Кола' ]
crate = [ ‘Яйцо*, 't <жир', 'Е ]
О
Далее добавьте инструкции, чтобы вывести на
экран содержимое первого списка и его длину:
printf , basket)
print( 'Элементов в списке Basket:', len( basket))
О
Теперь добавьте инструкции, чтобы добавить
элемент и вывести на экран получившийся
список, затем удалите последний элемент и еще
раз выведите на экран все элементы списка:
basket.appendf )
printf , basket )
printf 'Последний удаленный элеме , basket.рор())
printf . basket)
О
Наконец, добавьте инструкции, чтобы добавить
все элементы из второго списка в первый
и выведите на экран получившийся список.
Затем удалите элементы и снова выведите
на экран содержимое первого ciiHCKa:basket.
extendf crate)
printf а вл» .basket)
del basketfl]
printf 'Удаленный элемент:', basket)
del basket[1:3]
printf , basket )
0
pop py
СП
СП
Сохраните программу, затем запустите ее, и вы
увидите различные преобразования списков.
& DIE Shell 3.10.4 - □ X
File Edit Shell Debug Option» Window Help
»>
========= RESTART C:\MyCode\poc.pv ========
Basket List: ['Apple', 'Bun'. 'Cola']
Basket Elements: 3
Appended: ['Apple'. 'Bun', 'Ccla', 'Damson']
Last Item Removed Damson
Basket List ['Apple'. 'Bun'. 'Cola']
Extended: ['Apple', 'Bun', 'Cola', 'Egg'. 'Fig', 'Grape']
ItemRemoved: [ Apple'. 'Cola'. 'Egg' 'Fig'. 'Grape']
Slice Removed. ['Apple', 'Fig', 'Grape']
Последний индекс в срезе
указывает, в каком месте
следует прекратить
удаление элементов,
но элемент, имеющий этот
индекс, не удаляется.
Работа со списками
Как и нумерация индексов
списка, нумерация
индексов кортежа
нанимается с 0.
Ю
При распаковке кортежа
количество переменных
должно совпадать
с количеством элементов
в кортеже.
Неизменяемые списки
Во время выполнения программы значения в списке
могут быть изменены. Каждому элементу можно
приписать замещающее значение, используя оператор
присваивания и определяя имя списка, индекс элемента
и замещающее значение. В терминах программирования
значения, хранящиеся в обычном списке, являются
изменяемыми, то есть их можно изменить. Также при
выполнении программы в список можно динамически
добавлять элементы и удалять их из него. Это означает,
что список идеально подходит, если в программе будут
изменяться значения элементов.
Но если список содержит только постоянные
значения, которые не меняются во время работы
программы, то лучше создал и закрепленный список.
В терминах программирования значения, хранящиеся
в закрепленном списке, являются неизменяемыми —
их нельзя изменить. Во время выполнения программы
в закрепленный список нельзя динамически добавить
элементы, их нельзя из него удалить. Это означает,
что закрепленный список идеально подходит, если
программа никак не изменяет значения элементов.
В Python строго неизменяемый набор элементов
называется кортежем (tuple). Его можно создать,
приписав переменной разделенные запятой значения
в круглых скобках. Этот процесс известен как «упаковка
в кортеж»:
colors_tuple = ('Красный', 'Зеленый', 'Красный', 'Синий',
'Красный' )
К отдельному элементу кортежа можно обратиться,
использовав имя кортежа, за которым в квадратных
скобках указан индекс элемента. Полезно, что все
значения, хранящиеся внутри кортежа, можно присвоить
отдельным переменным. Этот процесс известен как
«распаковывание последовательностей»:
э , b , с , d , е = colors_tuple
Такие методы как sort() или reversed нельзя применить
при работе с кортежами, но встроенную функцию typed
можно использовать, чтобы получить информацию
о типе данных, а встроенную функцию 1еп() — чтобы
вернуть длину кортежа.
Обычно кортежи используются для хранения
постоянных неизменяемых значений, например,
названий дней недели и месяцев, личных данных,
таких как имя, фамилия, дата рождения, адрес, номер
телефона и т.д.
Начните новую протрамму, инициализировав
кортеж и выведя на экран тип переменной:
days = ('Пн', 'Вт', 'Ср', *Чт*, 'Пт', *Сб*, ’Вс’)
printf , type( days ))
Далее выведите на экран содержимое кортежа,
его длину и значение, сохраненное в первом
элементе:
printf , days )
printf 'Колима дели:', lenf days ))
printf T дели , daysfO] )
Теперь инициализируйте еще один кортеж,
содержащий личные данные пользователя:
user = ('Джон', 'Доу', 'Париж*, *555-1234*)
Затем выведите на экран полное имя
пользователя:
printf , userfO] , userfl] )
О
Наконец, выведите на экран номер телефона
пользователя:
printf , user[3] )
Сохраните программу, затем запустите ее,
и вы увидите значения, сохраненные внутри
кортежей.
tuple.py
В кортеже могут
храниться элементы, не
являющиеся уникальными
по отношению к другим
элементам этого же
кортежа.
Работа со списками
Список с уникальными
значениями
Значения в обычном списке или в кортеже могут
повторяться, но можно создать и список уникальных
элементов, где повторения не допускаются. В Python
изменяемый набор лттикальных значений называется
множеством (set). Его можно создать, приписав переменной
разделенные запятой значения в фигурных скобках:
phonetic_set = {'Alpha', 'Bravo', 'Charlie'}
В отличие от списков или кортежей, к отдельным
элементам множества нельзя обратиться, использовав имя
множества и указав индекс элемента в квадратных скобках.
Вместо этого существуют методы работы с множествами,
которые через точку можно добавить к имени множества
для преобразования или сравнения значений.
Множество не может
содержать элементы, не
являющиеся уникальными
по отношению к другим
элементам этого же
множества.
Методы множеств Описание
set.add(x) Добавляет элемент x в множеово
set updatefx, у, z) Добавляет в множество несколько элементов
set copy() Возвращает копию множества
set.popl) Удаляет один случайный элемент из множества
set.discard(x) Удаляет элемент х, обнаруженный в множестве
set 2. intersection(set2) Возвращает элементы, содеожащиеся в обоих множествах
setl. difference(set2) Возвращает элементы, которые содержатся в множестве 1, но не содержатся в множестве 2
Больше информации
о методах множеств
можно найти в онлайн-
документации Python по
адресу docs.python.org.
Встроенную функцию typef) можно использовать, чтобы
получить информацию о типе данных, а встроенную
функцию 1ел() — для того чтобы вернуть длину
множества. Кроме того, можно применить встроенный
оператор принадлежности in. чтобы найти значения,
хранящиеся в множестве.
Обычно множества используются для того, чтобы
хранить коллекции уникальных изменяемых значений,
которые можно легко найти и сравнить с помощью
мощных методов множеств. Хотя доступ к элементу
по индексу получить нельзя, множество можно
преобразовать в обычный список, использовав
встроенную функцию list() и, таким образом, сделав
элементы легкодоступными.
Начните новую программу, инициализировав
множество с уникальными значениями имен
и выведя на экран тип переменной:
party_goers { 'Эндрю', 'Барбара', 'Кэрол', 'Дэвид' }
print( 'Тип данных partyjgoers: , type( party_goers ))
Далее добавьте инструкции для поиска
в множестве двух элементов с конкретными
set.ру
значениями:
print( Ч нку?', 7 вид* in party_goers )
print( 'Идет ли Келли на вечеринку?', 'Келли' in party_goers )
Теперь инициализируйте еще одно множество
с уникальными значениями имен:
students = {'Эндрю', 'Келли', 'Линн', 'Дэвид'}
Создайте множество, содержащее только общие
значения двух предыдущих множеств:
commons = party_goers.intersection( students )
Преобразуйте получившееся множество в список,
чтобы можно было получить доступ к каждому
из них:
party_students = list( commons )
Наконец, выведите на экран все общие значения
и значение, сохраненное в первом элементе
списка:
1Л
tp
print( 'Студен , party_students )
print( , party_studentslO] )
Сохраните программу, затем запустите ее, и вы
увидите значения, сохраненные внутри множеств.
R, IDLE Shell 3.10.4
File Edit Shell Debug Options Window Help
========= RESTART- C:\MyCode\setpy ========
paity_goers: <class 'set'>
Did David go to the party? True
Did Kelly go to the paity? False
Students at the party: I'David. 'Andrew']
First student at the party: David
Отметим, что после
применения функции
list() элементы могут
оказаться не в том порядке,
в каком они размещались
в множестве.
Работа со списками
Именованные
элементы списка
В языке программирования Python словарем
называется структура данных, где элементы хранятся
в виде пар ключ: значение. В отличие от списков, где
доступ к значениям можно получить по индексам,
в словарях доступ к значениям получают по связанным
с ними ключам. Ключи должны быть уникальными
и обычно представляют собой строку, хотя допустимо
использование чисел и кортежей.
О
ID
В других языках
программирования
список часто называют
массивом, а словарь —
ассоциативным массивом
Чтобы создать словарь, нужно просто присвоить
переменной список разделенных запятыми пар ключ:
значение. Словари помещают в фигурные скобки.
Строки, как обычно, заключаются в кавычки. Ключ
и связанное с ним значение разделяются двоеточием:.
Пару ключ: значение можно удалить из словаря, указав
имя словаря и ключ в скобках после ключевого слова
del. И наоборот, пару ключ: значение можно добавить,
присвоив новое значение переменной, где указаны имя
словаря и новый ключ.
В Python у словарей есть метод keys(), который
с помощью записи через точку можно добавить
к имени словаря, чтобы вернуть список расположенных
в случайном порядке всех ключей словаря. Если вы
хотите, чтобы ключи были отсортированы в виде
буквенно-цифровой последовательности, просто
поместите выражение в круглые скобки после
стандартной функции sortedf)
С помощью оператора in можно найти, содержит ли
словарь конкретный ключ, для этого используется
синтаксис key in dictionary. Поиск вернет булево значение
True, если ключ найдется в указанном словаре, в ином
случае он вернет значение False.
Данные часто можно
соединить в пары по типу
ключ: значение. Например,
при создании веб формы
текстовое значение,
которое печатается в поле
ввода, обычно связывается
с текстовым именем
поля, которое выступает
в качестве ключа.
Словари — это последний тип контейнеров данных,
доступный в языке программирования Python. В целом,
подводя итоги, можно перечислить следующие типы:
• Переменная: хранит единичное значение.
• Список: хранит ряд значений с упорядоченными
индексами.
• Кортеж: хранит ряд фиксированных значений
в упорядоченной последовательности.
• Множество: хранит ряд уникальных значений
в виде неупорядоченной коллекции.
• Словарь: хранит ряд неупорядоченных значений
в виде пар ключ: значение.
Начните новую программу, инициализировав
словарь и выведя на экран тип данных
и содержимое словаря в виде пар ключ: значение:
info = {'name' : 'Bob', 'ref' : 'Python','s s' : 4 }
printf , type( info ))
printf , info )
diet ру
0
Далее выведите на экран одно значение,
обратившись к нему по ключу:
printf , info[ 'ref' ])
© ©
Теперь выведите на экран все ключи словаря:
printf , info.keysf))
Удалите из словаря одну пару ключ- значение
и добавьте новую, затем выведи ге ее содержимое
на экран:
del info| ]
infof ] =
printf , info )
0
Наконец, найдите в словаре конкретный ключ
и выведите на экран результат поиска:
printf *\пЕсть ли здесь ключ name?:' ,'name' in info )
Сохраните программу, затем запустите ее, и вы
увидите ключи и значения, сохраненные внутри
словаря.
Работа со списками
Краткие итоги
• В одном выражении .можно инициализировать
несколько переменных, использовав
последовательность операторов присваивания =.
В Python список — это переменная, где может
храниться набор единиц информации в качестве
последовательно нумерованных элементов, при
этом нумерация индексов начинается с нуля.
К данным, хранящимся в элементе списка, можно
обратиться, использовав имя списка и указав после
него индекс элемента в квадратных скобках [].
У элемента списка может быть более одного
индекса. Это характерно для многомерных списков,
например списков, где хранятся координаты X и Y.
У списков есть набор методов, которое через точку
можно добавить к имени списка для работы с ним.
Функция 1еп() возвращает длину указанного
в скобках списка.
Отдельный элемент списка можно удалить, указав
имя списка и индекс элемента после ключевого
слова del.
Кортеж в Python — это неизменяемый
список, значения элементов которого можно
присвоить отдельным переменным с помощью
«распаковывания последовательностей».
• К данным, хранящимся в элементе кортежа, можно
обратиться, использовав имя списка и указав после
него индекс элемента в квадратных скобках [].
В Python множество — это неупорядоченная
коллекция уникальных элементов, чьи значения
можно сравнивать и преобразовывать с помощью
методов множеств.
• К данным, сохраненным в элементе множества,
нельзя обратиться с помощью индекса элемента.
У множеств есть методы, которые с помощью
записи через точку можно добавить к имени
множества для сравнения множеств и их
преобразования.
В Python встроенный оператор принадлежности in
можно использовать, чтобы найти значение внутри
множества.
Множество можно преобразовать в обычный
список, использовав функцию list(). Это позволит
ссылаться на элементы данных по их индексу.
В Python словарь — это список пар ключ: значение,
где каждый ключ должен быть уникальным.
К данным, хранящимся в элементе словаря, можно
обратиться по имени словаря, после которого
в квадратных скобках |] указывается необходимый ключ.
Блоки
управления
В этой главе вы
увидите, как
создавать код,
влияющий на
п оследоватепъностъ
выполнения
инструкций
программы.
64 Ветвление и выборы
66 Циклы со счетчиком
68 Циклы с условием
70 Пропуск итерации
72 Ловим ошибки
74 Краткие итоги
Блоки управления
Ветвление и выборы
Конструкция if: elif: else:
в Python эквивалентна
выражениям switch или
case в других языках
программирования.
В Python отступы в коде
очень важны, поскольку
они обозначают блоки
кода для интерпретатооа.
В других языках
программирования для
этого используются
фигурные скобки {}.
Как и во многих других языках программирования,
в Python ключевое слово if служит для того, чтобы
добавить в код проверку условия, которое оценивается
на истинность и принимает булево значение True или
False. Это позволяет программе выполняться в различных
направлениях в зависимости от результатов проверки
и называется условным ветвлением.
В Python после выражения для проверки обязательно
ставится двоеточие:, инструкции, выполняющиеся,
если условие истинно, пишутся ниже на отдельной
строке, при этом делается отступ от уровня, на котором
находится строка с условием if. Размер отступа в целом
не важен, но он должен быть одинаковым во всех
строках. Таким образом, синтаксис конструкции
выглядит следующим образом:
if проверка условия:
инструкция, которая выполняется, если условие = True
инструкция, которая выполняется, если условие = True
При необходимости в проверку с if можно включить
альтернативные инструкции, которые выполняются,
если условие неверно. Это делается с помощью
добавления ключевого слова else после инструкций,
которые выполняются, если проверка проходит
успешно. После ключевого слова else ставится
двоеточие:, строка с ним находится на одном уровне
с ключевым словом if, а строки с инструкциями
располагаются с отступом. Таким образом синт аксис
в этом случае выглядит следующим образом:
if проверка условия:
инструкция, которая выполняется, если условие = True
инструкция, которая выполняется, если условие = True
else:
инструкция, которая выполняется, если условие = False
инструкция, которая выполняется, если условие - False
Условный блок if может сопровождаться альгернативной
проверкой условия, которая добаагяегся с помощью ключевого
слова elif («else if>>) и предлагает инструкции, которые будут
выполняться в случае, если алыврнативное условие окажется
истинным. Строка с ключевым словом elif также должна
располагаться на одном уровне с if, после elif ставится двоеточие:,
а инструкции располагаются с отступом. В конце можно
добавить ключевое слово else, предлагающее инструкции,
выполняющиеся в случае, если условия ложны. Полный
синтаксис структуры il-el'rt-else выгля ди1 «. ледующим образом:
if проверка условия!:
инструкция, которая выполняется, если условие! - True
инструкция, которая выполняется, если условие! = True
elif проверка условия2:
инструкция, которая выполняется, если условие2 = True
инструкция, которая выполняется, если условие2 = True
else:
инструкция, которая выполняется, если условия = False
инструкция, которая выполняется, если условия = False
о
о
Начните новую программу, инициализировав
переменную, приглашающую пользователя
ввести целое число:
num = int( input( 'Пожалуйста, введите число: *))
Далее проверьте переменную и выведите на
экран соответствующие ответы:
il num > 5 ;
print( i
elif num < 5 :
print( )
else :
print( |
О
if. РУ
Теперь проведите еще одну проверку,
использовав два выражения, и выведите ответ
только в случае успеха
it num > 7 ind num < 9 :
prints )
if num == 1 r num == 3 :
print( )
Сохраните программу, затем запустите ее, и вы
увидите условное ветвление в действии.
По умолчанию
данные, введенные
пользователем, относятся
к строкам, поэтому
для арифметического
сравнения они должны
быть преобразованы
в целочисленный тип
данных int с помощью
Функции int().
Ключевые слова and и or
используются для оценки
нескольких условий.
Оператор and возвращает
True, только если
выполняются все указанные
условия, а ключевое слово
or возвращает True, если
одно из них выполнено.
от
ЦП
Блоки управления
Циклы со счетчиком
В огличие от других языков
программирования, таких
как С, цикл for в Python
не позволяет определить
размер шага и момент
окончания работы цикла
Функция rangef)
может генерировать
как возрастающую,
так и убывающую
последовательность.
Как и в других языках программирования, в Python
для создания циклов используется ключевое слово for,
позволяющее перебрать все элементы списка, указанного
после ключевого слова in В Python эта конст рукция
должна заканчиваться двоеточием, а инструкции,
выполняющиеся при каждой итерации, размещаются
с отступом на новой строке:
tor каждый элемент in имя списка:
инструкция, выполняющаяся при каждой итерации
инструкция, выполняющаяся при каждой итерации
Поскольку строка — это, по сути, список символов,
конструкция for... in позволяет перебрать эти символы
по одному. Подобным же образом эта конструкция
итерирует каждый элемент списка, кортежа, множества
и каждый ключ в словаре.
Цикл for... in итерирует все элементы любого списка
или строки в порядке, в котором они появляются
в последовательности, при этом нельзя напрямую
определить количество итераций, условие прекращения
работы или размер шага итерации. Тем не менее
для перебора последовательности чисел можно
воспользоваться встроенной функцией rangef), указав
в скобках конечное числовое значение. Таким образом
будет сгенерирована последовательность чисел,
начинающаяся с 0 и продолжающаяся до указанного
числа, но не включающая его. Например, range(5) создает
последовательность 0, 1, 2, 3, 4.
При необходимости в скобках функции range() можно
указать начальное и конечное значения, разделив их
запятыми. Так, range(l, 5) генерирует последовательность
1, 2, 3, 4. Также можно указать начальное значение,
конечное значение и значение шага, также разделив
их запятыми. Скажем, функция rangefl, 14, 4) создает
последовательность 1, 5, 9, 13.
Для того чтобы вывести на экран индекс каждого
элемента и связанное с ним значение, можно
использовать функцию enumeratef), указав в круглых
скобках имя списка.
Во время итерации нескольких списков одновременно
можно вывести на экран значения с одним индексом
в каждом списке. Для этого используется функция zipf),
в скобках указываются разделенные запятой имена
списков.
При итерации словаря можно вывести на экран каждый
ключ и связанное с ним значение, использовав метод
словарей itemsf) и указав разделенные запятыми два
имени переменных после ключевого слова for (одна
служит для ключей, другая — для их значений).
Начните новую программу, инициализировав
три переменных: список, кортеж и словарь:
chars = [ , ]
fruit = ( . , )
info = { name' : 'Mike', 'r f' : 'Python', 'sys' : 'Win' }
Далее добавьте инструкции, чтобы вывести на
экран значения всех элементов списка:
printf , end - )
for item in chars :
printf item , end = )
Теперь добавьте инструкции, чтобы вывести на
экран все элементы списка и их индексы:
printf '\пПронумерованные:\г , end = ' *)
for item in enumeratef chars )
printf item , end = j
Добавьте инструкции, чтобы вывести на экран
все элементы списка и кортежа:
printf , end = )
for item in zipf chars , fruit) :
printf item , end = )
Наконец, добавьте инструкции, чтобы вывести
на экран все ключи словаря и связанные с ними
значения:
printf । )
for key , value in info.itemsf) :
printf key . , value )
Сохраните программу, затем запустите ее, и вы
увидите, как элементы отображаются на экране
в итерациях циклов.
& 'OLE Shell 3.10.4 - □ X
File Edit Shell Debug Options Window Help
========= RESTART: C:\MyCode\for.py =
Elements: ABC
Enumerated: (0 'A') (1, 'B'J (2, 'C')
Zipped: ('A'. 'Apple') ('B'. Banana') f'C, 'Cherry')
Paired.
name - Mike
ref = Pythcn
sys = Win
В программировании все,
что содержит несколько
элементов, которые можно
перебрать с помощью
цикла, называется
итерируемым объектом.
Блоки управления
3 отличие от других
ключевых слов в Python,
True и False* всегда
пишутся с заглавных букв.
Циклы с условием
Цикл — это часть программного кода, которая
автоматически повторяется. Одно полное выполнение
всех инструкций внутри цикла называется итерацией
или повторением. Длина цикла управляется проверкой
условия внутри цикла. Пока тестовое условие остается
истинным (.True), цикл будет продолжаться. Когда
условие станет ложным (False), он закончится.
В программировании на Python цикл можно создать
с помощью ключевого слова while. За ним обычно
следует проверяемое выражение и двоеточие:.
Инструкции, выполняющиеся, пока условие остается
истинным, пишутся ниже на отдельных строках
с отступами. Важно отметить, что блок с оператором
цикла должен включать инструкцию, меняющую
результат оценки проверяемого условия, иначе может
получиться бесконечный цикл.
Отступы при написании блоков кода должны
соблюдаться и в интерактивной оболочке Shell, как это
показано в примере ниже, где с помощью цикла while
воспроизводится последовательность чисел Фибоначчи.
Интерактивный
интерпретатор Python
автоматически делает
отступы и дает понять, что
ожидает от вас дальнейших
инструкций по коду.
' Есть еще одно ключевое
слово, которое пишется
с заглавной буквы.
None. — Прим. оед.
Циклы могут быть вложенными, что позволяет
завершить выполнение всех итераций внутреннего
вложенного цикла при каждой итерации внешнего.
Перед обьявлением каждого цикла можно
инициализировать переменную «счетчика» с начальным
значением. Она включается в проверяемое выражение
и увеличивается при каждой итерации, пока значение
переменной не превышает указанное в условии. В этот
момент цикл заканчивается.
Начните новую программу, инициализируйте
переменную счетчика и определите внешний
цикл, использовав переменную в условии для
проверки:
i = 1
while i < 4 :
Теперь после отступа добавьте инструкции для
того, чтобы вывести на экран значение счетчика
и увеличивать его на единицу при каждой
итерации цикла:
print( 'Итерация внешнего цикла:', i)
i += 1
О
о
о
Далее, по-прежнему с отступом, добавьте
инициализацию еще одной переменной счетчика
и объявите внутренний цикл, использовав
переменную в условии для проверки:
j = l
whi'e j < 4 :
Наконец, добавив еще отступ, напишите
инструкции, чтобы вывести на экран значение
этого счетчика и увеличивать его на единицу
при каждой итерации цикла:
print( 'ХГИтерация внутреннего цикла:', J )
j+= 1
Сохраните программу, затем запустите ее, и вы
увидите, что выводится на экран при каждой
итерации цикла.
while.ру
Результаты работы
внутреннего цикла
выводятся на экран
с отступом от результатов
работы внешнего цикла,
что достигается с помощью
символа табуляции \1.
оо
СО
Оператор присваивания
+= в выражении i += 1 —
это сокращенная запись
вО|ражения i = i+1. Для
присваивания значений
переменным также можно
использовать операторы *=,
/= и -=.
Блоки управления
nest.ру
Пропуск итерации
Для того чтобы досрочно остановить работу цикла,
когда будет достигнуто определенное условие, в Python
можно использовать ключевое слово break. Оператор
break находится внутри блока инструкций цикла, и ему
предшествует тестовое выражение.
Когда проверка возвращает True, цикл тут же прерывается
и пршрамма переходит к следующему заданию. Например,
в случае с вложенным внутренним циклом она переходит
к следующей итерации внешнего цикла.
Начните новую программу, объявив цикл
с тремя итерациями:
for i >n range( 1, 4 ) :
Теперь добавьте отступ и создайте вложенный
внутренний цикл также с тремя итерациями:
for j in range( 1, 4 )
Далее с еще одним отступом добавьте
к внутреннему циклу инструкцию, чтобы
вывести на экран значения переменных
внешнего и внутреннего циклов при каждой
итерации внутреннего цикла:
printf , i, , j)
Сохраните программу, затем запустите ее, и вы
увидите, что выводится на экран при каждой
итерации цикла.
£0^'
Сравните вложенном цикл
for с вложенной циклом
while, описанным на с. 67
0
Вставьте оператор break в начале внутреннего
цикла, чтобы прервать его, и снова запустите
программу:
break.ру
if I = 2 and j “ 1
printf 'Прервать внутренний цикл, когда i=2 j=l')
break
Для того чтобы пропустить одну итерацию цикла,
когда будет достигнуто определенное условие, можно
использовать ключевое слово continue. Оператор
continue находится внутри блока инструкций цикла,
и ему предшествует тестовое выражение. Koi да
проверка возвращает True, одна итерация заканчивается
и программа переходит к следующей итерации.
Оператор break
останавливает все три
итерации внутреннего
цикла, когда внешний цикл
запускает его ео второй
раз.
Теперь добавьте оператор continue в начале
внутреннего цикла, чтобы пропустить его первую
итерацию, затем снова запустите программу:
if i == 1 and j == 1 :
printf 'Продолжить внутреннй цикл, когда i=l j=l')
continue
continue ру
Оператор continue
пропускает первую
итерацию внутреннего
цикла, когда внешний цикл
запускает его в первогй раз.
Блоки управления
Ловим ошибки
Разделы программы, где можно ожидать появление
ошибок, например те части, где обрабатывается
пользовательский ввод данных, обычно помещают
в блок try , except, чтобы обработать исключения.
Инструкции для выполнения группируются в блоке
try:, а исключения обрабатываются в следующем
за ним блоке except:. При необходимости можно также
добавить блоки else: и finally:, содержащие инструкции,
которые выполняются после обработки исключений.
Python распознает большое количество исключений,
таких как ошибка NameError, возникающая,
когда имя переменной не определено, ошибка
IndexError, возникающая при попытке обратиться
к несуществующему индексу списка, и ошибка ValueError,
возникающая, когда встроенная операция или функция
возвращает неприемлемое значение.
Каждое исключение возвращает описывающее его
сообщение, которое полезно присваивать переменной
с помощью ключевого слова as. Затем переменную
можно использовать, чтобы вывести на экран
сообщение при появлении исключения.
try. ру
Начните новую программу, инициализировав
переменную со строковым значением:
title 'Программирование для начинающих*
Далее добавьте блок try, который пытается
вывести на экран значение переменной, при
этом имя переменной определено неправильно:
try :
prinr( titel )
Теперь добавьте блок except, чтобы вывести на
экран сообщение об ошибке, когда произойдет
NameError
except NameError эь msg .
printf msg )
В некоторых языках
программирования такая
структура называется
механизмом обработки
ошибок try-catch.
Сохраните программу, затем запустите ее, и вы
увидите, как обрабатываются ошибки.
Можно обработать несколько исключений, определив их
через запятую в скобках внутри блока except:
except ( NameError, IndexError) as msg .
printf msg )
Также можно дать интерпретатору понять, что нужно
сообщить об исключении, использовав ключевое слово
raise, чтобы определить тип исключения, который нужно
распознать. В скобках можно указать собственное
описательное сообщение.
о
Начните новый скрипт на Python,
инициализировав переменную с целочисленным
значением:
day = 32
Теперь добавьте блок try:, проверяющий
значение переменной, затем определите
исключение и сообщение об ошибке:
try :
if day > 31 :
raise ValueErrorf 'Неверный номер дня*)
Я Здесь можно добавить другие инструкции для
выполнения.
raise.ру
Далее добавьте блок except:, чтобы вывести на
экран сообщение об обнаруженной ошибке
ValueError:
except ValueError as msg :
printf 'Программа нашла ошибк, , msg )
Теперь добавьте блок finally:, чтобы вывести
сообщение после того, как исключение будет
успешно обработано:
finally :
printf 'Но сегодня все равно прекрасный день.*)
Вы можете включите
несколько блоко! except:,
чтобь! распознавать
оазличные встроенные
исключения.
Сохраните программу, затем запустите ее, и вы
увидите, как обрабатывается ошибка.
□ x
I*, IDLE Shell 3.10.4
File Edit Shell Debug Options Window Help
»>
======== RESTART: C:\MyCode\ralse.py ==
The Program Found An Invalid Day Number
But Today Is Beautiful Anyway.
Инструкции в блоке try
выполняются до тех
пор, пока не возникнет
исключение.
Блоки управления
Краткие итоги
Ключевое слово if проводит проверку указанного
в выражении условия и принимает булевы
значения True или False.
Условное ветвление позволяет программе выбирать
между разными вариантами событий с помощью
ключевых слов if, else и elif.
В Python после выражения для проверки ставится
двоеточие:, а блоки инструкций размещаются
с отступами.
Цикл for... in проходит по всем элементам
указанного списка или строки.
В циклах for ... in в Python ставится двоеточие:
после первой строки, блоки инструкций
размещаются с отступами.
Функция ranged создает числовую
последовательность, которую можно использовать,
чтобы определить длину цикла for.. in.
В функцию enumerated можно передать имя списка,
чтобы вывести на экран индекс каждого элемента
вместе с сохраненным значением.
Функцию zip() можно использовать, чтобы вывести
на экран значения элементов с одинаковыми
индексами из разных списков.
Цикл while повторяется, пока первоначальное
условное выражение принимает значение True,
и прекращает работу, когда условие перестает
выполняться (возвращает значение False).
После условного выражения в цикле while ставится
двоеточие:, блоки инструкций размещаются
с отступами.
Значение переменной счетчика можно проверять
в тестовом выражении, чтобы контролировать
количество итераций цикла.
Ключевое слово break немедленно прерывает
выполнение цикла, в котором он объявлен.
С помощью ключевого слова continue можно
пропустить одну итерацию цикла, когда проверка
условия возвращает False
Ожидаемые ошибки времени выполнения
программы можно обработать с помощью блока
инструкций try... except.
При необходимости можно использовать блок
finally, чтобы определить инструкции, которые
будут выполняться после того, как обработаются
исключения.
В Python после ключевых слов try, except, else
и finally ставится двоеточие:, а блок инструкций
размещается с отступами.
Создание
функций
В этой главе
вы увидите,
как создавать
в программах
блоки кода,
которые можно
использование
снова и снова.
76 Объявление функций
78 Добавление параметров
80 Возврат результатов
82 Сохранение функций
84 Импорт функций
86 Краткие итоги
Создание функций
Инструкции в функциях
должны размешаться
с отступами от уровня,
на котором находится
строка с объявлением
функции. Размер отступов
всегда должен быть
одинаковым, чтобы
интерпретатор Python мог
распознавать блоки кода.
Старайтесь не пользоваться
глобальными
переменными,
чтобы избежать
случайных конфликтов.
По возможности
используйте только
локальные переменные.
Объявление функций
Ранее в этой книге мы использовали встроенные
функции языка программирования Python, например
функцию print(). Тем не менее в большинстве программ
используются объявленные разработчиком функции,
которые вызываются по необходимости во время
работы программы.
В Python собственную функцию можно создать
с помощью ключевого слова def (definition — определение),
за которым следует имя на ваш выбор и круглые скобки ().
Разработчик может выбрать для функции любое имя,
единственное правило — не использовать ключевые
слова языка программирования и названия встроенных
функций. Эта строка должна заканчиваться символом
двоеточия;. Инструкции, которые выполняются, когда
вызывается функция, размещаются на строках ниже
с отступами. Синтаксис объявления функции выглядит
следующим образом:
def имя функции ().
инструкция для выполнения
инструкция для выполнения
Когда заявленные в функции инструкции выполняются,
поток программы возвращается в точку, находящуюся
непосредственно после вызова функции. Такой
модульный принцип организации очень полезен
в программировании, поскольку позволяет изолировать
рутинные процедуры, которые могут вызываться
многократно.
При создании собственных функций необходимо
понимать доступность («область видимости»)
переменных в программе:
• Существуют переменные, которые создаются вне
функции, но на них могут ссылаться инструкции
внутри функции. Такие переменные являются
«глобальными».
• Существуют переменные, которые создаются
внутри функции. На них нельзя сослаться вне
функции, где они были созданы. Такие переменные
являются локальными.
Ограниченный доступ к локальным переменным
означает, что в разных функциях могут появляться
переменные с одинаковыми именами, но конфликтов
при этом не возникает.
Если вы хотите, чтобы к локальной переменной можно
было получить доступ во всей программе, ее нужно
объявить с помощью ключевого слова global, за которым
следует только имя переменной. Далее переменной
может быть приписано значение, к которому можно
обращаться из любого места в программе. Если
глобальная и локальная переменные имеют одно и то же
имя, то функция будет использовать локальную версию.
о
о
о
о
о
0
о
Начните новую программу, инициализировав
глобальную переменную:
giobal_var = 1
Далее создайте функцию с именем «my_vars»,
которая будет выводить на экран значение,
содержащееся в глобальной переменной:
def myvarsf) :
printf 'Глобальная переменная:', global_var)
Теперь, не забывая про отступы, добавьте
к блоку инструкций функции инициализацию
локальной переменной. Затем выведите на экран
ее значение:
local_var = 2
printf 'Локальная переменная: , local var)
Не забывая про отступы, создайте в блоке
инструкций функции вторую глобальную
переменную и присвойте ей начальное значение:
global inner_var
inner_var = 3
После функции добавьте ее вызов, чтобы
выполнить инструкции, которые содержит
в себе функция:
my_vars()
Наконец, добавьте инструкцию, чтобы вывести
на экран значение, содержащееся во второй
глобальной переменной:
printf - , inner_var )
Сохраните программу, затем запустите ее, и вы
увидите, как созданная вами функция выводит
на экран значения переменных.
def.py
Переменные, которые
не являются глобальными,
но появляются во внешней
области видимости, можно
объявить с помощью
ключевого слова nonlocal.
Обычно ключевое слово
nonlocal используется
во вложенных функциях,
когда переменная,
объявленная во внутренней
функции, на самом деле
не принадлежит этой
функции Таким образом
она становится видимой
из внешней функции.
Создание функций
Параметры можно назвать
особыми переменными,
которые используются
исключительно внутри
функции. Они подчиняются
тем же правилам
именования, что и обычные
переменные.
Если называть переменные,
которые используются
как аргументы функции,
так же как параметры
при объявлении
функции, движение
данных в программе
часто становится более
очевидным, но лучше
избегать этого, если
код становится менее
понятным.
Добавление
параметров
При объявлении собственной функции в программе
можно при необходимости указать имя параметра
в скобках после имени функции. Таким образом
в параметр можно передать значение аргумента, указав
ею в скобках при вызове функции. Теперь функция
может использовать переданное значение во время
выполнения инструкций, обращаясь к этому значению
через имя параметра. Например, определим функцию,
принимающую параметр, который выводится на экран:
def echo* (user):
рппЦ'Пользователы', user)
В команде вызова функции необходимо указать
в скобках значение аргумента, которое будет выводиться
на экран:
есКо('Майк')
Функция может принимать несколько параметров,
которые указываются в скобках через запятую:
def echo(user, lang, sys):
рппЦ'Пользователь:', user, 'Язык:1, lang, 'Платформа:', sys)
Вызов функции с несколькими параметрами должен
включать го же количество аргументов. Например,
вызвать функцию с несколькими параметрами можно
следующим образом:
echofMike’, 'Python', ‘Windows')
Переданные значения должны указываться в том же
порядке, что и параметры при объявлении функции.
В ином случае во время вызова должны быть указаны
имена параметров:
echo(lang = ’Python', user = 'Mike', sys = ’Windows')
При объявлении функции при необходимости
можно указать значения необязательных параметров
по умолчанию. Необязательные параметры указываются
после всех обязательных параметров. Значение
по умолчанию будет переопределено, если в вызове
будет указано значение этого параметра, но функция
будет использовать это значение, если в вызове не будет
передано аргумента:
def echo(user, lang, sys = 'Linux'):
рппТ('Пользователь:', user, 'Язык:', lang, 'Платформа-', sys)
Это означает, что функцию можно вызвать, использовав
значение параметра по умолчанию и передав меньше
значений, чем количество параметров, указанных при
объявлении функции. Или же вы можете передать
то же количество аргументов, переопределив значение
по умолчанию.
* Данное имя echo зарезервировано в Bash (стандартная
командная оболочка). — Прим. ред.
Начните новую программу, объявив функцию с
тремя параметрами, которая будет выводить на
экран переданные значения аргументов:
def echo( user , lang , sys ) :
print! 'Пользователь:', user, 'Язык:', lang, 'Платформа , sys)
О
Далее вызовите функцию, передав в ее параметры
строковые значения аргументов в том порядке,
в каком они появляются:
echo( г', 'F г»', Ч lows')
param.ру
Теперь вызовите функцию, передав в ее
параметры строковые значения аргументов
и указав имена параметров:
echo( lang = Pyth , sys = 'Mr , user = )
Объявите еще одну функцию для вывода на
экран значений параметров. В ней укажите два
параметра, имеющих значения по умолчанию:
def mirror( user = , lang = 'Python' ) :
printf '\пПользователь:', user, 'Язык:', lang )
0
Наконец, добавьте вызовы второй функции
так, чтобы были использованы значения
по умолчанию, и так, чтобы они были
переопределены:
mirror!)
mirror! lang = )
mirrorf )
mirror! , )
Сохраните программу, затем запустите ее, и вы
увидите, как созданная вами функция выводит
на экран значения аргументов или значения
параметров по умолчанию.
& IDLE Shell 3.10.4 - □ X
File Edit Shell Debug Options Window Help
======== RESTART- C:\MyCode\param.py =======
User: Mike Language: Python Platform- Windows
User: Anne Language: Python Platform: Mac OS
User: Carole Language: Python
User: Carole Language: Java
User: Tony Language: Python
User: Susan Language; C++
Аргументы — это реальные
значения данных, которые
передаются в параметры
функции при ее вызове.
Создание функций
Возврат результатов
При вызове встроенная функция str() возвращает
строковое представление значения, переданного
в нее в качестве аргумента. Точно так же созданная
разработчиком функция при вызове будет возвращать
какое-то значение. Чтобы определить, какое значение
должно возвращаться, используется ключевое слово
return. Например, функция, возвращающая сумму
от сложения двух чисел, указанных в виде параметров,
выглядит следующим образом:
О
00
Значения параметров
по умолчанию можно
определить при
объявлении Функции.
def sum* ( a, b ).
return а + b
Во время вызова функции можно присвоить
возвращаемое значение переменной, чтобы далее
использовать его в программе:
total = sum( 8, 4 )
print( 'Восемь плюс четыре равно:', total )
Или же возвращаемый результат можно использовать
непосредственно в той же строке:
print( 'Восемь плюс четыре равно:', sum( 8, 4 ))
Обычно оператор return появляется в самом конце
блока функции и возвращает окончательный результат
выполнения всех ее инструкций.
Тем не менее иногда этот оператор может появиться
раньше, Ч1обы прервать выполнение всех последующих
инструкций в блоке. Это немедленно возобновляет
выполнение программы в точке вызова. При
необходимости оператор return может определять
значение, возвращаемое при вызове функции, или
значение может игнорироваться. Если значение
не указано, предполагается, что функция возвращает
значение по умолчанию None. Обычно это используется,
чтобы прервать исполнение инструкций после того, как
проверка условия даст отрицательный результат False
Например, ниже таким условием становится передача
аргумента со значением ниже определенного числа:
def sum( а, Ь ):
if а < 5 :
return
return а + b
В данном случае функция возвращает значение
по умолчанию None, если первый переданный
аргумент меньше пяти, и тогда последняя инструкция
не выполняется.
Когда в функции выполняются какие-либо
арифметические действия, введенные пользователем
данные можно проверить на то, являются ли они целыми
числами, с помощью встроенной функции isdigit().
* Sum — это название встроенной функции, которая станет
недоступной пои создании пользовательской функции с тем же
именем — Прим. ред.
Начните новую программу, инициализировав
переменную, приглашающую пользователя
ввести целое число для дальнейших
манипуляций:
num = input( 'Введите целое число:*)
О
Далее добавьте объявление функции,
принимающей один аргумент, передаваемый при
вызове функции:
def square( num ) :
return.py
Теперь с отступом добавьте блок инструкций,
проверяющий, является ли переданное значение
аргумента целым числом, и прерывающий
дальнейшее выполнение функции в случае, если
проверка не проходит:
if not num jsdigit() .
return 'Ошибка звсда’
He забывая об отступах, добавьте инструкции,
чтобы преобразовать значение переданного
аргументы в целочисленный тип данных int,
а затем вернуть результат возведения числа
в квадрат при вызове функции:
num = int( num )
return num * num
Наконец, добавьте инструкцию для вывода на
экран результата в виде строки и возвращаемого
значения из вызова функции:
print( num , , square( num ) )
Сохраните программу, затем запустите ее снова,
и вы увидите, как на экране отображается
возвращаемое значение функции.
Ц, IDLE Shell 3.10.4 - □ X
File Edit Shell Debug Options Window Help
======= RESTART: C:\MyCode\return.py =======
Enter An Integer 8
8 Squared is: 64
»>
======= RESIART: C:\MyCoue\return.py =======
Enter An Integer 8.0
8.0 Squared Is: Invalid Entry
>»
======= RESTART: C:\MyCode\return.py =======
Enter An IntegenEight
Eight Squared Is; Invalid Entry
»> 1
Помните, что вводимые
пользователем данные
всегда относятся
к типу str, поэтому для
арифметических операций
они должны быть
преобразованы в тип int
или float.
Создание функций
cat ру
kitty.py
Сохранение функций
Объявленные функции полезно хранить в одном
или нескольких отдельных файлах. Так их проще
поддерживать, а также использовать в различных
программах, не копируя объявление функций в каждую
из них. Каждый файл Python, где хранятся объявленные
функции, называется модулем. Имя модуля
представляет собой название файла без расширения.ру.
Доступ к сохраненным в модуле функциям
можно получить с помощью ключевого слова
import, за которым следует имя модуля. Хотя это
и не обязательно, но традиционно все команды импорта
размещают в начале программы.
Импортированные функции можно вызвать,
использовав их имя, добавленное через точку к имени
модуля. Например, функцию steps из импортированного
модуля под названием ineasy можно вызвать с помощью
выражения measy.steps().
Если сохраненные в модуле функции имеют параметры,
часто бывает полезно присваивать этим параметрам
значения по умолчанию при объявлении функции. Так
функция становится более универсальной, поскольку при
вызове необязательно указывать значение параметра.
Начните новый модуль, объявив функцию,
которая по умолчанию хранит строковое
значение в качестве параметра и выводит его на
экран:
del purr( pet = ) :
printf pet, )
Далее добавьте еще две функции, которые по
умолчанию также хранят строковые значения
в качестве параметров и могут выводить их на
экран:
det lick( pet - ) :
printf pet, )
del nap( pet = ) :
printf pet, )
Теперь сохраните файл как «cat.py», чтобы
модуль назывался «cat».
Начните новую программу, сделав функции
модуля «cat» доступными с помощью команды
импорта:
import cat
Далее вызовите каждую функцию, не передав
никакие аргументы:
cat.purrQ
cat.lickf)
cat.nap()
Теперь вызовите каждую функцию еще раз,
передав в каждую аргумент. Сохраните файл.
cat.purr( )
cat.lickf )
cat.nap( )
Начните еще одну программу . Снова
сделайте функции модуля «cat» доступными,
импортировав его в файл:
import cat
О
о
ф
Далее запросите у пользователя имя питомца,
чтобы переопределить значение параметра по
умолчанию;
pet = input( )
Наконец, вызовите каждую функцию, передав в
качестве аргумента определенное пользователем
значение:
cat.purr( pet)
cat.lickf pet)
cat.nap( pet )
Сохраните программу, затем снова
запустите ее, и вы увидите результат работы
импортированного модуля в каждой программе.
tiger.py
00
Импортируя модуль, вы
можете создать имя-
псевдоним, использовав
ключевые слова import
as. Например, команда
impoit cat as tom позволит
вам использовать tom
в качестве префикса при
вызове функций.
Создание функций
Если импортировать
отдельные имена функций,
то имя модуля не будет
импортировано и его
нельзя будет использовать
в качестве префикса для
вызова функции
dog ру
pooch, py
Импорт функций
Внутри каждой программы и каждого модуля на Python
есть своя собственная «таблица имен», которая
используется всеми функциями, объявленными
только в этом контексте. Это позволяет избегать
возможных конфликтов с функциями с такими же
именами из другого модуля, если оба модуля будут
импортированы в одну программу.
Когда вы импортируете модуль с помощью команды
import, таблица имен модуля не добавляется к таблице
имен программы — в нее включается только имя
.модуля. Именно поэтому вам приходится вызывать
функции модуля, используя в качестве префикса его
имя. Если импортировать функцию steps из модуля под
названием «ineasy» и еще одну функцию steps из модуля
под названием «dance», то их можно будет вызывать без
всяких конфликтов как ineasy,steps() и dance.steps().
В целом предпочтительнее избегать конфликтов,
импортируя название модуля и вызывая его функции
через имя модуля, но отдельные функции можно
импортировать с помощью конструкции from ... import.
Имя модуля указывается после ключевого слова from,
а имена функций перечисляются через запятую после
ключевого слова import. При необходимости после
слова import можно поставить символ звездочки *
и импортировать все функции в таблицу имен
программы. Такой способ импорта позволяет вызывать
функции, не указывая перед ними имя модуля.
Начните новый модуль, объявив функцию,
которая по умолчанию хранит строковое значение
в качестве параметра и выводит его на экран:
def bark( pet = j :
printf pet, )
Далее добавьте еще две функции, которые по
умолчанию также хранят строковые значения
в качестве параметров и могут выводить их на
экран:
def I ick( pet = ) ;
printf pet, )
del nap( pet = ) :
printf pet, )
Теперь сохраните файл как dog.py. чтобы модуль
назывался «dog».
Начните новую программу, импортировав
отдельные функции из модуля «dog»:
from dog import bark , lick , nap
Далее вызовите каждую функцию, не передав
аргументы:
bark()
lick()
nap()
О
о
о
о
Теперь вызовите каждую функцию еще раз,
передав в каждую аргумент. Сохраните файл.
bark( и )
lick( )
пар( )
Начните еще одну программу. Сделайте функции
модуля «dog» доступными, импортировав их
в файл:
from dog import *
Далее запросите у пользователя имя питомца,
чтобы переопределить значение параметра по
умолчанию:
pet = input( I
Наконец, вызовите каждую функцию,
передав в качестве аргумента определенное
пользователем значение.
bark( pet)
lick( pet)
nap| pet)
Сохраните программу, затем снова
запустите ее, и вы увидите результат работы
импортированных функций в каждой
программе.
fido.py
00
U1
В более крупных
программах можно
импортировать модули
в другие модули и, таким
образом., выстраивать
иерархию модулей.
Создание функций
Краткие итоги
О
00
• Функции объявляются с помощью ключевого слова
def, за которым следует имя функции по вашему
выбору и круглые скобки ().
• Строка с объявлением функции должна
заканчиваться символом двоеточия, блок
с инструкциями, которые выполняются при вызове
функции, размещается с отступами.
• К глобальным переменным можно обратиться
в любом месте программы.
• К локальным переменным можно обратиться
только в той функции, где они объявлены.
• Локальную переменную можно сделать доступной
глобально, объявив ее с помощью ключевого слова
global.
• Параметры функции — это особые переменные,
которые используются только внутри функции,
аргументы — эго значения данных, которые
передаются в параметры.
• Параметры объявляются через запятую внутри
круглых скобок при определении функции.
• При вызове функции в каждый из параметров
необходимо передать аргумент, если только при
объявлении функции не указано какое-либо
значение по умолчанию.
• При вызове функции данные должны передаваться
в параметры в том же порядке, в каком указаны
параметры при объявлении функции, в ином
случае следует определить имена параметров.
• При необходимости ключевое слово return можно
использовать внутри функции, чтобы вернуть
значение в точку вызова.
• Функции можно сохранять в модулях, имена
которых совпадают с именами файлов без
расширения.ру.
• Команда import делает функции модуля
доступными в программе, если указать имя модуля
и через точку имя функции.
• Внутри каждою модуля на Python существует
собственная таблица имен, поэтому одинаковые
названия функций в разных модулях
не конфликтуют.
• Конструкция from ... import * делает все функции
модуля доступными в программе без указания
имени модуля через точку.
• Конструкцию import * можно использовать, чтобы
импортировать функции модуля в таблицу имен
программы.
Алгоритмы
сортировки
В этой главе
показано, как
создавать
различные
алгоритмы,
сортирующие
следователъности.
88 Сортировка
90 Сортировка
92 Сортировка
94 Сортировка
96 Сортировка
98 Сортировка
с копированием
выбором
вставками
пузырьком
слиянием
с разделением
100 Краткие итоги
Алгоритмы сортировки
3 Python имеется
встроенный метод
сортировки sort(),
описанный на с. 52,
но он работает только
со списками Иногда
возникает необходимость
отсортировать какую-либо
другую структуру данных.
3 этой главе показано
на примерах, как можно
создать подобные
алгоритмы в коде.
Сортировка
с копированием
Алгоритм — это четко определенная последовательность
инструкций для выполнения какой-либо задачи.
Каждый алгоритм получает одно или несколько
значений на входе и производит одно или несколько
результирующих значений на выходе.
В коде алгоритм может быть создан как функция, где
команды определяют последовательность инструкций,
необходимых, чтобы выполнить задание. Входящие
значения могут быть переданы как аргументы при
вызове функции, а результирующие значения —
возвращены как выходные переменные. С помощью
структур данных и структур управления можно создать
различные алгоритмы для того, чтобы сортировать
списки в определенном порядке.
Эффективность сортировки может зависеть от того,
какой список необходимо отсортировать, поэтому
алгоритм лучше подбирать под конкретное задание.
Если для решения задачи нужен отсортированный
список, но первоначальный список при этом должен
остаться нетронутым, в функцию алгоритма в качестве
аргумента можно передать ссылку на список.
Затем функция делает копию первоначального
списка, сортирует элементы копии и возвращает
отсортированную копию на выходе. Алгоритм
сортировки с копированием преобразует значения
элементов в массив, затем сортирует их в порядке
возрастания.
Элементы массива
нумеруются с 0. Поэтому
в данном примере элемент
[0] содержит значение 5,
элемент [1] — значение 3
и т.д.
о
о
о
о
Начните новую программу, объявив
функцию, принимающую в качестве входных
данных ссылку на список и возвращающую
отсортированную копию на выходе:
def copy_sort( array ) :
copy = array[: ]
sorted_copy = I ]
# Здесь добавляется последовательность
действий для выполнения алгоритма.
return sorted_copy
Затем с отступом добавьте последовательность
инструкций для того, чтобы по порядку
вставить скопированные значения элементов
в пустой список:
whilp 1еп( сору ) > О
minimum = О
for element in rangef 0 , len( copy )) :
if copy[ element ] < copy[ minimum ] :
minimum = element
print( , copy[ minimum ], \
,copy)
sorted_copy.append( copy.popf minimum ))
Теперь добавьте выражения, чтобы создать
и вывести несортированный список:
array = [5,3,1,2,6,4]
printf 'Сортировка с копированием..ДпМассив:', array)
Наконец, добавьте инструкции, чтобы
вывести на экран отсортированную копию
и несортированный список, затем сохраните
и запустите программу, чтобы увидеть,
что первоначальный список остается
неотсор тированным:
printf , copy_sort( array ))
printf la . , array )
copysori.py
00
CD
Каждое значение
по порядку удаляется
из копии списка, чтобы
создать отсортированную
версию При этом элементы
по очереди добавляются
к пустому массиву.
Алгоритмы сортировки
Сортировка выбором
Часто бывает, что элементы несортированного списка
нужно отсортировать «на месте», не создавая копию
массива, как мы делали в предыдущем примере.
Существует несколько популярных алгоритмов, которые
можно применить для сортировки массивов на месте.
Каждый из них использует для этого различные методы
и имеет свои сильные и слабые стороны.
Алгоритм сортировки выбором рассматривает каждый
элемент в неотсортированной части массива и выбирает
элемент, содержащий наименьшее значение. Затем он
меняет значение выбранного элемента с элементом,
находящимся в начале неотсортированной части
массива, таким образом увеличивая отсортированную
часть массива и уменьшая неотсортированную. Этот
процесс продолжается до тех пор, пока все элементы
не окажутся отсортированными в порядке возрастания.
Сортировка выбором — простой, основанный
на перестановке алгоритм, который достаточно легко
понять и превратить в код функции. Это один из самых
эффективных алгоритмов сортировки небольших
массивов примерно из 20 элементов.
о
ОТ
В данном примере
последний элемент уже
содержит максимальное
значение, когда
происходит сортировка
предпоследнего элемента.
Начните новую программу, объявив функцию,
куда на вход передается ссылка на список и где
начинается цикл, чтобы сохранить значение
каждого элемента и его текущий индекс:
def selection_sort( array ):
foi index in rangef 0 , lenf array ) -1)
value - array I index ]
current - index
selection.py
# Здесь добавляется последовательность
действий для выполнения алгоритма.
Затем добавьте последовательность инструкций
для выполнения алгоритма, который будет раз за
разом менять минимальное неотсортированное
значение с первым неотсортированным
значением:
for element in rangef index+1, lenf array ) ) :
if arrayf element ] < arrayf current ] :
current = element
arrayf index ] = arrayf current ]
arrayf current |= value
printf '^Рассматривается элемент!', Index,'] из
, array)
Теперь добавьте выражения, чтобы создать
и вывести на экран несортированный список:
array = [5,3, 1,2,6,4]
printf 'Сортировка выбором..ДпМассив , array )
Наконец, добавьте инструкции, чтобы вызвать
функцию с алгоритмом и еще раз вывести на
экран список, на этот раз уже отсортированный:
selectiun_sort( array I
printf , array )
& «DIE Shell 3.10.4
File Edit Shell Debug Opvons Window Help
====== RESTART: C.\MyCode\selection.py =====
Selection Sort...
Array: [5,3,1. 2, 6. 4]
Resolving elementf o] to [1.3.5.2.6.4]
Resolving element} 1 ] to [1. 2. 5. 3. 6 4^
Resolving elementf 2 ] to [1,2, 3. 5. 6, 4]
Resolving elementf 3 ] to [1, 2. 3. 4. 6. 5]
Resolving element} 4 I to ft 2.3,4.5. 6j
Array : [1. 2.3. 4. 5. 6]
При сортировке «на месте»
меняются местами
значения элементов
оригинального списка.
Сортировка вставками
Алгоритмы сортировки
Метод перестановки элементов при использовании
алгоритма сортировки выбором, показанный
в предыдущем примере, работает хорошо, но существует
и альтернативный метод, который просто вставляет
элементы в массив в правильной восходящей
последовательности.
Алгоритм сортировки вставками рассматривает
следующий элемент в неотсортированной части массива
и, если это требуется, перемещает в подходящее
место среди ранее упорядоченных элементов. Чтобы
приспособиться к вставленному элементу, все остальные
элементы в несортированной части сдвигаются вправо.
Таким образом, отсортированная часть массива
увеличивается, а неотсортированная уменьшается.
Сортировка вставками — простой алгоритм, который
достаточно легко понять и превратить в код функции.
Наряду с алгоритмом сортировки выбором это один
из двух самых эффективных алгоритмов для сортировки
небольших массивов примерно из 20 элементов. Обычно
сортировка вставками требует меньше сравнений, чем
сортировка выбором, поэтому часто считается лучшим
методом для сортировки небольших массивов.
гм
СП
8 этом примере для того,
чтобы найти минимальное
значение самого первого
элемента, необходимо два
шага: вначале выяснить, что
3 меньше 5, затем — что 1
меньше 3
Начните новую программу, объявив функцию,
куда на вход передается ссылка на список и где
начинается цикл, чтобы сохранить текущее
значение каждого элемента:
del insertion_sort( array ):
foi index нт range) 1, len) array ) ) :
value = array) index ]
insertion.py
О
о
о
# Здесь добавляется последовательность
действий для выполнения алгоритма.
print) '^Рассматривается элемент) , index, j из',
array)
Далее добавьте последовательность инструкций
для выполнения алгоритма, который будет
раз за разом вставлять текущее значение
в отсортированную часть массива, если оно
окажется меньше первого ее элемента:
while array) index-1 ] > value «nd index >= 1:
array) index ] = array) index-1 ]
index -=1
array) index ] = value
Теперь добавьте инструкции, чтобы создать
и вывести на экран несортированный список:
array = [5,3,1,2,6,4}
print) 'Сортировка вставками...\пМассив :', array )
Наконец, добавьте инструкции для вызова
функции алгоритма и вывода на экран
отсортированного массива:
insertion_sort( array)
print) , array)
& (DIE Shell 3.10.4
File Edit Shell Debug Options Window Help
====== RESTART: C:\MyCode\insertion.py =====
Insertion Sort-
Array; [5. 3.1. 2. 6.4]
Resolving element! 0 ] to )3,5.1.2.6.4]
Resolving element) 0 j to [1, 3.5. 2,6. 4]
Resolving element) 1 ] co |1. 2. 3. 5.6.4]
Resolving element) 4 ] to )1. 2. 3,5. 6. 4 J
Resolving element) 3 ] to [1. 2,3.4. 5. 6]
Array: [1. 2. 3. 4. 5. 6]
На некоторых итерациях
этот алгооитм
распознает, что элементы
в несортированной части
уже отсоотированы
в соответствии
с предыдущими вставками.
Сортировка пузырьком
Алгоритмы сортировки
Алгоритм сортировки пузырьком — еще одна простая
альтернатива сортировке выбором и вставками.
Сортировка пузырьком раз за разом рассматривает
каждую соседнюю пару элементов массива и при
необходимости меняет их местами так, чтобы меньшее
значение оказалось перед большим, пока все элементы
не окажутся отсортированными в восходящей
последовательности.
Сортировка пузырьком — очень простой алгоритм,
который легко понять и превратить в код функции. Хотя
технически сортировка пузырьком менее эффективна,
чем вставка или выбор, это один из самых быстрых
алгоритмов для работы с почти отсортированными
массивами.
5 3 1 2 6 4
ОТ
3 этом примере при
первом прохождении
элементов с индексами [3J
и[41 перестановка не
требуется, поскольку
значения 5 и 6 уже
находятся в правильном
порядке.
о
о
о
Начните новую программу, объявив функцию,
куда на вход передается ссылка на список и где
начинается внешний цикл, который будет раз
за разом проходить по содержимому массива:
def bubble_sort( array ):
foi index in range) len) array )) .
d Здесь добавляется последовательность действий
для выполнения алгоритма.
Далее добавьте последовательность инструкций
для выполнения алгоритма, который будет раз
за разом рассматривать элементы массива вплоть
до предпоследнего и менять их местами, если
значение следующего элемента оказывается
больше предыдущего:
for element in range) ( len) array )-l) - index ) .
if array[ element ] > array! element+1 ] :
array! element ], array! element+1 ] = \
array! element+1 ], array! element ]
print! ^Рассматривается элемент!', element
,\
'] to , array )
Теперь добавьте инструкции, чтобы создать
и вывести на экран несортированный список:
array = [5,3,1,2,б,4]
print! 'Сортировка пузырьком.ДпМассив :', array )
Наконец, добавьте инструкции для вызова
функции алгоритма и вывода на экран
отсортированного массива: bubble_sort( array I
print! , array )
bubble.py
CD
U1
ft. iDl E Shell 3.10.4
File Edit Shell I: ebug Options Window Help
======= RESTART C:\MyCode\bubbie. py =======
Bubble Sort-
Array: [5. 3.1, 2, 6, 4]
Resolving element! 0 ] to [3. 5,1. 2. 6, 4]
Resolving element! 1 ] to [3.1. 5. 2.6.4]
Resolving element! 2 ] to [3.1. 2.5.6.4]
Resolving element! 4 J io [3.1. 2 5.4, 6]
Resolving element! 0 J to [13, 2, 5.4. 6|
Resolving element! 1 ] to [1 2.3,5.4,6]
Resolving element! 3 ] to [1.2.3.4.5. 6]
Array : [1. 2.3. 4. 5. 6]
В обычных простых случаях
алгоритм сортировки
вставками работает
быстрее сортировки
выбором, а сортировка
выбором — быстрее
сортировки пузыроком.
Алгоритмы сортировки
Сортировка слиянием
Простые алгоритмы сортировки выбором, вставками
и пузырьком хорошо работают на небольших массивах,
но для более крупных структур данных требуются
более эффективные и сложные алгоритмы сортировки.
Обычно в этих сложных алгоритмах применяется
принцип «разделяй и властвуй», когда вначале список
несколько раз делится на части, а затем эти подразделы
собираются в отсортированном порядке.
Алгоритм сортировки слиянием — это сложный
алгоритм сортировки, который вначале несколько раз
делит массив пополам на левый и правый подразделы
из центральной точки массива. Это продолжается
до тех пор, пока подраздел не оказывается пустым
или содержит один элемент. Затем подразделы вновь
собираются вместе в отсортированном порядке.
Алгоритм сортировки слиянием — сложный алгоритм,
который можно превратить в код с помощью функции,
которая делает рекурсивные вызовы, чтобы несколько
раз делить массив. Это быстрый алгоритм, который
сравнивает элементы только тогда, когда собирает их
обратно в отсортированный массив.
о
От
В этом примере массив
невелик, но именно
таким образом алгоритм
сортировки слиянием
эффективно делит на
части и собирает обратно
большие массивы.
Начните новую программу, объявив функцию
с рекурсивным вызовом, получающую на вход
ссылку на список и разбивающую массив на две
части и сортирующую каждую:
def merge_sort( array ):
if len( array ) > 1 :
middle = int( len( array ) / 2 )
left = array| <J : middle ] ; right = array! middle : ]
printf , left, right)
merge_sort( left) ; merge_sort( right)
# Здесь добавляется последовательность
действий для выполнения алгоритма.
merge py
Далее добавьте последовательность инструкций
для слияния отсортированных подразделов:
i = j = О
for element in rangef len( array } ) :
L = left! i ] if i < len( left) else None
R = right[ j ] if j < len( right) else None
f (( L and R ) and ( L < R ) ) ar R is None :
array[ element ] = L ; i += 1
elif ( ( L and R ) «md ( L >= R ) ) or L is None :
array! element ] = R ; j += 1
printf > left > r'ght )
Теперь добавьте инструкции, чтобы создать
и вывести на экран список:
array = [5,3,1,2,6,4]
print! 'Сортировка слиянием...\пМассив : , array )
merge_sort( array)
print! 'IV , array )
В приведенном здесь
коде используется
точка с запятой Это
разделитель для записи
двух инструкций в одной
строке, в данном случае он
применяется только из-за
ограничений страницы.
Алгоритмы сортировки
Сортировка
с разделением
Показанный в предыдущем примере метод разделения
массива на части из центральной точки с помощью
сортировки слиянием работает хорошо, но существует
и альтернативный метод, делящий массив с помощью
«барьерного» элемента.
Алгоритм «быстрой сортировки» — это сложный
алгоритм сортировки, который также придерживается
стратегии «разделяй и влас твуй». Вначале он
определяет конкретный элемент массива, чье значение
будет служить «барьером» или опорным элементом.
Затем алгоритм несколько раз делит массив на две
части: в одну входят все элементы меньше опорного,
а во вторую — больше него. Когда операция разделения
окончена, последний опорный элемент оказывается
на правильной позиции, так что алгоритм сливает
меньшую часть, опорный элемент и большую часть
в единый отсорт ированный список.
00
ат
Алгоритм быстрой сортировки — сложный алгоритм,
который можно превратить в код с помощью
функции, которая делает рекурсивные вызовы, чтобы
несколько раз делить массив. Это быстрый алгоритм,
сравнивающий значения элементов при разделении
массива на части.
В этом примере массив
невелик, но именно таким
образом алгоритм быстрой
сортировки эффективно
делит на части и собирает
обратно большие массивы.
Существуют разные мнения по поводу того, какой
элемент лучше выбрать в качестве опорного. Некоторые
разработчики любят выбирать средний элемент,
повторяя алгоритм сортировки слиянием, описанный
выше. Другие предпочитают выбирать первый или
последний элемент или элемент в произвольном
промежуточном положении, как показано в примере.
о
Начните новую программу, объявив функцию,
получающую на вход ссылку на список
и разбивающую массив на две части с помощью
опорного элемента. Затем отсортируйте каждую
часть, рекурсивно вызывая функцию, и сложите
обе части вместе:
del quick_sort( array ) :
if len( array ) > 1:
pivot = int( lcn( array ) -1)
less - [ J ; more = [ ]
# Здесь добавляется код из второго шага.
quick.ру
quick_sort( less ) ; quick_sort( more )
print( \tM< , less, , array[ pivot ], \
, more )
array[ • ] = less + [ arrgy[ pivot | ] + more
print! , array )
Далее добавьте последовательность инструкций
для деления элементов массива на сегменты,
затем слейте их обратно:
for element in ranpe( len( array ) ) :
value = at ray[ element ]
f element 1= pivot :
if value < arrayf pivot ] :
less.appendf value )
else :
more.append! value )
О
40
О
Теперь добавьте инструкции, чтобы создать
и вывести на экран список:
array = [5,3,1,2,6,4]
print! > array )
quick_sort( array )
print! , array )
Алгоритм быстрой
сортировки использует
меньше памяти, чем
сортировка слиянием, его
часто называют лучшим
алгоритмом сортировки.
Краткие итоги
Алгоритмы сортировки
• Алгоритм — это четко определенная
последовательность инструкций для того, чтобы
выполнить определенную задачу.
• Каждый алгоритм принимает на вход одно или
несколько значений и производит на выходе одно
или несколько результирующих значений.
• Алгоритм может быть создан в коде как функция,
в которой определена последовательность
инструкций для выполнения задания.
Эффективность алгоритмов сортировки может
зависеть от сущности списка, который надо
отсортировать.
• Функция алгоритма сортировки может скопировать
список, переданный на входе, и вернуть на выходе
отсортированную копию этого списка.
• Существует несколько популярных алгоритмов
сортировки массивов на месте, у каждого из них
есть свои сильные и слабые стороны.
• Сортировка выбором раз за разом выбирает
минимальный элемент из неотсортированной части
массива и переносит его в конец отсортированной
части.
Сортировка вставками раз за разом извлекает
следующий элемент из неотсортированной части
массива и вставляет его на правильную позицию
в отсортированную часть.
• Сортировка пузырьком раз за разом сравнивает
соседние элементы неотсортированного массива
и переставляет их местами в правильном порядке.
• Сортировка выбором, вставками и пузырьком —
это простые алгоритмы сравнения, они работают
относительно медленно.
• Сортировка слиянием несколько раз делит
неотсортированный массив на правый и левый
подразделы относительно средней точки
массива, затем сливает подразделы в единый
отсортированный массив.
• Алгоритм быстрой сортировки несколько раз
делит неотсортированный массив на сегменты,
содержащие значения больше или меньше опорного
значения, затем сливает сегменты в единый
отсортированный массив.
• Сортировка слиянием и быстрая сортировка —
быстрые сложные алгоритмы, придерживающиеся
стратегии «разделяй и властвуй».
Импорт
библиотек
102
Н этой главе
показано. 104
Python в подробностях
Математические расчеты
mg Вычисления с десятичными
а програи мм с
дробями
уже готовую
функциональности 108 КОТОРЫЙ ЧЭС?
различных
библиотек.
110
112
Запуск таймеров
Краткие итоги
Импорт библиотек
Python в подробностях
В Python входят два модуля — «sys» и «keywords», которые
полезны для того, чтобы исследовать саму систему языка
программирования. В атрибуте kwlist модуля «keyword»
содержится список всех ключевых слов Python. Если вы
хотите проверить, является ли какое-либо слово ключевым,
это можно сделать с помощью функции iskeywordf).
Многие функции модуля «sys», как и любые другие функнигг
языка программирования Python, можно изучить с помощью
справочной системы интерактивного режима. Просто
напишите help() в строке запроса интерактивной оболочки
Shell, затем напечатайте sys в запросе help>.
Возможно, для разработчика особенно полезно, что в модуле
«sys» имеются атрибуты, содержащие информацию о версии
Python, местонахождении интерпретатора в вашей системе,
а также список всех каталогов, где интерпретатор ищет файлы
модулей. То есть если вы будете сохранять файлы модулей
в одной из этих директорий, то можно не сомневаться в том,
что интерпретатор сможет их обнаружить.
system.ру
О
о
о
о
о
о
Начните новую программу, импортировав модули
«sys» и «keyword», чтобы получить доступ к их
функциям:
import sys , keyword
Затем добавьте инструкцию, чтобы вывести на экран
версию Python:
printf , sys.version )
Теперь добавьте выражения, чтобы вывести на экран
реальное местонахождение интерпретатора Python
в вашей системе:
printf Местонахождение интерпретатора Python, sys.executable)
Добавьте инструкции, чтобы вывести на экран список
всех каталогов, где интерпретатор Python ищет файлы
модулей:
printf 'Путь поиска модулей Python: )
for folder in sys.path :
printf folder )
Наконец, добавьте выражения, чтобы вывести
на экран список всех ключевых слов Python:
printf 'Ключевые слова Python:')
for word in keyword.kwlist:
printf word )
Сохраните и запустите программу, чтобы увидеть
информацию о версии Python в вашей системе.
Первый элемент в пути
поиска файлов Python —
это ют каталог, где
вы находитесь. Таким
образом, любой файл,
созданный в нем или
в его подкаталогах,
будет обнаружен
интерпретатором Python
Потратьте некоторое
время для того, чтобы
изучите Python С ПОМОЩЬЮ
справочной службы
интерактивной оболочки
Shell.
Математические
расчеты
В языке программирования Python имеется модуль
«math». Импортировав его, вы можете обнаружить
множество функций для проведения математических
расчетов.
Функции math.ceilf) и math ftoor() позволяют округлять
указанные в скобках значения с плавающей точкой
до ближайшего целого числа. Функция math.ceil()
округляет число в большую сторону, math.floorf) —
в меньшую, при этом возвращаемое число, хотя, по сути,
и является целым, относится к типу данных float, а не int-
Функция math.powf) принимает два аргумента
и возводит первое указанное значение в степень,
определенную вторым. Функция math.sqrt(), с другой
стороны, принимает один аргумент и возвращает
квадратный корень из указанного значения. Результаты
работы обеих функций возвращаются как числовые
значения типа float.
Целочисленные значения
можно преобразоьатс
из типа данных Int в тип
данных float с помощью
функции floatf). Их можно
преобразовать в строковый
тип данных с помощью
функции strf)
maths.ру
Тригонометрические вычисления можно провести
с помошью таких функций модуля «math», как math,
sinf), math.cosinf) и math.tanf).
Кроме того, в Python имеется модуль «random»,
который можно импортировать в программу для
генерации псевдослучайных чисел.
Функция random.randomf) генерирует одно число
с плавающей точкой между 0 и 1.0. Возможно, более
интересна функция random.samplef), которая создает
список элементов, случайным образом выбранных
из последовательности. Этот метод требует двух
аргументов, определяющих последовательность,
из которой выбираются элементы, и длину
списка. Поскольку функция rangef) возвращает
последовательность чисел, ее можно использовать
в качестве первого аргумента функции random.sample(),
и она случайным образом выберет числа из указанной
последовательности, в результате чего вы получите
список, где ни одно число не повторяется.
Начните новую программу, импортировав
модули «math» и «random», чтобы получить
доступ к их функциям:
import math , random
Затем добавьте инструкции, чтобы вывести на
экран два округленных числа:
printf 'Округление в большую сторону 9.5:', math.ceilf 9.5))
printf 'Округление в меньшую сторону 9.5:', math.floorf 9.5))
Теперь добавьте выражение, чтобы
инициализировать целочисленную переменную:
num = 4
о
о
о
о
Добавьте инструкции, чтобы вывести на экран
квадрат значения переменной и квадратный
корень из него:
printf num , , math.powf num , 2 ))
printf num , , math, sq rtf num ))
Добавьте выражения, чтобы создать случайный
список из 6 уникальных чисел от 1 до 59
включительно:
nums = random.sample( rangef 1, 60 ), 6 )
Наконец, добавьте инструкцию, чтобы вывести
на экран случайный список:
printf 'Ваши счастливые числа:', nums )
Сохраните и запустите программу, чтобы
увидеть результаты математических операций
и случайную выборку чисел.
Кроме того, существует
функция random.
randintf nl, n2 ),
возвращающая случайное
целое число в диапазоне,
указанном с помощью двух
целочисленных аргументов.
IV Ю1Е Shell 3.10,4 - П X
File Edit Shell Debug Options Window Help
»>
»>
»?
»>
======== RESTART: C:\MyCode\matns.py =======
Rounded Up 9.5:10
Rounded Down 9.5: 9
4 Squared. 16.0
4 Square Root: 2.0
Your Lucky Lotto Numbers Aie: [9.13.14.1. 28. 39]
======== RESTART: C:\MyCode\maths.py =======
Rounded Up 9.5:10
Rounded Down 9.5: 9
4 Squared 16 0
4 Square Root: 2 0
Your Lucky Lotto Numbers Are: [24. 34. 29.1.44. 20j
======== RESTART: C:\MyCcde\maths.py =======
Rounded Up 9.5:10
Rounded Down 9.5: 9
4 Squared 16 0
4 Square Root: 2.0
Your Lucky Lotto Numbers Are: [11.10. 20. 58 14.18]
======== RESTART: C:\MyCude\maths.py =======
Rounded Up 9.5-10
Rounded Down 9.5: 9
4 Squared. 16.0
4 Square Root: 2.0
Your Lucky Lotto Numbers Are: [25,17,15,5,20,59]
Все показанные здесь
Функции возвращают числа
с плавающей точкой типа
float.
Список, который
производит функция
random.samplef), на самом
деле не заменяет элементы
последовательности,
а копирует из нее
экземпляры, на что
и указывает название
функции (sample —
образец, экземпляр).
inaccurate.ру
Здесь значения
переменных
отформатированы
с помощью метода замены
строки, чтобы отображать
два знака после запятой.
Метод более подробно
описан на с 114.
Вычисления
с десятичными дробями
При выполнении арифметических операций
с десятичными дробями программы на Python могут
выдавать неожиданные и неточные результаты,
поскольку числа с плавающей точкой не могут
точно представить все десятичные дроби. Особенно
осторожными нужно быть, когда прокрамма работает
с денежными величинами.
Начните новую программу, инициализировав
две переменных, в которых хранятся числа
с плавающей точкой:
item = 0.70
rate = 1.05
Затем инициализируйте еще две переменных,
чтобы попытаться выполнить арифметические
операции с двумя первыми переменными:
tax - item * rate
toial = item * tax
Теперь добавьте выражения, чтобы вывести на
экран значения переменных, отформатированных
с точностью до двух знаков после запятой, чтобы
были видны конечные нули:
print( , format( item))
printf , form at (tax ) )
printf , .formatf total) j
Сохраните и запустите программу, чтобы
увидеть результаты математических операций
и неточные вычисления суммы.
expanded.ру
Чтобы попытаться понять, из-за чего возникает
проблема, отредактируйте все три вызова
функции printf), чтобы вывести на экран
значение переменных с точностью до 20 знака
после запятой, затем запустите видоизмененную
программу:
printf , .formatf item))
printf , .formatf tax))
printf , formatf total))
ft IDLE Shell 3.10.4 — □ X
File Edit Shell ..ebug Options Window Help
-==— RESTART. C:\MyCode\expanded.py = Item: 0.69999999999999995559 Tax; 0.73499999999999998668 Total: 1.435001100000Л <1005329 A
Теперь понятно, что значение переменной tax (налог)
немного меньше 0,735, поэтому округляется до 0,73.
И наоборот, значение total (общей суммы) численно
немного выше 1,435, поэтому округляется до 1,44, что
и приводит к явной ошибке при сложении.
Ошибок при арифметических операциях с числами
с плавающей точкой можно избежать, если использовать
модуль Python «decimal». Он содержит объект Decimal,
с помощью которого числа с плавающей точкой можно
представить более точно.
Описанная проблема
возникает не только
в Python. В языке
программирования
lava существует класс
BigDecimal, кстопый
решаем проблему расчетов
с десятичными дробями
примерно гак же, как
модуль «decimal» б Python.
0
О
О
о
Добавьте в начало программы команду,
импортирующую модуль «decimal», чтобы все
его функции стали доступными:
from decimal import *
Далее отредактируйте две первых переменных,
сделав их объектами:
item = Decimal! 0 70 )
rate = Decimal! 1 05 )
Теперь добавьте выражения, чтобы вывести на
экран значения переменных, отформатированных
так, чтобы отображались два знака после запятой
и были видны конечные нули:
print! , .formatf item ))
print! , format! tax))
print! V, '{ format! total ))
Сохраните и запустите измененную программу,
и вы увидите, что теперь налог tax и общая
сумма total округляются в меньшую сторону,
и в результате мы получаем правильный
результат сложения.
decimals.ру
Всегда используйте
объект Decimal при работе
с денежными величинами
или в других случаях, когда
точность имеет значение.
Который час?
Поскольку объект Datetime
носит то же имя, что
и модуль, то если вы
просто импортируете
модуль, то к нему придется
обращаться через точку как
datetime.datetime. Для того
чтобы использовать запись
datetime без точки, нужно
импортиоовагь объект
следующим образом: from
datetime import datetime.
Модуль Python «datetime» можно импортировать
в программу для того, чтобы использовать в ней
дату и время. Он предоставляет объект Datetime
с атрибутами year, month, day, hour, minute, second
и microsecond (год, месяц, день, час, минута, секунда
и микросекунда).
У объекта Datetime есть функция today(), которая
приписывает значения текущей даты и времени
его атрибутам и возвращает их как кортеж. Также
у него имеется функция getattr(), куда передаются
два аргумента, определяющих имя объекта Datetime
и атрибут, который нужно получить. И наоборот,
к атрибутам можно обратиться с помощью записи через
точку, например datetime.year.
Все значения объекта Datetime хранятся как числовые
значения, но их бывает полезно преобразовать в текстовые
эквиваленты с помощью фтакции strftimef). Для этого
передается один строковый аргумент, который указывает,
какую часть кортежа вернуть и в каком формате.
Возможные команды перечислены в таблице ниже:
Поскольку функция
strftime() принимает
строковый аргумент,
команду нужно заключать
в кавычки.
%А Полной название дня недели (%а возвращает сокращенное название дня недели)
%В Полное название месяца (%Ь вошрзщает сокоащенное название месяца)
%с Дату и время в соответствии с региональными настройками
%d День месяца в виде числа в формате 01 31
%f Микросекунды в формате 000000-9У999У
%Н Час 00 23 (24 часовой форма!)
%1 Час 01-12 (12-часовой формат)
%j День года в <роомате 0 366
%т Номер месяца в формате 01-12
%М Минуту 00-59
%р Эквивалент AM и РМ в соответствии с региональными настройками
%S Секунду 00-59
%w Номер дня недели 0(8оскресеьье)-6
%W Номер недели в году 0-53
%Х Время в соответствии с региональными настройками (%х возвращает соответствующую дату)
%Y Год в формате 0001 9999 (%у возвращает год в фермате 00 99)
%z Часовой пояс UTC как +ННММ или -ННММ
%Z Название часового пояса
Начните новую программу, импортировав модуль
«datetime», чтобы его функциональность была
доступна в коде:
from datetime import datetime
О
о
о
о
о
о
Затем создайте объект Datetime с атрибутами
текущей даты и времени и выведите на экран его
содержимое:
today = datetime.todayO
printf , today )
Добавьте цикл, чтобы вывести на экран значение
каждого атрибута:
for attr in \
[ 'год',’месяц’,'день','час','минута','секунда','микросекунда' ]:
printf attr , , getattrf today , attr ) )
Теперь добавьте инструкцию, чтобы вывести на
экран время с помощью записи через точку:
printf , today hour , , today,minute , sep =
)
Присвойте отформатированные атрибуты
названий дня и месяца переменным:
day = today.strftimef )
month = todaystrftime( )
Наконец, добавьте инструкцию, чтобы вывести
на экран отформатированную дату:
printf , day , month , today.day )
Сохраните и запустите программу, и вы увидите
на экране значения даты и времени.
time.py
Отметим, что здесь в цикле
используется символ
обсатной наклонной
черты, который позволяет
продолжать выражение
на следующей строке,
не вызывая ошибки.
109
Вы можете присвоить
атрибутам объекта Datetime
новые значения с помощью
функции replacef),
например: today = today.
replace(year~2023).
Функция gmtime()
преобразует время,
выраженное в секундах
с начала Эпохи,
в именованный объект
Struct_time в UTC, при этом
флаг Daylight Saving Time
всегда равен 0. Функция
localtimef) преобразует
время, выраженное
в секундах с начала Эпохи,
в объект Struct_time,
представляющий местное
время.
timer.py
Запуск таймеров
Длительность какого-либо события можно вычислить,
если получить текущее время до и после события
и вычислить разницу. Модуль Python «time» можно
импортировать в программу и воспользоваться его
функциями для работы со временем.
Текущее время системы обычно вычисляется как
количество секунд, прошедших с момента начала Эпохи
в 00:00:00 GMT 1 января 1970 года. Функция time()
модуля «time» возвращает текущее время в секундах
с начала Эпохи как число с плавающей точкой.
Цифра, возвращаемая функцией time(), может быть
преобразована в объект Struct_time с помощью функции
gmtime() или localtime(). У этого объекта есть атрибуты
tmyear, tm mon, tm mday, tm rour, tm min, tm sec,
tmwday, tm_yday, tm_yday и tm_isdst, к которым можно
обратиться с помощью записи через точку, например
struct.tm_wday.
Все значения объекта Struct_time хранятся как числовые,
но могут быть преобразованы в текстовые эквиваленты
с помощью функции strftimef). Для этого требуется
аргумент-команда, за которым следует имя объекта
Struct_time. Возможные команды перечислены в таблице
для объекта Datetime на с. 106. Вызов функции для
дня недели, к примеру, выглядит следующим образом:
strftime(’%A', struct).
Одна из самых полезных функций модуля «time» —
sleepf). Ее можно использовать для того, чтобы поставить
выполнение программы на паузу. В качестве аргумента
в функцию передается количество секунд, на которые
следует отложить выполнение программы.
Начните новую программу, импортировав
модуль «time», чтобы его функциональность
была доступна в коде:
from time import *
Затем создайте переменную с числом
с плавающей точкой, обозначающую текущее
время в секундах с начала Эпохи:
start_timer = time()
Добавьте инструкцию, чтобы создать объект
struct_time из значения текущего времени
с начала Эпохи:
struct = localtimef start_timer )
Теперь объявите, что таймер обратною отсчета
начинается с исходной точки текущего времени:
printf 'Начать обратный отсчет с , strftimef , struct))
Добавьте цикл, чтобы инициализировать
и вывести на экран значение переменной
счетчика, которая при каждой итерации будет
уменьшаться на 1 и останавливаться примерно
на одну секунду:
i = 10
while i > -1 :
print( i)
i -= 1
sleep( 1 )
Далее инициализируйте переменную с числом
с плавающей точкой, которая хранит количество
секунд, прошедших с начала Эпохи до
настоящего момента:
end. timer = time()
Обычно импортируют
модуль «datetime»,
но в модуле «time» есть
множество удобных
функций, дающих большую
точность Отметим, что
и в том, и в другом модуле
имеется функция time
Инициализируйте переменную, где вычисляется
разница между двумя временными точками
и происходит округление полученного значения
в секундах:
difference = round( end_timer - start_timei )
Наконец, добавьте инструкцию, чтобы вывести
на экран время выполнения цикла с обратным
отсчетом:
printf 'ХпВремя выполнения программы , difference, 'Секунд')
Сохраните и запустите программу, и вы увидите,
как цикл останавливается во время каждой
итерации, а также время выполнения программы.
Функция sleep!) обычно
задерживает выполнение
программы немного
дольше указанного
запаздывания, поэтому
здесь используется
функция round!).
Не путайте функцию time.
strftime(), использованную
в этом примере, с функцией
datetime.strftime()
из предыдущего примера.
Краткие итоги
У модуля «sys» есть атрибуты, содержащие
информацию о версии Python, местонахождении
интерпретатора и пути поиска модулей.
У модуля «keyword» имеется атрибут kwlist,
содержащий список всех ключевых слов языка
программирования Python.
Модуль «math» предоставляет функции для
выполнения математических операций, например
функции math.ceilf) и math.fluorf).
Функции math pnwf) и math.sqrtf) возвращают
результаты в виде десятичного значения,
относящегося к типу данных float
Тригонометрические вычисления можно выполнить
с помощью функций из модуля «math», таких как
math.sinf), math.cosinf) и math.tanf).
Модуль «random» предоставляет функцию
randomf), которая производит псевдослучайные
числа, и функцию samplef), которая на выходе дает
список элементов, случайным образом выбранных
из последовательности.
Числа с плавающей точкой не могут точно
представить все десятичные дроби.
Модуль «decimal» предоставляет объект Decimal,
с помощью которого можно точно представить
числа с плавающей точкой при расчете денежных
величин.
Модуль «datetime» предоставляет объект Datetime
с атрибутами year, month, day, hour, minute, second
и microsecond, к которым можно обратиться
с помощью записи через точку или функции
getattrf).
У объекта Datetime есть функция slrftimef),
в которую можно передать команду, чтобы вернуть
отформатированную часть объекта.
Модуль «time» предоставляет функцию timef),
возвращающую текущее время в секундах
с момента начала эпохи.
Функции gmtimef) и localtimef) возвращают
объект Struct_time с атрибутами, содержащими
компоненты даты и времени.
Управление
текстом
114
В этой главе
показано, как 116
Обработка строк
Форматирование строк
обрабатывать
118
строки
в программах 120
Изменение строк
Доступ к файлам
и как хранить
122
строки
в файлах. 124
Обработка содержимого файлов
Обновление содержимого файлов
126 Краткие итоги
Управление текстом
Обработка строк
В программе на Python манипулировать строками
можно с помощью различных операторов,
перечисленных в таблице ниже.
Конкатенация — складывает строки 'Hello' + 'Mike1
Повторение — умножает строки 'Hello' * 2
Срез — выбирает символ
с указанной позицией индекса
Срез диапазона — выбирает
символы в указанном диапазоне
'Hello' [0]
Hello' |0. 4]
Срез диапазона возвращает
строку до указанной
позиции индекса,
но не включает элемент
с этим индексом.
ш
not in
r/R
Принадлежность (включительно) —
возвращает True, если символ 'Н' in 'Hello'
присугсгвует в строке
Принадлежность (исключительно) — ц-р not tn
возвращает True, если символ ,
не поисутствуе, в строке непо
Необработанная строка — все
символы интерпретируются как есть, print(r'\n')
без обработки специальных символов
DnrUfll'F OllHtJHHV
И
Строка документации — описывает def sum(a, bj
модуль, функцию, класс или метод Add Args '"
Опера юры
принадлежности
чувствительны к регистру,
поэтому проверка ’А' ш 'аЬс'
окажется ложной.
Перед атрибутом___doc
и после нею находится
удвоенный символ
подчеркивания.
Операторы среза [] и [:] распознают строку как список.
Элементами списка являются отдельные символы,
к которым можно обратиться по индексу.
Подобным же образом операторы принадлежности
in и not in проходят по элементам, проверяя,
соответствуют ли они указанному символу.
Оператор необработанной строки г (или заглавная R)
помещается непосредственно перед открывающей
строку кавычкой, чтобы подавить специальные символы
в строке. Его полезно использовать, если строка
содержит обратную косую черту.
Строка документации — это литерал описательной
строки, который обычно размещается сразу после
объявления модуля, функции, класса или метода.
Строка документации заключается в тройные
одинарные кавычки для того, чтобы строка могла
распространяться на несколько линий. Уникальная
особенность строки документации в гом, что она
становится особым атрибутом объекта__doc_,
к которому можно обратиться, использовав имя объекта
и запись через точку. Во всех модулях, а также во всех
функциях и классах, экспортируемых в них, должны
быть строки документации.
о
Начните новую программу, определив простую
функцию, включающую строку документации:
def display! $ ) :
'Выводит значение аргумента '
print( s )
О
о
о
о
о
о
Затем добавьте инструкцию, чтобы вывести на
экран описание функции:
display( display._doc_)
Добавьте инструкцию, чтобы вывести на экран
значение сырой строки, содержащей символ
обратной косой черты:
display! )
Добавьте инструкцию, чтобы вывести на экран
значение сырой строки, содержащей символ
обратной косой черты:
display! .nHell + Р th )
Добавьте инструкцию, чтобы вывести на экран
срез указанной строки от определенного индекса
элемента:
display! ython in easy steps\n' [ 7 : ] )
Далее выведите на экран результаты поиска
символов в указанной строке:
display! in )
display! in ]
Сохраните и запустите программу, и вы увидите
различные манипуляции со строками.
manipulate.ру
Помните, что строки
должны быть заключены
в одинарные или двойные
кавычки.
115
£0®^
Если при срезе диапазона
не определен начальный
индекс, то на его месте
подразумевается 0 Если же
неуказан конечный индекс,
то подразумевается вся
строка до конца.
Управление текстом
Форматирование строк
Встроенная функция dir() может быть полезна для
того, чтобы изучить имена функций и переменных,
определенных в модуле. Для этого в скобках после
функции указывается имя модуля. Для этой цели
хорошо подходит интерактивная командная строка Shell.
Импортируйте в нее модуль, затем вызовите функцию
dir(). В примере ниже анализируется модуль «dog»,
созданный на странице 84 в главе 6.
Отметим, что атрибут
__doc__, представленный
в предыдущем примере,
также появляется в списке,
предоставленном
функцией dir().
Не путайте описанный
здесь объект String
с функцией str(),
поесбразуюшей значения
в строковый тип данных.
Все имена, начинающиеся и заканчивающиеся с двой-
ных нижних подчеркиваний, — эго объекты Python,
тогда как остальные имена определены разработ чиком
в программе. Модуль «_builtins_» также можно
рассмотреть с помощью функции dir(), и тогда мы
увидим имена функций и переменные, объявленные
по умолчанию, например функцию printf) и объект
String.
Объект String объявляет несколько полезных функций
для форматирования строк, в том числе функцию
tormatQ, осуществляющую замены. Строка для
форматирования может содержать как текст, так
и отмеченные специальными символами «поля замены»,
текст в которые вставляется из упорядоченного списка
значений, разделенного запятыми. Поля замены
обозначаются фигурными скобками {}, в которых при
необходимости может ставится индекс с номером
замещающего элемента из списка.
Также строки можно отформатировать с помощью
оператора подстановки %s в стиле языка
программирования С. С помощью этого оператора
помечаются те места строки, куда вставляется текст
из упорядоченного списка значений, разделенного
запятыми.
о
о
о
о
о
О
о
Начните новую программу, инициализировав
переменную с форматированной строкой:
snack « '{} and {}.format( 'Eypi э*, 'Картошка фри*)
Затем отобразите значение переменной, чтобы
увидеть текст замен в том порядке, в каком они
перечислены в списке:
printf , snack )
Теперь присвойте переменной строку, которая
отформатирована по-другому:
snack = '{1} and {OJ'.formatf 'Бургер', 'К ошка фри*)
Еще раз выведите на экран переменную, и вы
увидите, что теперь замены вставляются в текст
в соответствии с указанными индексами:
printf *н , snack)
Присвойте переменной еще одну
отформатированную строку:
snack = % ( 'Молоко*, 'Печ )
Далее еще раз выведите на экран значение
переменной, чтобы увидеть, как в строку
подст авляется текст подстановок:
printf ।' ст , snack)
Сохраните и запустите программу, и вы
увидите, как на экране отображаются
от форматированные строки.
format ру
Вокруг номеров индексов
в фигурных скобках полей
замены пробелов быть
не должно.
Для других типов данных
существуют собственные
операторы подстановки:
%d — для десятичных
целых, %с — для символов
и %f — для чисел
с плавающей точкой.
Управление текстом
Изменение строк
У объекта String есть много полезных функций,
которые через точку можно добавить к его имени для
модификации строки и изучения ее содержимого.
Самые распространенные функции для модификации
строк перечислены в таблице ниже. Каждая функция
сопровождается кратким описанием.
Символ пробела не
является буквенно-
цифровым, поэтому
isalnumf) возвращает False,
если рассматриваемая
строка содержит пробелы.
Метод Описание
cap.taiize() Меняет первую букву строки на заглавную
title() Меняет первую букву в каждом слове на заглавную
upper)) lower)) swapcase() Меняет регистр всех букв в строке соответственно на верхний или нижний или переключает регистр на противоположный
join(seq) Объединяет строку в одну итерируемую строку с указанной последовательностью
IstripO rstrip () strip)) Удаляет пробелы соответственно в начале строки, в конце строки или в начале и в конце строки
ieplace(old, new) Заменяет все вхождения old на new
ljust(w, c) rjust(w. c) Делают длину строки не меньше установленной длины w и заполняют недостающее количество символами с, добавляя их слева или справа соответственно
center(w, c) Возвращает отцентоированную строку усыновленной длины w. по краям коюоой добавляются символы с (по умолчанию — пробелы)
count(sub) Возвращает количество вхождений sub
find(sub) Находит индекс первого вхождения sub или возвращает-1, если элемент не найден
startswith(sub) endswith(sub) ВсзвращаетТгие, если sub находится в начале или в конце строки соответственно, в ином случае возвращает False
isalpbaQ isnumencf) isalnum() Возвращает True, если все символы в строке являются буквами, цифрами или буквами и цифрами соответственно, в ином случае возвращает False
islower)) is.jpperj) istitlel) Возвращает True, если все символы в строке являются строчными буквами, заглавными буквами или первые символы в каждом слове написаны заглавными буквами соответственно, в ином случае возвращает False
isspace)) Возвращает True, если строка содержит только пробелы, в ином случае возвращает False
isdigit)) isdec'mal)) Возвращает True, если строка содержит только цифры, в ином случае возвращает False
о
Начните новую программу, инициализировав
переменную со строкой, состоящей из символов
нижнего регистра и пробелов:
string = 'coding for beginners in easy steps'
О
о
о
о
0
Затем выведите на экран ту же строку, сделав
первую букву заглавной, сделав заглавными
первые буквы в каждом слове и разместив строку
по центру:
printf , string.capitalizef))
printf '\п- ые буквы в каждом слове\Г, string.titlef)
)
printf . string.centerf 30 , ) )
Теперь выведите на экран строку, написанную
заглавными буквами, и соедините ее
с последовательностью из двух звездочек:
printf , string upperf) )
printf • ’, string.joinf ))
Выведите на экран строку, где слева добавляются
звездочки:
printf , string.rjustf 30 . ) )
Наконец, выведите на экран строку, где все
вхождения символа «8» заменяются на звездочки:
printf , string.replacef , ) )
Сохраните и запустите программу, и вы увидите,
как на экране отображаются измененные строки.
modify,ру
119
При исполозовании
функции rjustf) строка
размещается справа
и дополнительные символы
добавляются СЛЕВА. При
использовании функции
ljustf) строка размешается
слева, а символы
добавляются СПРАВА
Управление текстом
Доступ к файлам
С помощью функции dir() можно выяснить, что модуль
«_built ins_» содержит объект File, имеющий несколько
методов для работы с файлами, в том числе cpen(), read(),
writeQ и close().
Прежде чем файл можно будет прочитать или записать
в него какое-либо содержимое, его вначале необходимо
открыть с помощью функции ореп(). Для этого требуется
передать в функцию два строковых аргумента, чтобы
определить имя и местонахождение файла, а также один
из перечисленных в таблице ниже спецификаторов
режима открытия файла:
Режим
открытия Операция
файла
Параметр режима открытия
файла является строковым
значением, поэтому он
должен быть окружен
кавычками
г Открыть существующий файл для чтения
Открыть существующий файл для записи. Создает
новый файл, если файл не существует; открывает
существующий файл и сбрасывает все его
содержимое
Добааляет содержимое Открывает существующий Файл
для записи в конец файла или создает новый файл
То же, что г, но файл может быть не только
г+
прочитан, но и записан
То же, что w, но файл может быть не только
w+
записан, но и прочитан
То же, что а, но файл может быть не только
а+
записан, но и прочитан
Если после одного из вышеперечисленных режимов стоит
буква Ь, то это указывает на то, что идет работа не с
текстовыми, а с бинарными файлами, например, rb или w+b.
Когда файл открыт и у вас имеется объект File, из его
свойств вы можете получить различную информацию:
Кроме того, вы можете
использовать функцию
readlinesQ, которая
возвращает список всех
строк файла, и функцию
writelinesf), записывающую
список элементов в файл.
Свойство Описание
name Имя открытого файла
mode Режим, в котором открыт файл
closed Булево значение статуса файла, возвращающее True или False
readable!) Разрешение на чтение, возвращает булево значение True или False
writable! ) Разрешение на запись, возвращает булево значение True или False
Начните новую программу, создав объект
File для нового текстового файла с именем
«example, txt», куда вы будете записывать
содержимое:
file = ореп( , )
О
о
о
Теперь добавьте выражения, чтобы вывести
на экран имя файла и режим, в котором файл
открыт:
print( > file,name )
printf ия файла , file.mode )
Теперь добавьте инструкции, чтобы вывести на
экран разрешения на доступ к файлу:
printf , file.readable!) )
print! » file.writable!))
Далее объявите функцию для определения
статуса файла:
def get_status( f ) :
if not f.closed :
return 'Открыт'
else :
return 'Закрь'т'
access.ру
О
Наконец, добавьте инструкции, чтобы вывести
на экран статус открытого файла, затем закройте
файл и снова выведите его статус:
print! , get_status( file ))
file.dose!)
print! > get_status( file ))
Если программа пытается
открыть несуществующий
файл в режиме г,
интерпретатор сообщит
об ошибке.
121
Сохраните и запустите программу, и вы увидите,
как файл открывается для записи, а потом
закрывается.
Создайте файл example.txt
в каталоге C:\MyCode
Управление текстом
readwrite.ру
Запись в существующий
файл авюматически
перепишет все его
содержимое!
Удалите отступ по
умолчанию, который
автоматически вставляет
функция print}), поскольку
строки уже содержат
переводы строки
Обработка
содержимого файлов
После того как файл успешно открыт, его можно
прочитать, добавить в него данные или записать новые,
в зависимости от того, в каком режиме файл открывается
при вызове функции open}). После этих манипуляций файл
должен быть закрыт, для чего вызывается функция close}).
Как можно предположить, функция read}) возвращает
содержимое всего файла, а функция write}) добавляет
в файл содержимое.
Содержимое файла можно быстро и эффективно
прочитать с помощью цикла, итерируя строку
за строкой.
Начните новую программу, инициализировав
переменную с конкатенацией строк, содержащих
символы новой строки:
Ml
Отрывок из «Баллады Редингской тюромы».
Ml
poem = 'Нет, не смотрел никто из нас\п*
роет += 'С такой тоской в глазах\п*
роет += 'На лоскуток голубизны\п'
роет +=
Теперь добавьте инструкцию, чтобы создать
объект File для нового текстового файла
«роет, txt», куда мы будем записывать
содержимое переменной:
file = open} , )
Далее добавьте инструкции, чтобы записать
содержащуюся в переменной строку в текстовый
файл, затем закройте файл:
file.write} poem )
file.close})
Теперь добавьте инструкцию, чтобы снова
открыть файл и прочитать его содержимое:
file = open} , )
Добавьте инструкции для того, чтобы вывести
на экран содержимое текстового файла, затем
закройте файл:
for line in file
print} line , end = )
file.close})
Сохраните и запустите программу, и вы увидите,
как файл создается и выводится на экран.
* Отрывок из произведения О. Уайльда дан в переводе
Т. Железняк. — Прим. ред.
г R IDLE Shell 3.10.4 □ X
File Edit Shell Debug Options Window Help
»> RES1 ART: C:\MyCode\feadwrite.py - 1 never saw a man who looked With such a wistful eye Upon that little tent of blue Which prisoners call the sky A
Запустите текстовый редактор «Блокнот», чтобы
проверить, существует ли новый текстовый
файл и его содержимое, записанное программой.
~----------------------------------------------------------------------------1
potm.txt Notepad — Г) X
File Edit View ®
I never saw a man who looked
With such a wistful eye
Upon that little rent of blue
Which prisoners call the sky
Создайте файл poem,txt
в каталоге C:\MyCode.
Добавьте в конец программы инструкции,
добавляющие в текстовый файл автора
произведения, затем снова сохраните файл
123
скрипта:
file = ореп( , )
file.write( )
file.close()
Сохраните и снова запустите программу, чтобы
переписать текстовый файл, затем просмотрите
его содержимое в «Блокноте», и вы увидите,
что после первоначального содержания файла
появилось имя автора текста.
poem.txt - Notepad — □ X
File Edit View Ф
I never saw a man who looked
with such a wistful eye
Upon that little tent of blue
dnich prisoners call the sky
(Oscar Wilde)|
Для чтения файла можно
использовать функцию
.объекта File readCines(),
которая возвращает
список всех строк в файле
(в каждом элементе списка
хранится одна строка).
Управление текстом
update.ру
Обновление
содержимого файлов
Функция read)) объекта File по умолчанию читает
все содержимое с самого начала, от индекса
с позицией 0, до самою конца — индекса с позицией,
соответствующей последнему символу. При
необходимости функция read)) может принимать
целочисленный аргумент, чтобы определить, сколько
символов следует прочитать.
Позицию индекса внутри файла — с какого места читать
или записывать данные — можно точно контролировать
с помощью функции объекта File seek(). Она принимает
целочисленный аргумент, определяющий, на сколько
символов передвинуть позицию первого индекса
от начала файла.
Текущую позицию курсора внутри файла можно найти,
вызвав функцию объекта File tell(), которая возвращает
целое число.
Работая с объектами File, удобно пользоваться
ключевым словом with, чтобы сгруппировать связанные
с файлами программные инструкции внутри одного
блока. Этот метод позволяет удостовериться, что файл
надлежащим образом закрывается после того, как
операции завершатся, даже если в процессе обработки
файла возникают какие-то исключения. Эта запись
значительно короче, чем блок try... except.
О
о
о
о
Начните новую программу, приписав строковое
значение переменной, содержащей текст,
который будет записан в файл:
text = 'Полипнеский лозунг «Пролетарии всех стран, соединяйтесь!»^*
text 'из «Манифеста Коммунистической партии».
Теперь добавьте инструкции, чтобы записать
текстовую строку в файл и отобразить текущий
статус файла в блоке with:
with open( 'update.txt*, *w* ) as file :
file.writef text)
print( \r , file.closed )
Далее без отступа добавьте после блока with
инструкцию, чтобы вывести на экран новый
статус файла:
printf , file.closed )
Теперь снова откройте файл и выведите на экран
его содержимое, чтобы убедиться, что теперь он
содержит всю текстовую строку целиком:
with -. реп! , ) as file :
text = file.read!)
print( ’Cff , text)
С отступом добавьте инструкции для того, чтобы
вывести на экран текущую позицию курсора
в файле, затем сдвиньте ее и выведите новую
позицию:
printf '\пПозиция курсора в файле в да г , file.tellf))
position = file.seekf 33 )
printf 'Позиция курсора в файле ный момент , file.tellf))
О
о
0
0
Теперь с отступом добавьте инструкцию, чтобы
переписать текст с текущей позиции курсора
в файле:
file.writef )
С отступом добавьте инструкции, чтобы
сместить позицию курсора в файле еще раз
и переписать текст с новой позиции:
file.seekf 61 )
file.writef 'надгробие Карла Маркса.')
Наконец, добавьте с отступом инструкции,
чтобы вернуться к началу файла, и выведите на
экран обновленное содержимое файла:
file.seekf 0 )
text = file.readf)
printf 1Стр , text)
Сохраните и снова запустите программу, и вы
увидите обновленное содержимое файла.
функция seekf) может при
необходимости принимать
второе значение аргумента
(О, 1 или 2), чтобы
передвинуть позицию
курсора в файле, начиная
с начала, текущей позиции
или конца соответственно.
По умолчанию стартовой
позицией является 0.
125
IDLE Shell ЗЛО 4
File Edit Shell Debug Options Window Help
===== RESTART: C:\MyCode\update.py =====
File Nnw Closed?: False
File Now Closed?: True
String; The political slogan "Workers Of The World Unitel"
is fiom The Communist Manifesto.
Position in File Now 85
Position in File Now: 33
String; The political slogan "Workers Of All Lands Unite!"
is from the tombstone of Karl Marx
Как и в случае со строками,
первый символ файла
имеет индекс с позицией О,
а не индекс с позицией 1.
Управление текстом
Краткие итоги
• Строки можно обрабатывать с помощью оператора
конкатенации +, который соединяет строки,
и оператора повторения *, умножающего их.
• Строки можно обрабатывать с помощью среза
[] и среза диапазона [:], что позволяет получить
доступ к символам строки по их индексам.
• Строки можно обрабатывать с помощью
операторов принадлежности in и not in, которые
ищут в строке соответствия указанному символу.
• Оператор необработанной строки г (R) можно
разместить непосредственно в начале строки,
чтобы подавить в ней специальные символы.
• «Строка документации» — это описательная
строка, заключенная в тройные кавычки
и находящаяся в начале модуля, класса или
функции, чтобы разъяснить их назначение.
• Атрибут___doc_можно использовать, чтобы
получить описание из строки документации.
• С помощью функции dir{) можно извлечь имена
функций и переменных но умолчанию из модуля
«______buiJtins_».
У объекта String есть функция format!) для
форматирования строк, а также много функций для
их изменения, например функция capitalize!).
Поля замены в строке, которая должна быть
от форматирована функцией format!), обозначаются
в разделенном запятыми списке с помощью
фигурных скобок {}.
Строки можно отформатировать с помощью оператора
подстановки %s в стиле языка программирования С,
с помощью которого помечаются те места строки, где
будут сделаны замены.
У объекта File есть функции . pen!), read)), write!)
и close!) для работы с файлами, а также основные
признаки, описывающие свойства файла.
Для того чтобы прочитать файл, в ф\ нкцию ореп()
необходимо передать строковый аргумент с именем
файла, а также строковый параметр с режимом
открытия файла, например, 'г'.
У открытого объекта File есть основные признаки,
которые показывают его текущее состояние,
например значения тоое и readable!).
Позиция курсора в файле — место, с которого
файл считывается или куда записываются новые
данные, — может быть задана с помощью метода
seek(). Найти ее можно с помощью функции tell().
Ключевое слово with группирует внутри блока
программные инструкции для работы с файлами
и автоматически закрывает открытый файл.
Программные
объекты
128
В этой главе
показано, как 130
Объявление классов
Копирование
создавать в коде
экземпляров классов
программы ^32
виртуальные
объекты.
134
Обращение к свойствам
классов
Наследование классов
136 Переопределение
методов
138 Действовать схожим
образом
140 Краткие итоги
Программные объекты
Объявление классов
Принято начинать имена
классов с. заглавных букв,
а имена объектов — со
строчной.
У окружающих нас объектов реального мира есть
свое поведение и отличительные признаки, которые
мы можем описать. Например, автомобиль мы можем
охарактеризовать с помощью признака цвета «красный»
и описать его поведение с помощью «ускорения».
В программировании объекты выступают как
виртуальные представления объектов реального мира.
Они описывают признаки и поведение в структуре,
которая называется классом.
Класс — эго определенная схема, описывающая набор
свойств, характеризующих объект. У каждого класса
есть своя структура данных, содержащая функции
и переменные, описывающие объект. Свойства класса
определяются его элементами данных. Функции класса
известны как методы, а переменные, объявленные
внутри структуры класса, но вне каких либо методов, —
как атрибуты. К членам класса можно обратиться
в программе с помощью записи через точку, указав имя
члена после имени класса, с подобным синтаксисом;
имя-класса.имя-метода() или имя-класса.имя-атрибута.
Объявление класса начинается с ключевого слова class,
за ним следует имя, которое дает сам разработчик
(имя должно соответствовать правилам именования
в Python, но начинается с заглавной буквы), затем
ставится двоеточие:. Далее все инструкции пишутся
с отступом. При необходимости можно указать строку
документации, далее объявляются переменные атрибуты
и методы класса. Таким образом, синтаксис блока класса
выглядит следующим образом:
class ClassName:
строка документации класса
объявление переменной класса
объявление метода класса
Объявление класса, в котором определяются атрибуты
и методы, — это шаблон, по которому создаются его
рабочие копии («экземпляры класса»). Переменные,
объявленные внутри методов класса, доступны только
локально, внутри метода, где они заявлены. Вне структуры
класса к ним нельзя получить доступ напрямую.
Обычно переменные, объявленные внутри метода
класса, содержат данные, которые передаются
при вызове, когда создается экземпляр класса.
Поскольку эти данные доступны только локально,
для внутреннего использования, они фактически
скрыты от остальной. про1раммы. Такой способ
«инкапсуляции» данных позволяет удостовериться, что
данные безопасно хранятся внутри структуры класса"’.
Это первый принцип объектно-ориентированного
программирования (ООП).
* На самом деле инкапсуляция в языке Python носит условный
характер, так как данные не имеют сильной защиты и к ним
можно получить доступ. — Прим ред.
Ко всем свойствам класса можно обратиться внутри
класса, добавив через точку префикс self. Так, имя
атрибута «sound» — self.sound. Кроме того, во все
объявления методов в классе префикс self должен
передаваться в качестве первого параметра, например,
метод «talk» — talk(self).
Когда создается экземпляр класса, автоматически
вызывается специальный метод_____init_(self).
Последующие параметры можно добавить в скобках,
если нужно передать значения для инициализации
атрибутов.
Полностью объявление класса в Python выглядит
следующим образом:
class Critter
Базовый класс для хранения свойств домашних
животных.
count = О
def___init_( self, chat) :
self.sound = chat
Critter.count += 1
def tai k( seif) :
return self.sound
Рассмотрим компоненты класса из этого примера.
Переменная count является переменной класса.
Ее целочисленное значение делится между всеми
экземплярами класса. К этому значению можно
обратиться как к Critter.count как изнутри класса,
так и снаружи.
Первый метод___init_() — это метод
инициализации, который вызывается
автоматически при создании экземпляра класса.
В данном случае метод__init_() инициализирует
переменную sound значением, которое передается
из параметра chat, и приращивает значение
переменной класса count каждый раз, когда
создается экземпляр класса.
Второй метод talk() объявляется как обычная
функция. Единственное отличие — в нее
автоматически встроен первый параметр self. При
вызове значение в этот параметр передавать не
надо.
В данном случае метод talk() просто возвращает
значение, заключенное в переменной sound
К строке документации
класса можно получить
доступ через специальный
атрибут__doc__,
использовав запись
Classname, doc
129
Хотя класс в программе
не может полностью
симулировать объект
реального мира, его
цель — хранить в себе
все значимые свойства
и действия.
Копирование
экземпляров классов
Конструктор класса
создает экземпляр класса,
используя имя класса,
за которым в скобках
указываются любые
необходимые параметры.
Bird.ру
Экземпляр объекта класса — это всего лишь копия
шаблона, создающаяся при вызове конструктора
класса, где в круглых скобках указывается необходимое
количество параметров.
Аргументы для вызова конструктора должны совпадать
с теми, которые указаны при объявлении метода
за исключением значения внутреннего
параметра self.
Экземпляр класса, возвращаемый конструктором,
присваивается переменной, для чего используется
следующий синтаксис: имя-экземпляра = ИмяКласса
(аргументы).
Для того чтобы сослаться на методы и переменные
атрибуты объекта экземпляра класса, можно
использовать запись через точку, добавив к имени
экземпляра имя метода или имя атрибута: имя-
экземпляра.имя-методаО или имя-экземпляра.имя-
атрибута.
Обычно класс можно определить в отдельном модуле,
который можно импортировать в другие скрипты,
где с помощью «мастер-копии» будут с легкостью
создаваться экземпляры класса.
Создайте новый файл и объявите новый класс
с описательной строкой документации:
class Bird :
'"Класс, определяющий особенности птицы."’
О
О
Затем с отступом добавьте инструкции для того,
чтобы объявить и инициализировать переменную
класса с целочисленным значением 0:
count - 0
Вы не должны передавать
значение аргумента
з параметр self, так как
Python автоматически
встраивает этот параметр.
Теперь добавьте метод инициализации
класса, чтобы присвоить начальное значение
переменной и прирастить переменную класса:
def__init_{ self, chat) :
self.sound = chat
Bird.count += 1
Наконец, добавьте метод класса, возвращающий
значение переменной при вызове, и сохраните
файл:
def talk( self) :
return self.sound
Начните программу, импортировав в нее
созданный класс, затем выведите на экран
строку документации:
from Bird import *
printf , Bird._doc_)
V Далее добавьте инструкции, чтобы создать
экземпляр класса и передать строковое значение
аргумента в переменную:
polly = Bird) )
Теперь выведите на экран значение переменной
и метод класса, чтобы продемонстрировать
общее значение переменной для класса:
printf , Pird.count)
printf , polly.talkf) )
Создайте второй экземпляр класса, передав
в переменную другое строковое значение
аргумента:
harry = Bird! J
Наконец, выведите на экран значение
этой переменной и метод класса, чтобы
продемонстрировать общее значение
переменной для класса:
printf '\пКоличество птиц:', Bird.count)
printf , harry.talkf))
Сохраните оба файла, затем запустите
программу, и вы увидите, как создаются два
экземпляра класса Bird.
instance.ру
Экземпляр класса
Bird — Dolly
Экземпляр класса
Bird — harry
131
К переменной класса count
также можно обратиться
через запись Bird count,
но созданная внутри
метода инкапсулированная
переменная sound доступна
только при вызове метода
talkf) экземпляра класса.
Программные объекты
Передавая имя атрибута
в эти встроенные функции,
следует заключать его
в кавычки.
address.ру
Обращение
к свойствам классов
Атрибут экземпляра класса может быть добавлен,
изменен или удален в любой момент. Это делается
с помощью обращения к атрибуту через запись с точкой.
Если создать инструкцию, которая присваивает значение
атрибуту, то значение существующего атрибута будет
обновлено или появится новый атрибут с указанным
именем, содержащий присвоенное значение:
имя-экземпляра.имя-атрибута = значение
del имя-экземпляра.имя-атрибута
Или же вы можете использовать следующие встроенные
функции, чтобы добавлять, изменять или удалять
переменные:
getattrfHMH-экземпляра, 'имя-атрибута') —
возвращает значение атрибута экземпляра класса;
ЬаьаЦг(имя экземлляра, 'имя-атрибута') —
возвращает True, если значение атрибута
существует в экземпляре класса, иначе возвращает
False;
setайг(имя-экземпляра, ‘имя-атрибута’, значение) —
обновляет существующее значение атрибута или
создает новый атрибут экземпляра класса;
бе1аПт(имя-экземпляра, имя-атрибута') — удаляет
атрибут из экземпляра класса.
Если Python автоматически дает имя атрибуту, то оно
всегда начинается с подчеркивания, чтобы условно
обозначить его «приватность» — он не должен изменяться
или удаляться. При желании вы можете добавить свои
собственные атрибуты, названные подобным образом,
чтобы обозначить приватность, но на практике их можно
изменить, как и любой другой атрибут.
Начните новую программу, импортировав класс
Bird, который мы создали на страницах 130-131:
from Bird import *
Теперь создайте экземпляр класса и добавьте
новый атрибут, присвоив ему значение
с помощью записи через точку:
chick = Bird( )
chick.age = *1 । еля
Теперь выведите на экран значение обоих
атрибутов:
prrnt( , chick.talkf ) }
printf , chick.age )
Далее измените новый атрибут с помощью
записи через точку и выведите на экран новое
значение:
chick.age =
printf , chick.age )
О
Измените новый атрибут, на этот раз
используйте встроенную функцию:
setattrf chick , 'age', '3 ^ели')
Экземпляр класса
Bird — chick
Теперь с помощью встроенной функции
выведите на экран список всех атрибутов
экземпляра класса, не являющихся приватным,
и их значений:
printf '\пАтрибуты экземпляра chick...' )
for attrib in dirf chick ) :
if attribfO? != :
printf attrib , , gerattrf chick , attrib ) )
Наконец, удалить новый атрибут и подтвердите
удаление с помощью встроенной функции:
delattrf chick , )
printf '\пУ цыпленка есть атрибут возраста?',
hasattrf chick , ) )
Сохраните и запустите программу, и вы увидите
обращения к атрибутам экземпляра класса.
133
Hr 'DLE Shell 3.10.4
File Edit Shell Debug Options Window Help
======= RESTAPT C:\MyCode\addiess.py ======
Chick Says: Cheep, cheep!
Chick Age. 1 week
Chick Now: 2 weeks
Chick Attributes...
age. 3 weeks
count:1
sound: Cheep, cheep!
talk: <bound method Bird .talk of <Bird Bird object at OxOC
0001EF0AD7CDF0»
Chick age Attribute? False
Этот цикл пропускает
атрибуты, имена
которых начинаются
с подчеркивания, так что
«приватные» атрибуты
в списке отображаться
не будут.
:z
Ф
.a
D
О
Ф
J2
X
5
ra
CL
-
Cl
CZ
Наследование классов
В Python класс можно создать как совершенно новый, как мы
уже делали в предыдущих примерах. Кроме того, он может
быть «унаследована от уже существующего класса. Особенно
важно, что производный (дочерний) класс наследует
членов родительского (базового) класса, от которого он
происходит, — вдобавок к собственным членам.
Способность наследовать членов базового класса
позволяет производным классам приобретать
определенные общие свойства, определенные
в родительском классе. 11апример, базовый
класс «Многоугольник» может иметь свойства
длины и ширины, которые будут общими для
всех многоугольников. Классы «Прямоугольник»
и «Треугольник» могут быть унаследованы от класса
«Многоугольник», и при этом унаследуют свойства
длины и ширины, но вдобавок у них будут собственные
члены, определяющие их уникальные характеристики.
134
Polygon, py
Rectangle.py
Наследование — очень мощный инструмент. Это
второй принцип объектно - ориентированного
программирования (ООП).
При создании производного класса после имени класса
добавляются круглые скобки, где указывается имя
родительского базового класса.
Создайте новый файл и объявите новый
базовый класс с двумя переменными класса
и методом, устанавливающим их значение*:
class Polygon :
width = О
height = п
def set_values( self, width , height) :
self.width = width
self.height = height
Затем создайте новый файл и объявите
производный класс с методом, возвращающим
результат манипуляций с переменными класса:
from Polygon -mport *
class Rectanglef Polygon ) :
def area( self) :
return self.width * self.height
* Созданный файл должен иметь имя Polygon ру иначе, на втооом
шаге, программа выдаст ошибку. — Прим. ред.
о
Теперь создайте еще один файл и объявите
производный класс с метолом, возвращающим
результат манипуляций с переменными класса:
from Polygon mport *
class Triangle! Polygon ):
def area( self) :
return ( self.width * self.height ) / 2
Triangle, ру
О
Сохраните три файла с классами, затем
начните новую программу, импортировав оба
производных класса*
from Rectangle import *
from Triangle .mport *
0
Создайте экземпляр каждого дочернего класса:
rect = Rectangle()
inherit.ру
trey = Triangle!)
О
Далее вызовите метод класса, унаследованный
из базового класса, передайте ар1ументы
в переменные класса:
rect.set_values{ 4,5)
trey.set_values( 4,5)
О
Теперь выведите на экран результат
манипуляций с переменными класса,
унаследованными из базового класса:
print! 'Площадь п сольника , rect.area() )
print( 'Площадь треугольника:', trey.area() )
135
О
Сохраните и запустите программу, и вы увидите,
как результаты вычислений с использованием
унаследованных свойств родительского класса
выводятся на экран.
Можно объявить
наследование
производного класса
от нескольких классов.
Тогда при объявлении
дочернего класса
родительские классы
перечисляются в скобках
через запятую.
Не путайте экземпляры
классов и производные
классы. Класс — это
шаблон для создания
экземпляра. Производный
класс — новый класс,
наследующий свой-
ства базового класса,
от которого он образован.
* Файлы с производными классами также должны иметь имена
Rectangle.ру и Triangle ру. — Прим. ред.
XI
:
Ф
fi
VO
О
ф
J3
I
S
5
га
о
а—
о
о.
с
Переопределение
методов
В производном классе можно объявить метод,
переопределяющий соответствующий метод базового
класса, при этом методы должны иметь одно и то же
имя и одно и то же количество параметров. Таким
образом метод родительского класса полностью
скрывается и становится недоступным, если только
не вызывается явно с помощью имени базового класса.
Если метод базового класса предоставляет значение
параметра по умолчанию, оно может быть использовано
при явном вызове базового метода, или же вы можете
задать другие значения, переопределив методы.
136
Person ру
Man ру
Hombre ру
Создайте новый файл с именем Person.py и объявите
новый базовый класс с методом инициализации, чтобы
определить значение переменной, и вторым методом,
выводящим значение переменной:
class Person :
"'Базовый класс Регтог,, определяющий характерные особенности человека."1
def__init_( self , name )
self, name = name
def speak( self, msg '(Вызов базового класса)') :
print( self.name , msg )
Затем создайте новый файл с именем Мап.ру
и объявите производный класс с методом,
переопределяющим второй метод родительского класса:
from Person import *
class Man( Person ) :
'"Производный класс, определяющий особенности класса Man'"
def speak( self, msg ) :
print( self.name , i\tK , msg )
Теперь создайте еще один файл с именем Hombre.py
и объявите производный класс с методом, который
еще раз переопределяет тот же метод базового класса:
from Person import *
class Hombre( Person ) :
"'Производный класс, определяющий особенности класса Hombre'"
def speak( self , msg ) :
print( self.name , , msg )
Сохраните три файла с классами, затем
начните новую программу, импортировав оба
производных класса:
from Man троп *
from Hombre import *
О
Создайте экземпляр каждого дочернего класса,
инициализировав переменную атрибута имени:
guy_l = Мап| )
guy_2 = Hombre( )
Далее вызовите переопределенные методы
каждого производного класса, присвоив разные
значения параметру «msg»:
guy_l.speak( 'lt\'s a beautiful evening.\n')
guy_2.speak( 'Es una tarde hermosa.\n')
Наконец, явно вызовите метод базового
класса, передав ссылку на экземпляр каждого
производного класса. Не используйте
переменную msg, поскольку в этом случае будет
использовано ее значение по умолчанию:
Person.speak( guy_l)
Person.speak( guy_2 )
override.ру
Экземпляр
класса Man —
Ричард
Сохраните и запустите программу, и вы увидите
результаты работы переопределенных методов
и метода базового класса.
Экземпляр
класса
Hombre —
Рикардо
137
Чтобы переопределить
метод, объявление метода
в производном классе
должно точно совпадать
с его объявлением
в базовом классе.
х
ф
а
О
О
ф
J3
I
S
5
га
CL
С
138
Duck.оу
Mouse.ру
Действовать
схожим образом
Три краеугольных камня объектно-ориентированного
программирования (ООП) — это инкапсуляция,
наследование и полиморфизм. Выше в этой главе мы
рассматривали, как данные могут инкапсулироваться
внутри класса в Python и как производные классы наследуют
свойства базовых классов. В этом примере мы поговорим
о последнем основополагающем принципе — полиморфизме.
Термин «полиморфизм» происходит от греческого
выражения, означающего «много форм», и описывает
способность приписывать сущности различные
значения или цели в зависимости от контекста.
В Python сущность символа +• можно описать как
полиморфную, поскольку он может представлять
как арифметический оператор сложения (в контексте
операций с числами), так и как оператор конкатенации
строк в контексте операций с символами.
Но куда более важно, что методы классов в Python
также могут быть полиморфными, так как язык
программирования Python использует так называемую
«утиную типизацию». Эго означает, что если что-то
ходит, как утка, плавает, как утка, и крякает, как утка,
то эта птица считается уткой.
В языке с утиной типизацией можно создать функцию,
которая будет принимать объект любого типа
и вызывать методы этого объекта. Если у объекта
действительно есть вызываемые методы (он считается
уткой), то они выполняются, иначе функция сообщает
об ошибке времени выполнения программы.
В разных классах могут быть созданы методы
с одинаковыми именами, и экземпляры этих классов
будут выполнять действия схожим образом.
Создайте новый файл с именем
Duck.py и объявите новый класс с методами,
выводящими на экран строки, уникальные для
этого класса:
class Duck :
def talkf self) :
printf )
def coatf self ) :
printf У1 |
Затем создайте новый файл с именем Mouse.py
и объявите класс с методами, имеющими такие
же названия, но выводящими на экран строки,
уникальные именно для этого класса:
class Mouse :
def taik( self ) :
printf '\пМышь говорит: Пи-пи!' )
def coatf self ) :
printf >: Mt )
о
Сохраните оба файла с классами, затем начните
новую программу, импортировав классы:
from Duck import *
from Mouse import *
О
Объявите функцию, которая в качестве
параметра принимает любой объект,
и попробуйте вызвать методы этого объекта:
def describe( bject) :
object.talkQ
object.coat()
0
polymorph ру
Теперь создайте объект — экземпляр каждого
класса:
dolly = Duck()
monty = Moused
О
Наконец, добавьте инструкции, чтобы вызвать
функцию, передав в качестве аргумента каждый
объект экземпляра класса:
describe( dolly )
describe( monty )
0
Экземпляр
класса Duck —
doily
Сохраните и запустите программу, и вы увидите,
как вызываются похожие методы.
Экземпляр
класса Mouse —
monty
139
Объектно-ориентированное программирование на
Python позволяет инкапсуляцию данных, наследование
и полиморфизм. Методы базового класса могут быть
переопределены методами с такими же именами
в производном классе. Тем не менее Python не
поддерживает так называемую перегрузку методов,
характерную для других языков программирования,
когда методы с одинаковыми именами могут
создаваться с различным списком параметров в рамках
одного класса.
Имена методов в рамках
одного класса не могут
повторяться: Python не
поддерживает nepei рузку
методов.
Программные объекты
Краткие итоги
Объекты в программировании можно считать
виртуальным представлением объектов реального
мира: они описывают характерные черты
и поведение объектов с помощью «классов».
Класс — это структура данных, описывающая
характерные черты объекта с помощью своих
членов, методов и атрибутов.
Объявление класса начинается с ключевого слова
class, затем с отступом следует блок кода, который
может содержать строку документации, методы
и переменные класса.
Переменные, присвоенные при объявлении класса,
относятся к глобальной области видимости,
но переменные, объявленные внутри методов,
являются локальными.
Переменные в методах класса безопасно хранят
данные в структуре класса и инициализируются,
когда создается экземпляр класса.
• К свойствам класса можно обратиться с помощью
записи через точку; внутри класса они доступны
через префикс е
Экземпляр класса — это копия шаблона. Метод
_init_() вызывается автоматически, когда
экземпляр создается впервые.
Атрибуты класса могут быть добавлены, изменены
или удалены с помощью записи через точку. Кроме
того, ими можно манипулировать с помощью
встроенных функций getattr(), hasattr(), setattr()
и delattr().
Если Python автоматически дает имя атрибуту,
то оно всегда начинается с подчеркивания, чтобы
условно обозначить «приватность».
• Производные классы наследуют методы и атрибуты
родительского базового класса, от которого они
образуются.
• Объявление производного класса должно содержать
имя родительского класса, которое помещается
в скобках после имени дочернего класса.
• Метод производного класса может переопределить
соответствующий одноименный метод
родительского базового класса.
• Метод базового класса может быть вызван явным
образом с помощью имени родительского класса.
• Python — динамически типизированный язык,
поддерживающий полиморфизм для методов
с одним и тем же именем в разных классах.
Три краеугольных камня объектно-
ориентированного программирования (ООП) —
это инкапсуляция, наследование и полиморфизм.
Создание
интерфейсов
142
В этой главе
показывается. 144
Запуск интерфейсов
Реагирующие кнопки
как со л да вить
146
программы
с оконным 148
Вывод сообщений
Сбор входных данных
графическим «
150 Список опции
интерфейсом.
152 Радиокнопки
154 Флажки или чекбоксы
156 Добавление изображений
158 Краткие итоги
Создание интерфейсов
Запуск интерфейсов
В программе может
быть только один вызов
конструктора Тк(), и он
должен находиться
в начале кода.
Метод управления
размещением gridf) показан
в примере на с 161.
Для создания графических приложений на Python
можно воспользоваться стандартным модулем
tkinter (сокращенное от toolkit interface) — набором
инструментов для взаимодействия с графическим
пользовательским интерфейсом (GUI) системы.
Модуль «tkinter» можно импортировать в программу,
как и любой другой модуль. Это даст доступ к его
атрибутам и методам для создания приложений
с окнами. Любая программа tkinter должна начинаться
с вызова конструктора Тк(), который создает объект
Window. Размер окна при необходимости определяется
как строковый аргумент 'widthxheight', передаваемый
в метод geometryO объекта Window. Подобным же
образом заголовок окна можно определить как
строковый аргумент 'title', передаваемый в метод titlef)
объекта Window. Если эти аргументы не определены,
то используется размер и заголовок по умолчанию.
Каждая программа tkinter должна также вызывать метод
mainloopO объекта Window, чтобы захватывать такие
события, как закрытие пользователем окна, чтобы
выйти из программы. Этот цикл должен появляться
в конце программы, так как он также обрабатывает
обновления окна, которые могут выполняться во время
ее работы.
При работе с tkinter в окно приложения могут быть
включены все элементы графического управления,
такие как кнопки или чекбоксы. Их принято называть
виджетами. Возможно, самый простой виджет — это
неинтерактивный объект Label, который просто
выводит на экран текст или изображение в интерфейсе
приложения. Для создания объекта Label нужно
передать в конструктор Label() два аргумента: имя
объекта Window и строку текста text= 'string'.
• pack() — размещает виджет около определенной
стороны окна, используя постоянные значения ТОР,
BOTTOM, LEFT или RIGHT, определенные в аргументе
side=;
• placet) — размещает виджет по координатам XY,
используя числовые значения, определенные
в аргументах х= и у=;
• gnd() — размещает виджет по ячейкам условной
сетки, разделяющей окно приложения, с помощью
числовых значений, определенных в аргументах
row= и column^.
При необходимости в метод раск() может передаваться
аргумент fill, чтобы растянуть виджет на все доступное
пространство, например, fill = 'х'. Или же в метод можно
передать аргументы padx и pady, чтобы растянуть
виджет на необходимое расстояние по горизонтали или
по вертикали.
о
Начните новую программу, импортировав
методы и атрибуты модуля графического
пользовательского интерфейса tkinter:
from tkinter mport *
О
Затем добавьте инструкцию, чтобы вызвать
конструктор для создания объекта Window:
window = Tk()
window, ру
О
Теперь добавьте инструкцию, чтобы определить
заголовок окна:
window.title( )
Добавьте инструкцию, вызывающую
конструктор для создания объекта Label:
label = Labelf window , text = )
О
Теперь используйте «упаковщик», чтобы
добавить Label в окно, указав горизонтальное
и вертикальное растягивание:
label.packf padx = 200 , pady = 50 )
Виджеты не появятся
в окне при запуске
программы, если они
не были добавлены
с помощью средств
управления размещением.
Наконец, добавьте обязательную инструкцию,
чтобы окно могло улавливать события:
window.mainloopf)
Сохраните и запустите программу, и вы увидите,
как на экране появится окно с виджетом.
143
У Тк есть два поколения
виджетов: классические
и белее новые виджеты
с темами. Тематические
виджеты заменили
многие (но не все)
классические виджеты.
Они предоставляют
разнообразные варианты
стилевого оформления Во
всех примерах Тк в этой
книге используются только
классические виджеты
ДЛЯ ТО'О, ЧТОбы КОД ОЫЛ
лаконичным. Информацию
о тематических виджетах
вы можете найти в docs.
python.org/3/library/tkinter.
ttk.html.
Создание интерфейсов
Реагирующие кнопки
Виджет кнопки предоставляет графическую кнопку
в окне приложения. Она может содержать как текст,
гак и изображение в зависимости от цели кнопки. При
создании объекта Button указывается имя окна и варианты
его настройки, которые как аргументы передаются
в конструктор Button(). Каждых! из вариантов определяется
как пара опция=значение. В опции command (команда)
всегда должно указываться имя функции или метод,
вызываемые, когда пользователь нажимает на кнопку.
Самые часто используемые опции приведены в таблице
ниже вместе с краткими описаниями:
Метод кнопки invoked*
также можно вызвать,
вызвав функцию, указанную
в опции command.
* Метод активации кнопки
без необходимости клика
по ней. — Прим. ред.
Опция Описание
activebackg'Ound Цвет фона при наведении курсора
acdveforeground Цвет переднего плана при наведении курсора
bd Ширина раницы в пикселях (по умолчанию 2)
bg Цвет фона
command Функция, которая вызывается при нажатии на кнопку
fg Цвет переднего плана
font Шрифт надписи на кнопке
neignt Высота кнопки в строках для текста или пикселях для изображения
highlightcolor Цвет границы, когда виджет активен
image Вместо текста отображается изображение Устанавливает выравнивание текста.
justify Значение LEFT выравнивает текст по левому краю, CENTER — по центру, RIGHT — по правому краю
padx Растягивание по горизонтали
pady Растягивание по вертикали
renef Задает стиль рамки (SUNKEN, RIDGE, RAISED или GROOVE)
state Управляет состоянием виджета: активное или отключенное
underline Подчеркивание символа в кнопке
width Ширина символа кнопки в буквах или пикселях для изображения
wraplength Ограничить количество символов в каждой строке
Значения, приписанные другим опциям, определяют,
как выглядит виджет. Их можно изменить, передав
в качестве аргумента в метод виджета configured пару
новая опция-значение. Кроме того, текущее значение
опции можно вернуть, передав его имя как строковый
аргумент в метод виджета cget().
о
о
Начните новую программу, импортировав
методы и атрибуты модуля графического
пользовательского интерфейса tkinter, затем
создайте окно и определите его заголовок:
from tkinter import *
window = Tk()
window.titie( )
button.py
Затем создайте кнопку выхода из программы
при клике на нее:
btn_end = Buttonf window, text = , command=exit)
О
о
о
о
Теперь добавьте функцию, чтобы переключать
фоновый цвет окна, когда нажимается другая
кнопка:
def tog() :
if window cget( | ==
window, configure! bg = )
else :
window.configure) bg = )
Создайте кнопку, чтобы при клике вызывать
функцию:
btn tog = Button! window, text = , command-tog)
В опции command
определяется только
имя функции. Не ставьте
круглые скобки.
Добавьте кнопки в окно, указав горизонтальное
и вертикальное растягивание:
btn_tog.pack( padx = 120 , pady = 20 )
btn_end pack( padx = 120 , pady = 20 )
Наконец, добавьте цикл, чтобы окно могло
улавливать события:
window, mainloop!)
Сохраните, затем запустите программу, нажмите
кнопку, и вы увидите, как меняется цвет фона
окна.
145
Светло-серый цвет
Tightgray' похож на цвет
окна по умолчанию.
Создание интерфейсов
Вывод сообщений
Программа может выводить сообщения для
пользователя, вызывая методы из модуля «tkinter.
messagebox». Его следует импортировать отдельно,
а длинное имя полезно заменить коротким псевдонимом
с помощью команды import as.
Окно сообщения можно создать, передав его заголовок
и текст сообщения для пользователя как два аргумента
в один из следующих методов.
Метод
showinto()
ОК
showwarningt)
ОК
showerror()
ОК
askquestion()
Yes возвращает строку yes
No возвращает строку по
Только метод askquestionf)
возвращает два строковых
значения.
askokcancel()
askyesno()
askret rycancelQ
askyesnocancel()
ОК возвращает True
Cancel возвращает False
Yes возвращает True
No возвращает False
Retry возвращает True
Cancel возвращает False
Yes возвращает True
No возвращает False
Cancel возвращает None
Методы, которые создают окно сообщения, содержащее
одну кнопку ОК, не возвращают никакого значения,
когда пользователь нажимает на кнопку. Те же методы,
которые возвращают значение, можно использовать
для создания условного ветвления при проверке этого
значения.
Начните новую программу, импортировав
методы и атрибуты модуля графического
пользовательского интерфейса tkinter, а также
окно сообщений, сделав его доступным иод
коротким псевдонимом:
from tkinter import *
import tkinter.messagebox as box
message.ру
О
о
Затем создайте объект Window и определите его
заголовок:
window = Tk()
window.title( 'Пример окна сообщения' )
Теперь добавьте функцию, чтобы отображать
различные окна сообщений:
def dialog!) :
var = box.askyesno( 'Окно сообщения' , 'Обработать?'
)
if var == 1 :
box.showinfo( )кно Да1, 'Обрабо <а...')
else :
box.showwarning!' , )
Создайте кнопку, чтобы при клике вызывать
функцию:
bin = Buttonf window , text = ,
command=diaiog)
Опции можно передать
как третий аргумент
в вызовах метода.
Например, добавьте
type='ab">rtretryignore',
и вы получите три кнопки
147
Добавьте кнопку в окно, указав горизонтальное
и вертикальное растягивание:
btn.pack( padx = 120 , pady = 50 )
О
Наконец, добавьте цикл, чтобы окно могло
улавливать события:
window.mainloop()
Сохраните файл, затем запустите программу,
нажмите кнопку, и вы увидите, как появляются
окна сообщений.
Message Box
Message Box Example — □ X
Canceling...
I or I
OK
Создание интерфейсов
Сбор входных данных
Виджет полей ввода создает в приложении
однострочное поле ввода, через которое программа
может собирать данные у пользователя. Чтобы создать
объект Entry, нужно указать имя родительского
контейнера (например, окна или фрейма) и в качестве
аргумента передать опции в конструктор Entry(). Каждая
опция определяется как пара опция=значение. Часто
используемые опции вместе с кратким описанием
каждой перечислены ниже:
Опция
Описание
bd
Ширина границы в пикселях
bg
Цвет фона
1g
Цвет переднего плана, используемый
для отображения текста
font
Шрифт текста
highlightcolor
Цвет границы, когда виджет активен
selectbackground
Цвет фона выбранного текста
selectforeground
Цвет переднего плана выбранного текста
snow
Скрыть символы пароля можно командой
show='*'
state
Управляет состоянием виджета- активное
или отключенное
width
Ширина окна ввода в буквах
Вместо виджета полей
ввода можно использовать
текстовый виджет, если вы
хотите, чтобы пользователь
вводил несколько строк
текста. Конструктор Text()
принимает те же опции,
что и конструктор Entry(),
а также опцию height
(размер по высоте).
Несколько виджетов можно сгруппировать в один
фрейм для удобства размещения. Для того чтобы
создать объект Frame, нужно передать имя окна
в конструктор Framed. Имя фрейма можно указать как
первый аргумент, чтобы конструктор виджета определил
его как контейнер для виджетов.
После того как во фрейм будут добавлены виджеты, вы
можете определить, по какой стороне их выравнивать,
воспользовавшись постоянными значениями ТОР,
BOTTOM, LEFT или RIGHT, например entry.pack(side=LEFT).
Обычно виджет полей ввода появляется рядом
с объектом Label, описывающим тип входных данных,
ожидаемых от пользователя, или рядом с виджетом
кнопки, которую пользователь может нажать, чтобы
выполнить какое-либо действие с введенными данными,
поэтому размещение их в одном фрейме оказывается
оптимальным.
Данные, переданные на настоящий момент в виджет
полей ввода, можно получи!ь в программе, использовав
метод get() виджета.
о
о
о
о
о
о
о
о
Начните новую программу, импортировав
методы и атрибуты модуля графического
пользовательского интерфейса tkinter, а также
окно сообщений, сделав его доступным иод
коротким псевдонимом:
from tkinter import *
import tkinter.messagebox as box
Затем создайте объект Window и определите его
заголовок:
window = Tk()
window titie( )
Теперь создайте фрейм, хранящий поле ввода
для входных данных:
frame = Frame( window )
entry = Entry( frame )
entry.py
Добавьте функцию, выводящую на экран данные,
вводимые пользователем:
det dialog() :
box.showinfo( ггствие', 'Добро ' + entry.get()
)
Создайте кнопку для вызова функции
при нажатии:
btn = Button( frame, text = , command-dialog )
149
Добавьте кнопку и поле ввода во фрейм
и определите сторону выравнивания:
btn.pack( side = RIGHT , padx = 5 )
entry.packf side = LEFT )
frame.pack( padx = 20 , pady = 20 ]
Наконец, добавьте цикл, чтобы окно могло
улавливать события:
window.mainlcmpO
Сохраните файл, затем запустите программу,
введите имя, нажмите кнопку, и вы увидите, как
появляется приветственное сообщение.
Вместо виджета полей
ввода можно использовать
виджет Laoel, если
вы хотите вывести на
экран текст, который
пользователь не может
изменить.
Создание интерфейсов
Список опций
Виджет окна списка отображает в приложении список
элементов, из которого пользователь может что-то
выбрать. Чтобы создать объект Listbox, нужно передать
в качестве аргументов имя родительского контейнера
(например, окна или фрейма) и опции в конструктор
Listbox(). Популярные опции вместе с кратким описанием
каждой перечислены ниже:
В tkinter полоса
прокрутки — это отдельный
виджет, который можно
присоединить к окну
списка, тексту, объекту-
холсту и виджету окна
ввода.
Опция Описание
bd Ширина границы в пикселях (по умолчанию 2)
bg Цвет фона
fg Цвет переднего плана, используемый для отображения текста
font Шрифт текста
height Количество строк в списке (по умолчанию 10)
selectbackground Цвет фона выбранного текста
selectmode Возможность выбрать один из вариантов (по умолчанию) или несколько вариантов
widtn Ширина окна списка в буквах (по умолчанию 20)
yscrollcommand Добавляет вертикальную полосу прокрутки
listbox.ру
Чтобы добавить в окно списка элементы, нужно
передать число с индексом этого элемента и строку с его
названием в метод insert().
Получить любой элемент окна списка можно, указав его
индекс в круглых скобках после метода get(). Полезно,
что у окна списка есть также и метод curselection(),
возвращающий индекс выбранного элемента, поэтому
таким образом можно получить аргумент для метода
get{), чтобы вернуть текущий выбор.
Начните новую программу, импортировав
методы и атрибуты модуля графического
пользовательского интерфейса tkinter, а также
окно сообщений, сделав его доступным под
коротким псевдонимом:
from tkinter import *
import tkinter.messagebox as box
i j Затем создайте объект Window и определите его
заголовок:
window = Tk()
window.title( )
Теперь создайте фрейм, хранящий виджеты:
frame = Frame( window )
Создайте окно списка, предлагающее для
выбора три элемента:
listbox = Listbox( frame )
listbox.insert! 1, 'HTML in eas )
listbox.insert( 2 , 'CSS in « )
listbox insertf 3 , )
e
о
Добавьте функцию, выводящую на экран
выбор, сделанный в окне списка:
def dialog!) :
box.showinfo! 'Sok . , + \
listbox.get( listbox.curselectionQ ))
Если в опции selectmode
стоит возможность
Вь|бирате несколько
элементов списка, то метод
curselection() возвращает
кортеж из индексов
выбранных элементов.
Создайте кнопку для вызова функции
при нажатии:
btn = Button! frame. text = , command = dialog)
О
Добавьте кнопку и поле списка во фрейм
и определите сторону выравнивания:
btn.pack( side = RIGHT , padx = 5 )
listbox.pack( side = LEFT )
frame.pack( padx = 30 , pady = 30 )
О
Наконец, добавьте цикл, чтобы окно могло
улавливать события:
window, mainloop!)
151
О
Сохраните файл, затем запустите программу,
выберите опцию из списка, нажмите кнопку,
и вы увидите, что ваш выбор подтверждается.
Listbox Example — □ X
JBI f Selection
Choose
Your Choice: JavaScript in easy steps
Создание интерфейсов
Радиокнопки
Виджет Radiobutton представляет собой
переключатель, который может находиться
в двух состояниях: выбранном или невыбранним.
Переключатели могут создавать группу, из которой
одномоментно пользователь может выбрать только
один переключатель. В tkinter объекты Radiobutton
группируются вместе, когда они привязаны к одной
управляющей переменной для присваивания
значения при выборе. Для этой цели можно создать
пустую строковую переменную StringVar с помощью
конструктора StringVar)) или пустую целочисленную
переменную IntVar с помощью конструктора IntVar)).
Для создания объекта Radiobutton в конструктор
Raaiubuttc>n|) передаются четыре аргумента:
Имя родительского контейнера, например имя
фрейма.
Текст, который выводится на экране, указывается
как пара text=text.
Управляющая переменная, указывается как пара
variable=variable.
Значение, которое будет присваиваться
переменной, указывается как пара value=value.
гаою.ру
У каждого объекта Radiobutton имеется метод select)),
который можно использовать, чтобы указать выбор
из группы переключателей по умолчанию на момент
запуска программы. Строковое значение, которое
присваивается при выборе переключателя, можно
вернуть из строковой переменной, воспользовавшись
методом get)).
Начните новую программу, импортировав
методы и атрибуты модуля графического
пользовательского интерфейса tkinter, а также
окно сообщений, сделав его доступным под
коротким псевдонимом:
from tkinter import *
mport tkinter.messagebox as box
О
Затем создайте объект Window и определите его
заголовок:
window = Tk()
wmdow.title) )
О
Теперь создайте фрейм, хранящий виджеты:
frame = Frame) window j
Создайте объект строковой переменной
StringVar, чтобы хранить результаты выбора:
bi>ok = StringVar))
0
Создайте три виджета Radiobutton, чьи значения
в результате выбора будут приписываться
к строковой переменной:
гасЬо_1 = Radiobutton! frame , text = , \
variable = book , value = )
radio_2 = Radiobutton! frame , text = , \
variable = book , value = )
radso_3 = Radiobuttonf frame , text = , \
variable = book , value a 'JavaScript teps*)
0
Добавьте инструкцию, указывающую, какой
переключатель будет выбран по умолчанию при
запуске программы:
radio_l.select()
О
Добавьте функцию, чтобы вывести на экран
выбор переключателей и кнопку для вызова этой
функции:
def dialog() :
box.showinfo( выберите один из вариантов", \
+ book.get())
btn = Button! frame , text = ’Choose', command = dialog)
0
У объекта Radiobutton есть
метод deselect!), который
можно использовать,
чтобы отменить выбор на
программном уровне.
Добавьте кнопку для вызова функции
и переключатели во фрейм:
btn.pack( side = RIGHT , padx = S )
radio l.packf side = LEFT )
radio_2.pack( side = LEFT )
radio_3.pack( side = LEFT )
frame.pack( padx = 30 , pady = 30 I
153
0
Наконец, добавьте цикл, чтобы окно могло
улавливать события:
window.mainloop!)
Сохраните файд, затем запустите программу,
выберите опцию из списка, нажмите кнопку,
и вы увидите, что ваш выбор подтверждается.
z Radio Button Example — □ X
r HTML CSS c JS Choose
Создание интерфейсов
Флажки или чекбоксы
£--
Е--
check.ру
Виджет чекбокса предоставляет единичный элемент
приложения, который пользователь может выбрать.
Когда появляется несколько чекбоксов вместе,
пользователь может выбрать один или более элементов.
Объекты Checkbutton привязаны к отдельной
управляющей переменной, чтобы хранить значение.
Они могут находиться в двух состояниях: отмеченном
или неотмеченном. Для этого с помощью конструктора
StringVar(), lntVar(), DoubleVarf) или BonleanVar() создается
пустой объект переменной. Поскольку отмеченное/
неотмеченное состояние объекта представляется через
значения True (1) и False (0), лучше всего воспользоваться
булевыми объектами.
Для создания объекта Checkbutton в конструктор
Checkbutton() передаются пять аргументов:
• Имя родительского контейнера, например имя
фрейма.
• Текст, который выводится на экране, указывается
как пара text=text.
• Управляющая переменная, указывается как пара
variable=variable.
• Значение, которое будет присваиваться
переменной, если объект отмечен, указывается как
пара onvalue-value.
• Значение, которое будет присваиваться
переменной, если объект не отмечен, указывается
как пара offvalue=value.
Строковое значение, присвоенное чекбоксу, можно
вернуть из объекта переменной, воспользовавшись
методом get().
О
о
о
о
Начните новую программу, импортировав
методы и атрибуты модуля графического
пользовательского интерфейса tkinter, а также
окно сообщений, сделав его доступным под
коротким псевдонимом:
from tkinter import *
import tkinter.messagebox as box
Затем создайте объект Window и определите его
заголовок:
window = lk()
window.title( 'Пример CheckButton ' )
Далее создайте фрейм для хранения виджетов;
frame = Framef window )
Теперь создайте три логические переменные,
чтобы хранить значения:
var_ 1 = BooleanVar()
var_2 = BooleanVar()
var_3 = BooleanVar()
V Создайте три виджета Checkbutton, чьи
значения будут приписываться целочисленным
переменным, независимо от того, отмечены ли
чекбоксы или не отмечены:
hook_l = Checkbutton! frame , text = \
variable = var_l )
bouk_2 = Checkbutton( frame , text = , \
variable = var_2 )
book 3 = Checkbutton! frame , text = , \
variable = var_3 )
Далее добавьте функцию, чтобы выводить на
экран результат выбора чекбоксов:
def dialog!) :
s =
if var_l.get() == 1: s += '\ntn «.II in < asy step
if var_2.get() == 1: s +=
if var_3.get() == 1 s +=
box.showinfo{ , s)
Создайте кнопку для вызовы этой функции:
btn - Button! frame, text = , command = dialog)
Добавьте кнопку для вызова функции и чекбоксы
во фрейм:
btn.pack( side = RIGHT , padx = 5 )
book_l.pack( side = LEFT )
bo< k_2.pack( side = LEFT )
book_3.pack( side = LEFT )
frame.pack! padx = 30, pady = 30 )
Наконец, добавьте цикл, чтобы окно могло
улавливать события:
window.mainloop!)
Сохраните файл, затем запустите программу,
выберите чекбоксы, нажмите кнопку, и вы
увидите, что ваш выбор подтверждается.
У объекта Checkbutton
есть методы select!)
и deselect!), которые
можно использовать,
чтобы переключать
флаг состояния с «вкл.»
на «выкл.» и наоборот,
например check_l.se!ect().
155
z Check Button Example
U X
HTML I” CSS 17 JS Choose
Состояние любого объекта
Checkbutton можно
вернуть, вызвав метод
toggle!).
Создание интерфейсов
У класса Photoimage
также имеется метод
zuom(), который в два раза
увеличивает изображение,
если указать те же
значения х=2 и у=2.
image.ру
python.gif
(200 х 200)
Добавление
изображений
В модуле tkinter можно отобразить изображения
в формате GIF или PGM/PPM на виджетах типа
Label, Button, Text и Canvas. Для создания объекта
Image используется конструктор Phciolmagef). В него
передается один аргумент file=, определяющий файл
с изображением. Что интересно, у объекта есть метод
subsamplef), с помощью которого можно уменьшить
указанное изображение, установив опорное значение
для х= и у=. Например, значения х=2, у=2 выбирают
каждый второй пиксель, так что объект Image
уменьшается в два раза по сравнению с оригиналом.
После того как объект Image создан, его можно добавить
в конструктор Label() или Buttonf) с помощью опции
image=.
У текстовых объектов есть метод image_create(),
с помощью которого изображение вставляется
в текстовое поле. Для этого нужно передать два
ар!умента, чтобы указать местоположение и image=,
например '1.0' указывает на первую строку и первый
символ.
У объектов холста есть метод create_image(), который
принимает два аргумента: местоположение и image=.
Здесь указываются координаты х, у, на которых
отрисовывается изображение.
О
о
о
о
о
Начните новую программу, импортировав
методы и атрибуты модуля графического
пользовательского интерфейса tkinter, затем
создайте объект Window и определите его
заголовок:
from tkinter import *
window = Tkf)
window.titlef 'Пример добавления изображения")
Затем создайте объект Image из размещенного
в той же папке файла*
img = Photoimage( file = )
Далее создайте объект Label, чтобы отобразить
изображение поверх цветного фона:
label = Labelf window , image = img , bg = )
Теперь создайте из первою объекта Image
уменьшенный в два раза объект Image:
smafljmg = PhotoImage.subsamplef img, x = 2, у = 2 )
Создайте кнопку, выводящую на экран
уменьшенное изображение:
btn = Buttonf window, image = smalljmg )
* Файл должен иметь имя python.gif, т.е. являться
изображением — Прим.ред.
Создайте текстовое поле и вставьте
уменьшенное изображение, а потом добавьте
после него текст:
txt = Text( window , width = 25 , height = 7 )
txt.image_create( , image = small, jmg )
txt.insert( in F )
Создайте объект Canvas и поместите
уменьшенное изображение поверх цветного
фона, затем нарисуйте диагональную черту
поверх него:
сап - \
Canvas( window , width = 100, height = 100, bg = )
can.create_image( ( 50,50 ), image = smalljmg )
can.ueate line( 0,0,100,100, width - 25, fill - )
Добавьте виджеты в окно:
label.pack( side = top )
btn.packf side = LEFT , padx = 10 )
txt.pack( side = LEFT )
can.packf side = LEFT, padx = 10 )
Обратите внимание,
что для объекта Text
существует метод image_
createf), а для объекта
Canvas — create_image().
Хоть имена методов
и похожи, но они разные.
Наконец, добавьте цикл, чтобы окно могло
улавливать события:
window.mainlo.<p()
Сохраните файл, затем запустите программу,
и вы увидите, как изображение появляется на
виджетах разного типа.
Виджеты Text и Canvas —
мощные и гибкие
инструменты. Больше
о них можно узнать
на странице https://docs.
python.org/3/library/tkinter.
html.
Создание интерфейсов
Краткие итоги
Модуль «tkinter» можно импортировать
в программу на Python, сделав доступными
его атрибуты и методы для создания оконных
приложений.
Каждая программа tkinter должна начинаться
с вызова конструктора Тк(), чтобы создать окно.
Также в ней должен быть метод mainloop!) для
захвата событий.
Заголовок объекта Window определяется в методе
title().
Для создания виджета Label нужно передать
в конструктор Label!) имя родительского
контейнера и его текст в качестве аргументов.
• Виджеты можно добавить в приложение
с помощью одного из методов управления
размещением: pack(), grid!) или place().
Для создания виджета кнопки нужно передать
как аргументы в конструктор Button!) имя
родительского контейнера, текст виджета и имя
функции, которая вызывается, когда пользователь
нажимает на кнопку.
• Модуль «tkinter.messagebox» можно импортировать
в программу на Python, сделав доступными его
атрибуты и методы для создания окон сообщений.
Окна сообщений, которые обращаются
к пользователю с предложением сделать какой-либо
выбор, возвращают значение в программу для
условного ветвления.
Конструктор Frame!) создает контейнер, в котором
для удобства размещения может храниться
несколько виджетов.
Конструктор Entry!) создает текстовое поле с одной
строкой. Текущее содержимое поля можно вернуть
с помощью метода get().
I Элементы добавляются в объект Listbox с помотцью
метода insert!). Их можно получить, передав индекс
элемент а в методе get().
♦ Объекты Radiobutton и Checkbutton хранят
значения в объекте StringVar или IntVar,
назначенном их атрибутом переменной variable.
Конструктор Photoimage создает объект Image,
у которого есть метод subsample(), уменьшающий
изображение.
Изображения можно добавить к объектам Button
и Label, встроить в объекты Text и нарисовать
на объектах Canvas.
Разработка
приложении
160
В этой главе
Генерация случайных чисел
показано, как,
162
Планирование потребностей
используя
164
элементы,
Разработка компоновки
виджетов
описанные
в предыдущих
166
Работа со статикой
главах,
разработать
167
Загрузка динамических данных
оконное
168
Добавление функционала
приложение.
170
Тестирование программ
172
Внедрение приложений
174
Краткие итоги
Разработка приложений
Числа с плавающей точкой
преобразуются из типа
float в тип int с помощью
встроенной функции int(),
отсекающей дробную
часть
С помощью функции
range() можно определить
начальное и конечное
значения. Если начальное
значение не указано, то
по умолчанию за него
принимается 0.
Генерация
случайных чисел
Графическое приложение, которое мы будем
разрабатывать в этой главе, генерирует шесть
случайных чисел в определенном диапазоне. Вначале
его функционал можно разработать как консольное
приложение, а потом перенести в оконное приложение,
чтобы показать, как он может применяться
на компонентах графических виджетов.
В стандартной библиотеке Python есть модуль
«random», предоставляющий методы для генерации
псевдослучайных чисел. По умолчанию в качестве
начального значения для генератора случайных чисел
используется текущее время операционной системы,
поэтому последовательность чисел при каждом запуске
программы не повторяется.
Псевдослучайные числа с плавающей точкой от 0,0
до 1,0 можно получить, вызвав метод random!) модуля
«random». Диапазон сгенерированных чисел можно
изменить, использовав оператор умножения *, чтобы
определить максимальное значение. Их можно
округлить до целых чисел с помощью встроенной
функции int(). Например, сгенерируем целое число
в диапазоне ог 0 до 9:
int(random.random!) * 10 )
Или целое число в диапазоне от 1 до 10:
int(random.randam() * 10 ) + 1
Это выражение можно использовать в цикле, чтобы
сгенерировать несколько случайных целых чисел
в определенном диапазоне, но числа в выходных
данных могут повторяться — никто не гарантирует
уникальность. Но несколько уникальных случайных
чисел в определенном диапазоне можно сгенерировать
с помощью метода sampled модуля random. Он
принимает два аргумента, определяющих диапазон
и количество уникальных целых чисел, которые
необходимо вернуть. Для того чтобы определить
максимальное значение, удобно пользоваться
встроенной функцией ranged. Например, сгенерируем
шесть уникальных чисел в диапазоне от 1 до 9:
random.sample! range( 1'J ), 6 )
Или шесть уникальных чисел в диапазоне от 1 до 10:
random.sample! range! 1» И ) < 6 )
С помощью этого метода .можно определить
выигрышные номера в лотерее, выбрав, скажем, шесть
уникальных чисел от 1 до 59.
Начните новую программу, импортировав две
функции из модуля random:
from random import random , sample
Затем присвойте переменной случайное число
с плавающей точкой и выведите на экран ее
значение:
sample ру
num = random!)
printf 'Случайное число с плавающей точкой 0.0-1.0 :', num )
Далее умножьте число с плавающей точкой
на 10 и преобразуйте его тип в целочисленное
значение, затем выведите число на экран:
num = int( num * 10 i
print! 'Случайное целое число 0-9 :', num )
Добавьте цикл, чтобы поместить несколько
случайных целых чисел в список, затем
выведите на экран элементы списка:
nums = [] ; I = 0
while i < 6 .
nums.append! 'nt( random!) * 10 ) + 1)
i += 1
print( 'Случайные целые числа 1-10 , nums )
Наконец, поместите несколько уникальных
случайных чисел в список и выведите на экран
элементы списка:
nums = sample! range! 1, 6С ), 6 )
print( 'Выборка случайных целых чисел 1-59 : ', nums )
Сохраните файл, затем запустите программу
несколько раз, и вы увидите сгенерированные
случайные числа.
161
File Edit Shell Cebug Options Window Help
======= RESTART: C:\MyCode\sampfe.py =======
Random Float 0 u-1.0 U.0U026439916178688794
Random Integei 0-9 0
Random Multiple Integers 1-10: [8.3.8, 2.6. 3]
Random Integer Sample 1-59 [1.42. 5. 21. 54.41]
======= RESTART: C:\MyCode\sample.py =======
Random Float 0.0-1.П: 0.5781C116390013073
Random Integei 0-9.5
Random Multiple Integers 1-10: [1,4,1,3,3.10]
Rand ?m Integer Sample 1 - 59. [51,11, 59, 55, 22, 4]
Функция random.sample!)
возвращает список, но на
самом деле не заменяет
элементы указанной
коллекции.
Разработка приложений
Чтобы управлять
действиями пользователя,
измените значение свой
ства состояния виджета
Button с НОРМАЛЬНОГО
на ОТКЛЮЧЕННОЕ В этом
случае приложение
должно быть сброшено,
прежде чем можно будет
сгенерировать следующий
ряд уникальных случайных
чисел.
Планирование
потребностей
Создавая новое графическое приложение, полезно
потратить некоторое время на планирование его
разработки. Четко определите цель существования
программы, решите, какой приложению необходим
функционал и какие виджеты потребуются для
пользовательского интерфейса.
План работы над простым приложением, выбирающим
числа в лотерее, может выглядеть следующим образом
Цель программы
• Программа будет генерировать серии из шести
случайных уникальных чисел в диапазоне 1-59
и иметь возможность перезагрузки.
Требуемый функционал
• Функция, генерирующая и выводящая на экран
шесть уникальных случайных чисел.
• Функция, убирающая с экрана шесть последних
случайных чисел.
Необходимые виджеты
• Одно окно с неизменяемым размером, хранящее
все остальные виджеты и выводящее на экран
заголовок приложения.
• Один виджет типа Label, чтобы выводить на экран
статический логотип приложения — просто для
того, чтобы сделать внешний вид приложения
более привлекательным.
• Шесть виджетов типа Label, чтобы динамически
отображать сгенерированные ряды уникальных
случайных чисел — но одному числу на каждый
виджет.
• Один виджет типа Button, чтобы генерировать
числа и выводить их на виджеты Label при нажатии
кнопки. Эта кнопка не будет работать, когда числа
выведены на экран.
• Один виджет типа Button для очистки виджетов
Label при нажатии кнопки. Эта кнопка не будет
работать, когда на экране нет чисел.
Создав план работы, вы можете приступать
к разработке основы приложения, создавая
необходимые виджеты.
о
о
о
Начните новую программу, импортировав
модуль tkinter:
а Виджеты
from tkinter import *
Затем добавьте инструкции для создания
объекта Window и объекта Image'* :
window = Tk()
img = Photolmage( file = )
Далее добавьте инструкции для создания всех
необходимых виджетов:
imgLbl = Label( window, image = img )
labell = Label( window, relief = , width = 2 )
Iabel2 = Label! window, relief = . width = 2 )
labels = Label! window, relief = , width = 2 )
Iabel4 = Label( window, relief = , width = 2 )
Iabel5 = Label! window, relief = , width = 2 )
labels = Labei( window, relief = , width = 2 )
getBtn = Button! window )
resBtn = Button! window )
Добавьте виджеты в окно с помощью диспетчера
компоновки grid. В него можно передать
аргументы, определяющие, как именно виджеты
будут располагаться в приложении, о чем мы
поговорим на следующей странице:
# Геометрия:
imgLbl.grid()
labell.grid()
Iabel2.grid()
labels.grid()
Iabel4.grid()
labels.grid!)
labelb.grid()
getBtn.grid()
resBtn.grid!)
Наконец, добавьте цикл, чтобы окно могло
улавливать события:
# Обеспечение работы окна:
window.mainloop!)
Сохраните файл, затем запустите программу,
и вы увидите, что окно содержит все
необходимые виджеты.
lotto(widgets).py
lotto.gif
Свойство relief определяет
стиль границы, а свойство
width — ширину объекта
Label в символах.
163
* Заранее создайте изображение с именем lotto gif и разместите
в папку с файлом программы. — Прим, ред
Разработка приложений
Разработка
компоновки виджетов
Создав все необходимые виджеты, как было показано
на странице 163, можно приступить к разработке
компоновки интерфейса, добавив аргументы,
определяющие расположение виджетов. По горизонтали
слева мы разместим логотип, справа поместим в ряд
шесть чисел, а внизу будут находиться кнопки.
Диспетчер компоновки grid, располагающий виджеты
в ряды и колонки, с легкостью решит эту задачу,
«растянув» логотип так, чтобы он занимал и ряд
со всеми шестью числами, и ряд с двумя кнопками.
Одна кнопка может занимать четыре колонки,
а другая — две. Дизайн приложения может выглядеть
примерно так:
Свойства rowspan
и columnspace диспетчера
компоновки grid работают,
как атрибуты ячейки
таблицы rowspan и colspan
в НТМ1,
lotto(layout) ру
Отредактируйте программу, которую мы начали
на странице 163. Во-первых, поместите логотип
в первую колонку первого ряда и растяните его
на второй ряд:
# Геометрия:
imgLbl.grid( row = 1, column = 1, rowspan = 2 )
Затем поместите объект Label во вторую колонку
первого ряда и растяните на 10 пикселей вправо
и влево:
labell.grid( row = 1, column = 2, padx = 10 J
Далее поместите объект Label в третью колонку
первого ряда и растяните на 10 пикселей вправо
и влево:
Iabel2.grid( row = 1, column = 3, padx = 10 )
Поместите объект Label в четвертую колонку
первого ряда и растяните на 10 пикселей вправо
и влево:
Iabel3.grid( row ~ 1, column = 4, padx = 10 )
О
Поместите объект Label в пятую колонку
первого ряда и растяните на 10 пикселей вправо
и влево:
Iabel4.grid( row = 1, column = 5, padx = 10 )
Поместите объект Label в шестую колонку
первого ряда и растяните на 10 пикселей вправо
и влево:
Iabel5.grid( row = 1, column = 6, padx = 10 )
Поместите объект Label в седьмую колонку
первого ряда и растяните на 10 пикселей влево
и на 20 пикселей вправо:
Iabei6.gn’d( row = 1, column = 7, padx = ( 10, 20 ))
Поместите кнопку во второй колонке второго
ряда и растяните ее на четыре колонки:
getBtn.grid( row = 2, column = 2, columnspan = 4 )
Поместите кнопку в шестой колонке второго
ряда и растяните ее на две колонки:
resBtn.grid( row = 2, column = 6, columnspan = 2 )
Сохраните файл, затем запустите программу,
и вы увидите, что окно содержит все
необходимые виджеты, расположенные
в соответствии с разработанной компоновкой.
Размер окна подстраивается автоматически так, чтобы
соответствовать содержимому ячеек. Виджеты кнопок
автоматически центрируются в соответствии с шириной
растянутой колонки.
Дополнительное
расширение справа
последней колонки после
добавления последнего
объекта в первый ряд
увеличивает ширину
окна так, чтобы справа
появилось небольшое поле
Кнопки будут расширены
для того, чтобы на них
поместился статический
текст Об этом мы
поговорим на следующем
этапе.
165
Разработка приложений
Работа со статикой
Разместив все необходимые виджеты в ячейки сетки,
как показано на страницах 164-165, вы можете
присвоить им статические значения.
Статические значения, такие как заголовок окна или
текстовые надписи на кнопках, которые будет нажимать
пользователь, не меняются во время выполнения
программы.
СО
СО
lotto(static).py
Отредактируйте программу, которую мы
начали на странице 165, добавив новый раздел
перед последним циклом. Секция начинается
с инструкции, определяющей заголовок окна:
# Свойства статики1
window.title( )
Затем добавьте инструкцию, не позволяющую
пользователю изменять размеры окна ни по
оси X, ни по оси Y. Она отключит кнопку окна
«resize»:
window.resizable( 0, 0 )
Далее добавьте инструкцию, выводящую текст,
который появится на первом виджете кнопки:
getBtn.configure( text = 'Ge )
Добавьте инструкцию, выводящую текст,
который появится на втором виджете кнопки:
resBtn.configure( text = )
Сохраните файл, затем запустите программу,
и вы увидите, что у окна появился заголовок,
кнопка изменения размера окна отключена,
а размер кнопок изменился соответственно
тексту на них.
Метод виджетов configured
позволяет последовательно
добавлять или изменять
свойства после того, как
они были созданы.
Загрузка
динамических данных
Определив значение статических свойств, как было
показано на предыдущей странице, теперь определим
начальные значения для тех свойств, чьи значения
будут меняться динамически во время выполнения
программы.
О
Отредактируйте программу с предыдущей
страницы, добавив новый раздел перед
последним циклом. Там будут определяться
все маленькие пустые объекты Label, которые
вначале будут выводиться как многоточия:
И Начальные значения:
labell.configure! text = )
Iabel2.configure! text = )
labels.configure! text = )
Iabel4.configure! text = )
labels.configure! text = )
labels.configure! text = )
О
Iotto(initial).py
Затем добавьте инструкцию, указывающую,
что в начале работы программы виджет второй
кнопки отключен:
resBtn.configure( state = DISABLED )
(.охраните файл, затем запустите программу,
и вы увидите, что в каждом маленьком
окошке с объектом Label теперь отображаются
многоточия.
167
Состояние кнопок
определяется с помощью
констант модуля tkinter
DISABLED (отключена),
NORMAL (включена)
и ACTIVE (нажата).
Также обратите внимание на то, что
кнопка Reset отключена.
Разработка приложений
Добавление
функционала
Создав код, чтобы инициализировать динамические
свойства, как показано на странице 167, теперь вы
можете добавить исполняемый код, реагирующий
на нажатие виджетов кнопок во время выполнения
программы.
Этот код обеспечивает
функционал, сопоставимый
с функционалом
консольного приложения
со с. 359
Отредактируйте программу, которую мы
написали на странице 167, добавив еще один
новый раздел перед последним циклом. Секция
начинается с инструкции, определяющей
заголовок окна:
# Динамические свойства:
from random import sample
Затем объявите функцию, генерирующую
уникальные случайные числа, привязывающую
их к шести маленьким окошкам Label
и меняющую состояние кнопок:
def pick}) :
nums = sample} range} 1, 60 ), 6 )
labell.configure} text = numsfOj )
Iabel2.configure( text = numsfl] )
labels.configure} text = nums[2] )
labels,configure} text = nums[3])
labels.configure} text = nums|4J )
Iabel6configure( text = nums[5] )
getBtn.configure} state = DISABLED )
resBtn.configure} state = NORMAL }
Далее объявите функцию, выводящую
многоточия в шести маленьких окошках
и возвращающую обе кнопки в первоначальное
состояние:
def reset}) :
labell.configure} text = )
Iabel2.configure} text = )
labels.configure} text = )
labeM.configure} text = )
labels.configure} text = )
Iabel6.configure} text = )
getBtn.configure} state = NORMAL )
resBtn.configure} state = DISABLED )
Добавьте инструкции, привязывающие
соответствующие функции к виджетам так,
чтобы они вызывались, когда пользователь
нажимает кнопку:
getBtn.contigure( command = pick )
resBtn.configure} command = reset)
Сохраните файл. Программа должна выглядеть
так, как показано на следующей странице.
I otto, ру - C:\MyCode\lQtto.py (3.10 Л) — □ X
File Edit Format Run Options Window Help
«Widgets-
from tkintei mport •
window = Гк()
Img = Photolmagel file = )
ImgLbl = Labell window, image = img )
labell = Labell window, relief = width = 2)
label2 - Labell window, relief - . width = 2)
Iabei3 = Labei( window, relief = . width = 2 ]
Iabei4 = Labell window, relief = , width = 2}
labels = Labell window leiief = . width = 2)
labeio = Labell window relief = width = 2)
getBtn Button) window)
resBtn = rjuttonl window)
# Geometry.
imgLbl.gndl row = 1 column - 1. rowspan = 2)
labellgrldl row = 1 column = 2. padx = 10)
Iabel2.g rld( row = 1, column = 3, padx = Ю)
Iabel3.grld( row = 1. column = 4. padx = Ю J
Iabel4.grid( row - 1, column = 5. padx - If )
labels gridl row = 1. column = 6. padx = 10 J
labeld.gridf row = 1. column = 7 padx = (10 20))
getBtn.gndl row - 2, column = 2, coumnspan - 4)
resBtn.gridl row = 2. column = 6. columnspan = 2)
# Static Properties:
winaow.titlel )
window.resizable! 0.0 !
getBtn.conflgurel text = 'Get My Lucky Numbers')
resBtn.configurel text = )
# Initial Properties:
labellconfigurel text = )
Iabel2.cor>figuret text = J
Iabel3 .con figure! text = )
iabei4.conflgure(text= )
iabel5.contlgurei text = .
iabel6.configure( text = )
resBtn.configurel state = DISABLED J
# Dynamic Properties:
froni random import sample
del pick();
nums = samplel i angel 1.601.6 J
labell configure! text = nums|0] J
Iabel2.configure( text = nums[1])
Iabel3.contigure! text = numsl2])
iabel4.configurel text = nums[3] J
labelS.configurel text = nums[4];
label6.configure(text = numsL5] )
getBtn.conflgurel state = DiSABl ED)
resBtn.configurel state = NORMAL )
def ieset():
laoeilconrigurel text - ]
iabel2.configure( text = j
iaoel3 conflgurei text = )
iabel4.configurel text = j
labelS.configurel text - )
labels .configurel text- j
getBtn.conflgurel state = NORMAL )
resBtn.configurel state = DISABcED ’
getBtn.conflgurel command = pick )
resBtn.contigurel command = reset)
# Sustain window:
window.niainioop()|
169
Все команды импорта
принято размещать
а начале скрипта, но они
могут находиться в любом
месте программы, как вы
можете видеть в данном
коде
Ln: 69 Cob 19
Разработка приложений
Тестирование
программ
На предыдущих страницах мы прошли по всем этапам
разработки программы. У нас в приложении есть все
необходимые виджеты и функции. Теперь мы готовы к
его тестированию.
, । Запустите приложение и проверьте, как оно
выглядит в начале работы программы.
Статический текст появляется в заголовке окна и на
виджетах кнопок, кнопка изменения размера окна
отключена, в маленьких окнах с объектами Label
отображаются начальные текстовые значения в виде
многоточий, кнопка Reset отключена..
Далее нажмите виджет кнопки «Get Му Lucky
Numbers», чтобы выполнить все инструкции из
функции pick()
Числа ни в одном ряду не
повторяются, потому что
Функция модуля random
sample() возвращает
последовательность
уникальных случайных
В приложении отображается ряд чисел в желаемом
диапазоне, состояние кнопок изменилось, как это
и требовалось, новые ряды чисел нельзя сгенерировать,
пока приложение не будет перезагружено.
О
Запишите числа, сгенерированные в первой
серии, для того чтобы сравнить их позднее.
целых чисел.
о
Нажмите виджет кнопки Reset, чтобы
выполнить все инструкции из функции reset(),
и вы увидите, что приложение вернулось
в первоначальное состояние, как мы этого
и хотели.
Lotto Number Picker
X
lotto
Numbers
Reset |
о
Снова нажмите виджет кнопки «Get Му Lucky
Numbers», чтобы выполнить все инструкции из
функции pick(), и убедитесь, что новый ряд чисел
отличается от предыдущего.
f Lotto Number Picker
7
4S
12
56
lotto
Get Му Lucky Numbers |
Reset ,
171
о
Наконец, перезапустите приложение и нажмите
виджет кнопки «Get Му Lucky Numbers» еще
раз. Убедитесь, что этот ряд чисел отличается от
тех, которые мы видели при прошлом запуске
приложения.
lotto Number Picker
б
29
9
54
4
31
lotto
Get Му Lucky Numbers |
Reset |
Ряды сгенерированных
чисел не повторяются при
перезапуске приложения,
потому что генератор
случайных чисел
использует в качестве
опорного значения текущее
время системы, которое
оказывается разным при
каждом вызове генератора.
Разработка приложений
Внедрение приложений
Приложения, разработанные на языке
программирования Python, можно «заморозить» для
использования в операционных системах Windows,
Linux и Мас с помощью инструмента «Pylnstaller»,
создающего один автономный исполняемый файл. Этот
файл не включен в поставку Python по умолчанию, но
может быть добавлен в систему с помощью менеджера
пакетов pip.
Установите подключение к интернету и нажмите
клавиши WinKey + R, затем введите cmd, чтобы
открыть окно Командной строки. Теперь введите
команду, чтобы установить Pylnstaller: python -m
pip install pyinstaller
Для приложений, куда внедряются дополнительные
файлы, например файлы с изображениями, требуется
особый файл со скриптом, чтобы инструмент Pylnstaller
правильно размещал эти файлы по их абсолютному
адресу.
lucky.py
Откройте файл с программой lotto.py и добавьте
эту служебную функцию в самом начале скрипта:
def resource_path(relative_path):
absolutepath = os.path.abspath(_file____)
root_path = os.path.dirname|absolute_path)
base_path = getattr(sys, '_MEIPASS‘, root_path)
return os.path.join(base_path, relative_path)
Атрибут file начинается
и заканчивается ДВУМЯ
нижними подчеркиваниями
Измените присваивание переменной img: укажите
расположение файла с изображением, используя
добавленную выше служебную функцию:
img = Photoimageffile = resource_pathClotto.gif1))
Сохраните измененный файл как lucky.py
в папке MyCode, затем откройте Командную
строку в этой папке.
Начните команду с pyinstaller —onefile
—noconsole, дав Pylnstaller команду создать
один файл и запретить открытие программы
в консоли.
О
Продолжите команду:—addbinary lorto.gif. Это
позволит включить файл с изображением
в единый исполняемый файл.
Закончите команду именем скрипта lucky.py.
Теперь команда выглядит так, как показано на
следующем скриншоте.
с 1 Command Prompt □ X
c:\Mycode>pyinstaller --onefile --noconsole —add-binary lotto.gif;. lucky.py
Проверив, что команда введена правильно,
нажмите клавишу ввода, чтобы создать
изолированный исполняемый файл
с расширением.ехе.
Объекты, следующие за
аргументом --add-binary,
определяют имя файла
(lento gif) и желаемое
направление (. для
текущей директории). Они
разделяются символом
точки с запятой ; В Unix-
подсбных системах следует
использовать в качестве
разделителя символ
двоеточия ..
Pylnstaller создаст внутри каталога MyCode
две папки с названиями «build» и «dist».
Изолированный исполняемый файл lucky.exe
будет находиться в папке «dist».
Исполняемый файл можно передать другим
пользователям, на чьих компьютерах может
быть не установлен Python. Приложение можно
запустит ь из командной строки или двойным
кликом по иконке файла.
173
' Command Prompt
C:\MyCodexd dist
C: \MyCode\di st>di г
X
volume in drive C is #indo*rs-SSO
Velum Serial Muaber is 4C84-3C8E
От rectory of C:\MyCodv\dist
M/18/2022
04/18/2022
M/18/2022
02:01 PH
02:04 ₽H
02:01 PH
1 Filets)
2 Oir(s)
<OIR>
<DIR>
9.915,023 lucky.exe
9.915.023 bytes
425,888,075,776 bytes fr
X
Lotto Number Picker
Й й 2 ® И ®
С: \MyCode\di»t>lucky
Pylnstaller собирает
все файлы, которые
нужны для выполнения
скрипта (в том числе
и интерпретатор Python),
в один исполняемый
файл. Это означает, что
их зависимости могут
быть самыми разными.
Больше информации
об этом можно
найти ь руководстве
по использованию
Pylnstaller на pylnstaller.
readthedocs.k-
Разработка приложений
Краткие итоги
• В стандартной библиотеке Python есть модуль
«random», содержащий функции для генерации
псевдослучайных чисел.
• Псевдослучайные числа с плавающей точкой от 0.0
до 1.0 можно сгенерировагь с помощью функции
random!) модуля «random».
• Несколько уникальных случайных целых чисел
в указанном диапазоне можно сгенерировать
с помощью функции sample!) модуля «random».
• План работы над программой должен включать
цель программы, требуемый функционал
и необходимые виджеты пользовательского
интерфейса.
• При разработке интерфейса программы диспетчер
компоновки grid() размещает виджеты в рядах
и колонках.
• Статические свойства не меняются во время
выполнения программы.
• Динамические свойства меняются во время
выполнения программы, используя функции, чтобы
реагировать на действия пользователя.
• После завершения работы программу нужно
протестировать, чтобы убедиться: она работает
именно так, как ожидалось.
• Файлы программы можно «заморозить» для
распространения на других компьютерах, где
интерпретатор Python не установлен.
• Инструмент Pylnstaller может создавать
изолированное исполняемое приложение,
но по умолчанию не включен в пакет установки
Python.
• Для того чтобы установить Pylnstaller, можно
использовать менеджер управления пакетами pip.
• Для создания приложений, которым для работы
необходимы дополнительные файлы, например
файлы с изображениями, нужно модифицировать
скрипт, чтобы инструмент Pylnstaller мог находить
эти файлы по их абсолютному адресу.
• Команда инструмента Pylnstaller создает папки
«build» и «dist» и помещает исполняемый файл
в папку «dist».
Расширяя
навыки
176
В этой главе
показаны 178
Что такое компиляторы
Компиляция кода
сходства
180
и различия
в написании
182
Код на С
Код на C++
программ
на различных
популярных
языках
программирования.
184
186
188
Код на C#
Код на Java
Краткие итоги
Расширяя навыки
Часто языки
программирования,
где используется
интерпретатор, называют
интерпретируемыми, а те
языки, где применяется
компилятор, —
компилируемыми
Что такое компиляторы
Современные приложения пишутся на высокоуровневых
языках программирования, что означает высокий
уровень абстракции между машинным кодом, который
воспринимают компьютеры, и понятным человеку
исходным кодом. Для того чтобы запустить программу,
исходный код должен быть превращен в машинный код,
который компьютер может выполнить. Этот процесс
осуществляется интерпретатором или компилятором —
в зависимости ог того, на каком языке написана
программа.
Язык программирования Python, который
использовался в примерах из предыдущих глав этой
книги, использует интерпретатор для трансформации
исходного кода программы. По мере выполнения
программы интерпретатор динамически переводит ее
функции и команды в байт-код. Далее байт-код может
быть выполнен с помощью интерпретатора байт-кода,
который также называют виртуальной машиной (ВМ).
Другие языки программирования, где для перевода
исходного кода в байт-код для исполнения виртуальной
машиной используется интерпретатор, — это,
к примеру, Java и Ruby.
Исходный
код
Байт-код
Отметим, что для того,
чтобы программы,
написанные нэ
интерпретируемых
языках, выполнялись, на
компьютере пользователя
должна быть установлена
виотуальная машина
В традиционных языках программирования, таких как
С, для преобразования исходного кода в машинный
используется компилятор. Во время компиляции
рассматривается весь исходный код целиком. Вначале
компилятор создает промежуточный «объектный код»,
представляющий функции и команды программы
в формате двоичного машинного кода. Затем
компилятор упаковывает байт-код в единый бинарный
файл машинного кода (.ехе), который может быть
исполнен компьютером.
Среди языков программирования, где для перевода
исходного кода в машинный код для непосредственного
исполнения компьютером используется компилятор,
прежде всего следует отметить C++ и С#.
Из этой разницы и возникают фундаментальные
отличия в гом, как выполняются на компьютере
программы, написанные на интерпретируемых языках,
таких как Python, и на компилируемых, таких как С.
У тех и других есть свои преимущества и недостатки
в плане производительности и переносимости, что
показано в следующей таблице:
Интерпретатор Компилятор
Принимает на вход отдельный Принимает на вход весь
обвею кода и щанслирует исходный ко/i, и преобразует
(перевидит) его в машинный
код
Не создает промежуточный Создает промежуточный
объектный код объектный код
Медленно выполняет инструкции управления потоками Быстро выполняет инструкции управления потоками
Требуем мало памя!и, Требует больше памяти.
поскольку объектный код поскольку создает объектный
не создается код
Переводит исходный код в Преобразует исходный
машинный каждый раз, когда код один раз во время
запускается программа компиляции
Сообщает об ошибках сразу же, как только обнаруживает их в инструкциях Сообщает об ошибках только после попытки скомпилировать весь исходный код
Программы запускаются Программы запускаются
медленнее, поскольку быстрее, поскольку
объекты кода переводятся машинный код запускается
в машинный код по непосредственно на
отдельности компьютере
Распределенные программы Распределенные программы
имеют исходный код, который скомпилированы в машинный
может прочитать человек, код, поэтому их трудно
поэтому его легко изменить изменить
Ниже степень защиты Выше степень защиты
права на интеллектуальную права на интеллектуальную
собственность собственность
Пусть поогоаммы
на Java не вводят вас
в заблуждение Они
«компилируются» в байт-
код как распростоаняемый
файл (.class), которому
для запуска требуется
интерпретатор байт кода —
виртуальная машина Java.
Расширяя навыки
Компиляция кода
Исходный код(.с)
Включения (J)
ч
Ассемблерный код (.s)
У
Объектный код (.о)
Исполняемый файл (.ехе)
Чтобы лучше понять процесс компиляции, полезно
рассмотреть ее подробно на примере программы
на языке С. Превращая первоначальный файл
с исходным кодом на С в исполняемый файл, процесс
компиляции проходит через четыре этапа, на каждом
из которых создается новый файл:
• Предварительная обработка. На этом
этапе реализуются все директивы импорта
препроцессора, чтобы включить файлы,
объявляющие содержимое библиотек. Созданный
в результате файл содержит заданные включения,
имеет текстовый формат и — обычно —
расширение .1.
• Компиляция. Компилятор переводит
высокоуровневые инструкции из файла
с расширением л в низкоуровневые инструкции
на языке ассемблер. Созданный файл сохраняет
переведенный код в текстовом формате и обычно
имеет расширение .s.
• Ассемблирование. Ассемблерные текстовые
инструкции из файла с расширением .s
преобразуются в объектный (машинный)
код. Созданный файл хранит объектный
код в двоичном формате и обычно имеет
расширение .о
• Компоновка. На этом этапе компоновщик
добавляет код в ответ на директивы, чтобы
включить в сборку нужные библиотеки. Он
собирает один или несколько бинарных объектных
файлов с расширением о в единый исполняемый
файл. Создается файл в двоичном формате, обычно
имеющий расширение .ехе
Строго говоря, слово «компиляция» описывает три
первых стадии, где происходят операции с одним
текстовым файлом с исходным кодом и в итоге
создается один бинарный объектный файл. Если
в исходном коде программы содержатся синтаксические
ошибки, такие как отсутствующий ограничитель
оператора или отсутствующая скобка, компилятор
сообщит о них, и компиляция не завершится.
Компоновщик же может работать с несколькими
объектными файлами и в итоге собирает один
исполняемый файл. Это позволяет создавать большие
программы из организованных по модульному
принципу объектных файлов, каждый из которых
может содержать многократно используемые функции.
Если компоновщик найдет функцию с одним и тем же
именем, объявленную в разных объектных файлах,
он сообщит об ошибке и исполняемый файл не будет
создан.
Обычно временные файды, которые создаются
на промежуточных этапах процесса компиляции,
автоматически удаляются, но компилятор языка
С GNU (GNU Compiler Collection, GCC) предоставляет
опцию -save-temps в команде компилятора. Таким
образом, временные файлы можно сохранить и изучить.
Для того чтобы скомпилировать простую
программу «Hello World!» на языке
программирования С, наберите команду gcc
hello.c -save-temps -о hello.exe, затем нажмите
клавишу ввода, чтобы запустить процесс
компиляции и сохранить временные файлы.
О
о
Компилятор
GNU C (GCC) — один
из самых популярных
и широко используемых
компиляторов. Он
бесплатно доступен как
часть пакета Minimalist
GNU для Windows
(MinGW) на sourceforge,
net/projects/mingw.
Инструкции по установке
и другую информацию
см. в документации'
mingw.org/wiki.
Откройте файл hello.i в текстовом редакторе
(например, в «Блокноте» в Windows), и вы
увидите, что исходный код появляется
в самом конце файла. Перед ним находится
подставленный библиотечный код.
Теперь откройте в текстовом редакторе
файл hello.s, и вы увидите, как исходный
код переводится в низкоуровневый код на
ассемблере. Заметьте, насколько непонятно
выглядит этот код по сравнению с языками
высокого уровня.
179
ЬеМол - Notepad —ОХ
File Edit View ®
LCO:
.ascii "Mello worldI\0”
.text
.globl «main
.def «main; .scl 2; . type 32; .endef
«main:
LFB13:
.cfi_startproc
pushl %ebp
.cfi_def_cfa_offset 8
.cfi_offset 5» -8
movl %esp, Xebp
.cfi_def_cfa_register 5
and! $-16, Xesp
subl $16, Xesp
call ____main
movl $LCO, (Xesp)
call «puts
movl $0, Xeax
leave
.cfi«restore 5
.cfi_def_cfa 4, 4
ret
.cfi«endproc
Полнь1Й пример того, как
написать и скомпилировать
программу на С находится
на с. 178-179
Расширяя навыки
guess.с
Эта программа на С
принимает числа
с плавающей точкой,
поскольку их значения
усекаются до целого
числа в выражении,
объявляющем переменную
guess.
Код на С
Программные структуры данных и структуры
управления, которые описывались и демонстрировались
в этой книге на примере языка программирования
Python, также существуют и в других языках. Если вы
научитесь находить сходство, то навыки, приобретенные
в программировании на Python, можно перенести
и в разработку кода на других языках, таких как С. Язык
программирования С появился еще в 1970-е годы. Он
был разработан так, чтобы легко компилироваться
в низкоуровневый машинный код. Его эффективность
заставляет применять этот язык в самых разных
приложениях, от встраиваемых до операционных
систем.
Простую программу с игрой в угадайку, которую
мы написали на Python на страницах 32-33, можно
воссоздать на языке С.
Начните новую программу на С, импортировав
библиотеки, сделав доступными функции для
ввода и вывода данных, генерации случайного
числа и времени:
rtindude <stdio.h>
^include <stdlib.h>
ttindude <time.h>
Затем объявите тело функции main, которая
будет включать весь код игры и возвращать 0 по
завершении работы:
int main()
{
/* Здесь будут добавлены инструкции */
return 0;
}
Далее добавьте выражения, чтобы присвоить
переменным случайное число в диапазоне от 0
до 20, булево значение true и целое число:
srandf time) NULL ) ) ;
nt num = ( rand() % 20 ) + 1;
int flag = 1;
int guess = 0 ;
Добавьте инструкции, запрашивающие
пользовательский ввод:
printf( ) ;
Теперь добавьте цикл, который будет читать
введенные пользователем данные как целое
число и проводить проверку условия:
while ( flag == 1)
{
scanf( , &guess ); fflushf stdin );
/* Здесь будет добавлена проверка условия */
}
Наконец, добавьте внутрь цикла проверку
условия, затем сохраните, скомпилируйте
и запустите программу:
if ( guess == 0 )
{
printf( "Ошибка! Введите только числа от 1 до 20\п" );
break ;
}
else if ( guess < num ) printf( "Слишком мало, попробуйте еще раз : " );
else if ( guess > num ) printf( "Слишком много, попробуйте еще раз : " )
else
{
printff "Правильно, мое число %d \n" , num );
flag = 0 ;
}
181
Игра-угадайка на С — сравнение программ
• В программах на С библиотечные функции
делаются доступными с помощью директивы
tfinclude, что похоже на использование ключевого
слова Python import.
• В программах на С всегда есть функция main(),
которая вызывается автоматически при каждом
запуске программы.
• Инструкции в программах на С группируются
внутри фигурных скобок {}.
• С не является языком программирования со слабой
типизацией, поэтому типы данных, такие как int
(integer), должны быть определены при объявлении
переменных.
• В конце каждой инструкции в С ставится символ
точки с запятой ;. Отступы и табуляции не имеют
значения.
• В структурах управления программ на С
используются ключевые слова if, else и while,
аналогично программам на Python.
Узнать больше
о программировании
на С вы можете из книги
«Программирование на С
для начинающих»
Расширяя навыки
Код на C++
Программные структуры данных и структуры
управления, которые описывались
и демонстрировались в этой книге на примере
языка программирования Python, также
существуют и в языке программирования C++.
Если вы научитесь находить сходство, то навыки,
приобретенные в программировании на Python,
можно перенести и в разработку кода на C++. Этот
язык программирования появился в 1980 х годах. Его
целью было расширить возможности языка С, и он
получил извест ность как «С с классами». Эти классы
определяют объекты, что превращает процедурное
программирование на С в объектно-ориентированное
программирование на C++.
guess.срр
Простую программу с игрой в угадайку, которую
мы написали на Python на страницах 32-33, можно
воссоздать на языке C++.
Эта программа на C++
принимает числа
с плавающей точкой,
поскольку их значения
усекаются до целого
числа в выражении,
объявляющем переменную
guess.
О
о
о
о
о
Начните новую программу на C+ + ,
импортировав библиотеки, сделав доступными
функции для ввода и вывода данных, генерации
случайного числа и времени:
ffinclude <iostream>
ffindude <cstdlib>
^include <ctime>
Затем объявите тело функции main, которая
будет включать весь код игры и возвращать 0 по
завершении работы:
int main()
{
/* Здесь будут добавлены инструкции */
return 0;
}
Далее добавьте выражения, чтобы присвоить
переменным случайное число в диапазоне от 0
до 20, булево значение true и целое число:
srand( time( 0 ));
int num = ( randf) % 20 ) + 1;
bool flag = true ;
int guess = 0 ;
Добавьте инструкции, запрашивающие
пользовательский ввод:
stducout« ;
Теперь добавьте цикл, который будет читать
введенные пользователем данные как целое
число и проводить проверку условия:
while (flag)
{
stdr.cin » guess ; std-:cin.ignore( 256 , '\n' );
/* Здесь будет добавлена проверка условия */
}
Наконец, добавьте внутрь цикла проверку
условия, затем сохраните, скомпилируйте и запустите программу:
if ( guess == 0 ) {
std::cout « "Ошибка! Введите только числа от 1 до 20\п" ;
break ;
}
Flse if ( guess < num ) {
std::cout« Слишком мало, попробуйте еще раз : ; }
else if ( guess > num ) {
std::cout« Слишком много, о еще раз : " ; }
else {
std::cout« «num« ;
flag = 0 ;
}
Пакет Min'malist GNU для
Windows (MinGW), который
можно найти на Sourceforge.
net/projects/mingw, может
предоставлять компилятор
для кода на C++.
На приведенном скриншоте
вызывается компилятор
языка C++ для сборки файла
с исходным кодом guess.
срр, а строка-о guessplus.exe
определяет исполняемый
файл на выходе
Guessing Game in C++ - program comparison
• В программах на C++ библиотечные функции
делаются доступными с помощью директивы
ttinclude, что похоже на использование ключевого
слова Python import.
• В программах на C++ всегда есть функция main(),
которая вызывается авт оматически при каждом
запуске программы.
• Инструкции в программах на C++ группируются
внутри фигурных скобок {}.
• C++ не является языком программирования со
слабой типизацией, поэтому типы данных, такие
как int (integer), должны быть определены при
объявлении переменных.
• В конце каждой инструкции в C++ ставится символ
точки с запятой ;. Отступы и табуляции не имеют
значения.
• В структурах управления программ на C++
используются ключевые слова if, else и while,
аналогично программам на Python.
183
Узнать больше
о программировании
на С+ч вы можете из книги
«Программирование на C++
для начинающих»
Расширяя навыки
Код на C#
guess.cs
Эта программа на C#
не принимает числа
с плавающей точкой,
поскольку функция
int.TryParse() распознает их
как числа, не являющиеся
целыми.
Программные структуры данных и структуры
управления, которые описывались и демонстрировались
в этой книге на примере языка программирования
Python, также существуют и в языке программирования
С#. Если вы научитесь находить сходство, то навыки,
приобретенные в программировании на Python,
можно перенести и в разработку кода на С#. Этот язык
программирования был разработан компанией Microsoft
как язык разработки приложений для платформы.NET
Framework и.NET Core. Для программ на C# необходимо
установить на компьютер общеязыковую исполняющую
среду (Common Language Runtime, CLR), производящую
машинный код во время работы программы. Этот
процесс называется динамической компиляцией (JIT-
компиляцией от англ, just in time — точно в нужное
время).
Простую программу с игрой в угадайку, которую
мы написали на Python на страницах 32-33, можно
воссоздать на языке С#..
О
о
о
о
о
Начните новую программу на С#, импортировав
пространство имен, чтобы сделать доступными
функции для ввода и вывода данных
и генерации случайного числа:
using System ;
Затем объявите структуру класса, который будет
включать весь код игры внутри функции Main:
class Guess
{
stati vc id Main( )
{
/* Здесь будут добавлены инструкции */
}
};
Далее добавьте выражения, чтобы присвоить
переменным случайное число в диапазоне от О
до 20, булево значение true и целое число:
Random generator = new Randomf );
int num = generator.Next( 1,20 + 1);
bool flag = true ;
int guess = 0 ,
Добавьте инструкции, запрашивающие
пользовательский ввод:
Console.Write( "Отгадай число от 1 до 20 : );
Теперь добавьте цикл, который будет читать
введенные пользователем данные как целое
число и проводить проверку условия:
while ( flag == true )
{
int.TryParse( Console.ReadLinef) , out guess ) ;
/* Здесь будет добавлена проверка условия */
}
Наконец, добавьте внутрь цикла проверку
условия, затем сохраните, скомпилируйте
и запустите программу:
if ( guess == 0 ) {
Console.Wrlte( "Ошибка! Введите только числа от 1 до 20\п" );
break ;
}
else if ( guess < num ) {
Console.Write( "Слишком мало, попробуйте еще раз : " ); }
else it ( guess > num ) {
Console.Writef Слишком много, попробуйте еще раз : 1 ); }
else {
Console.Writef "Правильно, мое число " + num + хп" );
flag = false ;
}
с- Command Prompt — D X
i:\MyCode^-csc /out:guesssharp.exe guess.cs |
: \MyCode>guesssharp
uessmy number 1-20 : ten
nval id! Enter only digits 1-20
:\MyCode>guesssharp
uess my number 1-20 : 10
oo low, try again : JS
oo high,try again : 14
oo low, try again : 17
orrect... Hy number is 17
:\HyCode>_
185
Игра-угадайка на C# — сравнение программ
• В программах на C# библиотечные функции
делаются доступными с помощью директивы using,
что похоже на использование в Python ключевого
слова import.
• В программах на C# всегда есть класс,
содержащий функцию Main(), которая вызывается
автоматически при каждом запуске программы.
• Инструкции в программах на C# группируются
внутри фигурных скобок {}.
• О не является языком программирования со
слабой типизацией, поэтому типы данных, такие
как bool (Boolean), должны быть определены нри
объявлении переменных.
• В конце каждой инструкции в C# ставится символ
точки с запятой ;. Отступы и табуляции не имеют
значения.
• В структурах управления программ на C#
используют ся ключевые слова if, else и while,
аналогично программам на Python.
*
Интегрированная среда
разработки Visual Studio
(Community Edition) —
отличная среда разработки
для программирования
на C# Она доступна
бесплатно на visuaistudio.
com и включает в себя
компилятор C# Compiler
(csc.exe). В приведенной
на скриншоте команде esc
вызывает компилятор, файл
с исходным кодом — guess,
cs, a /out: guesssharp.exe
определяет исполняемый
файл на выходе.
Узнать больше
о программировании
на C# Bbi можете из книги
«Программирование на C#
для начинающих»
Расширяя навыки
Код на Java
Guess.java
Программные структуры данных и структуры
управления, которые описывались и демонстрировались
в этой книге на примере языка программирования
Python, также существуют и в языке программирования
Java. Если вы научитесь находить сходство, то навыки,
приобретенные в программировании на Python,
можно перенести и в разработку кода на Java. Один
из основополагающих принципов Java, его лозунг —
«написано однажды, работает везде». Для программ
на Java необходимо установить на компьютер среду
выполнения Java (Java Runtime Environment, JRF.),
производящую машинный код во время работы
программы. Этот процесс называется динамической
компиляцией (JIT-компиляцией от англ, just in time —
точно в нужное время).
Простую программу с игрой в угадайку, которую
мы написали на Python на страницах 32-33, можно
воссоздать на языке Java.
Начните новую программу на Java, объявив
структуру класса, который будет включать весь
код игры внутри функции main:
class Guess
{
public static void main) String! ] args )
{
/* Здесь будут добавлены инструкции */
J
};
О
Далее добавьте выражения, чтобы присвоить
переменным случайное число в диапазоне от О
до 20, булево значение true и целое число:
int num = ( int) ( Math.randomf ) * 20 + 1 );
boolean flag = true ;
int guess = 0 ;
Эта программа на Java
не принимает числа
с плавающей точкой.,
поскольку функция
integer.parselntl )
распознает их как числа, не
являющиеся целыми.
О
о
Добавьте инструкции, запрашивающие
пользовательский ввод:
System.out.printf 'Отгадай число от 1 до 20 : 1 );
Теперь добавьте цикл, который будет читать
введенные пользователем данные как целое
число и проводить проверку условия:
while ( flag == true )
{
try {
guess = Integer.parselntf System.console().readLine()); }
catch ( Numberf-ormatException ex ) { }
/* Здесь будет добавлена проверка условия */
}
Наконец, добавьте внутри цикла проверку
условия, затем сохраните, скомпилируйте
и запустите программу:
if ( guess == 0 ) {
System.out.println( Ошибка! Введите только числа от 1 до 20" );
break ;
}
else if ( guess < num ) {
System.out.print( "Слишком мало, попрс еще раз : ); }
else it { guess > num ) {
System.out.print( "Слишком много, попро& еще раз : " ); }
else {
System.out.println( + num );
flag = false ;
}
Для создания программ
на Java необходим набор
инструментов разработки
Java Development Kit
(JDK). Он доступен
бесплатно на на oracle.
Игра-угадайка на Java — сравнение программ
• Функции для ввода и вывода данных и генерации
случайного числа уже доступны в программе на
Java без каких-либо имлортов.
• В программах на Java всегда есть структура класса,
включающая функцию mainj), которая вызывается
автоматически при каждом запуске программы.
• Инструкции в программах на Java группируются
внутри фигурных скобок JJ.
• Java не является языком программирования со
слабой типизацией, поэтому типы данных, такие
как bo>!( Boolean), должны быть определены при
объявлении переменных.
• В конце каждой инструкции в Java ставится символ
точки с запятой Отступы и табуляции не имеют
значения.
В структурах управления программ на Java
используются ключевые слова if, else и while,
аналогично программам на Python.
187
сот и включает в себя
работающий в командной
строке компилятор Jav ас
(javac.exe) На приведенном
скриншоте команда javac
вызывает компилятор,
для компиляиии файла
Guess.java с исходным
кодом, что автоматически
формирует исполняемый
файл Guess.exe на выходе.
Последний можно
запустить с помощью JRE,
использовав команду java.
Узнать больше
о программировании
на Java вы можете из
книги «Программирование
на Java для начинающих»
Краткие итоги
Расширяя навыки
• Современные языки программирования, такие как
Python и С, имеют высокий уровень абстракции
по сравнению с низкоуровневым машинным кодом.
• Понятный для человека высокоуровневый
исходный код может переводиться
в низкоуровневый машинный код с помощью
интерпретатора или компилятора.
• Интерпретируемые языки программирования,
такие как Python, транслируют исходный код
в байт-код, который затем может исполняться
с помощью их интерпретатора байт-кода —
виртуальной машины.
• Компилируемые языки программирования,
такие как С, создают промежуточный объектный
код, который преобразуется в машинный код,
исполняемый непосредственно компьютером.
• При компиляции программы на С
высокоуровневый исходный код преобразуется
в промежуточный код, а затем — в машинный код.
• Промежуточные файлы, создающиеся в процессе
компиляции, компилятор обычно удаляет
автоматически.
• Структуры данных и управляющие структуры,
используемые в Python, также существуют в языках
программирования С, C++, С» и Java, поэтому
навыки программирования можно применять при
работе с различными языками.
• Компилируемые языки программирования, такие
как С, имеют функцию main, которая вызывается
автоматически при запуске программы.
• Во многих языках программирования инструкции
группируются внутри фигурных скобок {}
и должны заканчиваться точкой с запятой;.
• В языках программирования со строгой
типизацией требуется при объявлении переменной
указывать тип данных, которые может содержать
переменная, например int для целочисленного
значения.
• Как и в Python, в других языках программирования
можно импортировать функции из других
библиотек.
• Для программ на C# необходимо установить
на компьютер общеязыковую исполняющую среду
(Common Language Runtime, CLR), производящую
машинный код во время работы программы.
• Для программ на Java необходимо установить
на компьютер среду выполнения Java (Java Runtime
Environment, IRE), производящую машинный код
во время работы программы.
Предметный указатель
builtins_, модуль 116
doc__. строка документации 114
jnit_(), метод инициализации 129
А
and, логический оператор as, ключевое слово 44 72
в
bool, тип данных 28
break, ключевое слово 70
build, папка 173
Button(), конструктор 144
С
Сй. язык программирования 184
С. язык пьограммиропания 180
С ++, язык программирования 182
Checkbutton(), конструктор 154
class, ключевое слово 128
continue, ключевое слово 71
create_image(), метод 156
D
darecime, модуль 108
Datenme, объект 108
geiattrO 108
strfrimeO 1G8
today(), функция 108
decimal модуль 107
Decimal, обоект 107
def, ключевое слово 76
del, ключевое слово 60
delattr(), функция 132
d:r(), функция 116, 120
dist, папка 173
IDLE (Python Integrated Development
Environment) 14
if, ключевое слово 64
image_create(), меюд 156
import, ключевое слово 82,84
in, оператор принадлежности 58
indexError 72
input(), функция 26, 30
int(), функция 160
int, тиг данных 28, 104
InrVarti, конструктор 152, 154
isdigitO, функция 80
J
Java, язык пьогоаммиоования 186
К
Keyword, модуль 102
iskeywordO, функция 102
kwnst, атрибут 102
L
Label(), конструктор 142
len(), Функция 54
Listbox(), конструктор 150
м
mainloopO, метод 142
math, модуль 104
ceil() 104
cosin() 104
floor 104
pow() 104
sin() 104
sqrt() 104
tan() 104
189
Е
N
elit, ключевое слово 64
else, ключевое слово 64
Entry(), конструктор 148
enumeraie(), функция 66
except, ключевое слово 72
F
File, объект 120
с lose)). функция 120, 122
closed, свойство 120
mode, свойство 120
пате свойство 120
ореп(). функция 120,122
read(). функция 120 122
readatne! ), функция 120
seek(), функция 124
tell(), функция 124
writable(), функция 120
wrire(), функция 120, 122
finally, ключевое слово 72
float(), функция 30
float, тип данных 28, 104
for, ключевое слово 66
for. ш, цикл 66
F-ame(), конструктор 148
from, ключевое слово 84
NameError 72
not in, оператор принадлежности 114
not, логический оператор 44
О
ореп(), функция 116
or, логический оператор 44
Р
Photolmage(), конструктор 15ь
pip, менеджер пакетов 172
print(), функция 14
end, параметр 2 7
sep, параметр 39
вывод нескольких значений 26
Pylnstaller, инструмент 172
Python, установка 12
R
Radiobutton(), конструктор 152
raise, ключевое слово 73
ranoorn, модуль 104
random!), функция 104,160
sample!), функция 102, 160
rangef), функция 66,104, 160
return, ключевое слово 80
geometry manager, методы 142
grid() 142,164
packj) 142
piace() 142
getattrf), функция 132
global, ключевое слово 76
hasad.rO, функция 132
S
self, аргумент 130
setattr(), функция 132
Shell, интерактивная оболочка 14
Shell, интерактивной оболочки
справочная система 16,102
soited{) функция 60
str(). функция 54
str, тип данных 28
Предметный указатель
String, объект 118
capitalize!) 118
center () 118
COuHt() 118
endswith() 118
find() 118
isalnumd 1?8
isalpha!) 118
isaeciiral() 118
isaigitO 118
islower() 118
isnumenc() 118
isspacef) 118
istitle() 118
tsupper() 118
joint) 118
IjustQ 118
lower;) 118
Istripf) 118
replace() 118
rjust() 118
rstripd 118
startswith() 118
strip!) 118
swapcase() 118
title!) 118
upper!) 118
StringVar(), конструктор 152, 154
Struct_tinie, объект HO
subsample(), метод 156
sys, модуль 102
nme, модуль 110
gmtime!) 110
ocaltimeQ НО
sleep!) 110
strftime!) НО
time!) 110
tkinter, модуль 142
Button!), конструктор 144
Checkbutton(), конструктор 154
tntry(). конструктор 148
Framed, конструктор 148
grid(), метод управления
размещением 142, 164
Label!), конструктор 142
Listbox!) конструктор 150
mainlocpd, метод 142
pack(), метод управления размещением 142
Photolmage()? конструктор 156
placet),метод управления размещением 142
Radiobuttonf), конструктор 152
titled, метод 142
Тк(), конструктор 142
tkinter.messagebox. модуль 146
try, ключевое слово 72
tyoe(). функция 28
U
Unicode
ValueError
1 W 1
while, ключевое слово with, ключевое слово 72 124
LZ
zip( 1, функция
Алгоритм 88
Аппаратное обеспечение 10
Аргумент 78
Арифметические операторе! 38
Арифметические операции Ассемблер, файлы с расширение Ассемблирование 106 м s 178 178
Б
Базовый класс 129, 134 140
байт код 176
Булевы значения True/False 20, 44, 64
Быстрая сортировка, алгоритм 98
в
Версия Python 102
Виджет 142
Виджет, метод cget() 144
configure!) 144
curselecnon() 150
get',; 148,150, 152, 154
insert!) select) Виртуальная машина (BM) Вложенные циклы Временные файлы Высокоуровневые языки 150 152 176 68, 70 179 11, 176
программирования
Г
Глобальные переменные Графический пользовательский 76
интерфейс (GUI) И, 142
L Д
Двоеючие Дебаг 34 64, 76, 128
Деление нацело, оператор// 38
Деление с остатком, оператор % 38
Деление, оператор / 38
Динамическая типизация 20
Динамические данные 167
Динамические свойства 167
3
Запись в файл 120
Запись иерез точку 128
Звездочка *, символ 84
И
Игра угадайка
С 180
Ctt 184
C++ 182
Java 186
Python 32
Интерпретатор Ингерпретируемые языки И, 176
программирования 177
Итерация 66
К
Кавычки 14
ключ, значение, пары Ключевые слова языка 60
программирования Python 16, 23
Код !0
Комментарии, символ # Компилируемые языки 22
программирования 177
Компилятор 11, 176
-save-temps, опция 179
преобразование кода 178
Компиляция, процесс 178
Компоновка интерфейса 164
Компоновщик 178
Конкатенация, оператор + 27, 30, 114
Консольная поограмма 11
Кортеж 58
Круглые скобки () 76
л
Локальные переменные 76
Логические операторы 44
м Ь J
Машинный код 11, 176
Многомерные списки 52
Множества, методы 58
add() 58
сору() 58
difference() 58
discard!) 58
intersection!) 58
рор() 58
update!) 58
Множество 58
Модуль Python 82. 1 ЗС
н
Низкоуровневый код 11
О
Область видимости 76
Обработка исключений 72
Объектно-ориентированное
про!раммирование (ООП) 11
инкапсуляция 128
наследование 134
полиморфизм 138
Обьектные файлы о 178
Объектный код 176
Объявление класса
атрибуты 128
методы 128
Окно сообщения 146
Оператор сложения, + 30, 38
Опорный элемент 98
Отступы 64, 76, 128
Ошибка времени выполнения программы 34
Ошибки, типы 34
п ь d
Переменная
область видимости 76
определение 20
переменная класса 128
правила именования 23
экземпляр класса 128
11еременная класса 128
Переменная экземпляра класса 128
Переопределение методов 136
Побитовый сдвиг 48
Повторение строк, оператор 114
Подстановка, оператор %ь 116
Пользовательский ввод 26
Поля замены {} 116
Правила именования 23
Препроцессор,, директивы 178
Приведение типов ЗС
Приложение 142, 160
внедрение 172
планирование потребностей 162
разработка 1.64
тестирование 170
функционал 168
Приоритет выполнения операторов 48
Присваивания, операторы 4С
Про'рамма, определение 10
Про-рамма, файл с расширением ,ру 18
Программное обеспечение 12
Производный (дочерний) класс 134
Р
«Разделяй и властвуй», стратегия 96, 98
Редактор кода 14
Рекурсивные вызовы функции 96, 98
С
Семантическая ошибка 34 Символ перевода строки \п 2 7 Синтаксическая ошибка 34 Словарь 60 items!), метод 66 keys(), метод 60 Сортировка вставками, алгоритм 92 Сортировка выбором, алгоритм 90 Сортировка на месте 90 Соргиэовкэ пузырьком, алгоритм 94 сортировка с копированием, алгоритм 88 Сортировка слиянием, алгоритм 96 Сохранение программ 18 Спецификаторе! режима 120 Список 52 СПИСОК, М' ТОДЫ append!) 54 count!) 54 extend!) 54 index!) 54 insert!) 54 pop!) 54 remove!) 54 reverse!) 54 sort() 54 Список, переменная 52 Справочная служба help(), команда 16 Сравнение оператор «больше чем» > 42 оператор «меньше чем» < 42 оператор больше или равно >= 42 оператор меньше или равно <= 42 оператор неравенства 1= 42 оператор равенства == 42 Среда разработки 14 Срез диапазона (:]. оператор 114 Срез строки оператор [ ] 114 Статическая типизация 20 Статические значения 166 Степень, оператор “ 38 Строка 14, 20, 114 Структуры данных 11 Структуры управления 11 Сырая строка, оператор ' /R 114
т
Таблица имен Таймер Тернарный оператор Типы данных 84 110 46 28
У
Умножение, оператор * Условное ветвление Условные выражения Установка Pytnon Утиная типизация 38 42, 64 46 12 138
Ф
Форматирование строк Функция аргументы 116 76 78
ц
Цикл 68
ч
Числа с плавающей точкой Члены класса Чтение файлов 104 128 120
э
130
52
Экземпляр объекта класса
элементы списка
191
Все правя защищены Книга или любая ее часть не может быть скопирована, воспроизведена в электронной или
механической форме в виде фотокопии, записи в память ЭВМ. репродукции или каким-либо иным способом,
а также использована в любой информационной системе без получения разрешения от издателя Копирование
воспроизведение и иное использование книги или ее части без согласия издателя является незаконным и влечет
уголовную, административную и гражданскую ответственность.
Производственно-практическое издание
ПРОГРАММИРОВАНИЕ ДЛЯ НАЧИНАЮЩИХ
МакГрат Майк
ПРОГРАММИРОВАНИЕ ДЛЯ НАЧИНАЮЩИХ
ОСНОВНЫЕ ПРИНЦИПЫ
Главный редактор Р. Фасхутдинов
Руководитель направления В Обручев
Продюсер A Отанеснн
Ответственный редактор Л Салихова
Научный редактор А Корягин
Литературный редактор Е. Сербина
Художественный редактор К. Доброслов
Компьютерная верстка Т Лукина
Корректоры Л Макарова. Е. Ерошкина
Страна происхождения: Российская Федерация
Шыгарушы ел Ресей Федерациясы
ООО «Издательство «Эксмо»
123308, Россия, г Москва, ул. Зорге, д. 1, стр. 1, эт. 20, каб. 2013. Тел.: 8 (496)411-68-86.
Home раде: www.eksmo.ru E-mail; mfo@eksmo.ru
вндоушс «Издательство «Эксмо» ЖШК,
123308, Ресей, Маскеу каласы. Зорге кешес!, 1-уй, 1-курылыс, 20 кабат. 2013-каб
Тел.: 8 (495) 411-68-86. Home раде: www.eksmo.ru E-mail: info@eksmo.ru.
Тауар белпа; «Эксмо»
Интернет-магазин www.book24.ru
Интернет-магазин www.book24.kz
Интернет-дукен: www.book24.kz
Импортёр в Республику Казахстан ТОО «РДЦ-Алматы^.
Казахстан Республикасына импорттаушы «РДЦ-Алматы» ЖШС.
Дистрибьютор и представитель по приему претензий на продукцию
в Республике Казахстан: ТОО «РДЦ-Алматы»
ТОО РДЦ Алматы, Алматы, ул. Домбровского, 3«а», литер Б. офис 1.
Дистрибьютор жене Казахстан Республикасында ен!мге шагымдар
кабылдау жен!ндег1 ек«л: -РДЦ-Алматы» ЖШС.
Алматы к-, Домбровский кеш., 3 «а», литер Б, офис 1.
Тел : 8(727) 251-59-90/91/92 E-mail: RDC-Almaty@eksmo.kz
Сведения о подтверждении соответствия издания согласно законодательству РФ
о техническом регулировании можно получить на сайте Издательства -Эксмо»:
www.eksmo.ru/certification
Техникалык реттеу туралы РФ зацнамасына сай басылымныц сайкест1пн растау
тур алы мэл)меттерд| мына адрес бойынша алута болады: http://eksmo.ru/certification/
Произведено в Российской Федерации
Ресей Федерациясы нда енд|р1лген
Сертификагтауга жатпайды
Да1а изготовления / Подписано в печать 21.03.2025. Формат 70x1007,,
Печать офсетная. Уел печ. л. 15,56.
Тираж экз. Заказ
БОМБОРА
ИЗДАТЕЛЬСТВО
БОМБОРА - лидер на рынке полезных и вдохновляющих книг.
Мы любим книги и создаем их, чтобы вы могли творить, открывать
мир, пробовать новое, расти. Быть счастливыми. Быть на волне.
0 bombora.ru СВ bomborabooks оо bombora
Литрес =
Я ГАК ЧИТАЮ
111 ЧИТАЙ
III ГОРОД
IFA2E eksmo.ru
Сфициалоный
интернет-магазин
издательства «Эксмо»
Хочешь стать
автором «Эксмо»?
3
ьЗ ТЕРИТОРИЯ
Wg КНИЖНЫЙ МАГАЗИН
и
Официальная франшиза
издательства «Эксмо»
ПОСЛЕ ПРОЧТЕНИЯ этой книги
ВЫ НАУЧИТЕСЬ ПРОГРАММИРОВАТЬ
ЦВЕТНЫЕ ПРИМЕРЫ СДЕЛАЮТ КОД ПОНЯТНЕЕ,
И ВЫ БЕЗ ТРУДА СМОЖЕТЕ:
* ПИСАТЬ ПРОГРАММНЫЙ КОД НА PYTHON
• ХРАНИТЬ ИНФОРМАЦИЮ В СТРУКТУРАХ ДАННЫХ
• СОЗДАВАТЬ АЛГОРИТМЫ В РАМКАХ ОБЪЕКТНО-
ОРИЕНТИРОВАННОГО ПРОГРАММИРОВАНИЯ
С помощью этих значков
ваше обучение станет проще
и понятнее
ПОЛЕЗНЫЕ СОВЕТЫ
СР^'
_^е
ВЫДЕЛЯЕТСЯ ЦВЕТОМ
ТО, ЧТО НЕОБХОДИМО
ЗАПОМНИТЬ
Благодаря практическим
заданиям вы получите
отличное представление об
основах программирования
на языке Python. Просто
следуйте инструкциям —
и вы научитесь создавать
простые программы, разбе-
ретесь с ключевыми концеп-
циями разработки и поймете,
как применять Python для
решения практических
задач
ПРЕДУПРЕЖДАЕТ ВАС
U ПОТЕНЦИАЛЬНОЙ
ОПАСНОСТИ1
СКАЧАЙТЕ ПРИМЕРЫ КОДА БЕСПЛАТНО
И ПРИСТУПАЙТЕ К РАБОТЕ СРАЗУ ЖЕ!
St БОМБОРА
ИЗДАТЕЛЬСТВО
ISBN 978-5-34-213835-5
БОМБОРА — лидер на рынке полезных
и вдохновляющих книг Мы любим книги и создаем
их, чтобы вы могли творить, открывать мир, пробовать
новое, расти. Быть счастливыми. Быть на волне.