10 главных операций с массивами Python для эффективной обработки данных

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

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

# Список с использованием конструктора list()
converted_list = list("Python") # Создаст ['P', 'y', 't', 'h', 'o', 'n']

# Генератор списков (list comprehension)
squares = [x**2 for x in range(10)] # [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

languages = ["Python", "Java", "JavaScript", "C++"]
print(languages[0]) # Python
print(languages[-1]) # C++ (отрицательный индекс считается с конца)

numbers = [10, 20, 30]
numbers[1] = 25 # Теперь список: [10, 25, 30]

# Добавление в конец списка (O(1) – константное время)
fruits = ["яблоко", "банан"]
fruits.append("груша")
print(fruits) # ["яблоко", "банан", "груша"]

# Вставка элемента по индексу (O(n) – линейное время)
fruits.insert(1, "апельсин")
print(fruits) # ["яблоко", "апельсин", "банан", "груша"]

# Расширение списка другим списком
more_fruits = ["киви", "ананас"]
fruits.extend(more_fruits)
print(fruits) # ["яблоко", "апельсин", "банан", "груша", "киви", "ананас"]

# Оператор + для конкатенации (создает новый список)
new_fruits = fruits + ["манго"]
print(new_fruits) # [..., "манго"]

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

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

# Удаление по значению (первое вхождение)
cities.remove("Казань")
print(cities) # ["Москва", "Санкт-Петербург", "Новосибирск", "Екатеринбург"]

# Удаление по индексу с возвращением элемента
removed_city = cities.pop(1) # "Санкт-Петербург"
print(cities) # ["Москва", "Новосибирск", "Екатеринбург"]

# Удаление последнего элемента
last_city = cities.pop() # "Екатеринбург"
print(cities) # ["Москва", "Новосибирск"]

# Удаление всех элементов
cities.clear()
print(cities) # []

# Оператор del для удаления элементов или срезов
numbers = [1, 2, 3, 4, 5]
del numbers[1] # [1, 3, 4, 5]
del numbers[1:3] # [1, 5]

# Неэффективно
numbers = [1, 2, 3, 4, 5, 6]
for num in numbers[:]: # Копия для итерации
if num % 2 == 0:
numbers.remove(num)

# Эффективно
numbers = [1, 2, 3, 4, 5, 6]
numbers = [num for num in numbers if num % 2 != 0]

# Базовая сортировка (изменяет исходный список)
numbers = [3, 1, 4, 1, 5, 9, 2]
numbers.sort()
print(numbers) # [1, 1, 2, 3, 4, 5, 9]

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

# Сортировка без изменения исходного списка
original = [3, 1, 4, 1, 5]
sorted_list = sorted(original)
print(original) # [3, 1, 4, 1, 5]
print(sorted_list) # [1, 1, 3, 4, 5]

# Сортировка строк (лексикографическая)
words = ["яблоко", "Банан", "апельсин"]
words.sort() # ["Банан", "апельсин", "яблоко"] (сначала заглавные буквы)
words.sort(key=str.lower) # ["апельсин", "Банан", "яблоко"] (игнорирует регистр)

# Сортировка по длине строк
words = ["Python", "JavaScript", "C++", "Rust", "Go"]
words.sort(key=len)
print(words) # ["Go", "C++", "Rust", "Python", "JavaScript"]

# Сортировка словарей по значению ключа
students = [
{"name": "Анна", "grade": 95},
{"name": "Борис", "grade": 88},
{"name": "Вера", "grade": 92}
]
students.sort(key=lambda student: student["grade"], reverse=True)
print(students) # [{"name": "Анна", "grade": 95}, {"name": "Вера", "grade": 92}, ...]

# Сортировка по нескольким критериям с operator.itemgetter
from operator import itemgetter
employees = [
("Иванов", "Инженер", 85000),
("Петров", "Инженер", 75000),
("Сидоров", "Менеджер", 95000)
]
# Сначала по должности, потом по зарплате (убывание)
employees.sort(key=itemgetter(1, 2), reverse=True)

fruits = ["яблоко", "банан", "груша", "яблоко", "апельсин"]

# Проверка наличия элемента
if "банан" in fruits:
print("Банан есть в списке")

# Поиск индекса первого вхождения
apple_index = fruits.index("яблоко") # 0
# Поиск в подмножестве списка
apple_index = fruits.index("яблоко", 1) # 3 (поиск начиная с индекса 1)

# Подсчёт вхождений элемента
apple_count = fruits.count("яблоко") # 2

# Поиск максимального/минимального элемента
max_fruit = max(fruits) # "яблоко" (лексикографически)
min_fruit = min(fruits) # "апельсин" (лексикографически)

# Поиск с использованием генератора списков
found_fruits = [f for f in fruits if f.startswith("а")] # ["яблоко", "апельсин", "яблоко"]

# Поиск с использованием filter
found_fruits = list(filter(lambda f: len(f) > 5, fruits)) # ["яблоко", "яблоко", "апельсин"]

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

# Проверяем, все ли элементы больше нуля
all_positive = all(num > 0 for num in numbers) # True

# Проверяем, есть ли в списке четные числа
has_even = any(num % 2 == 0 for num in numbers) # True

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

# Фильтрация с помощью генератора списков (предпочтительный способ)
even_numbers = [num for num in numbers if num % 2 == 0]
print(even_numbers) # [2, 4, 6, 8, 10]

# Фильтрация с помощью функции filter()
odd_numbers = list(filter(lambda x: x % 2 != 0, numbers))
print(odd_numbers) # [1, 3, 5, 7, 9]

# Комбинирование фильтрации и трансформации
squared_evens = [num**2 for num in numbers if num % 2 == 0]
print(squared_evens) # [4, 16, 36, 64, 100]

# Фильтрация с использованием нескольких условий
filtered = [num for num in numbers if num % 2 == 0 and num > 5]
print(filtered) # [6, 8, 10]

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

# Базовые срезы
first_three = sequence[:3] # [0, 1, 2]
middle_items = sequence[3:7] # [3, 4, 5, 6]
last_three = sequence[-3:] # [7, 8, 9]

# Срезы с шагом
even_numbers = sequence[::2] # [0, 2, 4, 6, 8]
odd_numbers = sequence[1::2] # [1, 3, 5, 7, 9]

# Отрицательный шаг (обратный порядок)
reversed_seq = sequence[::-1] # [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
reverse_evens = sequence[::-2] # [9, 7, 5, 3, 1]

# Комбинирование начала/конца с шагом
part_reversed = sequence[7:2:-1] # [7, 6, 5, 4, 3]

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

# Замена подпоследовательности
original[1:4] = [20, 30] # [1, 20, 30, 5]

# Вставка элементов без удаления
original[2:2] = [25, 26] # [1, 20, 25, 26, 30, 5]

# Удаление подпоследовательности
original[2:5] = [] # [1, 20, 5]

list1 = [1, 2, 3]
list2 = [4, 5, 6]
list3 = [7, 8, 9]

# Конкатенация с оператором +
combined = list1 + list2 # [1, 2, 3, 4, 5, 6]

# Использование метода extend()
result = list1.copy() # Создаем копию, чтобы не изменять исходный список
result.extend(list2) # [1, 2, 3, 4, 5, 6]

# Объединение нескольких списков
mega_list = list1 + list2 + list3 # [1, 2, 3, 4, 5, 6, 7, 8, 9]

# Метод sum() с пустым списком в качестве начального значения
combined = sum([list1, list2, list3], []) # [1, 2, 3, 4, 5, 6, 7, 8, 9]

# Использование распаковки (unpacking) с Python 3.5+
combined = [*list1, *list2, *list3] # [1, 2, 3, 4, 5, 6, 7, 8, 9]

# Метод chain() из модуля itertools
from itertools import chain
combined = list(chain(list1, list2, list3)) # [1, 2, 3, 4, 5, 6, 7, 8, 9]

# Селективное объединение с генераторами списков
selective = [x for x in list1 if x % 2 == 0] + [y for y in list2 if y % 2 == 1]
# [2, 5]

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

# Чередование элементов
def interleave(list1, list2):
result = []
for i in range(max(len(list1), len(list2))):
if i < len(list1):
result.append(list1[i])
if i < len(list2):
result.append(list2[i])
return result

interleaved = interleave([1, 3, 5], [2, 4, 6]) # [1, 2, 3, 4, 5, 6]

# Разделение списка на чанки определенного размера
def chunk_list(lst, chunk_size):
return [lst[i:i + chunk_size] for i in range(0, len(lst), chunk_size)]

chunks = chunk_list(data, 3) # [[1, 2, 3], [4, 5, 6], [7, 8, 9], [10]]

# Вращение списка (циклический сдвиг)
def rotate(lst, k):
k = k % len(lst) # Обработка случая, когда k больше длины списка
return lst[-k:] + lst[:-k] if k else lst.copy()

rotated = rotate(data, 3) # [8, 9, 10, 1, 2, 3, 4, 5, 6, 7]

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

# Доступ к элементам
element = matrix[1][2] # 6 (элемент на 2-й строке, 3-м столбце)

# Изменение элементов
matrix[0][1] = 20
# Теперь matrix = [[1, 20, 3], [4, 5, 6], [7, 8, 9]]

# Создание трехмерного массива (куб 2x2x2)
cube = [
[[1, 2], [3, 4]],
[[5, 6], [7, 8]]
]

# Доступ к элементу трехмерного массива
element = cube[1][0][1] # 6

import numpy as np

# Создание двумерного массива
np_matrix = np.array([
[1, 2, 3],
[4, 5, 6],
[7, 8, 9]
])

# Доступ и изменение элементов так же интуитивны
element = np_matrix[1, 2] # 6
np_matrix[0, 1] = 20

# Операции со всем массивом
np_matrix = np_matrix * 2 # Умножает все элементы на 2

# Срезы работают по всем измерениям
sub_matrix = np_matrix[:2, 1:] # Первые 2 строки, все столбцы кроме первого

# Обход элементов матрицы
matrix = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]

for i in range(len(matrix)):
for j in range(len(matrix[i])):
print(f"matrix[{i}][{j}] = {matrix[i][j]}")

# Альтернативный обход с перечислением строк
for row in matrix:
for element in row:
print(element, end=' ')
print() # Переход на новую строку после каждой строки матрицы

# Создание матрицы заданного размера (3x4)
rows, cols = 3, 4
matrix = [[0 for _ in range(cols)] for _ in range(rows)]

# Транспонирование матрицы (без NumPy)
transposed = [[row[i] for row in matrix] for i in range(len(matrix[0]))]

# Сложение матриц
matrix_a = [[1, 2], [3, 4]]
matrix_b = [[5, 6], [7, 8]]
result = [[matrix_a[i][j] + matrix_b[i][j] for j in range(len(matrix_a[0]))]
for i in range(len(matrix_a))]

import numpy as np

# Создание матрицы заданного размера (3x4)
matrix = np.zeros((3, 4)) # Матрица из нулей
matrix = np.ones((3, 4)) # Матрица из единиц
matrix = np.full((3, 4), 7) # Матрица заполненная 7

# Транспонирование
transposed = matrix.T
# или
transposed = np.transpose(matrix)

# Матричные операции
matrix_a = np.array([[1, 2], [3, 4]])
matrix_b = np.array([[5, 6], [7, 8]])

# Сложение
result = matrix_a + matrix_b
# или
result = np.add(matrix_a, matrix_b)

# Умножение матриц
product = np.dot(matrix_a, matrix_b)
# или в современном синтаксисе
product = matrix_a @ matrix_b

# Вычисление детерминанта
determinant = np.linalg.det(matrix_a)

# Нахождение обратной матрицы
inverse = np.linalg.inv(matrix_a)

# Решение системы линейных уравнений Ax = b
b = np.array([1, 2])
x = np.linalg.solve(matrix_a, b)

import numpy as np

# Broadcasting: операции между массивами разной формы
array_2d = np.array([[1, 2, 3], [4, 5, 6]])
array_1d = np.array([10, 20, 30])

# Прибавление вектора к каждой строке матрицы
result = array_2d + array_1d # [[11, 22, 33], [14, 25, 36]]

# Маскирование: выбор элементов по условию
mask = array_2d > 3
filtered = array_2d[mask] # [4, 5, 6]

# Изменение элементов по условию
array_2d[array_2d % 2 == 0] = 0 # Заменяем четные числа нулями
# Теперь array_2d = [[1, 0, 3], [0, 5, 0]]

# Применение функций к массиву
squared = np.square(array_2d) # Возводит каждый элемент в квадрат
logs = np.log(np.abs(array_2d) + 1) # Логарифм от модуля каждого элемента + 1

# Статистические функции по осям
column_means = np.mean(array_2d, axis=0) # Среднее по столбцам
row_sums = np.sum(array_2d, axis=1) # Суммы по строкам

# Пример: конволюция (свертка) — базовая операция в обработке изображений
def convolve2d(image, kernel):
# Предполагаем, что image и kernel – это numpy массивы
output = np.zeros_like(image)
padded = np.pad(image, pad_width=1, mode='constant')

for i in range(image.shape[0]):
for j in range(image.shape[1]):
output[i, j] = np.sum(padded[i:i+3, j:j+3] * kernel)

return output

# Простой фильтр выделения краев
edge_kernel = np.array([[-1, -1, -1],
[-1, 8, -1],
[-1, -1, -1]])

# Применение фильтра к изображению (в реальности используйте scipy.signal.convolve2d)