Using the len() Function in Python
In many situations, you’ll need to find the number of items stored in a data structure. Python’s built-in function len() is the tool that will help you with this task.
There are some cases in which the use of len() is straightforward. However, there are other times when you’ll need to understand how this function works in more detail and how to apply it to different data types.
In this tutorial, you’ll learn how to:
- Find the length of built-in data types using len()
- Use len() with third-party data types
- Provide support for len() with user-defined classes
By the end of this article, you’ll know when to use the len() Python function and how to use it effectively. You’ll know which built-in data types are valid arguments for len() and which ones you can’t use. You’ll also understand how to use len() with third-party types, such as ndarray in NumPy and DataFrame in pandas, and with your own classes.
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.
Getting Started With Python’s len()
The function len() is one of Python’s built-in functions. It returns the length of an object. For example, it can return the number of items in a list. You can use the function with many different data types. However, not all data types are valid arguments for len() .
You can start by looking at the help for this function:
The function takes an object as an argument and returns the length of that object. The documentation for len() goes a bit further:
Return the length (the number of items) of an object. The argument may be a sequence (such as a string, bytes, tuple, list, or range) or a collection (such as a dictionary, set, or frozen set). (Source)
When you use built-in data types and many third-party types with len() , the function doesn’t need to iterate through the data structure. The length of a container object is stored as an attribute of the object. The value of this attribute is modified each time items are added to or removed from the data structure, and len() returns the value of the length attribute. This ensures that len() works efficiently.
In the following sections, you’ll learn about how to use len() with sequences and collections. You’ll also learn about some data types that you cannot use as arguments for the len() Python function.
Using len() With Built-in Sequences
A sequence is a container with ordered items. Lists, tuples, and strings are three of the basic built-in sequences in Python. You can find the length of a sequence by calling len() :
When finding the length of the string greeting , the list office_days , and the tuple london_coordinates , you use len() in the same manner. All three data types are valid arguments for len() .
The function len() always returns an integer as it’s counting the number of items in the object that you pass to it. The function returns 0 if the argument is an empty sequence:
In the examples above, you find the length of an empty string, an empty list, and an empty tuple. The function returns 0 in each case.
A range object is also a sequence that you can create using range() . A range object doesn’t store all the values but generates them when they’re needed. However, you can still find the length of a range object using len() :
This range of numbers includes the integers from 1 to 19 with increments of 2 . The length of a range object can be determined from the start, stop, and step values.
In this section, you’ve used the len() Python function with strings, lists, tuples, and range objects. However, you can also use the function with any other built-in sequence.
Using len() With Built-in Collections
At some point, you may need to find the number of unique items in a list or another sequence. You can use sets and len() to achieve this:
You generate the list numbers using a list comprehension, and it contains twenty random numbers ranging between 1 and 20 . The output will be different each time the code runs since you’re generating random numbers. In this particular run, there are eleven unique numbers in the list of twenty randomly generated numbers.
Another built-in data type that you’ll use often is the dictionary. In a dictionary, each item consists of a key-value pair. When you use a dictionary as an argument for len() , the function returns the number of items in the dictionary:
The output from the first example shows that there are three key-value pairs in this dictionary. As was the case with sequences, len() will return 0 when the argument is either an empty dictionary or an empty set. This leads to empty dictionaries and empty sets being falsy.
Exploring len() With Other Built-in Data Types
You can’t use all built-in data types as arguments for len() . For data types that don’t store more than one item within them, the concept of length isn’t relevant. This is the case with numbers and Boolean types:
The integer, float, Boolean, and complex types are examples of built-in data types that you can’t use with len() . The function raises a TypeError when the argument is an object of a data type that doesn’t have a length.
You can also explore whether it’s possible to use iterators and generators as arguments for len() :
You’ve already seen that a list has a length, meaning you can use it as an argument in len() . You create an iterator from the list using the built-in function iter() . In an iterator, each item is fetched whenever it’s required, such as when the function next() is used or in a loop. However, you can’t use an iterator in len() .
You get a TypeError when you try to use an iterator as an argument for len() . As the iterator fetches each item as and when it’s needed, the only way to measure its length is to exhaust the iterator. An iterator can also be infinite, such as the iterator returned by itertools.cycle() , and therefore its length can’t be defined.
You can’t use generators with len() for the same reason. The length of these objects can’t be measured without using them up.
Exploring len() Further With Some Examples
In this section, you’ll learn about some common use cases for len() . These examples will help you understand better when to use this function and how to use it effectively. In some of the examples, you’ll also see cases where len() is a possible solution but there may be more Pythonic ways of achieving the same output.
Verifying the Length of a User Input
A common use case of len() is to verify the length of a sequence input by a user:
In this example, you use an if statement to check if the integer returned by len() is greater than or equal to 4 and less than or equal to 10 . You can run this script and you’ll get an output similar to the one below:
The username is nine characters long in this case, so the condition in the if statement evaluates to True . You can run the script again and input an invalid username:
In this case, len(username) returns 2 , and the condition in the if statement evaluates to False .
Ending a Loop Based on the Length of an Object
You’ll use len() if you need to check when the length of a mutable sequence, such as a list, reaches a specific number. In the following example, you ask the user to enter three username options, which you store in a list:
You’re now using the result from len() in the while statement. If the user enters an invalid username, you don’t keep the input. When the user enters a valid string, you append it to the list usernames . The loop repeats until there are three items in the list.
You could even use len() to check when a sequence is empty:
You use the list method .pop() to remove the first item from the list in each iteration until the list is empty. If you’re using this method on large lists, you should remove items from the end of the list as this is more efficient. You can also use the deque data type from the collections built-in module, which allows you to pop from the left efficiently.
There’s a more Pythonic way of achieving the same output by using the truthiness of sequences:
An empty list is falsy. This means that the while statement interprets an empty list as False . A non-empty list is truthy, and the while statement treats it as True . The value returned by len() determines the truthiness of a sequence. A sequence is truthy when len() returns any non-zero integer and falsy when len() returns 0 .
Finding the Index of the Last Item of a Sequence
Imagine you want to generate a sequence of random numbers in the range 1 to 10 and you’d like to keep adding numbers to the sequence until the sum of all the numbers exceeds 21 . The following code creates an empty list and uses a while loop to populate the list:
You append random numbers to the list until the sum exceeds 21 . The output you’ll get will vary as you’re generating random numbers. To display the last number in the list, you use len(numbers) and subtract 1 from it since the first index of the list is 0 . Indexing in Python allows you to use the index -1 to obtain the last item in a list. Therefore, although you can use len() in this case, you don’t need to.
You want to remove the last number in the list so that the sum of all numbers in the list doesn’t exceed 21 . You use len() again to work out the index of the last item in the list, which you use as an argument for the list method .pop() . Even in this instance, you could use -1 as an argument for .pop() to remove the last item from the list and return it.
Splitting a List Into Two Halves
If you need to split a sequence into two halves, you’ll need to use the index that represents the midpoint of the sequence. You can use len() to find this value. In the following example, you’ll create a list of random numbers and then split it into two smaller lists:
In the assignment statement where you define first_half , you use the slice that represents the items from the beginning of numbers up to the midpoint. You can work out what the slice represents by breaking down the steps you use in the slice expression:
- First, len(numbers) returns the integer 10 .
- Next, 10 // 2 returns the integer 5 as you use the integer division operator.
- Finally, 0:5 is a slice that represents the first five items, which have indices 0 to 4 . Note that the endpoint is excluded.
In the next assignment, where you define second_half , you use the same expression in the slice. However, in this case, the integer 5 represents the start of the range. The slice is now 5: to represent the items from index 5 up to the end of the list.
If your original list contains an odd number of items, then half of its length will no longer be a whole number. When you use integer division, you obtain the floor of the number. The list first_half will now contain one less item than second_half .
You can try this out by creating an initial list of eleven numbers instead of ten. The resulting lists will no longer be halves, but they’ll represent the closest alternative to splitting an odd sequence.
Using the len() Function With Third-Party Libraries
You can also use Python’s len() with several custom data types from third-party libraries. In the last section of this tutorial, you’ll learn how the behavior of len() depends on the class definition. In this section, you’ll look at examples of using len() with data types from two popular third-party libraries.
NumPy’s ndarray
The NumPy module is the cornerstone of all quantitative applications of programming in Python. The module introduces the numpy.ndarray data type. This data type, along with functions within NumPy, is ideally suited for numerical computations and is the building block for data types in other modules.
Before you can start using NumPy, you’ll need to install the library. You can use Python’s standard package manager, pip , and run the following command in the console:
You’ve installed NumPy, and now you can create a NumPy array from a list and use len() on the array:
The NumPy function np.array() creates an object of type numpy.ndarray from the list you pass as an argument.
However, NumPy arrays can have more than one dimension. You can create a two-dimensional array by converting a list of lists into an array:
The list numbers consists of two lists, each containing five integers. When you use this list of lists to create a NumPy array, the result is an array with two rows and five columns. The function returns the number of rows in the array when you pass this two-dimensional array as an argument in len() .
To get the size of both dimensions, you use the property .shape , which is a tuple showing the number of rows and columns. You obtain the number of dimensions of a NumPy array either by using .shape and len() or by using the property .ndim .
In general, when you have an array with any number of dimensions, len() returns the size of the first dimension:
In this example, you create a three-dimensional array with the shape (2, 3, 4) where each element is a random integer between 1 and 20 . You use the function np.random.randint() to create an array this time. The function len() returns 2 , which is the size of the first dimension.
Pandas’ DataFrame
The DataFrame type in the pandas library is another data type that is used extensively in many applications.
Before you can use pandas, you’ll need to install it by using the following command in the console:
You’ve installed the pandas package, and now you can create a DataFrame from a dictionary:
The dictionary’s keys are strings representing the names of students in a class. The value of each key is a list with the marks for three subjects. When you create a DataFrame from this dictionary, you define the index using a list containing the subject names.
The DataFrame has three rows and four columns. The function len() returns the number of rows in the DataFrame. The DataFrame type also has a .shape property, which you can use to show that the first dimension of a DataFrame represents the number of rows.
You’ve seen how len() works with a number of built-in data types and also with some data types from third-party modules. In the following section, you’ll learn how to define any class so that it’s usable as an argument for the len() Python function.
Using len() on User-Defined Classes
When you define a class, one of the special methods you can define is .__len__() . These special methods are called dunder methods as they have double underscores at the beginning and end of the method names. Python’s built-in len() function calls its argument’s .__len__() method.
In the previous section, you’ve seen how len() behaves when the argument is a pandas DataFrame object. This behavior is determined by the .__len__() method for the DataFrame class, which you can see in the module’s source code in pandas.core.frame :
This method returns the length of the DataFrame’s .index property using len() . This dunder method defines the length of a DataFrame to be equal to the number of rows in the DataFrame as represented by .index .
You can explore the .__len__() dunder method further with the following toy example. You’ll define a class named YString . This data type is based on the built-in string class, but objects of type YString give the letter Y more importance than all the other letters:
The .__init__() method of YString initializes the object using the .__init__() method of the parent str class. You achieve this using the function super() . The .__str__() method defines the way the object is displayed. The functions str() , print() , and format() all call this method. For this class, you represent the object as an all-lowercase string with the exception of the letter Y, which you display as uppercase.
For this toy class, you define the object’s length as the number of occurrences of the letter Y in the string. Therefore, the .__len__() method returns the count of the letter Y.
You can create an object of class YString and find its length. The module name used for the example above is ystring.py :
You create an object of type YString from an object of type str and show the representation of the object using print() . You then use the object message as an argument for len() . This calls the class’s .__len__() method, and the result is the number of occurrences of the letter Y in message . In this case, the letter Y appears four times.
The YString class is not a very useful one, but it helps illustrate how you can customize the behavior of len() to suit your needs. The .__len__() method must return a non-negative integer. Otherwise, it raises an error.
Another special method is the .__bool__() method, which determines how an object can be converted to a Boolean. The .__bool__() dunder method is not normally defined for sequences and collections. In these cases, the .__len__() method determines the truthiness of an object:
The variable first_string doesn’t have a Y in it. As shown by the output from bool() , the string is truthy as it’s non-empty. However, when you create an object of type YString from this string, the new object is falsy as there are no Y letters in the string. Therefore, len() returns 0 . In contrast, the variable second_string does include the letter Y, and so both the string and the object of type YString are truthy.
You can read more about using object-oriented programming and defining classes in Object-Oriented Programming (OOP) in Python 3.
Conclusion
You’ve explored how to use len() to determine the number of items in sequences, collections, and other data types that hold several items at a time, such as NumPy arrays and pandas DataFrames.
The len() Python function is a key tool in many programs. Some of its uses are straightforward, but there’s a lot more to this function than its most basic use cases, as you’ve seen in this tutorial. Knowing when you can use this function and how to use it effectively will help you write neater code.
In this tutorial, you’ve learned how to:
- Find the length of built-in data types using len()
- Use len() with third-party data types
- Provide support for len() with user-defined classes
You now have a good foundation for understanding the len() function. Learning more about len() helps you understand the differences between data types better. You’re ready to use len() in your algorithms and to improve the functionality of some of your class definitions by enhancing them with the .__len__() method.
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: Python's len() Function
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 Stephen Gruppetta
Stephen worked as a research physicist in the past, developing imaging systems to detect eye disease. He now teaches coding in Python to kids and adults. And he's almost finished writing his first Python coding book for beginners
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:
Master Real-World Python Skills With Unlimited Access to Real Python
Join us and get access to thousands of tutorials, hands-on video courses, and a community of expert Pythonistas:
Master Real-World Python Skills
With Unlimited Access to Real Python
Join us and get access to thousands of tutorials, hands-on video courses, and a community of expert Pythonistas:
What Do You Think?
What’s your #1 takeaway or favorite thing you learned? How are you going to put your newfound skills to use? Leave a comment below and let us know.
Commenting Tips: The most useful comments are those written with the goal of learning from or helping out other students. Get tips for asking good questions and get answers to common questions in our support portal. Looking for a real-time conversation? Visit the Real Python Community Chat or join the next “Office Hours” Live Q&A Session. Happy Pythoning!
Числа в Python
Когда мы хотим представить информацию о количестве деревьев в саду, остатке на банковской карте или же провести какие-либо математические расчеты, мы используем числа. В Python числа представлены сразу несколькими родственными категориями типов. Сюда относятся целые ( int ), вещественные ( float ) и комплексные ( complex ) числа. Если возможностей базовых типов не хватает, всегда можно воспользоваться числовыми расширениями в виде модулей decimal или fractions. Все перечисленные числовые типы довольно легко преобразуются между собой, а математические операции с ними интуитивно понятны и производятся по общепринятым правилам математики.
Целые числа
По умолчанию для записи литералов целых чисел в Python используется десятичная система счисления, однако разрешается записывать их в двоичной, восьмеричной и шестнадцатеричной системах счисления. При этом следует помнить, что вне зависимости от используемого формата представления, результат все равно будет отображаться в десятичном виде (см. пример №1 ).
Пример №1. Литералы целых чисел в Python.
Как видно из примера №1 , синтаксис записи целых чисел в разрешенных системах счисления должен иметь следующий вид.
- В десятичной системе счисления целые числа записываются в виде привычной нам последовательности цифр от нуля до десяти, например, 0 , -33 , +127 .
- В двоичной системе счисления запись целого числа должна начинаться с нуля и латинской буквы B в верхнем или нижнем регистре (т.е. 0b или 0B ), после чего должна идти последовательность нулей и единиц. Например, 0b01101 , 0B1011 , -0b1001 . Если будут использованы другие цифры, интерпретатор сгенерирует сообщение об ошибке.
- В восьмеричной системе счисления целое число должно начинаться с нуля и латинской буквы O в верхнем или нижнем регистре (т.е. 0o или 0O ), после чего должна идти последовательность цифр от нуля до семи ( 01234567 ). Например, 0o77 , 0O35 , -0O174 . Если будут использованы цифры не входящие в данный диапазон, интерпретатор сгенерирует сообщение об ошибке.
- В шестнадцатеричной системе счисления запись целого числа должна начинаться с нуля и латинской буквы X в верхнем или нижнем регистре (т.е. 0x или 0X ), после чего должны идти символы последовательности 0123456789ABCDEF , представляющих данную систему счисления. При этом буквы также разрешается использовать в любом регистре. Например, 0x7F , 0XDD5A , -0xfF9 . Если будут использованы символы не входящие в данный диапазон, интерпретатор сгенерирует сообщение об ошибке.
Кроме того, во всех случаях разрешается использовать перед числом знаки плюса ( + ) и минуса ( — ). Также можно переводить целые числа из одной системы счисления в другую. Для этого следует использовать следующие встроенные функции.
- bin(int_num) – преобразует целое число в двоичную систему счисления, возвращая строку с представлением литерала числа в этой системе.
- oct(int_num) – преобразует целое число в восьмеричную систему счисления, возвращая строку с представлением литерала числа в этой системе.
- hex(int_num) – преобразует целое число в шестнадцатеричную систему счисления, возвращая строку с представлением литерала числа в этой системе.
- int(obj) – конструктор типа int может использоваться как с одним, так и с двумя аргументами. Когда указан только один аргумент, функция пытается преобразовать объект в целое число в десятичной системе счисления, а в случае невозможности такого преобразования возбуждает соответствующее исключение. При этом, если объект obj является вещественным числом, оно преобразуется в целое путем усечения дробной части, например, int(21.302) вернет 21 .
- int(num_str, base=10) – если указано два аргумента, то первый аргумент должен быть строковым представлением целого числа в системе счисления с указанным основанием base . Разрешается использовать системы счисления с основаниями от 2 до 36 . При этом префикс 0b , 0o или 0x у строкового представления числа можно опускать. Если же точно известно, что в строковом представлении числа присутствует соответствующий префикс, второму аргументу разрешается передавать ноль, т.к. интерпретатор сможет определить систему счисления переводимого числа по указанному префиксу. В случае невозможности преобразования строки в целое число функция возбуждает соответствующее исключение (см. пример №2 ).
Пример №2. Перевод целых чисел между СС.
Итак, функции bin(int_num) , oct(int_num) и hex(int_num) принимают целые числа и возвращают строковые представления этих чисел в соответствующих системах счисления. Если же требуется обратное преобразование в десятичную систему, то следует передавать числа функции int(num_str, base=10) , предварительно приведя число к строке ( num_str = str(num) ) и указав основание системы счисления переводимого числа.
Подробнее о переводе чисел из одной системы счисления в другую можно почитать на нашей страничке здесь. Там же представлен калькулятор для перевода чисел из одной системы счисления в другую, а также ряд задач на закрепление теории.
Далее. Целые числа в Питоне отличаются тем, что их размер в принципе ограничивается лишь доступной памятью. Т.е. они поддерживают длинную арифметику и могут быть сколь угодно большими (см. пример №3 ). При этом следует помнить, что при обработке очень больших чисел приходится жертвовать скоростью их обработки.
Пример №3. Пример очень большого целого числа.
Также следует отметить, что в отличие от других типов чисел над целыми числами в Python можно производить битовые операции, перечень которых представлен для ознакомления в порядке возрастания их приоритета в таблице №4 . Подробнее данный вопрос мы рассмотрим позже, когда будем рассматривать битовые операции.
Таблица №4. Список битовых операций, применимых к целым числам.
Также у типа int имеется несколько дополнительных методов:
- int.bit_length() – метод возвращает количество бит, которое необходимо для представления числа в памяти в двоичном виде, без учета знака и незначащих (лидирующих) нулей;
- int.to_bytes(length, byteorder, *, signed=False) – метод возвращает массив байтов, который соответствует данному числу;
- int.from_bytes(bytes, byteorder, *, signed=False) – метод класса, который возвращает целое число, соответствующее указанному массиву байтов.
Как видим, все дополнительные методы тоже касаются битов и байтов, поэтому мы их сейчас рассматривать не будем.
Вещественные числа
Что касается записи литералов вещественных чисел (по-другому чисел с плавающей точкой), то в Python для них используется привычный нам математический синтаксис: сперва записывается знак числа (плюс можно не указывать), затем последовательность цифр целой части, разделительная точка и последовательность цифр дробной части. Например, 0.33 , .33 , 0.0 , .0 , -123.45 , -.123 . Также допустима запись вещественных чисел в экспоненциальной форме. При этом для представления степени 10 n используется латинская буква E в верхнем или нижнем регистре (т.е. e или E ), следующий за ней необязательный знак плюс или обязательный знак минус, а также сам показатель степени в виде положительного целого числа или нуля (см. пример №5 ).
Пример №5. Литералы вещественных чисел в Python.
В отличие от целых чисел вещественные не поддерживают длинную арифметику. В обычных условиях их точность ограничивается максимум 17 значащими цифрами. Поэтому для очень маленьких и очень больших вещественных чисел получаются весьма неточные результаты (см. пример №6 ). Если же в расчетах необходима высокая точность представления вещественных чисел, следует использовать, например, модуль decimal , позволяющий задавать требуемую точность результата (опять же, за счет снижения скорости обработки таких чисел).
Пример №6. Точность представления вещественных чисел в Python.
Неточное представление вещественных чисел в Python , впрочем как и в других языках программирования, может иногда приводить к неожиданным результатам (см. пример №7 ). Это связано с тем, что мы в основном привыкли вести расчеты в десятичной системе счисления, а компьютер перед вычислениями преобразует все числа в двоичную систему. Но не все вещественные числа могут быть точно преобразованы из десятичной системы счисления в двоичную, что и приводит к некоторой потере точности при хранении десятичных чисел в памяти компьютера.
Пример №7. Побочные эффекты сложения вещественных чисел в Python.
Как видим, на первый взгляд результат действительно получился неожиданным (не забываем про кнопку «Результат» ). Однако все верно. Ведь в данном случае при переводе десятичных чисел в двоичную систему компьютер не смог перевести их точно, округлив результат так, чтобы получившееся двоичное число поместилось в пределах выделяемого для хранения вещественного числа объема памяти. В результате у нас получилось число несколько меньшее, чем 0.8 . Но, повторимся, это не проблема Python , это проблема математики и невозможности во всех случаях осуществить точный перевод чисел из одной системы счисления в другую.
Не стоит сравнивать вещественные числа, доверяя их точности до последнего знака.
В заключение данного пункта перечислим дополнительные методы типа float .
- float.as_integer_ratio() – метод возвращает кортеж из пары целых чисел, которые представляют собой числитель и знаменатель наименьшей дроби, равной данному вещественному числу. Если вещественное число отрицательное, то первое число в возвращаемом кортеже будет со знаком минус. При этом второе число всегда положительное (см. пример №8 ).
- float.is_integer() – метод возвращает True , если дробная часть вещественного числа равна нулю.
- float.hex() – метод возвращает строковое представление числа с плавающей точкой в шестнадцатеричной системе счисления. При этом следует иметь в виду, что экспонента в таком представлении обозначается буквой p , т.к. буква e представляет собой допустимый символ в 16 -ной системе счисления.
- float.fromhex(float_num_str) – этот метод класса осуществляет преобразование строкового представления вещественного числа float_num_str в шестнадцатеричной системе счисления обратно в вещественное число в десятичной системе счисления.
Пример №8. Дополнительные методы типа float.
Комплексные числа
Комплексные числа в Python представлены типом complex , который хранит два вещественных числа: первое представляет собой действительную часть комплексного числа, а второе – мнимую. Как и принято в математике, действительная и мнимая части литерала комплексного числа объединяются знаком плюс или минус (см. пример №9 ). Однако за мнимой частью в Python следует символ j , как это принято в инженерии (в математике мнимая единица обозначается через i ).
Пример №9. Литералы комплексных чисел в Python.
Как видно из примера, если действительная часть комплексного числа равна 0 , ее можно опустить. Кроме того, отдельные части комплексного числа доступны в виде атрибутов real и imag , а получить сопряженное данному комплексное число можно изменив знак мнимой части при помощи метода complex.conjugate() .
Вполне возможно, что сталкиваться с комплексными числами вам придется довольно редко, однако иметь представление о наличии такого типа все-таки не помешает.
Математические операции в Python
Все известные нам со школы математические операции полностью поддерживаются в Python . Перечислим их и рассмотрим примеры.
- x + y – сложение двух чисел.
- x — y – вычитание двух чисел.
- x * y – умножение двух чисел.
- x / y – деление двух чисел. При делении вещественных и целых чисел (даже без остатка) результат всегда является вещественным числом. Если же в делении присутствуют комплексные числа, интерпретатор возвращает комплексный результат (см. пример №10 ).
- x // y – деление с округлением вниз. Например, 1//2 = 0 , -1//2 = -1 , 1//-2 = -1 , -1//-2 = 0 .
- x % y – операция возвращает остаток от деления целых и вещественных чисел. Если оба числа целые, то возвращается целочисленный остаток (тип int ). Например, 5%3 = 2 , -5%3 = 1 (т.к. -5 = 3*(-2) + 1 ), 6%3 = 0 . Если хотя бы одно число вещественное, остаток от деления также возвращается в вещественном виде (тип float ), при чем из-за неточности представления вещественных чисел результат может оказаться неточным. Например, 5.2%3 = 2.2 (все в порядке), -5.2%3 = 0.7999999999999998 (получили неточный результат, хотя ожидали 0.8 , т.к. -5.2 = 3*(-2) + 0.8 ). Что касается комплексных чисел, то для них операция неприменима.
- +x – операция используется в основном для повышения удобочитаемости кода, т.к. по факту она ничего не делает.
- -x – инверсия знака числа отличного от нуля, т.е. изменение плюса на минус или наоборот. Для нуля ничего не происходит.
- x ** y – возведение в степень. Отметим, что 0**0 = 1 .
Пример №10. Базовые математические операции в Python.
Что касается математических выражений, в которых используются сразу несколько операций, то для их группировки предназначены круглые скобки (см. пример №11 ). При этом внутри скобок приоритет отдается сперва возведению в степень ( x**y ), затем равносильно умножению ( x*y ), делению ( x/y ), делению с округлением вниз ( x//y ) и получению остатка от деления ( x%y ); в конце равнозначно выполняются сложение ( x + y ) и вычитание ( x — y ). Более подробно о приоритете операторов в Python (и не только математических) мы поговорим позже.
Если в выражении встречаются подряд идущие операторы с одинаковым приоритетом, то по умолчанию интерпретатор обрабатывает их слева направо. Однако, во избежание ошибок, старайтесь всегда использовать скобки, непосредственно определяя порядок группировки и не полагаясь на приоритет или ассоциативность операторов.
Пример №11. Математические выражения в Python.
Обратите внимание, что при наличии в одном выражении целых и вещественных чисел, интерпретатор при необходимости осуществляет приведение целых чисел к типу float , т.е. к более объемлющему типу (в математике целые числа являются подмножеством вещественных, а те в свою очередь принадлежат множеству комплексных чисел).
В дополнение к математическим операторам Python предоставляет и ряд полезных встроенных функций, позволяющих, например, найти модуль числа или округлить его (см. пример №12 ). Опять же, перечислим их и приведем краткое описание.
- divmod(x, y) – возвращает кортеж (x//y, x%y) . При этом для комплексных чисел она не предназначена.
- pow(x, y) – возвращает x в степени y (аналог x ** y ).
- abs(x) – возвращает абсолютное значение (модуль) числа x .
- round(x, n) – округляет число до n -го разряда после запятой. Если аргумент n не указан, то число округляется до ближайшего целого.
- max(num_1, num_2, . num_n) – возвращает максимальное из двух и более чисел.
- min(num_1, num_2, . num_n) – возвращает минимальное из двух и более чисел.
- sum(num_1, num_2, . num_n) – возвращает сумму двух и более чисел.
- int(x) – приведение числа к типу int .
- float(x) – приведение числа к типу float .
- complex(re, im=0) – приведение к типу complex . Аргумент im (мнимая часть будущего комплексного числа) можно не передавать, тогда он по умолчанию будет равен нулю.
Пример №12. Встроенные математические функции в Python.
Конечно же данный перечень встроенных функций довольно мал, но не стоит забывать про математические расширения и даже целые библиотеки, которые вполне смогут удовлетворить даже самых привередливых математиков. В частности, в следующем пункте мы познакомимся с модулем math стандартной библиотеки Python . Но сперва давайте закончим рассмотрение оставшейся части операторов, использующихся с числами.
Как вы наверняка помните, помимо основных операций вроде сложения и умножения, использующихся в обычных выражениях или уравнениях, в математике широко используются и операции сравнения чисел (например, в неравенствах). Перечислим их.
- x < y – выражение вернет True , если x строго меньше y .
- x > y – выражение вернет True , если x строго больше y .
- x <= y – выражение вернет True , если x меньше или равно y .
- x >= y – выражение вернет True , если x больше или равно y .
- x == y – выражение вернет True , если x равно y (в программировании один знак равно означает присвоить , поэтому для обозначения равенства используются два знака равно).
- x != y – выражение вернет True , если x не равно y .
Использование операторов сравнения показано в примере №13 .
Пример №13. Операторы сравнения чисел в Python.
В дополнение к базовому оператору присваивания = в Python применяется целый ряд комбинированных операторов присваивания, которые объединяют операцию присваивания с другой операцией. В общем случае выражение присваивания с комбинированным оператором x op= y можно считать сокращенной записью выражения x = x op y , где вместо op следует подставлять один из арифметических операторов. Например, x += y является сокращенной записью выражения x = x + y , в котором к значению переменной x прибавляется значение переменной y , после чего результат присваивается переменной x . Использование некоторых комбинированных операторов присваивания показано в примере №14 .
Пример №14. Комбинированные операторы присваивания в Python.
Конечно же мы перечислили не все комбинированные операторы присваивания, имеющиеся в Python . Весь перечень будет представлен в таблице в следующей главе, посвященной выражениям и операторам. Сейчас же мы рассмотрим ряд математических функций модуля math , поставляющегося в комплекте стандартной библиотеки Python .
Модуль math
Модуль math обеспечивает доступ к широкому кругу математических функций и констант, которые определены стандартом языка C . При этом модуль не поддерживает операции с комплексными числами, хотя они и определены стандартом языка Python . Но это не является большой проблемой, т.к. для операций с ними нужно просто воспользоваться модулем сmath , в котором легко найти требуемые функции, но уже с поддержкой комплексных чисел. Также стоит помнить, что, если явно не указано иное, все возвращаемые функциями модуля значения являются числами с плавающей точкой.
Для начала давайте рассмотрим представленные в модуле math математические константы и функции проверки чисел на принадлежность к ним.
- math.pi – представляет значение числа π с точностью, которая зависит от конкретной платформы. Мы его помним, как число 3.14 .
- math.tau ( чит. тау) – представляет удвоенное значение числа π с точностью, которая зависит от конкретной платформы. Т. о. τ – это отношение радиуса окружности к ее длине. Приблизительно оно равно 6.28 .
- math.e – представляет значение числа e с точностью, которая зависит от конкретной платформы. Мы его помним, как число 2.72 .
- math.inf (от англ. infinity) – представляет положительную бесконечность. Отметим, что значение является типом float и может быть получено вызовом конструктора float(‘inf’) . Для получения отрицательной бесконечности следует использовать унарный оператор — (см. пример №15 ). К значению inf в математике приводит, например, операция деления на 0 .
- math.nan (от англ. not a number) – представляет значение не число , которое также является типом float и может быть получено вызовом конструктора float(‘nan’) . К значению nan приводят недопустимые математические операции (например, извлечение корня четной степени из отрицательного числа на множестве вещественных чисел) или выход за допустимый диапазон значений для данной математической функции.
- math.isinf(x) – возвращает True , если x является отрицательной или положительной бесконечностью, или False в противном случае.
- math.isnan(x) – возвращает True , если x является значением nan , или False в противном случае.
- math.isfinite(x) – возвращает False , только если x является nan , inf или -inf . Во всех остальных случаях функция возвращает True .
Пример №15. Математические константы модуля math.
Что касается конкретно функций модуля math , то в нем представлены различные функции теории чисел, степенные, логарифмические, тригонометрические, гиперболические и ряд других функций. Все мы их здесь рассматривать не будем, однако краткое описание некоторых из них приведем в списке ниже. Остальные в случае необходимости всегда можно с легкостью найти в разделе «Numeric and Mathematical Modules» справочника стандартной библиотеки в описании модуля math (или cmath для комплексных чисел). Итак.
- math.ceil(x) – возвращает x , округленное вверх до ближайшего целого (см. пример №16 ).
- math.floor(x) – возвращает x , округленное вниз до ближайшего целого.
- math.trunc(x) – возвращает целую часть x , полностью отсекая дробную.
Пример №16. Функции модуля math (часть 1).
- math.factorial(x) – возвращает факториал неотрицательного целого числа x . Отметим, что факториалы чисел 0 и 1 принимаются равными 1 .
- math.sqrt(x) – возвращает квадратный корень из неотрицательного числа x (см. пример №17 ).
- math.log(x[, base]) – возвращает логарифм числа x по основанию base . Аргумент base можно опустить, тогда функция вернет натуральный логарифм числа x .
Пример №17. Функции модуля math (часть 2).
- math.sin(x) – возвращает синус угла x , значение которого задано в радианах. Отметим, что для косинуса угла функция имеет вид math.cos(x) (см. пример №18 ).
- math.tan(x) – возвращает тангенс угла x , значение которого задано в радианах.
- math.asin(x) – возвращает арксинус числа x . Для аркосинуса нужно использовать функцию math.acos(x) , а для арктангенса – math.atan(x) .
- math.degrees(x) – преобразует угол x из радиан в градусы.
- math.radians(x) – преобразует угол x из градусов в радианы.
Пример №18. Функции модуля math (часть 3).
Обязательно откройте модуль math в справочнике стандартной библиотеки и хотя бы бегло просмотрите весь список доступных функций. Кстати, не забываем, что получить его можно и программно через dir(math) .
Модуль decimal
Как мы уже знаем, числа типа float имеют весьма ограниченную точность. И хотя во многих случаях это не существенно, бывают ситуации, когда требуется повышенная точность вычислений, пусть даже и в ущерб производительности. В таких случаях нам на помощь приходит модуль decimal , который реализует неизменяемый числовой тип Decimal , представляющий числа с фиксированной точностью (см. пример №19 ).
Пример №19. Создание чисел фиксированной точности.
Как видим, для создания числа фиксированной точности Decimal необходимо передать конструктору Decimal строку с представлением требуемого числа или использовать функцию str для приведения числа к строке. Если в выражении используются числа с различной точностью представления, то для результата интерпретатор выберет наилучшую точность представления.
В принципе, конструктору Decimal можно передавать не только строковые представления чисел, но и сами целые и вещественные числа, а также их кортежи. Однако преобразование вещественных чисел в числа фиксированной точности иногда может порождать большое число десятичных знаков.
Числа типа Decimal обычно используются в определенном контексте, который подразумевает использование установленной точности представления, методики округления (вверх, вниз и т.д.) и некоторых других настроек (см. пример №20 ).
Пример №20. Изменение точности представления чисел Decimal.
Все настройки среды для арифметических операций получаемые при помощи метода decimal.getcontext() доступны для изменения. Кроме того, для установки нового контекста можно использовать метод decimal.setcontext() . С этим и некоторыми другими методами для работы с контекстами вы можете ознакомиться в модуле decimal стандартной библиотеки (см. раздел «Numeric and Mathematical Modules» ).
Отметим, что все арифметические операции, включая комбинированные, применимы и к числам Decimal . Однако модуль math для них неприменим. В тоже время некоторые функции, присутствующие в модуле math , реализованы как методы типа Decimal (см. пример №21 ).
Пример №21. Операции с числами Decimal.
Модуль fractions
Еще одним числовым типом в Python является тип Fraction . Он реализует объекты рациональных чисел, которые явным образом хранят числитель и знаменатель рациональной дроби (см. пример №22 ), что опять же при необходимости помогает избежать недостатков вещественных чисел.
Пример №22. Создание рациональных чисел.
В примере мы создали объекты рациональных чисел, указав в конструкторе Fraction в первом выражении числитель и знаменатель, а во втором передав ему вещественное число и строковое представление вещественного числа. Кроме того, рациональную дробь можно создать и конвертацией типа Decimal . В любом случае после создания объекты рациональных чисел могут участвовать в арифметических операциях, как обычные числа (см. пример №23 ).
Пример №23. Операции с рациональными числами.
Познакомиться с рациональными числами и их методами более подробно вы можете в модуле fractions стандартной библиотеки Python (см. раздел «Numeric and Mathematical Modules» ).
Краткие итоги параграфа
- Числа в Python представлены тремя базовыми типами: целые числа int , числа с плавающей точкой float и комплексные числа complex . Также посредством стандартной библиотеки доступны два расширения в виде чисел с фиксированной точностью Decimal и рациональных чисел Fraction .
- Для записи литералов целых чисел используется десятичная система счисления, однако разрешается записывать их в двоичной (например, 0b101 ), восьмеричной (например, -0o175 ) и шестнадцатеричной (например, 0xF5A ) системах счисления. Для перевода целых чисел из одной системы счисления в другую предназначены встроенные функции bin(int_num) , oct(int_num) , hex(int_num) , int(num_str, base=10) .
- Целые числа поддерживают длинную арифметику и могут быть сколь угодно большими. При этом следует помнить, что при обработке очень больших чисел приходится жертвовать скоростью их обработки.
- Для записи литералов вещественных чисел используется привычный нам математический синтаксис, например, -2.57 , 0.0 , .28 (ноль перед точкой можно опускать). Также допустима запись вещественных чисел в экспоненциальной форме, например, 1.2345e2 (т.е. 1.2345*10 2 ) или -1.2345E-3 (т.е. -1.2345*10 -3 ).
- В обычных условиях точность вещественных чисел ограничивается максимум 17 значащими цифрами. Поэтому не стоит сравнивать их, доверяя точности до последнего знака.
- Комплексные числа в Python хранят два вещественных числа: первое представляет собой действительную часть комплексного числа, а второе – мнимую. Например, -0.4+7j , 2-1.45j или 3.1j (нулевую действительную часть можно опускать).
- В Python поддерживаются все известные нам со школы математические операции: сложение x + y , вычитание x — y , умножение x*y , деление x/y , деление с округлением вниз x//y , получение остатка от деления x%y , возведение в степень x**y . Стоит помнить, что некоторые операции не применимы к комплексным числам.
- В дополнение к базовому оператору присваивания = в Python применяется целый ряд комбинированных операторов присваивания, которые объединяют операцию присваивания с другой операцией. Например, += , -= , *= , /= , //= , %= , **= . Как видим, в общем случае выражение присваивания с комбинированным оператором x op= y можно считать сокращенной записью выражения x = x op y , где вместо op следует подставлять один из арифметических операторов.
- Для сравнения чисел используются операторы < , > , <= , >= , == (равно), != (не равно).
- Помимо стандартных арифметических операций имеется и ряд полезных встроенных функций для работы с числами: divmod(x, y) – возвращает кортеж (x//y, x%y) , pow(x, y) – возвращает x в степени y , abs(x) – возвращает модуль числа x , round(x, n) – округляет число до n -го разряда после запятой, max(num_1, num_2, . num_n) , min(num_1, num_2, . num_n) и sum(num_1, num_2, . num_n) – соответственно возвращают максимальное, минимальное и сумму из двух и более чисел.
- Если встроенных функций недостаточно, можно воспользоваться расширением math стандартной библиотеки, которое обеспечивает доступ к широкому кругу математических функций и констант, которые определены стандартом языка C . Для комплексных чисел следует использовать модуль cmath .
- Для случаев, когда требуется повышенная точность вычислений, в Python предусмотрены дополнительные типы числовых объектов: числа с фиксированной точностью Decimal , которые позволяют устанавливать требуемую точность вычислений, способ округления и некоторые другие параметры, а также рациональные числа Fraction , которые явным образом хранят числитель и знаменатель рациональной дроби. Оба модуля доступны в стандартной библиотеке Python в разделе «Numeric and Mathematical Modules» .
Вопросы и задания для самоконтроля
1. Какие из представленых литералов чисел относятся к типу int , а какие к типу float : 3.4 , 0 , 5.0 , 0.0 , 123+4.1j , 795 ? Проверьте типы программно. Показать решение.
Ответ. Тип int : 0 и 795 . Тип float : 3.4 , 5.0 , 0.0 .
2. Определите системы счисления целых чисел 0x1101 , 0b1101 , 0o755 , 0X755 и 755 , записанные в исходном коде программы. Показать решение.
Ответ. Двоичная СС: 0b1101 ; восьмеричная СС: 0o755 ; десятичная СС: 755 , шестнадцатеричная СС: 0x1101 и 0X755 .
3. Какая операция над целыми числами никогда не дает в результате целое число? Показать решение.
Ответ. Результат деления целых чисел всегда имеет тип float , даже при делении без остатка. Например, 15/5 вернет 3.0 , а не 3 .
4. Как можно получить действительную и мнимую части комплексного числа? А как получить число, сопряженное к данному комплексному числу? Показать решение.
Ответ. Отдельные части комплексного числа доступны в виде атрибутов real и imag , а получить сопряженное данному комплексное число можно изменив знак мнимой части при помощи метода complex.conjugate() .
5. Вычислите устно и программно значения выражений 2*(3 + 4) и 2*3 + 4 . Объясните результаты. Показать решение.
Ответ. В Python как и в математике первыми выполняются действия в скобках, поэтому 2*(3 + 4) = 14 . Если скобки отсутствуют, то первыми выполняются операции с более высоким приоритетом. А так как приоритет умножения выше приоритета сложения, то 2*3 + 4 = 10 .
6. Каким будет тип результата вычисления выражения 7 — 3 + 2.0 и почему? Проверьте свой ответ программно. Показать решение.
Ответ. Результатом будет вещественное число, т.к. интерпретатор всегда преобразует числа к более сложному числовому типу, который встречается в выражении.
7. Каким будет остаток от деления числа 63 на число 5 ? Проверьте свой ответ программно. Показать решение.
8. Как получить доступ к функциям модуля math ? Показать решение.
Ответ. Нужно импортировать его при помощи инструкции import math .
9. Исправьте в коде пять ошибок (по одной в каждом блоке). Показать решение.
10. Дополнительные упражнения и задачи по теме расположены в разделе «Числа и математические выражения» нашего сборника задач и упражнений по языку программирования Python .
1. Типы данных¶
Переменная в языке программирования это название для зарезервированного места в памяти компьютера, предназначенное для хранения значений. Это означает, что когда вы создаете переменную, вы на самом деле резервируете определенное место в памяти компьютера. Основываясь на типе данных переменной, интерпретатор выделяет необходимое количество памяти и решает, что может находится в зарезервированной области памяти. Для понимания, можете думать о переменной как о коробке, в которую можно положить любую вещь, но только определенного размера. Размер в данном примере будет типом переменной. Это не совсем верное определение, но оно дает общее представление о картине в целом.
Присвоение значения переменной:
В Python вам не нужно объявлять тип переменной вручную (как, например в С++). Объявление происходит автоматически (это называется динамическая типизация), когда вы присваиваете значение переменной. Знак равенства ( = ) используется для присвоения значения переменной. Операнд по левую сторону от знака равно ( = ) это имя переменной, операнд по правую сторону — значение присвоенное этой переменной.
Найти количество цифр в числе в Python
В этом руководстве будут представлены методы подсчета количества цифр внутри числа в Python.
Please enable JavaScript
Найдите количество цифр внутри числа с помощью функции math.log10() в Python
Функция math.log10() внутри модуля math Python используется для поиска журнала по основанию 10 для любого указанного числа. Поскольку целые числа также находятся в базе 10, мы можем получить количество цифр внутри указанного целого числа с помощью этого метода.
Следующий фрагмент кода показывает нам, как найти количество цифр внутри числа с помощью функции math.log10() .
Мы вычислили количество цифр внутри числа -10 с помощью функции math.log10() в приведенном выше коде. Этот код также обрабатывает случай, когда число равно 0, поскольку логарифм 0 не может быть вычислен. Сначала мы проверяем, больше ли число 0. Если число больше 0, мы вычисляем цифры, беря журнал и добавляя 1 к результату. Этот процесс выполняется, потому что журнал любого числа на 1 меньше, чем количество цифр внутри этого числа.
Если число равно 0, мы устанавливаем цифры равными 1. Если число меньше 0, мы вычисляем количество цифр, беря логарифм аддитивного обратного значения этого отрицательного числа и прибавляя 2 к результату. В случае отрицательных чисел мы добавляем дополнительную единицу, потому что в этом примере мы рассматриваем знак — как цифру. В итоге печатаем количество цифр на экране.
Этот метод удобен, если мы хотим определить количество цифр внутри целого числа. Однако он не работает с десятичными числами или любыми числами с плавающей десятичной запятой.
Найдите количество цифр внутри числа с помощью функции len() в Python
Функция len() — это встроенная функция в Python, используемая для вычисления количества символов внутри строковой переменной. Функция len() принимает строку в качестве входного параметра и возвращает количество символов внутри этой строки. Чтобы вычислить количество цифр внутри числа с помощью функции len() , мы сначала должны преобразовать это число в строку с помощью функции str() .
Функция str() также является встроенной функцией в Python, используемой для преобразования объектов разных типов в строковую переменную. Следующий фрагмент кода показывает нам, как найти количество цифр внутри числа с помощью функции len() :
Мы вычислили количество цифр внутри числа -100.90 с помощью функции len() в приведенном выше коде. Сначала мы преобразовали число в строку с помощью функции str() . После этого мы передали результирующую строку в функцию len() и сохранили значения, возвращаемые функцией len() , внутри переменной digits . В конце концов, мы вывели значение внутри переменной digits . Выходные данные ясно показывают, что этот подход также применим для десятичных чисел или чисел, содержащих десятичную точку с плавающей запятой.
Метод len() намного превосходит метод math.log10() для определения количества цифр внутри десятичного числа в Python. Причина в том, что метод len() ясен, краток, а также обрабатывает десятичные дроби с плавающей запятой, в отличие от метода math.log10() , который излишне сложен и не обрабатывает десятичные числа с плавающей запятой.
Maisam is a highly skilled and motivated Data Scientist. He has over 4 years of experience with Python programming language. He loves solving complex problems and sharing his results on the internet.