math — Mathematical functions¶
This module provides access to the mathematical functions defined by the C standard.
These functions cannot be used with complex numbers; use the functions of the same name from the cmath module if you require support for complex numbers. The distinction between functions which support complex numbers and those which don’t is made since most users do not want to learn quite as much mathematics as required to understand complex numbers. Receiving an exception instead of a complex result allows earlier detection of the unexpected complex number used as a parameter, so that the programmer can determine how and why it was generated in the first place.
The following functions are provided by this module. Except when explicitly noted otherwise, all return values are floats.
Number-theoretic and representation functions¶
Return the ceiling of x, the smallest integer greater than or equal to x. If x is not a float, delegates to x.__ceil__ , which should return an Integral value.
Return the number of ways to choose k items from n items without repetition and without order.
Evaluates to n! / (k! * (n — k)!) when k <= n and evaluates to zero when k > n .
Also called the binomial coefficient because it is equivalent to the coefficient of k-th term in polynomial expansion of (1 + x)ⁿ .
Raises TypeError if either of the arguments are not integers. Raises ValueError if either of the arguments are negative.
New in version 3.8.
Return a float with the magnitude (absolute value) of x but the sign of y. On platforms that support signed zeros, copysign(1.0, -0.0) returns -1.0.
Return the absolute value of x.
math. factorial ( n ) ¶
Return n factorial as an integer. Raises ValueError if n is not integral or is negative.
Deprecated since version 3.9: Accepting floats with integral values (like 5.0 ) is deprecated.
Return the floor of x, the largest integer less than or equal to x. If x is not a float, delegates to x.__floor__ , which should return an Integral value.
Return fmod(x, y) , as defined by the platform C library. Note that the Python expression x % y may not return the same result. The intent of the C standard is that fmod(x, y) be exactly (mathematically; to infinite precision) equal to x — n*y for some integer n such that the result has the same sign as x and magnitude less than abs(y) . Python’s x % y returns a result with the sign of y instead, and may not be exactly computable for float arguments. For example, fmod(-1e-100, 1e100) is -1e-100 , but the result of Python’s -1e-100 % 1e100 is 1e100-1e-100 , which cannot be represented exactly as a float, and rounds to the surprising 1e100 . For this reason, function fmod() is generally preferred when working with floats, while Python’s x % y is preferred when working with integers.
Return the mantissa and exponent of x as the pair (m, e) . m is a float and e is an integer such that x == m * 2**e exactly. If x is zero, returns (0.0, 0) , otherwise 0.5 <= abs(m) < 1 . This is used to “pick apart” the internal representation of a float in a portable way.
math. fsum ( iterable ) ¶
Return an accurate floating point sum of values in the iterable. Avoids loss of precision by tracking multiple intermediate partial sums:
The algorithm’s accuracy depends on IEEE-754 arithmetic guarantees and the typical case where the rounding mode is half-even. On some non-Windows builds, the underlying C library uses extended precision addition and may occasionally double-round an intermediate sum causing it to be off in its least significant bit.
For further discussion and two alternative approaches, see the ASPN cookbook recipes for accurate floating point summation.
math. gcd ( * integers ) ¶
Return the greatest common divisor of the specified integer arguments. If any of the arguments is nonzero, then the returned value is the largest positive integer that is a divisor of all arguments. If all arguments are zero, then the returned value is 0 . gcd() without arguments returns 0 .
New in version 3.5.
Changed in version 3.9: Added support for an arbitrary number of arguments. Formerly, only two arguments were supported.
Return True if the values a and b are close to each other and False otherwise.
Whether or not two values are considered close is determined according to given absolute and relative tolerances.
rel_tol is the relative tolerance – it is the maximum allowed difference between a and b, relative to the larger absolute value of a or b. For example, to set a tolerance of 5%, pass rel_tol=0.05 . The default tolerance is 1e-09 , which assures that the two values are the same within about 9 decimal digits. rel_tol must be greater than zero.
abs_tol is the minimum absolute tolerance – useful for comparisons near zero. abs_tol must be at least zero.
If no errors occur, the result will be: abs(a-b) <= max(rel_tol * max(abs(a), abs(b)), abs_tol) .
The IEEE 754 special values of NaN , inf , and -inf will be handled according to IEEE rules. Specifically, NaN is not considered close to any other value, including NaN . inf and -inf are only considered close to themselves.
New in version 3.5.
PEP 485 – A function for testing approximate equality
Return True if x is neither an infinity nor a NaN, and False otherwise. (Note that 0.0 is considered finite.)
New in version 3.2.
Return True if x is a positive or negative infinity, and False otherwise.
Return True if x is a NaN (not a number), and False otherwise.
Return the integer square root of the nonnegative integer n. This is the floor of the exact square root of n, or equivalently the greatest integer a such that a² ≤ n.
For some applications, it may be more convenient to have the least integer a such that n ≤ a², or in other words the ceiling of the exact square root of n. For positive n, this can be computed using a = 1 + isqrt(n — 1) .
New in version 3.8.
Return the least common multiple of the specified integer arguments. If all arguments are nonzero, then the returned value is the smallest positive integer that is a multiple of all arguments. If any of the arguments is zero, then the returned value is 0 . lcm() without arguments returns 1 .
New in version 3.9.
Return x * (2**i) . This is essentially the inverse of function frexp() .
Return the fractional and integer parts of x. Both results carry the sign of x and are floats.
Return the next floating-point value after x towards y.
math.nextafter(x, math.inf) goes up: towards positive infinity.
math.nextafter(x, -math.inf) goes down: towards minus infinity.
math.nextafter(x, 0.0) goes towards zero.
math.nextafter(x, math.copysign(math.inf, x)) goes away from zero.
New in version 3.9.
Return the number of ways to choose k items from n items without repetition and with order.
Evaluates to n! / (n — k)! when k <= n and evaluates to zero when k > n .
If k is not specified or is None, then k defaults to n and the function returns n! .
Raises TypeError if either of the arguments are not integers. Raises ValueError if either of the arguments are negative.
New in version 3.8.
Calculate the product of all the elements in the input iterable. The default start value for the product is 1 .
When the iterable is empty, return the start value. This function is intended specifically for use with numeric values and may reject non-numeric types.
New in version 3.8.
Return the IEEE 754-style remainder of x with respect to y. For finite x and finite nonzero y, this is the difference x — n*y , where n is the closest integer to the exact value of the quotient x / y . If x / y is exactly halfway between two consecutive integers, the nearest even integer is used for n . The remainder r = remainder(x, y) thus always satisfies abs(r) <= 0.5 * abs(y) .
Special cases follow IEEE 754: in particular, remainder(x, math.inf) is x for any finite x, and remainder(x, 0) and remainder(math.inf, x) raise ValueError for any non-NaN x. If the result of the remainder operation is zero, that zero will have the same sign as x.
On platforms using IEEE 754 binary floating-point, the result of this operation is always exactly representable: no rounding error is introduced.
New in version 3.7.
Return x with the fractional part removed, leaving the integer part. This rounds toward 0: trunc() is equivalent to floor() for positive x, and equivalent to ceil() for negative x. If x is not a float, delegates to x.__trunc__ , which should return an Integral value.
Return the value of the least significant bit of the float x:
If x is a NaN (not a number), return x.
If x is negative, return ulp(-x) .
If x is a positive infinity, return x.
If x is equal to zero, return the smallest positive denormalized representable float (smaller than the minimum positive normalized float, sys.float_info.min ).
If x is equal to the largest positive representable float, return the value of the least significant bit of x, such that the first float smaller than x is x — ulp(x) .
Otherwise (x is a positive finite number), return the value of the least significant bit of x, such that the first float bigger than x is x + ulp(x) .
ULP stands for “Unit in the Last Place”.
New in version 3.9.
Note that frexp() and modf() have a different call/return pattern than their C equivalents: they take a single argument and return a pair of values, rather than returning their second return value through an ‘output parameter’ (there is no such thing in Python).
For the ceil() , floor() , and modf() functions, note that all floating-point numbers of sufficiently large magnitude are exact integers. Python floats typically carry no more than 53 bits of precision (the same as the platform C double type), in which case any float x with abs(x) >= 2**52 necessarily has no fractional bits.
Power and logarithmic functions¶
Return the cube root of x.
New in version 3.11.
Return e raised to the power x, where e = 2.718281… is the base of natural logarithms. This is usually more accurate than math.e ** x or pow(math.e, x) .
Return 2 raised to the power x.
New in version 3.11.
Return e raised to the power x, minus 1. Here e is the base of natural logarithms. For small floats x, the subtraction in exp(x) — 1 can result in a significant loss of precision; the expm1() function provides a way to compute this quantity to full precision:
New in version 3.2.
With one argument, return the natural logarithm of x (to base e).
With two arguments, return the logarithm of x to the given base, calculated as log(x)/log(base) .
Return the natural logarithm of 1+x (base e). The result is calculated in a way which is accurate for x near zero.
Return the base-2 logarithm of x. This is usually more accurate than log(x, 2) .
New in version 3.3.
int.bit_length() returns the number of bits necessary to represent an integer in binary, excluding the sign and leading zeros.
Return the base-10 logarithm of x. This is usually more accurate than log(x, 10) .
Return x raised to the power y . Exceptional cases follow the IEEE 754 standard as far as possible. In particular, pow(1.0, x) and pow(x, 0.0) always return 1.0 , even when x is a zero or a NaN. If both x and y are finite, x is negative, and y is not an integer then pow(x, y) is undefined, and raises ValueError .
Unlike the built-in ** operator, math.pow() converts both its arguments to type float . Use ** or the built-in pow() function for computing exact integer powers.
Changed in version 3.11: The special cases pow(0.0, -inf) and pow(-0.0, -inf) were changed to return inf instead of raising ValueError , for consistency with IEEE 754.
Return the square root of x.
Trigonometric functions¶
Return the arc cosine of x, in radians. The result is between 0 and pi .
Return the arc sine of x, in radians. The result is between -pi/2 and pi/2 .
Return the arc tangent of x, in radians. The result is between -pi/2 and pi/2 .
Return atan(y / x) , in radians. The result is between -pi and pi . The vector in the plane from the origin to point (x, y) makes this angle with the positive X axis. The point of atan2() is that the signs of both inputs are known to it, so it can compute the correct quadrant for the angle. For example, atan(1) and atan2(1, 1) are both pi/4 , but atan2(-1, -1) is -3*pi/4 .
Return the cosine of x radians.
Return the Euclidean distance between two points p and q, each given as a sequence (or iterable) of coordinates. The two points must have the same dimension.
Roughly equivalent to:
New in version 3.8.
Return the Euclidean norm, sqrt(sum(x**2 for x in coordinates)) . This is the length of the vector from the origin to the point given by the coordinates.
For a two dimensional point (x, y) , this is equivalent to computing the hypotenuse of a right triangle using the Pythagorean theorem, sqrt(x*x + y*y) .
Changed in version 3.8: Added support for n-dimensional points. Formerly, only the two dimensional case was supported.
Changed in version 3.10: Improved the algorithm’s accuracy so that the maximum error is under 1 ulp (unit in the last place). More typically, the result is almost always correctly rounded to within 1/2 ulp.
Return the sine of x radians.
Return the tangent of x radians.
Angular conversion¶
Convert angle x from radians to degrees.
Convert angle x from degrees to radians.
Hyperbolic functions¶
Hyperbolic functions are analogs of trigonometric functions that are based on hyperbolas instead of circles.
Return the inverse hyperbolic cosine of x.
Return the inverse hyperbolic sine of x.
Return the inverse hyperbolic tangent of x.
Return the hyperbolic cosine of x.
Return the hyperbolic sine of x.
Return the hyperbolic tangent of x.
Special functions¶
The erf() function can be used to compute traditional statistical functions such as the cumulative standard normal distribution:
New in version 3.2.
Return the complementary error function at x. The complementary error function is defined as 1.0 — erf(x) . It is used for large values of x where a subtraction from one would cause a loss of significance.
New in version 3.2.
New in version 3.2.
Return the natural logarithm of the absolute value of the Gamma function at x.
New in version 3.2.
Constants¶
The mathematical constant π = 3.141592…, to available precision.
The mathematical constant e = 2.718281…, to available precision.
The mathematical constant τ = 6.283185…, to available precision. Tau is a circle constant equal to 2π, the ratio of a circle’s circumference to its radius. To learn more about Tau, check out Vi Hart’s video Pi is (still) Wrong, and start celebrating Tau day by eating twice as much pie!
New in version 3.6.
A floating-point positive infinity. (For negative infinity, use -math.inf .) Equivalent to the output of float(‘inf’) .
New in version 3.5.
A floating-point “not a number” (NaN) value. Equivalent to the output of float(‘nan’) . Due to the requirements of the IEEE-754 standard, math.nan and float(‘nan’) are not considered to equal to any other numeric value, including themselves. To check whether a number is a NaN, use the isnan() function to test for NaNs instead of is or == . Example:
Changed in version 3.11: It is now always available.
New in version 3.5.
CPython implementation detail: The math module consists mostly of thin wrappers around the platform C math library functions. Behavior in exceptional cases follows Annex F of the C99 standard where appropriate. The current implementation will raise ValueError for invalid operations like sqrt(-1.0) or log(0.0) (where C99 Annex F recommends signaling invalid operation or divide-by-zero), and OverflowError for results that overflow (for example, exp(1000.0) ). A NaN will not be returned from any of the functions above unless one or more of the input arguments was a NaN; in that case, most functions will return a NaN, but (again following C99 Annex F) there are some exceptions to this rule, for example pow(float(‘nan’), 0.0) or hypot(float(‘nan’), float(‘inf’)) .
Note that Python makes no effort to distinguish signaling NaNs from quiet NaNs, and behavior for signaling NaNs remains unspecified. Typical behavior is to treat all NaNs as though they were quiet.
6 способов найти модуль числа в Python 3
Модуль числа. Это, казалось бы, простая вещь. да, так оно и есть. Тем не менее — всегда интересно поэкспериментировать и по-новому взглянуть на простое.
Сегодня я покажу вам 6 способов найти модуль числа в Python 3. Я не стал добавлять сюда совсем абсурдные вещи, но немного абсурдности здесь все же будет.
Для начала самое очевидное. Проверяем отрицательное число (назовем его x) или положительное, т.е. <0 или нет. В случае отрицательного значения x, его нужно умножить на -1. Можно так:
А можно заменить умножение унарным минусом:
Самое короткое решение в нашей статье — найти максимум между x и -x. Таким образом результат всегда будет положительным:
Здесь мы проверяем строку на наличие в ней минуса. Изначально я хотел использовать метод isdigit(), но потом я понял, что метод не считает точку частью числа, поэтому для float в строке метод возвращает False. Поэтому:
Этот способ использует условную инструкцию из предыдущей функции, но использует срез, чтобы избавиться от минуса. 3 строка выглядит не очень, приходится дважды менять тип данных результата. По-моему — это ухудшенная версия 3 способа:
Тут мы будем использовать факт того, что операция квадратного корня в Python всегда возвращает положительный результат. Эту операцию не обязательно брать из библиотеки Math, можно просто возвести число в с степень 0.5. Итак:
Здесь мы используем операции со строками, как в 4 способе. Отличие в том, что мы не проверяем строку на наличие минуса. Мы убираем уго, есть он в строке или нет. Метод replace() позволяет убрать все повторения одного символа, что для нас избыточно, но с нулем повторений он тоже работает:
Примечание: говоря про положительные значения, правильнее сказать — положительные или нулевые, но я решил не засорять текст такой мелочью.
Подведем итоги, узнаем — что же быстрее работает. О том, как замерить время работы программы, я, возможно, расскажу в одной из следующих статей. Ну а пока что приведу статистические данные.
Я измерил время работы данного куска кода, где i — одна из 6 функций.
И вот что получилось:
Что у нас по итогу? Худший результат показал 4 способ, неудивительно.Самый очевидный способ — первый, на 2 месте. С большим отрывом лидирует 5 вариант, 100000 повторений за 0.79 сек! Математика быстрее логического оператора if и операций со строками.
Я надеюсь, что вам была интересна данная статья, и вы разобрались в теме. Если хотите меня дополнить — пишите в комментариях. Удачи в мире IT!
How to Find an Absolute Value in Python
Absolute values are commonly used in mathematics, physics, and engineering. Although the school definition of an absolute value might seem straightforward, you can actually look at the concept from many different angles. If you intend to work with absolute values in Python, then you’ve come to the right place.
In this tutorial, you’ll learn how to:
- Implement the absolute value function from scratch
- Use the built-in abs() function in Python
- Calculate the absolute values of numbers
- Call abs() on NumPy arrays and pandas series
- Customize the behavior of abs() on objects
Don’t worry if your mathematical knowledge of the absolute value function is a little rusty. You’ll begin by refreshing your memory before diving deeper into Python code. That said, feel free to skip the next section and jump right into the nitty-gritty details that follow.
Sample Code: Click here to download the sample code that you’ll use to find absolute values in Python.
Defining the Absolute Value
The absolute value lets you determine the size or magnitude of an object, such as a number or a vector, regardless of its direction. Real numbers can have one of two directions when you ignore zero: they can be either positive or negative. On the other hand, complex numbers and vectors can have many more directions.
Note: When you take the absolute value of a number, you lose information about its sign or, more generally, its direction.
Consider a temperature measurement as an example. If the thermometer reads -12°C, then you can say it’s twelve degrees Celsius below freezing. Notice how you decomposed the temperature in the last sentence into a magnitude, twelve, and a sign. The phrase below freezing means the same as below zero degrees Celsius. The temperature’s size or absolute value is identical to the absolute value of the much warmer +12°C.
Using mathematical notation, you can define the absolute value of �� as a piecewise function, which behaves differently depending on the range of input values. A common symbol for absolute value consists of two vertical lines:
Absolute Value Defined as a Piecewise Function
This function returns values greater than or equal to zero without alteration. On the other hand, values smaller than zero have their sign flipped from a minus to a plus. Algebraically, this is equivalent to taking the square root of a number squared:
Absolute Value Defined Algebraically
When you square a real number, you always get a positive result, even if the number that you started with was negative. For example, the square of -12 and the square of 12 have the same value, equal to 144. Later, when you compute the square root of 144, you’ll only get 12 without the minus sign.
Geometrically, you can think of an absolute value as the distance from the origin, which is zero on a number line in the case of the temperature reading from before:
Absolute Value on a Number Line
To calculate this distance, you can subtract the origin from the temperature reading (-12°C — 0°C = -12°C) or the other way around (0°C — (-12°C) = +12°C), and then drop the sign of the result. Subtracting zero doesn’t make much difference here, but the reference point may sometimes be shifted. That’s the case for vectors bound to a fixed point in space, which becomes their origin.
Vectors, just like numbers, convey information about the direction and the magnitude of a physical quantity, but in more than one dimension. For example, you can express the velocity of a falling snowflake as a three-dimensional vector:
This vector indicates the snowflake’s current position relative to the origin of the coordinate system. It also shows the snowflake’s direction and pace of motion through the space. The longer the vector, the greater the magnitude of the snowflake’s speed. As long as the coordinates of the vector’s initial and terminal points are expressed in meters, calculating its length will get you the snowflake’s speed measured in meters per unit of time.
Note: There are two ways to look at a vector. A bound vector is an ordered pair of fixed points in space, whereas a free vector only tells you about the displacement of the coordinates from point A to point B without revealing their absolute locations. Consider the following code snippet as an example:
A bound vector wraps both points, providing quite a bit of information. In contrast, a free vector only represents the shift from A to B. You can calculate a free vector by subtracting the initial point, A, from the terminal one, B. One way to do so is by iterating over the consecutive pairs of coordinates with a list comprehension.
A free vector is essentially a bound vector translated to the origin of the coordinate system, so it begins at zero.
The length of a vector, also known as its magnitude, is the distance between its initial and terminal points, �� and ��, which you can calculate using the Euclidean norm:
The Length of a Bound Vector as a Euclidean Norm
This formula calculates the length of the ��-dimensional vector ����, by summing the squares of the differences between the coordinates of points �� and �� in each dimension indexed by ��. For a free vector, the initial point, ��, becomes the origin of the coordinate system—or zero—which simplifies the formula, as you only need to square the coordinates of your vector.
Recall the algebraic definition of an absolute value. For numbers, it was the square root of a number squared. Now, when you add more dimensions to the equation, you end up with the formula for the Euclidean norm, shown above. So, the absolute value of a vector is equivalent to its length!
All right. Now that you know when absolute values might be useful, it’s time to implement them in Python!
Implementing the Absolute Value Function in Python
To implement the absolute value function in Python, you can take one of the earlier mathematical definitions and translate it into code. For instance, the piecewise function may look like this:
You use a conditional statement to check whether the given number denoted with the letter x is greater than or equal to zero. If so, then you return the same number. Otherwise, you flip the number’s sign. Because there are only two possible outcomes here, you can rewrite the above function using a conditional expression that comfortably fits on a single line:
It’s exactly the same behavior as before, only implemented in a slightly more compact way. Conditional expressions are useful when you don’t have a lot of logic that goes into the two alternative branches in your code.
Note: Alternatively, you can write this even more concisely by relying on Python’s built-in max() function, which returns the largest argument:
If the number �� is negative, then this function will return its positive value. Otherwise, it’ll return �� itself.
The algebraic definition of an absolute value is also pretty straightforward to implement in Python:
First, you import the square root function from the math module and then call it on the given number raised to the power of two. The power function is built right into Python, so you don’t have to import it. Alternatively, you can avoid the import statement altogether by leveraging Python’s exponentiation operator ( ** ), which can simulate the square root function:
This is sort of a mathematical trick because using a fractional exponent is equivalent to computing the ��th root of a number. In this case, you take a squared number to the power of one-half (0.5) or one over two (½), which is the same as calculating the square root. Note that both Python implementations based on the algebraic definition suffer from a slight deficiency:
You always end up with a floating-point number, even if you started with an integer. So, if you’d like to preserve the original data type of a number, then you might prefer the piecewise-based implementation instead.
As long as you stay within integers and floating-point numbers, you can also write a somewhat silly implementation of the absolute value function by leveraging the textual representation of numbers in Python:
You convert the function’s argument, x , to a Python string using the built-in str() function. This lets you strip the leading minus sign, if there is one, with an empty string. Then, you convert the result to a floating-point number with float() . Note this implementation always converts integers to floats.
Implementing the absolute value function from scratch in Python is a worthwhile learning exercise. However, in real-life applications, you should take advantage of the built-in abs() function that comes with Python. You’ll find out why in the next section.
Using the Built-in abs() Function With Numbers
The last function that you implemented above was probably the least efficient one because of the data conversions and the string operations, which are usually slower than direct number manipulation. But in truth, all of your hand-made implementations of an absolute value pale in comparison to the abs() function that’s built into the language. That’s because abs() is compiled to blazing-fast machine code, while your pure-Python code isn’t.
You should always prefer abs() over your custom functions. It runs much more quickly, an advantage that can really add up when you have a lot of data to process. Additionally, it’s much more versatile, as you’re about to find out.
Integers and Floating-Point Numbers
The abs() function is one of the built-in functions that are part of the Python language. That means you can start using it right away without importing:
As you can see, abs() preserves the original data type. In the first case, you passed an integer literal and got an integer result. When called with a floating-point number, the function returned a Python float . But these two data types aren’t the only ones that you can call abs() on. The third numeric type that abs() knows how to handle is Python’s complex data type, which represents complex numbers.
Complex Numbers
You can think of a complex number as a pair consisting of two floating-point values, commonly known as the real part and the imaginary part. One way to define a complex number in Python is by calling the built-in complex() function:
It accepts two arguments. The first one represents the real part, while the second one represents the imaginary part. At any point, you can access the complex number’s .real and .imag attributes to get those parts back:
Both of them are read-only and are always expressed as floating-point values. Also, the absolute value of a complex number returned by abs() happens to be a floating-point number:
This might surprise you until you find out that complex numbers have a visual representation that resembles two-dimensional vectors fixed at the coordinate system’s origin:
You already know the formula to calculate the length of such a vector, which in this case agrees with the number returned by abs() . Note that the absolute value of a complex number is more commonly referred to as the magnitude, modulus, or radius of a complex number.
While integers, floating-point numbers, and complex numbers are the only numeric types supported natively by Python, you’ll find two additional numeric types in its standard library. They, too, can interoperate with the abs() function.
Fractions and Decimals
The abs() function in Python accepts all numeric data types available, including the lesser-known fractions and decimals. For instance, you can get the absolute value of one-third or minus three-quarters defined as Fraction instances:
In both cases, you get another Fraction object back, but it’s unsigned. That can be convenient if you plan to continue your computations on fractions, which offer higher precision than floating-point numbers.
If you’re working in finance, then you’ll probably want to use Decimal objects to help mitigate the floating-point representation error. Luckily, you can take the absolute value of these objects:
Again, the abs() function conveniently returns the same data type as the one that you supplied, but it gives you an appropriate positive value.
Wow, abs() can deal with an impressive variety of numeric data types! But it turns out that abs() is even more clever than that. You can even call it on some objects delivered by third-party libraries, as you’ll try out in the next section.
Calling abs() on Other Python Objects
Say you want to compute the absolute values of average daily temperature readings over some period. Unfortunately, as soon as you try calling abs() on a Python list with those numbers, you get an error:
That’s because abs() doesn’t know how to process a list of numbers. To work around this, you could use a list comprehension or call Python’s map() function, like so:
Both implementations do the job but require an additional step, which may not always be desirable. If you want to cut that extra step, then you may look into external libraries that change the behavior of abs() for your convenience. That’s what you’ll explore below.
NumPy Arrays and pandas Series
One of the most popular libraries for extending Python with high-performance arrays and matrices is NumPy. Its ��-dimensional array data structure, ndarray , is the cornerstone of numerical computing in Python, so many other libraries use it as a foundation.
Once you convert a regular Python list to a NumPy array with np.array() , you’ll be able to call some of the built-in functions, including abs() , on the result:
In response to calling abs() on a NumPy array, you get another array with the absolute values of the original elements. It’s as if you iterated over the list of temperature readings yourself and applied the abs() function on each element individually, just as you did with a list comprehension before.
You can convert a NumPy array back to a Python list if you find that more suitable:
However, note that NumPy arrays share most of the Python list interface. For example, they support indexing and slicing, and their methods are similar to those of plain lists, so most people usually just stick to using NumPy arrays without ever looking back at lists.
pandas is another third-party library widely used in data analysis thanks to its Series and DataFrame objects. A series is a sequence of observations or a column, whereas a DataFrame is like a table or a collection of columns. You can call abs() on both of them.
Suppose you have a Python dictionary that maps a city name to its lowest average temperatures observed monthly over the course of a year:
Each city has twelve temperature readings, spanning from January to December. Now, you can turn that dictionary into a pandas DataFrame object so that you can draw some interesting insights going forward:
Instead of using the default zero-based index, your DataFrame is indexed by abbreviated month names, which you obtained with the help of the calendar module. Each column in the DataFrame has a sequence of temperatures from the original dictionary, represented as a Series object:
By using the square bracket ( [] ) syntax and a city name like Rovaniemi, you can extract a single Series object from the DataFrame and narrow down the amount of information displayed.
pandas, just like NumPy, lets you call many of Python’s built-in functions on its objects, including its DataFrame and Series objects. Specifically, you can call abs() to calculate more than one absolute value in one go:
Calling abs() on the entire DataFrame applies the function to each element in every column. You can also call abs() on the individual column.
How did NumPy and pandas change the behavior of Python’s built-in abs() function without modifying its underlying code? Well, it was possible because the function was designed with such extensions in mind. If you’re looking for an advanced use of abs() , then read on to make your own data type that’ll play nicely with that function.
Your Very Own Data Types
Depending on the data type, Python will handle the computation of absolute values differently.
When you call abs() on an integer, it’ll use a custom code snippet that resembles your piecewise function. However, that function will be implemented in the C programming language for efficiency. If you pass a floating-point number, then Python will delegate that call to C’s fabs() function. In the case of a complex number, it’ll call the hypot() function instead.
What about container objects like DataFrames, series, and arrays?
Understandably, when you define a new data type in Python, it won’t work with the abs() function because its default behavior is unknown. However, you can optionally customize the behavior of abs() against the instances of your class by implementing the special .__abs__() method using pure Python. There’s a finite set of predefined special methods in Python that let you override how certain functions and operators should work.
Consider the following class representing a free ��-dimensional vector in the Euclidean space:
This class accepts one or more coordinate values, describing the displacement in each dimension from the origin of the coordinate system. Your special .__abs__() method calculates the distance from the origin, according to the Euclidean norm definition that you learned at the beginning of this tutorial.
To test your new class, you can create a three-dimensional velocity vector of a falling snowflake, for example, which might look like this:
Notice how calling abs() on your Vector class instance returns the correct absolute value, equal to about 1.78. The speed units will be expressed in meters per second as long as the snowflake’s displacement was measured in meters at two distinct time instants one second apart. In other words, it would take one second for the snowflake to travel from point A to point B.
Using the mentioned formula forces you to define the origin point. However, because your Vector class represents a free vector rather than a bound one, you can simplify your code by calculating the multidimensional hypotenuse using Python’s math.hypot() function:
You get the same result with fewer lines of code. Note that hypot() is a variadic function accepting a variable number of arguments, so you must use the star operator ( * ) to unpack your tuple of coordinates into those arguments.
Awesome! You can now implement your own library, and Python’s built-in abs() function will know how to work with it. You’ll get functionality similar to working with NumPy or pandas!
Conclusion
Implementing formulas for an absolute value in Python is a breeze. However, Python already comes with the versatile abs() function, which lets you calculate the absolute value of various types of numbers, including integers, floating-point numbers, complex numbers, and more. You can also use abs() on instances of custom classes and third-party library objects.
In this tutorial, you learned how to:
- Implement the absolute value function from scratch
- Use the built-in abs() function in Python
- Calculate the absolute values of numbers
- Call abs() on NumPy arrays and pandas series
- Customize the behavior of abs() on objects
With this knowledge, you’re equipped with an efficient tool to calculate absolute values in Python.
Sample Code: Click here to download the sample code that you’ll use to find absolute values in Python.
Числа¶
Числа в Python 3 — целые, вещественные, комплексные. Работа с числами и операции над ними.
Целые числа (int)¶
Числа в Python 3 ничем не отличаются от обычных чисел. Они поддерживают набор самых обычных математических операций:
| Синтаксис | Описание |
|---|---|
| x + y | Сложение |
| x — y | Вычитание |
| x * y | Умножение |
| x / y | Деление |
| x // y | Получение целой части от деления |
| x % y | Остаток от деления |
| -x | Смена знака числа |
| abs(x) | Модуль числа |
| divmod(x, y) | Пара ( x // y , x % y ) |
| x ** y | Возведение в степень |
| pow(x, y[, z]) | x y по модулю (если модуль задан) |
Также нужно отметить, что целые числа в python 3, в отличие от многих других языков, поддерживают длинную арифметику (однако, это требует больше памяти).
Битовые операции¶
Над целыми числами также можно производить битовые операции
Дополнительные методы¶
Системы счисления¶
Те, у кого в школе была информатика, знают, что числа могут быть представлены не только в десятичной системе счисления. К примеру, в компьютере используется двоичный код, и, к примеру, число 19 в двоичной системе счисления будет выглядеть как 10011 . Также иногда нужно переводить числа из одной системы счисления в другую. Python для этого предоставляет несколько функций:
int([object], [основание системы счисления]) преобразование к целому числу в десятичной системе счисления. По умолчанию система счисления десятичная, но можно задать любое основание от 2 до 36 включительно. bin(x) преобразование целого числа в двоичную строку. hex(х) преобразование целого числа в шестнадцатеричную строку. oct(х) преобразование целого числа в восьмеричную строку.
Вещественные числа (float)¶
Вещественные числа поддерживают те же операции, что и целые. Однако (из-за представления чисел в компьютере) вещественные числа неточны, и это может привести к ошибкам:
Для высокой точности используют другие объекты (например Decimal и Fraction )).
Также вещественные числа не поддерживают длинную арифметику:
Простенькие примеры работы с числами:
Дополнительные методы¶
Помимо стандартных выражений для работы с числами (а в Python их не так уж и много), в составе Python есть несколько полезных модулей.
Модуль math предоставляет более сложные математические функции.
Модуль random реализует генератор случайных чисел и функции случайного выбора.