Новости

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

Во-первых, вы, возможно, слышали о языке программирования Python и хотите научиться писать код на нем. В следующем разделе я объясню, почему именно Python отлично подходит в качестве первого языка программирования для изучения. Здесь вы много узнаете о Python и позже сможете прочесть более сложные книги об этом языке.

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

И в-третьих, вам может быть интересно изучить какой-нибудь другой язык программирования, например C ++, Java, Go или Rust. Многое из того, что вы узнаете в ходе изучения Python, будет полезно при усвоении других языков программирования. Кроме того, Python сам по себе заслуживает изучения. А почему именно он — об этом дальше.

Приступим к работе

Программирование — это написание кода для решения некоторой задачи. Этим мы и займемся. Поэтому не будем сначала изучать концепции Python, а затем формулировать задачи. Напротив, я сформулирую задачу, а уже на ее основе стану вводить концепции, которые нужно изучить.

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

Что мы будем делать

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

Мы напишем программы для решения всех приведенных задач. У каждой из них есть входные данные (ввод) определенного типа, которые программа будет получать, и ожидаемые выходные данные (вывод), тоже определенного типа. Будем считать, что программа правильно решает задачу, если может принимать любые допустимые входные данные и выдает в ответ правильные выходные данные.

В целом возможных входных данных могут быть миллионы или миллиарды. Каждый вариант входных данных называется экземпляром задачи. Например, в первой задаче, которую мы решим, входные данные — это строка текста, например hello there или bbaabbb aa abab. Наша цель — подсчитать и вывести количество слов в строке. Одна из самых крутых вещей в программировании заключается в том, что зачастую небольшой объем универсального кода позволяет решить бесконечное количество типовых задач. И не имеет значения, будет в строке два слова, три или 50 — программа всегда будет делать это правильно.

Наши программы будут выполнять три задачи.

• Чтение входных данных. Необходимо определить конкретный экземпляр задачи, которую требуется решить, поэтому сначала мы считываем предоставленные входные данные.
• Обработка. Мы обрабатываем входные данные, чтобы определить правильные выходные данные.
• Запись вывода. Решив задачу, выдаем желаемый вывод.

Границы между шагами бывают размытыми — иногда нам, возможно, придется чередовать обработку с получением результата. Но все равно работа в целом делится на эти три этапа.
Вы, вероятно, ежедневно пользуетесь программами, работающими в соответствии с моделью «ввод — обработка — вывод». Рассмотрим программу-калькулятор: вы вводите формулу (входные данные), программа обрабатывает числа (обработка), а затем отображает ответ (выходные данные). Или вспомним о поисковых системах в Интернете: вы вводите поисковый запрос (входные данные), поисковая система определяет наиболее релевантные результаты (обработка) и отображает их (выходные данные).

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

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

Оболочка Python

Для каждой задачи из книги мы хотим написать программу и сохранить ее в отдельном файле. Но для начала неплохо было бы знать, какую программу писать! Для решения многих задач вам нужно будет изучить пару новых функций Python.

Лучший способ поэкспериментировать с функциями Python — использовать оболочку Python. Это интерактивная среда, в которой можно ввести Python и нажать клавишу Enter, а Python в ответ выведет результат. Как только вы получите достаточно знаний, чтобы решить текущую задачу, можно будет перестать работать с оболочкой и начать писать решение в текстовом файле.
Для начала создайте на рабочем столе новую папку и назовите ее programming. Будем использовать ее для хранения результатов работы по ходу изучения книги.

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

Windows

Если вы работаете в Windows, сделайте следующее.
1. Удерживая нажатой клавишу Shift, щелкните правой кнопкой мыши на папке с вашими программами, например programming.
2. В появившемся меню выберите пункт Open PowerShell window here (Открыть окно PowerShell здесь). Если в контекстном меню нет такого пункта, выберите Open command window here (Открыть окно команд здесь).
3. В появившемся окне вы увидите строку, которая заканчивается знаком «больше» (>). Это приглашение операционной системы, и теперь она ждет, когда вы наберете команду. Вводить здесь нужно именно команды операционной системы, а не код Python. Обязательно нажимайте клавишу Enter после каждой команды.
4. Вы находитесь в папке programming. Можете ввести команду dir (от англ. directory — «папка»), если хотите посмотреть содержимое папки. Впрочем, пока вы не увидите никаких файлов, потому что мы их еще не создавали.
5. Введите команду python для запуска оболочки Python.

Запустив оболочку Python, вы увидите что-то вроде этого:

Python 3.9.2 (tags/v3.9.2:1a79785, Feb 19 2021, 13:30:23)
[MSC v.1928 32 bit (Intel)] on win32
Type "help", "copyright", "credits" or "license" for more information.
>>>

Здесь важно, чтобы в первой строке была указана версия Python не ниже 3.6. Если у вас установлена более старая версия, особенно 2.x, или Python не загружается вообще, установите последнюю версию Python, следуя инструкциям, приведенным во введении.
Внизу этого окна вы увидите приглашение вида >>>. Здесь мы будем писать код Python. Никогда не вводите символы >>> сами. Закончив писать программу, вы можете нажать сочетание клавиш Сtrl+Z, а затем Enter, чтобы выйти.

macOS

В macOS сделайте следующее.
1. Откройте приложение Terminal. Для этого нажмите сочетание клавиш Command+Пробел, введите слово terminal, а затем дважды щелкните на результате.
2. В открывшемся окне вы увидите строку, оканчивающуюся символом доллара ($). Это приглашение операционной системы, теперь можете ввести команду. Здесь вводятся именно команды операционной системы, а не код Python. Обязательно нажимайте клавишу Enter после каждой команды.
3. Можете ввести команду ls, чтобы получить список файлов, находящихся в текущей папке. Вы увидите свой рабочий стол.
4. Введите команду cd Desktop, чтобы перейти в папку рабочего стола. Команда cd означает change directory, то есть «перейти в другую папку».
5. Введите команду cd programming, чтобы перейти в папку programming.
6. Теперь введите команду python3, чтобы запустить оболочку Python (можно попробовать ввести просто python, но в результате может запуститься старая версия Python 2, которая не подходит для работы с этой книгой).

Когда вы запустите оболочку Python, появится что-то вроде этого:

Python 3.9.2 (default, Mar 15 2021, 17:23:44)
[Clang 11.0.0 (clang-1100.0.33.17)] on darwin
Type "help", "copyright", "credits" or "license" for more information.
>>>

Здесь важно, что в первой строке указана версия Python не ниже 3.6. Если у вас более старая версия, особенно 2.x, или Python не загружается вообще, установите последнюю версию Python, следуя инструкциям, данным во введении.

Внизу этого окна увидите приглашение >>>. Здесь вы набираете код Python. Никогда не вводите символы >>> самостоятельно. Если закончили программирование, можете нажать сочетание клавиш Ctrl+D, чтобы выйти.

Linux

Порядок действий для Linux таков.
1. Щелкните правой кнопкой мыши на папке programming.
2. В появившемся меню выберите пункт Open in Terminal (Открыть в терминале) (а можно сначала открыть консоль и перейти в папку programming, если вам так удобнее).
3. В открывшемся окне вы увидите строку, оканчивающуюся символом доллара ($). Это приглашение операционной системы, теперь можете ввести команду. Здесь вводятся именно команды операционной системы, а не код Python. Обязательно нажимайте клавишу Enter после каждой команды.
4. Вы находитесь в папке programming. Можете ввести команду ls, чтобы просмотреть ее содержимое. Но пока никаких файлов в ней быть не должно, потому что мы их еще не создавали.
5. Теперь введите команду python3, чтобы запустить оболочку Python (можно попробовать ввести просто python, но в результате может запуститься старая версия Python 2, которая не подходит для работы с этой книгой).

Когда вы запустите оболочку Python, появится что-то вроде этого:

Python 3.9.2 (default, Feb 20 2021, 20:57:50)
[GCC 7.5.0] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>>

Важно, чтобы версия Python в первой строке была не ниже 3.6. Если у вас более старая версия, особенно 2.x, или Python не загружается вообще, установите последнюю версию Python, следуя инструкциям, приведенным во введении.

Внизу этого окна вы увидите приглашение Python вида >>>. Здесь мы будем писать код Python. Никогда не вводите символы >>> сами. Закончив писать программу, можете нажать сочетание клавиш Сtrl+D, чтобы выйти.

Задача 1. Количество слов

Пришло время для нашей первой задачи! На Python напишем небольшую программу для подсчета слов. Вы узнаете, как считывать входные данные пользователя, обрабатывать их для решения задачи и выводить результат. А также узнаете, как управлять текстом и числами в своих программах, использовать встроенные операции Python и сохранять промежуточные результаты на пути к решению.

Это задача с сайта DMOJ, код dmopc15c7p2.

Постановка задачи

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

Входные данные

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

Максимальная длина строки — 80 символов.

Выходные данные

Количество слов в строке.

Строки

Фундаментальным строительным блоком программ на Python являются значения. У каждого значения есть тип, определяющий операции, которые над ним можно проводить. В задаче подсчета слов мы работаем со строкой текста. В Python текст хранится как строковое значение, поэтому нам нужно побольше узнать о том, что это значит. Чтобы решить задачу, требуется узнать количество слов в тексте, а для обозначения количества следует узнать о числовых значениях. Начнем со строк.

Представление строк

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

>>> 'hello'
'hello'
>>> 'a bunch of words'
'a bunch of words'

Оболочка Python повторяет за мной все, что я ввел.

А что, если в строке будет одинарная кавычка как ее часть?

>>> 'don't say that'
     File "<stdin>", line 1
        'don't say that'
               ^
SyntaxError: invalid syntax

Одиночная кавычка в слове don't завершает строку. Остальная часть уже не войдет в строку, поэтому наш ввод вызывает синтаксическую ошибку. Синтаксическая ошибка означает, что мы нарушили правила Python и написали неправильный код Python.

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

>>> "don't say that"
"don't say that"

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

Строковые операторы

Именно строки подойдут для хранения текста, количество слов в котором мы хотим подсчитать. Чтобы считать слова или вообще что-либо делать со строками, придется научиться работать с ними.

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

>>> 'hello' + 'there'
'hellothere'

Ах да, нам же нужен пробел между словами. Добавим его в конец первой строки:

>>> 'hello ' + 'there'
'hello there'

А еще есть оператор *, который размножает строку на указанное количество раз:

>>> '-' * 30
'------------------------------'

Здесь 30 — это целое число. О числах подробнее поговорим в ближайшее время.

ПРОВЕРИМ ЗНАНИЯ

Что выведет следующий код?

>>> '' * 3

А. ''''''
Б. ''
В. Этот код вызывает синтаксическую ошибку (недопустимый код Python).

Ответ

Б. '' — это пустая строка — строка без символов. Трехкратное повторение пустой строки остается пустой строкой!

Строковые методы

Метод — это операция, выполняемая над определенным типом значений. У строк, в частности, много методов. Например, есть метод с именем upper, который превращает все буквы строки в прописные:

>>> 'hello'.upper()
'HELLO'

Информация, которую мы получаем от метода, называется возвращаемым значением метода. Например, в предыдущем примере мы могли бы сказать, что метод upper вернул строку 'HELLO'.

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

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

Например, у строк есть метод strip. Если вызывать его без аргументов, он удаляет из строки все начальные и конечные пробелы:

>>> ' abc'.strip()
'abc'
>>> ' abc '.strip()
'abc'
>>> 'abc'.strip()
'abc'

Но мы также можем передать ему в качестве аргумента строку. Если сделать это, аргумент скажет методу, какие именно символы нужно удалить слева и справа:

>>> 'abc'.strip('a')
'bc'
>>> 'abca'.strip('a')
'bc'
>>> 'abca'.strip('ac')
'b'

Поговорим еще об одном строковом методе — count. Мы передаем ему строковый аргумент, и он сообщает, сколько вхождений этого аргумента найдено в строке:

>>> 'abc'.count('a')
1
>>> 'abc'.count('q')
0
>>> 'aaabcaa'.count('a')
5
>>> 'aaabcaa'.count('ab')
1

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

>>> 'ababa'.count('aba')
1

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

Сами подумайте: строка состоит из нескольких слов. Обратите внимание на то, что после каждого слова стоит пробел. Фактически, если бы вам нужно было подсчитать количество слов вручную, пробелы могли бы подсказать, где заканчивается каждое слово. А что, если мы посчитаем количество пробелов в строке? Для этого можем передать методу count символ пробела. Это выглядит так:

>>> 'this is a string with a few words'.count(' ')
7

Мы получили значение 7. Это не соответствует количеству слов, ведь их в строке восемь, но значение близко. Почему мы получили 7 вместо 8?

Причина в том, что пробел стоит после каждого слова, кроме последнего. Это значит, что при подсчете пробелов не учитывается последнее слово. Чтобы внести поправки, нам нужно научиться обращаться с числами.

Целые числа и числа с плавающей точкой

Любое выражение состоит из значений и операторов. Рассмотрим, как писать числовые значения и комбинировать их с операторами.

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

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

>>> 30
30
>>> 7
7
>>> 1000000
1000000
>>> -9
-9

Значение само по себе — простейший вид выражения.

Привычные нам математические операторы позволяют работать с целыми числами. Оператор + выполняет сложение, — — вычитание, * — умножение. С их помощью можно писать более сложные выражения.

>>> 8 + 10
18
>>> 8 - 10
-2
>>> 8 * 10
80

Обратите внимание на пробелы вокруг операторов. Хотя для Python выражения 8+10 и 8 + 10 одинаковы, написание с пробелами упрощает чтение.

В Python есть два оператора деления! Оператор // выполняет целочисленное деление, при котором остаток отбрасывается, а результат округляется вниз:

>>> 8 // 2
4
>>> 9 // 5
1
>>> -9 // 5
-2

Если хотите получить остаток от деления, используйте оператор деления по модулю, который обозначается символом %. Например, деление 8 на 2 выполняется без остатка:

>>> 8 % 2
0

При делении 8 на 3 в остатке 2:

>>> 8 % 3
2

Оператор /, в отличие от //, не округляет результат:

>>> 8 / 2
4.0
>>> 9 / 5
1.8
>>> -9 / 5
-1.8

И вот тут-то полученные результаты уже не являются целыми числами! Они пишутся через дробную точку и принадлежат другому типу Python, называемому float (число с плавающей точкой). Чтобы писать значения с плавающей точкой, нужно добавить собственно точку:

>>> 12.5 * 2
25.0

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

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

>>> 50 + 10 * 2
70

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

>>> (50 + 10) * 2
120

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

Вы можете спросить: а есть ли у целых чисел и чисел с плавающей точкой методы, как у строк. Есть! Но они не так уж и полезны. Например, есть метод, который сообщает нам, сколько памяти компьютера выделено на целое число. Чем оно больше, тем больше памяти ему требуется:

>>> (5).bit_length()
3
>>> (100).bit_length()
7
>>> (99999).bit_length()
17

В этом случае вокруг чисел нужны круглые скобки, иначе точечная нотация будет воспринята как десятичная точка и мы получим синтаксическую ошибку.

Переменные

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

Оператор присваивания

Переменная — это имя, которое ссылается на некоторое значение. Всякий раз, когда мы позже используем имя переменной, оно будет заменяться значением, на которое ссылается эта переменная. Чтобы она ссылалась на значение, применяется оператор присваивания. Он состоит из переменной, знака равенства (=) и выражения. Python вычисляет выражение и заставляет переменную ссылаться на результат. Пример оператора присваивания:

>>> dollars = 250
Имя dollars всегда заменяется числом 250:
>>> dollars
250
>>> dollars + 10
260
>>> dollars
250

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

>>> dollars = 250
>>> dollars
250
>>> dollars = 300
>>> dollars
300

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

>>> purchase_price1 = 58
>>> purchase_price2 = 9
>>> purchase_price1 + purchase_price2
67

Обратите внимание: я выбрал такие имена переменных, чтобы из них было понятно, что в них хранится. Эти две переменные, например, хранят стоимости двух покупок. Было бы проще ввести имена переменных p1 и p2, но, читая код через несколько дней, мы, вероятно, уже не поймем, что они означают!

Можно поместить в переменные строки:

>>> start = 'Monday'
>>> end = 'Friday'
>>> start
'Monday'
>>> end
'Friday'

Можно использовать их так же, как и переменные, которые ссылаются на числа, — в более крупных выражениях:

>>> start + '-' + end
'Monday-Friday'

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

Изменение значений переменных

Предположим, у нас есть переменная dollars, которая ссылается на значение:

>>> dollars = 250

Теперь мы хотим увеличить значение так, чтобы переменная dollars стала равна 251. Не сработает:

>>> dollars + 1
251

Результат равен 251, но это значение пропало, нигде не сохранившись:

>>> dollars
250

Нам нужен оператор присваивания, который позволяет сохранить результат:

>>> dollars = dollars + 1
>>> dollars
251
>>> dollars = dollars + 1
>>> dollars
252

Учащиеся часто путают оператор присваивания = с символом равенства. Не повторяйте этой ошибки! Оператор присваивания — это команда, заставляющая переменную ссылаться на значение выражения, а не утверждение о том, что два значения равны.

ПРОВЕРИМ ЗНАНИЯ

Каким окажется значение переменной у после выполнения приведенного фрагмента кода?

>>> x = 37
>>> y = x + 2
>>> x = 20

А. 39
Б. 22
В. 35
Г. 20
Д. 18

Ответ

A. Присваивание значения у выполняется лишь раз и дает значение 39. Выражение x = 20 меняет значение переменной x и на значение y никак не влияет.

Подсчет слов с использованием переменной

Давайте резюмируем все, что вы уже знаете о решении задачи подсчета слов.

• Вы узнали о строках и о том, что их можно применять для хранения какого-то текста.
• Узнали, что у строк есть метод count, который позволит подсчитать количество пробелов между словами в строке. Получим значение на единицу меньше нужного.
• Вы узнали о целых числах и об операторе сложения, который можно использовать для увеличения числа на 1.
• Узнали о переменных и об операторе присваивания, которые помогают сохранять значения.

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

>>> line = 'this is a string with a few words'
>>> total_words = line.count(' ') + 1
>>> total_words
8

Переменные line и total_words здесь не нужны, можно обойтись без них:

>>> 'this is a string with a few words'.count(' ') + 1
8

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

Чтение ввода от пользователя

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

Чтобы считать строку ввода, нужна функция input. Функции похожи на методы: мы вызываем их, передав какие-то аргументы, а они возвращают значение. Различие между методом и функцией заключается в том, что в функциях не используется точечная нотация. Вся информация передается в них через аргументы.

Далее приведен пример вызова функции ввода с последующим вводом информации, в данном случае слова testing:

>>> input()
testing
'testing'

Введя функцию input() и нажав клавишу Enter, вы не получите приглашение для ввода. Вместо этого Python ждет, когда вы что-нибудь напечатаете на клавиатуре и нажмете клавишу Enter. Затем функция input возвратит введенную вами строку. Как обычно, если мы нигде не сохраним эту строку, она будет потеряна. Воспользуемся оператором присваивания, чтобы сохранить введенное значение:

>>> result = input()
testing
>>> result
'testing'
>>> result.upper()
'TESTING'

Обратите внимание, что в последней строке я использовал метод upper на значении, возвращаемом input. Так делать можно, потому что input возвращает строку, а upper — строковый метод.

Вывод результата

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

>>> 'abc'
'abc'
>>> 'abc'.upper()
'ABC'
>>> 45 + 9
54

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

>>> print('abc')
abc
>>> print('abc'.upper())
ABC
>>> print(45 + 9)
54

Обратите внимание на то, что строки, выводимые с помощью функции print, не заключаются в кавычки. Это удобно, так как мы, скорее всего, не захотим задействовать кавычки при общении программы с пользователями!

Приятная особенность функции print заключается в том, что вы можете передать ей сколько угодно аргументов и все они будут выведены и разделены пробелами:

>>> print('abc', 45 + 9)
abc 54

Об авторе

Доктор Даниэль Зингаро — адъюнкт-профессор информатики и преподаватель в Университете Торонто, обладатель множества наград. Его основная область исследований — образование в сфере информатики и вопросы, связанные с тем, как студенты осваивают (пусть порой и плохо) информатику. Даниэль написал книгу Algorithmic Thinking1 (No Starch Press, 2021), которая помогает студентам изучать и использовать алгоритмы и структуры данных.

О научном редакторе

Люк Савчак — редактор-фрилансер и программист-любитель. Ему нравится превращать прозу в стихи, он написал пособие по нарезанию нужного количества кусочков торта и заумную версию Boggle, разобраться в которой сможет только преподаватель математики. Сейчас он преподает французский и английский языки на окраине Торонто. Люк также пишет стихи и сочиняет музыку для фортепиано, чем с удовольствием зарабатывал бы себе на жизнь, если бы мог. Его сайт: https://sawczak.com/.

Подробнее с книгой можно ознакомиться в нашем каталоге.