Встроенные функции Python 3 для работы с числами

Вступление

Python 3 поставляется с множеством встроенных функций, которые вы можете легко использовать в любой программе, над которой вы работаете. Некоторые функции позволяют вам convert типы данных, а другие относятся к определенному типу, например strings.

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

  • + abs () + для абсолютного значения

  • + divmod () +, чтобы найти частное и остаток одновременно

  • + pow () + чтобы поднять число до определенной степени

  • + round () + для округления числа до определенного десятичного знака

  • + sum () + для вычисления суммы элементов в итерируемом типе данных

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

Абсолютная величина

Встроенная функция + abs () + вернет абсолютное значение числа, которое вы ей передадите. В математике * абсолютное значение * относится к расстоянию, на котором число находится на числовой линии от 0. Абсолютное значение не учитывает, в каком направлении от нуля лежит число, а это означает, что отрицательные числа будут представлены положительными числами.

Чтобы привести некоторые примеры, абсолютное значение + 15 + равно + 15 +, абсолютное значение + -74 + равно + 74 +, а абсолютное значение + 0 + равно ` + 0 + `.

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

Давайте используем + abs () + для решения этой проблемы:

destination_miles.py

miles_from_origin = 58  # Miles destination is from origin
miles_travelled = 93    # Miles travelled from origin to destination (too many)

# Calculate how many miles destination is from current location:
miles_to_go = miles_from_origin - miles_travelled

print(miles_to_go)      # Print how many miles left (a negative number)
print(abs(miles_to_go)) # Use absolute value to account for negative number
Output-35
35

В выводе мы видим, что если мы не используем функцию + abs () +, в этом случае у нас есть отрицательное число, + -35 +. Хотя мы можем оказаться в положении, когда + miles_travelled + меньше, чем + miles_from_origin +, в том числе функция + abs () + учитывает возможность отрицательного числа.

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

Давайте пройдемся по + abs () + с положительным числом и нулем:

print(abs(89.9))
print(abs(0))
Output89.9
0

Скорее всего, мы будем использовать + abs () + с переменной, которая может быть положительной или отрицательной в том случае, когда мы ищем только положительное число. Чтобы учесть отрицательный ввод или результат, мы будем использовать + abs () +, чтобы изменить то, что возвращается как положительное число.

Нахождение фактора и остатка в одной функции

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

Встроенная функция Python + divmod () + объединяет два, возвращая сначала частное, полученное из деления по полу, а затем остаток.

Поскольку + divmod () + будет работать с двумя числами, нам нужно передать ему два числа.

divmod(a,b)

С помощью этой функции мы в основном выполняем следующее:

a // b
a & b

Допустим, мы написали книгу длиной 80 000 слов. С нашим издателем у нас есть выбор: 300 или 250 слов на страницу, и мы хотели бы получить представление о том, сколько страниц у нас будет в каждом случае. С помощью + divmod () + мы сразу видим, сколько страниц у нас будет, и сколько слов будет перетекать на дополнительную страницу.

words_per_page.py

words = 80000       # How many words in our book
per_page_A = 300    # Option A, 300 words per page
per_page_B = 250    # Option B, 25- words per page

print(divmod(words,per_page_A)) # Calculate Option A
print(divmod(words,per_page_B)) # Calculate Option B
Output(266, 200)
(320, 0)

В варианте A у нас будет 266 страниц, заполненных словами, и 200 слов, оставшихся (⅔ на странице), всего 267 страниц, а в варианте B у нас будет книга на 320 страниц. Если мы хотим быть заботящимися об окружающей среде, мы можем выбрать вариант A, но если мы хотим выглядеть более эффектно с книгой большего размера, мы можем выбрать вариант B.

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

a = 985.5
b = 115.25

print(divmod(a,b))
Output(8.0, 63.5)

В этом примере + 8.0 + - это минимальный коэффициент 985.5, разделенный на 115.25, а + 63.5 + - остаток.

Помните, что вы можете использовать оператор деления по полу + // + и оператор по модулю +% +, чтобы проверить, что сделал + divmod () +:

print(a//b)
print(a%b)
Output8.0
63.5

При использовании функции + divmod () + в Python. мы получаем и общее количество раз, когда деление происходит, и остаток возвращается.

Мощность

В Python вы можете использовать the оператор + ** + для увеличить число на экспоненту, или вы можете использовать встроенную функцию + pow () +, которая принимает два числа.

Чтобы увидеть, как работает функция + pow () +, скажем, мы проводим исследование бактерий и хотим посмотреть, сколько бактерий у нас будет в конце дня, если мы начнем с 1. Конкретные бактерии, с которыми мы работаем, удваиваются каждый час, поэтому мы будем рассчитывать 2 (удвоение) на общее число часов (24 в нашем случае).

bacteria.py

hours = 24
total_bacteria = pow(2,hours)

print(total_bacteria)
Output16777216

Мы передали два целых числа в функцию + pow () + и определили, что к концу этого 24-часового периода у нас будет более 16 миллионов бактерий.

В математике, если мы хотим вычислить 3 в степени 3, это обычно пишется так:

Вычисление, которое мы завершаем, равно 3 x 3 x 3, что равно 27.

Чтобы вычислить 3³ в Python, мы набрали бы + pow (3,3) +.

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

Округление чисел

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

Мы будем использовать функцию, чтобы взять число с плавающей запятой, содержащее более 10 знаков после запятой, и функцию + round () +, чтобы уменьшить количество знаков после запятой до 4:

i = 17.34989436516001
print(round(i,4))
Output17.3499

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

Также обратите внимание, что функция + round () + округляет числа вверх, поэтому вместо предоставления + 17.3498 + в качестве выхода она предоставила + 17.3499 +, потому что число после десятичного числа 8 - это число 9. Любое число, за которым следует число 5 или больше, будет округлено до следующего целого числа.

Давайте разберем синтаксис для + round () +:

round(,)

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

Давайте рассмотрим пример простой программы, которая может рассчитать чаевые. Здесь мы приведем цифры, но мы могли бы переписать программу, чтобы вместо нее ввести предоставленные пользователем числа. В этом примере 3 друга пошли в ресторан, которые хотят равномерно разделить счет на 87,93 $, добавив 20% чаевых.

bill_split.py

bill = 87.93                # Total bill
tip = 0.2                   # 20% tip
split = 3                   # Number of people splitting the bill

total = bill + (bill * tip) # Calculate the total bill

each_pay = total / split    # Calculate what each person pays

print(each_pay)             # What each person pays before rounded

print(round(each_pay,2))    # Round the number - we can’t split pennies
Output35.172000000000004
35.17

В этой программе мы сначала запрашиваем вывод числа после того, как вычислим общий счет плюс чаевые, разделенные на 3, что дает число с большим количеством десятичных знаков: + 35.172000000000004 +. Поскольку это число не имеет смысла в денежном выражении, мы используем функцию + round () + и ограничиваем десятичные разряды до 2, чтобы мы могли предоставить вывод, с которым фактически могут работать 3 друга: `+ 35,17 + `.

Если вы предпочитаете округлять до числа только с 0 в качестве десятичного значения, вы можете сделать это, используя 0 в качестве второго параметра в функции + round () +:

round(345.9874590348545304636,0)

Это оценило бы к + 346.0 +.

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

Расчет суммы

Функция + sum () + используется для вычисления сумм числовых составных типов данных, включая lists, https: //www.digitalocean.com/community/tutorials/understanding-tuples-in-python-3[tuples] и https://www.digitalocean.com/community/tutorials/understanding-dictionaries-in-python-3 [ словари].

Мы можем передать список в функцию + sum () +, чтобы сложить все элементы в списке в порядке слева направо:

some_floats = [1.1, 2.2, 3.3, 4.4, 5.5, 6.6, 7.7, 8.8, 9.9]
print(sum(some_floats))
Output49.5

Это будет работать аналогично с кортежами и словарями:

print(sum((8,16,64,512)))   # Calculate sum of numbers in tuple
print(sum({-10: 'x', -20: 'y', -30: 'z'}))  # Calculate sum of numbers in dictionary
Output600 # Sum of numbers in tuple
-60 # Sum of numbers in dictionary

Функция + sum () + может принимать до 2 аргументов, поэтому вы можете добавить дополнительное число в виде целого числа или числа с плавающей запятой для добавления к числам, составляющим аргумент в первой позиции:

some_floats = [1.1, 2.2, 3.3, 4.4, 5.5, 6.6, 7.7, 8.8, 9.9]

print(sum(some_floats, 0.5))
print(sum({-10: 'x', -20: 'y', -30: 'z'},60))
Output50.0
0

Когда вы не включаете второй аргумент, функция + sum () + по умолчанию добавляет 0 к итерируемому составному типу данных.

Заключение

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

Чтобы узнать больше о работе с числами, вы можете прочитать «https://www.digitalocean.com/community/tutorials/how-to-do-math-in-python-3-with-operators[How To Math in Python 3 с операторами] », и чтобы узнать больше о списках, взгляните на« Understanding Lists в Python 3 ».