Списки в Python – это упорядоченные, изменяемые коллекции элементов. Они являются одними из самых фундаментальных и часто используемых структур данных в Python. Вот основные действия, которые можно выполнять со списками:
1. Создание списков:
Пустой список:
· my_list = []
· my_list = list()
Список с элементами:
· my_list = [1, 2, 3, 4, 5]
· my_list = ["apple", "banana", "cherry"]
· my_list = [1, "hello", True, 3.14] # Списки могут содержать разные типы данных
Создание списка из другого итерируемого объекта (строки, кортежа, множества):
· my_list = list("hello") # [‘h’, ‘e’, ‘l’, ‘l’, ‘o’]
· my_tuple = (1, 2, 3)
· my_list = list(my_tuple) # [1, 2, 3]
· my_set = {4, 5, 6}
· my_list = list(my_set) # [4, 5, 6] (порядок элементов может быть непредсказуемым)
List comprehension (генератор списка): Это мощный способ создания списков, используя цикл и условные выражения.
· # Создание списка квадратов чисел от 0 до 9
· squares = [x**2 for x in range(10)] # [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
·
· # Создание списка четных чисел от 0 до 19
· even_numbers = [x for x in range(20) if x % 2 == 0] # [0, 2, 4, 6, 8, 10, 12, 14, 16, 18]
2. Доступ к элементам списка:
По индексу: Индексы начинаются с 0.
· my_list = ["apple", "banana", "cherry"]
· print(my_list[0]) # apple
· print(my_list[1]) # banana
· print(my_list[2]) # cherry
· print(my_list[-1]) # cherry (Последний Элемент)
· print(my_list[-2]) # banana (Предпоследний Элемент)
Срезы (slicing): Позволяют получить подсписок.
· my_list = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
· print(my_list[2:5]) # [2, 3, 4] (от индекса 2 включительно до индекса 5 исключительно)
· print(my_list[:3]) # [0, 1, 2] (от начала до индекса 3 исключительно)
· print(my_list[5:]) # [5, 6, 7, 8, 9] (от индекса 5 до конца)
· print(my_list[:]) # [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] (копия всего списка)
· print(my_list[::2]) # [0, 2, 4, 6, 8] (каждый второй элемент)
· print(my_list[::-1]) # [9, 8, 7, 6, 5, 4, 3, 2, 1, 0] (перевернутый список)
3. Изменение списков:
Изменение элемента по индексу:
· my_list = ["apple", "banana", "cherry"]
· my_list[1] = "grape"
· print(my_list) # [‘apple’, ‘grape’, ‘cherry’]
Добавление элементов:
append(element): Добавляет элемент в конец списка.
O my_list = [1, 2, 3]
O my_list. append(4)
O print(my_list) # [1, 2, 3, 4]
insert(index, element): Вставляет элемент по указанному индексу.
O my_list = [1, 2, 3]
O my_list. insert(1, "hello") # Вставляет "hello" На Индекс 1
O print(my_list) # [1, ‘hello’, 2, 3]
extend(iterable): Добавляет элементы из другого итерируемого объекта (списка, кортежа, строки) в конец списка.
O my_list = [1, 2, 3]
O my_list. extend([4, 5, 6])
O print(my_list) # [1, 2, 3, 4, 5, 6]
O
O my_list. extend("abc")
O print(my_list) # [1, 2, 3, 4, 5, 6, ‘a’, ‘b’, ‘c’]
Удаление элементов:
remove(element): Удаляет первое вхождение указанного элемента. Если элемент не найден, вызывается ValueError.
O my_list = [1, 2, 3, 2, 4]
O my_list. remove(2)
O print(my_list) # [1, 3, 2, 4]
pop(index): Удаляет элемент по указанному индексу и возвращает его. Если индекс не указан, удаляет и возвращает последний элемент.
O my_list = [1, 2, 3, 4]
O removed_element = my_list. pop(1) # Удаляет Элемент С Индексом 1 (2)
O print(my_list) # [1, 3, 4]
O print(removed_element) # 2
O
O removed_element = my_list. pop() # Удаляет Последний Элемент (4)
O print(my_list) # [1, 3]
O print(removed_element) # 4
del my_list[index]: Удаляет элемент по индексу (аналогично pop(index), но не возвращает значение). Можно использовать для удаления срезов.
O my_list = [1, 2, 3, 4, 5]
O del my_list[2]
O print(my_list) # [1, 2, 4, 5]
O
O del my_list[1:3] # Удаляем срез от индекса 1 (включительно) до 3 (исключительно)
O print(my_list) # [1, 5]
clear(): Удаляет все элементы из списка.
O my_list = [1, 2, 3]
O my_list. clear()
O print(my_list) # []
4. Другие полезные методы:
len(my_list): Возвращает длину списка (количество элементов).
· my_list = [1, 2, 3, 4, 5]
· print(len(my_list)) # 5
index(element, start, end): Возвращает индекс первого вхождения указанного элемента. Можно указать необязательные параметры start и end для поиска только в определенном диапазоне. Если элемент не найден, вызывается ValueError.
· my_list = ["apple", "banana", "cherry", "banana"]
· print(my_list. index("banana")) # 1
· print(my_list. index("banana", 2)) # 3 (Начинаем Поиск С Индекса 2)
· #print(my_list. index("grape")) # ValueError: ‘grape’ is not in list
count(element): Возвращает количество вхождений указанного элемента в списке.
· my_list = [1, 2, 2, 3, 2, 4]
· print(my_list. count(2)) # 3
· print(my_list. count(5)) # 0
sort(key=…, reverse=…): Сортирует список На месте (изменяет исходный список). Можно использовать параметры key для указания функции, используемой для сравнения элементов, и reverse для указания порядка сортировки (по возрастанию или по убыванию).
· my_list = [3, 1, 4, 1, 5, 9, 2, 6]
· my_list. sort()
· print(my_list) # [1, 1, 2, 3, 4, 5, 6, 9]
·
· my_list. sort(reverse=True)
· print(my_list) # [9, 6, 5, 4, 3, 2, 1, 1]
·
· words = ["apple", "Banana", "cherry"]
· words. sort() # Сортировка с учетом регистра
· print(words) # [‘Banana’, ‘apple’, ‘cherry’]
·
· words. sort(key=str. lower) # Сортировка без учета регистра
· print(words) # [‘apple’, ‘Banana’, ‘cherry’]
reversed(my_list): Возвращает Итератор в обратном порядке. Это Не изменяет исходный список. Чтобы получить перевернутый список, нужно преобразовать итератор в список.
· my_list = [1, 2, 3, 4, 5]
· reversed_list = list(reversed(my_list))
· print(reversed_list) # [5, 4, 3, 2, 1]
· print(my_list) # [1, 2, 3, 4, 5] (исходный список не изменился)
copy(): Создает Поверхностную копию списка. Это важно, если вы хотите изменить список, не затрагивая исходный список.
· my_list = [1, 2, [3, 4]]
· new_list = my_list. copy()
·
· new_list[0] = 10 # Изменяем элемент в new_list
· print(my_list) # [1, 2, [3, 4]] (my_list Не Изменился)
· print(new_list) # [10, 2, [3, 4]]
·
· new_list[2][0] = 30 # Изменяем вложенный список
·
· print(my_list) # [1, 2, [30, 4]] (my_list тоже изменился, т. к. вложенный список копируется по ссылке)
· print(new_list) # [10, 2, [30, 4]]
·
· import copy
· my_list = [1, 2, [3, 4]]
· new_list = copy. deepcopy(my_list) # Создаем Глубокую Копию
·
· new_list[2][0] = 30
·
· print(my_list) # [1, 2, [3, 4]]
· print(new_list) # [1, 2, [30, 4]] Теперь не изменился my_list, т. к. создана полная копия всех вложенных объектов
5. Операции со списками:
Сложение списков (+): Создает новый список, объединяя элементы двух списков.
· list1 = [1, 2, 3]
· list2 = [4, 5, 6]
· combined_list = list1 + list2
· print(combined_list) # [1, 2, 3, 4, 5, 6]
Умножение списка (*): Создает новый список, повторяя элементы исходного списка указанное количество раз.
· my_list = [1, 2, 3]
· repeated_list = my_list * 3
· print(repeated_list) # [1, 2, 3, 1, 2, 3, 1, 2, 3]
Проверка наличия элемента (in, not in):
· my_list = ["apple", "banana", "cherry"]
· print("banana" in my_list) # True
· print("grape" not in my_list) # True
Цикл For для перебора элементов списка:
· my_list = ["apple", "banana", "cherry"]
· for fruit in my_list:
· print(fruit)
Enumerate() для получения индекса и элемента одновременно:
· my_list = ["apple", "banana", "cherry"]
· for index, fruit in enumerate(my_list):
· print(f"Индекс: {index}, Фрукт: {fruit}")
6. List Comprehensions (Генераторы списков):
Это краткий и элегантный способ создавать новые списки на основе существующих.
Numbers = [1, 2, 3, 4, 5]
# Создание Списка Квадратов Чисел
Squares = [x**2 for x in numbers] # [1, 4, 9, 16, 25]
# Создание Списка Четных Чисел
Even_numbers = [x for x in numbers if x % 2 == 0] # [2, 4]
# Создание списка строк, преобразованных в верхний регистр
Words = ["hello", "world"]
Upper_words = [word. upper() for word in words] # [‘HELLO’, ‘WORLD’]
Важно помнить:
Списки являются изменяемыми (mutable). Это означает, что вы можете изменять их после создания. Индексы в списках начинаются с 0. Срезы создают новые списки, а не просто ссылки на часть исходного списка (поверхностное копирование). Будьте осторожны с поверхностным копированием при работе с вложенными списками (списками, содержащими другие списки). Используйте copy. deepcopy() для создания полной копии, если это необходимо.
Понимание этих действий со списками является ключевым для эффективной работы с данными в Python. Практикуйтесь, и вы быстро освоите их!