Введите два числа с клавиатуры и выведите целую часть от деления первого на второй python

Обновлено: 21.11.2024

Эти значения относятся к разным типам: 2 — целое число, а "Hello, World!" представляет собой строку, названную так потому, что она содержит "строку" букв. Вы (и интерпретатор) можете идентифицировать строки, поскольку они заключены в кавычки.

Операция print также работает для целых чисел. Мы используем команду python для запуска интерпретатора.

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

>> type('Hello, World!') >>> type(17) -->

Неудивительно, что строки относятся к типу str, а целые числа — к типу int. Менее очевидно, что числа с десятичной точкой относятся к типу с плавающей запятой, потому что эти числа представлены в формате, который называется с плавающей запятой.

Как насчет таких значений, как "17" и "3,2"? Они выглядят как числа, но заключены в кавычки, как строки.

Когда вы вводите большое целое число, у вас может возникнуть соблазн использовать запятые между группами из трех цифр, например 1 000 000 . Это недопустимое целое число в Python, но допустимо:

>> print(1 000 000) 1 0 0 -->

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

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

Переменные

Одной из самых мощных функций языка программирования является возможность манипулировать переменными. Переменная — это имя, которое ссылается на значение.

оператор присваивания создает новые переменные и присваивает им значения:

В этом примере выполняются три назначения. Первый присваивает строку новой переменной с именем message; второй присваивает n целое число 17; третий присваивает (приблизительное) значение π pi .

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

Тип переменной – это тип значения, на которое она ссылается.

Имена переменных и ключевые слова

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

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

В имени может использоваться символ подчеркивания ( _ ). Он часто используется в именах, состоящих из нескольких слов, таких как my_name или airspeed_of_unladen_swallow. Имена переменных могут начинаться с символа подчеркивания, но мы обычно избегаем этого, если только мы не пишем код библиотеки для использования другими.

Если вы дадите переменной недопустимое имя, вы получите синтаксическую ошибку:

>> 76trombones = 'большой парад' SyntaxError: неверный синтаксис >>> more@ = 1000000 SyntaxError: неверный синтаксис >>> SyntaxError: неверный синтаксис -->

76trombones недопустимы, так как они начинаются с цифры. more@ является недопустимым, поскольку содержит недопустимый символ @ . Но что не так с классом?

Оказывается, класс — это одно из ключевых слов Python. Интерпретатор использует ключевые слова для распознавания структуры программы, и их нельзя использовать в качестве имен переменных.

Python резервирует 33 ключевых слова:

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

Утверждения

оператор — это единица кода, которую может выполнить интерпретатор Python. Мы видели два типа операторов: print как оператор выражения и оператор присваивания.

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

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

Например, скрипт

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

Оператор присваивания не производит вывода.

Операторы и операнды

Операторы — это специальные символы, которые представляют такие вычисления, как сложение и умножение. Значения, к которым применяется оператор, называются операндами.

Операторы + , - , * , / и ** выполняют сложение, вычитание, умножение, деление и возведение в степень, как показано в следующих примерах:

В Python 2.x и Python 3.x произошли изменения в операторе деления. В Python 3.x результатом этого деления является результат с плавающей запятой:

>> минута = 59 >>> минута/60 0,9833333333333333 -->

Операция деления в Python 2.0 разделяла два целых числа и усекала результат до целого числа:

Чтобы получить тот же ответ в Python 3.0 использовать напольное (//целочисленное) деление.

>> минута = 59 >>> минута//60 0 -->

В Python 3.0 функции целочисленного деления гораздо шире, чем можно было бы ожидать, если бы вы вводили выражение на калькуляторе.

Выражения

выражение – это комбинация значений, переменных и операторов. Значение само по себе считается выражением, как и переменная, поэтому ниже приведены все допустимые выражения (при условии, что переменной x присвоено значение):

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

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

Упражнение 1. Введите следующие операторы в интерпретаторе Python, чтобы увидеть, что они делают:

Порядок операций

Когда в выражении появляется более одного оператора, порядок вычисления зависит от правил приоритета. Для математических операторов Python следует математическим соглашениям. Аббревиатура PEMDAS помогает запомнить правила:

Pкруглые скобки имеют наивысший приоритет и могут использоваться для принудительного вычисления выражения в нужном вам порядке. Поскольку выражения в круглых скобках оцениваются первыми, 2 * (3-1) равно 4, а (1+1)**(5-2) равно 8. Вы также можете использовать круглые скобки, чтобы упростить чтение выражения, как в ( минуту * 100) / 60 , даже если это не меняет результат.

Eвозведение в степень имеет следующий наивысший приоритет, поэтому 2**1+1 равно 3, а не 4, а 3*1**3 равно 3, а не 27.

Mумножение и Dделение имеют одинаковый приоритет, который выше, чем Aсложение и Sвычитание. , которые также имеют одинаковый приоритет. Таким образом, 2*3-1 равно 5, а не 4, а 6+4/2 равно 8,0, а не 5.

Операторы с одинаковым приоритетом оцениваются слева направо. Таким образом, выражение 5-3-1 равно 1, а не 3, потому что сначала происходит 5-3, а затем 1 вычитается из 2 .

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

Оператор модуля

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

>> частное = 7 // 3 >>> напечатать(частное) 2 >>> остаток = 7 % 3 >>> напечатать(остаток) 1 -->

Таким образом, 7 разделить на 3 равно 2 с остатком 1.

Оператор модуля оказывается на удивление полезным. Например, вы можете проверить, делится ли одно число на другое: если x % y равно нулю, то x делится на y .

Вы также можете извлечь крайнюю правую цифру или цифры из числа. Например, x % 10 дает самую правую цифру x (в базе 10). Точно так же x % 100 дает две последние цифры.

Операции со строками

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

Вывод этой программы: 100150 .

Запрос пользователя на ввод

Иногда нам нужно получить значение переменной от пользователя с помощью его клавиатуры. Python предоставляет встроенную функцию ввода, которая получает ввод с клавиатуры 1 . Когда эта функция вызывается, программа останавливается и ждет, пока пользователь что-нибудь введет. Когда пользователь нажимает Return или Enter , программа возобновляет работу, и ввод возвращает то, что пользователь ввел в виде строки.

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

Последовательность \n в конце подсказки представляет собой новую строку, специальный символ, вызывающий разрыв строки. Вот почему ввод пользователя отображается под подсказкой.

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

Но если пользователь вводит что-то другое, кроме строки цифр, вы получите сообщение об ошибке:

Мы увидим, как обрабатывать ошибки такого рода позже.

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

В этом случае комментарий появляется на отдельной строке. Вы также можете поместить комментарии в конце строки:

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

Этот комментарий избыточен в коде и бесполезен:

Этот комментарий содержит полезную информацию, которой нет в коде:

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

Выбор мнемонических имен переменных

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

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

Мы называем эти разумно выбранные имена переменных "мнемонимическими именами переменных". Слово мнемоника 2 означает "помощь памяти". Мы выбираем мнемонические имена переменных, чтобы помочь нам вспомнить, почему мы создали переменную в первую очередь.

Хотя все это звучит великолепно, и использование мнемонических имен переменных является очень хорошей идеей, мнемонические имена переменных могут мешать начинающему программисту анализировать и понимать код. Это связано с тем, что начинающие программисты еще не запомнили зарезервированные слова (их всего 33), и иногда переменные со слишком описательными именами начинают выглядеть как часть языка, а не просто хорошо подобранные имена переменных.

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

Что здесь происходит? Какие из токенов (for, word, in и т. д.) являются зарезервированными словами, а какие — просто именами переменных? Понимает ли Python на фундаментальном уровне понятие слов? У начинающих программистов возникают проблемы с разделением того, какие части кода должны быть такими же, как в этом примере, а какие части кода являются просто выбором, сделанным программистом.

Следующий код эквивалентен коду выше:

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

Но если наша программа действительно считывает данные и ищет в них слова, то pizza и slice — совсем не мнемонические имена переменных. Их выбор в качестве имен переменных отвлекает от смысла программы.

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

слово *в* слова*:*\ *напечатать* слово

Части кода, определенные Python ( for , in , print и : ), выделены жирным шрифтом, а выбранные программистом переменные (word и words) не выделены жирным шрифтом. Многие текстовые редакторы знают о синтаксисе Python и по-разному окрашивают зарезервированные слова, чтобы дать вам подсказки, чтобы разделить переменные и зарезервированные слова. Через некоторое время вы начнете читать Python и быстро определять, что такое переменная, а что зарезервированное слово.

Отладка

На данном этапе синтаксическая ошибка, которую вы, скорее всего, совершите, связана с недопустимым именем переменной, например class и yield , которые являются ключевыми словами, илиod~job и US$ , которые содержат недопустимые символы.

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

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

Ошибка времени выполнения, которую вы, скорее всего, сделаете, это "use before def"; то есть попытка использовать переменную до того, как вы присвоили ей значение. Это может произойти, если вы неправильно напишете имя переменной:

Имена переменных вводятся с учетом регистра, поэтому LaTeX отличается от латекса.

На данный момент наиболее вероятной причиной семантической ошибки является порядок операций. Например, чтобы вычислить 1 / 2π , у вас может возникнуть соблазн написать

Но сначала происходит деление, поэтому вы получите π / 2 , что не одно и то же! У Python нет возможности узнать, что вы хотели написать, поэтому в этом случае вы не получите сообщение об ошибке; вы просто получите неправильный ответ.

Глоссарий

объединить Чтобы соединить два операнда встык.

комментарий Информация в программе, предназначенная для других программистов (или тех, кто читает исходный код) и не влияющая на выполнение программы.

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

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

с плавающей запятой Тип, представляющий числа с дробными частями.

integer Тип, представляющий целые числа.

ключевое слово Зарезервированное слово, используемое компилятором для разбора программы; вы не можете использовать такие ключевые слова, как if , def и while в качестве имен переменных.

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

оператор модуля Оператор, обозначаемый знаком процента ( %), который работает с целыми числами и дает остаток при делении одного числа на другое.

операнд Одно из значений, над которым работает оператор.

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

правила приоритета Набор правил, определяющих порядок, в котором оцениваются выражения, включающие несколько операторов и операндов.

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

string Тип, представляющий последовательность символов.

тип Категория значений. До сих пор мы видели целые числа (тип int ), числа с плавающей запятой (тип float ) и строки (тип str ).

значение Одна из основных единиц данных, например число или строка, с которыми работает программа.

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

Упражнения

Упражнение 2. Напишите программу, которая использует ввод для запроса имени пользователя, а затем приветствует его.

Упражнение 3. Напишите программу, запрашивающую у пользователя количество часов и почасовую ставку для расчета брутто-зарплаты.

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

Упражнение 4. Предположим, что мы выполняем следующие операторы присваивания:

Для каждого из следующих выражений запишите значение выражения и тип (значения выражения).

Используйте интерпретатор Python, чтобы проверить свои ответы.

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

В Python 2.0 эта функция называлась raw_input .↩

Подробное описание слова «мнемоника» см. на http://en.wikipedia.org/wiki/Mnemonic.↩

Текст © Чарльз Р. Северанс. Интерактивный HTML © Trinket. Оба предоставляются по лицензии CC-NC-BY-SA.
Огромное спасибо многим участникам проекта!

Это программа Python для чтения двух чисел и вывода их частного и остатка.

Программа берет два числа и печатает частное и остаток.

<р>1. Возьмите первое и второе число и сохраните их в отдельных переменных.
2. Затем получите частное с помощью деления и остаток с помощью оператора модуля.
3. Выход.

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

<р>1. Пользователь должен ввести первое и второе число.
2. Частное получается с помощью истинного деления (оператор //).
3. Оператор модуля дает остаток от деления a на b.

Sanfoundry Global Education & Learning Series – Программы Python.

Следующие шаги:

Получите бесплатный сертификат о заслугах в программировании на Python
Примите участие в конкурсе сертификации программистов на Python
Стать лидером в программировании на Python
Пройдите тесты по программированию на Python
Практические тесты по главам: главы 1, 2, 3, 4, 5, 6, 7, 8, 9, 10
Проверки по главам: главы 1, 2, 3, 4, 5, 6, 7, 8, 9, 10

Похожие сообщения:

Подать заявку на стажировку по Python
Купить книги по информационным технологиям
Подать заявку на стажировку по программированию
Практика программирования MCQ
Купить книги по Python

2.2. Три способа записи строк¶

Строки в Python могут быть заключены либо в одинарные кавычки ( ' ), либо в двойные кавычки ( " ), либо в три кавычки ( ''' или """ )

Строки в двойных кавычках могут содержать внутри одинарные кавычки, как в "Bruce's beard" , а строки в одинарных кавычках могут иметь внутри двойные кавычки, как в "The Knights who say "Ni!"" .

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

Строки в тройных кавычках могут занимать даже несколько строк:

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

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

2.3. Строковые литералы и escape-последовательности¶

Литерал — это нотация для представления постоянного значения встроенного типа данных.

В строковых литералах большинство символов представляют сами себя, поэтому, если нам нужен литерал с буквами s-t-r-i-n-g , мы просто пишем 'string' .

Но что, если мы хотим представить литерал для перевода строки (то, что вы получаете, когда нажимаете клавишу на клавиатуре) или табуляции? Эти строковые литералы нельзя распечатать так, как s или t.Чтобы решить эту проблему, Python использует управляющую последовательность для представления этих строковых литералов.

Существует несколько таких escape-последовательностей, которые полезно знать.

\n — наиболее часто используемый из них. Следующий пример, надеюсь, прояснит, что он делает.

2.4. Имена и операторы присваивания¶

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

Мы используем оператор присваивания Python именно для этой цели:

В приведенном выше примере используются три назначения. Первый присваивает строковое значение «Как дела, Док?» к названию сообщение . Второй присваивает целому числу 17 имя n , а третий присваивает числу с плавающей запятой 3,14159 имя pi .

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

Имена также называются переменными, поскольку значения, на которые они ссылаются, могут изменяться во время выполнения программы. Переменные также имеют типы. Опять же, мы можем спросить у переводчика, что это такое.

Тип переменной – это тип значения, на которое она в данный момент ссылается.

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

На этой диаграмме показан результат выполнения предыдущих операторов присваивания:

2.5. Переменные переменные¶

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

Это отличается от математики. В математике, если вы присвоите x значение 3, оно не может измениться, чтобы связать с другим значением на полпути к вашим вычислениям!

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

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

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

2.6. Оператор присваивания не является знаком равенства!¶

Семантика оператора присваивания может сбить с толку начинающих программистов, особенно потому, что токен присваивания = можно легко спутать с equals (Python использует токен == для равенства, поскольку мы скоро увидим). Это не так!

Вышеприведенное среднее утверждение было бы невозможным, если бы = означало равно, поскольку n никогда не может быть равно n + 1 . Однако это утверждение совершенно законно для Python. Оператор присваивания связывает имя слева от оператора с значением справа.

Два ns в n = n + 1 имеют разные значения: n справа — это поиск в памяти, который заменяется значением, когда правая часть вычисляется Python устный переводчик. Он должен уже существовать, иначе возникнет ошибка имени. Сначала оценивается правая часть оператора присваивания.

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

Имена в Python существуют в контексте, называемом пространством имен, которое мы обсудим позже в этой книге.

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

При чтении или написании кода скажите себе: «n присваивается 17» или «n получает значение 17». Не говорите «n равно 17».

Если вам интересно, токен – это символ или строка символов, имеющая синтаксическое значение в языке. В Python операторы, ключевые слова, литералы и пробелы образуют токены языка.

2.7. Имена переменных и ключевые слова¶

Действительные имена переменных в Python должны соответствовать следующим трем простым правилам:

Это произвольно длинная последовательность букв и цифр.

Последовательность должна начинаться с буквы.

В дополнение к a..z и A..Z подчеркивание ( _ ) является буквой.

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

В имени может использоваться символ подчеркивания ( _ ). Он часто используется в именах, состоящих из нескольких слов, таких как my_name или price_of_tea_in_china .

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

Если вы дадите переменной недопустимое имя, вы получите синтаксическую ошибку:

76trombones является незаконным, так как не начинается с буквы. more$ является недопустимым, поскольку содержит недопустимый символ, знак доллара. Но что не так с классом?

Оказывается, класс — это одно из ключевых слов Python. Ключевые слова определяют синтаксические правила и структуру языка, и их нельзя использовать в качестве имен переменных.

Python 3 содержит тридцать три ключевых слова (и время от времени усовершенствования Python вводят или исключают одно или два):

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

Список ключевых слов, keyword.kwlist , соответственно, приходит к нам в виде списка Python.

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

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

Новички иногда путают значимый для человека-читателя с значимым для компьютера. Таким образом, они ошибочно думают, что раз они назвали некоторую переменную средней или pi, она каким-то образом автоматически рассчитает среднее значение или автоматически свяжет переменную pi со значением 3,14159. Нет! Компьютер не придает семантического значения вашим именам переменных. Это зависит от вас.

2.8. Операторы и выражения¶

Инструкция — это инструкция, которую может выполнить интерпретатор Python. До сих пор мы видели два: оператор присваивания и оператор импорта. Некоторые другие виды операторов, которые мы скоро увидим, — это операторы if, while и for. (Есть и другие виды!)

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

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

В этом примере len — это встроенная функция Python, которая возвращает количество символов в строке. Ранее мы видели функции print и type, так что это наш третий пример функции.

В результате вычисления выражения получается значение, поэтому выражения могут появляться справа от операторов присваивания. Значение само по себе является простым выражением, как и переменная.

2.9. Операторы и операнды¶

Операторы — это специальные токены, представляющие такие вычисления, как сложение, умножение и деление. Значения, которые использует оператор, называются операндами.

Ниже приведены все допустимые выражения Python, смысл которых более или менее ясен:

Токены + и - , а также использование скобок для группировки означают в Python то же, что и в математике. Звездочка ( * ) – это знак умножения, а ** – знак возведения в степень (возведение числа в степень).

Когда вместо операнда появляется имя переменной, перед выполнением операции оно заменяется его значением.

Сложение, вычитание, умножение и возведение в степень делают то, что вы ожидаете.

Пример: переведем 645 минут в часы:

Ой! В Python 3 оператор деления / всегда дает результат с плавающей запятой. Возможно, нам хотелось бы знать, сколько осталось полных часов и сколько минут осталось. Python дает нам два разных варианта оператора деления. Второе, называемое целочисленным делением, использует токен // . Он всегда усекает результат до следующего наименьшего целого числа (слева в числовой строке).

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

2.10. Оператор модуля¶

Операция модуля работает с целыми числами (и целочисленными выражениями) и дает остаток при делении первого числа на второе. В Python оператор модуля представляет собой знак процента ( %).Синтаксис такой же, как и для других операторов:

Поэтому 7 разделить на 3 равно 2 с остатком 1.

Оператор модуля оказывается на удивление полезным. Например, вы можете проверить, делится ли одно число на другое — если x % y равно нулю, то x делится на y .

Кроме того, вы можете извлечь крайнюю правую цифру или цифры из числа. Например, x % 10 дает самую правую цифру x (в базе 10). Точно так же x % 100 дает две последние цифры.

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

2.11. Порядок операций¶

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

Скобки имеют наивысший приоритет и могут использоваться для принудительного вычисления выражения в нужном вам порядке. Поскольку выражения в круглых скобках оцениваются первыми, 2 * (3-1) равно 4, а (1+1)**(5-2) равно 8. Вы также можете использовать круглые скобки, чтобы упростить чтение выражения, как в ( минуту * 100) / 60 , даже если это не меняет результат.

Возведение в степень имеет следующий наивысший приоритет, поэтому 2**1+1 равно 3, а не 4, а 3*1**3 равно 3, а не 27.

Из-за некоторой исторической причуды исключением из правила левой ассоциативности слева направо является оператор возведения в степень ** , поэтому полезно всегда использовать круглые скобки, чтобы задать именно тот порядок, который вы хотите, когда задействовано возведение в степень:

Командная строка Python в непосредственном режиме отлично подходит для изучения и экспериментирования с подобными выражениями.

2.12. Операции со строками¶

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

Интересно, что оператор + работает со строками, но для строк оператор + представляет конкатенацию, а не сложение. Конкатенация означает соединение двух операндов путем их сквозной связи. Например:

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

Оператор * также работает со строками; он выполняет повторение. Например, «Веселье» * 3 — это «Веселье, веселье». Один из операндов должен быть строкой; другое должно быть целым числом.

С одной стороны, эта интерпретация + и * имеет смысл по аналогии со сложением и умножением. Поскольку 4 * 3 эквивалентно 4 + 4 + 4 , мы ожидаем, что «Веселье» * 3 будет таким же, как «Веселье» + «Веселье» + «Веселье», и это так. С другой стороны, конкатенация и повторение строк существенно отличаются от сложения и умножения целых чисел. Можете ли вы придумать свойство, которым обладают сложение и умножение и которых нет у конкатенации строк и повторения?

2.13. Функции преобразования типов¶

Здесь мы рассмотрим еще три функции Python, int , float и str , которые будут (попытаться) преобразовать свои аргументы в типы int , float и str соответственно. Мы называем эти функции преобразования типов.

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

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

Преобразователь типа float может преобразовать целое число, число с плавающей запятой или синтаксически допустимую строку в число с плавающей запятой.

1. Как читать и писать на Python

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

Для ввода данных в программу мы используем input() . Эта функция считывает одну строку текста как строку.

Вот программа, которая считывает имя пользователя и приветствует его:

2. Сумма чисел и строк

Попробуем написать программу, которая вводит два числа и выводит их сумму. Мы читаем два числа и сохраняем их в переменных a и b с помощью оператора присваивания = . Слева от оператора присваивания мы помещаем имя переменной.Имя может быть строкой латинских символов (A-Z, a-z, 0-9, _), но должно начинаться с буквы в диапазоне A-Z или a-z. Справа от оператора присваивания мы помещаем любое выражение, которое Python может вычислить. Имя начинает указывать на результат оценки. Прочтите этот пример, запустите его и посмотрите на результат:

После запуска примера мы видим, что он печатает 57 . Как нас учили в школе, 5+7 дает 12. Итак, программа неверна, и важно понять, почему. Дело в том, что в третьей строке s = a + b Python «суммировал» две строки, а не два числа. Сумма двух строк в Python работает следующим образом: они просто склеиваются одна за другой. Это также иногда называют "объединением строк".

Видите ли вы в инспекторе переменных справа, что значения, связанные с переменными a и b, заключены в кавычки? Это означает, что значения там строковые, а не числа. Строки и числа представлены в Python по-разному.

Все значения в Python называются "объектами". Каждый объект имеет определенный тип. Число 2 соответствует объекту «число 2» типа «int» (т. е. целое число). Строка «привет» соответствует объекту «строка «привет»» типа «str». Каждое число с плавающей запятой представлено как объект типа "float". Тип объекта указывает, какие операции могут быть применены к нему. Например, если две переменные «first» и «second» указывают на объекты типа int, Python может их перемножить. Однако, если они указывают на объекты типа str , Python не может этого сделать:

Чтобы привести (преобразовать) строку цифр в целое число, мы можем использовать функцию int() . Например, int('23') дает объект int со значением 23 .

Учитывая приведенную выше информацию, теперь мы можем исправить неверный вывод и правильно вывести сумму двух чисел:

Читайте также: