Списки питон: Python | Списки

Содержание

Python | Списки

Список

Последнее обновление: 20.06.2017

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

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


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

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


numbers1 = []
numbers2 = list()

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

Конструктор list для создания списока может принимать другой список:


numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9]
numbers2 = list(numbers)

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


numbers = [1, 2, 3, 4, 5]
print(numbers[0])   # 1
print(numbers[2])   # 3
print(numbers[-3])  # 3

numbers[0] = 125  # изменяем первый элемент списка
print(numbers[0])   # 125

Если необходимо создать список, в котором повторяется одно и то же значение несколько раз, то можно использовать символ звездочки *. Например, определим список из шести пятерок:


numbers = [5] * 6  # [5, 5, 5, 5, 5, 5]
print(numbers)

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

  • range(end): создается набор чисел от 0 до числа end

  • range(start, end): создается набор чисел от числа start до числа end

  • range(start, end, step): создается набор чисел от числа start до числа end с шагом step


numbers = list(range(10))
print(numbers)      # [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
numbers = list(range(2, 10))
print(numbers)      # [2, 3, 4, 5, 6, 7, 8, 9]
numbers = list(range(10, 2, -2))
print(numbers)      # [10, 8, 6, 4]

Например, следующие два определения списка будут аналогичны, но за счет функции range мы сокращаем объем кода:


numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9]
numbers2 = list(range(1, 10))

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

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

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

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

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


companies = ["Microsoft", "Google", "Oracle", "Apple"]
for item in companies:
    print(item)

Здесь вместо функции range мы сразу можем подставить имеющийся список companies.

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


companies = ["Microsoft", "Google", "Oracle", "Apple"]
i = 0
while i < len(companies):
    print(companies[i])
    i += 1

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

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

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


numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9]
numbers2 = list(range(1,10))
if numbers == numbers2:
    print("numbers equal to numbers2")
else:
    print("numbers is not equal to numbers2")

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

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

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

  • append(item): добавляет элемент item в конец списка

  • insert(index, item): добавляет элемент item в список по индексу index

  • remove(item): удаляет элемент item. Удаляется только первое вхождение элемента. Если элемент не найден, генерирует исключение ValueError

  • clear(): удаление всех элементов из списка

  • index(item): возвращает индекс элемента item. Если элемент не найден, генерирует исключение ValueError

  • pop([index]): удаляет и возвращает элемент по индексу index. Если индекс не передан, то просто удаляет последний элемент.

  • count(item): возвращает количество вхождений элемента item в список

  • sort([key]): сортирует элементы. По умолчанию сортирует по возрастанию. Но с помощью параметра key мы можем передать функцию сортировки.

  • reverse(): расставляет все элементы в списке в обратном порядке

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

  • len(list): возвращает длину списка

  • sorted(list, [key]): возвращает отсортированный список

  • min(list): возвращает наименьший элемент списка

  • max(list): возвращает наибольший элемент списка

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

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

pop() и clear().

Использование методов:


users = ["Tom", "Bob"]

# добавляем в конец списка
users.append("Alice")  # ["Tom", "Bob", "Alice"]
# добавляем на вторую позицию
users.insert(1, "Bill")          # ["Tom", "Bill", "Bob", "Alice"]

# получаем индекс элемента
i = users.index("Tom")
# удаляем по этому индексу
removed_item = users.pop(i)            # ["Bill", "Bob", "Alice"]

last_user = users[-1]
# удаляем последний элемент
users.remove(last_user)           # ["Bill", "Bob"]

print(users)

# удаляем все элементы
users.clear()

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

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

companies = ["Microsoft", "Google", "Oracle", "Apple"] item = "Oracle" # элемент для удаления if item in companies: companies.remove(item) print(companies)

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

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

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


users = ["Tom", "Bob", "Alice", "Tom", "Bill", "Tom"]

users_count = users.count("Tom")
print(users_count)      # 3

Сортировка

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


users = ["Tom", "Bob", "Alice", "Sam", "Bill"]

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

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


users = ["Tom", "Bob", "Alice", "Sam", "Bill"]

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

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

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


users = ["Tom", "bob", "alice", "Sam", "Bill"]

users.sort(key=str.lower)
print(users)      # ["alice", "Bill", "bob", "Sam", "Tom"]

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

  • sorted(list): сортирует список list

  • sorted(list, key): сортирует список list, применяя к элементам функцию key


users = ["Tom", "bob", "alice", "Sam", "Bill"]

sorted_users = sorted(users, key=str.lower)
print(sorted_users)      # ["alice", "Bill", "bob", "Sam", "Tom"]

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

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

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


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

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

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


users1 = ["Tom", "Bob", "Alice"]
users2 = users1
users2.append("Sam")
# users1 и users2 указывают на один и тот же список
print(users1)   # ["Tom", "Bob", "Alice", "Sam"]
print(users2)   # ["Tom", "Bob", "Alice", "Sam"]

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


import copy

users1 = ["Tom", "Bob", "Alice"]
users2 = copy.deepcopy(users1)
users2.append("Sam")
# пееменные users1 и users2 указывают на разные списки
print(users1)   # ["Tom", "Bob", "Alice"]
print(users2)   # ["Tom", "Bob", "Alice", "Sam"]

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

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

  • list[:end]: через параметр end передается индекс элемента, до которого нужно копировать список

  • list[start:end]: параметр start указывает на индекс элемента, начиная с которого надо скопировать элементы

  • list[start:end:step]: параметр step указывает на шаг, через который будут копироваться элементы из списка. По умолчанию этот параметр равен 1.


users = ["Tom", "Bob", "Alice", "Sam", "Tim", "Bill"]

slice_users1 = users[:3]   # с 0 по 3
print(slice_users1)   # ["Tom", "Bob", "Alice"]

slice_users2 = users[1:3]   # с 1 по 3
print(slice_users2)   # ["Bob", "Alice"]

slice_users3 = users[1:6:2]   # с 1 по 6 с шагом 2
print(slice_users3)   # ["Bob", "Sam", "Bill"]

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

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


users1 = ["Tom", "Bob", "Alice"]
users2 = ["Tom", "Sam", "Tim", "Bill"]
users3 = users1 + users2
print(users3)   # ["Tom", "Bob", "Alice", "Tom", "Sam", "Tim", "Bill"]

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

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


users = [
    ["Tom", 29],
    ["Alice", 33],
    ["Bob", 27]
]

print(users[0])         # ["Tom", 29]
print(users[0][0])      # Tom
print(users[0][1])      # 29

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

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


users = [
    ["Tom", 29],
    ["Alice", 33],
    ["Bob", 27]
]

# создание вложенного списка
user = list()
user.append("Bill")
user.append(41)
# добавление вложенного списка
users.append(user)

print(users[-1])         # ["Bill", 41]

# добавление во вложенный список
users[-1].append("+79876543210")

print(users[-1])         # ["Bill", 41, "+79876543210"]

# удаление последнего элемента из вложенного списка
users[-1].pop()
print(users[-1])         # ["Bill", 41]

# удаление всего последнего вложенного списка
users.pop(-1)

# изменение первого элемента
users[0] = ["Sam", 18]
print(users)            # [ ["Sam", 18], ["Alice", 33], ["Bob", 27]]

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


users = [
    ["Tom", 29],
    ["Alice", 33],
    ["Bob", 27]
]

for user in users:
    for item in user:
        print(item, end=" | ")

Консольный вывод:


Tom | 29 | Alice | 33 | Bob | 27 | 

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

В Python у списков есть множество методов, описание которых приведено ниже.

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

Метод:

list.append(item)

Описание:

Добавляет один элемент в конец списка.

Параметры:

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

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

Модифицирует исходный список.  Возвращает None.

Примеры:

Пример 1: Добавление элемента в список.

animals = ['cat', 'dog', 'rabbit']

# добавление элемента 
animals.append('guinea pig')

print('Updated animals list: ', animals)

Результат:

Updated animals list:  [‘cat’, ‘dog’, ‘rabbit’, ‘guinea pig’]

 

Пример 2: Добавление списка (как элемента) в другой список.

animals = ['cat', 'dog', 'rabbit']
wild_animals = ['tiger', 'fox']

# добавление списка wild_animals в список animals 
animals.append(wild_animals)

print('Updated animals list: ', animals)

Результат:

Updated animals list:  [‘cat’, ‘dog’, ‘rabbit’, [‘tiger’, ‘fox’]]

Примечание:

Если вам нужно добавить не список в список (как в примере выше), а элементы одного списка в другой список, используйте метод extend().


Метод:

list.extend(iterable)

Описание:

Добавляет все элементы итерируемого объекта (списка, кортежа, строки и т. д.) в конец списка.

Параметры:

iterable — итерируемый объект, элементы которого будут добавлены в список.

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

Модифицирует исходный список.  Возвращает None.

Примечание:

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

1. Оператор «+»:

a = [1, 2]
b = [3, 4]

a += b  

# Output: [1, 2, 3, 4]
print(a)

2. Срезы:

a = [1, 2]
b = [3, 4]

a[len(a):] = b

# Output: [1, 2, 3, 4]
print(a)

Примеры:

Пример 1: Добавление элементов одного списка в другой список.

language = ['French', 'English']
language1 = ['Spanish', 'Portuguese']

# добавление элементов списка language1 в  список language
language.extend(language1)

print('Language List:', language)

Результат:

Language List: [‘French’, ‘English’, ‘Spanish’, ‘Portuguese’]

 

Пример 2: Добавление элементов кортежа и множества в список.

language = ['French']
language_tuple = ('Spanish', 'Portuguese')
language_set = {'Chinese', 'Japanese'}

# добавление элементов кортежа language_tuple в список language
language.extend(language_tuple)

print('New Language List:', language)

# добавление элементов множества language_set в список language
language.extend(language_set)

print('Newer Language List:', language)

Результат:

New Language List: [‘French’, ‘Spanish’, ‘Portuguese’]

Newer Language List: [‘French’, ‘Spanish’, ‘Portuguese’, ‘Japanese’, ‘Chinese’]


Метод:

list.insert(index, element)

Описание:

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

Параметры:

index – позиция (индекс), на которую будет помещен указанный элемент. Нумерация начинается с нуля. Также поддерживается отрицательная индексация.

element — элемент, который нужно поместить в список.

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

Модифицирует исходный список.  Возвращает None.

Примеры:

Пример 1: Вставка элемента в список.

vowel = ['a', 'e', 'i', 'u']

# вставка 'o' по индексу 3
vowel.insert(3, 'o')

print('Updated List:', vowel)

Результат:
Updated List: [‘a’, ‘e’, ‘i’, ‘o’, ‘u’]

Пример 2: Вставка кортежа (как элемента) в список.

mixed_list = [{1, 2}, [5, 6, 7]]
number_tuple = (3, 4)

# вставка кортежа по индексу 1
mixed_list.insert(1, number_tuple)

print('Updated List:', mixed_list)

Результат:

Updated List: [{1, 2}, (3, 4), [5, 6, 7]]

Удаление элементов

Метод:

list.remove(element)

Описание:

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

Параметры:

element — элемент, который будет удален из списка. Если элемент в списке не найден, то возбуждается исключение ValueError.

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

Модифицирует исходный список.  Возвращает None.

Примечание:

Если список содержит повторяющиеся элементы, метод remove() удаляет только первое вхождение заданного элемента в списке.

Если нужно удалить элемент по индексу или вернуть значение удаляемого элемента, используйте list.pop().

Также для удаления элементов из списка можно использовать инструкцию del.

Примеры:

Пример 1: Удаление элемента из списка.

animals = ['cat', 'dog', 'rabbit', 'guinea pig']

# удаление элемента 'rabbit'
animals.remove('rabbit')

print('Updated animals list: ', animals)

Результат:

Updated animals list:  [‘cat’, ‘dog’, ‘guinea pig’]

 

Пример 2: Удаление элемента, который не существует.

animals = ['cat', 'dog', 'rabbit', 'guinea pig']

# удаление элемента 'fish'
animals.remove('fish')

print('Updated animals list: ', animals)

Результат:

Traceback (most recent call last):

 File «<string>», line 5, in <module>

ValueError: list.remove(x): x not in list


Метод:

list.pop([index])

Описание:

Удаляет элемент по указанному индексу из списка и возвращает удаленный элемент.

Параметры:

index — индекс искомого элемента в списке (целое число). Если индекс не указан, то удаляется последний элемент списка. Индексация начинается с нуля. Также поддерживается отрицательная индексация. Если индекс, переданный методу, вне диапазона списка, то возбуждается исключение IndexError.

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

Элемент [по указанному индексу], который был удален из списка.

Примечание:

Если нужно удалить элемент из списка не возвращая его, используйте list.remove().

Также вы можете использовать инструкцию del для удаления  элементов или срезов из списка.

Примеры:

Пример 1: Удаление элемента из списка по индексу.

languages = ['Python', 'Java', 'C++', 'French', 'C']

# удалить элемент по индексу 3 из списка и вернуть его
return_value = languages.pop(3)

print('Return Value:', return_value)
print('Updated List:', languages)

Результат:

Return Value: French

Updated List: [‘Python’, ‘Java’, ‘C++’, ‘C’]

 

Пример 2: Удаление элемента из списка без указания индекса и по отрицательному индексу.

languages = ['Python', 'Java', 'C++', 'Ruby', 'C']

# удалить последний элемент из списка и вернуть его
print('When index is not passed:') 
print('Return Value:', languages.pop())
print('Updated List:', languages)

# удалить последний элемент из списка и вернуть его
print('\nWhen -1 is passed:') 
print('Return Value:', languages.pop(-1)) 
print('Updated List:', languages)

# удалить 3й элемент с конца списка и вернуть его
print('\nWhen -3 is passed:') 
print('Return Value:', languages.pop(-3))
print('Updated List:', languages)

Результат:

When index is not passed:

Return Value: C

Updated List: [‘Python’, ‘Java’, ‘C++’, ‘Ruby’]

 

When -1 is passed:

Return Value: Ruby

Updated List: [‘Python’, ‘Java’, ‘C++’]

 

When -3 is passed:

Return Value: Python

Updated List: [‘Java’, ‘C++’]


Метод:

list.clear()

Описание:

Удаляет все элементы из списка.

Параметры:

Метод не принимает никаких аргументов.

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

Модифицирует исходный список.  Возвращает None.

Примечание:

Также для удаления всех элементов из списка можно использовать инструкцию del:

list = [{1, 2}, ('a'), ['1.1', '2.2']]

del list[:]

# Output: List: []
print('List:', list)

Примеры:

list = [{1, 2}, ('a'), ['1.1', '2.2']]

# очистить список
list.clear()

print('List:', list)

Результат:

List: []

Получение информации

Метод:

list.index(element [,start [, end]])

Описание:

Возвращает индекс первого вхождения искомого значения в списке.

Параметры:

element — искомое значение.

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

end — индекс, до которого ведется поиск элемента. Необязательный аргумент, по умолчанию равен len(list).

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

Индекс искомого значения в списке.

Примечание:

Если элемент не найден, то возбуждается исключение ValueError.

Примеры:

Пример 1: Найти индекс элемента в списке.

vowels = ['a', 'e', 'i', 'o', 'i', 'u']

# индекс 'e' в списке vowels
index = vowels.index('e')
print('The index of e:', index)

# индекс первого элемента 'i' в списке vowels 
index = vowels.index('i')
print('The index of i:', index)

Результат:

The index of e: 1

The index of i: 2

 

Пример 2: Индекс элемента, которого нет в списке.

vowels = ['a', 'e', 'i', 'o', 'u']

# индекс 'p' в списке vowels
index = vowels.index('p')
print('The index of p:', index)

Результат:

Traceback (most recent call last):

  File «<string>», line 5, in <module>

ValueError: ‘p’ is not in list

 

Пример 3: Найти индекс элемента с параметрами start и end.

alphabets = ['a', 'e', 'i', 'o', 'g', 'l', 'i', 'u']

# индекс 'i' в списке alphabets  
index = alphabets.index('i')  # 2 
print('The index of i:', index)

# индекс  'i' при поиске начиная с 5-го элемента списка alphabets  
index = alphabets.index('i', 4)   # 6
print('The index of i:', index)

# индекс  'i'  между 4м и 6м элементами списка alphabets 
index = alphabets.index('i', 3, 5)   # Error!
print('The index of i:', index)

Результат:

The index of e: 2

The index of i: 6

Traceback (most recent call last):

  File «<string>», line 13, in <module>

ValueError: ‘i’ is not in list


Метод:

list.count(element)

Описание:

Возвращает количество вхождений указанного элемента в список.

Параметры:

element – элемент, количество вхождений которого надо определить.

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

Количество вхождений указанного элемента в списке.

Примеры:

vowels = ['a', 'e', 'i', 'o', 'i', 'u']

# количество вхождений элемента 'i'
count = vowels.count('i')

print('The count of i is:', count)

# количество вхождений элемента 'p'
count = vowels.count('p')

print('The count of p is:', count)

Результат:

The count of i is: 2

The count of p is: 0

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

Метод:

list.sort([key [, reverse]])

Описание:

Сортирует элементы данного списка.

Параметры:

key — функция, на основе которой сортируется список. Необязательный аргумент, по умолчанию равен None.

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

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

Модифицирует исходный список.  Возвращает None.

Примечание:

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

Можно использовать лямбда-функции, когда функция может быть записана в одну строку. Пример 3 (приведенный ниже) можно написать следующим образом:

# сортировка по имени (в порядке возрастания)
employees.sort(key=lambda x: x.get('Name'))

# сортировка по возрасту (в порядке возрастания)
employees.sort(key=lambda x: x.get('age'))

# сортировка по зарплате (в порядке убывания)
employees.sort(key=lambda x: x.get('salary'), reverse=True)

Примеры:

Пример 1: Сортировка списка.

vowels = ['e', 'a', 'u', 'o', 'i']

# сортировка списка vowels
vowels.sort()

print('Sorted list:', vowels)

Результат:

Sorted list: [‘a’, ‘e’, ‘i’, ‘o’, ‘u’]

 

Пример 2: Сортировка списка по убыванию.

vowels = ['e', 'a', 'u', 'o', 'i']

# сортировка списка vowels
vowels.sort(reverse=True)

print('Sorted list (in Descending):', vowels)

Результат:

Sorted list (in Descending): [‘u’, ‘o’, ‘i’, ‘e’, ‘a’]

 

Пример 3: Сортировка списка на основе собственной функции.

employees = [
    {'Name': 'Alan Turing', 'age': 25, 'salary': 10000},
    {'Name': 'Sharon Lin', 'age': 30, 'salary': 8000},
    {'Name': 'Mikhail Tal', 'age': 40, 'salary': 15000},
]

# функции для получения информации о сотрудниках
def get_name(employee):
    return employee.get('Name')

def get_age(employee):
    return employee.get('age')

def get_salary(employee):
    return employee.get('salary')

# сортировка по имени (в порядке возрастания)
employees.sort(key=get_name)
print(employees, end='\n\n')

# сортировка по возрасту (в порядке возрастания)
employees.sort(key=get_age)
print(employees, end='\n\n')

# сортировка по зарплате (в порядке убывания)
employees.sort(key=get_salary, reverse=True)
print(employees, end='\n\n')

Результат:

[{‘Name’: ‘Alan Turing’, ‘age’: 25, ‘salary’: 10000}, {‘Name’: ‘Mikhail Tal’, ‘age’: 40, ‘salary’: 15000}, {‘Name’: ‘Sharon Lin’, ‘age’: 30, ‘salary’: 8000}]

 

[{‘Name’: ‘Alan Turing’, ‘age’: 25, ‘salary’: 10000}, {‘Name’: ‘Sharon Lin’, ‘age’: 30, ‘salary’: 8000}, {‘Name’: ‘Mikhail Tal’, ‘age’: 40, ‘salary’: 15000}]

 

[{‘Name’: ‘Mikhail Tal’, ‘age’: 40, ‘salary’: 15000}, {‘Name’: ‘Alan Turing’, ‘age’: 25, ‘salary’: 10000}, {‘Name’: ‘Sharon Lin’, ‘age’: 30, ‘salary’: 8000}]

Метод:

list.reverse()

Описание:

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

Параметры:

Метод не принимает никаких аргументов.

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

Модифицирует исходный список.  Возвращает None.

Примечание:

Если вам нужно получить доступ к элементам списка в обратном порядке, то лучше использовать функцию reversed().

Список также можно перевернуть при помощи срезов:

systems = ['Windows', 'macOS', 'Linux']

reversed_list = systems[::-1]

# Output: ['Linux', 'macOS', 'Windows']
print(reversed_list)

Примеры:

systems = ['Windows', 'macOS', 'Linux']
print('Original List:', systems)

# перевернуть список
systems.reverse()

# вывести обновленный список
print('Updated List:', systems)

Результат:
Original List: [‘Windows’, ‘macOS’, ‘Linux’]
Updated List: [‘Linux’, ‘macOS’, ‘Windows’]

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

Метод:

list.copy()

Описание:

Возвращает поверхностную копию списка (без рекурсивного копирования вложенных элементов).

Параметры:

Метод не принимает никаких аргументов.

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

Новый список. Не модифицирует исходный список.

Примечание:

Вы также можете копировать список, используя срезы:

list = ['cat', 0, 6.7]

new_list = list[:]

# Output: New List: ['cat', 0, 6.7]
print('New List:', new_list)

Примеры:

my_list = ['cat', 0, 6.7]

# копирование списка
new_list = my_list.copy()

print('Copied List:', new_list)

Результат:
Copied List: [‘cat’, 0, 6.7]

Базовые знания о списках в Python. Создание и наполнение списков

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

В этой статье:

Базовое использование

Как создать список

Пустой список создается при помощи пары квадратных скобок:

empty_list = []
print(type(empty_list)) # <class 'list'>
print(len(empty_list)) # 0

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

homogeneous_list = [1, 1, 2, 3, 5, 8]
print(homogeneous_list) # [1, 1, 2, 3, 5, 8]
print(len(homogeneous_list)) # 6

heterogeneous_list = [1, "Hello, Pythonist!"]
print(heterogeneous_list) # [1, 'Hello, Pythonist!']
print(len(heterogeneous_list)) # 2

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

empty_list = list()  # Создаем пустой список
print(empty_list)  # []
new_list = list("Hello, Pythonist!")  # Новый список создается путем перебора заданного итерируемого объекта.
print(new_list)  # ['H', 'e', 'l', 'l', 'o', ',', ' ', 'P', 'y', 't', 'h', 'o', 'n', 'i', 's', 't', '!']

Также при создании списков используется List Comprehension, к которому мы еще вернемся.

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

Вывод всего списка:

my_list = [1, 2, 9, 16, 25]
print(my_list)  # [1, 2, 9, 16, 25]

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

print(my_list[0])  # 1
print(my_list[1])  # 2
print(my_list[2])  # 9

В Python для обращения к элементам можно использовать и отрицательные индексы. При этом последний элемент в списке будет иметь индекс -1, предпоследний — -2 и так далее.

print(my_list[-1])  # 25
print(my_list[-2])  # 16
print(my_list[-3])  # 9

Распаковка списков (для python-3). Если поставить перед именем списка звездочку, все элементы этого списка будут переданы функции в качестве отдельных аргументов.

my_list = [1, 2, 9, 16, 25]
print(my_list)  # [1, 2, 9, 16, 25]
print(*my_list)  # 1 2 9 16 25

words = ["I", "love", "Python", "I", "love"]
print(words)  # ['I', 'love', 'Python', 'I', 'love']
print(*words)  # I love Python I love

Списки мутабельны

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

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

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

my_list = [1, 2, 9, 16, 25, 34, 53, 21]
my_index = [5, 2, 0]
my_new_list = [my_list[i] for i in my_index]
print(my_new_list)  # [34, 9, 1]

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

len()

Метод len() возвращает длину объекта (списка, строки, кортежа или словаря).

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

list1 = [123, 'abc', 'apple']  # список
print(len(list1)) # в списке 3 элемента, в выводе команды будет "3"

str1 = 'basketball'  # строка
print(len(str1))  # в строке 9 букв, в выводе команды будет "9"

tuple1 = (2, 3, 4, 5)  # кортеж
print(len(tuple1))  # в кортеже 4 элемента, в выводе команды будет "4"

dict1 = {'name': 'John', 'age': 4, 'score': 45} # словарь
print(len(dict1))  # в словаре 3 пары ключ-значение, в выводе команды будет "3"

index()

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

numbers = [1, 2, 2, 3, 9, 5, 6, 10]
words = ["I", "love", "Python", "I", "love"]

print(numbers.index(9)) # 4
print(numbers.index(2)) # 1
print(words.index("I")) # 0
print(words.index("JavaScript")) # возвращает ValueError, поскольку 'JavaScript' в списке 'words' нет

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

Цифра «2» встречается в списке дважды, первое ее вхождение имеет индекс 1, второе — 2. Метод index() возвращает индекс 1.

Аналогично возвращается индекс 0 для элемента «I».

Если элемент, переданный в качестве аргумента, вообще не встречается в списке, вернется ValueError. Так получилось с попыткой выяснить индекс «JavaScript» в списке words.

Опциональные аргументы

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

words = ["I", "am", "a", "I", "am", "Pythonista"]
print(words.index("am", 2, 5)) # 4

Метод index() будет искать элемент «am» в диапазоне от элемента с индексом 2 (включительно) до элемента с индексом 5 (этот последний элемент не входит в диапазон).

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

pop()

Метод pop() удаляет и возвращает последний элемент списка.

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

Если в списке нет указанного вами индекса, метод выбросит exception IndexError: pop index out of range.

cities = ['New York', 'Dallas', 'San Antonio', 'Houston', 'San Francisco']

print "City popped is: ", cities.pop() # City popped is: San Francisco
print "City at index 2 is  : ", cities.pop(2) # City at index 2 is: San Antonio

Базовый функционал стека

Для реализации базового функционала стека в программах на Python часто используется связка метода pop() и метода append():

stack = []

for i in range(5):
    stack.append(i)

while len(stack):
    print(stack.pop())

List Comprehension

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

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

# просто любой список чисел
some_list = [1, 2, 5, 7, 8, 10]

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

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

print(even_list) # [2, 8, 10]

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

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

# просто любой список чисел
some_list = [1, 2, 5, 7, 8, 10]

# List Comprehension
even_list = [number for number in some_list if number % 2 == 0]
print(even_list) # [2, 8, 10]

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

my_starting_list = [1, 2, 3, 4, 5, 6, 7, 8]
my_new_list = []

for item in my_starting_list:
    my_new_list.append(item * 7)
print(my_new_list)  # [7, 14, 21, 28, 35, 42, 49, 56]

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

my_starting_list = [1, 2, 3, 4, 5, 6, 7, 8]
my_new_list = [item * 7 for item in my_starting_list]

print(my_new_list)  # [7, 14, 21, 28, 35, 42, 49, 56]

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

my_list = [{operation with input n} for n in {python iterable}]

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

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

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

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

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

only_even_list = [i for i in range(13) if i%2==0]
print(only_even_list)  # [0, 2, 4, 6, 8, 10, 12]

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

only_even_list = list()
for i in range(13):
  if i%2 == 0:
    only_even_list.append(i)
print(only_even_list)  # [0, 2, 4, 6, 8, 10, 12]

List comprehension может также содержать вложенные if-условия. Обратите внимание на следующий пример:

divisible = list()
for i in range(50):
  if i % 2 == 0:
    if i % 3 == 0:
      divisible.append(i)
print(divisible)  # [0, 6, 12, 18, 24, 30, 36, 42, 48]

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

divisible = [i for i in range(50) if i % 2 == 0 if i % 3 == 0]
print(divisible)  # [0, 6, 12, 18, 24, 30, 36, 42, 48]

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

list_1 = [i if i % 2 == 0 else i * -1 for i in range(10)]
print(list_1)  # [0, -1, 2, -3, 4, -5, 6, -7, 8, -9]

Интерактивный учебник языка Python

1. Списки

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

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

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

	
Primes = [2, 3, 5, 7, 11, 13]
Rainbow = ['Red', 'Orange', 'Yellow', 'Green', 'Blue', 'Indigo', 'Violet']

В списке Primes — 6 элементов, а именно: Primes[0] == 2, Primes[1] == 3, Primes[2] == 5, Primes[3] == 7, Primes[4] == 11, Primes[5] == 13. Список Rainbow состоит из 7 элементов, каждый из которых является строкой.

Также как и символы в строке, элементы списка можно индексировать отрицательными числами с конца, например, Primes[-1] == 13, Primes[-6] == 2.

Длину списка, то есть количество элементов в нем, можно узнать при помощи функции len, например, len(Primes) == 6.

В отличие от строк, элементы списка можно изменять, присваивая им новые значения.

	
Rainbow = ['Red', 'Orange', 'Yellow', 'Green', 'Blue', 'Indigo', 'Violet']
print(Rainbow[0])
Rainbow[0] = 'красный'
print('Выведем радугу')
for i in range(len(Rainbow)):
    print(Rainbow[i])

Рассмотрим несколько способов создания и считывания списков. Прежде всего, можно создать пустой список (не содержащий элементов, длины 0), а в конец списка можно добавлять элементы при помощи метода append. Например, пусть программа получает на вход количество элементов в списке n, а потом n элементов списка по одному в отдельной строке. Вот пример входных данных в таком формате:

5
1809
1854
1860
1891
1925
В этом случае организовать считывание списка можно так:
5
1809
1854
1860
1891
1925
a = []  # заводим пустой список
n = int(input())  # считываем количество элемент в списке
for i in range(n):  
    new_element = int(input())  # считываем очередной элемент
    a.append(new_element)  # добавляем его в список
    # последние две строки можно было заменить одной:
    # a.append(int(input()))
print(a)

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

5
1809
1854
1860
1891
1925
a = []
for i in range(int(input())):
    a.append(int(input()))
print(a)

Для списков целиком определены следующие операции: конкатенация списков (сложение списков, т. е. приписывание к одному списку другого) и повторение списков (умножение списка на число). Например:

	
a = [1, 2, 3]
b = [4, 5]
c = a + b
d = b * 3
print([7, 8] + [9])
print([0, 1] * 3)

В результате список c будет равен [1, 2, 3, 4, 5], а список d будет равен [4, 5, 4, 5, 4, 5]. Это позволяет по-другому организовать процесс считывания списков: сначала считать размер списка и создать список из нужного числа элементов, затем организовать цикл по переменной i начиная с числа 0 и внутри цикла считывается i-й элемент списка:

5
1809
1854
1860
1891
1925
a = [0] * int(input())
for i in range(len(a)):
    a[i] = int(input())

Вывести элементы списка a можно одной инструкцией print(a), при этом будут выведены квадратные скобки вокруг элементов списка и запятые между элементами списка. Такой вывод неудобен, чаще требуется просто вывес

Списки в Python — Программирование с нуля

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

Как создать список?

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

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

# пустой список
my_list = []

# сипсок чисел
my_list = [1, 2, 3]

# список элементов имеющих разный тип данных
my_list = [1, "Hello", 3.4]

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

# пример вложенного списка
my_list = ["mouse", [8, 4, 6], ['a']]

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

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

Доступ по индексу

Для доступа к элементу списка можно использовать оператор индекса []. Индекс начинается с 0. Итак, список из 5 элементов будет иметь индексы от 0 до 4.

Попытка получить доступ к элементу, который не существует, вызовет ошибку IndexError. Индекс должен быть целым числом. Нельзя использовать float или другие типы данных в качестве индекса, это приведет к ошибке TypeError.

Доступ к вложенному списку осуществляется с помощью дополнительных индексов.

my_list = ['p','r','o','b','e']

# Вывод первого элемента: p
print(my_list[0])

# Вывод третьего элемента: o
print(my_list[2])

# Вывод последнего (пятого) элемента: e
print(my_list[4])

# Ошибка, индексом может быть только целое число
# my_list[4.0]

# Пример вложенного списка
n_list = ["Happy", [2,0,1,5]]

# Индексы вложенных списков
# Вывод второго символа первого элемента списка: a
print(n_list[0][1])

# вывод четвертого элемента второго вложенного списка: 5
print(n_list[1][3])

Отрицательные индексы списка

Python допускает отрицательную индексацию для элементов списка. Индекс -1 выведет последний элемент, -2 — второй элемент с конца и т.д.

my_list = ['p','r','o','b','e']

# Вывод последнего элемента: e
print(my_list[-1])

# Вывод последнего элемента с конца (первого): p
print(my_list[-5])

Срезы списков в Python

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

my_list = ['p','r','o','g','r','a','m','f','i', 'l', 'e', 's']

# Элементы с 3го по 5й
print(my_list[2:5])

# Элементы с начала до 4го
print(my_list[:4])

# Элементы с 6го до последнего
print(my_list[5:])

# Элементы с первого до последнего
print(my_list[:])

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

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

Мы можем использовать оператор присваивания (=), чтобы изменить элемент или диапазон элементов.

odd = [2, 4, 6, 8]

# Изменение первого элемента 
odd[0] = 1
# Результат: [1, 4, 6, 8]
print(odd)

# Изменение элементов со 2го по 4й
odd[1:4] = [3, 5, 7] 
# Результат: [1, 3, 5, 7]
print(odd)

Мы можем добавить один элемент в список с помощью метода append() или несколько элементов с помощью метода extended().

odd = [1, 3, 5]

odd.append(7)
# Результат: [1, 3, 5, 7]
print(odd)

odd.extend([9, 11, 13])
# Результат: [1, 3, 5, 7, 9, 11, 13]
print(odd)

Мы также можем использовать оператор + для объединения двух списков. Это называется конкатенацией списка.

Оператор * повторяет список заданное количество раз.

odd = [1, 3, 5]

# Результат: [1, 3, 5, 9, 7, 5]
print(odd + [9, 7, 5])

# Результат: ["re", "re", "re"]
print(["re"] * 3)

Кроме того, мы можем вставить один или несколько элементов в нужное место с помощью метода insert().

odd = [1, 9]

odd.insert(1,3)
# Результат: [1, 3, 9] 
print(odd)

odd[2:2] = [5, 7]
# Результат: [1, 3, 5, 7, 9]
print(odd)

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

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

my_list = ['p','r','o','b','l','e','m']

# Удалить один элемент
del my_list[2]
# Результат: ['p', 'r', 'b', 'l', 'e', 'm'] 
print(my_list)

# Удалить несколько элементов
del my_list[1:5] 
# Результат: ['p', 'm']
print(my_list)

# Удалить весь список
del my_list 
# Результат: Error: List not defined
print(my_list)

Мы можем использовать метод remove() для удаления элемента или метод pop() для удаления элемента по указанному индексу.

Метод pop() удаляет последний элемент, если индекс не указан. Это помогает нам реализовывать списки в виде стеков «first come, last go» («первый вошел, последний вышел»).

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

my_list = ['p','r','o','b','l','e','m']
my_list.remove('p')
# Результат: ['r', 'o', 'b', 'l', 'e', 'm']
print(my_list)

# Результат: 'o'
print(my_list.pop(1))

# Результат: ['r', 'b', 'l', 'e', 'm']
print(my_list)
# Результат: 'm'
print(my_list.pop())

# Результат: ['r', 'b', 'l', 'e']
print(my_list)
my_list.clear()
# Результат: []
print(my_list)

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

>>> my_list = ['p','r','o','b','l','e','m']
>>> my_list[2:3] = []
>>> my_list
['p', 'r', 'b', 'l', 'e', 'm']
>>> my_list[2:5] = []
>>> my_list
['p', 'r', 'm']

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

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

  • append() — добавляет элемент в конец списка
  • extend() — добавляет все элементы списка в другой список
  • insert() — вставляет элемент по указанному индексу
  • remove() — удаляет элемент из списка
  • pop() — удаляет и возвращает элемент по указанному индексу
  • clear() — удаляет все элементы из списка (очищает список)
  • index() — возвращает индекс первого соответствующего элемента
  • count() — возвращает количество элементов, переданных в качестве аргумента
  • sort() — сортировка элементов в списке в порядке возрастания
  • reverse() — обратный порядок элементов в списке
  • copy() — возвращает поверхностную копию списка

Генератор списков: иной способ создания нового списка в Python

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

Генератор списка состоит из выражения, за которым следует оператор for в квадратных скобках.

В примере ниже, создается список, в котором каждый следующий элемент умножается на 2:

pow_new = [2 ** x for x in range(10)]
# Результат: [1, 2, 4, 8, 16, 32, 64, 128, 256, 512]
print(pow_new)

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

pow_new = []
for x in range(10):
    pow_new.append(2 ** x)

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

Оператор in позволяет проверить, существует ли данный элемент в списке. Если да, то в результате вернется True, если нет то False.

my_list = ['p','r','o','b','l','e','m']
# Результат: True
print('p' in my_list)
# Результат: False
print('a' in my_list)
# Результат: True
print('c' not in my_list)

Итерация по списку (перебор списка)

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

for fruit in ['apple','banana','mango']:
    print("I like",fruit)

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

Быстрый путеводитель по Python: cписки за 7 минут

Не путайте в Python списки и массивы: в первых можно хранить разнородные объекты. Здесь кратко описаны все основные методы списков Python 3.x.

Когда речь идет о массивах, обычно мы подразумеваем набор однородных элементов. Но в Python списки – это не массивы. Список (list) может представлять коллекцию разнородных объектов: целые и дробные числа, строки, логические значения и т. д. Описанное свойство позволяет разработчикам применять списки более гибко, чем обычные массивы. Среди типов данных Python списки являются одним из наиболее мощных и часто используемых.

В Python списки создаются двумя способами:

  1. С помощью квадратных скобок []
  2. С помощью функции list()

Элементы списка можно сразу поместить внутрь скобок. По умолчанию создается пустой list.

>>> # Рассмотрим создание списка на примере дел
... # Второй будем использовать для хранения абстрактной информации
... 
>>> todo_list = []
>>> general_info = list()
>>> type(todo_list), type(general_info)
(<class 'list'>, <class 'list'>)

Итак, мы создали два пустых списка. Заполним их данными.

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

  1. append()
  2. insert()

Добавление элемента методом append()

append() добавляет в конец списка элемент, переданный в качестве аргумента:

>>> todo_list.append('Завтрак, зарядка, душ')
>>> todo_list.append('Чтение статей на proglib')
>>> todo_list.append('Дорога до работы')
>>> todo_list
['Завтрак, зарядка, душ', 'Чтение статей на proglib', 'Дорога до работы']

Добавление элемента методом insert()

insert() принимает два аргумента – индекс позиции и вставляемый элемент:

>>> general_info.insert(0, 'Важные математические константы')
>>> general_info.insert(1, 1j)
>>> general_info.insert(2, 3.1415926)
>>> general_info.insert(3, False)
>>> general_info.insert(4, 1)
>>> general_info
['Важные математические константы', 1j, 3.1415926, False, 1]

Есть три способа:

  1. Оператор индекса
  2. Оператор среза
  3. Итерирование

Оператор индекса

Индекс используется для доступа к отдельному элементу.

>>> todo_list[2]
'Дорога до работы'
>>> general_info[1]
1j

Оператор среза

Срез применяется для обращения к нескольким элементам списка. Синтаксис: list_name[start:stop:step], где

  • start – индекс, с которого начинается срез (по умолчанию начало списка)
  • stop – индекс, до которого осуществляется срез (по умолчанию конец списка)
  • step – шаг приращения, по умолчанию равно 1
>>> general_info[:2]      # срез с начала до 2 индекса, не включая
['Важные математические константы', 1j]
>>> general_info[2:4]     # срез с индекса 2 по 3
[3.1415926, False]
>>> general_info[::2]     # чётные индексы
['Важные математические константы', 3.1415926, 1]

Обратите внимание: если указан индекс stop, то срез осуществляется вплоть до него, но исключая сам элемент.

Итерирование

Списки Python – итерируемые объекты. Для перебора элементов списка не нужен счетчик:

>>> for item in todo_list:
...     print(item)
... 
Завтрак, зарядка, душ
Чтение статей на proglib
Дорога до работы

Всего два метода:

  1. remove()
  2. pop()

Удаление элемента методом remove()

remove() находит и удаляет элемент из списка:

>>> general_info.remove(False)
>>> general_info
['Важные математические константы', 1j, 3.1415926, 1]

Удаление элемента методом pop()

pop() удаляет и возвращает элемент, по умолчанию последний:

>>> general_info.pop()
1
>>> general_info.pop()
3.1415926
>>> general_info
['Важные математические константы', 1j]

Посмотреть аттрибуты и функции объекта списка, как и других объектов Python, можно передав список функции dir(). Вот сокращенный вид выводимого функцией списка:

>>> dir(todo_list)
[...  'append', 'clear', 'copy', 'count', 'extend', 'index',
'insert', 'pop', 'remove', 'reverse', 'sort']

Ничего сложного, правда? 🙂

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

  1. a.append(e) – добавляет переданную переменную e в конец списка a
  2. a.clear() – удаляет все элементы из списка a
  3. a.copy() – возвращает копию списка a
  4. a.count(e) – возвращает число столько раз, сколько элемент e встречается в списке a
  5. a.extend(b) – добавляет все элементы списка b в конец списка a
  6. a.index(e) – находит и возвращает индекс первого элемента списка a, равного e
  7. a.insert(i, e) – вставляет элемент на позицию с индексом i
  8. a.pop(i) – возвращает и удаляет элемент с индексом (по умолчанию последний)
  9. a.remove(e) – удаляет элемент e из списка a
  10. a.reverse() – разворачивает в обратном порядке элементы списка a
  11. a.sort() – сортирует элементы списка a в восходящем порядке

Используйте списки Python, если от структуры данных нужно следующее:

  • Хранить объекты данных нескольких типов.
  • Сохранять очередность элементов и порядок вставки.
  • Хранить повторяющиеся значения.
  • Изменять элементы.

Источник

списки list и функции len, min, max, sum, sorted

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

Москва

Санкт-Петербург

Самара

Казань

Тверь

1200

200

500

2100

100

0.5

0.55

0.6

0.4

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

[элемент1, элемент2, …, элементN]

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

lst = ["Москва", "Санкт-Петербург", "Тверь", "Казань"]

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

Здесь синей рамкой отмечен сам список, внутри которого располагаются элементы. Если мы посмотрим тип объекта, на который ссылается переменая lst:

то увидим значение «list». Это как раз и есть тип списка. То есть, через переменную lst мы можем работать со списком в целом, и первое, что нас здесь интересует: как обратиться к определенному элементу этого списка? Для этого используется такой синтаксис:

список[индекс]

Например,

Но, если мы укажем не существующий индекс:

то возникнет ошибка. Чтобы этого избежать нам надо знать значение последнего индекса. Для этого можно воспользоваться функцией

len(список)

которая возвращает число элементов в списке:

вернет значение 4. Но, так как индексы начинаются с нуля, то последний индекс будет равен:

lastIndex = len(lst) – 1

То есть, можно записать вот так:

но можно и проще, вот так:

Этот пример показывает, что при отрицательных индексах, мы начинаем движение с конца списка и значение -1 дает самый последний элемент.

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

lst = ["Москва", "Санкт-Петербург", "Тверь", "Казань"]
for city in lst:
   print(city)

Смотрите, как это легко и просто делается! Конечно, мы можем распечатать весь контейнер целиком, просто записав:

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

Увидим везде строковый тип str. Но раз city ссылается на элементы списка, можно ли их изменить, присвоив этой переменной другое значение?

city = "новое значение"

Если мы теперь выведем список lst в консоль:

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

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

числа, булевые значения, строки

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

список[индекс] = значение

Например, так:

Теперь первый элемент не «Москва», а «Самара». В действительности, здесь произошло следующее:

Мы поменяли значение ссылки lst[0] первого элемента списка. Изначально она ссылалась на объект «Москва», а затем, стала ссылаться на объект «Самара». Прежний объект автоматически удаляется сборщиком мусора. Вот так происходит изменение элементов списка, то есть, меняются значения ссылок на новые объекты.

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

и в цикле мы хотим его изменить на их квадраты. Для этого запишем цикл в таком виде:

digs = [-1, 0, 5, 3, 2]
for x in range(5):
    digs[x] **= 2   #digs[x] = digs[x]**2
print(digs)

Или, чтобы не указывать конкретное число в функции range, ее можно переписать так:

for x in range(len(digs)):

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

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

создает список из 1000 элементов со значением 0. Фактически, мы здесь сначала создали список из одного нулевого элемента, а затем, размножили его до тысячи. Или, можно сделать так:

Получим 100 элементов со строкой «none». И так далее. Кстати, если требуется создать пустой список, то это будет так:

Ну хорошо, есть у нас список из 100 или 1000 или другого числа элементов. Но как нам теперь с ним работать, например, занести туда какие-либо данные. Для наглядности, предположим, пользователь вводит N чисел с клавиатуры (N<100) и пока он вводит положительные значения, мы их добавляем в список. Как только он ввел какое-либо отрицательное число, считывание прекращается и мы вычисляем среднее арифметическое введенных значений. Это можно реализовать так:

digs = [0]*100
N = 0; x = 0
while x >= 0:
   x = int(input("Введите целое число: "))
   digs[N] = x
   N += 1
 
S = 0
for x in range(N):
    S += digs[x]
S = S/N;
 
print("S = %f, N = %d"%(S, N))

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

t = ["строка", 5, 5.7, True, [1,2,3]]

Причем, его длина

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

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

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

а, затем, ко второму:

Получим значение 4. С этими списками можно выполнять все те же самые операции, о которых мы говорили ранее, например, изменить значение:

Далее, списки можно объединять друг с другом, используя оператор +:

[1,2,3] + ["Москва", "Тверь"]

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

digs = [1,2,3,4]
digs = digs + [5]
digs += [6]

или в начало:

digs = ["числа"]+digs

И здесь обратите внимание, что мы объединяем именно списки, то есть, вот такая запись:

приведет к ошибке, т.к. 3 – это число, а не список.

Следующий оператор:

возвращает True, если элемент, записанный слева, присутствует в списке, указанный справа. Иначе, значение False:

Или, можно делать так:

То есть, в качестве элемента может быть любой тип данных.

Следующие две полезные функции:

digs = [1,2,3,4]
max(digs)
min(digs)

находят минимальное или максимальное числовое значение. И если в списке имеется не числовой элемент:

то эти функции приводят к ошибкам.

Также можно вычислять сумму элементов числового списка:

выполнять сортировку чисел по возрастанию:

d = [-1, 0, 5, 3, 2, 5]
sorted(d)

или, по убыванию:

Эта функция возвращает новый объект-список, прежний d остается без изменений.

Наконец, можно сравнивать списки между собой:

[1,2,3] == [1,2,3]
[1,2,3] != [1,2,3]
[1,2,3] > [1,2,3]

В последнем сравнении получим False, т.к. списки равны, но если записать так:

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

Все эти сравнения работают с однотипными данными:

[1,2, "abc"] > [1,2, "abc"]

сработает корректно, а вот так:

Произойдет ошибка, т.к. число 3 не может быть сравнено со строкой «abc».

Задания для самопроверки

1. Дан список [-1, 0, 5, 3, 2]. Необходимо изменить его, увеличив каждое значение на 7.2.

2. Пользователь вводит с клавиатуры N значений (строки или числа). На их основе сформировать список, состоящий из продублированных элементов. (Например, из значений 1, 5, «abc» формируется список [1, 1, 5, 5, «abc», «abc»]).

3. Написать программу сложения двух матриц:

4. Пользователь вводит N значений в список. Необходимо проверить: было ли введено число 5.

списков Python


Коллекции Python (массивы)

В языке программирования Python существует четыре типа коллекционных данных:

  • Список — это упорядоченная и изменяемая коллекция. Позволяет дублировать участников.
  • Tuple — это упорядоченная и неизменяемая коллекция. Позволяет дублировать участников.
  • Set — это неупорядоченная и неиндексированная коллекция. Нет повторяющихся участников.
  • Словарь — это неупорядоченный, изменяемый и индексированный сборник. Нет повторяющихся участников.

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

Список

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

Пример

Создать список:

thislist = [«яблоко», «банан», «вишня»]
печать (этот список)

Попробуй сам »

Элементы доступа

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

Пример

Распечатать второй пункт списка:

thislist = [«яблоко», «банан», «вишня»]
печать (этот список [1])

Попробуй сам »

Отрицательное индексирование

Отрицательная индексация означает начало с конца, -1 относится к последнему элементу, -2 относится ко второму последнему элементу и т. Д.

Пример

Распечатать последний элемент списка:

thislist = [«яблоко», «банан», «вишня»]
печать (этот список [-1])

Попробуй сам »

Диапазон индексов

Вы можете указать диапазон индексов, указав, где начать и где конец диапазона.

При указании диапазона возвращаемое значение будет новым списком с указанные предметы.

Пример

Верните третий, четвертый и пятый предмет:

thislist = [«яблоко», «банан», «вишня», «апельсин», «киви», «дыня», «манго»]
печать (этот список [2: 5])

Попробуй сам »

Примечание: Поиск начнется с индекса 2 (включен) и закончится с индексом 5 (не включен).

Помните, что первый элемент имеет индекс 0.

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

Пример

В этом примере возвращаются элементы от начала до «оранжевого»:

thislist = [«яблоко», «банан», «вишня», «апельсин», «киви», «дыня», «манго»]
печать (этот список [: 4])

Попробуй сам »

Если не указывать конечное значение, диапазон будет продолжен до конца списка:

Пример

В этом примере возвращаются элементы от «вишни» до конца:

thislist = [«яблоко», «банан», «вишня», «апельсин», «киви», «дыня», «манго»]
печать (этот список [2:])

Попробуй сам »

Диапазон отрицательных индексов

Укажите отрицательные индексы, если вы хотите начать поиск с конца список:

Пример

В этом примере возвращаются элементы от индекса -4 (включен) до индекса -1 (исключен)

thislist = [«яблоко», «банан», «вишня», «апельсин», «киви», «дыня», «манго»]
печать (этот список [-4: -1])

Попробуй сам »

Изменить значение позиции

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

Пример

Измените второй элемент:

thislist = [«яблоко», «банан», «вишня»]
thislist [1] = «черная смородина»
печать (этот список)

Попробуй сам »

Цикл по списку

Вы можете перемещаться по элементам списка, используя для цикл:

Пример

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

thislist = [«яблоко», «банан», «вишня»]
для x в этом списке:
print (x)

Попробуй сам »

Вы узнаете больше о циклах для в нашей главе Python For Loops.


Проверить, существует ли элемент

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

Пример

Проверить, присутствует ли «яблоко» в списке:

thislist = [«яблоко», «банан», «вишня»]
если «яблоко» в этом списке:
print («Да,« яблоко »в списке фруктов»)

Попробуй сам »

Длина списка

Чтобы определить, сколько элементов в списке, используйте len () функция:

Пример

Вывести количество пунктов в списке:

thislist = [«яблоко», «банан», «вишня»]
print (len (этот список))

Попробуй сам »

Добавить товары

Чтобы добавить элемент в конец списка, используйте append () метод:

Пример

Использование метода append () для добавления элемента:

thislist = [«яблоко», «банан», «вишня»]
этот список.append («оранжевый»)
печать (этот список)

Попробуй сам »

Чтобы добавить элемент по указанному индексу, используйте метод insert ():

Пример

Вставьте элемент как вторую позицию:

thislist = [«яблоко», «банан», «вишня»]
thislist.insert (1, «оранжевый»)
печать (этот список)

Попробуй сам »

Удалить предмет

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

Пример

Метод remove () удаляет указанный элемент:

thislist = [«яблоко», «банан», «вишня»]
этот список.удалить («банан»)
печать (этот список)

Попробуй сам »

Пример

Метод pop () удаляет указанный index (или последний элемент, если индекс не указан):

thislist = [«яблоко», «банан», «вишня»]
thislist.pop ()
печать (этот список)

Попробуй сам »

Пример

Ключевое слово del удаляет указанный индекс:

thislist = [«яблоко», «банан», «вишня»]
дель этот список [0]
печать (этот список)

Попробуй сам »

Пример

Ключевое слово del также может удалить список полностью:

thislist = [«яблоко», «банан», «вишня»]
дель этот список

Попробуй сам »

Пример

Метод clear () очищает список:

thislist = [«яблоко», «банан», «вишня»]
этот список.clear ()
print (этот список)

Попробуй сам »

Копировать список

Вы не можете скопировать список, просто набрав list2 = list1 , потому что: list2 будет только ссылки на list1 , и изменения, внесенные в list1 также будет автоматически внесен в список2 .

Есть способы сделать копию, один из них — использовать встроенный Список метод Копия () .

Пример

Сделайте копию списка с помощью метода copy () :

thislist = [«яблоко», «банан», «вишня»]
mylist = thislist.copy ()
печать (мой список)

Попробуй сам »

Другой способ сделать копию — использовать встроенный метод list () .

Пример

Сделайте копию списка с помощью метода list () :

thislist = [«яблоко», «банан», «вишня»]
mylist = список (этот список)
печать (мой список)

Попробуй сам »

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

Есть несколько способов объединить или объединить два или более списков в Python.

Один из самых простых способов — использовать + оператор.

Пример

Присоединяйтесь к двум спискам:

list1 = [«a», «b», «c»]
list2 = [1, 2, 3]

list3 = list1 + list2
печать (список3)

Попробуй сам »

Еще один способ объединить два списка — добавить все элементы из списка2 в list1, один за другим:

Пример

Добавить list2 в list1:

list1 = [«a», «b», «c»]
list2 = [1, 2, 3]

для x в list2:
list1.добавить (x)

печать (список1)

Попробуй сам »

Или вы можете использовать extend () метод цель которого — добавить элементы из одного списка в другой список:

Пример

Используйте метод extend () , чтобы добавить list2 в конец list1:

list1 = [«a», «b», «c»]
list2 = [1, 2, 3]

list1.extend (list2)
печать (список1)

Попробуй сам »

Конструктор list ()

Также можно использовать конструктор list () для создания новый список.

Пример

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

thislist = list ((«яблоко», «банан», «вишня»)) # обратите внимание на двойные круглые скобки
печать (этот список)

Попробуй сам »

Список методов

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

Метод Описание
append () Добавляет элемент в конец списка
clear () Удаляет все элементы из списка
copy () Возвращает копию list
count () Возвращает количество элементы с указанным значением
extend () Добавить элементы списка (или любого итеративного) до конца текущего списка
index () Возвращает индекс первый элемент с указанным значением
insert () Добавляет элемент в в указанной позиции
pop () Удаляет элемент в указанное положение
remove () Удаляет элемент с указанным значением
reverse () Обратный порядок списка
sort () Сортирует список



.

списков Python — GeeksforGeeks

Списки похожи на массивы динамического размера, объявленные на других языках (вектор в C ++ и ArrayList в Java). Списки не всегда должны быть однородными, что делает их наиболее мощным инструментом в Python. Один список может содержать такие типы данных, как целые числа, строки, а также объекты. Списки изменяемы, и, следовательно, они могут быть изменены даже после их создания.

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

Note- Списки — полезный инструмент для сохранения последовательности данных и дальнейшего повторения по ней.

Содержание:

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


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

Список = []

печать ( «Пустой список:» )

печать ( Список )

Список = [ 10 , 20 , 14 ]

печать ( "\ nСписок номеров:" )

печать ( Список )

Список = [ «Вундеркинды» , «Для» , «Вундеркинды» ]

печать ( "\ nПредметы списка:" )

печать ( Список [ 0 ])

печать ( Список [ 2 ])

Список = [[ 'Компьютерщики' , 'Для' ], [ 'Компьютерщики » ]]

печать ( "\ nМногимерный список:" )

печать ( Список )

Выход:
Пустой список:
[]

Список номеров:
[10, 20, 14]

Элементы списка
Компьютерщики
Компьютерщики

Многомерный список:
[["Гики", "Для"], ["Гики"]]
 

Создание списка с несколькими отдельными или повторяющимися элементами

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

Список = [ 1 , 2 , 4 , 4 , 3 , 3 , 3 , 6 , 5 ]

печать ( "\ nСписок с использованием номеров:" )

печать ( Список )

Список = [ 1 , 2 , 'Компьютерщики' , 4 , 'Для' , 6 , «Вундеркинды» ]

печать ( "\ nСписок с использованием смешанных значений:" )

печать ( Список )

Выход:
Список с использованием чисел:
[1, 2, 4, 4, 3, 3, 3, 6, 5]

Список с использованием смешанных значений:
[1, 2, «Гики», 4, «Для», 6, «Гики»]
 

Список1 = []

печать ( лин (Список1))

Список2 = [ 10 , 20 , 14 ]

печать ( лин (Список2))

Использование метода append ()

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

Список = []

печать ( "Начальный пустой список:" )

печать ( Список )

Список .добавить ( 1 )

Список . Приложение ( 2 )

Список . Приложение ( 4 )

печать ( "\ nСписок после добавления трех элементов:" )

печать ( Список )

для i в диапазоне ( 1 , 4 ):

Список .добавление (i)

печать ( "\ nСписок после добавления элементов из 1-3:" )

печать ( Список )

Список . Приложение (( 5 , 6 ))

печать ( "\ nСписок после добавления кортежа:" )

печать ( Список )

List2 = [ 'Для' , 'Компьютерщики' ]

Список .добавить (Список2)

печать ( "\ nСписок после добавления списка:" )

печать ( Список )

Выход:
Начальный пустой список:
[]

Список после добавления трех элементов:
[1, 2, 4]

Список после добавления элементов из 1-3:
[1, 2, 4, 1, 2, 3]

Список после добавления кортежа:
[1, 2, 4, 1, 2, 3, (5, 6)]

Список после добавления списка:
[1, 2, 4, 1, 2, 3, (5, 6), ['For', 'Geeks']]
 

Использование вставки () метод

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



Список = [ 1 , 2 , 3 , 4 ]

печать ( "Исходный список:" )

печать ( Список )

Список .вставка ( 3 , 12 )

Список .insert ( 0 , 'Geeks' )

печать ( "\ nСписок после выполнения операции вставки:" )

печать ( Список )

Выход:
Первоначальный список:
[1, 2, 3, 4]

Список после выполнения операции вставки:
["Гики", 1, 2, 3, 12, 4]
 

Использование метода extend ()

Помимо методов append (), и insert () , есть еще один метод для добавления элементов, extend () , этот метод используется для одновременного добавления нескольких элементов в конце список.

Примечание. Методы append () и extend () могут добавлять элементы только в конце.

Список = [ 1 , 2 , 3 , 4 ]

печать ( "Исходный список:" )

печать ( Список )

Список .продлить ([ 8 , «Гики» , «Всегда» ])

печать ( "\ nСписок после выполнения операции расширения:" )

печать ( Список )

Выход:
Первоначальный список:
[1, 2, 3, 4]

Список после выполнения операции расширения:
[1, 2, 3, 4, 8, «Гики», «Всегда»]
 

Для доступа к элементам списка обратитесь к порядковому номеру.Используйте оператор индекса [] для доступа к элементу в списке. Индекс должен быть целым числом. Доступ к вложенным спискам осуществляется с помощью вложенного индексирования.

Список = [ «Вундеркинды» , «Для» , «Вундеркинды» ]

печать ( «Доступ к элементу из списка» )

печать ( Список [ 0 ])

печать ( Список [ 2 ])

Список = [[ 'Компьютерщики' , 'Для' ], [ 'Компьютерщики » ]]

печать ( «Доступ к элементу из многомерного списка» )

печать ( Список [ 0 ] [ 1 ])

печать ( Список [ 1 ] [ 0 ])

.Список Python

— 15 вещей, которые вы ДОЛЖНЫ знать

  • Список Python — изменяемая последовательность.
  • Мы можем создать список, поместив элементы в квадратную скобку.
  • Элементы списка разделяются запятой.
  • Мы можем создавать вложенные списки.
  • Список представляет собой упорядоченную коллекцию. Таким образом, он поддерживает порядок, в котором добавляются элементы.
  • Мы можем получить доступ к элементам списка с помощью index. Он также поддерживает отрицательный индекс для ссылки на элементы от начала до конца.
  • Мы можем распаковать элементы списка в переменные, разделенные запятыми.
  • Список Python может иметь повторяющиеся элементы. Они также разрешают Нет .
  • Список поддерживает два оператора: + для объединения и * для повторения элементов.
  • Мы можем разрезать список, чтобы создать другой список из его элементов.
  • Мы можем перебирать элементы списка с помощью цикла for.
  • Мы можем использовать оператор «in», чтобы проверить, присутствует ли элемент в списке или нет. Мы также можем использовать оператор «не в» со списком.
  • Список используется для хранения однородных элементов, куда мы хотим добавить / обновить / удалить элементы.

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

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

fruit_list = ["Яблоко", "Банан", "Апельсин"]
 

В списке можно хранить разные типы элементов.

random_list = [1, "A", объект (), 10,55, True, (1, 2)]
 

У нас также могут быть вложенные списки.

nested_list = [1, [2, 3], [4, 5, 6], 7]
 

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

empty_list = []
 
Создание списка в Python

Элементы списка доступа

Мы можем получить доступ к элементам списка с помощью index. Значение индекса начинается с 0.

>>> vowels_list = ["a", "e", "i", "o", "u"]
>>> список_гласных [0]
'а'
>>> список_гласных [4]
'ты'
 

Если индекс находится вне диапазона, возникает IndexError.

>>> список_гласных [40]
Отслеживание (последний вызов последний):
  Файл "", строка 1, в 
IndexError: список индекса вне допустимого диапазона
>>>
 
Доступ к элементам списка Python

Мы также можем передать отрицательное значение индекса. В этом случае элемент возвращается от конца к началу. Допустимый диапазон значений индекса — от -1 до — (длина списка).

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

>>> vowels_list = ["a", "e", "i", "o", "u"]
>>> vowels_list [-1] # последний элемент
'ты'
>>> vowels_list [-2] # второй последний элемент
'е'
>>> список_гласных [-5]
'а'
 

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

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

nested_list = [1, [2, 3], [4, 5, 6], 7]

# первый элемент во вложенной последовательности с индексом 1
печать (вложенный_лист [1] [0])

# второй элемент во вложенной последовательности с индексом 1
печать (вложенный_лист [1] [1])

# третий элемент во вложенной последовательности с индексом 2
печать (вложенный_лист [2] [2])
 

Вложенный элемент может быть любой другой последовательностью, которая также поддерживает доступ на основе индекса.Например, результат будет таким же для вложенного списка [1, (2, 3), (4, 5, 6), 7].

Мы также можем использовать отрицательные индексы с вложенными списками. Приведенный выше фрагмент кода можно переписать следующим образом.

nested_list = [1, (2, 3), (4, 5, 6), 7]

# первый элемент во вложенной последовательности в третьем последнем индексе
печать (вложенный_лист [-3] [0])

# последний элемент во вложенной последовательности в третьем последнем индексе
печать (вложенный_лист [-3] [- 1])

# последний элемент во вложенной последовательности по второму последнему индексу
печать (вложенный_лист [-2] [- 1])
 
Значения индекса списка Python

Обновление списка

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

>>> my_list = [1, 2, 3]
>>> my_list [1] = 10
>>> мой_лист
[1, 10, 3]
>>>
 

Перебор списка

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

>>> my_list = [1, 2, 3]
>>> для x в my_list:
... печать (x)
...
1
2
3
>>>
 

Если вы хотите перебирать элементы списка в обратном порядке, вы можете использовать встроенную функцию reversed ().

>>> my_list = [1, 2, 3]
>>> для x в обратном порядке (my_list):
... печать (x)
...
3
2
1
>>>
 

Проверить, существует ли элемент в списке

Мы можем использовать оператор «in», чтобы проверить, присутствует ли элемент в списке или нет. Точно так же мы можем использовать оператор «не в» со списком.

>>> my_list = [1, 2, 3]
>>>
>>> 1 в my_list
Правда
>>> 10 в my_list
Ложь
>>> 10 нет в my_list
Правда
>>> 1 нет в my_list
Ложь
>>>
 

Удаление списка

Мы можем использовать ключевое слово «del» для удаления индекса списка или самого полного списка.

>>> my_list = [1, 2, 3]
>>> del my_list [1]
>>> мой_лист
[1, 3]
>>>
>>> del my_list
>>> мой_лист
Отслеживание (последний вызов последний):
  Файл "", строка 1, в 
NameError: имя my_list не определено
>>>
 

Нарезка списка

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

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

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

печать (list_numbers [1: 3])
печать (list_numbers [: 4])
печать (list_numbers [5:])
print (list_numbers [: - 5])
 
Нарезка списка Python

Объединение списков (оператор +)

Мы можем объединить несколько списков элементов для создания нового списка с помощью оператора +.

>>> l1 = [1]
>>> l2 = [2, 3]
>>> l3 = [4, "5", (6, 7)]
>>>
>>> l1 + l2 + l3
[1, 2, 3, 4, '5', (6, 7)]
>>>
 

Повторяющиеся элементы списка (оператор *)

Python List также поддерживает оператор * для создания нового списка с элементами, повторяющимися указанное количество раз.

>>> l1 = [1, 2]
>>>
>>> l1 * 3
[1, 2, 1, 2, 1, 2]
>>>
 

Длина списка Python

Мы можем получить длину или размер списка с помощью встроенной функции len ().

>>> list_numbers = [1, 2, 3, 4]
>>> len (список_числов)
4
 

Встроенный конструктор list ()

Мы можем создать список из итерируемого, используя встроенный конструктор list (). Эта функция принимает итеративный аргумент, поэтому мы можем передавать String, Tuple и т. Д.

>>> l1 = список ("ABC")
>>> l1
['A', 'B', 'C']
>>>
>>> l1 = список ((1, 2, 3))
>>>
>>> l1
[1, 2, 3]
>>>
 

Функции списка Python

Давайте посмотрим на некоторые функции, присутствующие в объекте списка.

1. добавить (объект)

Эта функция используется для добавления элемента в конец списка.

>>> list_numbers = [1, 2, 3, 4]
>>> list_numbers.добавить (5)
>>> print (list_numbers)
[1, 2, 3, 4, 5]
 

2. индекс (объект, начало, конец)

Эта функция возвращает первый индекс объекта в списке. Если объект не найден, возникает ошибка ValueError .

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

>>> list_numbers = [1, 2, 1, 2, 1, 2]
>>>
>>> list_numbers.индекс (1)
0
>>> list_numbers.index (1, 1)
2
>>> list_numbers.index (1, 3, 10)
4
>>> list_numbers.index (10)
Отслеживание (последний вызов последний):
  Файл "", строка 1, в 
ValueError: 10 нет в списке
>>>
 

3. кол (объект)

Эта функция возвращает количество вхождений объекта в список.

>>> list_numbers = [1, 2, 1, 2, 1, 2]
>>> list_numbers.count (2)
3
>>> list_numbers.количество (1)
3
 

4. обратный ()

Эта функция переворачивает элементы списка.

>>> list_numbers = [1, 2, 3]
>>> list_numbers.reverse ()
>>> print (list_numbers)
[3, 2, 1]
 

5. прозрачный ()

Эта функция удаляет все элементы из списка.

>>> list_numbers = [1, 2, 5]
>>> list_numbers.clear ()
>>> print (list_numbers)
[]
 

6. копия ()

Эта функция возвращает частичную копию списка.

>>> list_items = [1, 2, 3]
>>> tmp_list = list_items.copy ()
>>> печать (tmp_list)
[1, 2, 3]
 

7. расширение (итерация)

Эта функция добавляет все элементы из итерируемого объекта в конец этого списка. Некоторые из известных итераций в Python — это Tuple, List и String.

>>> list_num = []
>>> list_num.extend ([1, 2]) # список повторяемых аргументов
>>> print (list_num)
[1, 2]
>>> list_num.extend ((3, 4)) # итерируемый аргумент кортежа
>>> print (list_num)
[1, 2, 3, 4]
>>> list_num.extend ("ABC") # строковый итеративный аргумент
>>> print (list_num)
[1, 2, 3, 4, «A», «B», «C»]
>>>
 

8. insert (индекс, объект)

Этот метод вставляет объект непосредственно перед заданным индексом.

Если значение индекса больше, чем длина списка, объект добавляется в конец списка.

Если значение индекса отрицательное и не входит в диапазон, то объект добавляется в начало списка.

>>> my_list = [1, 2, 3]
>>>
>>> my_list.insert (1, 'X') # вставить непосредственно перед индексом 1
>>> печать (мой_лист)
[1, 'X', 2, 3]
>>>
>>> my_list.insert (100, 'Y') # вставить в конец списка
>>> печать (мой_лист)
[1, 'X', 2, 3, 'Y']
>>>
>>> my_list.insert (-100, 'Z') # отрицательное значение и не входит в диапазон, поэтому вставьте его в начале
>>> печать (мой_лист)
['Z', 1, 'X', 2, 3, 'Y']
>>> my_list.insert (-2, 'A') # отрицательное значение и находится в диапазоне, поэтому вставьте перед вторым последним элементом
>>> печать (мой_лист)
['Z', 1, 'X', 2, 'A', 3, 'Y']
>>>
 

9.pop (индекс)

Эта функция удаляет элемент по заданному индексу и возвращает его. Если индекс не указан, последний элемент удаляется и возвращается.

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

>>> my_list = [1, 2, 3, 4]
>>>
>>> my_list.pop ()
4
>>> мой_лист
[1, 2, 3]
>>> my_list.pop (1)
2
>>> мой_лист
[1, 3]
>>> my_list.pop (-1)
3
>>> мой_лист
[1]
>>> мой_лист.поп (100)
Отслеживание (последний вызов последний):
  Файл "", строка 1, в 
IndexError: вывести индекс за пределы допустимого диапазона
>>>
 

10. удалить (объект)

Эта функция удаляет первое вхождение данного объекта из списка. Если объект не найден в списке, возникает ошибка ValueError .

>>> my_list = [1,2,3,1,2,3]
>>> my_list.remove (2)
>>> мой_лист
[1, 3, 1, 2, 3]
>>> my_list.remove (20)
Отслеживание (последний вызов последний):
  Файл "", строка 1, в 
ValueError: список.remove (x): x нет в списке
>>>
 

11. Сортировка (ключ, реверс)

Эта функция используется для сортировки элементов списка. Элементы списка должны реализовывать функцию __lt __ (self, other) .

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

Обратное принимает логическое значение. Если это True , то список сортируется в обратном порядке.Значение по умолчанию для обратного — False , и элементы сортируются в естественном порядке.

>>> list_num = [1, 0, 3, 4, -1, 5, 2]
>>> list_num.sort ()
>>> list_num
[-1, 0, 1, 2, 3, 4, 5]
>>> list_num.sort (обратный = True)
>>> list_num
[5, 4, 3, 2, 1, 0, -1]
>>>
 

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

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

Заключение

Список Python — изменяемая последовательность. Он предоставляет различные функции для добавления, вставки, обновления и удаления своих элементов. Мы можем создать список из других итерируемых элементов, используя встроенный конструктор list ().


Артикул:

.

списков и кортежей в Python — настоящий Python