Как написать минус в питоне

Как перевернуть знак?

В python, чтобы поменять знак какого-либо числа в переменной num , надо записать -num :

print(-a) # -5 print(-b) # 2 

Как сделать положительное число?

Быстрый способ

Чтобы перевести любое число в ранг положительных, нужно написать abs(num) :

print(abs(a)) # 5 print(abs(b)) # 2 

Почему этот способ самый быстрый?

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

Математический способ

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

print((a**2)**0.5) # 5 print((b**2)**0.5) # 2 

from math import pow, sqrt print(sqrt(pow(a, 2))) # 5 print(sqrt(pow(b, 2))) # 2 

Как это работает?

Чтобы получить модуль числа (то же число, только всегда положительное) число надо возвести в квадрат и извлечь квадратный корень.
В питоне можно по-разному записать эти операции, один способ — ** (возведение в степень), другой — воспользоваться встроенной библиотекой math .
Возведение в 2 степень — возведение в квадрат, а в 0.5 — эквивалентно извлечению квадратного корня.
Также для возведения в степень можно использовать функцию math.pow , а для извлечения квадратного корня — math.sqrt .

Вывод

Наш выбор для создания положительного числа — использовать функцию abs !
Соединяя инверсию знака с созданием положительного числа мы получаем следующее:

Чтобы перевести любое число num в ранг отрицательных, надо записать -abs(num)

print(-abs(a)) # -5 print(-abs(b)) # -2 

Ремарки

• Для простоты понимания я опустил деталь, что при использования математического способа результат — float , а не int , и при выводе .0 добавляется к числу.
• Изначально в вопросе просилось сделать отрицательное число.

Как сделать так чтобы при вычитании не уходило в минус?

Оберните код в вопросе тегом code для корректного отображения.

Также рекомендую убрать тег «программирование», он тут лишний.

Алан Гибизов @phaggi Куратор тега Python
Было бы неплохо показать, как вы пробовали решить свою проблему.
Решения вопроса 1
Сергей Еремин @Sergei_Erjemin
Улыбайся, будь самураем.
Очевидно, что проверить уйдёт в минус или нет. Например так:

kick = random.randint(0, maxkick if maxkick < player2['oranges'] else player2['oranges']) player2['oranges'] = player2['oranges'] - kick

А вообще зависит от того какое распределение значения kick нужно
Ответ написан более двух лет назад
yafir @yafir Автор вопроса

У меня пишет такую ошибку:
---------------------------------------------------------------------------
NameError Traceback (most recent call last)
in ()
----> 1 kick = random.randint(0, maxkick if maxkick > player2['oranges'] else player2['oranges'])
2 player2['oranges'] = player2['oranges'] - kick

NameError: name 'random' is not defined

Сергей Еремин @Sergei_Erjemin
ну так импорт рандом не сделал же.

import random kick = random.randint(0, maxkick if maxkick < player2['oranges'] else player2['oranges']) player2['oranges'] = player2['oranges'] - kick

И в первой версии когда конечно > -- не правильно. Нужно
Ответы на вопрос 2

Алан Гибизов @phaggi Куратор тега Python
лужу, паяю, ЭВМы починяю

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

Ответ написан более двух лет назад
Комментировать
Нравится Комментировать
Если вопрос в том, как не уходить в минус (независимо от того, что вычитаем), то можно так:

player2['oranges'] = max(player2['oranges'] - kick, 0)

Ответ написан более двух лет назад
Комментировать
Нравится Комментировать
Ваш ответ на вопрос

Войдите, чтобы написать ответ

• Python
• +1 ещё

Как заставить селениум просто открыть страницу и ждать?

• 1 подписчик
• час назад
• 143 просмотра

Как написать минус в питоне

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

+ Сложение двух чисел:

print(6 + 2) # 8

print(6 - 2) # 4

print(6 * 2) # 12

print(6 / 2) # 3.0

print(7 / 2) # 3.5 print(7 // 2) # 3

print(6 ** 2) # Возводим число 6 в степень 2. Результат - 36

print(7 % 2) # Получение остатка от деления числа 7 на 2. Результат - 1

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

Пусть у нас выполняется следующее выражение:

number = 3 + 4 * 5 ** 2 + 7 print(number) # 110

Здесь начале выполняется возведение в степень (5 ** 2) как операция с большим приоритетом, далее результат умножается на 4 (25 * 4), затем происходит сложение (3 + 100) и далее опять идет сложение (103 + 7).

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

number = (3 + 4) * (5 ** 2 + 7) print(number) # 224

Следует отметить, что в арифметических операциях могут принимать участие как целые, так и дробные числа. Если в одной операции участвует целое число (int) и число с плавающей точкой (float), то целое число приводится к типу float.

Арифметические операции с присвоением

Ряд специальных операций позволяют использовать присвоить результат операции первому операнду:

• += Присвоение результата сложения
• -= Присвоение результата вычитания
• *= Присвоение результата умножения
• /= Присвоение результата от деления
• //= Присвоение результата целочисленного деления
• **= Присвоение степени числа
• %= Присвоение остатка от деления

number = 10 number += 5 print(number) # 15 number -= 3 print(number) # 12 number *= 4 print(number) # 48

Округление и функция round

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

first_number = 2.0001 second_number = 5 third_number = first_number / second_number print(third_number) # 0.40002000000000004

В данном случае мы ожидаем получить число 0.40002, однако в конце через ряд нулей появляется еще какая-то четверка. Или еще одно выражение:

print(2.0001 + 0.1) # 2.1001000000000003

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

first_number = 2.0001 second_number = 0.1 third_number = first_number + second_number print(round(third_number)) # 2

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

Функция round() также может принимать второе число, которое указывает, сколько знаков после запятой должно содержать получаемое число:

first_number = 2.0001 second_number = 0.1 third_number = first_number + second_number print(round(third_number, 4)) # 2.1001

В данном случае число third_number округляется до 4 знаков после запятой.

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

# округление до целого числа print(round(2.49)) # 2 - округление до ближайшего целого 2 print(round(2.51)) # 3

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

print(round(2.5)) # 2 - ближайшее четное print(round(3.5)) # 4 - ближайшее четное

Округление производится до ближайшего кратного 10 в степени минус округляемая часть:

# округление до двух знаков после запятой print(round(2.554, 2)) # 2.55 print(round(2.5551, 2)) # 2.56 print(round(2.554999, 2)) # 2.55 print(round(2.499, 2)) # 2.5

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

# округление до двух знаков после запятой print(round(2.545, 2)) # 2.54 print(round(2.555, 2)) # 2.56 - округление до четного print(round(2.565, 2)) # 2.56 print(round(2.575, 2)) # 2.58 print(round(2.655, 2)) # 2.65 - округление не до четного print(round(2.665, 2)) # 2.67 print(round(2.675, 2)) # 2.67

Подобно о проблеме можно почитать к документации.

Математические (арифметические) операторы. Примеры

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

• ** – возведение в степень;
• –x – унарный минус;
• / , // – обычное деление, деление с округлением вниз (одинаковый приоритет);
• % – остаток от деления;
• * – умножение;
• – – вычитание;
• + – сложение.

2. Для каких категорий числовых типов можно применять математические операторы?

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

• целочисленных (типов);
• вещественных;
• комплексных.

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

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

Здесь возможны два случая:

• операнды имеют одинаковый тип. В этом случае тип результата операции есть этот же тип. Исключение составляет операция деления / целочисленных операндов. Если оба операнда целого типа, то результат операции деления будет иметь вещественый тип (число с плавающей запятой);
• операнды имеют разные типы. В этом случае тип результата операции будет определяется в следующей последовательности: сначала тип обоих операндов приводится к типу более сложного операнда; затем для операндов применяется математика, специфическая для этого типа.

Интерпретатор Python определяет сложность типов в такой последовательности (от простого к более сложному):

• целый тип;
• вещественный тип;
• комплексный тип.

В Python 2.6 (при необходимости) обычные целые числа могут быть преобразованы в длинные целые числа. В Python 3.0 и выше этого ранжирования уже нет и все целые числа представлены как длинные целые числа.

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

4. Операция возведения в степень ** . Пример

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

# Операция ** - возведение в степень # 1. Для целых чисел a = 3 b = 2 c = a**b # c = 9 print("c color: #ff0000;"># 2. Для вещественных чисел a = 2.5 b = 3 c = a**b # c = 15.625 print('c = ', c) # 3. Для комплексных чисел x = 1 - 2j y = -4j z = x**y # z = (-0.011895629765035814+0.0009211666704635043j) print('z = ', z) # 4. В 16-й системе исчисления a = 0xA1 b = 0x03 c = a**b # c = 4173281 - результат в 10-й системе исчисления d = hex(c) # d = 0x3fade1 - результат в 16-й системе исчисления print('c = ', c) print('d = ', d) # 5. В 8-й системе исчисления a = 0o356 b = 0o2 c = a**b # c = 56644 - результат в 10-й системе исчисления d = oct(c) # d = 0o156504 - результат в 8-й системе исчисления print('c = ', c) print('d = ', d) # 6. В 2-й системе исчисления a = 0b101 b = 0b110 c = a**b # c = 15625 - результат в 10-й системе исчисления d = bin(c) # d = 0b11110100001001 - результат в 2-й с/и print('c = ', c) print('d = ', d)

5. Операции сложения ( + ), вычитания ( – ). Примеры

Операции сложения + и вычитания – являются бинарными и используются для любого числового типа.

# Операция сложения +, вычитания - # 1. Сложение, вычитание целых чисел a=3 b=5 c = a+b #c = 8 d = a-b # d = -2 # 2. Сложение, вычитание целого и вещественного чисел a = 2.5 b = 7 c = a + b # c = 9.5 - результат - вещественное число d = a - b # d = -4.5 - результат - вещественное число # 3. Сложение, вычитание вещественных чисел x = 8.99902 y = 9.112356 z = x+y # z = 18.111376 v = x-y # v = -0.11333600000000033 # 4. Сложение, вычитание комплексных чисел, результат - комплексное число a = 7+8j b = 3-2j c = a + b # c = (10+6j) d = a - b # d = (4+10j) # 5. Сложение, вычитание чисел в шестнадцатеричной системе исчисления a = 0xFF5 b = 0xC9 c = a + b # c = 4286 - в десятичной системе исчисления d = a - b # d = 3884 # 6. Сложение, вычитание чисел в восьмеричной системе исчисления a = 0o730 b = 0o50 c = a + b # c = 512 d = a - b # d = 432 # 7. Сложение, вычитание чисел в двоичной системе исчисления a = 0b0110110 b = 0b0001010 c = a + b # c = 64 - результат в десятичной системе исчисления d = a - b # d = 44

6. Операции умножения ( * ) и обычного деления ( / ). Пример

Операции умножения * и деления / есть бинарными. Эти операции используются с операндами любого числового типа (целого, вещественного, комплексного).

# Операции умножения * и обычного деления / # 1. Для целых чисел a = 7 b = 4 c = a*b # c = 28 - целый результат d = a/b # d = 1.75 - вещественный результат # 2. Для вещественных чисел a = 7.5 b = 3.2 c = a*b # c = 24.0 - вещественный результат d = a/b # d = 2.34375 # 3. Для комплексных чисел x = 2 + 2j y = 3 - 1j z = x*y # z = (8+4j) v = x/y # v = (0.4+0.7999999999999999j) # 4. В 16-й системе исчисления a = 0xaff b = 0x5b c = a*b # c = 256165 - результат в 10-й системи исчисления d = a/b # d = 30.934065934065934 - вещественное число # 5. В 8-й системе исчисления a = 0o356 b = 0o2 c = a*b # c = 476 d = a/b # d = 119.0 # 6. В 2-й системе исчисления a = 0b111 # a = 35 b = 0b101 # b = 5 c = a*b # c = 35 - результат в 10-й системе исчисления d = a/b # d = 1.4 - результат в 2-й системе исчисления

7. Особенности операции деления / для различных типов чисел. Пример

Если в операции деления / один из операндов является вещественного типа, то результат будет также вещественного типа (дробное число).

При использовании операции деления для целочисленных операндов в таких языках как C/C ++, C#, Java результат операции будет целочисленным. В версиях Python 2.6 и ниже операция деления целочисленных операндов также дает целочисленный результат, то есть после деления

a = 9/6 # a = 1 - версии Python 2.6 и ниже

переменная a = 1.

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

a = 9/6 # a = 1.5 - версии Python 3.0 и выше

переменная a имеет вещественный тип (a = 1.5). Если в версии Python 3.0 и выше при делении целочисленных операндов нужно вернуть целое число, то для этого используется операция деления с округлением вниз // (см. п. 8).

Пример.

# Для целых чисел (целочисленных операндов) a = 7 b = 4 c = a/b # c = 1.75 - результат вещественный a = 9 b = 3 c = a/3 # c = 3.0 - результат также вещественный

8. Операция деления с округлением вниз // . Пример

В версиях Python 2.2 и выше введена операция // деления с округлением вниз, которая в случае целочисленных операндов возвращает результат целого типа. В версиях Python 3.0 и выше эта операция заменяет целочисленное деление с возвращением целочисленного результата.

Пример.

# Операция деления // с округлением вниз, Python 3.7.0 # 1. Для целых чисел a = 8 b = 5 c = a // b # c = 1 a = 17 b = 3 c = a//b # c = 5 - целый результат с округлением вниз # 2. Для вещественного и целого числа x = 6.0 y = 2 z = x//y # z = 3.0 - вещественный результат # 3. Для вещественных чисел x = 5.5 y = 2.5 z = x//y # z = 2.0 - вещественный результат с округлением вниз x = 13.7 y = 2.3333 z = x//y # z = 5.0 - вещественный результат с округлением вниз

9. Операция «унарный» минус ( –x ). Пример

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

# Унарный минус -x a = 15 b = -a # b = -15 - унарный минус a = -12.35 b = -a # b = 12.35 a = 0xFF b = -a # b = -255 - десятичная система исчисления c = hex(b) # c = -0xff a = 0o775 # восьмеричная система исчисления b = -a c = oct(b) # c = -0o775 a = 0b1111001 b = -a # b = -121 - десятичная система исчисления c = bin(b) # c = -0b1111001 - двоичная система исчисления # Комплексное число z = 2 - 8j z = -z # z = (-2+8j)

10. Операция взятия остатка от деления ( % ). Пример

# Операция взятия остатка от деления # 1. Для целых чисел a = 7 b = 4 c = a%b # c = 3 a = 5 b = 9 c = a % b # c = 5 # 2. Для вещественных чисел a = 5.5 b = 2.1 c = a%b # c = 1.2999999999999998 a = -8.1 b = -1.01 c = a%b # c = -0.019999999999999574 # 3. Для шестнадцатеричных чисел a = 0xA8 b = 0x0F c = a%b # c = 3 - результат в десятичной системе d = hex(c) # d = 0x3 - результат в 16-й системе # 4. Для восьмеричных чисел a = 0o15 b = 0o25 c = a % b # c = 13 d = oct(c) # d = 0o15 # 5. Для двоичных чисел a = 0b10011 b = 0b101 c = a%b # c = 4 d = bin(c) # d = 0b100

Связанные темы

• Операторы (операции) для работы с числовыми объектами. Таблица приоритетности операторов
• Смешивание типов. Преобразование типов в операторах
• Операторы сравнения