Как создать пустой список в python
Перейти к содержимому

Как создать пустой список в python

  • автор:

Список list в Python

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

Списки поддерживают следующие операции:

  • общие операции с последовательностями;
  • операции с изменяемыми последовательностями.

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

Списки могут быть созданы несколькими способами:

  1. Используя пару квадратных скобок для обозначения пустого списка: [] .
  2. Используя квадратные скобки, разделяя элементы запятыми: [a, b, c] .
  3. Используя генератор списка: [x for x in iterable] .
  4. Используя конструктор типа list :
    • list() — создаст пустой список,
    • list(iterable) — преобразует в список объект, который поддерживает итерацию.

Конструктор класса list(iterable) создает список, элементы которого совпадают и находятся в том же порядке, что и элементы итератора iterable . Аргумент iterable может быть либо последовательностью, контейнером поддерживающим итерацию, либо объектом итератора. Если аргумент не задан, конструктор создает новый пустой список [] .

  • Если код программы многократно использует операцию вхождения в список list , то для этой цели лучше использовать множество set . Множества set / frozenset специально заточены для этой цели.
  • Когда код программы часто добавляет элементы списка с одной стороны и удаляет с другой стороны (методы с изменяемыми последовательностями это делать позволяют). В этом случае следует использовать класс deque который представляет собой двустороннюю очередь, которая предназначена для быстрого добавления и удаления элементов с обоих концов последовательности.

Список list способен хранить в себе разные типы данных.

Примеры использования создания списка и преобразования объектов к типу list :

>>> list() # Создание списка # [] >>> [] # [] >>> [1, 'a', 10, 'b', '105'] # [1, 'a', 10, 'b', '105'] # Преобразование строки str в список тип list >>> list('abc') # ['a',' b',' c'] # Преобразование кортежа tuple в список тип list >>> list((1, 2, 3)) # [1, 2, 3] # Преобразование множества set в список тип list >>> list(1, 2, 3>) # [1, 2, 3] # Преобразование генератора в список тип list >>> list(range(5)) # [0, 1, 2, 3, 4] # Преобразуем список строк в список чисел x = ['55', '11', '25', '15', '9'] int_list = [int(i) for i in x] print(int_list) # [11, 15, 25, 55, 9] 

Если объект iterable уже является списком, создается и возвращается копия, аналогичная iterable[:] . Многие другие операции также создают списки, в том числе встроенная функция sorted() .

Списки имеют дополнительный метод:

list.sort(*, key=None, reverse=False) :

Метод list.sort() принимает два аргумента, которые могут передаваться только по ключевому слову:

  • key определяет функцию с одним аргументом, которая используется для извлечения ключа сравнения из каждого элемента списка, например, key=str.lower . Ключ, соответствующий каждому элементу в списке, вычисляется один раз и затем используется для всего процесса сортировки. Значение по умолчанию None означает, что элементы списка сортируются напрямую без вычисления отдельного значения ключа.
  • reverse это логическое значение. Если установлено значение True , то элементы списка сортируются так, как если бы каждое сравнение было обратным.

Метод изменяет последовательность на месте для экономии памяти при сортировке большой последовательности. Чтобы напомнить пользователям, что он работает с таким эффектом, он не возвращает отсортированную последовательность. Для того, что бы получить копию отсортированного списка используйте встроенную функцию сортировки sorted() .

Метод list.sort() гарантированно будет стабильным. Сортировка является стабильной, если она гарантирует отсутствие изменения относительного порядка элементов, которые будут равными в сортируемом списке. Это полезно для сортировки за несколько проходов, например сортировка по отделу, а затем по уровню зарплаты.

Примеры использования сортировки списка методом sort() :

>>> x = [5, 2, 3, 1, 4] >>> x.sort() >>> x # [1, 2, 3, 4, 5] # Обратная сортировка - reverse=True >>> x = [5, 2, 3, 1, 4] >>> x.sort(reverse=True) >>> x # [5, 4, 3, 2, 1] 

Сортировка по длине строки, в качестве функции сортировки выступает встроенная len() :

>>> x = ['a', 'dddd', 'сс', 'bbb'] >>> x.sort(key=len) >>> x # ['a', 'сс', 'bbb', 'dddd'] 

В следующем примере, в списке x представлена последовательность чисел в качестве строк. При простой сортировке будет использоваться лексикографическое сравнение.

>>> x = ['55', '11', '25', '15', '9'] >>> x.sort() >>> x # ['11', '15', '25', '55', '9'] 

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

>>> x = ['55', '11', '25', '15', '9'] >>> x.sort(key=int) >>> x # ['9', '11', '15', '25', '55'] 
  • КРАТКИЙ ОБЗОР МАТЕРИАЛА.
  • Утиная типизация ‘Duck Typing’
  • Что такое вызываемый объект callable?
  • Как проверить тип переменной/объекта
  • Логический тип данных bool
  • Целые числа int
  • Ограничение длины преобразования целочисленной строки
  • Вещественные числа float
  • Комплексные числа complex
  • Типы последовательностей
  • Список list
  • Кортеж tuple
  • Диапазон range
  • Текстовые строки str
  • Словарь dict
  • Множество set и frozenset
  • Итератор Iterator, протокол итератора
  • Генератор generator и выражение yield
  • Контекстный менеджер with
  • Байтовые строки bytes
  • Байтовый массив bytearray
  • Тип memoryview, буфер обмена
  • Файловый объект file object
  • Универсальный псевдоним GenericAlias
  • Объект объединения Union

Пустой список в Python

Эм, а можно пример такой ошибки? Если lst действительно список и действительно пуст, то данный код обязан работать, а вы наверно что-то делаете не так с самой переменной.

16 мая 2016 в 10:09
@andreymal может топикастер переживает, что кто-то напишет def len(a): return 1 ?
16 мая 2016 в 10:24
@VladimirGamalian в таком случае есть куча более серьёзных поводов для беспокойства 😀
16 мая 2016 в 10:34

@andreymal это да ). Для junior кстати не такая уж и гипотетическая ситуация. Например использование built-in имен типа file для своих переменных встречается довольно часто.

16 мая 2016 в 10:40

1 ответ 1

Сортировка: Сброс на вариант по умолчанию

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

Взято отсюда, может чего еще полезного найдете.

Поэтому предложенный в комментарии вариант @Vladimir Gamalian думаю подходит:

if not lst: 

Отслеживать
ответ дан 17 мая 2016 в 6:31
6,161 3 3 золотых знака 20 20 серебряных знаков 38 38 бронзовых знаков

  • python
  • python-3.x
    Важное на Мете
Похожие

Подписаться на ленту

Лента вопроса

Для подписки на ленту скопируйте и вставьте эту ссылку в вашу программу для чтения RSS.

Дизайн сайта / логотип © 2024 Stack Exchange Inc; пользовательские материалы лицензированы в соответствии с CC BY-SA . rev 2024.2.16.5008

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

Для работы с наборами данных Python предоставляет такие встроенные типы как списки, кортежи и словари.

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

Создание списка

Для создания списка применяются квадратные скобки [] , внутри которых через запятую перечисляются элементы списка. Например, определим список чисел:

numbers = [1, 2, 3, 4, 5]

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

people = ["Tom", "Sam", "Bob"]

Также для создания списка можно использовать функцию-конструктор list() :

numbers1 = [] numbers2 = list()

Оба этих определения списка аналогичны — они создают пустой список.

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

objects = [1, 2.6, "Hello", True]

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

numbers = [1, 2, 3, 4, 5] people = ["Tom", "Sam", "Bob"] print(numbers) # [1, 2, 3, 4, 5] print(people) # ["Tom", "Sam", "Bob"]

Конструктор list может принимать набор значений, на основе которых создается список:

numbers1 = [1, 2, 3, 4, 5] numbers2 = list(numbers1) print(numbers2) # [1, 2, 3, 4, 5] letters = list("Hello") print(letters) # ['H', 'e', 'l', 'l', 'o']

Если необходимо создать список, в котором повторяется одно и то же значение несколько раз, то можно использовать символ звездочки *, то есть фактически применить операцию умножения к уже существующему списку:

numbers = [5] * 6 # 6 раз повторяем 5 print(numbers) # [5, 5, 5, 5, 5, 5] people = ["Tom"] * 3 # 3 раза повторяем "Tom" print(people) # ["Tom", "Tom", "Tom"] students = ["Bob", "Sam"] * 2 # 2 раза повторяем "Bob", "Sam" print(students) # ["Bob", "Sam", "Bob", "Sam"]

Обращение к элементам списка

Для обращения к элементам списка надо использовать индексы, которые представляют номер элемента в списка. Индексы начинаются с нуля. То есть первый элемент будет иметь индекс 0, второй элемент — индекс 1 и так далее. Для обращения к элементам с конца можно использовать отрицательные индексы, начиная с -1. То есть у последнего элемента будет индекс -1, у предпоследнего — -2 и так далее.

people = ["Tom", "Sam", "Bob"] # получение элементов с начала списка print(people[0]) # Tom print(people[1]) # Sam print(people[2]) # Bob # получение элементов с конца списка print(people[-2]) # Sam print(people[-1]) # Bob print(people[-3]) # Tom

Для изменения элемента списка достаточно присвоить ему новое значение:

people = ["Tom", "Sam", "Bob"] people[1] = "Mike" # изменение второго элемента print(people[1]) # Mike print(people) # ["Tom", "Mike", "Bob"]

Разложение списка

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

people = ["Tom", "Bob", "Sam"] tom, bob, sam = people print(tom) # Tom print(bob) # Bob print(sam) # Sam

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

Перебор элементов

Для перебора элементов можно использовать как цикл for, так и цикл while.

Перебор с помощью цикла for :

people = ["Tom", "Sam", "Bob"] for person in people: print(person)

Здесь будет производиться перебор списка people, и каждый его элемент будет помещаться в переменную person.

Перебор также можно сделать с помощью цикла while :

people = ["Tom", "Sam", "Bob"] i = 0 while i < len(people): print(people[i]) # применяем индекс для получения элемента i += 1

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

Сравнение списков

Два списка считаются равными, если они содержат один и тот же набор элементов:

numbers1 = [1, 2, 3, 4, 5] numbers2 = list([1, 2, 3, 4, 5]) if numbers1 == numbers2: print("numbers1 equal to numbers2") else: print("numbers1 is not equal to numbers2")

В данном случае оба списка будут равны.

Получение части списка

Если необходимо получить какую-то определенную часть списка, то мы можем применять специальный синтаксис, который может принимать следующие формы:

  • list[:end] : через параметр end передается индекс элемента, до которого нужно копировать список
  • list[start:end] : параметр start указывает на индекс элемента, начиная с которого надо скопировать элементы
  • list[start:end:step] : параметр step указывает на шаг, через который будут копироваться элементы из списка. По умолчанию этот параметр равен 1.
people = ["Tom", "Bob", "Alice", "Sam", "Tim", "Bill"] slice_people1 = people[:3] # с 0 по 3 print(slice_people1) # ["Tom", "Bob", "Alice"] slice_people2 = people[1:3] # с 1 по 3 print(slice_people2) # ["Bob", "Alice"] slice_people3 = people[1:6:2] # с 1 по 6 с шагом 2 print(slice_people3) # ["Bob", "Sam", "Bill"]

Можно использовать отрицательные индексы, тогда отсчет будет идти с конца, например, -1 - предпоследний, -2 - третий сконца и так далее.

people = ["Tom", "Bob", "Alice", "Sam", "Tim", "Bill"] slice_people1 = people[:-1] # с предпоследнего по нулевой print(slice_people1) # ["Tom", "Bob", "Alice", "Sam", "Tim"] slice_people2 = people[-3:-1] # с третьего с конца по предпоследний print(slice_people2) # [ "Sam", "Tim"]

Методы и функции по работе со списками

Для управления элементами списки имеют целый ряд методов. Некоторые из них:

  • append(item) : добавляет элемент item в конец списка
  • insert(index, item) : добавляет элемент item в список по индексу index
  • extend(items) : добавляет набор элементов items в конец списка
  • remove(item) : удаляет элемент item. Удаляется только первое вхождение элемента. Если элемент не найден, генерирует исключение ValueError
  • clear() : удаление всех элементов из списка
  • index(item) : возвращает индекс элемента item. Если элемент не найден, генерирует исключение ValueError
  • pop([index]) : удаляет и возвращает элемент по индексу index. Если индекс не передан, то просто удаляет последний элемент.
  • count(item) : возвращает количество вхождений элемента item в список
  • sort([key]) : сортирует элементы. По умолчанию сортирует по возрастанию. Но с помощью параметра key мы можем передать функцию сортировки.
  • reverse() : расставляет все элементы в списке в обратном порядке
  • copy() : копирует список

Кроме того, Python предоставляет ряд встроенных функций для работы со списками:

  • len(list) : возвращает длину списка
  • sorted(list, [key]) : возвращает отсортированный список
  • min(list) : возвращает наименьший элемент списка
  • max(list) : возвращает наибольший элемент списка

Добавление и удаление элементов

Для добавления элемента применяются методы append() , extend и insert , а для удаления - методы remove() , pop() и clear() .

people = ["Tom", "Bob"] # добавляем в конец списка people.append("Alice") # ["Tom", "Bob", "Alice"] # добавляем на вторую позицию people.insert(1, "Bill") # ["Tom", "Bill", "Bob", "Alice"] # добавляем набор элементов ["Mike", "Sam"] people.extend(["Mike", "Sam"]) # ["Tom", "Bill", "Bob", "Alice", "Mike", "Sam"] # получаем индекс элемента index_of_tom = people.index("Tom") # удаляем по этому индексу removed_item = people.pop(index_of_tom) # ["Bill", "Bob", "Alice", "Mike", "Sam"] # удаляем последний элемент last_item = people.pop() # ["Bill", "Bob", "Alice", "Mike"] # удаляем элемент "Alice" people.remove("Alice") # ["Bill", "Bob", "Mike"] print(people) # ["Bill", "Bob", "Mike"] # удаляем все элементы people.clear() print(people) # []

Проверка наличия элемента

Если определенный элемент не найден, то методы remove и index генерируют исключение. Чтобы избежать подобной ситуации, перед операцией с элементом можно проверять его наличие с помощью ключевого слова in :

people = ["Tom", "Bob", "Alice", "Sam"] if "Alice" in people: people.remove("Alice") print(people) # ["Tom", "Bob", "Sam"]

Выражение if "Alice" in people возвращает True, если элемент "Alice" имеется в списке people. Поэтому конструкция if "Alice" in people может выполнить последующий блок инструкций в зависимости от наличия элемента в списке.

Удаление с помощью del

Python также поддерживает еще один способ удаления элементов списка - с помощью оператора del . В качестве параметра этому оператору передается удаляемый элемент или набор элементов:

people = ["Tom", "Bob", "Alice", "Sam", "Bill", "Kate", "Mike"] del people[1] # удаляем второй элемент print(people) # ["Tom", "Alice", "Sam", "Bill", "Kate", "Mike"] del people[:3] # удаляем по четвертый элемент не включая print(people) # ["Bill", "Kate", "Mike"] del people[1:] # удаляем со второго элемента print(people) # ["Bill"]

Изменение подсписка

Для изменения подсписка - набора элементов в списке можно использовать вышерассмотренный синтаксис [start:end] :

nums = [10, 20, 30, 40, 50] nums[1:4]=[11, 22] print(nums) # [10, 11, 22, 50]

Здесь выражение nums[1:4] фактически обращается к подсписку [20, 30, 40] . Присвоение этому подсписку списка [11, 22] позволяет заменить элемента с 1 по 4 индекс не включая на элементы [11, 22] . И после изменения получим список [10, 11, 22, 50]

Подсчет вхождений

Если необходимо узнать, сколько раз в списке присутствует тот или иной элемент, то можно применить метод count() :

people = ["Tom", "Bob", "Alice", "Tom", "Bill", "Tom"] people_count = people.count("Tom") print(people_count) # 3

Сортировка

Для сортировки по возрастанию применяется метод sort() :

people = ["Tom", "Bob", "Alice", "Sam", "Bill"] people.sort() print(people) # ["Alice", "Bill", "Bob", "Sam", "Tom"]

Если необходимо отсортировать данные в обратном порядке, то мы можем после сортировки применить метод reverse() :

people = ["Tom", "Bob", "Alice", "Sam", "Bill"] people.sort() people.reverse() print(people) # ["Tom", "Sam", "Bob", "Bill", "Alice"]

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

Таким образом, если в списке сочетаются строки с верхним и нижним регистром, то мы можем получить не совсем корректные результаты, так как для нас строка "bob" должна стоять до строки "Tom". И чтобы изменить стандартное поведение сортировки, мы можем передать в метод sort() в качестве параметра функцию:

people = ["Tom", "bob", "alice", "Sam", "Bill"] people.sort() # стандартная сортировка print(people) # ["Bill", "Sam", "Tom", "alice", "bob"] people.sort(key=str.lower) # сортировка без учета регистра print(people) # ["alice", "Bill", "bob", "Sam", "Tom"]

Кроме метода sort мы можем использовать встроенную функцию sorted , которая имеет две формы:

  • sorted(list) : сортирует список list
  • sorted(list, key) : сортирует список list, применяя к элементам функцию key
people = ["Tom", "bob", "alice", "Sam", "Bill"] sorted_people = sorted(people, key=str.lower) print(sorted_people) # ["alice", "Bill", "bob", "Sam", "Tom"]

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

Фильтрация списка

Для фильтрации списка применяется функция filter() , в которую передается функция-условие и фильтруемый список:

filter(fun, iter)

Функция принимает два параметра:

  • fun : функция-условие, в которую передается каждый элемент коллекции и которая возвращает True, если элемент соответствует условию. Иначе возвращается False.
  • iter : фильтруемая коллекция

В качестве результата функция возвращает список отфильтрованных элементов. Например, получим из списка чисел все значения больше 1:

numbers = [-5, -4, -3 ,-2, -1, 0, 1, 2, 3, 4, 5] def condition(number): return number > 1 result = filter(condition, numbers) for n in result: print(n, end=" ") # 2 3 4 5

Здесь фильтруется список numbers. Для фильтрации определяем функцию condition, в которую в качестве параметра передается каждый элемент списка numbers. Результатом функции являет True , если число больше 1, либо False , если число меньше 2.

Результатом функции filter является отфильтрованный список.

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

numbers = [-5, -4, -3 ,-2, -1, 0, 1, 2, 3, 4, 5] result = filter(lambda n: n > 1, numbers) for n in result: print(n, end=" ") # 2 3 4 5

Аналогичным образом можно отфильтровать списки более сложных объектов:

class Person: def __init__(self, name, age): self.name = name self.age = age people = [ Person("Tom", 38), Person("Kate", 31), Person("Bob", 42), Person("Alice", 34), Person("Sam", 25) ] # фильтрация элементов, у которых age > 33 view = filter(lambda p: p.age > 33, people) for person in view: print(f"Name: Age: ")

В данном случае фильтруем список объектов Person, поэтому в функцию-условие/лямбда-выражение в качестве параметра передается каждый объект Person из списка. Каждый объект Person хранит имя (Name) и возраст (Age), и здесь выбираем всех Person, у которых возраст больше 33.

Проекция списка

Для проекции/преобразования элементов списка применяется функция map() , в которую передается функция-условие и фильтруемый список:

map(fun, iter)

Функция принимает два параметра:

  • fun : функция преобразования, в которую передается каждый элемент коллекции.
  • iter : перебираемая коллекция

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

numbers = [ 1, 2, 3, 4, 5] def square(number): return number * number result = map(square, numbers) for n in result: print(n, end=" ") # 1 4 9 16 25

В качестве функции преобразования здесь выступает функция square, в которую передается число из списка и которая возвращает его квадрат.

Также в качестве функции преобразования можно использовать лямбда-выражения:

numbers = [ 1, 2, 3, 4, 5] result = map(lambda n: n * n, numbers) for n in result: print(n, end=" ") # 1 4 9 16 25

Аналогичным образом можно преобразовывать коллекции более сложных объектов:

class Person: def __init__(self, name, age): self.name = name self.age = age people = [ Person("Tom", 38), Person("Kate", 31), Person("Bob", 42), Person("Alice", 34), Person("Sam", 25) ] # получаем из Person строку с именем view = map(lambda p: p.name, people) for person in view: print(person)

Здесь проекция применяется к списку объектов Person. Функция преобразование получает каждый объект Person и возвращает значение его атрибута name. То есть полученный в результате список будет содержать набор строк (атрибуты name всех объектов Person). Консольный вывод:

Tom Kate Bob Alice Sam

Минимальное и максимальное значения

Встроенный функции Python min() и max() позволяют найти минимальное и максимальное значения соответственно:

numbers = [9, 21, 12, 1, 3, 15, 18] print(min(numbers)) # 1 print(max(numbers)) # 21

Копирование списков

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

people1 = ["Tom", "Bob", "Alice"] people2 = people1 people2.append("Sam") # добавляем элемент во второй список # people1 и people2 указывают на один и тот же список print(people1) # ["Tom", "Bob", "Alice", "Sam"] print(people2) # ["Tom", "Bob", "Alice", "Sam"]

Это так называемое "поверхностное копирование" (shallow copy). И, как правило, такое поведение нежелательное. И чтобы происходило копирование элементов, но при этом переменные указывали на разные списки, необходимо выполнить глубокое копирование (deep copy). Для этого можно использовать метод copy() :

people1 = ["Tom", "Bob", "Alice"] people2 = people1.copy() # копируем элементы из people1 в people2 people2.append("Sam") # добавляем элемент ТОЛЬКО во второй список # people1 и people2 указывают на разные списки print(people1) # ["Tom", "Bob", "Alice"] print(people2) # ["Tom", "Bob", "Alice", "Sam"]

Соединение списков

Для объединения списков применяется операция сложения (+):

people1 = ["Tom", "Bob", "Alice"] people2 = ["Tom", "Sam", "Tim", "Bill"] people3 = people1 + people2 print(people3) # ["Tom", "Bob", "Alice", "Tom", "Sam", "Tim", "Bill"]

Списки списков

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

people = [ ["Tom", 29], ["Alice", 33], ["Bob", 27] ] print(people[0]) # ["Tom", 29] print(people[0][0]) # Tom print(people[0][1]) # 29

Чтобы обратиться к элементу вложенного списка, необходимо использовать пару индексов: people[0][1] - обращение ко второму элементу первого вложенного списка.

Добавление, удаление и изменение общего списка, а также вложенных списков аналогично тому, как это делается с обычными (одномерными) списками:

people = [ ["Tom", 29], ["Alice", 33], ["Bob", 27] ] # создание вложенного списка person = list() person.append("Bill") person.append(41) # добавление вложенного списка people.append(person) print(people[-1]) # ["Bill", 41] # добавление во вложенный список people[-1].append("+79876543210") print(people[-1]) # ["Bill", 41, "+79876543210"] # удаление последнего элемента из вложенного списка people[-1].pop() print(people[-1]) # ["Bill", 41] # удаление всего последнего вложенного списка people.pop(-1) # изменение первого элемента people[0] = ["Sam", 18] print(people) # [ ["Sam", 18], ["Alice", 33], ["Bob", 27]]

Перебор вложенных списков:

people = [ ["Tom", 29], ["Alice", 33], ["Bob", 27] ] for person in people: for item in person: print(item, end=" | ")
Tom | 29 | Alice | 33 | Bob | 27 |
  • Вопросы для самопроверки
  • Упражнения для самопроверки

Списки в Python

Обложка к статье

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

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

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

Создание списков в Python

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

Существует несколько способов создания списков в Python. Один из наиболее распространенных способов — это использование квадратных скобок ([]), внутри которых перечисляются элементы списка, разделенные запятыми. Например:

my_list = [1, 2, 3, 4, 5] # создание списка с целыми числами

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

empty_list = [] # создание пустого списка

Списки могут содержать элементы разных типов данных, например:

mixed_list = [1, "hello", True, 3.14] # создание списка с элементами различных типов данных

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

my_string = "hello" # создание строки string_list = list(my_string) # создание списка из строки

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

squares = [x ** 2 for x in range(1, 6)] # создание списка квадратов чисел от 1 до 5

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

Доступ к элементам списка в Python

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

Для доступа к элементам списка используется имя списка, за которым в квадратных скобках указывается индекс элемента, например:

my_list = [1, 2, 3, 4, 5] # создание списка с целыми числами print(my_list[0]) # вывод первого элемента списка, результат: 1

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

print(my_list[-1]) # вывод последнего элемента списка, результат: 5

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

print(my_list[1:4]) # вывод элементов списка с индексами 1, 2, 3, результат: [2, 3, 4]

Здесь указан диапазон индексов от 1 до 4, при этом первый индекс включается в результат, а последний — нет.

Если не указывать начальный и конечный индексы, то будут использоваться значения по умолчанию: начальный индекс 0 и конечный индекс -1 (последний элемент списка). Например:

print(my_list[:3]) # вывод элементов списка с индексами 0, 1, 2, результат: [1, 2, 3] print(my_list[2:]) # вывод элементов списка с индексами 2, 3, 4, результат: [3, 4, 5]

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

Изменение элементов списка в Python

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

Для изменения значения элемента списка используется индекс элемента, за которым присваивается новое значение. Например:

my_list = [1, 2, 3, 4, 5] # создание списка с целыми числами my_list[2] = 10 # изменение значения элемента с индексом 2 на 10 print(my_list) # вывод списка после изменения, результат: [1, 2, 10, 4, 5]

В данном примере значение элемента списка с индексом 2 было изменено на 10.

Также можно использовать отрицательные индексы и диапазоны индексов, как при доступе к элементам списка. Например:

my_list[-1] = 50 # изменение значения последнего элемента списка на 50 print(my_list) # вывод списка после изменения, результат: [1, 2, 10, 4, 50]
my_list[1:4] = [20, 30, 40] # изменение значений элементов списка с индексами 1, 2, 3 print(my_list) # вывод списка после изменения, результат: [1, 20, 30, 40, 50]

Здесь мы использовали срез списка [1:4] для замены значений элементов с индексами 1, 2, 3 на новые значения 20, 30, 40 соответственно.

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

Добавление и удаление элементов списка в Python

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

Для добавления новых элементов в список используется метод append() или оператор += . Например:

my_list = [1, 2, 3] # создание списка с целыми числами my_list.append(4) # добавление нового элемента со значением 4 в конец списка print(my_list) # вывод списка после добавления, результат: [1, 2, 3, 4]
my_list = [1, 2, 3] # создание списка с целыми числами my_list += [4, 5] # добавление нескольких элементов в конец списка print(my_list) # вывод списка после добавления, результат: [1, 2, 3, 4, 5]

Для удаления элементов из списка можно использовать несколько методов, таких как remove() , pop() и del . Например:

my_list = [1, 2, 3, 4, 5] # создание списка с целыми числами my_list.remove(3) # удаление элемента со значением 3 из списка print(my_list) # вывод списка после удаления, результат: [1, 2, 4, 5]
my_list = [1, 2, 3, 4, 5] # создание списка с целыми числами removed_item = my_list.pop(2) # удаление элемента с индексом 2 и сохранение его значения в переменной print(my_list) # вывод списка после удаления, результат: [1, 2, 4, 5] print(removed_item) # вывод удаленного значения, результат: 3
my_list = [1, 2, 3, 4, 5] # создание списка с целыми числами del my_list[1] # удаление элемента с индексом 1 из списка print(my_list) # вывод списка после удаления, результат: [1, 3, 4, 5]

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

Копирование и объединение списков в Python

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

Для создания копии списка можно использовать метод copy() или срез списка. Например:

my_list = [1, 2, 3, 4, 5] # создание списка с целыми числами my_list_copy = my_list.copy() # создание копии списка print(my_list_copy) # вывод копии списка, результат: [1, 2, 3, 4, 5]
my_list = [1, 2, 3, 4, 5] # создание списка с целыми числами my_list_copy = my_list[:] # создание копии списка с помощью среза print(my_list_copy) # вывод копии списка, результат: [1, 2, 3, 4, 5]

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

Для объединения нескольких списков в один можно использовать оператор + или метод extend() . Например:

list1 = [1, 2, 3] # создание первого списка list2 = [4, 5, 6] # создание второго списка merged_list = list1 + list2 # объединение списков с использованием оператора + print(merged_list) # вывод объединенного списка, результат: [1, 2, 3, 4, 5, 6]
list1 = [1, 2, 3] # создание первого списка list2 = [4, 5, 6] # создание второго списка list1.extend(list2) # объединение списков с использованием метода extend() print(list1) # вывод объединенного списка, результат: [1, 2, 3, 4, 5, 6]

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

Итерирование по спискам в Python

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

Цикл for

Цикл for в Python позволяет итерироваться по элементам списка один за другим без явного использования индексов. Пример использования цикла for для итерирования по списку:

my_list = [1, 2, 3, 4, 5] # создание списка с целыми числами for item in my_list: # итерирование по элементам списка print(item) # вывод элемента списка на каждой итерации
1 2 3 4 5

Использование индексов

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

my_list = [1, 2, 3, 4, 5] # создание списка с целыми числами for i in range(len(my_list)): # итерирование по индексам элементов списка print(my_list[i]) # вывод элемента списка по индексу на каждой итерации
1 2 3 4 5

Использование функции enumerate()

Функция enumerate() в Python позволяет итерироваться по списку и получать одновременно и индекс, и значение элемента. Пример использования функции enumerate() для итерирования по списку:

my_list = [1, 2, 3, 4, 5] # создание списка с целыми числами for i, item in enumerate(my_list): # итерирование по элементам списка с использованием функции enumerate() print(f"Индекс: , Значение: ") # вывод индекса и значения элемента на каждой итерации
Индекс: 0, Значение: 1 Индекс: 1, Значение: 2 Индекс: 2, Значение: 3 Индекс: 3, Значение: 4 Индекс: 4, Значение: 5

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

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

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

Вот несколько распространенных методов списков в Python:

  1. append() : Добавляет элемент в конец списка.
  2. extend() : Объединяет два списка, добавляя элементы одного списка в конец другого.
  3. remove() : Удаляет первое вхождение указанного элемента из списка.
  4. index() : Находит индекс первого вхождения указанного элемента в списке.
  5. sort() : Сортирует список в порядке возрастания (по умолчанию) или в указанном порядке.
  6. reverse() : Разворачивает список на месте, меняя порядок элементов на обратный.
  7. count() : Возвращает количество вхождений указанного элемента в списке.
  8. copy() : Создает и возвращает копию списка.
  9. insert() : Вставляет элемент на указанную позицию в списке.
  10. pop() : Удаляет и возвращает элемент с указанной позиции в списке.
  11. clear() : Удаляет все элементы из списка.
  12. index() : Возвращает индекс первого вхождения указанного элемента в списке.
  13. len() : Возвращает количество элементов в списке.
  14. max() : Возвращает максимальный элемент в списке.
  15. min() : Возвращает минимальный элемент в списке.

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

Более подробно о функциях и методах списков читайте в нашей статье

Сортировка списков в Python

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

Метод sort()

Это встроенный метод списка, который сортирует список на месте, изменяя порядок элементов в самом списке. Метод sort() имеет несколько параметров, таких как key , reverse , которые позволяют определить ключ сортировки и указать порядок сортировки (по возрастанию или убыванию). Пример:

my_list = [3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5] my_list.sort() # сортировка по возрастанию print(my_list) # [1, 1, 2, 3, 3, 4, 5, 5, 5, 6, 9] my_list.sort(reverse=True) # сортировка по убыванию print(my_list) # [9, 6, 5, 5, 5, 4, 3, 3, 2, 1, 1]

Функция sorted()

Это встроенная функция, которая возвращает новый отсортированный список на основе исходного, не изменяя его. Функция sorted() также принимает аргументы key и reverse для определения ключа сортировки и порядка сортировки. Пример:

my_list = [3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5] sorted_list = sorted(my_list) # сортировка по возрастанию print(sorted_list) # [1, 1, 2, 3, 3, 4, 5, 5, 5, 6, 9] sorted_list_reverse = sorted(my_list, reverse=True) # сортировка по убыванию print(sorted_list_reverse) # [9, 6, 5, 5, 5, 4, 3, 3, 2, 1, 1]

Метод sort() с параметром key

Параметр key позволяет указать функцию, которая будет использоваться в качестве ключа сортировки. Функция должна возвращать значение, по которому будет производиться сортировка. Пример:

my_list = ['apple', 'banana', 'cherry', 'date', 'fig', 'grape'] my_list.sort(key=len) # сортировка по длине элементов print(my_list) # ['fig', 'date', 'apple', 'grape', 'banana', 'cherry']

Функция sorted() с параметром key

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

my_list = ['apple', 'banana', 'cherry', 'date', 'fig', 'grape'] sorted_list = sorted(my_list, key=len) # сортировка по длине элементов print(sorted_list) # ['fig', 'date', 'apple', 'grape', 'banana', 'cherry']

Метод sort() и функция sorted() с параметром reverse

Параметр reverse позволяет указать порядок сортировки: True для сортировки в обратном порядке (по убыванию), и False (по умолчанию) для сортировки в прямом порядке (по возрастанию). Пример:

my_list = [3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5] my_list.sort(reverse=True) # сортировка по убыванию print(my_list) # [9, 6, 5, 5, 5, 4, 3, 3, 2, 1, 1] sorted_list = sorted(my_list, reverse=False) # сортировка по возрастанию print(sorted_list) # [1, 1, 2, 3, 3, 4, 5, 5, 5, 6, 9]

Метод reverse()

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

my_list = [1, 2, 3, 4, 5] my_list.reverse() # разворот списка print(my_list) # [5, 4, 3, 2, 1]

Добавить комментарий

Ваш адрес email не будет опубликован. Обязательные поля помечены *