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

В отличие от других итеративных методов, таких как циклы for, понимание списков — это быстрый, лаконичный и элегантный подход к созданию списков.

Синтаксис понимания списка

Основной синтаксис для понимания списка выглядит следующим образом:

list_comp = [expression for item in iterable if condition]

Давайте разберем приведенный выше синтаксис:

  • list_comp: это имя нового списка, который будет создан на основе значений, сгенерированных выражением.
  • expression: представляет собой операцию или вызов метода, который будет применен к каждому элементу в итерации. Результат чего будет добавлен в новый список list_comp.
  • item: Это переменная, которая представляет каждый элемент в итерации.
  • iterable: Это существующий список, набор, кортеж, строка или любой другой итерируемый объект, который может возвращать свои элементы по одному.
  • if condition (необязательно): эта часть используется для фильтрации элементов из итерируемого объекта на основе условия.

Примеры

Вот несколько примеров, иллюстрирующих концепцию понимания списка:

Фильтровать нечетные числа из списка

Предположим, у нас есть список, из которого мы хотим отфильтровать нечетные числа. Вот как это можно сделать «традиционным» способом:

numbers = [1, 2, 3, 4, 5]
odd_numbers = []
for i in numbers:
  if i % 2 != 0:
    odd_numbers.append(i)
print(odd_numbers)

Выход:

[1, 3, 5]

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

numbers = [1, 2, 3, 4, 5]
odd_numbers = [x for x in numbers if x % 2 != 0]
print(odd_numbers)

Выход:

[1, 3, 5]

В строке 2приведенного выше примера[x for x in numbers if x % 2 != 0] возвращает новый список с именем odd_numbers, используя понимание списка. Сначала он перебирает список numbers один за другим. Элемент x будет возвращен и сохранен в новом списке, если указанное условие if x % 2 != 0 будет равно True. Здесь выражение x просто сохраняет значение x в новый список.

Манипулирование строками с использованием понимания списка

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

word = ['Educative', 'Hello', 'World', 'Amazing', 'Fantastic']
characters = [s for s in word if 'e' in s]
print(characters)

Выход:

['Educative', 'Hello']

В строке 2 приведенного выше кода выражение [s for s in word if 'e' in s] возвращает True, если элемент содержит символ e. Итак, в новый список войдут имена, содержащие e.

Понимание вложенных списков

Вложенный понимание списков в Python позволяет создавать списки, содержащие другие списки. Он предполагает использование нескольких предложений for и необязательных предложений if в рамках одного понимания списка.

Основной синтаксис понимания вложенного списка следующий:

nested_list = [exp for item1 in iterable1 if cond1
            for item2 in iterable2 if cond2
            ...
            for itemN in iterableN if condN]

Примеры

Вот несколько примеров, иллюстрирующих концепцию понимания вложенных списков:

Сгладить матрицу

Давайте проверим приведенный ниже код, чтобы увидеть, как можно использовать понимание списка для представления матрицы.

matrix = [[1, 2, 3],
          [4, 5, 6],
          [7, 8, 9]]

flatten_matrix = [num for row in matrix for num in row]
print(flatten_matrix)

Выход:

[1, 2, 3, 4, 5, 6, 7, 8, 9]

В приведенном выше примере у нас есть вложенный список matrix, представляющий матрицу 3x3. Механизм вложенного списка [num for row in matrix for num in row] сглаживает матрицу в один список. Он перебирает каждую строку в матрице (for row in matrix), а затем перебирает каждое число в строке (for num in row), добавляя число к flatten_matrix.

Фильтровать нечетные числа из вложенного списка

Вы также можете включать условные операторы во вложенные списки. Вот пример, демонстрирующий фильтрацию нечетных чисел из вложенного списка:

matrix =    [[1, 2, 3],
            [4, 5, 6],
            [7, 8, 9]]

odd_num = [num for row in matrix for num in row if num % 2 != 0]
print(odd_num)

Выход:

[1, 3, 5, 7, 9]

В строке 5 приведенного выше примера генератор вложенного списка [num for row in matrix for num in row if num % 2 != 0] перебирает каждую строку в matrix, затем перебирает каждое число в строке и добавляет число только к odd_num. если оно нечетное ( if num % 2 != 0).

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

Это всего лишь несколько примеров того, что можно сделать с помощью списков в Python.

Преимущества использования понимания списка

Понимание списков в Python предлагает несколько преимуществ по сравнению с традиционными циклами for и условными операторами. Некоторые из его существенных преимуществ:

Краткий и читаемый код. Поддержка списков позволяет выражать сложные операции в одной строке кода. Это облегчает написание кода меньшим количеством строк.

Более быстрое выполнение. Генерация списков, как правило, более эффективна по времени и пространству, чем традиционные циклы. Интерпретаторы Python могут оптимизировать понимание списков для более быстрой работы с помощью встроенных функций и операций.

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

Простота отладки. Списковые выражения представляют собой автономные выражения, которые упрощают отладку, что приводит к более быстрому выявлению и решению проблем.

Когда не следует использовать понимание списка

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

Сложный код. Если ваш код слишком сложен, лучше избегать понимания списка, так как его может быть сложно понять. В таком случае вы можете рассмотреть возможность использования цикла for или других функций.

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

Ключевые моменты, которые следует запомнить

Заключение

Хотя понимание списков Python широко используется в кодировании, имейте в виду, что вы можете разработать чистый код, который выполнит поставленную задачу, используя свою интуицию и способность эффективно использовать данные. В конечном счете, в этом и заключается секрет написания кода на Python!

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

Чтобы продолжить обучение по пониманию списков в Python, мы рекомендуем следующие образовательные курсы:

Мы надеемся, что вам понравилось читать этот блог так же, как и нам его писать.

Как всегда, приятного обучения!