Как переменной x присвоить значение 45

Работа с числами в Python

В этом материале рассмотрим работу с числами в Python. Установите последнюю версию этого языка программирования и используйте IDE для работы с кодом, например, Visual Studio Code.

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

• int (целые числа)
• float (числа с плавающей точкой)
• complex (комплексные числа)

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

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

В программирование целые числа — это те, что лишены плавающей точкой, например, 1, 10, -1, 0 и так далее. Числа с плавающей точкой — это, например, 1.0, 6.1 и так далее.

Создание int и float чисел

Для создания целого числа нужно присвоить соответствующее значение переменной. Возьмем в качестве примера следующий код:

Здесь мы присваиваем значение 25 переменной var1 . Важно не использовать одинарные или двойные кавычки при создании чисел, поскольку они отвечают за представление строк. Рассмотрим следующий код.

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

Здесь также не стоит использовать кавычки.

Проверить тип данных переменной можно с помощью встроенной функции type() . Можете проверить результат выполнения, скопировав этот код в свою IDE.

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

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

Значение выведем с помощью функции print :

Арифметические операции над целыми и числами с плавающей точкой

Используем такие арифметические операции, как сложение и вычитание, на числах. Для запуска этого кода откройте оболочку Python, введите python или python3 . Терминал должен выглядеть следующим образом:

Сложение

В Python сложение выполняется с помощью оператора + . В терминале Python выполните следующее.

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

Теперь запустим такой код.

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

Вычитание

В Python для операции вычитания используется оператор -. Рассмотрим примеры.

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

Умножение

Для умножения в Python применяется оператор * .

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

Деление

В Python деление выполняется с помощью оператора / .

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

Деление без остатка

При обычном делении с использованием оператора / результатом будет точное число с плавающей точкой. Но иногда достаточно получить лишь целую часть операции. Для этого есть операции интегрального деления. Стоит рассмотреть ее на примере.

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

Остаток от деления

Для получения остатка деления двух чисел используется оператор деления по модулю % .

На этих примерах видно, как это работает.

Возведение в степень

Число можно возвести в степень с помощью оператора ** .

Комплексные числа

Комплексные числа — это числа, которые включают мнимую часть. Python поддерживает их «из коробки». Их можно запросто создавать и использовать. Пример:

Как переменной x присвоить значение 45

Переменные – очень важная составляющая программы; по сути, это символ (или набор символов), которому присвоено значение и который можно использовать вместо этого значения при написании программы.

Данное руководство ознакомит вас с основами работы с переменными в Python 3.

Что такое переменная?

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

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

К примеру, у вас есть целое число 103204934813. Вы можете сохранить его в переменной, и тогда вам не придётся постоянно вводить повторно длинное число. Сохраните число в переменной my_int:

По сути, my_int – это ярлык, привязанный к значению 103204934813.

Фраза my_int = 103204934813 – это операция присваивания, которая состоит из следующих частей:

• my_int – имя переменной;
• = – оператор присваивания;
• 103204934813 – значение.

Таким образом, присваивая значению имя, вы инициализируете, или создаёте переменную. После этого можно использовать переменную вместо значения. В Python, в отличие от некоторых других языков программирования, переменные не нужно явно декларировать. То есть, объявив, что my_int равно 103204934813, вы можете просто использовать my_int вместо числа. Попробуйте запустить:

С помощью переменных можно быстро выполнить вычисления. Попробуйте отнять 813 из my_int:

print(my_int — 813)
103204934000

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

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

Выведите значение x:

Python выводит 221, потому что именно это число получается в результате сложения 76 и 145.

В виде переменной можно представить любой тип данных, не только числа.

my_string = ‘Hello, World!’
my_flt = 45.06
my_bool = 5 > 9 #логический оператор оценивает выражение как истинное или ложное
my_list = [‘item_1’, ‘item_2’, ‘item_3’, ‘item_4’] my_tuple = (‘one’, ‘two’, ‘three’)
my_dict =

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

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

Правила задания имен переменных

Существует ряд правил, которых следует придерживаться при наименовании переменных.

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

Для примера рассмотрим правильные и неправильные имена переменных:

Правильно

Неправильно

Выбирая имя для переменной, следует также учитывать регистр: my_int, MY_INT, My_Int и mY_iNt – не одна, а четыре разные переменные.

Примечание: Избегайте похожих имён переменных в рамках одной программы.

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

Правильно

Неправильно

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

Читайте также: PEP 8 – официальный мануал по кодированию в Python

Переназначение переменной

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

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

Попробуйте задать в переменной x число, а затем переназначить её и задать строку:

Если бы программа была написана так:

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

Множественное присваивание переменной

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

Например, можно задать переменным x, y и z значение 0.

x = y = z = 0
print(x)
print(y)
print(z)
0
0
0

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

Python также позволяет присваивать несколько значений нескольким переменным в рамках одной строки. Например:

j, k, l = «8host», 1.05, 16
print(j)
print(k)
print(l)
8host
1.05
16

Как видите, переменной j было присвоено значение 8host, переменной k 1.05, l – 16.

Эта функция позволяет сократить код, и при этом сохранить его читабельность.

Глобальные и локальные переменные

При использовании переменной в программе важно иметь в виду её область видимости.

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

Глобальные переменные объявлены вне функции, но доступны внутри функции. Локальные переменные объявлены внутри функции.

Рассмотрите пример таких переменных:

#Создайте глобальную переменную
glb_var = «global»
#Определите функцию
def var_function():
lcl_var = «local» #Создайте локальную переменную внутри функции
print(lcl_var)
#Вызовите функцию
var_function()
#Выведите глобальную переменную
print(glb_var)
local
global

Поскольку переменная glb_var является глобальной, мы можем сослаться на неё внутри функции var_function(). Отредактируйте предложенный выше код, чтобы сделать это:

glb_var = «global»
def var_function():
lcl_var = «local»
print(lcl_var)
print(glb_var) #Выводит glb_var внутри функции
var_function()
print(glb_var)
local
global
global

Теперь переменная glb_var выводится дважды: внутри и вне функции.

Попробуйте вызвать локальную переменную вне функции:

glb_var = «global»
def var_function():
lcl_var = «local»
print(lcl_var)
print(lcl_var)
NameError: name ‘lcl_var’ is not defined

Как видите, вы не можете вызвать локальную переменную вне функции, так как она существует только внутри функции.

Рассмотрим ещё один пример. Задайте глобальной и локальной переменной одно и то же имя:

num1 = 5 #Глобальная переменная
def my_function():
num1 = 10 #Локальная переменная с таким же именем, num1
num2 = 7 #Локальная переменная
print(num1) #Выведет локальную переменную num1
print(num2) #Выведет локальную переменную num2
#Вызывает my_function()
my_function()
#Выводит глобальную переменную num1
print(num1)
10
7
5

Поскольку локальная переменная num1 присвоена внутри функции, при вызове num1 появляется 10. При выводе глобальной переменной num1 (после вызова функции my_function()) появляется значение 5.

Оператор global позволяет определять глобальные переменные Python внутри функции:

def new_blog():
global blog = «8host» #Присваивает глобальную переменную
#Выводит глобальную переменную blog
print(blog)

Несмотря на то, что переменная blog была присвоена локально внутри функции new_blog(), она доступна вне функции благодаря оператору global. Потому при вызове print(blog) Python не выдаёт ошибку: переменная существует и вне, и внутри функции.

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

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

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

Как присвоить значение моей переменной через функцию?

Есть скрипт, в котором я хочу присвоить некоторое значение переменной x с помощью функции x_value , но в консоли выходить undefined , т.е. функция срабатывает позже console.log() . Как грамотно это сделать?)

Туплю, но прошу помощи)

Функция срабатывает раньше, чем console.log , и это легко проверить, добавив в функцию еще один console.log("внутри функции"); .

Всё ещё ищете ответ? Посмотрите другие вопросы с метками javascript или задайте свой вопрос.

Site design / logo © 2022 Stack Exchange Inc; user contributions licensed under cc by-sa. rev 2022.6.10.42345

Нажимая «Принять все файлы cookie», вы соглашаетесь, что Stack Exchange может хранить файлы cookie на вашем устройстве и раскрывать информацию в соответствии с нашей Политикой в отношении файлов cookie.

Как в Python присвоить значение переменной? Мануал для новичков

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

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

Объявление переменной в Питоне

Объявление переменной в Питоне осуществляется при помощи оператора присваивания «=» ; чтобы присвоить значение переменной в Python, также используется этот оператор.

Простой пример , как создать переменную в Python:

То есть слева указывается имя переменной, а справа от оператора указывается ее значение. Разные переменные могут быть разными типами данных. Например, наша первая переменная «name» — это строка, а вторая переменная «age» — это число. Помимо этих типов, переменные могут соответствовать и другим типам данных.

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

Давайте проведем с объявленными переменными самую простую операцию — выведем их значения на экран:

На экране появится: Максим 22.

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

x = y = z = 6 # всем трем переменным будет присвоено значение «6»

Как правильно задать имена переменным в Питоне?

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

Нельзя в имени использовать пробелы.

Нельзя имя начинать с цифры.

Важно соблюдать регистр: name и Name — это разные имена переменных.

Нельзя использовать «зарезервированные имена». Данные имена зарезервированы самим Python и используются или будут использоваться самим языком. Например: false, true, break и др. Полный список этих имен доступен в интерпретаторе Питона по команде: help(“keywords“).

Имя переменной должно содержать в себе информацию о том, что хранит в себе эта переменная. Как в нашем примере: «name» — это имя, «age» — это возраст. В таком случае вы всегда сможете понять , для чего нужна эта переменная, даже когда ваш код сильно разрастется.

Так как основной язык программирования — это английский, то имя должно быть написано на этом языке, а не транслитом. Например : «name» — это правильно, а «imya» — это неправильно.

Адекватная длина. Имя должно отражать суть переменной, но не быть слишком длинным. Например : «name» — это хорошо, «thisIsNameOfBoy» — не очень хорошо.

В сложных именах предпочтительно использовать CamelCase или Snake Case. CamelCase предполагает , что первое слово имени начинается с маленькой буквы, а остальные — с большой. Например: boyName. А Snake Case предполагает все слова имени писать с маленькой буквы, однако разделять их нужно нижним подчеркиванием. Например: boy_name.

Заключение

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

И если после этого добавить в код print(name), то произойдет ошибка.

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

x, y = y, x # такая операция поменяет значения, теперь x = 4 , y = 6

x, y, z = z, x, y # можно менять значения больше , чем у 2-х переменных!

Изучайте этот язык программирования и используйте «правильный» подход, когда нужно сделать объявление переменных в Питоне. Это позволит вам изначально учиться программировать правильно. Такой подход в наименовании переменных нужен не только в Питоне.

Мы будем очень благодарны

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

Числа в Python

Когда мы хотим представить информацию о количестве деревьев в саду, остатке на банковской карте или же провести какие-либо математические расчеты, мы используем числа. В Python числа представлены сразу несколькими родственными категориями типов. Сюда относятся целые ( int ), вещественные ( float ) и комплексные ( complex ) числа. Если возможностей базовых типов не хватает, всегда можно воспользоваться числовыми расширениями в виде модулей decimal или fractions. Все перечисленные числовые типы довольно легко преобразуются между собой, а математические операции с ними интуитивно понятны и производятся по общепринятым правилам математики.

Целые числа

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

Пример №1. Литералы целых чисел в Python.

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

• В десятичной системе счисления целые числа записываются в виде привычной нам последовательности цифр от нуля до десяти, например, 0 , -33 , +127 .
• В двоичной системе счисления запись целого числа должна начинаться с нуля и латинской буквы B в верхнем или нижнем регистре (т.е. 0b или 0B ), после чего должна идти последовательность нулей и единиц. Например, 0b01101 , 0B1011 , -0b1001 . Если будут использованы другие цифры, интерпретатор сгенерирует сообщение об ошибке.
• В восьмеричной системе счисления целое число должно начинаться с нуля и латинской буквы O в верхнем или нижнем регистре (т.е. 0o или 0O ), после чего должна идти последовательность цифр от нуля до семи ( 01234567 ). Например, 0o77 , 0O35 , -0O174 . Если будут использованы цифры не входящие в данный диапазон, интерпретатор сгенерирует сообщение об ошибке.
• В шестнадцатеричной системе счисления запись целого числа должна начинаться с нуля и латинской буквы X в верхнем или нижнем регистре (т.е. 0x или 0X ), после чего должны идти символы последовательности 0123456789ABCDEF , представляющих данную систему счисления. При этом буквы также разрешается использовать в любом регистре. Например, 0x7F , 0XDD5A , -0xfF9 . Если будут использованы символы не входящие в данный диапазон, интерпретатор сгенерирует сообщение об ошибке.

Кроме того, во всех случаях разрешается использовать перед числом знаки плюса ( + ) и минуса ( — ). Также можно переводить целые числа из одной системы счисления в другую. Для этого следует использовать следующие встроенные функции.

• bin(int_num) – преобразует целое число в двоичную систему счисления, возвращая строку с представлением литерала числа в этой системе.
• oct(int_num) – преобразует целое число в восьмеричную систему счисления, возвращая строку с представлением литерала числа в этой системе.
• hex(int_num) – преобразует целое число в шестнадцатеричную систему счисления, возвращая строку с представлением литерала числа в этой системе.
• int(obj) – конструктор типа int может использоваться как с одним, так и с двумя аргументами. Когда указан только один аргумент, функция пытается преобразовать объект в целое число в десятичной системе счисления, а в случае невозможности такого преобразования возбуждает соответствующее исключение. При этом, если объект obj является вещественным числом, оно преобразуется в целое путем усечения дробной части, например, int(21.302) вернет 21 .
• int(num_str, base=10) – если указано два аргумента, то первый аргумент должен быть строковым представлением целого числа в системе счисления с указанным основанием base . Разрешается использовать системы счисления с основаниями от 2 до 36 . При этом префикс 0b , 0o или 0x у строкового представления числа можно опускать. Если же точно известно, что в строковом представлении числа присутствует соответствующий префикс, второму аргументу разрешается передавать ноль, т.к. интерпретатор сможет определить систему счисления переводимого числа по указанному префиксу. В случае невозможности преобразования строки в целое число функция возбуждает соответствующее исключение (см. пример №2 ).

Пример №2. Перевод целых чисел между СС.

Итак, функции bin(int_num) , oct(int_num) и hex(int_num) принимают целые числа и возвращают строковые представления этих чисел в соответствующих системах счисления. Если же требуется обратное преобразование в десятичную систему, то следует передавать числа функции int(num_str, base=10) , предварительно приведя число к строке ( num_str = str(num) ) и указав основание системы счисления переводимого числа.

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

Далее. Целые числа в Питоне отличаются тем, что их размер в принципе ограничивается лишь доступной памятью. Т.е. они поддерживают длинную арифметику и могут быть сколь угодно большими (см. пример №3 ). При этом следует помнить, что при обработке очень больших чисел приходится жертвовать скоростью их обработки.

Пример №3. Пример очень большого целого числа.

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

Таблица №4. Список битовых операций, применимых к целым числам.

Также у типа int имеется несколько дополнительных методов:

• int.bit_length() – метод возвращает количество бит, которое необходимо для представления числа в памяти в двоичном виде, без учета знака и незначащих (лидирующих) нулей;
• int.to_bytes(length, byteorder, *, signed=False) – метод возвращает массив байтов, который соответствует данному числу;
• int.from_bytes(bytes, byteorder, *, signed=False) – метод класса, который возвращает целое число, соответствующее указанному массиву байтов.

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

Вещественные числа

Что касается записи литералов вещественных чисел (по-другому чисел с плавающей точкой), то в Python для них используется привычный нам математический синтаксис: сперва записывается знак числа (плюс можно не указывать), затем последовательность цифр целой части, разделительная точка и последовательность цифр дробной части. Например, 0.33 , .33 , 0.0 , .0 , -123.45 , -.123 . Также допустима запись вещественных чисел в экспоненциальной форме. При этом для представления степени 10 n используется латинская буква E в верхнем или нижнем регистре (т.е. e или E ), следующий за ней необязательный знак плюс или обязательный знак минус, а также сам показатель степени в виде положительного целого числа или нуля (см. пример №5 ).

Пример №5. Литералы вещественных чисел в Python.

В отличие от целых чисел вещественные не поддерживают длинную арифметику. В обычных условиях их точность ограничивается максимум 17 значащими цифрами. Поэтому для очень маленьких и очень больших вещественных чисел получаются весьма неточные результаты (см. пример №6 ). Если же в расчетах необходима высокая точность представления вещественных чисел, следует использовать, например, модуль decimal , позволяющий задавать требуемую точность результата (опять же, за счет снижения скорости обработки таких чисел).

Пример №6. Точность представления вещественных чисел в Python.

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

Пример №7. Побочные эффекты сложения вещественных чисел в Python.

Как видим, на первый взгляд результат действительно получился неожиданным (не забываем про кнопку «Результат» ). Однако все верно. Ведь в данном случае при переводе десятичных чисел в двоичную систему компьютер не смог перевести их точно, округлив результат так, чтобы получившееся двоичное число поместилось в пределах выделяемого для хранения вещественного числа объема памяти. В результате у нас получилось число несколько меньшее, чем 0.8 . Но, повторимся, это не проблема Python , это проблема математики и невозможности во всех случаях осуществить точный перевод чисел из одной системы счисления в другую.

Не стоит сравнивать вещественные числа, доверяя их точности до последнего знака.

В заключение данного пункта перечислим дополнительные методы типа float .

• float.as_integer_ratio() – метод возвращает кортеж из пары целых чисел, которые представляют собой числитель и знаменатель наименьшей дроби, равной данному вещественному числу. Если вещественное число отрицательное, то первое число в возвращаемом кортеже будет со знаком минус. При этом второе число всегда положительное (см. пример №8 ).
• float.is_integer() – метод возвращает True , если дробная часть вещественного числа равна нулю.
• float.hex() – метод возвращает строковое представление числа с плавающей точкой в шестнадцатеричной системе счисления. При этом следует иметь в виду, что экспонента в таком представлении обозначается буквой p , т.к. буква e представляет собой допустимый символ в 16 -ной системе счисления.
• float.fromhex(float_num_str) – этот метод класса осуществляет преобразование строкового представления вещественного числа float_num_str в шестнадца­теричной системе счисления обратно в вещественное число в десятичной системе счисления.

Пример №8. Дополнительные методы типа float.

Комплексные числа

Комплексные числа в Python представлены типом complex , который хранит два вещественных числа: первое представляет собой действительную часть комплексного числа, а второе – мнимую. Как и принято в математике, действительная и мнимая части литерала комплексного числа объединяются знаком плюс или минус (см. пример №9 ). Однако за мнимой частью в Python следует символ j , как это принято в инженерии (в математике мнимая единица обозначается через i ).

Пример №9. Литералы комплексных чисел в Python.

Как видно из примера, если действительная часть комплексного числа равна 0 , ее можно опустить. Кроме того, отдельные части комплексного числа доступны в виде атрибутов real и imag , а получить сопряженное данному комплексное число можно изменив знак мнимой части при помощи метода complex.conjugate() .

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

Математические операции в Python

Все известные нам со школы математические операции полностью поддерживаются в Python . Перечислим их и рассмотрим примеры.

• x + y – сложение двух чисел.
• x — y – вычитание двух чисел.
• x * y – умножение двух чисел.
• x / y – деление двух чисел. При делении вещественных и целых чисел (даже без остатка) результат всегда является вещественным числом. Если же в делении присутствуют комплексные числа, интерпретатор возвращает комплексный результат (см. пример №10 ).
• x // y – деление с округлением вниз. Например, 1//2 = 0 , -1//2 = -1 , 1//-2 = -1 , -1//-2 = 0 .
• x % y – операция возвращает остаток от деления целых и вещественных чисел. Если оба числа целые, то возвращается целочисленный остаток (тип int ). Например, 5%3 = 2 , -5%3 = 1 (т.к. -5 = 3*(-2) + 1 ), 6%3 = 0 . Если хотя бы одно число вещественное, остаток от деления также возвращается в вещественном виде (тип float ), при чем из-за неточности представления вещественных чисел результат может оказаться неточным. Например, 5.2%3 = 2.2 (все в порядке), -5.2%3 = 0.7999999999999998 (получили неточный результат, хотя ожидали 0.8 , т.к. -5.2 = 3*(-2) + 0.8 ). Что касается комплексных чисел, то для них операция неприменима.
• +x – операция используется в основном для повышения удобочитаемости кода, т.к. по факту она ничего не делает.
• -x – инверсия знака числа отличного от нуля, т.е. изменение плюса на минус или наоборот. Для нуля ничего не происходит.
• x ** y – возведение в степень. Отметим, что 0**0 = 1 .

Пример №10. Базовые математические операции в Python.

Что касается математических выражений, в которых используются сразу несколько операций, то для их группировки предназначены круглые скобки (см. пример №11 ). При этом внутри скобок приоритет отдается сперва возведению в степень ( x**y ), затем равносильно умножению ( x*y ), делению ( x/y ), делению с округлением вниз ( x//y ) и получению остатка от деления ( x%y ); в конце равнозначно выполняются сложение ( x + y ) и вычитание ( x — y ). Более подробно о приоритете операторов в Python (и не только математических) мы поговорим позже.

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

Пример №11. Математические выражения в Python.

Обратите внимание, что при наличии в одном выражении целых и вещественных чисел, интерпретатор при необходимости осуществляет приведение целых чисел к типу float , т.е. к более объемлющему типу (в математике целые числа являются подмножеством вещест­вен­ных, а те в свою очередь принадлежат множеству комплексных чисел).

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

• divmod(x, y) – возвращает кортеж (x//y, x%y) . При этом для комплексных чисел она не предназначена.
• pow(x, y) – возвращает x в степени y (аналог x ** y ).
• abs(x) – возвращает абсолютное значение (модуль) числа x .
• round(x, n) – округляет число до n -го разряда после запятой. Если аргумент n не указан, то число округляется до ближайшего целого.
• max(num_1, num_2, . num_n) – возвращает максимальное из двух и более чисел.
• min(num_1, num_2, . num_n) – возвращает минимальное из двух и более чисел.
• sum(num_1, num_2, . num_n) – возвращает сумму двух и более чисел.
• int(x) – приведение числа к типу int .
• float(x) – приведение числа к типу float .
• complex(re, im=0) – приведение к типу complex . Аргумент im (мнимая часть будущего комплексного числа) можно не передавать, тогда он по умолчанию будет равен нулю.

Пример №12. Встроенные математические функции в Python.

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

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

• x < y – выражение вернет True , если x строго меньше y .
• x > y – выражение вернет True , если x строго больше y .
• x <= y – выражение вернет True , если x меньше или равно y .
• x >= y – выражение вернет True , если x больше или равно y .
• x == y – выражение вернет True , если x равно y (в программировании один знак равно означает присвоить , поэтому для обозначения равенства используются два знака равно).
• x != y – выражение вернет True , если x не равно y .

Использование операторов сравнения показано в примере №13 .

Пример №13. Операторы сравнения чисел в Python.

В дополнение к базовому оператору присваивания = в Python применяется целый ряд комбинированных операторов присваивания, которые объединяют операцию присваивания с другой операцией. В общем случае выражение присваивания с комбини­рованным оператором x op= y можно считать сокращенной записью выражения x = x op y , где вместо op следует подставлять один из арифметических операторов. Например, x += y является сокращенной записью выражения x = x + y , в котором к значению переменной x прибавляется значение переменной y , после чего результат присваивается переменной x . Использование некоторых комбинированных операторов присваивания показано в примере №14 .

Пример №14. Комбинированные операторы присваивания в Python.

Конечно же мы перечислили не все комбинированные операторы присваивания, имеющиеся в Python . Весь перечень будет представлен в таблице в следующей главе, посвященной выражениям и операторам. Сейчас же мы рассмотрим ряд математических функций модуля math , поставляющегося в комплекте стандартной библиотеки Python .

Модуль math

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

Для начала давайте рассмотрим представленные в модуле math математические константы и функции проверки чисел на принадлежность к ним.

• math.pi – представляет значение числа π с точностью, которая зависит от конкретной платформы. Мы его помним, как число 3.14 .
• math.tau ( чит. тау) – представляет удвоенное значение числа π с точностью, которая зависит от конкретной платформы. Т. о. τ – это отношение радиуса окружности к ее длине. Прибли­зительно оно равно 6.28 .
• math.e – представляет значение числа e с точностью, которая зависит от конкретной платформы. Мы его помним, как число 2.72 .
• math.inf (от англ. infinity) – представляет положительную бесконечность. Отметим, что значение является типом float и может быть получено вызовом конструктора float(‘inf’) . Для получения отрицательной бесконечности следует использовать унарный оператор — (см. пример №15 ). К значению inf в математике приводит, например, операция деления на 0 .
• math.nan (от англ. not a number) – представляет значение не число , которое также является типом float и может быть получено вызовом конструктора float(‘nan’) . К значению nan приводят недопустимые математические операции (например, извлечение корня четной степени из отрицательного числа на множестве вещественных чисел) или выход за допустимый диапазон значений для данной математической функции.
• math.isinf(x) – возвращает True , если x является отрицательной или положительной бесконечностью, или False в противном случае.
• math.isnan(x) – возвращает True , если x является значением nan , или False в противном случае.
• math.isfinite(x) – возвращает False , только если x является nan , inf или -inf . Во всех остальных случаях функция возвращает True .

Пример №15. Математические константы модуля math.

Что касается конкретно функций модуля math , то в нем представлены различные функции теории чисел, степенные, логарифмические, тригонометрические, гиперболические и ряд других функций. Все мы их здесь рассматривать не будем, однако краткое описание некоторых из них приведем в списке ниже. Остальные в случае необходимости всегда можно с легкостью найти в разделе «Numeric and Mathematical Modules» справочника стандартной библиотеки в описании модуля math (или cmath для комплексных чисел). Итак.

• math.ceil(x) – возвращает x , округленное вверх до ближайшего целого (см. пример №16 ).
• math.floor(x) – возвращает x , округленное вниз до ближайшего целого.
• math.trunc(x) – возвращает целую часть x , полностью отсекая дробную.

Пример №16. Функции модуля math (часть 1).

• math.factorial(x) – возвращает факториал неотрицательного целого числа x . Отметим, что факториалы чисел 0 и 1 принимаются равными 1 .
• math.sqrt(x) – возвращает квадратный корень из неотрицательного числа x (см. пример №17 ).
• math.log(x[, base]) – возвращает логарифм числа x по основанию base . Аргумент base можно опустить, тогда функция вернет натуральный логарифм числа x .

Пример №17. Функции модуля math (часть 2).

• math.sin(x) – возвращает синус угла x , значение которого задано в радианах. Отметим, что для косинуса угла функция имеет вид math.cos(x) (см. пример №18 ).
• math.tan(x) – возвращает тангенс угла x , значение которого задано в радианах.
• math.asin(x) – возвращает арксинус числа x . Для аркосинуса нужно использовать функцию math.acos(x) , а для арктангенса – math.atan(x) .
• math.degrees(x) – преобразует угол x из радиан в градусы.
• math.radians(x) – преобразует угол x из градусов в радианы.

Пример №18. Функции модуля math (часть 3).

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

Модуль decimal

Как мы уже знаем, числа типа float имеют весьма ограниченную точность. И хотя во многих случаях это не существенно, бывают ситуации, когда требуется повышенная точность вычислений, пусть даже и в ущерб производительности. В таких случаях нам на помощь приходит модуль decimal , который реализует неизменяемый числовой тип Decimal , представляющий числа с фиксированной точностью (см. пример №19 ).

Пример №19. Создание чисел фиксированной точности.

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

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

Числа типа Decimal обычно используются в определенном контексте, который подразумевает использование установленной точности представления, методики округления (вверх, вниз и т.д.) и некоторых других настроек (см. пример №20 ).

Пример №20. Изменение точности представления чисел Decimal.

Все настройки среды для арифметических операций получаемые при помощи метода decimal.getcontext() доступны для изменения. Кроме того, для установки нового контекста можно использовать метод decimal.setcontext() . С этим и некоторыми другими методами для работы с контекстами вы можете ознакомиться в модуле decimal стандартной библиотеки (см. раздел «Numeric and Mathematical Modules» ).

Отметим, что все арифметические операции, включая комбинированные, применимы и к числам Decimal . Однако модуль math для них неприменим. В тоже время некоторые функции, присутствующие в модуле math , реализованы как методы типа Decimal (см. пример №21 ).

Пример №21. Операции с числами Decimal.

Модуль fractions

Еще одним числовым типом в Python является тип Fraction . Он реализует объекты рациональных чисел, которые явным образом хранят числитель и знаменатель рациональной дроби (см. пример №22 ), что опять же при необходимости помогает избежать недостатков вещественных чисел.

Пример №22. Создание рациональных чисел.

В примере мы создали объекты рациональных чисел, указав в конструкторе Fraction в первом выражении числитель и знаменатель, а во втором передав ему вещественное число и строковое представление вещественного числа. Кроме того, рациональную дробь можно создать и конвертацией типа Decimal . В любом случае после создания объекты рациональных чисел могут участвовать в арифметических операциях, как обычные числа (см. пример №23 ).

Пример №23. Операции с рациональными числами.

Познакомиться с рациональными числами и их методами более подробно вы можете в модуле fractions стандартной библиотеки Python (см. раздел «Numeric and Mathematical Modules» ).

Краткие итоги параграфа

• Числа в Python представлены тремя базовыми типами: целые числа int , числа с плавающей точкой float и комплексные числа complex . Также посредством стандартной библиотеки доступны два расширения в виде чисел с фиксированной точностью Decimal и рациональных чисел Fraction .
• Для записи литералов целых чисел используется десятичная система счисления, однако разрешается записывать их в двоичной (например, 0b101 ), восьмеричной (например, -0o175 ) и шестнадцатеричной (например, 0xF5A ) системах счисления. Для перевода целых чисел из одной системы счисления в другую предназначены встроенные функции bin(int_num) , oct(int_num) , hex(int_num) , int(num_str, base=10) .
• Целые числа поддерживают длинную арифметику и могут быть сколь угодно большими. При этом следует помнить, что при обработке очень больших чисел приходится жертвовать скоростью их обработки.
• Для записи литералов вещественных чисел используется привычный нам математический синтаксис, например, -2.57 , 0.0 , .28 (ноль перед точкой можно опускать). Также допустима запись вещественных чисел в экспоненциальной форме, например, 1.2345e2 (т.е. 1.2345*10 2 ) или -1.2345E-3 (т.е. -1.2345*10 -3 ).
• В обычных условиях точность вещественных чисел ограничивается максимум 17 значащими цифрами. Поэтому не стоит сравнивать их, доверяя точности до последнего знака.
• Комплексные числа в Python хранят два вещественных числа: первое представляет собой действительную часть комплексного числа, а второе – мнимую. Например, -0.4+7j , 2-1.45j или 3.1j (нулевую действительную часть можно опускать).
• В Python поддерживаются все известные нам со школы математические операции: сложение x + y , вычитание x — y , умножение x*y , деление x/y , деление с округлением вниз x//y , получение остатка от деления x%y , возведение в степень x**y . Стоит помнить, что некоторые операции не применимы к комплексным числам.
• В дополнение к базовому оператору присваивания = в Python применяется целый ряд комбинированных операторов присваивания, которые объединяют операцию присваивания с другой операцией. Например, += , -= , *= , /= , //= , %= , **= . Как видим, в общем случае выражение присваивания с комбини­рованным оператором x op= y можно считать сокращенной записью выражения x = x op y , где вместо op следует подставлять один из арифметических операторов.
• Для сравнения чисел используются операторы < , > , <= , >= , == (равно), != (не равно).
• Помимо стандартных арифметических операций имеется и ряд полезных встроенных функций для работы с числами: divmod(x, y) – возвращает кортеж (x//y, x%y) , pow(x, y) – возвращает x в степени y , abs(x) – возвращает модуль числа x , round(x, n) – округляет число до n -го разряда после запятой, max(num_1, num_2, . num_n) , min(num_1, num_2, . num_n) и sum(num_1, num_2, . num_n) – соответственно возвращают максимальное, минимальное и сумму из двух и более чисел.
• Если встроенных функций недостаточно, можно воспользоваться расширением math стандартной библиотеки, которое обеспечивает доступ к широкому кругу математических функций и констант, которые определены стандартом языка C . Для комплексных чисел следует использовать модуль cmath .
• Для случаев, когда требуется повышенная точность вычислений, в Python предусмотрены дополнительные типы числовых объектов: числа с фиксированной точностью Decimal , которые позволяют устанавливать требуемую точность вычислений, способ округления и некоторые другие параметры, а также рациональные числа Fraction , которые явным образом хранят числитель и знаменатель рациональной дроби. Оба модуля доступны в стандартной библиотеке Python в разделе «Numeric and Mathematical Modules» .

Вопросы и задания для самоконтроля

1. Какие из представленых литералов чисел относятся к типу int , а какие к типу float : 3.4 , 0 , 5.0 , 0.0 , 123+4.1j , 795 ? Проверьте типы программно. Показать решение.

Ответ. Тип int : 0 и 795 . Тип float : 3.4 , 5.0 , 0.0 .

2. Определите системы счисления целых чисел 0x1101 , 0b1101 , 0o755 , 0X755 и 755 , записанные в исходном коде программы. Показать решение.

Ответ. Двоичная СС: 0b1101 ; восьмеричная СС: 0o755 ; десятичная СС: 755 , шестнадцатеричная СС: 0x1101 и 0X755 .

3. Какая операция над целыми числами никогда не дает в результате целое число? Показать решение.

Ответ. Результат деления целых чисел всегда имеет тип float , даже при делении без остатка. Например, 15/5 вернет 3.0 , а не 3 .

4. Как можно получить действительную и мнимую части комплексного числа? А как получить число, сопряженное к данному комплексному числу? Показать решение.

Ответ. Отдельные части комплексного числа доступны в виде атрибутов real и imag , а получить сопряженное данному комплексное число можно изменив знак мнимой части при помощи метода complex.conjugate() .

5. Вычислите устно и программно значения выражений 2*(3 + 4) и 2*3 + 4 . Объясните результаты. Показать решение.

Ответ. В Python как и в математике первыми выполняются действия в скобках, поэтому 2*(3 + 4) = 14 . Если скобки отсутствуют, то первыми выполняются операции с более высоким приоритетом. А так как приоритет умножения выше приоритета сложения, то 2*3 + 4 = 10 .

6. Каким будет тип результата вычисления выражения 7 — 3 + 2.0 и почему? Проверьте свой ответ программно. Показать решение.

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

7. Каким будет остаток от деления числа 63 на число 5 ? Проверьте свой ответ программно. Показать решение.

8. Как получить доступ к функциям модуля math ? Показать решение.

Ответ. Нужно импортировать его при помощи инструкции import math .

9. Исправьте в коде пять ошибок (по одной в каждом блоке). Показать решение.

10. Дополнительные тесты по теме расположены в разделе «Числа и математические выражения» нашего сборника тестов.

11. Дополнительные упражнения и задачи по теме расположены в разделе «Числа и математические выражения» нашего сборника задач и упражнений.

Числовые и буквенные выражения

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

17 декабря 2020

· Обновлено 21 октября 2022

Числовые выражения: что это

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

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

Например:

Это простые числовые выражения.

Более сложные числовые выражения состоят из нескольких чисел и знаков арифметических действий:

Число, которое мы получаем после выполнения всех арифметических действий в числовом выражении, называют значением этого выражения.

Вспомним, какие виды арифметических действий есть.
+ — знак сложения, найти сумму.
— — знак вычитания, найти разность.
* — знак умножения, найти произведение.
: — знак деления, найти частное.

11 — значение числового выражения 5 + 6.

48 — значение числового выражения 6 * 8.

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

Сначала выполняется действие, записанное в скобках.

Затем выполняются действия деления и умножения слева направо.

В последнюю очередь выполняются действия сложения и вычитания слева направо.

Онлайн-курсы математики для детей помогут подтянуть оценки, подготовиться к контрольным, ВПР и экзаменам.

Пример 1. Найдите значение числового выражения: 3 * (2 + 8) — 4

Пример 2. Найдите значение числового выражения: (6 + 7) * (13 + 2)

(6 + 7) * (13 + 2) = 195

Часто бывает нужно сравнить два числовых выражения.

Сравнить числовые выражения — значит найти значения каждого выражения и сравнить их.

Пример 1. Сравните два числовых выражения: 6 + 8 и 2 * 2

Сначала находим значение первого выражения:

Затем находим значение второго выражения:

Сравниваем получившиеся результаты:

Пример 2. Сравните следующие числовые выражения:
5 * (12 — 2) — 7 и (115 + 9) — (7 — 3)

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

5 * (12 — 2) — 7 = 43

Затем находим значение:

Сравниваем полученные результаты:

5 * (12 — 2) — 7 < (115 + 9) — (7 — 3).

Буквенные выражения

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

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

Получается, что буквенное выражение — это числовое выражение, в котором есть не только числа, но и буквы.

Это буквенные выражения. Для записи буквенных выражений используют буквы латинского алфавита.

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

Сначала следует прочитать его полностью.

Затем оно записывается.

Третьим шагом идет подстановка значения неизвестного в выражение.

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

Пример 1. Найдите значение выражения при x = 4: 5 + x.

1. Читаем: найдите сумму числа 5 и x.
2. Подставляем вместо неизвестного x число 4.
3. Вычисляем: 5 + 4 = 9.

Пример 2. Найдите значение выражения: (4 + a) * (2 + x) при а = 2 и х = 5.

Читаем: найдите произведение суммы числа 4 и а и суммы числа 2 и x.

Подставляем вместо неизвестного a число 2.

Вычисляем 4 + 2 = 6.

Подставляем вместо неизвестного x число 5.

Вычисляем 2 + 5 = 7.

Находим произведение 6 * 7 = 42.

Записываем результат: (4 + 2) * (2 + 5) = 42.

Выражения с переменными

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

Например, в выражении x + a — 8

Если вместо переменных подставить числа, то буквенное выражение x + a — 8 станет числовым выражением. Вот так:

подставляем вместо переменной x число 5, а вместо переменной a — число 10, получаем 5 + 10 — 8.

Числа, которые подставляют вместо переменных — это значения переменных. В нашем примере это числа 5 и 10.

После подстановки значения переменных находим значение x + a — 8 = 5 + 10 — 8 = 7.

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

Число и переменная записаны без знака арифметического действия. Так коротко записывается умножение.

5x — это произведение числа 5 и переменной x.

4a — это произведение числа 4 и переменной a.

Числа 4 и 5 называют коэффициентами.

Коэффициент показывает, во сколько раз будет увеличена переменная.

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