Связный список на python: что это такое и как его реализовать

Краткое введение в ООП

Объектно-ориентированное программирование (ООП) – технология разработки сложного программного обеспечения, в которой программа строится в виде совокупности объектов и их взаимосвязей.

Объединение данных и действий, производимых над этими данными, в единое целое, которое называется объектом – является одним из основных принципов ООП.

Основными понятиями являются понятие класса и объекта.

Класс является типом данных, определяемым пользователем и представляет собой структуру в виде данных и методов для работы с данными.

Формально Класс — это шаблон, по которому будет сделан объект.

Объект является экземпляром класса. Объект  и экземпляр - это одно и то же.

Вот пример. Форма для изготовления печенья – это класс, а само печенье это объект или экземпляр класса, т.е. это конкретное изделие. Печенье имеет размеры, цвет, состав – это атрибуты класса. Также в классе описываются методы, которые предназначены для чтения или изменения данных объекта.

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

Объект = атрибуты + методы 

List Comprehension

List Comprehension это создание списка путем итерации в цикле уже существующего списка (с соблюдением указанных условий). Поначалу такой подход может казаться сложным, но когда разберетесь, вы поймете, насколько это просто и быстро.

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

# просто любой список чисел
some_list = 

# пустой список, который будет заполняться четными числами из первого списка
even_list = []

for number in some_list:
  if number % 2 == 0:
    even_list.append(number)

print(even_list) # 

Давайте разберем этот пример. Сначала мы создаем список с числами. Затем создаем пустой список, в котором будут сохраняться результаты, полученные в цикле. Дальше идет сам цикл, в котором мы перебираем числа из первого списка и проверяем, являются ли они четными. Если число делится на 2 без остатка, мы добавляем его в список четных чисел. Для получения нужного результата нам потребуется 5 строк кода (без учета комментариев), да еще пробелы.

А теперь давайте посмотрим пример, в
котором мы делаем все то же самое, но с
помощью list comprehension.

# просто любой список чисел
some_list = 

# List Comprehension
even_list = 
print(even_list) # 

Давайте возьмем еще пример. Создадим
список, каждый элемент которого будет
элементом старого списка, умноженным
на 7.

my_starting_list = 
my_new_list = []

for item in my_starting_list:
    my_new_list.append(item * 7)
print(my_new_list)  # 

С помощью list comprehension можно достичь
того же результата:

my_starting_list = 
my_new_list = 

print(my_new_list)  # 

Вообще list comprehension пишется в соответствии
со следующей формулой:

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

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

List
comprehension добавляет элемент из существующего
списка в новый, если соблюдается какое-то
условие. Этот способ лаконичнее, а в
большинстве случаев еще и намного
быстрее. Иногда применение list comprehension
может ухудшить читаемость кода, поэтому
разработчику нужно действовать по
ситуации.

Примеры использования list comprehension с условиями

Вносим в новый список только четные
числа:

only_even_list = 
print(only_even_list)  # 

Это эквивалентно следующему циклу:

only_even_list = list()
for i in range(13):
  if i%2 == 0:
    only_even_list.append(i)
print(only_even_list)  # 

List
comprehension может также содержать вложенные
if-условия

Обратите внимание на следующий
пример:

divisible = list()
for i in range(50):
  if i % 2 == 0:
    if i % 3 == 0:
      divisible.append(i)
print(divisible)  # 

С применением list comprehension этот код можно
переписать следующим образом:

divisible = 
print(divisible)  # 

С list comprehension также может использоваться if-else. В следующем примере мы берем диапазон чисел от 0 до 10 и добавляем в наш список все четные числа из этого диапазона, а нечетные добавляем после умножения на -1.

list_1 = 
print(list_1)  # 

Подписаться

×

Список Python POP () по значению

В предыдущих двух примерах вы видели, как поп-элементы по индексу. Но вы также можете пойти по стоимости?

Да, вы можете использовать Способ, который дает вам индекс значения элемента в списке. Теперь вы можете использовать Способ этого индекса Чтобы удалить значение из списка и получить результат в качестве возвращаемого значения.

Вот пример, где вы хотите поп-элемент 7 из списка и хранить результат в переменной Отказ

>>> primes = 
>>> some_prime = primes.pop(primes.index(7))
>>> some_prime
7

Если вы не заинтересованы в возвращенной стоимости, но вы хотите только удалить первое вхождение значения В Используйте метод.

Связанная статья:

Список Python Удалить ()

Как в Python работают представления списков?

Представление списков это, в сущности, просто элегантный способ конструирования списков в Python. Особенно этот способ понравится тем, кто любит математику. Судите сами:

Результат:

Итак, что же произошло? Мы взяли все целые числа от 0 до 10 (исключая 10) и каждое число возвели в квадрат.

Согласитесь, не очень сложно. Теперь давайте поднимем планку.

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

Результат:

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

Итак, в более общем смысле, вы также можете использовать представление списков для преобразования ваших списков в другие списки, что звучит немного сложнее, не так ли?

Рассмотрим следующий пример:

Результат:

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

Теперь обратите внимание на выражение .  Для простоты, вы должны просто знать, что лямбда-функции — это анонимные функции, которые создаются во время выполнения

Учитывая это, вы можете просто сосредоточиться на выражении .

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

Для лучшего понимания вторую строку кода можно переписать следующим образом:

Здесь мы просто определяем лямбда-функцию заранее.

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

Предварительные сведения

Списки в Python это на редкость популярная тема как для начинающих свой путь программировании, так и для опытных экспертов в языке Python. Если верить Google Trends, то интерес к этой теме растет из года в год.

Если вы регулярно посещаете форумы, где можно задать вопросы по программированию на Python, например Stack Overflow, Quora или Reddit, то наверняка понимаете причину такой популярности этой темы.

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

В данной статье мы кратко пройдемся по самым распространенным вопросам на тему списков в языке Python.

2. Как лучше выбирать элементы из списка?

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

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

# Выбираем первый элемент списка
oneZooAnimal = biggerZoo

# Выводим на экран переменную `oneZooAnimal`
print(oneZooAnimal)

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

Как получить последний элемент списка?

Ответ на этот вопрос является дополнением к объяснению в предыдущем разделе.

Попробуйте ввести отрицательное значение, например, или , в оператор индекса, чтобы получить последние элементы нашего списка !

# Вставляем -1 
monkeys = biggerZoo
print(monkeys)

# А теперь -2
zebra = biggerZoo
print(zebra)

Не правда ли, не слишком сложно?

Что означает ошибка «Index Out Of Range»?

Эта ошибка одна из тех, которые вы будете видеть достаточно часто, особенно если вы новичок в программировании.

Лучший способ понять эту ошибку — попробовать ее получить самостоятельно.

Возьмите ваш список и передайте в оператор индекса либо очень маленькое отрицательное число, либо очень большое положительное число.

Как видите, вы можете получить ошибку «Индекс вне диапазона» в случаях, когда вы передаете в оператор индекса целочисленное значение, не попадающее в диапазон значений индекса списка. Это означает, что вы присваиваете значение или ссылаетесь на (пока) несуществующий индекс.

Срезы в списках

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

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

# Используем нотацию срезов
someZooAnimals = biggerZoo

# Выводим на экран то, что мы выбрали
print(someZooAnimals)

# Теперь поменяем местами 2 и двоеточие
otherZooAnimals = biggerZoo

# Выводим на экран полученный результат
print(otherZooAnimals)

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

Что же происходит во втором случае, когда мы поменяли местами индекс и двоеточие? Вы можете видеть, что мы получаем список из двух элементов, и . В данном случае мы стартуем с индекса и доходим до индекса (не включая его). Как вы можете видеть, результат не будет включать элемент .

В общем, подводя итоги:

# элементы берутся от start до end (но элемент под номером end не входит в диапазон!)
a

# элементы берутся начиная со start и до конца
a    

# элементы берутся с начала до end (но элемент под номером end не входит в диапазон!)
a

Совет: передавая в оператор индекса только двоеточие, мы создаем копию списка.

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

# Начиная со start, не доходя до end, с шагом step
a

Так что же по сути дает значение шага?

Ну, это позволяет вам буквально шагать по списку и выбирать только те элементы, которые включает в себя значение вашего шага. Вот пример:

Обратите внимание, что если вы не указали какое-либо значение шага, оно будет просто установлено в значение. При проходе по списку ни один элемент пропущен не будет

Также всегда помните, что ваш результат не включает индекс конечного значения, который вы указали в записи среза!

Как случайным образом выбрать элемент из списка?

Для этого мы используем пакет .

# Импортируем функцию `choice` из библиотеки `random` 
from random import choice

# Создадим список из первых четырех букв алфавита
list = 

# Выведем на экран случайный элемент списка
print(choice(list))

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

# Импортируем функцию `randrange` из библиотеки `random`
from random import randrange

# Создадим список из первых четырех букв алфавита
randomLetters = 

# Выбираем случайный индекс нашего списка
randomIndex = randrange(0,len(randomLetters))

# Выводим случайный элемент на экран
print(randomLetters)

Совет: обратите внимание на библиотеку , она может вам пригодиться во многих случаях при программировании на Python

Проверяем наш связный список

Давайте все это проверим. Начнем с создания нового объекта Node. Назовем его (две латинские буквы «l» в нижнем регистре как сокращение Linked List). Назначим ему значение 1.

Поскольку мы написали такой классный метод , мы можем вызывать его для добавления в наш список новых узлов.

Как нам увидеть, как выглядит наш список? Теоретически, выглядеть он должен следующим образом:

Но нет способа вывести его именно в таком виде. Нам нужно пройти список, выводя каждое значение. Вы же помните, как проходить список? Мы только что это делали. Повторим:

1. Создаем переменную, указывающую на .
2. Если есть следующий узел, перемещаемся к этому узлу.

И просто выводим в каждом узле. Мы начинаем с шага № 1: создаем новую переменную и назначаем ее головным элементом списка.

Далее мы выводим первый узел. Почему мы не начали с цикла while? Цикл while проитерируется только дважды, потому что только у двух узлов есть (у последнего узла его нет). В информатике это называется ошибкой на единицу (когда нужно сделать что-то Х раз плюс 1). Это можно представить в виде забора. Вы ставите столб, затем секцию забора, и чередуете пару столько раз, сколько нужно по длине.

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

Для начала мы выведем первый узел, а затем запустим цикл while для вывода всех последующих узлов.

node = ll
print(node.data)
while node.next:
    node = node.next
    print(node.data)

Запустив это для нашего предыдущего списка, мы получим в консоли:

Ура! Наш связный список работает.

Понимание списка – удалить элементы условно

Хорошо, это вроде мошенничество, потому что этот метод на самом деле не удаляет элементы из объекта списка. Это просто создает новый список с некоторыми элементами, которые соответствуют вашему состоянию.

Понимание списка является компактным способом создания списков. Простая формула .

• Выражение: Что делать с каждым элементом списка?
• Контекст: в каком списке элементы выбрать? Он состоит из произвольного количества для и если утверждения.

Пример Создает список .

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

>>> lst = list(range(10))
>>> lst_new = 
>>> lst_new
 

Пока вы повторяете весь список , состояние требует, чтобы элементы нечетными.

Связанные статьи в блоге:

Проверьте мой полный урок понимания списка для максимального обучения!

Логические операторы

Для сравнения значений используется три логических оператора, которые сводят результат к логическому значению True или False.

Оператор	Значение
and	Оператор «и»: выражение истинно, если оба его компонента истинны.
or	Оператор «или»: выражение истинно, если хотя бы один из его компонентов истинен.
not	Оператор «не»: изменяет логическое значение компонента на противоположное.

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

• сдал ли студент экзамен
• и зарегистрирован ли он.

Если оба значения истинны, студент будет переведён на следующий курс.

Другой пример: программа с логическими операторами может проверять активность пользователя в онлайн-магазине:

• использовал ли он кредит магазина
• или заказывал ли он товары в течение последних 6 месяцев.

Для примера попробуйте сравнить три выражения:

В первом случае оба выражения истинны, потому оператор and возвращает True.

Во втором случае истинно только значение 8 == 8. Поскольку хотя бы одно из предложенных условий истинно, оператор or возвращает True. Оператор and в таком случае выдал бы False.

В третьем случае выражение 3 <= 1 ложно. Оператор not изменяет полученное логическое значение на противоположное: not False = True.

Теперь попробуйте сравнить числа с плавающей точкой.

• Поскольку в первом примере одно из выражений ложно, and вернёт False. Оператор and оценивает выражение как истинное только тогда, когда оба компонента истинны.
• Поскольку оба выражения ложны, оператор or выдаст False.
• Поскольку выражение истинно, оператор not вернёт False (not True = False).

Примечание: Если вы не понимаете, как это работает, вам помогут разобраться таблицы истинности. Эту тему мы рассмотрим далее в этом руководстве.

Логические операторы можно объединять в составные выражения:

Выражение (0.8 < 3.1) or (0.1 == 0.1) истинно, поскольку оба математических выражения, из которых оно состоит, истинны. Оператор or вернёт True.

Полученное значение True становится компонентом следующего выражения: (-0.2 > 1.4) and (True). Оператор and выдаст False, потому что выражение -0.2 > 1.4 ложно. (False) and (True) = False.

Далее оператор not заменит полученное значение False на обратное ему логическое значение: not(False) = True. Значит, результат будет таким:

Срез списков

Также вы можете вызывать несколько объектов из списка (к примеру, только объекты с индексом от 1 до 3). Это называется срезом. Срез включает в себя диапазон объектов списка в формате :

Первый индекс в срезе – начало диапазона (включительно), второй – конец диапазона (исключительно). Потому срез включает в себя только объекты с индексами 1, 2 и 3.

Чтобы включить в срез первый или последний объект списка, достаточно пропустить соответствующий индекс в квадратных скобках list. К примеру, чтобы вывести первые три объекта списка, можно ввести:

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

Также для этого можно использовать отрицательные индексы:

Также в срезе можно задавать шаг – количество объектов, которые нужно пропустить после первого извлеченного объекта. По умолчанию шаг=1, то есть, Python выводит каждый объект списка.

Синтаксис этой конструкции выглядит так:

где z – размер шага. Создайте новый список, а затем задайте срез и шаг:

Конструкция numbers выводит из списка все объекты с индексами в диапазоне от 1 до 11 с шагом 2 (т.е., через один).

Чтобы задать шаг для всего списка, можно пропустить первые два параметра:

Это выведет каждый третий объект:

1. В каких ситуациях лучше использовать списки, а в каких кортежи, словари или множества?

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

Но выбор правильной структуры для ваших данных очень важен!

Списки против кортежей

Кортежи используются для хранения неизменяемых упорядоченных наборов элементов. Это означает следующее:

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

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

Списки против словарей

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

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

Заметим, что при проверке на наличие элемента производительность словарей будет выше.

Списки против множеств

• Как и словари, множества это неупорядоченные наборы данных (в отличие от списков).
• Множества требуют, чтобы данные, хранящиеся в них, были хэшируемыми. Списки поддерживают хранение нехэшируемых типов данных.
• Множества требуют, чтобы элементы, содержащиеся в них, были уникальными и неизменяемыми. Дубликаты недопустимы во множествах, в то время как в списках они возможны, равно как и возможно и изменять сами элементы.

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

Вы не уверены, какие значения можно хэшировать?

Взгляните на таблицу ниже:

Хэшируемые объекты	нехэшируемые объекты
Floats	Dictionaries
Integers	Sets
Tuples	Lists
Strings
frozenset()

Не верьте нам на слово! Поэксперементируйте сами!

# Импортируем библиотеку `collections`
import collections

# Проверяем, можно ли хэшировать словарь
print(isinstance({}, collections.Hashable))

# Проверяем на хэшируемость число с плавающей запятой
print(isinstance(0.125, collections.Hashable))

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

Список Python POP и Push (Stack)

Python не имеет встроенного Стекстическая структура данных Потому что это не нужно. Вы можете просто создать пустой список и называть его стеком. Затем вы используете метод Stack.Append (X) для нажимания элемента x в стек. И вы подаете следующее: метод Stack.pop (), чтобы протолкнуть верхний элемент из стека.

Вот пример, который показывает, как нажимать три значения в стек, а затем удалить их в традиционной первой в порядке последнего (FILO) стеками.

>>> stack = []
>>> stack.append(5)
>>> stack.append(42)
>>> stack.append("Ann")
>>> stack.pop()
'Ann'
>>> stack.pop()
42
>>> stack.pop()
5
>>> stack
[]

Методы списков в Python

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

Давайте подумаем о списках покупок. Какие операции мы с ними проделываем чаще всего?

• Добавляем элементы (по одному или несколько сразу)
• Удаляем элементы
• Меняем порядок элементов.

Как добавлять элементы в список

Мы можем добавлять элементы, вставляя их по одному в конец списка. Это делается при помощи метода . Давайте добавим в наш .

shopping_list.append('grapes')
print(shopping_list)

>> 

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

shopping_list.extend()
print(shopping_list)

>> ['apples', 'pens', 'candy', 'notepad', 'brushes', 'paint', 'grapes', 'protein bars', 'cheese'

Примечание. Есть существенная разница между методами и и оператором конкатенации .

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

Как удалять элементы из списка

Мы можем удалять элементы из списка по одному или даже группами.

Метод возвращает последний элемент списка и удаляет его, как показано ниже. Последним элементом в списке был , а после применения метода его не стало.

last_element = shopping_list.pop()
print(shopping_list)
print(last_element)
# Вывод
>> 
>> cheese

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

not_needed = shopping_list.pop(2)
print(not_needed)
# Вывод
>> candy

Если нам не нужен доступ к значению удаляемого элемента, можно воспользоваться функцией .

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

del shopping_list
print(shopping_list)
# Вывод
>> 

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

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

Для удаления всех элементов из списка можно использовать .

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

Продвинутые методы списков

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

Zip(list, list2, …)

Метод zip используется для объединения нескольких списков в Python в кортежи. Если два списка не имеют одинаковую длину, то длинный из двух списков будет обрезан до длины более короткого.

first_names = 
last_names = 
names = zip(first_names, last_names)
for name in names:
  print(name)
# Outputs: 
('John', 'Wick')
('Jeff', 'Chen')
('Chris', 'Test')

List.Sort(key=func, reversed=T/F)

Рассмотрим метод сортировки с использованием пользовательских функций ранжирования:

posts = 

# Rank here returns a tuple of the days
#   since 1900 date and the number of claps
def rank(element):
  return (element, 
          element)

# Sorting using our rank algorithm 
#   and reversed so the largest date
#   with the most claps is first
posts.sort(key=rank, reverse=True)

# Finally a list comprehension to tie it all together
print( for post in posts])

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

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

Код Python для 2D-списка

Код, который производит сетку на рисунке ниже.

grid = []

for row in range(5):
    new_row = []
    for col in range(5):
        new_row.append((row, col))
    grid.append(new_row)

for row in grid:
    print(row)

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

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

Так обратите внимание, для понимания о 2D списки в Python Вам нужно быть комфортно с

• Простые 1-мерные списки
• Доступ к элементам 1D-списка с использованием индекса. Например.
• Вложенные петли
• Этот пример использует хранить «координаты», но это не всегда требование

Группировка элементов нескольких списков

zip(*iterables)

Возвращает итератор по кортежам, где i-й кортеж содержит i-й элемент из каждого переданного итерируемого объекта.

Параметры:

— итерируемые объекты.

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

Итератор по кортежам на основе переданных итерируемых объектов.

• Если был передан один итерируемый объект, то будет возвращен итератор по кортежам, каждый из которых имеет только один элемент.
• Если итерируемые объекты не были переданы, то будет возвращен пустой итератор.

Примечание:

Итератор останавливается, когда самая короткая из последовательностей исчерпана:

list(zip(, , ))   # 

Если у вас последовательности разной длины и потеря данных недопустима, используйте .

В сочетании с оператором функция может быть использована для распаковки списка (см. Пример 2).

Примеры:

Пример 1: Использование .

number_list = 
str_list = 

# Без аргументов
result = zip()

# Преобразование итератора в список
result_list = list(result)
print(result_list)

# С двумя итерируемыми объектами
result = zip(number_list, str_list)

# Преобразование итератора во множество
result_set = set(result)
print(result_set)

Результат:

{(3, ‘three’), (2, ‘two’), (1, ‘one’)}

Пример 2: Распаковка списка с использованием .

coordinate = 
value = 

result = zip(coordinate, value)
result_list = list(result)
print(result_list)

c, v =  zip(*result_list)
print('c =', c)
print('v =', v)

Результат:

c = (‘x’, ‘y’, ‘z’)

v = (3, 4, 5)

Подписаться

×

Заключение

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

Теперь вы можете:

• Упростите циклы и вызовы map() с помощью использования декларативный представлений
• Использовать условную логику в представление
• Создать set и dictionary представления
• Определить, когда ясность кода или производительность диктует альтернативный подход

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

Помните, что хотя list comprehensions привлекает к себе большое внимание, ваша интуиция и способность использовать расчетные данные, помогут вам написать чистый код, который выполняет поставленную задачу. Это, в конечном счете, ключ к созданию вашего кода Pythonic!