Списки (массивы) в Python

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

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

task1 = "Приготовить завтрак"
task2 = "Помыть посуду"
task3 = "Сходить в магазин"

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

tasks = ["Приготовить завтрак", "Помыть посуду", "Сходить в магазин"]

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

# добавляем новую задачу в список
tasks.append("Почистить квартиру")

# удаляем задачу из списка
del tasks[1]

# меняем порядок выполнения задач
tasks[0], tasks[1] = tasks[1], tasks[0]

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

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

Важно отметить, что в Python индексация элементов списка начинается с нуля. То есть первый элемент списка имеет индекс 0, второй элемент — индекс 1, и так далее.

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

Ручное создание списка

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

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

Также можно создать список из строк:

fruits = ["apple", "banana", "orange", "kiwi"]

Создание пустого списка

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

empty_list = []

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

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

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

# создаем пустой список
my_list = []

# заполняем список квадратами чисел от 1 до 10
for i in range(1, 11):
    my_list.append(i**2)

print(my_list)

Результат

[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

В данном примере мы создали пустой список my_list и заполнили его квадратами чисел от 1 до 10 с помощью цикла for. В каждой итерации цикла мы добавляем новый элемент в список с помощью метода append().

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

Создание списков с помощью функции list()

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

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

Пример:

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

print(my_list)

Результат:

['h', 'e', 'l', 'l', 'o']

В данном примере мы создали строку my_string и передали ее в функцию list(). Функция list() разбила строку на символы и создала из них список my_list.

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

Пример:

# создаем список из кортежа
my_tuple = (1, 2, 3, 4, 5)
my_list = list(my_tuple)

print(my_list)

Что такое итератор (итерируемый объект)

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

В Python все итерируемые объекты имеют метод __iter__(), который возвращает итератор — объект, реализующий метод __next__(), который в свою очередь возвращает следующий элемент итерируемого объекта.

В Python существует множество итерируемых объектов, например:

1. Последовательности (sequences) — это объекты, которые содержат элементы в определенном порядке. Примерами последовательностей в Python являются списки, кортежи, строки, диапазоны (range).
2. Результаты функций, которые возвращают итерируемые объекты. Например, функция range() возвращает итерируемый объект, содержащий диапазон чисел.
3. Функции модуля itertools. Этот модуль содержит множество функций для работы с итерируемыми объектами. Например, функция itertools.count() возвращает бесконечную последовательность чисел.

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

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

Использование list() с различными итераторами

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

1. Создание списка из последовательности:

s = 'Hello World'
lst = list(s)
print(lst) # ['H', 'e', 'l', 'l', 'o', ' ', 'W', 'o', 'r', 'l', 'd']

2. Создание списка из объекта range():

r = range(1, 6)
lst = list(r)
print(lst) # [1, 2, 3, 4, 5]

3. Создание списка из функции itertools.count():

import itertools

c = itertools.count(start=1, step=2)
lst = list(next(c) for _ in range(5))
print(lst) # [1, 3, 5, 7, 9]

В приведенных выше примерах мы использовали различные типы итераторов. В первом примере мы использовали итератор последовательности, во втором — итератор объекта range(), а в третьем — итератор функции itertools.count(). Конструктор list() позволяет создавать список из любого итерируемого объекта, что делает его очень гибким и удобным в использовании.

Функция map()

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

Рассмотрим пример. Дана строка состоящая из цифр. С помощью функции list() нужно сформировать список из цифр строки. Каждый элемент списка должен быть целым числом.

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

Затем мы преобразуем этот итератор в список с помощью функции list() и получаем список из цифр строки:

s = "1234567890"
digits = list(map(int, s))
print(digits)

Таким образом, комбинация list() и map() может быть очень полезна для создания списка, содержащего результаты функции, примененной к каждому элементу итерируемого объекта.

Функция filter()

Мы также могли бы использовать функцию filter() вместо условного выражения, чтобы фильтровать элементы. Например:

nums = [1, 2, 3, 4, 5]
evens = list(filter(lambda x: x % 2 == 0, nums))
print(evens) # [2, 4]

Здесь мы используем функцию filter() для выбора только четных элементов из списка nums. Функция filter() принимает функцию-предикат и итерируемый объект, и возвращает итератор, содержащий только те элементы, для которых функция-предикат возвращает True. Мы затем преобразуем этот итератор в список, используя конструктор list().

Что такое lambda функции. Как функции могут быть аргументами других функций?

Lambda-функция — это функция, которая определяется без использования ключевого слова def. Она используется для создания функций на лету, обычно для выполнения простых операций.

Лямбда-функции могут использоваться в качестве аргументов других функций, таких как map(), filter() и sorted(). Например, если вы хотите применить какую-то операцию ко всем элементам списка, вы можете использовать функцию map(), которая принимает в качестве аргументов функцию и итерируемый объект, и применяет функцию ко всем элементам объекта.

Вот пример использования lambda-функции в качестве аргумента функции map():

nums = [1, 2, 3, 4, 5]
squared_nums = map(lambda x: x**2, nums)

В этом примере мы используем lambda-функцию, которая принимает один аргумент x и возвращает x в квадрате. Затем мы передаем эту функцию и список nums функции map(), которая возвращает итератор, содержащий квадраты каждого элемента списка.

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

Вот примеры использования lambda-функций в качестве аргументов функций filter() и sorted():

nums = [1, 2, 3, 4, 5]
even_nums = filter(lambda x: x % 2 == 0, nums) # оставляем только четные числа

words = ['apple', 'banana', 'cherry', 'date']
sorted_words = sorted(words, key=lambda x: len(x)) # сортируем по длине слов

В этих примерах мы используем lambda-функции в качестве аргументов функций filter() и sorted(), чтобы выбрать только четные числа и отсортировать список слов по их длине.

Генераторы списков

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

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

squares = [x**2 for x in range(10)]
print(squares)

Здесь мы используем выражение x**2 для создания квадратов чисел от 0 до 9. Затем мы используем генератор списка, чтобы создать список из этих квадратов. Функция range(10) создает последовательность чисел от 0 до 9.

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

even_squares = [x**2 for x in range(10) if x % 2 == 0]
print(even_squares)

Здесь мы добавляем условие if x % 2 == 0, чтобы выбрать только четные числа из последовательности range(10).

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

Примеры создания списков через генератор и list()

Список случайных чисел от 1 до 100

Для создания списка из 20 случайных чисел от 1 до 100 с использованием генератора можно воспользоваться модулем random:

import random

random_list = [random.randint(1, 100) for _ in range(20)]
print(random_list)

В данном примере мы создаем список random_list из 20 случайных целых чисел в диапазоне от 1 до 100 с помощью генератора списков.

Аналогичным образом можно создать такой же список с помощью функции list() и генератора:

import random

random_list = list(random.randint(1, 100) for _ in range(20))
print(random_list)

Ввод списка с клавиатуры посредством генератора и list()

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

Пример создания списка из n чисел, введенных с клавиатуры:

n = int(input("Введите количество чисел: "))
my_list = [int(input(f"Введите число {i}: ")) for i in range(1, n+1)]
print(my_list)

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

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

n = int(input("Введите количество чисел: "))
my_list = list(int(input(f"Введите число {i}: ")) for i in range(1, n+1))
print(my_list)

Список из квадратов всех чисел от 1 до 1000, где исходное число кратно 3

Можно использовать генераторы списков и условные выражения для создания списка квадратов всех чисел от 1 до 1000, где исходное число кратно 3.

Вот пример:

squares = [x**2 for x in range(1, 1001) if x % 3 == 0]

В этом примере мы используем генератор списков, чтобы создать список квадратов всех чисел от 1 до 1000, которые кратны 3. Для этого мы используем цикл for x in range(1, 1001), чтобы пройти через все числа от 1 до 1000. Затем мы используем условное выражение if x % 3 == 0, чтобы проверить, кратно ли число 3. Если да, то мы добавляем его квадрат (x**2) в список squares.

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

squares_list = list(x**2 for x in range(1, 1001) if x % 3 == 0)

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

Задачи на закрепление

Задача 1. Создание списка из чисел, возведенных в степень 2, начиная с 0 и заканчивая 9.

squares = [x**2 for x in range(10)]
print(squares) # [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

Задача 2. Дана строка. Создать список из букв в строке.

word = "Hello"
letters = [letter for letter in word]
print(letters) # ['H', 'e', 'l', 'l', 'o']

Задача 3. Создание списка из всех четных чисел от 1 до 100.

even_nums = list(range(2, 101,2))
print(even_nums) # [2, 4, 6, 8, 10, ... , 96, 98, 100]

Задача 4. Создание списка из квадратов чисел от 1 до 10, которые являются четными.

squares = [x**2 for x in range(1, 11) if x**2 % 2 == 0]
print(squares) # [4, 16, 36, 64, 100]

Задача 5. Создание списка из чисел, которые делятся на 3 или на 5.

nums = list(x for x in range(1, 101) if x % 3 == 0 or x % 5 == 0)
print(nums) # [3, 5, 6, 9, 10, ... , 96, 99, 100]

Задача 6. Создание списка из целых чисел, которые являются степенями двойки.

powers_of_two = [pow(2, i) for i in range(10)]
print(powers_of_two) # [1, 2, 4, 8, 16, 32, 64, 128, 256, 512]

Задача 7. Создание списка из квадратных корней чисел от 1 до 10.

import math

squares = [math.sqrt(x) for x in range(1, 11)]
print(squares) # [1.0, 1.4142135623730951, 1.7320508075688772, 2.0, 2.236067977

Срезы и индексы в списках. Получение части списка.

Индексы элементов списка. Как получить элемент списка

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

Индексы начинаются с нуля для первого элемента в списке и увеличиваются на единицу для каждого последующего элемента.

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

my_list = [10, 20, 30, 40, 50]
print(my_list[2]) # выведет 30, так как это элемент с индексом 2 в списке

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

Срезы. Получение подсписка.

Срез (slice) в списке — это операция извлечения подсписка из исходного списка по указанным индексам элементов.

Синтаксис среза выглядит так: список[start:stop:step], где start — индекс первого элемента, который будет включен в срез, stop — индекс элемента, который не будет включен в срез, step — шаг, с которым нужно выбирать элементы.

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

Например, если мы хотим получить первые три элемента списка my_list, мы можем использовать срез:

my_list = [1, 2, 3, 4, 5]
first_three = my_list[:3] # [1, 2, 3]

Если мы хотим выбрать каждый второй элемент списка my_list, мы можем использовать срез с шагом 2:

my_list = [1, 2, 3, 4, 5]
every_other = my_list[::2] # [1, 3, 5]

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

my_list = [1, 2, 3, 4, 5]
my_list[1:4] = [10, 20, 30] # [1, 10, 20, 30, 5]

Срезы с двумя параметрами: start, stop

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

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

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

срез a[2:6] вернет подсписок, начиная с элемента с индексом 2 и заканчивая элементом с индексом 5 (элемент с индексом 6 не включается):

[2, 3, 4, 5]

Также мы можем не указывать начальный или конечный индекс.

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

Примеры:

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

# срез от начала до 5 элемента (не включая)
b = a[:5]
# результат: [0, 1, 2, 3, 4]

# срез с 3 элемента до конца списка
c = a[3:]
# результат: [3, 4, 5, 6, 7, 8, 9]

# срез с 3 элемента до 7 элемента (не включая)
d = a[3:7]
# результат: [3, 4, 5, 6]

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

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

В Python индексы списка могут быть отрицательными, что означает отсчёт элементов с конца списка. Индекс -1 соответствует последнему элементу списка, -2 — предпоследнему и так далее.

Например, если у нас есть список my_list с элементами [1, 2, 3, 4, 5], то my_list[-1] вернет 5, my_list[-2] вернет 4, и так далее.

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

Пример:

my_list = [1, 2, 3, 4, 5]
last_element = my_list[-1] # 5
second_last_element = my_list[-2] # 4

Также отрицательные индексы могут использоваться в срезах. Например, чтобы получить последние два элемента списка, можно использовать срез my_list[-2:].

Пример:

my_list = [1, 2, 3, 4, 5]
last_two_elements = my_list[-2:] # [4, 5]

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

Срезы с тремя параметрами: start, stop, step

Срезы с тремя параметрами (start, stop, step) используются для получения подсписков из списка с определенным шагом.

Параметр start задает начальный индекс среза, stop — конечный индекс (не включая элемент с индексом stop), а step — шаг между элементами.

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

my_list = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
# срез со второго элемента до седьмого с шагом 2
print(my_list[1:7:2]) # [1, 3, 5]
# срез со всего списка с шагом 3
print(my_list[::3]) # [0, 3, 6, 9]
# срез с последнего элемента до первого с шагом -1 (обратный порядок)
print(my_list[-1::-1]) # [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]

Если не задать значение для start, то срез начнется с начала списка. Если не задать значение для stop, то срез будет до конца списка. Если значение параметра step отрицательное, то элементы списка будут выбираться в обратном порядке.

Когда используется отрицательный шаг step, начальный индекс start должен указывать на элемент с большим индексом, чем конечный индекс stop, иначе срез будет пустым. Например:

my_list = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
# срез с конца списка до элемента с индексом 3 с шагом -2
print(my_list[3::-2]) # [] #Неправильно!
print(my_list[9:2:-2]) # [9, 7, 5, 3] #Правильно!

Задачи для закрепления

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

lst = [1, 2, 3, 4, 5]
result = lst[:3]
print(result)  # [1, 2, 3]

Задача 9. Получить последние два элемента списка.

lst = [1, 2, 3, 4, 5]
result = lst[-2:]
print(result)  # [4, 5]

Задача 10. Получить каждый второй элемент списка.

lst = [1, 2, 3, 4, 5]
result = lst[::2]
print(result)  # [1, 3, 5]

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

lst = [1, 2, 3, 4, 5]
result = lst[1:4]
print(result)  # [2, 3, 4]

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

lst = [1, 2, 3, 4, 5, 6, 7, 8, 9]
result = lst[1:7:3]
print(result)  # [2, 5]

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

lst = [1, 2, 3, 4, 5, 6, 7, 8, 9]
result = lst[-1:-5:-4]
print(result)  # [9, 5]

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

lst = [1, 2, 3, 4, 5]
result = lst[1:-1]
print(result)  # [2, 3, 4]

Задача 15. Получить список, состоящий из каждого второго элемента, начиная с первого элемента списка.

lst = [1, 2, 3, 4, 5, 6, 7, 8, 9]
result = lst[::2]
print(result)  # [1, 3, 5, 7, 9]

Изменение списков

Операторы при работе со списками

1. Операторы при работе со списками в Python позволяют выполнять различные операции над списками, изменять их содержимое, сравнивать и объединять.
2. Некоторые из операторов при работе со списками:
3. Оператор индексации [ ]: позволяет получить элемент списка по его индексу. Например, my_list[0] вернет первый элемент списка my_list.
4. Оператор среза [ : ]: позволяет получить часть списка, начиная с указанного индекса и заканчивая другим указанным индексом. Например, my_list[1:4] вернет элементы списка, начиная со второго элемента и заканчивая четвертым элементом.
5. Оператор длины len( ): позволяет получить количество элементов в списке. Например, len(my_list) вернет количество элементов в списке my_list.
6. Операторы + и *: позволяют объединять списки и умножать их на число, соответственно. Например, my_list1 + my_list2 объединит списки my_list1 и my_list2, а my_list * 3 создаст список, содержащий три копии списка my_list.
7. Операторы in и not in: позволяют проверить наличие элемента в списке. Например, 5 in my_list вернет True, если число 5 содержится в списке my_list, и False в противном случае.
8. Оператор присваивания =: позволяет присваивать новое значение элементу списка по его индексу. Например, my_list[0] = "new_value" присвоит новое значение первому элементу списка my_list.
9. Оператор удаления элемента del: позволяет удалить элемент списка по его индексу. Например, del my_list[0] удалит первый элемент списка my_list.
10. Оператор сравнения ==: позволяет проверить равенство двух списков. Например, my_list1 == my_list2 вернет True, если списки my_list1 и my_list2 содержат одни и те же элементы в том же порядке, и False в противном случае.

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

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

my_list = [1, 2, 3, 4, 5]
third_element = my_list[2]
print(third_element) # выведет 3

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

my_list = [1, 2, 3, 4, 5]
first_three_elements = my_list[:3]
print(first_three_elements) # выведет [1, 2, 3]

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

my_list = [1, 2, 3, 4, 5]
list_length = len(my_list)
print(list_length) # выведет 5

Оператор проверки вхождения — позволяет проверить, содержится ли элемент в списке. Например:

my_list = [1, 2, 3, 4, 5]
is_3_in_list = 3 in my_list
print(is_3_in_list) # выведет True

Оператор конкатенации — позволяет объединять два списка в один. Например:

list1 = [1, 2, 3]
list2 = [4, 5, 6]
concatenated_list = list1 + list2
print(concatenated_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]

Оператор присваивания по индексу — позволяет изменять значение элемента списка по его индексу. Например:

my_list = [1, 2, 3, 4, 5]
my_list[2] = 10
print(my_list) # выведет [1, 2, 10, 4, 5]

Оператор удаления по индексу — позволяет удалить элемент списка по его индексу. Например:

fruits = ['apple', 'banana', 'cherry', 'orange']
del fruits[1]
['apple', 'cherry', 'orange'] #Элемент с индексом 1 (т.е. 'banana') был удален из списка.

Оператор not in используется для проверки отсутствия элемента в списке. Например:

my_list = [1, 2, 3, 4, 5]
if 6 not in my_list:
print("6 is not in the list")

Оператор <strong>+=</strong> используется для добавления элементов другого списка в конец текущего списка. Например:

my_list = [1, 2, 3]
my_list += [4, 5, 6]
print(my_list)

Вывод: [1, 2, 3, 4, 5, 6]

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

my_list = [1, 2, 3, 4, 5]
my_list -= [3, 4, 6]
print(my_list)

Вывод: [1, 2, 5]

Оператор <strong>*=</strong> используется для повторения текущего списка заданное число раз. Например:

my_list = [1, 2, 3]
my_list *= 3
print(my_list)

Вывод: [1, 2, 3, 1, 2, 3, 1, 2, 3]

Оператор /= не применим к спискам, так как операция деления не имеет смысла в контексте списков. Операторы //= и %= также не имеют смысла для списков.

Оператор **= также не применим к спискам, так как операция возведения в степень не имеет смысла в контексте списков.

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

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

my_list = ['apple', 'banana', 'cherry']

и мы хотим изменить второй элемент списка ‘banana’ на ‘orange’, то можно использовать следующий код:

my_list[1] = 'orange'

После этого список будет выглядеть следующим образом:

['apple', 'orange', 'cherry']

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

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

my_list[:2] = ['grape', 'kiwi']

После этого список будет выглядеть следующим образом:

['grape', 'kiwi', 'cherry']

Здесь мы использовали срез, который указывает на первые два элемента списка, и присвоили ему новые значения ‘grape’ и ‘kiwi’.

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

Пример:

my_list = [1, 2, 3, 4, 5]
my_list[1:4] = [6, 7, 8]
print(my_list) # [1, 6, 7, 8, 5]

В данном примере мы выбираем срез элементов списка my_list от индекса 1 до 4 (не включая индекс 4), т.е. [2, 3, 4] и заменяем его на список [6, 7, 8]. Результатом будет измененный список [1, 6, 7, 8, 5].

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

my_list = [1, 2, 3, 4, 5]
my_list[::2] = [10, 30, 50]
print(my_list) # [10, 2, 30, 4, 50]

В данном примере мы выбираем каждый второй элемент списка, начиная с первого элемента и заменяем его на список [10, 30, 50]. Результатом будет измененный список [10, 2, 30, 4, 50].

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

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

Пример:

lst = [1, 2, 3, 4, 5]
lst[1:4] = [6, 7]
print(lst) # Output: [1, 6, 7, 5]

Здесь мы заменяем срез [2, 3, 4] на новый список [6, 7], и получаем итоговый список [1, 6, 7, 5].

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

Пример:

lst = [1, 2, 3, 4, 5]
lst[1:3] = [6, 7, 8, 9]
print(lst) # Output: [1, 6, 7, 8, 9, 4, 5]

Здесь мы заменяем срез [2, 3] на новый список [6, 7, 8, 9], но так как длина нового списка больше, то оставшаяся часть списка смещается вправо, и мы получаем итоговый список [1, 6, 7, 8, 9, 4, 5].

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

Пример изменения каждого второго элемента списка с индексом больше 2 на значение 0 с использованием среза с отрицательным шагом:

my_list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
my_list[-3::-2] = [0] * len(my_list[-3::-2])
print(my_list)

Результат

[1, 2, 3, 0, 5, 0, 7, 0, 9, 0]

В данном примере мы использовали срез от -3 элемента (индекс -3 соответствует третьему элементу с конца списка) до конца списка с шагом -2 (то есть каждый второй элемент с конца). Затем мы заменили каждый элемент полученного среза на 0, используя операцию присваивания через срез.

Задания для закрепления

Задача 16. Замена части списка на другой список.

Дан список чисел:

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

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

new_numbers = [11, 12, 13]

numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
new_numbers = [11, 12, 13]

numbers[:3] = new_numbers

print(numbers) # [11, 12, 13, 4, 5, 6, 7, 8, 9, 10]

Задача 17. Удаление элементов списка по индексу.

Дан список строк:

fruits = ['apple', 'banana', 'cherry', 'date', 'elderberry']

Необходимо удалить из него элементы с индексами 1 и 3.

fruits = ['apple', 'banana', 'cherry', 'date', 'elderberry']

del fruits[3]
del fruits[1]

print(fruits) # ['apple', 'cherry', 'elderberry']

Задача 18. Замена каждого второго элемента на другой элемент.

Дан список чисел:

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

Необходимо заменить каждый второй элемент на число 0.

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

numbers[1::2] = [0] * ((len(numbers) - 1) // 2 + 1)

print(numbers) # [1, 0, 3, 0, 5, 0, 7, 0, 9, 0]

Задача 19. Создать список из 5 элементов, повторяющихся 3 раза.

lst = [1, 2, 3, 4, 5]
new_lst = lst * 3
print(new_lst)

Задача 20. Создать список из трех списков, объединив их в один.

lst1 = [1, 2, 3]
lst2 = [4, 5, 6]
lst3 = [7, 8, 9]
new_lst = lst1 + lst2 + lst3
print(new_lst)

Задача 21. Создать список из строк, повторяющихся в порядке их индексов. То есть для ['apple','banana', 'orange', 'grape'] : ['apple', 'bananabanana', 'orangeorangeorange', 'grapegrapegrapegrape']

lst = ['apple', 'banana', 'orange', 'grape']
new_lst = [lst[i] * (i+1) for i in range(len(lst))]
print(new_lst)

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

Добавление элементов в конец списка. Методы append() и extend().

Чтобы добавить элемент в конец списка, можно использовать метод append(). Например, если у нас есть список my_list, мы можем добавить элемент в конец списка следующим образом:

my_list = [1, 2, 3]
my_list.append(4)
print(my_list) # Output: [1, 2, 3, 4]

Метод append() добавляет переданный элемент в конец списка и изменяет его исходный размер. Если нужно добавить несколько элементов в конец списка, можно передать итерируемый объект (например, список) в метод extend(). Например:

my_list = [1, 2, 3]
my_list.extend([4, 5])
print(my_list) # Output: [1, 2, 3, 4, 5]

Здесь мы передаем список [4, 5] в метод extend(), который добавляет его элементы в конец списка my_list. Обратите внимание, что метод extend() изменяет исходный список.

Добавление элемента списка в произвольное место

Чтобы добавить элемент в произвольное место списка, можно использовать метод insert().

Синтаксис метода insert() выглядит так: list.insert(index, obj), где index — индекс, куда нужно вставить элемент, obj — объект, который нужно вставить.

Пример:

my_list = [1, 2, 3, 4, 5]
my_list.insert(2, 'new')
print(my_list)

В этом примере мы вставляем строку ‘new’ на индекс 2 списка my_list. Результат выполнения будет: [1, 2, 'new', 3, 4, 5].

Удаление элемента из списка

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

my_list = [1, 2, 3, 4, 5]
my_list.remove(3)
print(my_list) # [1, 2, 4, 5]

Если элемента в списке нет, то будет сгенерировано исключение ValueError.

Удаление нескольких элементов из списка

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

my_list = [1, 2, 3, 4, 5, 6]
del my_list[2:5]

После этого операции del элементы с индексами 2, 3 и 4 будут удалены из списка my_list.

Еще один вариант — использовать метод remove(), чтобы удалить элементы по их значению. Например, чтобы удалить все элементы со значением 3 из списка my_list, можно сделать следующее:

my_list = [1, 2, 3, 4, 3, 5, 6, 3]
while 3 in my_list:
   my_list.remove(3)

После выполнения этих операций в списке my_list останутся только элементы [1, 2, 4, 5, 6].

Задания для закрепления.

Задача 22. Добавьте элементы «cat», «dog» и «hamster» в конец списка pets. pets = "bird", "fish"]

pets = ["bird", "fish"]
pets += ["cat", "dog", "hamster"]
print(pets)

Задача 23. Удаление элемента из списка. Удалите элемент «dog» из списка pets. pets = ["bird", "fish", "cat", "dog", "hamster"]

pets = ["bird", "fish", "cat", "dog", "hamster"]
pets.remove("dog")
print(pets)

Задача 24. Добавление элемента в середину списка. Добавьте элемент «parrot» после элемента «bird» в список pets. pets = ["bird", "fish", "cat", "dog", "hamster"]

pets = ["bird", "fish", "cat", "hamster"]
pets.insert(1, "parrot")
print(pets)

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

numbers = [2, 7, 3, 8, 1, 9, 4, 6, 5]
numbers = [n for n in numbers if n <= 5]
print(numbers)

Поиск в списке

Поиск элемента по значению. Метод index()

Для поиска элемента в списке по его значению можно использовать метод index(). Он возвращает индекс первого вхождения элемента в список, если элемент найден, и генерирует исключение ValueError, если элемент не найден. Например:

my_list = [1, 2, 3, 4, 5]
index_of_3 = my_list.index(3)
print(index_of_3) # Output: 2

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

my_list = [1, 2, 3, 4, 5]
try:
    index_of_6 = my_list.index(6)
    print(index_of_6)
except ValueError:
    print("Element not found")

Output: Element not found

Поиск элемента по индексу (номеру)

Чтобы найти элемент списка по индексу, можно использовать квадратные скобки [] и указать индекс элемента внутри них. Например, для списка my_list и индекса 2 следует написать my_list[2]. Это вернет элемент списка, который расположен на третьей позиции (индексация начинается с 0).

Пример:

my_list = ['apple', 'banana', 'cherry']
print(my_list[1]) # выведет 'banana'

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

Как проверить, есть ли элемент в списке?

Для проверки наличия элемента в списке можно использовать ключевое слово in вместе с именем списка. Ключевое слово in возвращает True, если элемент есть в списке, и False, если элемента в списке нет.

Пример:

my_list = ['apple', 'banana', 'orange']
print('apple' in my_list) # True
print('pear' in my_list) # False

Задания на закрепление материала

Задача 26. Дан список чисел, проверить, содержится ли число 5 в этом списке.

numbers = [2, 3, 5, 7, 11, 13]

if 5 in numbers:
    print("Число 5 содержится в списке numbers")
else:
    print("Число 5 не содержится в списке numbers")

Задача 27. Имеется список названий фруктов. Найти индекс апельсина в этом списке.

fruits = ['яблоко', 'банан', 'киви', 'апельсин', 'манго']

fruit = 'апельсин'

if fruit in fruits:
    index = fruits.index(fruit)
    print(f"Индекс элемента {fruit} в списке fruits: {index}")
else:
    print(f"Элемент {fruit} не найден в списке fruits")

Перебор элементов списка в цикле

Перебор списка в цикле — это процесс обхода каждого элемента списка и выполнения определенных операций с ним.

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

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

Вот простой пример перебора элементов списка без использования индексов:

my_list = ['apple', 'banana', 'orange', 'pear']

for item in my_list:
    print(item)

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

Перебор индексов списка

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

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

Использование функции range() с длиной списка, полученной с помощью функции len():

my_list = ['a', 'b', 'c']
for i in range(len(my_list)):
    print(i, my_list[i])

Использование функции enumerate() для получения индекса и значения элемента списка:

my_list = ['a', 'b', 'c']
for i, val in enumerate(my_list):
    print(i, val)

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

my_list = ['a', 'b', 'c']
for i, val in enumerate(my_list, start=1):
    print(i, val)

Этот код выведет:

1 a
2 b
3 c

Задания для закрепления

Задача 28. Дан список из целых чисел. Посчитать количество четных чисел в нем.

numbers = [3, 5, 2, 8, 1, 9, 6, 4]
count = 0
for num in numbers:
    if num % 2 == 0:
        count += 1
print(f"Количество четных чисел: {count}")

Задача 29. Дан список из названий фруктов. Добавить слева к названию фрукта, его позицию(начиная с 1) через точку. Было: ‘banana’. Стало: ‘2.banana’

fruits = ["apple", "banana", "cherry", "date", "elderberry"]
for i in range(len(fruits)):
    fruits[i] = f"{i+1}. {fruits[i]}"
print(fruits)

Задача 30. Дан список из названий фруктов. Удалить все элементы, содержащие в названии определенную подстроку.

words = ["apple", "banana", "cherry", "date", "elderberry"]
substring = "err"
for i in range(len(words)-1, -1, -1):
    if substring in words[i]:
        del words[i]
print(words)

Преобразование списка в строку и наоборот

Как преобразовать список в строку

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

Пример:

my_list = ['apple', 'banana', 'orange']
my_string = ', '.join(my_list)
print(my_string)

Результат выполнения:

apple, banana, orange

В данном примере мы создали список my_list из трех фруктов, затем с помощью метода join() объединили его элементы в строку my_string с разделителем ', '.

Как преобразовать строку в список

Чтобы преобразовать строку в список, можно использовать методы list() и split().

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

s = "hello"
lst = list(s)
print(lst) # ['h', 'e', 'l', 'l', 'o']

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

s = "10,20,30,40,50"
lst = s.split(",")
print(lst) # ['10', '20', '30', '40', '50']

В этом примере split() разбивает строку на части по запятой и возвращает список этих частей.

Также можно использовать метод split() без аргументов, чтобы разбить строку на части по пробельным символам:

s = "hello world"
lst = s.split()
print(lst) # ['hello', 'world']

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

Задания на закрепление

Задача 31. Дан список слов. Напишите программу, которая объединяет все слова в одну строку, разделяя их пробелом.

words = ["hello", "world", "how", "are", "you"]
result = " ".join(words)
print(result)

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

my_string = "hello world"

my_list = list(my_string)

new_list = []

for char in my_list:
    new_list.append(char.upper())

print(new_list)

my_string = "hello world"
my_list = list(my_string)
new_list = []
for char in my_list:
new_list.append(char.upper())
print(new_list)

['H', 'E', 'L', 'L', 'O', ' ', 'W', 'O', 'R', 'L', 'D']

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

s = "1,2,3,4,5"
lst = s.split(",")
lst = [int(i) for i in lst]
print(lst)

Функции для работы со списками

Как найти максимальное и минимальное значение в списке?

Для нахождения максимального и минимального значения в списке можно использовать функции max() и min() соответственно.

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

numbers = [3, 7, 2, 9, 1, 4]

max_value = max(numbers)
min_value = min(numbers)

print("Максимальное значение:", max_value)
print("Минимальное значение:", min_value)

Этот код выведет:

Максимальное значение: 9
Минимальное значение: 1

Функции max() и min() также могут принимать несколько списков в качестве аргументов, и тогда они будут возвращать максимальное и минимальное значение среди всех элементов в этих списках.

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

Для сортировки списка в Python используется метод sort() или функция sorted(). Оба этих метода сортируют список в порядке возрастания элементов по умолчанию.

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

my_list = [3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5]
my_list.sort()
print(my_list)

Вывод:

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

Если нужно отсортировать список в порядке убывания, можно передать параметр reverse=True:

my_list = [3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5]
my_list.sort(reverse=True)
print(my_list)

Вывод:

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

Если нужно отсортировать список по другому критерию, можно передать функцию key, которая будет использоваться для определения порядка сортировки. Например, для сортировки списка строк по длине:

my_list = ['apple', 'banana', 'cherry', 'date', 'elderberry', 'fig']
my_list.sort(key=len)
print(my_list)

Вывод:
['date', 'fig', 'apple', 'banana', 'cherry', 'elderberry']

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

Функция sorted() работает аналогично методу sort(), но возвращает новый отсортированный список вместо изменения оригинального списка:

my_list = [3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5]
sorted_list = sorted(my_list)
print(sorted_list)

Вывод:

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

Параметр reverse и функция key также могут быть использованы с функцией sorted().

Как найти сумму элементов в списке

Для нахождения суммы элементов списка можно использовать функцию sum(). Функция sum() принимает на вход список и возвращает сумму его элементов.

Пример:

my_list = [1, 2, 3, 4, 5]
sum_of_list = sum(my_list)
print(sum_of_list) # выводит 15

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

my_list = [1, 2, "three", 4, 5]
sum_of_list = sum(my_list) # вызывает TypeError

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

my_list = [1, 2, "three", 4, 5]
filtered_list = [x for x in my_list if isinstance(x, (int, float))]
sum_of_list = sum(filtered_list)
print(sum_of_list) # выводит 12

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

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

Функции any() и all() являются встроенными функциями Python и используются для работы с логическими значениями.

Функция any() принимает на вход итерируемый объект и возвращает True, если хотя бы один элемент этого объекта истинен (не равен False, 0, None, "", (), [], {}), и False, если все элементы ложны. Вот пример использования функции any():

numbers = [1, 0, 3, 5, 7]
result = any(numbers) # True, так как в списке есть хотя бы одно ненулевое число

Функция all() также принимает на вход итерируемый объект и возвращает True, если все элементы этого объекта истинны, и False, если хотя бы один элемент ложен. Вот пример использования функции all():

numbers = [1, 2, 3, 4, 5]
result = all(numbers) # True, так как все элементы списка ненулевые

Функции any() и all() могут быть использованы в различных ситуациях, например, для проверки наличия хотя бы одного ненулевого элемента в списке или для проверки того, что все элементы списка удовлетворяют какому-то условию.

Задания для тренировки

Задача 34.Найти максимальный элемент в списке целых чисел.

numbers = [2, 7, 1, 9, 3, 8]
max_number = max(numbers)
print("Максимальное число в списке:", max_number)

Задача 35. Найти минимальный элемент в списке вещественных чисел.

numbers = [2.5, 1.1, 3.7, 0.8, 2.3]
min_number = min(numbers)
print("Минимальное число в списке:", min_number)

Задача 36. Дан список чисел. Найти сумму его элементов и их количество.

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

# Находим сумму чисел в списке
sum_numbers = sum(numbers)
print("Сумма чисел в списке:", sum_numbers)

# Находим количество чисел в списке
count_numbers = len(numbers)
print("Количество чисел в списке:", count_numbers)

Сумма чисел в списке: 15
Количество чисел в списке: 5

Задача 37. Дан список чисел. Необходимо отсортировать список чисел в порядке убывания.

numbers = [5, 1, 9, 3, 7, 4]
numbers.sort(reverse=True)
print(numbers)  # [9, 7, 5, 4, 3, 1]

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

fruits = ['Apple', 'banana', 'orange', 'kiwi']
fruits.sort(key=str.lower)
print(fruits)  # ['Apple', 'banana', 'kiwi', 'orange']

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

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

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

numbers = [1, 2, 3, 4]
numbers.append(5)
print(numbers) # [1, 2, 3, 4, 5]

insert(): вставляет элемент на заданную позицию

numbers = [1, 2, 3, 4]
numbers.insert(2, 2.5)
print(numbers) # [1, 2, 2.5, 3, 4]

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

numbers = [1, 2, 3, 4]
numbers.insert(2, 2.5)
print(numbers) # [1, 2, 2.5, 3, 4]

<strong>pop()</strong>: удаляет элемент из списка по указанному индексу (если индекс не указан, удаляет последний элемент)

numbers = [1, 2, 3, 4]
numbers.pop(1)
print(numbers) # [1, 3, 4]

clear(): удаляет все элементы из списка

numbers = [1, 2, 3, 4]
numbers.clear()
print(numbers) # []

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

numbers = [1, 2, 3, 4, 2]
index = numbers.index(2)
print(index) # 1

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

numbers = [1, 2, 3, 4, 2]
count = numbers.count(2)
print(count) # 2

sort(): сортирует список по возрастанию (при использовании параметра reverse=True, сортирует по убыванию). Может использоваться с параметром key для определения критерия сортировки

numbers = [3, 1, 4, 2]
numbers.sort()
print(numbers) # [1, 2, 3, 4]

words = ['apple', 'banana', 'cherry', 'date']
words.sort(key=lambda x: len(x))
print(words) # ['date', 'apple', 'banana', 'cherry']

<strong>reverse()</strong>: изменяет порядок элементов в списке на обратный

numbers = [1, 2, 3, 4]
numbers.reverse()
print(numbers) # [4, 3, 2, 1]

<strong>copy()</strong> — метод, возвращающий копию списка. Например:

lst = [1, 2, 3]
lst_copy = lst.copy()
print(lst_copy) # [1, 2, 3]

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

<strong>extend()</strong> — метод, добавляющий элементы другого списка в конец списка.

lst1 = [1, 2, 3]
lst2 = [4, 5, 6]
lst1.extend(lst2)
print(lst1) # [1, 2, 3, 4, 5, 6]

Двумерные массивы

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

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

Вот пример создания и использования двумерного массива в Python:

# создание двумерного массива
matrix = [[1, 2, 3],
[4, 5, 6],
[7, 8, 9]]

# доступ к элементу массива
print(matrix[0][0]) # выведет 1
print(matrix[1][2]) # выведет 6

# изменение элемента массива
matrix[2][1] = 10

# перебор элементов массива
for row in matrix:
    for element in row:
        print(element, end=' ')
    print()

В данном примере мы создали двумерный массив matrix размером 3×3, где каждый элемент представляет собой целое число. Для доступа к элементу массива мы указываем два индекса: первый индекс соответствует номеру строки, а второй индекс — номеру столбца. Мы также можем изменять значения элементов массива. Для перебора элементов массива мы используем два вложенных цикла for, сначала перебирая строки, а затем элементы в каждой строке.

Создание двумерного массива

Создание двумерного списка с помощью цикла

# Создание двумерного списка размером 3 на 4 с помощью цикла
matrix = []
for i in range(3):
    row = []
    for j in range(4):
        row.append(i * j)
    matrix.append(row)

# Вывод двумерного списка
for row in matrix:
    print(row)

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

Создание двумерного списка с помощью генератора

# Создание двумерного списка размером 3 на 4 с помощью генератора
matrix = [[i * j for j in range(4)] for i in range(3)]

# Вывод двумерного списка
for row in matrix:
    print(row)

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

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

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

Пример:

# Создание двумерного массива 3x3
matrix = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]

# Получение значения элемента во второй строке и третьем столбце
value = matrix[1][2]

print(value) # Output: 6

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

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

Для перебора двумерного массива можно использовать двойной цикл for. Первый цикл перебирает строки, а второй — элементы каждой строки. Например:

# создаем двумерный массив
matrix = [
  [1, 2, 3],
  [4, 5, 6],
  [7, 8, 9]
]

# перебираем строки и элементы каждой строки
for row in matrix:
  for element in row:
    print(element, end=' ')
  print()

Вывод:

1 2 3
4 5 6
7 8 9

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

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

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

for i in range(len(matrix)):
    for j in range(len(matrix[i])):
        print(matrix[i][j], end=' ')
    print()

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

Ввод матрицы с клавиатуры

matrix = []
 
# Заполнение списка
for i in range(3):
    row = input().split()
    matrix.append(row)
 
# Вывод списка на экран
for i in range(3):
    for j in range(3):
        print(matrix[i][j], end=' ')
    print()

Для ввода двумерного списка с клавиатуры можно использовать вложенные циклы. В данном примере мы создаем пустой список matrix и заполняем его значениями, введенными с клавиатуры. Для этого мы используем цикл for, который проходит по строкам списка (три раза в данном примере) и в каждой итерации запрашивает у пользователя ввод строки. Метод split() разбивает введенную строку на отдельные элементы (разделитель по умолчанию — пробел), которые добавляются в список row. Затем список row добавляется в список matrix.

После заполнения списка мы выводим его на экран, также используя вложенные циклы. Первый цикл проходит по строкам списка, второй — по элементам в каждой строке. Функция print() с параметром end=' ' позволяет выводить элементы списка через пробел, а не переносить строку после каждого элемента. Второй вызов функции print() без параметров просто переносит строку, чтобы следующая строка списка начиналась с новой строки.

Альтернативный вариант, где вводится каждый элемент отдельно:

# Запрашиваем у пользователя количество строк и столбцов
rows = int(input("Введите количество строк: "))
cols = int(input("Введите количество столбцов: "))

# Создаем пустой двумерный массив нужного размера
matrix = []

# Заполняем массив в цикле
for i in range(rows):
    row = []
    for j in range(cols):
        # Запрашиваем у пользователя значение для текущей ячейки
        val = int(input(f"Введите элемент [{i}][{j}]: "))
        row.append(val)
    matrix.append(row)

# Выводим полученный массив на экран
for row in matrix:
    print(row)

В данном примере пользователь сначала вводит количество строк и столбцов в массиве. Затем в двойном цикле заполняется пустой массив matrix с помощью встроенной функции input(), которая запрашивает у пользователя значение для каждой ячейки. Наконец, полученный массив выводится на экран с помощью цикла for.

Пример обработки двумерного массива

Пусть дан квадратный массив из n строк и n столбцов. Необходимо элементам, находящимся на главной диагонали, проходящей из левого верхнего угла в правый нижний (то есть тем элементам a[i][j], для которых i==j) присвоить значение 1, элементам, находящимся выше главной диагонали – значение 0, элементам, находящимся ниже главной диагонали – значение 2.

Для решения данной задачи необходимо пройтись по элементам массива в двойном цикле. Если i==j (т.е. элемент находится на главной диагонали), то присваиваем ему значение 1. Если i<j (элемент выше диагонали), то присваиваем ему значение 0. Если i>j (элемент ниже диагонали), то присваиваем ему значение 2.

Пример кода:

n = int(input("Введите размерность квадратной матрицы: "))
matrix = [[0]*n for i in range(n)]

for i in range(n):
    for j in range(n):
        if i == j:
            matrix[i][j] = 1
        elif i < j:
            matrix[i][j] = 0
        else:
            matrix[i][j] = 2

# вывод матрицы
for row in matrix:
    print(row)

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

Задания на закрепление

Задача 39. Дан двумерный массив размером n строк и m столбцов, заполненный случайными числами от 1 до 100. Наша задача — найти индексы первого вхождения максимального элемента и вывести их на экран.

import random

n = int(input("Введите количество строк: "))
m = int(input("Введите количество столбцов: "))

# создаем двумерный массив с случайными числами от 1 до 100
matrix = [[random.randint(1, 100) for j in range(m)] for i in range(n)]

# выводим массив на экран
print("Двумерный массив:")
for i in range(n):
    for j in range(m):
        print(matrix[i][j], end=" ")
    print()

# инициализируем переменные для хранения индексов максимального элемента
max_i = 0
max_j = 0

# перебираем все элементы массива
for i in range(n):
    for j in range(m):
        # если текущий элемент больше максимального,
        # то запоминаем его индексы
        if matrix[i][j] > matrix[max_i][max_j]:
            max_i = i
            max_j = j

# выводим индексы максимального элемента
print(f"Индексы максимального элемента: ({max_i}, {max_j})")

Задача 40. Дана матрица размером n*n, где n — нечетное число. Заполни матрицу символами «1», затем средний столбец символами «2», потом среднюю строку символами «3», потом главную диагональ — «4», затем побочную диагональ — «5»

n = 7  # нечетное число
matrix = []
for i in range(n):
    row = []
    for j in range(n):
        row.append("1")
    matrix.append(row)

for i in range(n):
    matrix[i][n // 2] = "2"

for j in range(n):
    matrix[n // 2][j] = "3"

for i in range(n):
    matrix[i][i] = "4"

for i in range(n):
    matrix[i][n - i - 1] = "5"

4 1 1 2 1 1 5
1 4 1 2 1 5 1
1 1 4 2 5 1 1
3 3 3 5 3 3 3
1 1 5 2 4 1 1
1 5 1 2 1 4 1
5 1 1 2 1 1 4

for row in matrix:
    for elem in row:
        print(elem, end=" ")
    print()

Задача 41. Дан двумерный массив и два числа: i и j. Поменяйте в массиве столбцы с номерами i и j и выведите результат. Программа получает на вход размеры массива n и m, затем элементы массива, затем числа i и j.

n, m = map(int, input().split())
arr = [list(map(int, input().split())) for _ in range(n)]
i, j = map(int, input().split())

# Перебираем все строки и меняем элементы i-го и j-го столбцов местами
for k in range(n):
    temp = arr[k][i]
    arr[k][i] = arr[k][j]
    arr[k][j] = temp

# Выводим результат
for row in arr:
    print(*row)

Входные данные:
3 4
1 2 3 4
5 6 7 8
9 10 11 12
1 2

Результат:
3 2 1 4
7 6 5 8
11 10 9 12

Задача 42. Реализуйте структуру, хранящую информацию о занятых/свободных местах в концертном зале. Строки матрицы — ряды, а столбцы — места в ряду. Если место занято, в матрице поставьте значение -1, иначе — стоимость билета на данное место. Дано два числа: r и m — номер ряда и место. Определите, занято или нет место. Если занято — выведите соответствующий текст. Если свободно — выведите стоимость билета.

n = 5 # число рядов
m = 6 # число мест в ряду

# создаем матрицу для хранения информации о занятых/свободных местах
hall = []
for i in range(n):
    row = []
    for j in range(m):
        row.append(i*j) # просто заполняем матрицу случайными значениями
    hall.append(row)

# выводим информацию о месте с номером (3, 4)
r = 3
m = 4
if hall[r-1][m-1] == -1:
    print("Место занято")
else:
    print("Стоимость билета:", hall[r-1][m-1])

Задача 43. Дана шахматная доска 8*8. В позиции i,j стоит шахматный ферзь. Отметьте на шахматной доске, реализованной в виде матрицы:

единицами клетки, куда может пойти ферзь

нулями — куда не может

и -1 — текущую позицию ферзя.

# создаем матрицу 8x8 и заполняем ее нулями
board = [[0] * 8 for i in range(8)]

# задаем координаты ферзя
i, j = 3, 4

# помечаем текущую позицию ферзя
board[i][j] = -1

# помечаем строки и столбцы, находящиеся в той же позиции с ферзем
for k in range(8):
    board[i][k] = 1
    board[k][j] = 1

# помечаем диагонали
for k in range(8):
    for l in range(8):
        if k + l == i + j or k - l == i - j:
            board[k][l] = 1

# выводим матрицу на экран
for row in board:
    for elem in row:
        print(str(elem).rjust(2), end=' ')
    print()

Кортежи в Python

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

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

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

Пример создания кортежа:

my_tuple = (1, 'hello', [3, 4, 5])

Пример получения элемента кортежа:

print(my_tuple[1]) # 'hello'

Попытка изменения элемента кортежа приведет к ошибке:

my_tuple[0] = 2 # TypeError: 'tuple' object does not support item assignment

Создание кортежей

Кортежи можно создавать несколькими способами:

При помощи литерала кортежа, заключенного в круглые скобки:

my_tuple = (1, 2, 3)

При помощи встроенной функции tuple(), которая принимает в качестве аргумента итерабельный объект:

my_list = [1, 2, 3]
my_tuple = tuple(my_list)

При помощи генератора кортежей:

my_tuple = (x for x in range(3))

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

Что можно, и чего нельзя делать с кортежами

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

Операции и методы, которые применимы к кортежам и спискам:

1. Индексация: элементы кортежа и списка можно получить с помощью квадратных скобок и индекса, например my_tuple[0] или my_list[-1].
2. Срезы: можно получить подмножество элементов кортежа или списка с помощью срезов, например my_tuple[1:3] или my_list[:-2].
3. Оператор in: можно проверить, содержится ли элемент в кортеже или списке с помощью оператора in, например 5 in my_tuple или 'hello' in my_list.
4. Встроенные функции len(), max() и min(): можно получить длину кортежа или списка, а также максимальное и минимальное значение элементов, если они сравнимы.
5. Методы count() и index(): можно получить количество вхождений элемента в кортеже или списке (my_tuple.count(5)) и индекс первого вхождения элемента (my_list.index('hello')).

Операции и методы, которые неприменимы к кортежам, но применимы к спискам:

1. Методы append(), extend(), insert(), remove(), pop(), sort() и другие, которые изменяют список.
2. Оператор присваивания = с последующим изменением значения элемента списка.
3. Функция id(), которая возвращает уникальный идентификатор объекта в памяти.

Эти операции и методы не применимы к кортежам, потому что кортежи в Python являются неизменяемыми (immutable) объектами. После создания кортежа его элементы не могут быть изменены.

Функция zip()

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

Например, если у нас есть два списка:

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

Тогда можно использовать функцию zip, чтобы объединить их элементы в кортежи:

zipped = zip(list1, list2)

Переменная zipped теперь будет содержать итератор, элементами которого будут кортежи (1, 'a'), (2, 'b') и (3, 'c').

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

Функция zip() может быть использована для совместной обработки нескольких списков. Например, если есть два списка, один содержит имена студентов, а другой — их оценки по математике, то можно использовать zip() для создания нового списка, в котором будут пары имя студента — оценка:

names = ['Alice', 'Bob', 'Charlie']
scores = [80, 90, 75]

name_score_pairs = zip(names, scores)
# [('Alice', 80), ('Bob', 90), ('Charlie', 75)]

Функция unzip() может быть использована для разбиения списка кортежей на отдельные списки. Например, если есть список кортежей, содержащий пары имя студента — оценка по математике, то можно использовать unzip() для создания двух отдельных списков — один со списком имен студентов, а другой — со списком оценок:

name_score_pairs = [('Alice', 80), ('Bob', 90), ('Charlie', 75)]

names, scores = unzip(name_score_pairs)
# ['Alice', 'Bob', 'Charlie'], [80, 90, 75]

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

Задание для повторения

Задача 44. Даны два списка names и ages с одинаковым количеством элементов. Создайте новый список person_info, который будет содержать кортежи с информацией о каждом человеке в формате (name, age).

names = ['Alice', 'Bob', 'Charlie', 'David']
ages = [24, 32, 45, 19]

person_info = list(zip(names, ages))

print(person_info)

[('Alice', 24), ('Bob', 32), ('Charlie', 45), ('David', 19)]

Распаковка последовательностей

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

Рассмотрим основные сценарии распаковки:

Распаковка в простых случаях:

# Распаковка кортежа
coordinates = (3, 4)
x, y = coordinates
print(f"x: {x}, y: {y}")

# Распаковка списка
colors = ['red', 'green', 'blue']
first, second, third = colors
print(f"first: {first}, second: {second}, third: {third}")

Распаковка с использованием звездочки (распаковка последнего элемента или оставшихся элементов):

# Распаковка последнего элемента
first, *rest = [1, 2, 3, 4, 5]
print(f"first: {first}, rest: {rest}")

# Распаковка оставшихся элементов
first, *middle, last = [1, 2, 3, 4, 5]
print(f"first: {first}, middle: {middle}, last: {last}")

Распаковка в функциях:

# Пример функции с неизвестным числом аргументов
def print_elements(*args):
    for arg in args:
        print(arg)

print_elements(1, 2, 3, 'a', 'b')

# Пример функции с именованными аргументами
def print_person_info(name, age, **kwargs):
    print(f"Name: {name}, Age: {age}")
    for key, value in kwargs.items():
        print(f"{key}: {value}")

print_person_info(name='John', age=30, city='New York', occupation='Engineer')

Распаковка при передаче аргументов в функцию

values = (1, 2, 3, 4, 5)
print(*values)

Работа со списками. Видеоуроки

Базовая теория и примеры работы:

Работа с двумерными списками (матрицами)

Задания на закрепление

Еще несколько заданий, на усвоение пройденного материала по теме «Списки в Python».

Задача 45. Дан список случайных чисел от 0 до 100. Выведите все элементы, которые меньше предыдущего.

from random import randrange
lst = [randrange(1,101) for i in range(20)]

pairs = zip(lst[1:], lst)
result = [curr for curr, prev in filter(lambda x: x[0] < x[1], pairs)]

print(result)

Задача 46. Дан список случайных чисел от -100 до 100. Выведи количество соседних элементов разного знака.

from random import randint

lst = [randint(-100, 100) for _ in range(20)]
count = 0

for i in range(len(lst) - 1):
    if lst[i] * lst[i+1] < 0:
        count += 1

Задача 47. Дан список случайных чисел от 0 до 10. Выведите максимальный элемент списка и его индекс. Если элементов несколько, то выведите индекс его последнего вхождения.

from random import randint

lst = [randint(0,10) for _ in range(20)]

max_val = max(lst)
max_index = len(lst) - lst[::-1].index(max_val) - 1
print("Максимальный элемент списка:", max_val)
print("Индекс максимального элемента:", max_index)

Задача 48. Дан список населения городов страны. В него решили добавить сведения о новом городе. Определить, на каком месте будет находиться новый город в списке. Если несколько городов будут иметь равную численность с новым, то новый город встает в списке ПОСЛЕ ранее добавленных городов.

population = [('city1', 100000), ('city2', 50000), ('city3', 200000)]

new_city = ('new_city', 150000)

# Добавляем новый город в список
population.append(new_city)

# Сортируем список по убыванию населения городов
population.sort(key=lambda x: x[1], reverse=True)

# Находим позицию для нового города
for i, city in enumerate(population):
    if city[1] <= new_city[1]:
        # Если есть города с равным населением, находим индекс последнего города и добавляем 1
        if i > 0 and population[i-1][1] == new_city[1]:
            position = population.index(population[i-1]) + 1
        else:
            position = i
        break

print(f"Новый город {new_city[0]} с населением {new_city[1]} должен быть вставлен на позицию {position}")

Новый город new_city с населением 150000 должен быть вставлен на позицию 2

Задача 49. Дан список случайных чисел от 0 до 10. Сколько в нем различных элементов?

from random import randint

lst = [randint(0, 10) for _ in range(10)]
unique_lst = []

for elem in lst:
    if elem not in unique_lst:
        unique_lst.append(elem)

print(f"Список: {lst}")
print(f"Количество уникальных элементов: {len(unique_lst)}")

Список: [5, 10, 7, 8, 2, 3, 0, 10, 8, 6]
Количество уникальных элементов: 8

Задача 50. Дан список случайных чисел от 0 до 100. Переставь местами пары соседних элементов. Под парой подразумеваются элементы 0-1, 2-3, 4-5 и т.д.

import random

lst = [random.randint(0, 100) for _ in range(10)]
print("Исходный список:", lst)

for i in range(0, len(lst)-1, 2):
    lst[i], lst[i+1] = lst[i+1], lst[i]

print("Переставленный список:", lst)

Исходный список: [85, 28, 14, 88, 29, 31, 43, 47, 57, 72]
Переставленный список: [28, 85, 88, 14, 31, 29, 47, 43, 72, 57]

Задача 51. Дан список, в котором все элементы различны. Переставьте местами вторые по величине максимумы и минимумы списка.

lst = [5, 8, 2, 10, 1, 7, 3, 6, 4, 9]  # пример списка

min_index = lst.index(min(lst))  # находим индекс минимального элемента
max1_index = lst.index(max(lst))  # находим индекс максимального элемента
lst[max1_index] = float('-inf')  # заменяем первый максимум на бесконечно маленькое число
max2_index = lst.index(max(lst))  # находим индекс второго максимума
lst[max1_index] = lst[max2_index]  # восстанавливаем первый максимум
lst[max2_index] = float('inf')  # заменяем второй максимум на бесконечно большое число
min2_index = lst.index(min(lst))  # находим индекс второго минимума
lst[max1_index], lst[min2_index] = lst[min2_index], lst[max1_index]  # меняем местами минимум и второй максимум
print(lst)  # выводим результат

Задача 52. Дан список случайных чисел от 0 до 5. Посчитайте сколько в нем пар одинаковых чисел. Пара — два любых элемента списка.

from random import randint
lst = [randint(0,5) for _ in range(20)]
pairs = 0

for i in range(len(lst)):
    for j in range(i+1, len(lst)):
        if lst[i] == lst[j]:
            pairs += 1

print(pairs)

Задача 53. Дан список случайных чисел от 0 до 5. Выведите элементы, которые встречаются в списке ровно три раза.

lst = [1, 2, 3, 4, 3, 3, 5, 5, 1, 0]
result = []

for i in range(len(lst)):
    if lst.count(lst[i]) == 3 and lst[i] not in result:
        result.append(lst[i])

print(result)  # [3, 5]

Задача 54. Дана шахматная доска 8*8 с расположенными на ней случайным образом восемью ладьями.

Информация о расположении ладей, представлена в виде матрицы, где 0 — свободная ячейка шахматного поля, а 1 — ячейка, занятая ладьей.

Подсчитать, сколько ладей могут побить другие фигуры на доске.

board = [[0, 0, 0, 1, 0, 0, 0, 0],
         [0, 0, 0, 0, 0, 0, 0, 1],
         [0, 1, 0, 0, 0, 0, 0, 0],
         [0, 0, 0, 0, 1, 0, 0, 0],
         [1, 0, 0, 0, 0, 0, 0, 0],
         [0, 0, 0, 0, 0, 0, 1, 0],
         [0, 0, 0, 0, 0, 1, 0, 0],
         [0, 0, 1, 0, 0, 0, 0, 0]]

count = 0
for i in range(8):
    for j in range(8):
        if board[i][j] == 1:  # если на клетке находится ладья
            for k in range(8):
                if board[i][k] == 1 and k != j:  # проверяем ладьи на этом же ряду
                    count += 1
                    break
                if board[k][j] == 1 and k != i:  # проверяем ладьи на этом же столбце
                    count += 1
                    break

print("Количество ладей, которые могут побить другие фигуры:", count)