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

Убираем конкретные символы из строки

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

s="Hello$ Python3$" s1=s.replace("$", "") print (s1) # Результат: Hello Python3
Если мы можем указать ограничение для количества совпадений, чтобы не убирать все символы.
s="Hello$ Python3$" s1=s.replace("$", "", 1) print (s1) # Результат: Hello Python3$
С помощью ' re.sub '
re. sub (pattern, repl, string, count=0, flags=0)
Возвращает строку, полученную путем замены крайних левых неперекрывающихся 
совпадений с шаблоном в строке на значение repl. Если совпадения с шаблоном 
не найдены, возвращается неизмененная строка 
— Из документации Python'а 

Если мы хотим убрать символы, то просто заменяем совпадения на пустую строку. 
s="Hello$@& Python3$" import re s1=re.sub("[$|@|&]","",s) print (s1) # Результат: Hello Python3

Заменяемый шаблон → “[ $ | @ | & ]”
[ ] используется для определения множества
$ | @ | & → будет искать $ или @ или &
Заменяем на пустую строку
Если вышеуказанные символы заменяются найдены, то они заменяются на пустую строку

Убрать все символы, кроме букв
С помощью 'isalpha()'

 isalpha() используется для того, чтобы проверять, состоит ли строка только из букв. Возвращает True если является буквой. Мы будем проходить по каждому символу строки и проверять является ли он буквой.
 Пример 
s="Hello$@ Python3&" s1="".join(c for c in s if c.isalpha()) print (s1) # Результат: HelloPython
 (c for c in s if c.isalpha()) 
Перед нами объект генератор, содержащий все буквы из строки: 
 s1=””.join(c for c in s if c.isalpha()) 
 ””.join будет соединять все символы в одну строку.
С помощью 'filter()'
s = "Hello$@ Python3&" f = filter(str.isalpha, s) s1 = "".join(f) print(s1)
 f = filter(str.isalpha, s) 
Функция filter() будет применять str.isalpha метод для каждого элемента строки, и если получаем истину , то мы возвращаем элемент. В противном случае - пропускаем.
Функция filter() вернет итератор, содержащий все буквы переданной строки, а join() будем "склеиват" все элементы друг с другом.
С помощью 're.sub()'

s = "Hello$@ Python3$" import re s1 = re.sub("[^A-Za-z]", "", s) print (s1) # Результат: HelloPython
Рассмотрим s1 = re.sub(“[^A-Za-z]”, ””, s) 

“[ A-Za-z]”* → Ищет все символы, кроме букв. Если в начале множества указать * , тогда к шаблону будут подходить все те символы, которые НЕ указаны в множестве. (для русских слов используйте [^А-Яа-я] - прим. ред.)
Все символы, удовлетворяющие шаблону будут заменены на пустую строку.
Все символы, кроме букв, будут убраны.

Убрать все символы, кроме букв и чисел
С помощью 'isalnum()'

 isalnum() используется, когда мы хотим определить состоит строка только из чисел или букв.
Пройдемся по каждому символу строки, что-бы выявить нужные символы.
s = "Hello$@ Python3&" s1 = "".join(c for c in s if c.isalnum()) print(s1) # Результат: HelloPython3
С помощью 're.sub()'
s = "Hello$@ Python3&_" import re s1 = re.sub("[^A-Za-z0-9]", "", s) print(s1) # Результат: HelloPython3

“[^A-Za-z0–9]” → Этот шаблон будет искать все символы, кроме букв и цифр.
Все найденные символы будут заменены на пустую строку
Все символы, кроме букв и цифры убраны.

Убрать все числа из строки, с помощью регулярных выражений
С помощью 're.sub()'

s = "Hello347 Python3$" import re s1 = re.sub("[0-9]", "", s) print(s1) # Результат: Hello Python$

[0-9] - цифры от 0 до 9
re.sub(“[0–9]”, ””, s) - если есть совпадения, заменяем на пустую строку

Убираем все символы из строки кроме цифр
С помощью 'isdecimal()'
 isdecimal() возвращает истину, если все символы строки являются цифрами, в противном случае возвращается ложь.

s = "1-2$3%4 5a" s1 = "".join(c for c in s if c.isdecimal()) print(s1) # Результат: 12345
Пороходим по каждому символу строки и проверяем и является ли он цифрой. "".join() соединяет все элементы.
С помощью 're.sub()'
s = "1-2$3%4 5a" import re s1 = re.sub("[^0-9]", "", s) print(s1) # Результат: 12345
Рассмотрим s1 = re.sub(“[^0–9]”, ””, s) 

[^0-9] будет искать все символы кроме от 0 до 9
re.sub(“[^0–9]”, ””, s) все символы кроме цифр будут заменены на пустую строку.

С помощью 'filter()'
s = "1-2$3%4 5a" f = filter(str.isdecimal, s) s1 = "".join(f) print(s1) # Результат: 12345
Рассмотрим f = filter(str.isdecimal, s) 
Функция filter() будет выполнять str.isdecimal метод для каждого символа, если он возвращает истину, то добовляет его в генератор. Затем генератор распаковывается в готовую строку с помощью метода join() .
Примечание
Строки в Python являются неизменяемыми объектами, поэтому все вышеуказаные методы убирает символы из данной строки и возвращает новую, они не меняют состояние оригинальной строки.

Рекомендуем хостинг TIMEWEB
Стабильный хостинг, на котором располагается социальная сеть EVILEG. Для проектов на Django рекомендуем VDS хостинг.
По статье задано0 вопрос(ов) 
Подписка на обсуждение 4

Подписка на раздел 74
Вам это нравится? Поделитесь в социальных сетях!
Как в питоне убрать минус
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
Очень часто возникает необходимость вычисления модуля числа в Python. Рассмотрим, что такое модуль числа, какие есть способы его вычисления. Так же отдельно коснемся комплексных чисел.
Модуль числа
Часто в программировании требуется вычислить абсолютное значение числа. Иначе говоря, отбросить знак.
При вычислении модуля возможны 3 ситуации:

Когда число больше 0. Если взять его по модулю — не изменится.
Модуль нуля так же равен нулю.
У отрицательного числа отбрасываем знак. То есть умножаем его на -1.

Но это все справедливо только для действительных чисел. Чему же тогда будет равен модуль комплексных?
Комплексное число состоит из действительной составляющей и мнимой. Геометрически это можно представить как 2 ортогональные оси: действительную и мнимую. Отмечаем на координатных осях требуемую точку. Модулем будет длина отрезка, проведенного из начала координат в эту точку.

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

Используя стандартную функцию abs.
С помощью функции fabs библиотеки math.
При помощи самостоятельно написанной функции.

Все эти функции работают как в Python 2, так и в Python 3.
abs
Для вычисления в Python модуля числа используется функция abs. Результат функции того же типа, которого был аргумент.
a = -10 b = abs(a) print(b) print(type(b)) 10
fabs
Можно так же воспользоваться функцией fabs из библиотеки math. Библиотеку можно подключить с помощью from math import fabs .
from math import fabs a = -10 b = fabs(a) print(b) print(type(b)) 10.0
Отличие abs от fabs заключается в том, что функция abs возвращает значение того же типа, что и аргумент. Функция же fabs вначале преобразует тип аргумента к вещественному числу.
Свое решение
Если по каким то причинам нет возможности или желания использовать стандартные функции, то можно написать свое решение.
Например, можно вычислить воспользоваться тернарным оператором.
a = -10 b = a if a > 0 else -a print(b) 10
На основе такого условия сделаем свою функцию.
def my_abs(a): return a if a > 0 else -a print(my_abs(-3)) 3
Модуль комплексного числа
Мы разобрались как происходит вычисление с действительными числами. Теперь посмотрим, как в языке программирования Python можно получить модуль комплексного.
Функцией fabs мы не сможем воспользоваться. Если попытаемся это сделать, то получим ошибку приведения комплексного числа к действительному (TypeError).
from math import fabs a = -10-2j b = fabs(a) print(b) Traceback (most recent call last): File "main.py", line 3, in b = fabs(a) TypeError: can't convert complex to float
А вот с помощью abs преобразование удается.
a = -10-2j b = abs(a) print(b) 10.19803902718557
Или же напишем свою функцию:
from math import sqrt def my_abs_complex(c): return sqrt(c.real**2 + c.imag**2) a = -10-2j b = my_abs_complex(a) print(b) 10.198039027185569
Результаты получились одинаковыми. Но нам все равно пришлось подключить библиотеку math для вычисления квадратного корня.
Математические вычисления в Python 3 
Программирование невозможно представить без работы с числами. Размеры экрана, выбор цвета путем присвоения числовых кодов, географическое расположение, деньги и очки, продолжительность видео – для всего этого используются числа.
Потому умение выполнять математические операции очень важно для программирования. Конечно, чем выше у вас навык математических вычислений, тем лучше для вас; однако совсем не обязательно уметь выполнять сложнейшие вычисления, чтобы быть хорошим программистом. Если у вас нет опыта работы в области математики, старайтесь представлять математику как инструмент или как способ улучшить ваше логическое мышление.
Данное руководство научит вас работать с двумя наиболее распространёнными числовыми типами данных Python:

целыми числами (бывают положительными, отрицательными или равными нулю (…, -1, 0, 1, …)).
и числами с плавающей точкой (числа с десятичными знаками (например, 9.0 или -2.25)).

Операторы Python
Оператор – это символ или функция, которая выполняет то или иное действие над данными. К примеру, символ + – это оператор сложения.
В Python присутствуют как общие, так и специальные математические операторы.
Ниже приведена таблица наиболее распространённых математических операторов Python.


Операция
Результат




x + y
Сложение (сумма x и y)


x – y
Вычитание (разница между x и y)


-x
Смена знака x


+x
Тождественность x


x * y
Умножение x на y


x / y
Деление x на y


x // y
Получение целой части от деления x на y


x % y
Остаток от деления x / y


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



Также руководство охватывает использование операторов присваивания.
Сложение и вычитание
Операции сложения и вычитания в Python выполняются точно так же, как и в обычной математике. Вы даже можете использовать Python вместо калькулятора.
Также вы можете объявить переменные и указать их в функции print:
a = 88 
b = 103 
print(a + b) 
191
Целые числа бывают положительными и отрицательными. Попробуйте сложить следующие числа:
c = -36 
d = 25 
print(c + d) 
-11
Числа с плавающей точкой складываются аналогичным образом:
e = 5.5 
f = 2.5 
print(e + f) 
8.0
В результате сложения чисел с плавающей точкой также получается число с плавающей точкой, потому Python выводит 8.0, а не 8.
Синтаксис вычитания отличается от сложения только оператором. Попробуйте отнять 32 из 75.67:
g = 75.67 
h = 32 
print(g - h) 
43.67
Примечание: Если в операции присутствует хотя бы одно число с плавающей точкой, в результате Python также выведет число с плавающей точкой.
Унарные арифметические операции
Унарное математическое выражение состоит только из одного компонента или элемента. В Python плюс и минус вместе со значением могут быть использованы в качестве одного элемента, это позволяет показать тождественность значения (+) или изменить его знак (-).
Тождественность используется нечасто. Плюс можно использовать с положительными числами:
Если вы используете плюс с отрицательным числом, он также вернёт тождественное (в этом случае – отрицательное) число.
Минус позволяет изменить знак. Если вы добавите минус к положительному значению, в результате будет отображено отрицательное значение:
Если добавить минус к отрицательному значению, в результате получится положительное число:
Умножение и деление
Операции умножения и деления, как сложение и вычитание, выполняются в Python так же, как в обычной математике. Для умножения Python использует *, для деления – /.
k = 100.1 
l = 10.1 
print(k * l) 
1011.0099999999999
При делении в Python 3 частное всегда возвращается в виде числа с плавающей точкой, даже если вы делите целые числа:
m = 80 
n = 5 
print(m / n) 
16.0
Это одно из главных различий между Python 2 и Python 3. Python 3 возвращает дробный результат, потому при делении 11 на 2 вы получите 5.5. В Python 2 деление привязано к типам данных, потому при делении целого числа невозможно получить число с плавающей точкой; поэтому при делении 11 на 2 Python 2 возвращает 5.
Читайте также: Python 2 vs Python 3
Когда числа по обе стороны символа деления являются целыми, выполняется деление floor, то есть, для фактора х Python 2 возвращает наибольшее целое число меньше или равное х. К примеру, при делении 5 / 2 таким числом будет 2.
Чтобы выполнить деление floor и получить только целую часть числа, Python 3 использует оператор //. К примеру, разделив 100//40, вы получите 2.
Деление по модулю
Оператор % – это модуль, который возвращает остаток от деления. К примеру, это позволяет найти числа, кратные одному и тому же числу.
o = 85 
p = 15 
print(o % p) 
10
При делении 85 на 15 получается 5 и 10 в остатке.
Попробуйте разделить числа с плавающей точкой:
q = 36.0 
r = 6.0 
print(o % p) 
0.0
Число 36.0 делится на 6.0 без остатка, потому в результате получился 0.0.
Возведение в степень
Оператор ** в Python возводит число в степень. Например, выражение 5 ** 3 значит, что 5 нужно возвести в третью степень. В математике это выглядит так: 5³. В Python можно получить тот же результат (125), умножив 5*5*5.
s = 52.25 
t = 7 
print(s ** t) 
1063173305051.292
Приоритет операций
Как и в математике, в Python нужно помнить о том, что операции выполняются в порядке их приоритета, а не по порядку справа налево.
Сначала выполняется умножение (10*5=50), а затем сложение (10+50). Потому результат будет такой:
Чтобы сначала выполнить операцию сложения, а затем умножить полученный результат на 5, нужно взять сложение в скобки:
u = (10 + 10) * 5 
print(u) 
100
Математические операции имеют такой приоритет:

Выражение в скобках;
Экспоненты;
Умножение;
Деление;
Сложение;
Вычитание.

Операторы присваивания
Наиболее распространённым оператором присваивания является знак равенства (=). Он присваивает переменной слева значение справа. К примеру, в выражении v = 23 переменной v было присвоено значение 23.
В программировании часто используются составные операторы присваивания, которые выполняют операцию со значением переменной, а затем присваивают этой переменной полученное новое значение. Составные операторы объединяют арифметический оператор с оператором =. Например:
Составной оператор += выполнил сложение, а затем присвоил переменной w, значение, полученное в результате сложения.
Составные операторы часто используются в циклах.
for x in range (0, 7): 
x *= 2 
print(x) 
0 
2 
4 
6 
8 
10 
12
Это позволяет автоматизировать процесс умножения чисел в заданном диапазоне.
В Python есть составные операторы присваивания для каждой математической операции:
y += 1 # сложение и присваивание 
y -= 1 # вычитание и присваивание 
y *= 2 # умножение и присваивание 
y /= 3 # деление и присваивание 
y // = 5 # деление floor и присваивание 
y **= 2 # возведение в степень и присваивание 
y %= 3 # вывод остатка и присваивание
Операторы присваивания позволяют постепенно увеличить или уменьшить значение, а также автоматизировать некоторые вычисления.
Заключение
Теперь вы умеете выполнять вычисления в Python. Читайте также:

Типы данных в Python 3
Преобразование типов данных в Python 3



Похожие публикации:

Бмв какие машины покупать
Как в маткаде просуммировать матрицу
Как перепрошить стиральную машину канди
Как сделать лифлет в индизайне