Список
Список — это непрерывная динамическая коллекция элементов. Каждому элементу списка присваивается порядковый номер — его индекс. Первый индекс равен нулю, второй — единице и так далее. Основные операции для работы со списками — это индексирование, срезы, добавление и удаление элементов, а также проверка на наличие элемента в последовательности.
Создание пустого списка выглядит так:
Создадим список, состоящий из нескольких чисел:
numbers = [ 40 , 20 , 90 , 11 , 5 ]
Настало время строковых переменных:
fruits = [ ‘Apple’ , ‘Grape’ , ‘Peach’ , ‘Banan’ , ‘Orange’ ]
Не будем забывать и о дробях:
fractions = [ 3.14 , 2.72 , 1.41 , 1.73 , 17.9 ]
Мы можем создать список, состоящий из различных типов данных:
values = [ 3.14 , 10 , ‘Hello world!’ , False, ‘Python is the best’ ]
И такое возможно (⊙_⊙)
list_of_lists = [[ 2 , 4 , 0 ], [ 11 , 2 , 10 ], [ 0 , 19 , 27 ]]
Индексирование
Что же такое индексирование? Это загадочное слово обозначает операцию обращения к элементу по его порядковому номеру ( ( ･ω･)ア напоминаю, что нумерация начинается с нуля). Проиллюстрируем это на примере:
fruits = [ ‘Apple’ , ‘Grape’ , ‘Peach’ , ‘Banan’ , ‘Orange’ ]
print (fruits[ 0 ])
print (fruits[ 1 ])
print (fruits[ 4 ])
Списки в Python являются изменяемым типом данных. Мы можем изменять содержимое каждой из ячеек:
fruits = [ ‘Apple’ , ‘Grape’ , ‘Peach’ , ‘Banan’ , ‘Orange’ ]
fruits[ 0 ] = ‘Watermelon’
fruits[ 3 ] = ‘Lemon’
print (fruits)
>>> [ ‘Watermelon’ , ‘Grape’ , ‘Peach’ , ‘Lemon’ , ‘Orange’ ]
Индексирование работает и в обратную сторону. Как такое возможно? Всё просто, мы обращаемся к элементу списка по отрицательному индексу. Индекс с номером -1 дает нам доступ к последнему элементу, -2 к предпоследнему и так далее.
fruits = [ ‘Apple’ , ‘Grape’ , ‘Peach’ , ‘Banan’ , ‘Orange’ ]
print (fruits[ -1 ])
print (fruits[ -2 ])
print (fruits[ -3 ])
print (fruits[ -4 ])
Создание списка с помощью list()
Переходим к способам создания списка. Самый простой из них был приведен выше. Еще раз для закрепления:
А есть еще способы? Да, есть. Один из них — создание списка с помощью функции list() В неё мы можем передать любой итерируемый объект (да-да, тот самый по которому можно запустить цикл (• ᵕ •) )
Рассмотрим несколько примеров:
letters = list ( ‘abcdef’ )
numbers = list ( range ( 10 ))
even_numbers = list ( range ( 0 , 10 , 2 ))
print (letters)
print (numbers)
print (even_numbers)
>>> [ ‘a’ , ‘b’ , ‘c’ , ‘d’ , ‘e’ , ‘f’
>>> [ 0 , 1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 , 9 ]
>>> [ 0 , 2 , 4 , 6 , 8 ]
Длина списка
С созданием списка вроде разобрались. Следующий вопрос: как узнать длину списка? Можно, конечно, просто посчитать количество элементов. (⊙_⊙) Но есть способ получше! Функция len() возвращает длину любой итерируемой переменной, переменной, по которой можно запустить цикл. Рассмотрим пример:
fruits = [ ‘Apple’ , ‘Grape’ , ‘Peach’ , ‘Banan’ , ‘Orange’ ]
print ( len (fruits))
numbers = [ 40 , 20 , 90 ]
print ( len (numbers))
«. любой итерируемой», а это значит:
string = ‘Hello world’
print ( len (string))
# 11
print ( len ( range ( 10 ))
Срезы
В начале статьи что-то говорилось о «срезах». Давайте разберем подробнее, что это такое. Срезом называется некоторая подпоследовательность. Принцип действия срезов очень прост: мы «отрезаем» кусок от исходной последовательности элемента, не меняя её при этом. Я сказал «последовательность», а не «список», потому что срезы работают и с другими итерируемыми типами данных, например, со строками.
fruits = [ ‘Apple’ , ‘Grape’ , ‘Peach’ , ‘Banan’ , ‘Orange’ ]
part_of_fruits = fruits[ 0 :3]
print (part_of_fruits)
>>> [ ‘Apple’ , ‘Grape’ , ‘Peach’ ]
Детально рассмотрим синтаксис срезов:
итерируемая_переменная[начальный_индекс:конечный_индекс — 1 :длина_шага]
Обращаю ваше внимание, что мы делаем срез от начального индекса до конечного индекса — 1. То есть i = начальный_индекс и i = [ ‘Apple’ , ‘Grape’ , ‘Peach’ , ‘Banan’ , ‘Orange’ ]
print (fruits[ 0 :1])
# Если начальный индекс равен 0, то его можно опустить
print (fruits[: 2 ])
print (fruits[: 3 ])
print (fruits[: 4 ])
print (fruits[: 5 ])
# Если конечный индекс равен длине списка, то его тоже можно опустить
print (fruits[: len (fruits)])
print (fruits[::])
>>> [ ‘Apple’ ]
>>> [ ‘Apple’ , ‘Grape’ ]
>>> [ ‘Apple’ , ‘Grape’ , ‘Peach’ ]
>>> [ ‘Apple’ , ‘Grape’ , ‘Peach’ , ‘Banan’ ]
>>> [ ‘Apple’ , ‘Grape’ , ‘Peach’ , ‘Banan’ , ‘Orange’ ]
>>> [ ‘Apple’ , ‘Grape’ , ‘Peach’ , ‘Banan’ , ‘Orange’ ]
>>> [ ‘Apple’ , ‘Grape’ , ‘Peach’ , ‘Banan’ , ‘Orange’ ]
Самое время понять, что делает третий параметр среза — длина шага!
fruits = [ ‘Apple’ , ‘Grape’ , ‘Peach’ , ‘Banan’ , ‘Orange’ ]
print (fruits[:: 2 ])
print (fruits[:: 3 ])
# Длина шага тоже может быть отрицательной!
print (fruits[:: -1 ])
print (fruits[ 4 :2: -1 ])
print (fruits[ 3 :1: -1 ])
>>> [ ‘Apple’ , ‘Peach’ , ‘Orange’ ]
>>> [ ‘Apple’ , ‘Banan’ ]
>>> [ ‘Orange’ , ‘Banan’ , ‘Peach’ , ‘Grape’ , ‘Apple’ ]
>>> [ ‘Orange’ , ‘Banan’ ]
>>> [ ‘Banan’ , ‘Peach’ ]
А теперь вспоминаем всё, что мы знаем о циклах. В Python их целых два! Цикл for и цикл while Нас интересует цикл for, с его помощью мы можем перебирать значения и индексы наших последовательностей. Начнем с перебора значений:
fruits = [ ‘Apple’ , ‘Grape’ , ‘Peach’ , ‘Banan’ , ‘Orange’ ]
f or fruit in fruits:
print (fruit, end = ‘ ‘ )
>>> Apple Grape Peach Banan Orange
Выглядит несложно, правда? В переменную fruit объявленную в цикле по очереди записываются значения всех элементов списка fruits
А что там с перебором индексов?
f or index in range ( len (fruits)):
print (fruits[index], end = ‘ ‘ )
Этот пример гораздо интереснее предыдущего! Что же здесь происходит? Для начала разберемся, что делает функция range(len(fruits))
Мы с вами знаем, что функция len() возвращает длину списка, а range() генерирует диапазон целых чисел от 0 до len()-1.
Сложив 2+2, мы получим, что переменная index принимает значения в диапазоне от 0 до len()-1. Идем дальше, fruits[index] — это обращение по индексу к элементу с индексом index списка fruits. А так как переменная index принимает значения всех индексов списка fruits, то в цикле мы переберем значения всех элементов нашего списка!
Операция in
С помощью in мы можем проверить наличие элемента в списке, строке и любой другой итерируемой переменной.
fruits = [ ‘Apple’ , ‘Grape’ , ‘Peach’ , ‘Banan’ , ‘Orange’ ]
if ‘Apple’ in fruits:
print ( ‘В списке есть элемент Apple’ )
>>> В списке есть элемент Apple
fruits = [ ‘Apple’ , ‘Grape’ , ‘Peach’ , ‘Banan’ , ‘Orange’ ]
if ‘Lemon’ in fruits:
print ( ‘В списке есть элемент Lemon’ )
else :’
print ( ‘В списке НЕТ элемента Lemon’ )
>>> В списке НЕТ элемента Lemon
Приведу более сложный пример:
all_fruits = [ ‘Apple’ , ‘Grape’ , ‘Peach’ , ‘Banan’ , ‘Orange’ ]
my_favorite_fruits = [ ‘Apple’ , ‘Banan’ , ‘Orange’ ]
f or item in all_fruits:
if item in my_favorite_fruits:
print (item + ‘ is my favorite fruit’ )
else :
print ( ‘I do not like ‘ + item)
>>> Apple is my favorite fruit
>>> I do not like Grape
>>> I do not like Peach
>>> Banan is my favorite fruit
>>> Orange is my favorite fruit
Методы для работы со списками
Начнем с метода append(), который добавляет элемент в конец списка:
# Создаем список, состоящий из четных чисел от 0 до 8 включительно
numbers = list ( range ( 0 ,10, 2 ))
# Добавляем число 200 в конец списка
numbers. append ( 200 )
numbers. append ( 1 )
numbers. append ( 2 )
numbers. append ( 3 )
print (numbers)
>>> [ 0 , 2 , 4 , 6 , 8 , 200 , 1 , 2 , 3 ]
Мы можем передавать методу append() абсолютно любые значения:
all_types = [ 10 , 3.14 , ‘Python’ , [ ‘I’ , ‘am’ , ‘list’ ]]
all_types. append ( 1024 )
all_types. append ( ‘Hello world!’ )
all_types. append ([ 1 , 2 , 3 ])
print (all_types)
>>> [ 10 , 3.14 , ‘Python’ , [ ‘I’ , ‘am’ , ‘list’ ], 1024 , ‘Hello world!’ , [ 1 , 2 , 3 ]]
Метод append() отлично выполняет свою функцию. Но, что делать, если нам нужно добавить элемент в середину списка? Это умеет метод insert(). Он добавляет элемент в список на произвольную позицию. insert() принимает в качестве первого аргумента позицию, на которую нужно вставить элемент, а вторым — сам элемент.
# Создадим список чисел от 0 до 9
numbers = list ( range ( 10 ))
# Добавление элемента 999 на позицию с индексом 0
numbers. insert ( 0 , 999 )
print (numbers) # первый print
numbers. insert ( 2 , 1024 )
print (numbers) # второй print
numbers. insert ( 5 , ‘Засланная строка-шпион’ )
print (numbers) # третий print
>>> [ 999 , 0 , 1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 , 9 ] # первый print
>>> [ 999 , 0 , 1024 , 1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 , 9 ] # второй print
>>> [ 999 , 0 , 1024 , 1 , 2 , ‘Засланная строка-шпион’ , 3 , 4 , 5 , 6 , 7 , 8 , 9 ] # третий print
Отлично! Добавлять элементы в список мы научились, осталось понять, как их из него удалять. Метод pop() удаляет элемент из списка по его индексу:
numbers = list ( range ( 10 ))
print (numbers) # 1
# Удаляем первый элемент
numbers. pop ( 0 )
print (numbers) # 2
numbers. pop ( 0 )
print (numbers) # 3
numbers. pop ( 2 )
print (numbers) # 4
# Чтобы удалить последний элемент, вызовем метод pop без аргументов
numbers. pop ()
print (numbers) # 5
numbers. pop ()
print (numbers) # 6
>>> [ 0 , 1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 , 9 ] # 1
>>> [ 1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 , 9 ] # 2
>>> [ 2 , 3 , 4 , 5 , 6 , 7 , 8 , 9 ] # 3
>>> [ 2 , 3 , 5 , 6 , 7 , 8 , 9 ] # 4
>>> [ 2 , 3 , 5 , 6 , 7 , 8 ] # 5
>>> [ 2 , 3 , 5 , 6 , 7 ] # 6
Теперь мы знаем, как удалять элемент из списка по его индексу. Но что, если мы не знаем индекса элемента, но знаем его значение? Для такого случая у нас есть метод remove(), который удаляет первый найденный по значению элемент в списке.
all_types = [ 10 , ‘Python’ , 10 , 3.14 , ‘Python’ , [ ‘I’ , ‘am’ , ‘list’ ]]
all_types. remove ( 3.14 )
print (all_types) # 1
all_types. remove ( 10 )
print (all_types) # 2
all_types. remove ( ‘Python’ )
print (all_types) # 3
>>> [ 10 , ‘Python’ , 10 , ‘Python’ , [ ‘I’ , ‘am’ , ‘list’ ]] # 1
>>> [ ‘Python’ , 10 , ‘Python’ , [ ‘I’ , ‘am’ , ‘list’ ]] # 2
>>> [ 10 , ‘Python’ , [ ‘I’ , ‘am’ , ‘list’ ]] # 3
А сейчас немного посчитаем, посчитаем элементы списка с помощью метода count()
numbers = [ 100 , 100 , 100 , 200 , 200 , 500 , 500 , 500 , 500 , 500 , 999 ]
print (numbers. count ( 100 )) # 1
print (numbers. count ( 200 )) # 2
print (numbers. count ( 500 )) # 3
print (numbers. count ( 999 )) # 4
В программировании, как и в жизни, проще работать с упорядоченными данными, в них легче ориентироваться и что-либо искать. Метод sort() сортирует список по возрастанию значений его элементов.
numbers = [ 100 , 2 , 11 , 9 , 3 , 1024 , 567 , 78 ]
numbers. sort ()
print (numbers) # 1
fruits = [ ‘Orange’ , ‘Grape’ , ‘Peach’ , ‘Banan’ , ‘Apple’ ]
fruits. sort ()
print (fruits) # 2
>>> [ 2 , 3 , 9 , 11 , 78 , 100 , 567 , 1024 ] # 1
>>> [ ‘Apple’ , ‘Banan’ , ‘Grape’ , ‘Orange’ , ‘Peach’ ] # 2
Мы можем изменять порядок сортировки с помощью параметра reverse. По умолчанию этот параметр равен False
fruits = [ ‘Orange’ , ‘Grape’ , ‘Peach’ , ‘Banan’ , ‘Apple’ ]
fruits. sort ()
print (fruits) # 1
fruits. sort (reverse = True)
print (fruits) # 2
>>> [ ‘Apple’ , ‘Banan’ , ‘Grape’ , ‘Orange’ , ‘Peach’ ] # 1
>>> [ ‘Peach’ , ‘Orange’ , ‘Grape’ , ‘Banan’ , ‘Apple’ ] # 2
Иногда нам нужно перевернуть список, не спрашивайте меня зачем. Для этого в самом лучшем языке программирования на этой планете JavaScr..Python есть метод reverse():
numbers = [ 100 , 2 , 11 , 9 , 3 , 1024 , 567 , 78 ]
numbers. reverse ()
print (numbers) # 1
fruits = [ ‘Orange’ , ‘Grape’ , ‘Peach’ , ‘Banan’ , ‘Apple’ ]
fruits. reverse ()
print (fruits) # 2
>>> [ 78 , 567 , 1024 , 3 , 9 , 11 , 2 , 100 ] # 1
>>> [ ‘Apple’ , ‘Banan’ , ‘Peach’ , ‘Grape’ , ‘Orange’ ] # 2
Допустим, у нас есть два списка и нам нужно их объединить. Программисты на C++ cразу же кинулись писать циклы for, но мы пишем на python, а в python у списков есть полезный метод extend(). Этот метод вызывается для одного списка, а в качестве аргумента ему передается другой список, extend() записывает в конец первого из них начало второго:
fruits = [ ‘Banana’ , ‘Apple’ , ‘Grape’ ]
vegetables = [ ‘Tomato’ , ‘Cucumber’ , ‘Potato’ , ‘Carrot’ ]
fruits. extend (vegetables)
print (fruits)
>>> [ ‘Banana’ , ‘Apple’ , ‘Grape’ , ‘Tomato’ , ‘Cucumber’ , ‘Potato’ , ‘Carrot’ ]
В природе существует специальный метод для очистки списка — clear()
fruits = [ ‘Banana’ , ‘Apple’ , ‘Grape’ ]
vegetables = [ ‘Tomato’ , ‘Cucumber’ , ‘Potato’ , ‘Carrot’ ]
fruits. clear ()
vegetables. clear ()
print (fruits)
print (vegetables)
Осталось совсем чуть-чуть всего лишь пара методов, так что делаем последний рывок! Метод index() возвращает индекс элемента. Работает это так: вы передаете в качестве аргумента в index() значение элемента, а метод возвращает его индекс:
fruits = [ ‘Banana’ , ‘Apple’ , ‘Grape’ ]
print (fruits. index ( ‘Apple’ ))
print (fruits. index ( ‘Banana’ ))
print (fruits. index ( ‘Grape’ ))
Финишная прямая! Метод copy(), только не падайте, копирует список и возвращает его брата-близнеца. Вообще, копирование списков — это тема достаточно интересная, давайте рассмотрим её по-подробнее.
Во-первых, если мы просто присвоим уже существующий список новой переменной, то на первый взгляд всё выглядит неплохо:
fruits = [ ‘Banana’ , ‘Apple’ , ‘Grape’ ]
new_fruits = fruits
print (fruits)
print (new_fruits)
>>> [ ‘Banana’ , ‘Apple’ , ‘Grape’ ]
>>> [ ‘Banana’ , ‘Apple’ , ‘Grape’ ]
Но есть одно маленькое «НО»:
fruits = [ ‘Banana’ , ‘Apple’ , ‘Grape’ ]
new_fruits = fruits
fruits. pop ()
print (fruits)
print (new_fruits)
# Внезапно, из списка new_fruits исчез последний элемент
>>> [ ‘Banana’ , ‘Apple’ ]
>>> [ ‘Banana’ , ‘Apple’ ]
При прямом присваивании списков копирования не происходит. Обе переменные начинают ссылаться на один и тот же список! То есть если мы изменим один из них, то изменится и другой. Что же тогда делать? Пользоваться методом copy(), конечно:
fruits = [ ‘Banana’ , ‘Apple’ , ‘Grape’ ]
new_fruits = fruits. copy ()
fruits. pop ()
print (fruits)
print (new_fruits)
>>> [ ‘Banana’ , ‘Apple’ ]
>>> [ ‘Banana’ , ‘Apple’ , ‘Grape’ ]
Отлично! Но что если у нас список в списке? Скопируется ли внутренний список с помощью метода copy() — нет:
fruits = [ ‘Banana’ , ‘Apple’ , ‘Grape’ , [ ‘Orange’ , ‘Peach’ ]]
new_fruits = fruits. copy ()
fruits[ -1 ]. pop ()
print (fruits) # 1
print (new_fruits) # 2
>>> [ ‘Banana’ , ‘Apple’ , ‘Grape’ , [ ‘Orange’ ]] # 1
>>> [ ‘Banana’ , ‘Apple’ , ‘Grape’ , [ ‘Orange’ ]] # 2
Решение задач
1. Создайте список из 10 четных чисел и выведите его с помощью цикла for
2. Создайте список из 5 элементов. Сделайте срез от второго индекса до четвертого
3. Создайте пустой список и добавьте в него 10 случайных чисел и выведите их. В данной задаче нужно использовать функцию randint.
from random import randint
n = randint ( 1 , 10 ) # Случайное число от 1 до 10
4. Удалите все элементы из списка, созданного в задании 3
5. Создайте список из введенной пользователем строки и удалите из него символы ‘a’, ‘e’, ‘o’
6. Даны два списка, удалите все элементы первого списка из второго
a = [ 1 , 3 , 4 , 5 ]
b = [ 4 , 5 , 6 , 7 ]
# Вывод
>>> [ 6 , 7 ]
7. Создайте список из случайных чисел и найдите наибольший элемент в нем.
8. Найдите наименьший элемент в списке из задания 7
9. Найдите сумму элементов списка из задания 7
10. Найдите среднее арифметическое элементов списка из задания 7
Сложные задачи
1. Создайте список из случайных чисел. Найдите номер его последнего локального максимума (локальный максимум — это элемент, который больше любого из своих соседей).
2. Создайте список из случайных чисел. Найдите максимальное количество его одинаковых элементов.
3. Создайте список из случайных чисел. Найдите второй максимум.
a = [ 1 , 2 , 3 ] # Первый максимум == 3, второй == 2
4. Создайте список из случайных чисел. Найдите количество различных элементов в нем.
Как найти количество элементов в объекте Python? Подсчитываем число элементов в списке, массиве, кортеже
В этой статье мы рассмотрим, как определить количество элементов в объекте Python и при необходимости подсчитать их сумму. Также увидим, как подсчитать количество вхождений конкретного элемента.
Итак, представим, что у нас есть следующий массив:
По условию задачи мы хотим определить, сколько элементов в данном массиве, и какова сумма всех этих элементов.
В первую очередь, вспомним, что в языке программирования Python существует специальная функция, возвращающая длину списка, массива, последовательности и так далее — это len(x) , где x — наша последовательность.
Если разобраться, длина последовательности из чисел — это одновременно и количество самих цифр, поэтому мы можем решить поставленную задачу следующим образом:
А для подсчёта суммы можем занести перечисление массива Python в цикл:
В принципе, вопрос решён. Но, по правде говоря, перебор целочисленного массива с помощью цикла для получения суммы элементов массива — это, всё же, костыль)). Дело в том, что в Python существует встроенная функция sum() . Она вернёт нам сумму без лишних телодвижений.
Python: количество вхождений конкретного элемента
Бывает, нам надо подсчитать число вхождений определённых элементов в списке и вернуть найденное значение. Для этого в Python есть метод count() . Вот его синтаксис:
Метод принимает аргумент x, значение которого нас интересует. И возвращает число вхождений интересующего элемента в список:
Итог будет следующим:
Также этот метод успешно работает и с кортежами:
Вот и всё, теперь вы знаете, как подсчитывать количество элементов в списке, массиве, кортеже в Python.
How do I get the number of elements in a list (length of a list) in Python?
How do I get the number of elements in the list items ?
11 Answers 11
The len() function can be used with several different types in Python — both built-in types and library types. For example:
How do I get the length of a list?
To find the number of elements in a list, use the builtin function len :
Explanation
Everything in Python is an object, including lists. All objects have a header of some sort in the C implementation.
Lists and other similar builtin objects with a "size" in Python, in particular, have an attribute called ob_size , where the number of elements in the object is cached. So checking the number of objects in a list is very fast.
But if you’re checking if list size is zero or not, don’t use len — instead, put the list in a boolean context — it is treated as False if empty, and True if non-empty.
From the docs
len(s)
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).
len is implemented with __len__ , from the data model docs:
object.__len__(self)
Called to implement the built-in function len() . Should return the length of the object, an integer >= 0. Also, an object that doesn’t define a __nonzero__() [in Python 2 or __bool__() in Python 3] method and whose __len__() method returns zero is considered to be false in a Boolean context.
And we can also see that __len__ is a method of lists:
Builtin types you can get the len (length) of
And in fact we see we can get this information for all of the described types:
Do not use len to test for an empty or nonempty list
To test for a specific length, of course, simply test for equality:
But there’s a special case for testing for a zero length list or the inverse. In that case, do not test for equality.
Instead, simply do:
I explain why here but in short, if items or if not items is both more readable and more performant.
While this may not be useful due to the fact that it’d make a lot more sense as being «out of the box» functionality, a fairly simple hack would be to build a class with a length property:
You can use it like so:
Essentially, it’s exactly identical to a list object, with the added benefit of having an OOP-friendly length property.
As always, your mileage may vary.
Besides len you can also use operator.length_hint (requires Python 3.4+). For a normal list both are equivalent, but length_hint makes it possible to get the length of a list-iterator, which could be useful in certain circumstances:
But length_hint is by definition only a «hint», so most of the time len is better.
I’ve seen several answers suggesting accessing __len__ . This is all right when dealing with built-in classes like list , but it could lead to problems with custom classes, because len (and length_hint ) implement some safety checks. For example, both do not allow negative lengths or lengths that exceed a certain value (the sys.maxsize value). So it’s always safer to use the len function instead of the __len__ method!
And for completeness (primarily educational), it is possible without using the len() function. I would not condone this as a good option DO NOT PROGRAM LIKE THIS IN PYTHON, but it serves a purpose for learning algorithms.
(The list object must be iterable, implied by the for..in stanza.)
The lesson here for new programmers is: You can’t get the number of items in a list without counting them at some point. The question becomes: when is a good time to count them? For example, high-performance code like the connect system call for sockets (written in C) connect(int sockfd, const struct sockaddr *addr, socklen_t addrlen); , does not calculate the length of elements (giving that responsibility to the calling code). Notice that the length of the address is passed along to save the step of counting the length first? Another option: computationally, it might make sense to keep track of the number of items as you add them within the object that you pass. Mind that this takes up more space in memory. See Naftuli Kay‘s answer.
Example of keeping track of the length to improve performance while taking up more space in memory. Note that I never use the len() function because the length is tracked:
Функция len() в Python
Длина списка в Python представляет количество элементов в списке.
Чтобы получить длину списка в Python, вызовите глобальную функцию len() со списком, переданным в качестве аргумента.
Вы также можете использовать циклические операторы, такие как цикл for или while, чтобы найти количество элементов в списке. Но это стало бы неэффективным, поскольку у нас есть встроенная функция.
Синтаксис
Синтаксис функции len() для определения длины списка показан ниже.
Функция возвращает целое число, которое представляет количество элементов, присутствующих в списке.
Пример 1: длина списка
В следующем примере мы создадим список, а затем воспользуемся командой len(), чтобы найти количество элементов в нем.
В списке четыре элемента, поэтому его длина равна 4.
Пример 2: с обновлениями списка
В следующем примере мы создадим список, а затем добавим или удалим некоторые элементы из списка и найдем результирующую длину.
Изначально в списке четыре элемента. Позже мы добавили к элементам с помощью list append(). Таким образом, окончательная длина списка составила шесть.
Заключение
В этом руководстве примеров мы узнали, как определить длину списка в Python.