1.2 Числа · Python Express Course
Все типы, описанные в разделе, являются неизменяемыми.
print(7/2) # 3.5 - обычное математическое деление print(7//2) # 3 - целочисленное деление print(7%2) # 1 - остаток от деления
Целочисленные типы
- Логические выражения:
- False и 0 — это False
- True и любые числа кроме 0 — это True
- Численные выражения:
- True — это 1
- False — это 0
i += True # синтаксически верно и увеличивает на 1, но НЕ ПИШИТЕ ТАК i += 1 # то же самое, лучше писать так x = bool(7) # x == True x = bool(-7) # x == True x = bool(0) # x == False
int
int — целые положительные и отрицательные числа. Размер не ограничен.
x = 2**217 # 2 в степени 217 print(x) # 210624583337114373395836055367340864637790190801098222508621955072
Как создаются целочисленные объекты?
Для других типов объектов похожие правила.
Вызывается функция int
- с одним аргументом
- int(12) — поверхностная копия
- int(‘123’), int(4.56) — если тип аргумента подходящий, то происходит преобразование. Если оно неудачное, например, int(‘Hello’), то возбуждается исключение ValueError, если тип неподходящий, например, int([1, 2, 3]), то исключение TypeError
- с двумя аргументами int(x, base) — аналогично, ибо в одном аргументе по умолчанию base=10 (подробнее далее)
Функции преобразования целых чисел
| Синтаксис | Описание |
|---|---|
| bin(i) | Возвращает двоичное представление целого числа i в виде строки, например, bin(1980) == ‘0b11110111100’ |
| hex(i) | Возвращает шестнадцатеричное представление целого числа i в виде строки, например, hex(1980) == ‘0x7bc’ |
| int(x) | Преобразует объект x в целое число; в случае ошибки во время преобразования возбуждает исключение ValueError, а если тип объекта x не поддерживает преобразование в целое число, возбуждает исключение TypeError. Если x является числом с плавающей точкой, оно преобразуется в целое число путем усечения дробной части. |
| int(s, base) | Преобразует строку s в целое число, в случае ошибки возбуждает исключение ValueError. Если задан необязательный аргумент base, он должен быть целым числом в диапазоне от 2 до 36 включительно. |
| oct(i) | Возвращает восьмеричное представление целого числа i в виде строки, например, oct(1980) == ‘0o3674’ |
>>> s1 = bin(10) # получаем из числа 10 строки для представления числа в бинарной, восьмеричной и шестнадцатеричной системах счисления
>>> s1
'0b1010'
>>> s2 = oct(10)
>>> s2
'0o12' # Заметьте, что префикс **0o**, а не просто 0, как в языке С.
>>> s3 = hex(10)
>>> s3
'0xa'
>>> x1 = int('10') # из строки - десятичного представления числа - получаем целое число типа int
>>> x1; type(x1)
10
<class 'int'>
>>> x1 = int(' 10 ') # **допускает пробельные символы до и после числа**
>>> x1
10
>>> x2 = int(s1, 2) # обратно из бинарной строки в целое число
>>> x2; type(x2)
10
<class 'int'>
>>> x2 = int('111', 2) # обратно из бинарной строки в целое число
>>> x2
7
>>> x3 = int('z', 36) # параметр base может быть от 2 до 36, цифры тогда 0-9a-zA-Z
>>> x3
35
>>> x3 = int('Az', 36)
>>> x3
395
Для преобразования стандартных типов данных используются функци
- int(x, base=10)
- float(x)
- str(x)
- bool(x)
- complex(re, im)
Действия над числами
| Синтаксис | Описание |
|---|---|
| x + y | Складывает число x и число y |
| x — y | Вычитает число y из числа x |
| x * y | Умножает x на y |
| x / y | Делит x на y – результатом всегда является значение типа float (или complex, если x или y является комплексным числом) |
| x // y | Делит x на y, результат округляется вниз -7//2 == -4 |
| x % y | Возвращает модуль (остаток) от деления x на y. Для комплексных чисел преобразуется с помощью abs() к float |
| x ** y | Возводит x в степень y, смотрите также функцию pow() |
| -x | Изменяет знак числа. 0 остается нулем. |
| +x | Ничего не делает, иногда используется для повышения удобочитаемости программного кода |
| abs(x) | Возвращает абсолютное значение x |
| divmod(x, y) | Возвращает частное и остаток деления x на y в виде кортежа двух значений типа int |
| Возводит x в степень y; то же самое, что и оператор ** | |
| pow(x, y, z) | Более быстрая альтернатива выражению (x ** y) % z |
| round(x, n) | Возвращает значение типа int, соответствующее значению x типа float, округленному до ближайшего целого числа (или значение типа float, округленное до n-го знака после запятой, если задан аргумент n) |
Комбинированные операторы присвоения
+= -= *= /= //= %= и прочие операторы
Как работает ++ и —
Никак.
j
bool
True и False — константы.
Операторы and, or, not.
НЕ используйте 1 и 0 вместо True и False (понижает читаемость кода).
Числа с плавающей точкой
В стандартной библиотеке это float, complex и decimal.Decimal
float
Константы записываются как 0.0, 4., 5.7, –2.5, –2e9, 8.9e–4.
Обычно реализованые типом double языка С. Подробнее смотри sys.float_info
Поэтому часть чисел может быть представлена точно (0.
5), а часть — только приблизительно (0.1).
Можно написать простую функцию, которая сравнивает числа с машинной точностью:
def equal_float(a, b):
return abs(a - b) <= sys.float_info.epsilon
Округление
Все numbers.Real типы (int и float) могут быть аргументами следующих функций :
| Результат | |
|---|---|
| int(x) | Округляет число в сторону нуля. Это стандартная функция, для ее использования не нужно подключать модуль math |
| round(x) | Округляет число до ближайшего целого. Если дробная часть числа равна 0.5, то число округляется до ближайшего четного числа |
| round(x, n) | Округляет число x до n знаков после точки. Это стандартная функция, для ее использования не нужно подключать модуль math |
| math.floor(x) | Округляет число вниз («пол»), при этом floor(1.5) = 1, floor(-1.5) = -2 |
| math.ceil(x) | Округляет число вверх («потолок»), при этом ceil(1. |
| math.trunc(x) | Отбрасывает дробную часть |
| float.is_integer() | True, если дробная часть 0. |
| float.as_integer_ratio() | Возвращает числитель и знаменатель дроби |
Примеры:
| Выражение | Результат |
|---|---|
| int(1.7) | 1 |
| int(-1.7) | -1 |
| ceil(4.2) | 5 |
| ceil(4.8) | 5 |
| ceil(-4.2) | -4 |
| round(1.3) | 1 |
| round(1.7) | |
| round(1.5) | 2 |
| round(2.5) | 2 |
| round(2.65, 1) | 2.6 |
| round(2.75, 1) | 2.8 |
| trunc(5.32) | 5 |
| trunc(-5.32) | -5 |
>>> x = 3.0 >>> x.is_integer() True >>> x = 2.75 >>> a, b = x.as_integer_ratio() # помним, что функция может возвращать несколько значений >>> a # числитель 11 >>> b # знаменатель 4
75
>>> a, b = x.as_integer_ratio() # помним, что функция может возвращать несколько значений
>>> a # числитель
11
>>> b # знаменатель
4
Сюрпризы:
round(2.85, 1) # 2.9
подробнее: Floating Point Arithmetic: Issues and Limitations
Функции и константы модуля math
Не забудьте сделать import math
| Синтаксис | Описание | ||
|---|---|---|---|
| math.acos(x) | Возвращает арккосинус x в радианах | ||
| math.acosh(x) | Возвращает гиперболический арккосинус x в радианах | ||
| math.asin(x) | Возвращает арксинус x в радианах | ||
| math.asinh(x) | Возвращает гиперболический арксинус x в радианах | ||
| math.atan(x) | Возвращает арктангенс x в радианах | ||
| math.atan2(y, x) | Возвращает арктангенс y/x в радианах | ||
| math.atanh(x) | Возвращает гиперболический арктангенс x в радианах | ||
math. ceil(x) | Возвращает наименьшее целое число типа int, большее и равное x, например, math.ceil(5.4) == 6 | ||
| math.copysign(x,y) | Возвращает x со знаком числа y | ||
| math.cos(x) | Возвращает косинус x в радианах | ||
| math.cosh(x) | Возвращает гиперболический косинус x в радианах | ||
| math.degrees(r) | Преобразует число r, типа float, из радианов в градусы | ||
| math.e | Константа e, примерно равная значению 2.7182818284590451 | ||
| math.exp(x) | Возвращает e в степени x, то есть math.e ** x | ||
| math.fabs(x) | Возвращает \ | x\ | , то есть абсолютное значение x в виде числа типа float |
| math.factorial(x) | Возвращает x! | ||
| math.floor(x) | Возвращает наименьшее целое число типа int, меньшее и равное x, например, math.floor(5.4) == 5 | ||
| math.fmod(x, y) | Выполняет деление по модулю (возвращает остаток) числа x на число y; дает более точный результат, чем оператор %, применительно к числам типа float | ||
math. y$$ в виде числа типа float | |||
| math.radians(d) | Преобразует число d, типа float, из градусов в радианы | ||
| math.sin(x) | Возвращает синус x в радианах | ||
| math.sinh(x) | Возвращает гиперболический синус x в радианах | ||
| math.sqrt(x) | Возвращает $$\sqrt{x}$$ | ||
| math.sum(i) | Возвращает сумму значений в итерируемом объекте i в виде числа типа float | ||
| math.tan(x) | Возвращает тангенс x в радианах | ||
| math.tanh(x) | Возвращает гиперболический тангенс x в радианах | ||
| math.trunc(x) | Возвращает целую часть числа x в виде значения типа int; то же самое, что и int(x) |
Бесконечность и NaN (not a number)
Создаем бесконечность, отрицательную бесконечность и NaN
>>> a = float('inf')
>>> b = float('-inf')
>>> c = float('nan')
>>> a
inf
>>> b
-inf
>>> c
nan
>>>
Проверяем эти особые значения функциями
math.
isinf() и math.isnan()>>> math.isinf(a) True >>> math.isinf(b) True >>> math.isnan(c) True >>> b < 0 True
Операции над бесконечностью интуитивно понятны математику:
>>> a = float('inf')
>>> a + 45
inf
>>> a * 10
inf
>>> 10 / a
0.0
Когда получается
nan ?>>> a = float('inf')
>>> a/a
nan
>>> b = float('-inf')
>>> a + b
nan
Из nan получается только nan
>>> c = float('nan')
>>> c + 23
nan
>>> c / 2
nan
>>> c * 2
nan
>>> math.sqrt(c)
nan
Не сравнивайте nan
>>> c = float('nan')
>>> d = float('nan')
>>> c == d
False
>>> c is d
False
Получить исключение, когда результат nan
Иногда при отладке нужно поймать, где возникло «не то значение».
Используйте модуль fpectl
Floating point exception control модуль не входит в стандартную поставку.
complex
Неизменяемый тип данных. Состоит из двух float чисел — действительной и мнимой части.
Для представления комплесных чисел есть встроенный тип complex. Мнимая единица обозначается как j или J. Если действительная часть 0, то ее можно не писать.
Примеры комплексных чисел: 3.5+2j, 0.5j, -7.24+0j
>>> x = 3.5 + 2.1j >>> x.real, x.imag # действительная и мнимая часть (3.5, 2.1) >>> x.conjugate() # изменили знак мнимой части (3.5-2.1j)
При конвертации из строки вокруг + или — НЕ должно быть пробелов
x = complex(3, 5) # 3+5j
x = complex(3.5) # 3.5+0j
x = complex(' 3+5j ') # 3+5j
x = complex('3 + 5j') # ОШИБКА
С комплексными числами работают привычные операторы и функции, за исключением //, %, divmod, pow с тремя аргументами (см. таблицу далее)
Для работы с комплексными числами используйте функции из модуля cmath.
Decimal
Если нужна бОльшая точность, чем дает float, используйте decimal.
Decimal.
Эти числа обеспечивают уровень точности, который вы укажете (по умолчанию 28 знаков после запятой), и могут точно представлять периодические числа, такие как 0.11, но скорость работы с такими числами существенно ниже, чем с обычными числами типа float. Вследствие высокой точности числа типа decimal.Decimal прекрасно подходят для производства финансовых вычислений.
Различные типы в бинарных операторах
| Тип операторов | Тип результата |
|---|---|
| int float | float |
| float complex | complex |
| Decimal int | Decimal |
Decimal может использоваться только с Decimal или int, нельзя его использовать с float и другими неточными типами.
3 метода как удалить дробную часть десятичного числа в Python
Мы работали с разными типами чисел в Python и модифицировали их тип в соответствии с нашими потребностями.
В этом руководстве мы обсудим, как мы можем удалить десятичную дробную часть числа в Python.
Начнем с простой программы,
a = 24 print(type(a)) b = 19.4 print(type(b)) c = 3+4j print(type(c))
Вывод:
<class 'int'> <class 'float'> <class 'complex'>
Объяснение:
В приведенной выше программе мы объявили a, b и c как 24, 19,4 и 3 + 4j соответственно.
Проверив их тип, мы узнали, что a принадлежит классу int, b принадлежит классу float, а c принадлежит классу complex.
Здесь нам нужно произвести действия с числами с плавающей запятой, поэтому давайте перечислим различные методы удаления десятичных знаков из чисел.
- Используя функцию trunc().
- Использование int()
- Использование split()
Давайте подробно обсудим каждый из них.
Функция trunc()
В первой программе мы воспользуемся функцией trunc() и удалим десятичную часть, присутствующую в числах.
import math num_value1 = math.trunc(523.771) print(num_value1) print(type(num_value1)) num_value2 = math.trunc(21.67) print(num_value2) print(type(num_value2)) num_value3 = math.trunc(182.33) print(num_value3) print(type(num_value3)) num_value4 = math.trunc(211.54) print(num_value4) print(type(num_value4)) num_value5 = math.trunc(19.1) print(num_value5) print(type(num_value5))
Вывод:
523 <class 'int'> 21 <class 'int'> 182 <class 'int'> 211 <class 'int'> 19 <class 'int'>
Объяснение:
- Поскольку нам нужно использовать функцию trunc(), мы импортировали математический модуль.
- Мы предоставили пять различных десятичных значений пяти переменным и проверили их тип после их передачи в функцию trunc().
- При выполнении программы отображается требуемый результат.
Использование int()
Пришло время узнать о втором подходе, который удаляет десятичную дробь с помощью int().
Программа, представленная ниже, показывает, как это можно сделать:
num_value1 = 523.771 num_value2 = 21.67 num_value3 = 182.33 print(type(num_value1)) print(type(num_value2)) print(type(num_value3)) new_value1 = int(num_value1) new_value2 = int(num_value2) new_value3 = int(num_value3) print(new_value1) print(new_value2) print(new_value3) print(type(new_value1))
Вывод:
<class 'float'> <class 'float'> <class 'float'> 523 21 182 <class 'int'>
Объяснение.
Давайте разберемся, что мы здесь сделали:
- На первом этапе мы предоставили значения с плавающей запятой для трех переменных и проверили их тип.
- После этого мы передали каждую переменную в int() и сохранили их в новой переменной.
- Наконец, мы распечатали значения, хранящиеся в этих переменных.
- При выполнении этой программы отображается ожидаемый результат.
Использование split()
Наконец, в последнем подходе мы будем использовать интересную функцию split() для получения целочисленных значений.
num_values=[523.771,21.67,182.33,211.54,19.1]
sp_lst = []
for ele in num_values:
sp_lst.append(str(ele).split('.')[0])
res_list = [int(i) for i in sp_lst]
print("The resultant list is: ",res_list)
Вывод:
The resultant list is: [523, 21, 182, 211, 19]
Объяснение:
- На первом этапе мы создали список, содержащий все десятичные значения.
- После этого мы объявили пустой список и добавили в него значения.
- На следующем шаге мы взяли каждый элемент из этого списка и передали его в int().
- Наконец, мы отобразили результирующий список, содержащий числа без десятичной дроби.
Вывод
В этом руководстве мы начали с общего представления о типах чисел, которые мы используем в Python, а затем изучили различные методы удаления десятичных знаков из чисел.
Михаил Русаков
Изучаю Python вместе с вами, читаю, собираю и записываю информацию опытных программистов.
Еще для изучения:python — Разбиение числа на целую и десятичную части
Я придумал два оператора, которые могут делить положительные и отрицательные числа на целые и дробные без ущерба для точности (битовое переполнение) и скорости.
Код
# Разделить число (x) на целое и дробное i = int(x) # Получить целое число f = (x*1e17 - i*1e17) / 1e17 # Получить дробь
Положительное и отрицательное значение значения 100,1323 будет разделено следующим образом ( 100 , 0,1323 ) и ( -100 , -0,1323 ), где результат math. будет (
modf 0,13230000000 000075 , 100,0 ) и ( -0,13230000000000075 , -100,0 ).
Speedtest
Тест производительности показывает, что два оператора работают быстрее, чем math.modf , если они не помещены в свою собственную функцию или метод (расширение C/C++ улучшает это).
test.py :
#!/usr/bin/env питон
импортировать математику
импорт cProfile
""" Получить производительность обоих операторов и math.modf """
X = -100.1323 # Число, которое нужно разделить на целое и дробное
ПЕТЛИ = диапазон (5 * 10 ** 6) # Количество петель
определение сценария_a():
""" Получить исполнение операторов """
для _ в петлях:
я = int(X) # -100
f = (X*1e17-i*1e17)/1e17 # -0,1323
определение сценария_b():
""" Проверяет скорость операторов, когда целое число должно быть с плавающей запятой.
ПРИМЕЧАНИЕ. Единственная разница между этим и math. modf заключается в точности """
для _ в петлях:
я = int(X) # -100
i, f = float(i), (X*1e17-i*1e17)/1e17 # (-100,0, -0,1323)
определение сценария_c():
""" Проверяет скорость операторов в функции """
деф модф(х):
я = интервал (х)
вернуть i, (x*1e17-i*1e17)/1e17
для _ в петлях:
i, f = modf(X) # (-100, -0,1323)
определение сценария_d():
""" Проверяет скорость math.modf """
для _ в петлях:
f, i = math.modf(X) # (-0,13230000000000075, -100,0)
определение сценария_e():
""" Проверяет скорость math.modf, когда целая часть должна быть целочисленной """
для _ в петлях:
f, i = math.modf(X) # (-0,13230000000000075, -100,0)
я = интервал (я) # -100
если __name__ == '__main__':
cProfile.run('scenario_a()')
cProfile.run('scenario_b()')
cProfile.run('scenario_c()')
cProfile.run('scenario_d()')
cProfile.run('scenario_e()')
modf заключается в точности """
для _ в петлях:
я = int(X) # -100
i, f = float(i), (X*1e17-i*1e17)/1e17 # (-100,0, -0,1323)
определение сценария_c():
""" Проверяет скорость операторов в функции """
деф модф(х):
я = интервал (х)
вернуть i, (x*1e17-i*1e17)/1e17
для _ в петлях:
i, f = modf(X) # (-100, -0,1323)
определение сценария_d():
""" Проверяет скорость math.modf """
для _ в петлях:
f, i = math.modf(X) # (-0,13230000000000075, -100,0)
определение сценария_e():
""" Проверяет скорость math.modf, когда целая часть должна быть целочисленной """
для _ в петлях:
f, i = math.modf(X) # (-0,13230000000000075, -100,0)
я = интервал (я) # -100
если __name__ == '__main__':
cProfile.run('scenario_a()')
cProfile.run('scenario_b()')
cProfile.run('scenario_c()')
cProfile.run('scenario_d()')
cProfile.run('scenario_e()')
Результат:
4 вызова функции за 1,357 секунды
Упорядочено: стандартное имя
ncalls tottime percall cumtime percall имя файла:lineno(функция)
1 0,000 0,000 1,357 1,357 <строка>:1(<модуль>)
1 1,357 1,357 1,357 1,357 test. py:11(scenario_a)
1 0,000 0,000 1,357 1,357 {встроенный метод builtins.exec}
1 0.000 0.000 0.000 0.000 {метод 'отключить' объектов '_lsprof.Profiler'}
4 вызова функций за 1,858 секунды
Упорядочено: стандартное имя
ncalls tottime percall cumtime percall имя файла:lineno(функция)
1 0,000 0,000 1,858 1,858 <строка>:1(<модуль>)
1 1,858 1,858 1,858 1,858 test.py:18(scenario_b)
1 0,000 0,000 1,858 1,858 {встроенный метод builtins.exec}
1 0.000 0.000 0.000 0.000 {метод 'отключить' объектов '_lsprof.Profiler'}
5000004 вызовов функций за 2,744 секунды
Упорядочено: стандартное имя
ncalls tottime percall cumtime percall имя файла:lineno(функция)
1 0,000 0,000 2,744 2,744 <строка>:1(<модуль>)
1 1,245 1,245 2,744 2,744 test.py:26(scenario_c)
5000000 1,499 0,000 1,499 0,000 тест.py:29(modf)
1 0,000 0,000 2,744 2,744 {встроенный метод builtins.exec}
1 0.000 0.000 0.000 0.000 {метод 'отключить' объектов '_lsprof. Profiler'}
5000004 вызовов функций за 1,904 секунды
Упорядочено: стандартное имя
ncalls tottime percall cumtime percall имя файла:lineno(функция)
1 0,000 0,000 1,904 1,904 <строка>:1(<модуль>)
1 1,073 1,073 1,904 1,904 test.py:37(scenario_d)
1 0,000 0,000 1,904 1.904 {встроенный метод builtins.exec}
5000000 0,831 0,000 0,831 0,000 {встроенный метод math.modf}
1 0.000 0.000 0.000 0.000 {метод 'отключить' объектов '_lsprof.Profiler'}
5000004 вызовов функций за 2,547 секунды
Упорядочено: стандартное имя
ncalls tottime percall cumtime percall имя файла:lineno(функция)
1 0,000 0,000 2,547 2,547 <строка>:1(<модуль>)
1 1,696 1,696 2,547 2,547 test.py:43(scenario_e)
1 0,000 0,000 2,547 2,547 {встроенный метод builtins.exec}
5000000 0,851 0,000 0,851 0,000 {встроенный метод math.modf}
1 0.000 0.000 0.000 0.000 {метод 'отключить' объектов '_lsprof.Profiler'}
py:11(scenario_a)
1 0,000 0,000 1,357 1,357 {встроенный метод builtins.exec}
1 0.000 0.000 0.000 0.000 {метод 'отключить' объектов '_lsprof.Profiler'}
4 вызова функций за 1,858 секунды
Упорядочено: стандартное имя
ncalls tottime percall cumtime percall имя файла:lineno(функция)
1 0,000 0,000 1,858 1,858 <строка>:1(<модуль>)
1 1,858 1,858 1,858 1,858 test.py:18(scenario_b)
1 0,000 0,000 1,858 1,858 {встроенный метод builtins.exec}
1 0.000 0.000 0.000 0.000 {метод 'отключить' объектов '_lsprof.Profiler'}
5000004 вызовов функций за 2,744 секунды
Упорядочено: стандартное имя
ncalls tottime percall cumtime percall имя файла:lineno(функция)
1 0,000 0,000 2,744 2,744 <строка>:1(<модуль>)
1 1,245 1,245 2,744 2,744 test.py:26(scenario_c)
5000000 1,499 0,000 1,499 0,000 тест.py:29(modf)
1 0,000 0,000 2,744 2,744 {встроенный метод builtins.exec}
1 0.000 0.000 0.000 0.000 {метод 'отключить' объектов '_lsprof.
Profiler'}
5000004 вызовов функций за 1,904 секунды
Упорядочено: стандартное имя
ncalls tottime percall cumtime percall имя файла:lineno(функция)
1 0,000 0,000 1,904 1,904 <строка>:1(<модуль>)
1 1,073 1,073 1,904 1,904 test.py:37(scenario_d)
1 0,000 0,000 1,904 1.904 {встроенный метод builtins.exec}
5000000 0,831 0,000 0,831 0,000 {встроенный метод math.modf}
1 0.000 0.000 0.000 0.000 {метод 'отключить' объектов '_lsprof.Profiler'}
5000004 вызовов функций за 2,547 секунды
Упорядочено: стандартное имя
ncalls tottime percall cumtime percall имя файла:lineno(функция)
1 0,000 0,000 2,547 2,547 <строка>:1(<модуль>)
1 1,696 1,696 2,547 2,547 test.py:43(scenario_e)
1 0,000 0,000 2,547 2,547 {встроенный метод builtins.exec}
5000000 0,851 0,000 0,851 0,000 {встроенный метод math.modf}
1 0.000 0.000 0.000 0.000 {метод 'отключить' объектов '_lsprof.Profiler'}
Расширение C/C++
Я попытался скомпилировать два оператора с поддержкой C/C++, и результат был даже лучше.
С модулем расширения Python можно было получить метод, который был быстрее и точнее, чем math.modf .
math3.pyx :
def modf(номер):
cdef float num = <число с плавающей точкой>
cdef int i = число
вернуть i, (число*1e17 - i*1e17) / 1e17
См. Основы Cython
test.py :
#!/usr/bin/env python
импортировать математику
импорт cProfile
импортировать math3
""" Получить производительность обоих операторов и math.modf """
X = -100.1323 # Число, которое нужно разделить на целые числа и дроби
ПЕТЛИ = диапазон (5 * 10 ** 6) # Количество петель
определение сценария_a():
""" Проверяет скорость операторов в функции, использующей поддержку C/C++ """
для _ в петлях:
i, f = math3.modf(X) # (-100, -0,1323)
определение сценария_b():
""" Проверяет скорость math.modf """
для _ в петлях:
f, i = math.modf(X) # (-0,13230000000000075, -100,0)
если __name__ == '__main__':
cProfile. run('scenario_a()')
cProfile.run('scenario_b()')
run('scenario_a()')
cProfile.run('scenario_b()')
Результат:
5000004 вызовов функций за 1,629 секунды
Упорядочено: стандартное имя
ncalls tottime percall cumtime percall имя файла:lineno(функция)
1 0,000 0,000 1,629 1,629 <строка>:1(<модуль>)
1 1.100 1.100 1.629 1.629 test.py:10(scenario_a)
1 0,000 0,000 1,629 1,629 {встроенный метод builtins.exec}
5000000 0,529 0,000 0,529 0,000 {math3.modf}
1 0.000 0.000 0.000 0.000 {метод 'отключить' объектов '_lsprof.Profiler'}
5000004 вызовов функций за 1,802 секунды
Упорядочено: стандартное имя
ncalls tottime percall cumtime percall имя файла:lineno(функция)
1 0,000 0,000 1,802 1,802 <строка>:1(<модуль>)
1 1,010 1,010 1,802 1,802 test.py:16(scenario_b)
1 0,000 0,000 1,802 1,802 {встроенный метод builtins.exec}
5000000 0,791 0,000 0,791 0,000 {встроенный метод math.modf}
1 0.000 0.000 0.000 0.000 {метод 'отключить' объектов '_lsprof.Profiler'}
ПРИМЕЧАНИЕ
по модулю быстрее для деления положительных чисел, но не может обрабатывать отрицательные числа без дополнительной работы, что замедлит деление отрицательных чисел.
Однако это самый быстрый способ разделить положительные числа.
i, f = int(x), x*1e17%1e17/1e17 # Деление числа (x) на целое и дробное
Положительное значение значения 100.1323 будет разделено следующим образом ( 100 , 0.1323 ), а отрицательное значение будет ошибочным ( -100 , 0,8677 ).
python – Как получить целую часть столбца с плавающей запятой в pandas
спросил
Изменено 3 года, 4 месяца назад
Просмотрено 4к раз
Предположим, у меня есть кадр данных df, как показано ниже
кол-во 0 1.300 1 1,909
Теперь я хочу извлечь только целую часть столбца qty, и df должен выглядеть как
qty 0 1 1 1
Пытался использовать df[‘qty’].
round(0), но не получил желаемого результата, так как он округляет число до ближайшего целого числа.
В Java есть функция intValue(), которая выполняет требуемую операцию. Есть ли аналогичная функция в пандах?
- python
- pandas
- numpy
Преобразование значений в целые числа с помощью Series.astype :
df['qty'] = df['qty']. тип (целое число) печать (дф) кол-во 0 1 1 1
Если вышеперечисленное не работает, используйте numpy.modf для извлечения значений до . :
а, б = np.modf(df['количество']) df['кол-во'] = b.astype(int) печать (дф) кол-во 0 1 1 1
Или разделить до . , но это должно быть медленным, если большой DataFrame:
df['qty'] = b.astype(str).str.strip('.').str[0].astype(int)
Или используйте numpy.floor :
df['qty'] = np.floor(df['qty']).astype(int)6
Вы можете использовать метод floordiv :
df['col'].
floordiv(1).astype(int)
Например:
цв. 0 9.748333 1 6.612708 2 2,888753 3 8.913470 4 2.354213
Вывод:
0 91 6 2 2 3 8 4 2 Имя: столбец, dtype: int640
Зарегистрируйтесь или войдите в систему
Зарегистрируйтесь с помощью Google Зарегистрироваться через Facebook Зарегистрируйтесь, используя электронную почту и парольОпубликовать как гость
Электронная почтаОбязательно, но не отображается
Опубликовать как гость
Электронная почтаТребуется, но не отображается
Нажимая «Опубликовать свой ответ», вы соглашаетесь с нашими условиями обслуживания и подтверждаете, что прочитали и поняли нашу политику конфиденциальности и кодекс поведения.