Вычисления в python
Хорошего дня! Сегодня мы научимся умножать, делить, вычитать. В каком смысле ты это уже умеешь?! А ты в этом уверен? В любом случае, повторение — это мать учения, так что устраивайся по-удобнее, мы начинаем.
Арифметические операции в python
Вы считаете, что арифметические операции — это просто? Пересчитайте. На самом деле, всё не так страшно, но расслабляться не стоит.
Начнём со всем знакомой четверки:
print ( 10 + 10 )
# 10
print ( 10 — 5 )
# 5
print ( 11 * 7 )
# 77
print ( 10 / 2 )
# 5.0
Никаких неожиданностей, правда? Не совсем, посмотрите внимательно на операцию деления. Заметили? Мы разделили целое число на его делитель, но несмотря на это, результат имеет тип float . Взглянем на операцию деления чуть более пристально:
print ( 10 / 2 )
# 5.0
print ( 100 / 3 )
# 33.333333333333336
print ( 21 / 4 )
# 5.25
print ( 23 / 7 )
# 3.2857142857142856
Обратите внимание на деление 100 / 3 . Выполнив эту операцию, мы получили очень интересный результат 33.333333333333336 . На конце 6 ?! Вспомним перевод числа в двоичную систему счисления. То есть мы можем представить любое число в виде ноликов и единичек, например:
37 = 2^5 + 2^2 + 2^0 = 100101 .
А как обстоит дело с дробями? Точно также:
0.75 = 0.5 + 0.25 = 1/2 + 1/4 = 0.11
Возникает вопрос, как перевести в двоичную систему такие дроби: 1/3
1/3 = 1/4 + 1/8 + 1/16 + 1/32 + .
Это может продолжаться бесконечно долго. Поэтому python прерывает выполнение таких вычислений и часто выдает такие приколы:
print ( 0.1 + 0.1 + 0.1 + 0.1 + 0.1 + 0.1 + 0.1 + 0.1 )
# 0.7999999999999999
print ( 0.1 + 0.2 )
# 0.30000000000000004
print ( 7 / 3 )
# 2.3333333333333335
Еще немного математики. Математика в каждый дом!
# Возведение в степень
print ( 10 * * 2 )
# 100
print ( 2 * * 4 )
# 16
print ( 3 * * 0.5 )
# 1.7320508075688772
print ( 3 * * — 2 )
# 0.1111111111111111
# Остаток от деления
print ( 11 % 4 )
# 3
print ( 101 % 7 )
# 3
print ( 34 % 5 )
# 4
# Деление нацело
print ( 20 // 4 )
# 5
print ( 129 // 11 )
# 11
print ( 100 // 61 )
# 1
Операции сравнения в python
Операции сравнения в отличие от арифметические имеют всего два результата: True и False . Чаще всего такие операции используются в условии циклов, условных оператов, а также в некоторых функциях, например, filter .
# Операция равенства: True, если X равен Y
print ( 10 == 10 )
# True
print ( 666 == 661 )
# False
# Операция неравенства: True, если X не равен Y
print ( 666 != 661 )
# True
print ( 666 != 666 )
# False
# Операция больше: True, если X больше Y
print ( 120 > 2 )
# True
print ( 1000 > 1999 )
# False
# Операция меньше: True, если X меньше Y
print ( 121 120 )
# False
print ( 0 1 )
# True
# Операция меньше или равно: True, если X меньше или равен Y
print ( 6 6 )
# True
print ( 5 2 )
# False
# Операция больше или равно: True, если X больше или равен Y
print ( 1000 >= 10000 )
# False
print ( 9999 >= 9999 )
# False
Логические операции в python
Логические операции, как и операции сравнения, имеют всего два возможных результата: True и False . Используются для объединения операций сравнения в условиях циклов, условных оператов, а также в некоторых функциях, например, filter .
# Оператор «and» или конъюнкция.
# True, если и выражение X, и выражение Y равны True
print ( 10 == 10 and 10 > 2 )
# True
print ( 666 == 661 and 9 > 0 )
# False
# Оператор «or» или дизъюнкция.
# True, если или выражение X, или выражение Y равны True
print ( 666 == 661 or 9 > 0 )
# True
print ( 666 == 661 or 9 0 )
# False
# Оператор «not» или инверсия меняет значение на противоположное.
# True, если выражение X равно False
print ( not 120 > 2 )
# False
print ( not 1000 999 )
# True
print ( not ( 121 121 and 10 == 2 ))
# True
Округление чисел в python
Всё дело в округлении! В python есть несколько замечательных функций, которые округляют число до указанного знака. Одной из таких функций является round :
pi = 3.14159265358979323846264338327
print (round(pi, 1 ))
# 3.1
print (round(pi, 2 ))
# 3.14
print (round(pi, 3 ))
# 3.12
print (round(pi, 4 ))
# 3.1416
print (round(pi, 10 ))
# 3.1415926536
print (round(pi, 15 ))
# 3.141592653589793
Рассмотрим любопытный пример:
print (round( 2.5 ))
# 2
print (round( 3.5 ))
# 4
Если на вашем лице застыл немой вопрос: «почему?», то я вас понимаю. В школе нас учили, что дроби 1.1, 1.2, 1.3, 1.4 округляются до единицы, а 1.5, . 1.9 до двойки. Но python думает по-другому. Есть два типа округления: арифметическое и банковское. Именно арифметическому округлению вас учили в школе. Python использует как раз-таки банковское округление, его еще называют округлением до ближайшего четного. Приведу еще несколько примеров:
print (round( 10.51213 ))
# 11
print (round( 23.5 ))
# 24
print (round( 22.5 ))
# 22
Модуль math
Модуль math представляет собой набор математических формул. Рассмотрим несколько примеров:
print ( dir (math))
[‘__doc__’, ‘__loader__’, ‘__name__’, ‘__package__’, ‘__spec__’, ‘acos’,
‘acosh’, ‘asin’, ‘asinh’, ‘atan’, ‘atan2’, ‘atanh’, ‘ceil’, ‘copysign’,
‘cos’, ‘cosh’, ‘degrees’, ‘e’, ‘erf’, ‘erfc’, ‘exp’, ‘expm1’, ‘fabs’,
‘factorial’, ‘floor’, ‘fmod’, ‘frexp’, ‘fsum’, ‘gamma’, ‘gcd’, ‘hypot’,
‘inf’, ‘isclose’, ‘isfinite’, ‘isinf’, ‘isnan’, ‘ldexp’, ‘lgamma’, ‘log’,
‘log10’, ‘log1p’, ‘log2’, ‘modf’, ‘nan’, ‘pi’, ‘pow’, ‘radians’, ‘remainder’,
‘sin’, ‘sinh’, ‘sqrt’, ‘tan’, ‘tanh’, ‘tau’, ‘trunc’]
import math
# Синус 3.14 радиан
print (math. sin ( 3.14 ))
# 0.0015926529164868282
# Косинус 1.1 радиан
print (math. cos ( 1.1 ))
# 0.4535961214255773
# Возведение экспоненты в 3 степень
print (math. exp ( 3 ))
# 20.085536923187668
# Натуральный логарифм 61
print (math. log ( 61 ))
# 4.110873864173311
# Факториал четырех
print (math. factorial ( 4 ))
# 24
# Извлечение квадратного корня
print (math. sqrt ( 9 ))
# 3.0
# Алгоритм Евклида для чисел 20 и 19
print (math. gcd ( 20 , 19 ))
# 1
# Вычисление гипотенузы треугольника с катетами 3 и 4
print (math. hypot ( 3 , 4 ))
# 5.0
# Перевод радиан в градусы
print (math. degrees ( 1.572 ))
# 90.06896539456541
# Факториал четырех
print (math. fmod ( 20 , 3 ))
# 24
И это далеко не всё! Остальные функции я предлагаю вам протестировать самостоятельно : )
Python's sum(): The Pythonic Way to Sum Values
Watch Now This tutorial has a related video course created by the Real Python team. Watch it together with the written tutorial to deepen your understanding: Summing Values the Pythonic Way With sum()
Python’s built-in function sum() is an efficient and Pythonic way to sum a list of numeric values. Adding several numbers together is a common intermediate step in many computations, so sum() is a pretty handy tool for a Python programmer.
As an additional and interesting use case, you can concatenate lists and tuples using sum() , which can be convenient when you need to flatten a list of lists.
In this tutorial, you’ll learn how to:
- Sum numeric values by hand using general techniques and tools
- Use Python’s sum() to add several numeric values efficiently
- Concatenate lists and tuples with sum()
- Use sum() to approach common summation problems
- Use appropriate values for the arguments in sum()
- Decide between sum() and alternative tools to sum and concatenate objects
This knowledge will help you efficiently approach and solve summation problems in your code using either sum() or other alternative and specialized tools.
Free Bonus: Click here to get a Python Cheat Sheet and learn the basics of Python 3, like working with data types, dictionaries, lists, and Python functions.
Understanding the Summation Problem
Summing numeric values together is a fairly common problem in programming. For example, say you have a list of numbers [1, 2, 3, 4, 5] and want to add them together to compute their total sum. With standard arithmetic, you’ll do something like this:
1 + 2 + 3 + 4 + 5 = 15
As far as math goes, this expression is pretty straightforward. It walks you through a short series of additions until you find the sum of all the numbers.
It’s possible to do this particular calculation by hand, but imagine some other situations where it might not be so possible. If you have a particularly long list of numbers, adding by hand can be inefficient and error-prone. What happens if you don’t even know how many items are in the list? Finally, imagine a scenario where the number of items you need to add changes dynamically or unpredictably.
In situations like these, whether you have a long or short list of numbers, Python can be quite useful to solve summation problems.
If you want to sum the numbers by creating your own solution from scratch, then you can try using a for loop:
Here, you first create total and initialize it to 0 . This variable works as an accumulator in which you store intermediate results until you get the final one. The loop iterates through numbers and updates total by accumulating each successive value using an augmented assignment.
You can also wrap the for loop in a function. This way, you can reuse the code for different lists:
In sum_numbers() , you take an iterable—specifically, a list of numeric values—as an argument and return the total sum of the values in the input list. If the input list is empty, then the function returns 0 . The for loop is the same one that you saw before.
You can also use recursion instead of iteration. Recursion is a functional programming technique where a function is called within its own definition. In other words, a recursive function calls itself in a loop:
When you define a recursive function, you take the risk of running into an infinite loop. To prevent this, you need to define both a base case that stops the recursion and a recursive case to call the function and start the implicit loop.
In the above example, the base case implies that the sum of a zero-length list is 0 . The recursive case implies that the total sum is the first value, numbers[0] , plus the sum of the rest of the values, numbers[1:] . Because the recursive case uses a shorter sequence on each iteration, you expect to run into the base case when numbers is a zero-length list. As a final result, you get the sum of all the items in your input list, numbers .
Note: In this example, if you don’t check for an empty input list (your base case), then sum_numbers() will never run into an infinite recursive loop. When your numbers list reaches a length of 0 , the code tries to access an item from the empty list, which raises an IndexError and breaks the loop.
With this kind of implementation, you’ll never get a sum from this function. You’ll get an IndexError every time.
Another option to sum a list of numbers in Python is to use reduce() from functools . To get the sum of a list of numbers, you can pass either operator.add or an appropriate lambda function as the first argument to reduce() :
You can call reduce() with a reduction, or folding, function along with an iterable as arguments. Then reduce() uses the input function to process iterable and returns a single cumulative value.
In the first example, the reduction function is add() , which takes two numbers and adds them together. The final result is the sum of the numbers in the input iterable . As a drawback, reduce() raises a TypeError when you call it with an empty iterable .
In the second example, the reduction function is a lambda function that returns the addition of two numbers.
Since summations like these are commonplace in programming, coding a new function every time you need to sum some numbers is a lot of repetitive work. Additionally, using reduce() isn’t the most readable solution available to you.
Python provides a dedicated built-in function to solve this problem. The function is conveniently called sum() . Since it’s a built-in function, you can use it directly in your code without importing anything.
Getting Started With Python’s sum()
Readability is one of the most important principles behind Python’s philosophy. Visualize what you are asking a loop to do when summing a list of values. You want it to loop over some numbers, accumulate them in an intermediate variable, and return the final sum. However, you can probably imagine a more readable version of summation that doesn’t need a loop. You want Python to take some numbers and sum them together.
Now think about how reduce() does summation. Using reduce() is arguably less readable and less straightforward than even the loop-based solution.
This is why Python 2.3 added sum() as a built-in function to provide a Pythonic solution to the summation problem. Alex Martelli contributed the function, which nowadays is the preferred syntax for summing a list of values:
Wow! That’s neat, isn’t it? It reads like plain English and clearly communicates the action you’re performing on the input list. Using sum() is way more readable than a for loop or a reduce() call. Unlike reduce() , sum() doesn’t raise a TypeError when you provide an empty iterable. Instead, it understandably returns 0 .
You can call sum() with the following two arguments:
- iterable is a required argument that can hold any Python iterable. The iterable typically contains numeric values but can also contain lists or tuples.
- start is an optional argument that can hold an initial value. This value is then added to the final result. It defaults to 0 .
Internally, sum() adds start plus the values in iterable from left to right. The values in the input iterable are normally numbers, but you can also use lists and tuples. The optional argument start can accept a number, list, or tuple, depending on what is passed to iterable . It can’t take a string.
In the following two sections, you’ll learn the basics of using sum() in your code.
The Required Argument: iterable
Accepting any Python iterable as its first argument makes sum() generic, reusable, and polymorphic. Because of this feature, you can use sum() with lists, tuples, sets, range objects, and dictionaries:
In all these examples, sum() computes the arithmetic sum of all the values in the input iterable regardless of their types. In the two dictionary examples, both calls to sum() return the sum of the keys of the input dictionary. The first example sums the keys by default and the second example sums the keys because of the .keys() call on the input dictionary.
If your dictionary stores numbers in its values and you would like to sum these values instead of the keys, then you can do this by using .values() just like in the .keys() example.
You can also use sum() with a list comprehension as an argument. Here’s an example that computes the sum of the squares of a range of values:
Python 2.4 added generator expressions to the language. Again, sum() works as expected when you use a generator expression as an argument:
This example shows one of the most Pythonic techniques to approach the summation problem. It provides an elegant, readable, and efficient solution in a single line of code.
The Optional Argument: start
The second and optional argument, start , allows you to provide a value to initialize the summation process. This argument is handy when you need to process cumulative values sequentially:
Here, you provide an initial value of 100 to start . The net effect is that sum() adds this value to the cumulative sum of the values in the input iterable. Note that you can provide start as a positional argument or as a keyword argument. The latter option is way more explicit and readable.
If you don’t provide a value to start , then it defaults to 0 . A default value of 0 ensures the expected behavior of returning the total sum of the input values.
Summing Numeric Values
The primary purpose of sum() is to provide a Pythonic way to add numeric values together. Up to this point, you’ve seen how to use the function to sum integer numbers. Additionally, you can use sum() with any other numeric Python types, such as float , complex , decimal.Decimal , and fractions.Fraction .
Here are a few examples of using sum() with values of different numeric types:
Here, you first use sum() with floating-point numbers. It’s worth noting the function’s behavior when you use the special symbols inf and nan in the calls float(«inf») and float(«nan») . The first symbol represents an infinite value, so sum() returns inf . The second symbol represents NaN (not a number) values. Since you can’t add numbers with non-numbers, you get nan as a result.
The other examples sum iterables of complex , Decimal , and Fraction numbers. In all cases, sum() returns the resulting cumulative sum using the appropriate numeric type.
Concatenating Sequences
Even though sum() is mostly intended to operate on numeric values, you can also use the function to concatenate sequences such as lists and tuples. To do that, you need to provide an appropriate value to start :
In these examples, you use sum() to concatenate lists and tuples. This is an interesting feature that you can use to flatten a list of lists or a tuple of tuples. The key requirement for these examples to work is to select an appropriate value for start . For example, if you want to concatenate lists, then start needs to hold a list.
In the examples above, sum() is internally performing a concatenation operation, so it works only with those sequence types that support concatenation, with the exception of strings:
When you try to use sum() to concatenate strings, you get a TypeError . As the exception message suggests, you should use str.join() to concatenate strings in Python. You’ll see examples of using this method later on when you get to the section on Using Alternatives to sum() .
Practicing With Python’s sum()
So far, you’ve learned the basics of working with sum() . You’ve learned how to use this function to add numeric values together and also to concatenate sequences such as lists and tuples.
In this section, you’ll look at some more examples of when and how to use sum() in your code. With these practical examples, you’ll learn that this built-in function is quite handy when you’re performing computations that require finding the sum of a series of numbers as an intermediate step.
You’ll also learn that sum() can be helpful when you’re working with lists and tuples. A special example you’ll look at is when you need to flatten a list of lists.
Computing Cumulative Sums
The first example you’ll code has to do with how to take advantage of the start argument for summing cumulative lists of numeric values.
Say you’re developing a system to manage the sales of a given product at several different points of sale. Every day, you get a sold units report from each point of sale. You need to systematically compute the cumulative sum to know how many units the whole company sold over the week. To solve this problem, you can use sum() :
By using start , you set an initial value to initialize the sum, which allows you to add successive units to the previously computed subtotal. At the end of the week, you’ll have the company’s total count of sold units.
Calculating the Mean of a Sample
Another practical use case of sum() is to use it as an intermediate calculation before doing further calculations. For example, say you need to calculate the arithmetic mean of a sample of numeric values. The arithmetic mean, also known as the average, is the total sum of the values divided by the number of values, or data points, in the sample.
If you have the sample [2, 3, 4, 2, 3, 6, 4, 2] and you want to calculate the arithmetic mean by hand, then you can solve this operation:
(2 + 3 + 4 + 2 + 3 + 6 + 4 + 2) / 8 = 3.25
If you want to speed this up by using Python, you can break it up into two parts. The first part of this computation, where you are adding together the numbers, is a task for sum() . The next part of the operation, where you are dividing by 8, uses the count of numbers in your sample. To calculate your divisor, you can use len() :
Here, the call to sum() computes the total sum of the data points in your sample. Next, you use len() to get the number of data points. Finally, you perform the required division to calculate the sample’s arithmetic mean.
In practice, you may want to turn this code into a function with some additional features, such as a descriptive name and a check for empty samples:
Inside average() , you first check if the input sample has any data points. If not, then you raise a ValueError with a descriptive message. In this example, you use the walrus operator to store the number of data points in the variable num_points so that you won’t need to call len() again. The return statement computes the sample’s arithmetic mean and sends it back to the calling code.
Note: Computing the mean of a sample of data is a common operation in statistics and data analysis. The Python standard library provides a convenient module called statistics to approach these kinds of calculations.
In the statistics module, you’ll find a function called mean() :
The statistics.mean() function has very similar behavior to the average() function you coded earlier. When you call mean() with a sample of numeric values, you’ll get the arithmetic mean of the input data. When you pass an empty list to mean() , you’ll get a statistics.StatisticsError .
Note that when you call average() with a proper sample, you’ll get the desired mean. If you call average() with an empty sample, then you get a ValueError as expected.
Finding the Dot Product of Two Sequences
Another problem you can solve using sum() is finding the dot product of two equal-length sequences of numeric values. The dot product is the algebraic sum of products of every pair of values in the input sequences. For example, if you have the sequences (1, 2, 3) and (4, 5, 6), then you can calculate their dot product by hand using addition and multiplication:
1 × 4 + 2 × 5 + 3 × 6 = 32
To extract successive pairs of values from the input sequences, you can use zip() . Then you can use a generator expression to multiply each pair of values. Finally, sum() can sum the products:
With zip() , you generate a list of tuples with the values from each of the input sequences. The generator expression loops over each tuple while multiplying the successive pairs of values previously arranged by zip() . The final step is to add the products together using sum() .
The code in the above example works. However, the dot product is defined for sequences of equal length, so what happens if you provide sequences with different lengths? In that case, zip() ignores the extra values from the longest sequence, which leads to an incorrect result.
To deal with this possibility, you can wrap the call to sum() in a custom function and provide a proper check for the length of the input sequences:
Here, dot_product() takes two sequences as arguments and returns their corresponding dot product. If the input sequences have different lengths, then the function raises a ValueError .
Embedding the functionality in a custom function allows you to reuse the code. It also gives you the opportunity to name the function descriptively so that the user knows what the function does just by reading its name.
Flattening a List of Lists
Flattening a list of lists is a common task in Python. Say you have a list of lists and need to flatten it into a single list containing all the items from the original nested lists. You can use any of several approaches to flattening lists in Python. For example, you can use a for loop, as in the following code:
Inside flatten_list() , the loop iterates over all the nested lists contained in a_list . Then it concatenates them in flat using an augmented assignment operation ( += ). As the result, you get a flat list with all the items from the original nested lists.
But hold on! You’ve already learned how to use sum() to concatenate sequences in this tutorial. Can you use that feature to flatten a list of lists like you did in the example above? Yes! Here’s how:
That was quick! A single line of code and matrix is now a flat list. However, using sum() doesn’t seem to be the fastest solution.
Using a list comprehension is another common way to flatten a list of list in Python:
This new version of flatten_list() uses a comprehension instead of a regular for loop. However, the nested comprehensions can be challenging to read and understand.
Using .append() is another way to flatten a list of lists:
In this version of flatten_list() , someone reading your code can see that the function iterates over every sublist in a_list . In the second for loop, the function iterates over each item in sublist to finally populate the new flat list with .append() . Arguably, readability can be an advantage of this solution.
Using Alternatives to sum()
As you’ve already learned, sum() is helpful for working with numeric values in general. However, when it comes to working with floating-point numbers, Python provides an alternative tool. In math , you’ll find a function called fsum() that can help you improve the general precision of your floating-point computations.
You might have a task where you want to concatenate or chain several iterables so that you can work with them as one. For this scenario, you can look to the itertools module’s function chain() .
You might also have a task where you want to concatenate a list of strings. You’ve learned in this tutorial that there’s no way to use sum() for concatenating strings. This function just wasn’t built for string concatenation. The most Pythonic alternative is to use str.join() .
Summing Floating-Point Numbers: math.fsum()
If your code is constantly summing floating-point numbers with sum() , then you should consider using math.fsum() instead. This function performs floating-point computations more carefully than sum() , which improves the precision of your computation.
According to its documentation, fsum() “avoids loss of precision by tracking multiple intermediate partial sums.” The documentation provides the following example:
With fsum() , you get a more precise result. However, you should note that fsum() doesn’t solve the representation error in floating-point arithmetic. The following example uncovers this limitation:
In these examples, both functions return the same result. This is due to the impossibility of accurately representing both values 0.1 and 0.2 in binary floating-point:
Unlike sum() , however, fsum() can help you reduce floating-point error propagation when you add very large and very small numbers together:
Wow! The second example is pretty surprising and totally defeats sum() . With sum() , you get 0.0 as a result. This is quite far away from the correct result of 20000.0 , as you get with fsum() .
Concatenating Iterables With itertools.chain()
If you’re looking for a handy tool for concatenating or chaining a series of iterables, then consider using chain() from itertools . This function can take multiple iterables and build an iterator that yields items from the first one, from the second one, and so on until it exhausts all the input iterables:
When you call chain() , you get an iterator of the items from the input iterables. In this example, you access successive items from numbers using next() . If you want to work with a list instead, then you can use list() to consume the iterator and return a regular Python list.
chain() is also a good option for flattening a list of lists in Python:
To flatten a list of lists with chain() , you need to use the iterable unpacking operator ( * ). This operator unpacks all the input iterables so that chain() can work with them and generate the corresponding iterator. The final step is to call list() to build the desired flat list.
Concatenating Strings With str.join()
As you’ve already seen, sum() doesn’t concatenate or join strings. If you need to do so, then the preferred and fastest tool available in Python is str.join() . This method takes a sequence of strings as an argument and returns a new, concatenated string:
Using .join() is the most efficient and Pythonic way to concatenate strings. Here, you use a list of strings as an argument and build a single string from the input. Note that .join() uses the string on which you call the method as a separator during the concatenation. In this example, you call .join() on a string that consists of a single space character ( » » ), so the original strings from greeting are separated by spaces in your final string.
Conclusion
You can now use Python’s built-in function sum() to add multiple numeric values together. This function provides an efficient, readable, and Pythonic way to solve summation problems in your code. If you’re dealing with math computations that require summing numeric values, then sum() can be your lifesaver.
In this tutorial, you learned how to:
- Sum numeric values using general techniques and tools
- Add several numeric values efficiently using Python’s sum()
- Concatenate sequences using sum()
- Use sum() to approach common summation problems
- Use appropriate values for the iterable and start arguments in sum()
- Decide between sum() and alternative tools to sum and concatenate objects
With this knowledge, you’re now able to add multiple numeric values together in a Pythonic, readable, and efficient way.
Watch Now This tutorial has a related video course created by the Real Python team. Watch it together with the written tutorial to deepen your understanding: Summing Values the Pythonic Way With sum()
Get a short & sweet Python Trick delivered to your inbox every couple of days. No spam ever. Unsubscribe any time. Curated by the Real Python team.
About Leodanis Pozo Ramos
Leodanis is an industrial engineer who loves Python and software development. He's a self-taught Python developer with 6+ years of experience. He's an avid technical writer with a growing number of articles published on Real Python and other sites.
Each tutorial at Real Python is created by a team of developers so that it meets our high quality standards. The team members who worked on this tutorial are:
Как сложить числа в python
Python поддерживает все распространенные арифметические операции:
Сложение двух чисел:
Вычитание двух чисел:
Умножение двух чисел:
Деление двух чисел:
Целочисленное деление двух чисел:
Данная операция возвращает целочисленный результат деления, отбрасывая дробную часть
Возведение в степень:
Получение остатка от деления:
В данном случае ближайшее число к 7, которое делится на 2 без остатка, это 6. Поэтому остаток от деления равен 7 — 6 = 1
При последовательном использовании нескольких арифметических операций их выполнение производится в соответствии с их приоритетом. В начале выполняются операции с большим приоритетом. Приоритеты операций в порядке убывания приведены в следующей таблице.
Пусть у нас выполняется следующее выражение:
Здесь начале выполняется возведение в степень (5 ** 2) как операция с большим приоритетом, далее результат умножается на 4 (25 * 4), затем происходит сложение (3 + 100) и далее опять идет сложение (103 + 7).
Чтобы переопределить порядок операций, можно использовать скобки:
Следует отметить, что в арифметических операциях могут принимать участие как целые, так и дробные числа. Если в одной операции участвует целое число (int) и число с плавающей точкой (float), то целое число приводится к типу float.
Арифметические операции с присвоением
Ряд специальных операций позволяют использовать присвоить результат операции первому операнду:
Присвоение результата сложения
Присвоение результата вычитания
Присвоение результата умножения
Присвоение результата от деления
Присвоение результата целочисленного деления
Присвоение степени числа
Присвоение остатка от деления
Округление и функция round
При операциях с числами типа float надо учитывать, что результат операций с ними может быть не совсем точным. Например:
В данном случае мы ожидаем получить число 0.40002, однако в конце через ряд нулей появляется еще какая-то четверка. Или еще одно выражение:
В случае выше для округления результата мы можем использовать встроенную функцию round() :
В функцию round() передается число, которое надо округлить. Если в функцию передается одно число, как в примере выше, то оно округляется до целого.
Функция round() также может принимать второе число, которое указывает, сколько знаков после запятой должно содержать получаемое число:
В данном случае число third_number округляется до 4 знаков после запятой.
Если в функцию передается только одно значение — только округляемое число, оно округляется то ближайшего целого
Однако если округляемая часть равна одинаково удалена от двух целых чисел, то округление идет к ближайшему четному:
Округление производится до ближайшего кратного 10 в степени минус округляемая часть:
Однако следует учитывать, что функция round() не идеальный инструмент. Например, выше при округление до целых чисел применяется правило, согласно которому, если округляемая часть одинаково удалена от двух значений, то округление производится до ближайшего четного значения. В Python в связи с тем, что десятичная часть числа не может быть точно представлена в виде числа float, то это может приводить к некоторым не совсем ожидаемым результатам. Например:
Pythonista. Привет, Python
Доброго времени суток, Хабр. Запускаю короткий курс статей, который охватывает ключевые навыки Python, необходимые для изучения Data Science. Данные статьи подойдут для тех, кто уже имел опыт в программировании и хочет добавить Python в свою копилку навыков.
Привет, Python!
Python был назван в честь популярного британского комедийного телешоу 1970-х «Летающий цирк Монти Пайтона», поскольку автор был поклонником этого телешоу.
Просто ради удовольствия попробуйте прочитать приведенный ниже код и предсказать, что он будет делать при запуске. (Если вы не знаете, это нормально!) Он приурочен скетчу Монти Пайтона про спам.
But I don`t want ANY spam!
Spam Spam Spam Spam
Эта забавная программа демонстрирует многие важные аспекты того, как выглядит код Python и как он работает. Давайте подробнее рассмотрим код.
Присвоение переменной: здесь мы создаем переменную с именем spam_amount и присваиваем ей значение 0 используя = , что называется оператором присваивания.
Обратите внимание: если вы программировали на других языках (например, Java или C ++), вы могли заметить некоторые вещи, которые Python не требует от нас здесь:
• нам не нужно объявлять spam_amount перед присвоением ему значения
• нам не нужно указывать Python, на какой тип значения будет ссылаться spam_amount . Фактически, мы даже можем переназначить spam_amount для обозначения другого типа вещей, таких как строка или логическое значение.
Вызов функций: print — это функция Python, которая отображает на экране переданное ей значение. Мы вызываем функции, добавляя круглые скобки после их имени и помещая входные данные (или аргументы) функции в эти скобки.
Первая строка выше — это комментарий. В Python комментарии начинаются с символа # .
Далее мы видим пример переопределения. Переопределение значения существующей переменной выглядит так же, как создание новой переменной — по-прежнему используется оператор присваивания = .
В этом случае значение, которое мы присваиваем spam_amount , включает простое арифметическое действие с его предыдущим значением. Когда он встречает эту строку, Python оценивает выражение в правой части = (0 + 4 = 4), а затем присваивает это значение переменной в левой части.
Мы будем говорить об «условных выражениях» позже, но, даже если вы никогда раньше не программировали, вы, вероятно, можете догадаться, что тут происходит. Python ценится за его комфортность кода и простоту.
Обратите внимание, как мы указываем, какой код принадлежит if . «But I don’t want ANY spam! » выведется, только если spam_amount положительный. Но дальше (например, print (viking_song) ) код должен выполняться несмотря ни на что. Как мы (и Python) это различаем?
Двоеточие ( : ) в конце строки if указывает, что начинается новый «блок кода». Последующие строки с отступом являются частью этого блока кода. Некоторые другие языки используют < фигурные скобки >для обозначения начала и конца блоков кода. Использование в Python значимых пробелов может удивить программистов, которые привыкли к другим языкам, но на практике это приводит к более согласованному и читаемому коду, чем языки, которые не требуют отступов блоков кода.
Последующие строки, относящиеся к viking_song , не имеют отступа с дополнительными 4 пробелами, поэтому они не являются частью блока кода if . Мы увидим больше примеров блоков кода с отступом позже, когда мы будем определять функции и использовать циклы.
Этот фрагмент кода также является нашим первым знакомством со строками в Python:
Строки можно помечать двойными или одинарными кавычками. (Но поскольку эта конкретная строка содержит символ одинарной кавычки, мы можем запутать Python, пытаясь заключить ее в строку, если мы не будем осторожны.)
Оператор * можно использовать для умножения двух чисел ( 3 * 3 равно 9), но, что довольно интересно, мы также можем умножить строку на число, чтобы получить версию, которая повторяется столько раз. Python разрешает несколько маленьких трюков, подобных этому, где операторы типа * и + имеют разное значение в зависимости от того, к чему они применяются. (Технический термин для этого — перегрузка оператора)
Числа и арифметика в Python
Мы уже видели пример переменной, содержащей число выше:
«Число» — неформальное название для такого рода вещей, но если мы хотим быть более техническими, мы можем спросить Python, как он описывает тип вещи, которым является spam_amount :
Здесь int — сокращение от integer. Есть еще один вид чисел, с которым мы часто сталкиваемся в Python:
float — это число с плавающей точкой, которое очень полезно для представления таких вещей, как вес или пропорции.
type() — еще одна встроенная функция, которую мы встречаем (после print() ), и ее следует запомнить. Очень полезно иметь возможность спросить Python «к какому типу вещей относиться это?».
Естественное желание действий с числами — выполнять арифметические операции. Мы видели оператор + для сложения и оператор * для умножения. Python также покрывает остальные основные кнопки вашего калькулятора: