Массивы в Python: эффективные методы обработки данных и операций

# Создание списка
my_list = [1, 2, 3, 4, 5]
mixed_list = [1, "hello", 3.14, True]

# Доступ к элементам
print(my_list[0]) # 1
print(my_list[-1]) # 5

import numpy as np

# Создание NumPy массива
arr = np.array([1, 2, 3, 4, 5])
print(arr) # [1 2 3 4 5]

# Математические операции выполняются поэлементно
print(arr * 2) # [2 4 6 8 10]

# Списки
empty_list = []
list_from_range = list(range(10)) # [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
list_comprehension = [x**2 for x in range(5)] # [0, 1, 4, 9, 16]

# NumPy массивы
import numpy as np
zeros_array = np.zeros(5) # [0\. 0. 0. 0. 0.]
ones_array = np.ones((2, 3)) # 2x3 массив из единиц
linspace = np.linspace(0, 1, 5) # [0\. 0.25 0.5 0.75 1. ]

my_list = [10, 20, 30, 40, 50]

# Доступ к элементам
print(my_list[0]) # 10
print(my_list[-1]) # 50

# Изменение элементов
my_list[2] = 35
print(my_list) # [10, 20, 35, 40, 50]

# Срезы (slices)
print(my_list[1:4]) # [20, 35, 40]
print(my_list[::2]) # [10, 35, 50] – с шагом 2

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

# Добавление элементов
fruits.append('date') # ['apple', 'banana', 'cherry', 'date']
fruits.insert(1, 'blueberry') # ['apple', 'blueberry', 'banana', 'cherry', 'date']
fruits.extend(['fig', 'grape']) # ['apple', 'blueberry', 'banana', 'cherry', 'date', 'fig', 'grape']

# Удаление элементов
removed = fruits.pop() # удаляет и возвращает последний элемент
fruits.remove('banana') # удаляет первое вхождение 'banana'
del fruits[0] # удаляет элемент по индексу

# Поиск и сортировка
print('cherry' in fruits) # True
fruits.sort() # сортировка на месте
sorted_fruits = sorted(fruits) # новый отсортированный список

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

# Простой цикл
for num in numbers:
print(num)

# Цикл с индексами
for i, num in enumerate(numbers):
print(f"Index {i}: {num}")

# Функциональный подход
squared = list(map(lambda x: x**2, numbers))
evens = list(filter(lambda x: x % 2 == 0, numbers))

import numpy as np

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

# Доступ к элементам
print(matrix[1, 2]) # 6 (элемент во второй строке, третьем столбце)

# Срезы в многомерных массивах
print(matrix[:, 1]) # [2, 5, 8] (второй столбец)
print(matrix[1:, :2]) # [[4, 5], [7, 8]] (подматрица)

# Традиционный подход
squares = []
for i in range(10):
squares.append(i**2)

# Списковое включение (быстрее и лаконичнее)
squares = [i**2 for i in range(10)]

# С условием
even_squares = [i**2 for i in range(10) if i % 2 == 0]

import numpy as np
import time

# Неэффективно: использование циклов
def slow_sum_of_squares(n):
total = 0
for i in range(n):
total += i**2
return total

# Эффективно: векторизованный подход
def fast_sum_of_squares(n):
return np.sum(np.arange(n)**2)

# Сравнение производительности
n = 10000000
start = time.time()
result1 = slow_sum_of_squares(n)
end = time.time()
print(f"Цикл: {end – start:.4f} сек")

start = time.time()
result2 = fast_sum_of_squares(n)
end = time.time()
print(f"Векторизация: {end – start:.4f} сек")

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

# map применяет функцию к каждому элементу
squared = list(map(lambda x: x**2, numbers)) # [1, 4, 9, 16, 25]

# filter отбирает элементы по условию
evens = list(filter(lambda x: x % 2 == 0, numbers)) # [2, 4]

# reduce применяет бинарную операцию к элементам последовательно
from functools import reduce
product = reduce(lambda x, y: x * y, numbers) # 120 (1*2*3*4*5)

import pandas as pd

# Создание DataFrame
data = {
'Name': ['John', 'Anna', 'Peter', 'Linda'],
'Age': [28, 34, 29, 42],
'City': ['New York', 'Paris', 'Berlin', 'London']
}
df = pd.DataFrame(data)

# Группировка и агрегация
age_stats = df.groupby('City')['Age'].agg(['mean', 'min', 'max'])

import numpy as np

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

# Булева индексация
mask = arr > 5
print(arr[mask]) # [6 7 8 9]

# Индексация массивами
row_indices = np.array([0, 2])
col_indices = np.array([1, 2])
print(arr[row_indices, col_indices]) # [2 9]

# Фантомное индексирование (fancy indexing)
print(arr[[0, 2], :][:, [0, 2]]) # [[1 3], [7 9]]

# Преобразование формы
arr = np.arange(12)
reshaped = arr.reshape(3, 4) # 3x4 матрица
print(reshaped)

# Транспонирование
transposed = reshaped.T # 4x3 матрица
print(transposed)

# Объединение массивов
arr1 = np.array([1, 2, 3])
arr2 = np.array([4, 5, 6])
stacked_v = np.vstack((arr1, arr2)) # вертикальное объединение
stacked_h = np.hstack((arr1, arr2)) # горизонтальное объединение

# Разделение массивов
split_arrays = np.split(np.arange(9), 3) # разделение на 3 равные части

# Операции без циклов
x = np.array([1, 2, 3, 4])
y = np.array([5, 6, 7, 8])

# Арифметические операции
print(x + y) # [6 8 10 12]
print(x * y) # [5 12 21 32]

# Математические функции
print(np.sin(x)) # тригонометрические функции
print(np.exp(x)) # экспоненциальная функция

# Статистические операции
print(np.mean(x)) # среднее значение
print(np.std(y)) # стандартное отклонение
print(np.corrcoef(x, y)) # корреляция

# Генераторы для обработки больших массивов
def process_chunks(data, chunk_size=1000):
"""Обрабатывает большой массив по частям"""
n = len(data)
for i in range(0, n, chunk_size):
chunk = data[i:i+chunk_size]
# Обработка части массива
yield process_function(chunk)

# Использование memmap для работы с файлами без загрузки в память
filename = "large_array.dat"
fp = np.memmap(filename, dtype='float32', mode='w+', shape=(10000, 10000))

# Заполняем массив данными частями
for i in range(10):
fp[i*1000:(i+1)*1000] = some_data_function(i)

# Изменения сохраняются на диске
fp.flush()

# Пример оптимизации с Numba
from numba import jit

@jit(nopython=True)
def fast_function(x):
"""Функция, оптимизированная с помощью JIT-компиляции"""
result = np.zeros_like(x)
for i in range(len(x)):
result[i] = x[i] * math.sin(x[i])
return result

# Результат будет выполняться со скоростью, близкой к C

import numpy as np

# Сгенерируем данные о температуре за год
np.random.seed(42) # для воспроизводимости
temperatures = np.random.normal(15, 10, 365) # среднее 15, ст. откл. 10

# Находим среднюю температуру
avg_temp = np.mean(temperatures)
print(f"Средняя температура: {avg_temp:.2f}°C")

# Создаем маску для температур выше среднего
above_avg = temperatures > avg_temp

# Находим начала и концы периодов
diff = np.diff(np.concatenate(([0], above_avg.astype(int), [0])))
starts = np.where(diff == 1)[0]
ends = np.where(diff == -1)[0]

# Находим длительности периодов
durations = ends – starts
max_duration_idx = np.argmax(durations)

print(f"Самый длинный период: с {starts[max_duration_idx]} по {ends[max_duration_idx] – 1} дня")
print(f"Длительность: {durations[max_duration_idx]} дней")
print(f"Температуры в этот период: {temperatures[starts[max_duration_idx]:ends[max_duration_idx]]}")

import numpy as np
import matplotlib.pyplot as plt

# Создадим временной ряд с несколькими аномалиями
n_points = 1000
time_series = np.sin(np.linspace(0, 10 * np.pi, n_points)) + 0.5 * np.random.randn(n_points)

# Добавим несколько выбросов
outlier_indices = np.random.choice(range(n_points), 10, replace=False)
time_series[outlier_indices] += np.random.choice([-1, 1], 10) * np.random.uniform(3, 5, 10)

# Алгоритм обнаружения аномалий на основе Z-score
def detect_outliers_zscore(data, threshold=3):
mean = np.mean(data)
std = np.std(data)
z_scores = (data – mean) / std
return np.abs(z_scores) > threshold

# Обнаруживаем выбросы
outliers = detect_outliers_zscore(time_series)
outlier_values = time_series[outliers]
outlier_indices = np.where(outliers)[0]

print(f"Обнаружено {len(outlier_indices)} выбросов")
print(f"Индексы выбросов: {outlier_indices}")

import numpy as np
from PIL import Image

# Функция для применения размытия к изображению
def apply_blur(image_array, kernel_size=3):
"""Применяет размытие к изображению с помощью свертки"""
height, width, channels = image_array.shape
result = np.zeros_like(image_array, dtype=np.float32)

# Создаем ядро свертки (простое усреднение)
kernel = np.ones((kernel_size, kernel_size)) / (kernel_size ** 2)

# Применяем свертку для каждого канала
for c in range(channels):
for i in range(height – kernel_size + 1):
for j in range(width – kernel_size + 1):
window = image_array[i:i+kernel_size, j:j+kernel_size, c]
result[i+kernel_size//2, j+kernel_size//2, c] = np.sum(window * kernel)

return np.clip(result, 0, 255).astype(np.uint8)

# Пример использования:
# image = np.array(Image.open('image.jpg'))
# blurred_image = apply_blur(image, kernel_size=5)
# Image.fromarray(blurred_image).save('blurred_image.jpg')

import numpy as np
from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.naive_bayes import MultinomialNB
from sklearn.metrics import accuracy_score

# Пример текстов для классификации
texts = [
"Python is a great programming language",
"Machine learning is fascinating",
"Data science uses both statistics and programming",
"Python is widely used in data science and machine learning",
"Statistics is an important part of data analysis"
]

labels = np.array([0, 1, 1, 0, 1]) # 0 – программирование, 1 – статистика/данные

# Создаем TF-IDF представление текстов
vectorizer = TfidfVectorizer()
X = vectorizer.fit_transform(texts)

# Разделяем на обучающую и тестовую выборки
train_indices = [0, 1, 2]
test_indices = [3, 4]

X_train = X[train_indices]
y_train = labels[train_indices]
X_test = X[test_indices]
y_test = labels[test_indices]

# Обучаем классификатор
clf = MultinomialNB()
clf.fit(X_train, y_train)

# Предсказываем метки для тестовой выборки
y_pred = clf.predict(X_test)

print(f"Предсказанные метки: {y_pred}")
print(f"Истинные метки: {y_test}")
print(f"Точность: {accuracy_score(y_test, y_pred):.2f}")

import numpy as np

# Решаем систему линейных уравнений:
# 2x + y – z = 8
# -3x – y + 2z = -11
# -2x + y + 2z = -3

# Матрица коэффициентов
A = np.array([
[2, 1, -1],
[-3, -1, 2],
[-2, 1, 2]
])

# Вектор правых частей
b = np.array([8, -11, -3])

# Решение с помощью numpy.linalg.solve
solution = np.linalg.solve(A, b)

print(f"Решение системы: x = {solution[0]}, y = {solution[1]}, z = {solution[2]}")

# Проверка решения
check = np.allclose(np.dot(A, solution), b)
print(f"Проверка: {'Верно' if check else 'Ошибка'}")