Какая функция определяет длину списка

Функция len() в Python, количество элементов объекта

Количество элементов в последовательности или коллекции

Синтаксис:

len(s) 

Параметры:

• s — последовательность или коллекция.

Возвращаемое значение:

Описание:

Функция len() возвращает длину (количество элементов) в объекте.

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

Когда объект является строкой, функция len() возвращает количество символов в строке (строка представляет собой частный случай кортежа Python).

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

Примеры подсчета количества элементов в последовательности.

Что можно подсчитать:

• число элементов в списке;
• число элементов в кортеже;
• число символов в строке (длина строки);
• количество байтов в строке;
• число элементов в множестве;
• число пар ключ-значение в словаре;

Подсчет элементов списка.

# подсчет количества элементов списка >>> mylist = ['apple', 'banana', 'cherry'] >>> len(mylist) # 3 

Подсчет количества символов в строке (длина строки).

# подсчет символов в строке >>> string = 'Hello' >>> len(string) # 5 >>> len('абракадабра') # 11 

Подсчет количества байтов в строке.

# подсчет символов в строке >>> line_en = 'Hello'.encode('utf-8') >>> line_ru = 'Привет'.encode('utf-8') >>> len(line_en) # 5 >>> len(line_ru) # 12 

Подсчет количества ключей словаря.

# подсчет количества ключей словаря. >>> d = 'a': 1, 'b': 1, 'c': 1, 'd': 1> >>> keys = list(d) >>> len(keys) # 4 

Другие паттерны использования функции len() .

Проверка списка на дублирующие значения:

Чтобы проверить уникальность значений списка достаточно сравнить количество элементов списка с количеством элементов множества этого списка. Используя тот факт, что множество set() содержит только уникальные элементы.

>>> lst = [1, 2, 3, 4, 5, 6] # список с уникальными значениями >>> len(lst) == len(set(lst)) # True >>> lst.append(3) >>> lst # [1, 2, 3, 4, 5, 6, 3] # в списке есть повторы >>> len(lst) == len(set(lst)) # False 

Использование функции len() для подчеркивания строки:

>>> mystr = "Привет Python!" >>> underline = '-' * len(mystr) >>> print(f'mystr>\nunderline>') # Привет Python! # -------------- 

Использование функции len() в итерации по индексам последовательности:

Это пример — как один из вариантов получения индексов элементов списка. Конечно, для этой цели лучше использовать встроенную функцию enumerate() , т.к. сразу можно получить и индекс элемента и его значение.

>>> mylist = ['apple', 'banana', 'cherry', 'pear', 'plum'] >>> for i in range(len(mylist)): . print(i, mylist[i]) . # 0 apple # 1 banana # 2 cherry # 3 pear # 4 plum 

Использование встроенной функции enumerate() для получения индексов элементов:

>>> mylist = ['apple', 'banana', 'cherry', 'pear', 'plum'] >>> for i, item in enumerate(mylist): . print(i, item) . # 0 apple # 1 banana # 2 cherry # 3 pear # 4 plum 

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

Подсчет количества цифр в числе (длина числа)

Для того, чтобы посчитать количество цифр в числе необходимо сначала перевести число float или int в любую последовательность, например в строку, а затем к последовательности применить функцию len() , что бы получить количество элементов.

Для получения строкового представления объектов float и int , применим к ним функцию str.

Пример получения длины целого числа:

# получение длины целого числа >>> x = 1235412687 >>> str_x = str(x) >>> str_x # '1235412687' >>> num_x = len(str_x) >>> num_x # 10 

Так как вещественные числа в Python имеют запятую, то количество цифр в числе float будет на 1 меньше, а именно len(str(float)) — 1 .

Пример получения длины вещественного числа:

# получение длины вещественного числа >>> x = 0.1230541287 # запишем преобразования короче >>> num_x = len(str(x)) - 1 >>> num_x # 11 

Чтобы получить количество уникальных цифр в числе, необходимо строковое представление числа преобразовать в множество set , т.к. множество представляет собой последовательность неповторяющихся элементов.

Пример подсчета уникальных цифр в числах float и int :

# получение кол-ва уникальных цифр целого числа >>> x = 1235412687 # получаем строковое представление >>> str_x = str(x) # получаем множество уникальных цифр числа >>> set_x = set(str_x) # # считаем кол-во уникальных цифр >>> num_x = len(set_x) >>> num_x # 8 # для получения кол-ва уникальных цифр # числа `float` сделаем запись короче >>> x = 0.1230541287 # количество уникальных цифр числа `float` # будет на 1 меньше, т.к. число имеет разделитель >>> num_x = len(set(str(x))) - 1 # 8 

• ОБЗОРНАЯ СТРАНИЦА РАЗДЕЛА
• Функция abs(), абсолютное значение числа
• Функция all(), все элементы True
• Функция any(), хотя бы один элемент True
• Функция ascii(), преобразует строку в ASCII
• Функция bin(), число в двоичную строку
• Класс bool(), логическое значение объекта
• Функция breakpoint(), отладчик кода
• Класс bytearray(), преобразует в массив байтов
• Класс bytes(), преобразует в строку байтов
• Функция callable(), проверяет можно ли вызвать объект
• Функция chr(), число в символ Юникода
• Класс classmethod, делает функцию методом класса
• Функция compile() компилирует блок кода Python
• Класс complex(), преобразует в комплексное число
• Функция delattr(), удаляет атрибут объекта
• Класс dict() создает словарь
• Функция dir(), все атрибуты объекта
• Функция divmod(), делит числа с остатком
• Функция enumerate(), счетчик элементов последовательности
• Функция eval(), выполняет строку-выражение с кодом
• Функция exec(), выполняет блок кода
• Функция filter(), фильтрует список по условию
• Класс float(), преобразует в вещественное число
• Функция format(), форматирует значение переменной
• Класс frozenset(), преобразует в неизменяемое множество
• Функция getattr(), значение атрибута по имени
• Функция globals(), переменные глобальной области
• Функция hasattr(), наличие атрибута объекта
• Функция hash(), хэш-значение объекта
• Функция help(), справка по любому объекту
• Функция hex(), число в шестнадцатеричную строку
• Функция id(), идентификатор объекта
• Функция input(), ввод данных с клавиатуры
• Класс int(), преобразует в тип int
• Функция isinstance(), принадлежность экземпляра к классу
• Функция issubclass(), проверяет наследование класса
• Функция iter(), создает итератор
• Функция len(), количество элементов объекта
• Класс list(), преобразовывает в список
• Функция locals(), переменные локальной области
• Функция map(), обработка последовательности без цикла
• Функция max(), максимальное значение элемента
• Класс memoryview(), ссылка на буфер обмена
• Функция min(), минимальное значение элемента
• Функция next(), следующий элемент итератора
• Класс object(), возвращает безликий объект
• Функция oct(), число в восьмеричную строку
• Функция open(), открывает файл на чтение/запись
• Функция ord(), число символа Unicode
• Функция pow(), возводит число в степень
• Функция print(), печатает объект
• Класс property(), метод класса как свойство
• Класс range(), генерирует арифметические последовательности
• Функция repr(), описание объекта
• Функция reversed(), разворачивает последовательность
• Функция round(), округляет число
• Класс set(), создает или преобразовывает в множество
• Функция setattr(), создает атрибут объекта
• Класс slice(), шаблон среза
• Функция sorted(), выполняет сортировку
• Декоратор staticmethod(), метод класса в статический метод
• Класс str(), преобразует объект в строку
• Функция sum(), сумма последовательности
• Функция super(), доступ к унаследованным методам
• Класс tuple(), создает или преобразует в кортеж
• Класс type(), возвращает тип объекта
• Функция vars(), словарь переменных объекта
• Функция zip(), объединить элементы в список кортежей
• Функция __import__(), находит и импортирует модуль
• Функция aiter(), создает асинхронный итератор
• Функция anext(), следующий элемент асинхронного итератора

Нахождение длины списка при помощи рекурсии

Программа принимает на вход список и определяет его длину при помощи рекурсии.

Решение задачи

1. Инициализируем переменную списком.
2. Определяем рекурсивную функцию, которая принимает список в качестве аргумента.
3. В качестве базового условия рекурсии примем наличие в списке элементов. Если на вход функции подается пустой список, то функция возвращает 0 и рекурсия останавливается.
4. В противном случае функция выводит сумму 1 и рекурсивной функции, на вход которой подается исходный список без первого элемента.
5. После окончания работы функции выводим результат на экран.
6. Конец.

Исходный код

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

def length(lst): if not lst: return 0 return 1 + length(lst[1:]) a = [1, 2, 3] print("Длина списка равна: ") print(length(a))

Объяснение работы программы

1. Инициализируем переменную a списком.
2. Определяем рекурсивную функцию length() , которая принимает список в качестве аргумента.
3. В качестве базового условия рекурсии примем наличие в списке элементов. Если на вход функции подается пустой список, то функция возвращает 0 и рекурсия останавливается.
4. В противном случае функция выводит сумму 1 и рекурсивной функции length() , на вход которой подается исходный список без первого элемента. Это делается при помощи среза списка lst[1:] .
5. После окончания работы функции выводим результат на экран.

Результаты работы программы

Пример 1: Длина списка равна: [1, 2, 3]

Четыре способа найти длину строки в Python

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

Итак, в языке программирования Python строки относят к категории неизменяемых последовательностей, что необходимо помнить при вызове методов и функций. Теперь давайте представим, что у нас есть строка, и нам требуется найти её длину:

 
Input: 'otus' Output: 4
 
Сделать это можно несколькими способами.
 
Определяем длину строки в Python: способ № 1
   
 
Начнём с общеизвестного и наиболее популярного — использования функции len() . Эта встроенная функция возвращает количество символов в исследуемой нами строке, определяя таким образом её длину. Тут всё элементарно, и вы можете проверить код ниже на любом онлайн-компиляторе:
 
 
# Находим длину строки в Python с помощью функции len() str = 'otus' print(len(str))
 
Итогом работы функции станет следующий вывод в терминал:
 
Ищем длину строки в «Питоне»: способ № 2
   
 
Чтобы подсчитать количество символов в строке Python, мы можем воспользоваться циклом for и счётчиком. Тут тоже всё просто, т. к. определение длины происходит путём подсчёта числа итераций.
 
 
# Python-код возвращает длину строки def findLen(str): counter = 0 for i in str: counter += 1 return counter str = "otus" print(findLen(str))
 
Соответственно, наш вывод в консоли тоже будет равен 4.
 
Поиск длины строки в Python: способ № 3
   
 
Теперь давайте воспользуемся циклом while. Мы «нарежем» строку, укорачивая её на каждой итерации, в результате чего получим пустую строку и остановку цикла. А подсчёт количества итераций снова позволит нам вывести в терминал искомую длину.
 
 
# Python-код, возвращающий длину строки def findLen(str): counter = 0 while str[counter:]: counter += 1 return counter str = "otus" print(findLen(str))
 
Находим длину строки в Python: способ № 4
   
 
Теперь воспользуемся строковым методом объединения. Он принимает итеративный элемент, возвращая строку, являющуюся объединением строк в итерируемом нами элементе. Разделитель между элементами — исходная строка, для которой и вызывается метод. Применение метода объединения с последующим подсчётом объединённой строки в исходной строке тоже позволит нам получить длину строки на «Питоне».
 
 
# Python-код, возвращающий длину строки def findLen(str): if not str: return 0 else: some_random_str = 'py' return ((some_random_str).join(str)).count(some_random_str) + 1 str = "otus" print(findLen(str))
 
Как и во всех примерах выше, в консоль выведется количество символов в строе ‘otus’, равное 4. Вот и всё!
   
 
Хотите знать про Python гораздо больше? Записывайтесь на наш курс для продвинутых разработчиков:
 
Списки в Python — 10 примеров работы с функциями и методами
 
 
Списки в Python — это составная структура данных, которая позволяет собирать значения в одном месте. В других языках они чаще всего называются динамическими массивами данных. Списки — изменяемый (immutable) тип данных. Это означает, что список можно изменять, например путем добавления или удаления значений.
 
Какой у списков в Python формальный синтаксис?
   
 
[value, value, . ] list([iterable])
 
Для чего вообще нужны списки?



 
Списки в Python — одна из 4 структур данных, предназначенных для работы с итерируемыми объектами. Представим, что нам нужно написать скрипт, который проверяет, является ли модель машины производства компании Tesla. Код будет выглядеть следующим образом:
 
Что еще можно делать со списками в Python?
 
Ниже собраны примеры решений задач на основные вопросы, с которыми сталкиваются Python разработчики и дата-саентисты:
 
 
Как узнать длину списка в Python?
 
Как проверить, существует ли элемент в списке?
 
Как получить значение из списка по индексу?
 
Как перебрать значения списка в Python?
 
Какие есть методы списков в Python?
 
Как получить значение по индексу из многомерного списка в Python?
 
Как проверить, что список пустой?
 
All и any в Python — как проверить, что каждое или любое значение списка соответствует критерию?
 
Как сравнить списки в Python?
 
Как удалить дубликаты в списке?
 
 
Как узнать длину списка в Python?
 
Функция len() , позволяет получить одномерную длину списка.
 
len(['one', 'two']) # вернет 2 len(['one', [2, 3], 'four']) # вернет 3, а не 4
 
len() также работает со строками, словарями и другими структурами данных, схожими со списками.
 
Обратите внимание, что len() — это встроенная функция, а не метод списка.
 
Производительность функции len() равна O(1) (константная), то есть скорость получения длины списка не зависит от его длины.
 
Как проверить, существует ли элемент в списке?
 
За проверку вхождения значения в список отвечает оператор in .
   
 
lst = ['test', 'twest', 'tweast', 'treast'] 'test' in lst # True 'toast' in lst # False
 
Примечание: оператор  in  в множествах асимптотически быстрее, чем в списках. Если его предстоит использовать много раз в потенциально больших списках, вы можете преобразовать список во множество (set) и проверить наличие значений во множестве.
 
lst = ['test', 'twest', 'tweast', 'treast'] slst = set(lst) 'test' in slst #True
 
Как получить значение списка по индексу?
 
У каждого элемента списка есть свой уникальный номер. Этот номер называется индексом. Списки в Python имеют нулевую индексацию, как у массивов в других языках. Это означает, что первый элемент списка имеет индекс 0, второй элемент — индекс 1, третий — 2 и т. д.
 
lst = [1, 2, 3, 4] lst[0] # 1 lst[1] # 2
 
Если запросить элемент по индексу за пределами списка, Python выкинет исключение  IndexError .
 
lst = [1, 2, 3, 4] lst[10] # IndexError: list index out of range
 
Отрицательные индексы интерпретируются как подсчёт с конца списка.
 
lst = [1, 2, 3, 4] lst[-1] # 4 lst[-2] # 3 lst[-5] # IndexError: list index out of range
 
То же действие можно воспроизвести следующим образом:
 
lst = [1, 2, 3, 4] lst[len(lst)-1] # 4
 
Списки в Python поддерживают слайсинг. Синтаксис слайса: lst[начало:конец:шаг] . Результатом слайса будет новый список, содержащий элементы от начала до конца - 1.
 
lst = [1, 2, 3, 4] lst[1:] # [2, 3, 4] lst[:3] # [1, 2, 3] lst[::2] # [1, 3] lst[::-1] # [4, 3, 2, 1] lst[-1:0:-1] # [4, 3, 2] lst[5:8] # [] поскольку начальный индекс больше # длины lst, возвращает пустой список lst[1:10] # [2, 3, 4] то же, что опускание конечного индекса
 
Слайсингом можно развернуть список в обратную сторону:
 
lst = [1, 2, 3, 4] lst[::-1] # [4, 3, 2, 1]
 
Как перебрать значения списка в Python?
 
Python позволяет использовать цикла for со списками:
 
my_list = ['foo', 'bar', 'baz'] for item in my_list: print(item) # foo # bar # baz
 
Индекс текущего элемента в цикле можно получить используя функцию enumerate:
 
for (index, item) in enumerate(my_list): print('The item in position <>: <>'.format(index, item)) # The item in position 0: foo # The item in position 1: bar # The item in position 2: baz
 
Так же, можно проходить по списку используя функцию range. Range генерирует ряд чисел в рамках заданного диапазона, соответственно началом диапазона является число 0 (индекс первого элемента), а концом индекс последнего элемента. Len возвращает длину списка, так как индекс первого элемента является нулем, вычитать из длины списка единицу не нужно, индекс последнего элемента будет соответствовать длине списка:
   
 
for i in range(0, len(my_list)): print(my_list[i]) # foo # bar # baz
 
Ранее отмечалось, что списки являются изменяемой (или иммютабельной, от англ. immutable) структурой данных. Это означает, что если изменить список во время итерации, мы можем получить неожиданные результаты, например:
 
for item in my_list: if item == 'foo': del my_list[0] print(item) # Вывод: # foo # baz
 
В примере мы удалили первый элемент на первой итерации изменив список, что привело к пропуску bar. На второй итерации, baz стал вторым элементом списка.
 
Какие есть методы списков в Python?
 
Метод списка append
 
 append(value) — позволяет добавить новый элемент в конец списка.
 
a = [1, 2, 3, 4, 5] # Добавим значения 6, 7, и 7 в список a a.append(6) a.append(7) a.append(7) # a: [1, 2, 3, 4, 5, 6, 7, 7] # Добавим к значениям списка другой список b = [8, 9] a.append(b) # a: [1, 2, 3, 4, 5, 6, 7, 7, [8, 9]] # Если вы добавляете список к списку, добавляемый # вами будет одним элементом в конце первого # списка. Для расширения списка используйте метод extends # Добавим к списку элемент другого типа my_string = "hello world" a.append(my_string) # a: [1, 2, 3, 4, 5, 6, 7, 7, [8, 9], "hello world"]
 
Метод списка extends
 
 extends (enumerable) — расширяет список, добавляя элементы переданного итерируемого объекта.
 
a = [1, 2, 3, 4, 5, 6, 7, 7] b = [8, 9, 10] a.extend(b) # Добавляем в список a все элементы из списка b # a: [1, 2, 3, 4, 5, 6, 7, 7, 8, 9, 10] a.extend(range(3)) # Добавляем в список a все элементы # последовательности (0, 1, 2) # a: [1, 2, 3, 4, 5, 6, 7, 7, 8, 9, 10, 0, 1, 2]
 
Списки также можно объединять с помощью оператора +. При этом, оператор + не изменяет список, а создает новый.
 
a = [1, 2, 3, 4, 5, 6] + [7, 7] + b # a: [1, 2, 3, 4, 5, 6, 7, 7, 8, 9, 10]
 
Метод списка index
 
index (value, [startIndex]) — возвращает индекс первого вхождения значения. Если вводного значения нет в списке, возникнет исключение ValueError. Если указан второй аргумент, поиск начнется с указанного индекса.
 
a = [1, 2, 3, 4, 5, 6, 7, 7, 8, 9, 10] a.index(7) # Вернется 6 a.index(49) # Возникнет исключение ValueError, # т. к. значения 49 нет в списке a. a.index(7, 7) # Вернется 7 a.index(7, 8) # Возникнет ValueError, т. к. в списке a нет # значения 7, которое начиналось бы с индекса 8
 
Метод списка insert
 
 insert (index, value) — добавляет значение value непосредственно перед указанным индексом index. После вставки новое значение занимает индекс index.
 
a = [1, 2, 3, 4, 5, 6, 7, 7, 8, 9, 10] a.insert(0, 0) # вставляет 0 на позицию 0 a.insert(2, 5) # вставляет 5 на позицию 2 a # [0, 1, 5, 2, 3, 4, 5, 6, 7, 7, 8, 9, 10]
 
Метод списка pop
 
 pop([index]) — удаляет и возвращает значение по индексу index. Без аргумента index удаляет и возвращает последний элемент списка.
 
a = [0, 1, 5, 2, 3, 4, 5, 6, 7, 7, 8, 9, 10] a.pop(2) # Возвращает 5 # a: [0, 1, 2, 3, 4, 5, 6, 7, 7, 8, 9, 10] a.pop(8) # Возвращает 7 # a: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10] # Без аргумента: a.pop() # Возвращает: 10 # a: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
 
Метод списка remove
 
 remove(value) — удаляет первое вхождение указанного значения. Если указанного значения нет в списке, выдаётся исключение ValueError.
 
a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] a.remove(0) a.remove(9) # a: [1, 2, 3, 4, 5, 6, 7, 8]
 
Метод списка reverse
 
 reverse() — переворачивает список задом наперёд и возвращает None.
 
a = [1, 2, 3, 4, 5, 6, 7, 8] a.reverse() # a: [8, 7, 6, 5, 4, 3, 2, 1]
 
Метод списка count
 
 count(value) — подсчитывает количество появлений значения в списке.
 
a = [1, 2, 3, 4, 5, 6, 7, 7] a.count() # 2
 
Метод списка sort
 
 sort() — сортирует список в числовом и лексическом порядке и возвращает None
 
a = [1, 2, 3, 4, 5, 6, 7, 8] a.sort() # Отсортирует список в числовом порядке # a = [1, 2, 3, 4, 5, 6, 7, 8]
 
Списки также можно сортировать в обратном порядке используя флаг reverse=True в методе sort().
 
a = [1, 2, 3, 4, 5, 6, 7, 8] a.sort(reverse=True) # a = [8, 7, 6, 5, 4, 3, 2, 1]
 
Для сортировки списка по атрибутам элементов, можно использовать аргумент key:
 
class Person(object): def __init__(self, name, height): self.name = name self.height = height def __repr__(self): return self.name lst = [Person("John Cena", 175), Person("Chuck Norris", 180), Person("Jon Skeet", 185)] # Отсортируется по аттрибуту name lst.sort(key=lambda item: item.name) lst # [Chuck Norris, John Cena, Jon Skeet] # Отсортируется по аттрибуту height lst.sort(key=lambda item: item.height) lst # lst: [John Cena, Chuck Norris, Jon Skeet]
 
Метод списка clear
 
 clear() — удаляет все элементы из списка
 
a = [1, 2, 3, 4, 5, 6, 7, 8] a.clear() a # []
 
Метод списка copy
 
 copy() — возвращает пустую копию списка.
 
a = [1, 2, 3, 4, 5] aa = a.copy() aa # [1, 2, 3, 4, 5]
 
Как получить значение по индексу из многомерного списка в Python?
 
Список списков называется многомерным списком, возможная глубина не ограничена. Список списков является двумерным, список списков списков — трехмерным и т. д.
 
Доступ к значениям многомерного списка:
 
alist = [[[1,2],[3,4]], [[5,6,7],[8,9,10], [12, 13, 14]]] # Значение второго элемента в первом списке первого списка print(alist[0][0][1]) # Выведет 2 # Значение третьего элемента во втором списке # второго списка втором списк print(alist[1][1][2]) # Выведет 10
 
Использование методов списков на примере добавления значения в мгогомерный список:
 
alist = [[[1,2],[3,4]], [[5,6,7],[8,9,10], [12, 13, 14]]] alist[0][0].append(11) # Добавим значение 11 в конец первого списка в первом списке print(alist[0][0][2]) # Выведет 11
 
Использование вложенных циклов for для обхода многомерного списка:
 
alist = [[[1,2,11], [3,4]], [[5,6,7],[8,9,10], [12, 13, 14]]] # Один из способов циклического обхода многомерных списков for row in alist: for col in row: print(col) # Вывод: # [1, 2, 11] # [3, 4] # [5, 6, 7] # [8, 9, 10] # [12, 13, 14]
 
Использование слайсов в многомерном списке:
 
alist = [[[1,2,11], [3,4]], [[5,6,7],[8,9,10], [12, 13, 14]]] print(alist[1][1:]) #[[8, 9, 10], 15, [12, 13, 14]]
 
Как проверить, что список пустой?
 
Пустой список эквивалентен значению False, поэтому не нужно проверять len(lst) == 0, а достаточно вызвать lst или not lst:
 
alst = [] if not lst: print("list is empty") # "List is empty"
 
All и any в Python — как проверить, что каждое или любое значение списка соответствует критерию?
 
Функция all() помогает определить, все ли значения итерируемого объекта соответствуют значению True
 
nums = [1, 1, 0, 1] all(nums) # False chars = ['a', 'b', 'c', 'd'] all(chars) # True
 
Аналогично, any() определяет, соответствует ли одно или несколько значений в итерируемом объекте значению True
 
nums = [1, 1, 0, 1] any(nums) # True vals = [None, None, None, False] any(vals) # False
 
All и any удобно использовать с генераторами:
 
vals = [1, 2, 3, 4] any(val > 12 for val in vals) # False any((val * 2) > 6 for val in vals) # True
 
Как сравнить списки в Python?
 
Python поддерживает лексическое сравнение списков с помощью операторов сравнения. Оба операнда должны быть одного типа.
 
[1, 10, 100] < [2, 10, 100] # True, потому что 1 < 2 [1, 10, 100] < [1, 10, 100] # False, потому что списки равны [1, 10, 100] 
 
Если один из списков содержится в начале другого, выигрывает самый короткий список.
 
[1, 10] < [1, 10, 100] # True
 
Как удалить дубликаты в списке?
 
Удаление повторяющихся значений в списке можно сделать путём преобразования списка во множество (set). Множества представляют собой неупорядоченную коллекцию уникальных значений. Если требуется сохранить структуру данных в виде списка, то множество можно преобразовать обратно в список с помощью функции list():
 
names = ["aixk", "duke", "edik", "tofp", "duke"] list(set(names)) # ['duke', 'tofp', 'aixk', 'edik']
 
Обратите внимание, что при преобразовании списка во множество теряется исходный порядок. Для сохранения исходного порядка можно использовать OrderedDict.
 
import collections collections.OrderedDict.fromkeys(names).keys() # ['aixk', 'duke', 'edik', 'tofp']
 
Упражнение
 
Добавьте числа 1 , 2 и 3 в список numbers , а слова hello и word — в переменную strings .
    
Затем, заполнить переменную second_name вторым значением из списка names, используя оператор [] . Обратите внимание, что индекс начинается с нуля, поэтому, если вы хотите получить доступ ко второму элементу в списке, его индекс будет равен 1.
 
Решение упражнения
 
numbers = [] strings = [] names = ["John", "Eric", "Jessica"] # напишите ниже свой код numbers.append(1) numbers.append(2) numbers.append(3) strings.append("hello") strings.append("world") second_name = names[1] print(numbers) print(strings) print("The second name on the names list is %s" % second_name)