Kodduu Python
1.08K subscribers
311 photos
28 videos
186 links
Научись программировать на Python на интересных примерах

Самый быстрый курс https://stepik.org/a/187914
Самый нескучный курс https://stepik.org/a/185238

Во вопросам сотрудничества: @AlexErf
Download Telegram
Пример кода, который моделирует взаимодействие материи и антивещества. В нем мы создадим простую симуляцию, где частицы вещества и антивещества движутся в пространстве и аннигилируют при столкновении. Этот пример визуализирует, как происходит аннигиляция, что является ключевой концепцией антивещества.


import numpy as np
import matplotlib.pyplot as plt
import matplotlib.animation as animation

# Параметры симуляции
num_particles = 50 # Число частиц вещества и антивещества
box_size = 10 # Размер области

# Начальные позиции и направления для частиц вещества и антивещества
positions_matter = np.random.uniform(0, box_size, (num_particles, 2))
positions_antimatter = np.random.uniform(0, box_size, (num_particles, 2))
velocities_matter = np.random.uniform(-1, 1, (num_particles, 2))
velocities_antimatter = np.random.uniform(-1, 1, (num_particles, 2))

# Создание графика
fig, ax = plt.subplots(figsize=(6, 6))
ax.set_xlim(0, box_size)
ax.set_ylim(0, box_size)

matter_plot = ax.scatter(positions_matter[:, 0], positions_matter[:, 1], color='blue', label='Matter')
antimatter_plot = ax.scatter(positions_antimatter[:, 0], positions_antimatter[:, 1], color='red', label='Antimatter')
plt.legend()

# Функция обновления для анимации
def update(frame):
global positions_matter, positions_antimatter

# Обновляем позиции частиц
positions_matter += velocities_matter
positions_antimatter += velocities_antimatter

# Отражение от стенок
for pos, vel in [(positions_matter, velocities_matter), (positions_antimatter, velocities_antimatter)]:
vel[pos < 0] *= -1
vel[pos > box_size] *= -1

# Проверка на столкновения и аннигиляцию
for i, pos_m in enumerate(positions_matter):
distances = np.linalg.norm(positions_antimatter - pos_m, axis=1)
collision_indices = np.where(distances < 0.5)[0] # Радиус аннигиляции

# Удаление столкнувшихся частиц
if len(collision_indices) > 0:
positions_matter[i] = np.nan # Устанавливаем NaN для "аннигилированных" частиц
positions_antimatter[collision_indices] = np.nan

# Обновляем отображение частиц
matter_plot.set_offsets(positions_matter)
antimatter_plot.set_offsets(positions_antimatter)

return matter_plot, antimatter_plot

# Запуск анимации
ani = animation.FuncAnimation(fig, update, frames=200, interval=50, blit=True)
plt.show()


### Объяснение:

1. Начальные позиции и скорости: Создаются случайные позиции и направления для частиц материи и антивещества в заданной области.
2. Отражение от стенок: Частицы отскакивают от стенок, если достигают границы области.
3. Проверка на аннигиляцию: Когда частица материи находится на определенном расстоянии от частицы антивещества, обе частицы "аннигилируют" — их позиции заменяются на NaN, чтобы их не отображать.
4. Анимация: FuncAnimation обновляет позиции и проверяет столкновения, создавая визуализацию аннигиляции.

### Ключевая идея:
Когда частица материи и антивещества сталкиваются, они аннигилируют, исчезая из пространства симуляции, что демонстрирует основную концепцию антивещества.

Подпишись 👉🏻 @KodduuPython 🤖
👍2
This media is not supported in your browser
VIEW IN TELEGRAM
Анигиляция вещества и антивещества. Код выше 👆👆👆

Подпишись 👉🏻 @KodduuPython 🤖
Жадный алгоритм (Greedy Algorithm)
Жадный алгоритм — это метод решения оптимизационных задач, который на каждом шаге принимает локально оптимальное решение, надеясь, что оно приведет к глобально оптимальному результату. Он работает по принципу "бери, что лучше прямо сейчас", без учета возможных последствий в будущем.

Для решения задачи оптимального выбора стратегии начисления или списания баллов при каждой покупке можно использовать жадный алгоритм. Вот пример реализации на Python:


def optimize_cashback_strategy(receipts, balance):
"""
Оптимизировать стратегию начисления/списания баллов для максимизации кэшбэка и минимизации расходов.

:param receipts: Список чеков (стоимость каждой покупки).
:param balance: Начальный баланс баллов.
:return: Список стратегий ('add' для начисления, 'redeem' для списания), итоговый баланс и суммарный кэшбэк.
"""
strategies = [] # Список стратегий
total_cashback = 0 # Суммарный кэшбэк

for receipt in receipts:
cashback = receipt * 0.10 # 10% кэшбэк от стоимости покупки

if balance >= receipt:
# Если баллов достаточно, выгоднее списать
strategies.append('redeem')
balance -= receipt # Списываем баллы
else:
# Если баллов недостаточно, начисляем кэшбэк
strategies.append('add')
total_cashback += cashback
balance += cashback # Начисляем баллы в баланс

return strategies, balance, total_cashback


# Пример данных
receipts = [200, 150, 300, 100, 250, 50, 400, 120, 80, 60] # Стоимость каждой покупки
initial_balance = 500 # Начальный баланс баллов

# Оптимизация стратегии
strategies, final_balance, total_cashback = optimize_cashback_strategy(receipts, initial_balance)

# Вывод результатов
print("Чеки:", receipts)
print("Начальный баланс:", initial_balance)
print("Стратегии:", strategies)
print("Итоговый баланс:", final_balance)
print("Суммарный кэшбэк:", total_cashback)


### Пояснение алгоритма:
1. Баллы списываются только если текущего баланса хватает на покрытие стоимости чека. Это позволяет минимизировать расходы.
2. Кэшбэк начисляется, если недостаточно баллов для списания. Начисленные баллы добавляются к балансу.
3. В каждом шаге выбирается наиболее выгодный вариант: либо списание баллов, либо начисление кэшбэка.

### Пример работы:
Для списка чеков [200, 150, 300, 100, 250, 50, 400, 120, 80, 60] и начального баланса 500 программа подберет стратегию, которая максимизирует итоговый кэшбэк и минимизирует расходы.

Подпишись 👉🏻 @KodduuPython 🤖
👍3
### Задача о рюкзаке (Knapsack Problem)

Задача:
У вас есть рюкзак фиксированного объема W, и множество предметов, каждый из которых имеет вес w_i и ценность v_i. Нужно определить, какие предметы положить в рюкзак, чтобы максимизировать общую ценность, не превышая объема W.

---

### Жадный алгоритм для задачи о рюкзаке (Fractional Knapsack)

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

Принцип работы:
1. Считаем "ценность на единицу веса" для каждого предмета ( v_i / w_i ).
2. Сортируем предметы по убыванию этой ценности.
3. Идем по отсортированным предметам, добавляя их в рюкзак, пока есть место:
- Если предмет помещается целиком, кладем его.
- Если предмет не помещается, берем только часть, которая влезет.

---

### Код для жадного алгоритма (дробный рюкзак):


def fractional_knapsack(items, max_weight):
"""
Жадный алгоритм для задачи о дробном рюкзаке.

:param items: Список предметов в формате [(ценность, вес), ...].
:param max_weight: Максимальный вес рюкзака.
:return: Максимальная ценность и список взятых предметов (включая доли).
"""
# Считаем ценность на единицу веса для каждого предмета и сортируем по убыванию
items = sorted(items, key=lambda x: x[0] / x[1], reverse=True)

total_value = 0 # Суммарная ценность
taken_items = [] # Список взятых предметов (включая доли)

for value, weight in items:
if max_weight == 0: # Если рюкзак заполнен
break

if weight <= max_weight:
# Берем предмет целиком
total_value += value
max_weight -= weight
taken_items.append((value, weight, 1)) # 1 означает "взято целиком"
else:
# Берем часть предмета
fraction = max_weight / weight
total_value += value * fraction
taken_items.append((value, weight, fraction))
max_weight = 0 # Рюкзак заполнен

return total_value, taken_items


# Пример данных: (ценность, вес)
items = [
(60, 10), # Ценность 60, вес 10
(100, 20), # Ценность 100, вес 20
(120, 30) # Ценность 120, вес 30
]
max_weight = 50 # Максимальный вес рюкзака

# Решение задачи
max_value, selected_items = fractional_knapsack(items, max_weight)

# Вывод результатов
print("Максимальная ценность:", max_value)
print("Выбранные предметы (ценность, вес, доля):")
for item in selected_items:
print(item)


---

### Пример вывода:

Максимальная ценность: 240.0
Выбранные предметы (ценность, вес, доля):
(100, 20, 1)
(120, 30, 1)
(60, 10, 0.6666666666666666)


---

### Динамическое программирование для задачи целого рюкзака

Если дробить предметы нельзя, применяют метод динамического программирования.


def knapsack_dp(items, max_weight):
"""
Задача о рюкзаке для целых предметов с использованием динамического программирования.

:param items: Список предметов в формате [(ценность, вес), ...].
:param max_weight: Максимальный вес рюкзака.
:return: Максимальная ценность.
"""
n = len(items)
dp = [[0] * (max_weight + 1) for _ in range(n + 1)]

for i in range(1, n + 1):
value, weight = items[i - 1]
for w in range(max_weight + 1):
if weight <= w:
# Либо берем предмет, либо не берем
dp[i][w] = max(dp[i - 1][w], dp[i - 1][w - weight] + value)
else:
dp[i][w] = dp[i - 1][w]

return dp[n][max_weight]


# Пример данных
items = [
(60, 10), # Ценность 60, вес 10
(100, 20), # Ценность 100, вес 20
(120, 30) # Ценность 120, вес 30
]
max_weight = 50 # Максимальный вес рюкзака

# Решение задачи
max_value = knapsack_dp(items, max_weight)

# Вывод результатов
print("Максимальная ценность:", max_value)


---

### Пример вывода для целого рюкзака:

Максимальная ценность: 220


Подпишись 👉🏻 @KodduuPython 🤖
👍42
Проанализировали сотни собесов по Python. Начали паковать курс "Топ 100 вопросов с реальных собеседований по Python (шпаргалка)" 👍

Странно - но есть вопросы которые прямо в топе, а есть не менее интересные, которые прямо редко задают 🤷 Перед собесом по идее надо учить, те что часто задают 🧐 Но и знать что-то из редких, может быть тоже критично 🤨 На картинке, то что в топе 🤷

Подпишись 👉🏻 @KodduuPython 🤖
31👍1
### Жадный алгоритм Хаффмана (Huffman Coding)

Алгоритм Хаффмана используется для эффективного сжатия данных. Он создает префиксное кодирование, где ни один код не является префиксом другого, что гарантирует декодируемость. Этот метод часто применяется в сжатии данных, таких как ZIP, GZIP и JPEG.

---

### Основные этапы алгоритма Хаффмана:

1. Подготовка данных: Извлечь символы и их частоты из исходных данных.
2. Создание приоритетной очереди: Построить очередь (обычно в виде мин-кучи), где каждый символ представляет собой узел, а его частота определяет приоритет.
3. Построение дерева Хаффмана:
- На каждом шаге извлекаются два узла с наименьшими частотами.
- Создается новый объединенный узел, чья частота равна сумме частот выбранных узлов.
- Новый узел добавляется обратно в очередь.
- Повторяется до тех пор, пока не останется один узел (корень дерева).
4. Назначение кодов:
- Обход дерева (обычно рекурсивный) назначает каждому символу код, основываясь на пути: левый узел = 0, правый узел = 1.

---

### Реализация на Python


import heapq
from collections import Counter, namedtuple

# Узел дерева
class HuffmanNode(namedtuple("HuffmanNode", ["char", "freq", "left", "right"])):
def __lt__(self, other):
return self.freq < other.freq

def build_huffman_tree(frequencies):
# Создаем очередь с приоритетом на основе частот
heap = [HuffmanNode(char, freq, None, None) for char, freq in frequencies.items()]
heapq.heapify(heap)

# Построение дерева
while len(heap) > 1:
# Извлекаем два узла с минимальной частотой
left = heapq.heappop(heap)
right = heapq.heappop(heap)

# Создаем объединенный узел
merged = HuffmanNode(None, left.freq + right.freq, left, right)
heapq.heappush(heap, merged)

# Корень дерева
return heap[0]

def assign_codes(node, prefix="", codebook=None):
if codebook is None:
codebook = {}
if node.char is not None:
# Если это листовой узел, сохраняем код
codebook[node.char] = prefix
else:
# Рекурсивно обходим дерево
assign_codes(node.left, prefix + "0", codebook)
assign_codes(node.right, prefix + "1", codebook)
return codebook

def huffman_encoding(data):
# Подсчет частот символов
frequencies = Counter(data)

# Построение дерева
root = build_huffman_tree(frequencies)

# Назначение кодов
codebook = assign_codes(root)

# Кодирование данных
encoded_data = "".join(codebook[char] for char in data)
return encoded_data, codebook

def huffman_decoding(encoded_data, codebook):
# Инвертируем кодовую таблицу
reverse_codebook = {v: k for k, v in codebook.items()}

# Декодирование строки
decoded_data = []
buffer = ""
for bit in encoded_data:
buffer += bit
if buffer in reverse_codebook:
decoded_data.append(reverse_codebook[buffer])
buffer = ""

return "".join(decoded_data)

# Пример использования
data = "huffman coding is fun"
print("Исходные данные:", data)

# Кодирование
encoded_data, codebook = huffman_encoding(data)
print("Закодированные данные:", encoded_data)
print("Кодовая таблица:", codebook)

# Декодирование
decoded_data = huffman_decoding(encoded_data, codebook)
print("Декодированные данные:", decoded_data)


---

### Пример вывода:

Исходные данные: huffman coding is fun
Закодированные данные: 110101001111100010010011101111100011011011001110110010
Кодовая таблица: {'h': '1101', 'u': '1100', 'f': '100', 'm': '101', 'a': '1111', 'n': '1110', ' ': '010', 'c': '0110', 'o': '0111', 'd': '000', 'i': '001', 'g': '1011', 's': '011'}
Декодированные данные: huffman coding is fun


---

### Объяснение вывода:
1. Частоты символов определяют длину их кодов: более частые символы имеют более короткие коды.
2. Алгоритм успешно сжимает данные, удаляя избыточность, но оставляя возможность точного восстановления.

Подпишись 👉🏻 @KodduuPython 🤖
👍1
### Алгоритмы маршрутизации

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

---

### 1. Алгоритм Дейкстры
- Идея: Найти самый короткий путь от одной точки ко всем другим точкам.
- Как работает:
1. Начинаем с точки (например, дома) и отмечаем, что расстояние до нее — 0.
2. Для всех соседних точек рассчитываем их расстояние от дома.
3. Идем в ближайшую точку, фиксируем расстояние до нее и продолжаем проверять ее соседей.
4. Повторяем процесс, пока не пройдем все точки.
- Пример:
- Вы хотите найти самый короткий путь из дома до магазина.
- Вы сначала проверяете все ближайшие улицы, потом переходите к более дальним, выбирая на каждом шаге самую короткую улицу.

Код на Python:

import heapq

def dijkstra(graph, start):
distances = {node: float('inf') for node in graph} # Все расстояния бесконечны
distances[start] = 0 # Расстояние до начальной точки — 0
priority_queue = [(0, start)] # Очередь для обработки вершин

while priority_queue:
current_distance, current_node = heapq.heappop(priority_queue)

for neighbor, weight in graph[current_node]:
distance = current_distance + weight
if distance < distances[neighbor]:
distances[neighbor] = distance
heapq.heappush(priority_queue, (distance, neighbor))

return distances

# Пример графа
graph = {
'A': [('B', 1), ('C', 4)],
'B': [('A', 1), ('C', 2), ('D', 6)],
'C': [('A', 4), ('B', 2), ('D', 3)],
'D': [('B', 6), ('C', 3)],
}

print(dijkstra(graph, 'A'))


---

### 2. Алгоритм Беллмана-Форда
- Идея: Найти самый короткий путь, даже если есть улицы с "негативными" условиями (например, короткие, но опасные пути).
- Как работает:
1. Начинаем с дома и отмечаем, что расстояние до него — 0.
2. Проходим через каждую улицу, пытаясь улучшить (сделать короче) расстояния до других точек.
3. Повторяем процесс несколько раз, чтобы убедиться, что не осталось непросчитанных улучшений.
- Пример:
- Представьте, что у вас есть маршрут, где некоторые улицы сокращают общее время (например, за счет срезов или сокращения светофоров).
- Беллман-Форд учитывает такие "улучшенные" пути.

Код на Python:

def bellman_ford(graph, start):
distances = {node: float('inf') for node in {u for u, _, _ in graph}.union({v for _, v, _ in graph})}
distances[start] = 0

for _ in range(len(distances) - 1):
for u, v, weight in graph:
if distances[u] + weight < distances[v]:
distances[v] = distances[u] + weight

return distances

# Пример графа
graph = [
('A', 'B', 1),
('B', 'C', 2),
('A', 'C', 4),
('C', 'D', 3),
('D', 'B', -6), # "Негативный" путь
]

print(bellman_ford(graph, 'A'))


---

### 3. Алгоритм Флойда-Уоршалла
- Идея: Найти самые короткие пути между всеми парами точек.
- Как работает:
1. Создаем таблицу, где записаны все известные расстояния между точками.
2. Постепенно проверяем, можно ли улучшить расстояние через промежуточные точки.
3. Обновляем таблицу после каждой проверки.
- Пример:
- У вас есть несколько маршрутов, и вы хотите знать, как быстрее добраться из любой точки в любую другую.
- Алгоритм Флойда-Уоршалла строит карту с минимальными расстояниями между всеми точками.

Код на Python:

def floyd_warshall(graph):
n = len(graph)
dist = [[float('inf')] * n for _ in range(n)]

for i in range(n):
dist[i][i] = 0
for j in range(n):
if graph[i][j] is not None:
dist[i][j] = graph[i][j]

for k in range(n):
for i in range(n):
for j in range(n):
dist[i][j] = min(dist[i][j], dist[i][k] + dist[k][j])

return dist

graph = [
[0, 3, None, None],
[None, 0, 1, None],
[None, None, 0, 7],
[2, None, None, 0],
]

result = floyd_warshall(graph)
for row in result:
print(row)


Подпишись 👉🏻 @KodduuPython 🤖
Похоже самые успешные наши курсы - это все наши курсы вместе 😎

Программа кусрсов FullStack Developer and Data Scientist (Python+JS+Data+CookBook) вышла в топ ⚡️⚡️⚡️

Большая Stepik распродажа продолжается до 9 декабря 👍👍👍

Программа курсов состоит из:

👉 Python: самый быстрый курс

👉 JavaScript: самый быстрый курс

👉 Python Data Science: самый быстрый курс

👉 Python в нескучных примерах (50) aka CookBook

Подпишись 👉🏻 @KodduuPython 🤖
🔥🔥🔥 Топ посты за 3 месяца 🤖🤖🤖

👉 Modin — это библиотека, разработанная для увеличения производительности операций с данными в Pandas

👉 Vaex — это библиотека Python для быстрого чтения, записи и анализа очень больших наборов данных прямо из файловой системы

👉 Hadoop - это распределенная система хранения и обработки больших объемов данных

👉 PyTorch с Wine Dataset (Винный набор данных)

👉 Python с использованием библиотеки Bokeh для визуализации данных из базы данных SQLite

👉 Демо использования декораторов, контекстных менеджеров, асинхронного программирования и датаклассов

👉 Демо использования библиотеки Polyglot для обработки естественного языка

👉 Octoparse — это мощный инструмент для веб-скрейпинга с графическим интерфейсом

👉 Создадим интересную программу на Python, которая реализует генетический алгоритм для решения задачи оптимизации

Подпишись 👉🏻 @KodduuPython 🤖
👍4
### Алгоритмы планирования задач

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

---

### Ключевые цели планирования
1. Минимизация времени выполнения:
- Сократить общее время выполнения задач (makespan).
2. Эффективное использование ресурсов:
- Распределение задач по ресурсам (например, процессорам, работникам).
3. Учет приоритетов:
- Выполнение более важных задач раньше.
4. Соблюдение дедлайнов:
- Удовлетворение временных ограничений.

---

### Основные типы алгоритмов планирования

#### 1. Планирование по приоритету (Priority Scheduling)
- Идея: Каждой задаче присваивается приоритет, и задачи с более высоким приоритетом выполняются раньше.
- Применение: Используется в операционных системах для выполнения пользовательских или системных процессов.

Код на Python:

def priority_scheduling(tasks):
"""
Планирование задач по приоритету.
:param tasks: Список задач [(имя, приоритет)].
:return: Упорядоченный список задач.
"""
# Сортировка задач по приоритету (чем меньше число, тем выше приоритет)
tasks = sorted(tasks, key=lambda x: x[1])
return tasks

# Пример задач
tasks = [("Task1", 3), ("Task2", 1), ("Task3", 2)]
result = priority_scheduling(tasks)
print("Упорядоченные задачи:", result)


Пример вывода:

Упорядоченные задачи: [('Task2', 1), ('Task3', 2), ('Task1', 3)]


---

#### 2. Алгоритм "Сначала короткие задачи" (Shortest Job First, SJF)
- Идея: Сначала выполняются задачи с наименьшим временем выполнения.
- Применение: Уменьшение времени ожидания для задач.
- Ограничение: Требует предварительного знания времени выполнения задач.

Код на Python:

def sjf_scheduling(tasks):
"""
Планирование задач по времени выполнения.
:param tasks: Список задач [(имя, время выполнения)].
:return: Упорядоченный список задач.
"""
tasks = sorted(tasks, key=lambda x: x[1])
return tasks

# Пример задач
tasks = [("Task1", 6), ("Task2", 2), ("Task3", 8), ("Task4", 3)]
result = sjf_scheduling(tasks)
print("Упорядоченные задачи:", result)


Пример вывода:

Упорядоченные задачи: [('Task2', 2), ('Task4', 3), ('Task1', 6), ('Task3', 8)]


---

#### 3. Планирование с учетом дедлайнов (Deadline Scheduling)
- Идея: Выполнять задачи так, чтобы минимизировать штрафы за пропуск дедлайнов.
- Пример: Задачи должны быть завершены до определенного времени.

Код на Python:

def deadline_scheduling(tasks, max_time):
"""
Планирование задач с учетом дедлайнов.
:param tasks: Список задач [(имя, дедлайн, прибыль)].
:param max_time: Общее доступное время.
:return: Список выполненных задач.
"""
# Сортировка по прибыли в порядке убывания
tasks = sorted(tasks, key=lambda x: x[2], reverse=True)

schedule = [None] * max_time # Таймслот для каждой задачи
total_profit = 0

for task in tasks:
name, deadline, profit = task
for t in range(min(deadline - 1, max_time - 1), -1, -1):
if schedule[t] is None:
schedule[t] = name
total_profit += profit
break

return schedule, total_profit

# Пример задач
tasks = [("Task1", 4, 70), ("Task2", 1, 80), ("Task3", 1, 30), ("Task4", 2, 40)]
result, profit = deadline_scheduling(tasks, 4)
print("План выполнения:", result)
print("Общая прибыль:", profit)


Пример вывода:

План выполнения: ['Task2', 'Task4', 'Task1', None]
Общая прибыль: 190


Подпишись 👉🏻 @KodduuPython 🤖
🆒2👍1
Для демонстрации различий между Python и Elixir, давайте рассмотрим несколько примеров, сравнивающих синтаксис и ключевые особенности этих языков. Мы затронем основные аспекты, такие как обработка списков, функции высшего порядка и многопоточность.

---

### 1. Обработка списков (List Comprehension vs. Enum.map)

#### Python:

# Генерация списка квадратов чисел
numbers = [1, 2, 3, 4, 5]
squares = [x ** 2 for x in numbers]
print(squares) # [1, 4, 9, 16, 25]


#### Elixir:

# Генерация списка квадратов чисел
numbers = [1, 2, 3, 4, 5]
squares = Enum.map(numbers, fn x -> x * x end)
IO.inspect(squares) # [1, 4, 9, 16, 25]


---

### 2. Функции высшего порядка

#### Python:

# Функция высшего порядка с передачей функции
def apply_function(data, func):
return [func(x) for x in data]

result = apply_function([1, 2, 3], lambda x: x + 10)
print(result) # [11, 12, 13]


#### Elixir:

# Функция высшего порядка с передачей функции
defmodule HigherOrder do
def apply_function(data, func) do
Enum.map(data, func)
end
end

result = HigherOrder.apply_function([1, 2, 3], fn x -> x + 10 end)
IO.inspect(result) # [11, 12, 13]


---

### 3. Многопоточность

#### Python (с использованием `threading`):

import threading

def print_numbers():
for i in range(1, 6):
print(f"Thread: {i}")

# Создаем и запускаем поток
thread = threading.Thread(target=print_numbers)
thread.start()
thread.join()


#### Elixir (встроенная многопоточность):

# Спавн и выполнение процесса
spawn(fn ->
Enum.each(1..5, fn i -> IO.puts("Process: #{i}") end)
end)


---

### 4. Распределенные вычисления

#### Python (требуется дополнительная библиотека, например, multiprocessing или `asyncio`):

from multiprocessing import Pool

def square(x):
return x ** 2

if __name__ == "__main__":
with Pool(4) as pool:
result = pool.map(square, [1, 2, 3, 4, 5])
print(result) # [1, 4, 9, 16, 25]


#### Elixir (распределенные вычисления встроены в язык):

# Распределенные вычисления с использованием Task.async
tasks = Enum.map([1, 2, 3, 4, 5], fn x ->
Task.async(fn -> x * x end)
end)

results = Enum.map(tasks, &Task.await/1)
IO.inspect(results) # [1, 4, 9, 16, 25]


---

### Основные отличия:

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

2. Многопоточность и распределенные системы: Elixir предлагает встроенные возможности для многопоточности и распределенных вычислений благодаря платформе Erlang. В Python для этого часто требуется использование библиотек.

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

Подпишись 👉🏻 @KodduuPython 🤖
2
Сравним Python и другой функциональный язык — Haskell. Haskell — это язык, ориентированный на чисто функциональное программирование, где неизменяемость данных, ленивые вычисления и строгая типизация являются ключевыми концепциями.

---

### 1. Обработка списков (List Comprehension)

#### Python:

# Генерация списка квадратов чисел
numbers = [1, 2, 3, 4, 5]
squares = [x ** 2 for x in numbers]
print(squares) # [1, 4, 9, 16, 25]


#### Haskell:

-- Генерация списка квадратов чисел
numbers = [1, 2, 3, 4, 5]
squares = [x ^ 2 | x <- numbers]
main = print squares -- [1, 4, 9, 16, 25]


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

---

### 2. Функции высшего порядка

#### Python:

# Пример применения функции к каждому элементу списка
def apply_function(data, func):
return [func(x) for x in data]

result = apply_function([1, 2, 3], lambda x: x + 10)
print(result) # [11, 12, 13]


#### Haskell:

-- Пример применения функции к каждому элементу списка
applyFunction :: [Int] -> (Int -> Int) -> [Int]
applyFunction data func = map func data

main = print $ applyFunction [1, 2, 3] (+ 10) -- [11, 12, 13]


Отличие: В Haskell типы функций строго указаны, а операции, такие как map, встроены в стандартную библиотеку. Кроме того, Haskell автоматически выводит типы, если вы их не указываете.

---

### 3. Рекурсия

#### Python:

# Рекурсивное вычисление факториала
def factorial(n):
if n == 0:
return 1
return n * factorial(n - 1)

print(factorial(5)) # 120


#### Haskell:

-- Рекурсивное вычисление факториала
factorial :: Int -> Int
factorial 0 = 1
factorial n = n * factorial (n - 1)

main = print $ factorial 5 -- 120


Отличие: В Haskell рекурсия является основным инструментом, заменяющим циклы. Также используется сопоставление с образцом (`pattern matching`) для упрощения кода.

---

### 4. Ленивые вычисления

#### Python:

# Пример ленивых вычислений через генераторы
def lazy_numbers():
for i in range(1, 6):
yield i ** 2

for num in lazy_numbers():
print(num) # 1, 4, 9, 16, 25


#### Haskell:

-- Ленивые вычисления встроены в язык
lazyNumbers = [x ^ 2 | x <- [1..5]]

main = print lazyNumbers -- [1, 4, 9, 16, 25]


Отличие: В Haskell ленивые вычисления встроены на уровне языка. Python требует явного использования генераторов.

---

### 5. Многопоточность

#### Python:

import threading

def print_numbers():
for i in range(1, 6):
print(f"Thread: {i}")

thread = threading.Thread(target=print_numbers)
thread.start()
thread.join()


#### Haskell:

import Control.Concurrent

printNumbers :: IO ()
printNumbers = mapM_ (putStrLn . show) [1..5]

main = forkIO printNumbers >> return ()


Отличие: Haskell предоставляет средства для чистой и управляемой многопоточности через библиотеки, такие как Control.Concurrent.

---

### 6. Чистота и изменяемость

- Python: Изменяемые состояния являются стандартом. Можно изменять переменные, списки и другие структуры данных.

x = 5
x += 1
print(x) # 6


- Haskell: Данные неизменяемы по умолчанию.

x = 5
-- x = x + 1 -- Ошибка: Нельзя изменить значение x
y = x + 1
main = print y -- 6


Подпишись 👉🏻 @KodduuPython 🤖
2
Сравним Python и Kotlin — два языка, популярные в разных областях: Python широко используется для веб-разработки, анализа данных и автоматизации, а Kotlin — для разработки мобильных приложений (особенно на Android) и серверных решений.

1. Функции

#### Python:

def greet(name):
return f"Hello, {name}!"

print(greet("Alice")) # Hello, Alice!


#### Kotlin:

fun greet(name: String): String {
return "Hello, $name!"
}

println(greet("Alice")) // Hello, Alice!


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

2. Классы

#### Python:

class Person:
def __init__(self, name, age):
self.name = name
self.age = age

def greet(self):
return f"My name is {self.name} and I am {self.age} years old."

p = Person("Alice", 30)
print(p.greet())


#### Kotlin:

class Person(val name: String, val age: Int) {
fun greet(): String {
return "My name is $name and I am $age years old."
}
}

val p = Person("Alice", 30)
println(p.greet())


Отличие: Kotlin поддерживает конструкторы непосредственно в объявлении класса, что делает код более компактным. Python требует явного определения конструктора через init.

3. Null Safety (Безопасность null)

#### Python:

x = None # Может содержать null (None в Python)

# Операция может вызвать ошибку, если x равен None
if x is not None:
print(x + 5)


#### Kotlin:

var x: Int? = null // Тип Int? может быть null

x?.let {
println(it + 5) // Выполнится только если x не равен null
}


Отличие: В Kotlin типы по умолчанию не допускают значения null. Чтобы переменная могла быть null, нужно явно указать это через ?. Python позволяет None для любого объекта.

4. Обработка исключений

#### Python:

try:
result = 10 / 0
except ZeroDivisionError as e:
print(f"Error: {e}")
finally:
print("Cleanup")


#### Kotlin:

try {
val result = 10 / 0
} catch (e: ArithmeticException) {
println("Error: ${e.message}")
} finally {
println("Cleanup")
}


Отличие: Синтаксис обработки исключений похож, но Kotlin использует фигурные скобки вместо отступов.

5. Асинхронное программирование

#### Python (с использованием `asyncio`):

import asyncio

async def greet():
print("Hello")
await asyncio.sleep(1)
print("World")

asyncio.run(greet())


#### Kotlin (с использованием Coroutines):

import kotlinx.coroutines.*

fun main() = runBlocking {
launch {
println("Hello")
delay(1000L)
println("World")
}
}


Отличие: Kotlin встроенно поддерживает сопрограммы (`coroutines`), которые более естественно интегрированы в язык. В Python используется библиотека asyncio.

6. Лямбда-выражения

#### Python:

add = lambda x, y: x + y
print(add(5, 3)) # 8


#### Kotlin:

val add: (Int, Int) -> Int = { x, y -> x + y }
println(add(5, 3)) // 8


Отличие: Kotlin требует явного указания типов аргументов для функций, тогда как Python определяет типы во время выполнения.

Подпишись 👉🏻 @KodduuPython 🤖
👍4
Доделали важные вопросы, некоторый из них на картинке 😎Каждый вопрос снабжен тестами по теме вопроса 🧐 Хорошая шпаргалка по Python перед собеседованием. Вопросы собраны с 300 собеседований разных компаний в 2023-2024 году.

Подпишись 👉🏻 @KodduuPython 🤖
2
Сравним Python и GoLang (Golang), два языка, которые широко используются, но с разными целями: Python популярен для скриптов, анализа данных, веб-разработки и автоматизации, а Go — для высокопроизводительных серверных приложений, микросервисов и системного программирования.

1. Функции

#### Python:

def greet(name):
return f"Hello, {name}!"

print(greet("Alice")) # Hello, Alice!


#### Go:

package main

import "fmt"

func greet(name string) string {
return fmt.Sprintf("Hello, %s!", name)
}

func main() {
fmt.Println(greet("Alice")) // Hello, Alice!
}


Отличие: В Go типы аргументов и возвращаемого значения обязательны. В Python они не нужны, но могут быть добавлены как аннотации.

2. Циклы

#### Python:

for i in range(5):
print(i)


#### Go:

package main

import "fmt"

func main() {
for i := 0; i < 5; i++ {
fmt.Println(i)
}
}


Отличие: Go имеет только один вид цикла (`for`), который может использоваться как цикл с условием, итерационный цикл или бесконечный цикл.

2. Работа с коллекциями

#### Python:

numbers = [1, 2, 3, 4, 5]
squares = [x ** 2 for x in numbers]
print(squares) # [1, 4, 9, 16, 25]


#### Go:

package main

import "fmt"

func main() {
numbers := []int{1, 2, 3, 4, 5}
squares := make([]int, len(numbers))
for i, x := range numbers {
squares[i] = x * x
}
fmt.Println(squares) // [1, 4, 9, 16, 25]
}


Отличие: Python поддерживает включения списков (list comprehensions), а в Go для работы с коллекциями часто используется цикл for.

3. Многопоточность

#### Python (с использованием `threading`):

import threading

def print_numbers():
for i in range(5):
print(i)

thread = threading.Thread(target=print_numbers)
thread.start()
thread.join()


#### Go:

package main

import (
"fmt"
"sync"
)

func printNumbers(wg *sync.WaitGroup) {
defer wg.Done()
for i := 0; i < 5; i++ {
fmt.Println(i)
}
}

func main() {
var wg sync.WaitGroup
wg.Add(1)
go printNumbers(&wg)
wg.Wait()
}


Отличие: Go имеет встроенную поддержку многопоточности через goroutines и каналы, тогда как Python требует библиотек для работы с потоками.

4. Обработка ошибок

#### Python:

try:
result = 10 / 0
except ZeroDivisionError as e:
print(f"Error: {e}")


#### Go:

package main

import (
"fmt"
"errors"
)

func main() {
result, err := divide(10, 0)
if err != nil {
fmt.Println("Error:", err)
} else {
fmt.Println("Result:", result)
}
}

func divide(a, b int) (int, error) {
if b == 0 {
return 0, errors.New("division by zero")
}
return a / b, nil
}


Отличие: Go не использует исключения, а вместо этого возвращает ошибки как значения. Python полагается на механизм исключений.

5. Асинхронное программирование

#### Python (с использованием `asyncio`):

import asyncio

async def greet():
print("Hello")
await asyncio.sleep(1)
print("World")

asyncio.run(greet())


#### Go:

package main

import (
"fmt"
"time"
)

func greet() {
fmt.Println("Hello")
time.Sleep(1 * time.Second)
fmt.Println("World")
}

func main() {
go greet()
time.Sleep(2 * time.Second)
}


Отличие: Go использует goroutines, которые интегрированы в язык, тогда как Python применяет библиотеку asyncio.

6. Пакеты и модули

#### Python:

# В файле module.py
def greet(name):
return f"Hello, {name}!"

# В main.py
from module import greet
print(greet("Alice"))


#### Go:

// В файле module.go
package module

func Greet(name string) string {
return "Hello, " + name + "!"
}

// В main.go
package main

import (
"fmt"
"module"
)

func main() {
fmt.Println(module.Greet("Alice"))
}


Отличие: Go требует явного указания пакетов, а файлы пакетов находятся в строго организованной структуре.

Подпишись 👉🏻 @KodduuPython 🤖
Смоделировать термоядерный синтез на токамаке полностью невозможно из-за сложности физического процесса и необходимых вычислительных ресурсов. Однако можно написать упрощённую модель для демонстрации основных принципов — удержания плазмы в магнитном поле и её нагрева.

Пример кода для визуализации удержания заряженных частиц в магнитной ловушке:


import numpy as np
import matplotlib.pyplot as plt

# Константы
q = 1.6e-19 # заряд частицы (Кулон)
m = 1.67e-27 # масса частицы (кг, протон)
B = 5.0 # магнитное поле (Тесла)
dt = 1e-9 # временной шаг (с)

# Параметры начального состояния
v_perp = 1e6 # скорость перпендикулярно полю (м/с)
v_parallel = 2e6 # скорость вдоль поля (м/с)
r = 0.0 # начальная позиция в радиальном направлении (м)
z = 0.0 # начальная позиция вдоль поля (м)
theta = 0.0 # угол поворота

# Временные массивы для визуализации
time_steps = 5000
positions = np.zeros((time_steps, 3)) # (r, z, theta)

# Цикл моделирования
for i in range(time_steps):
# Рассчитываем частоту циклотронной частоты
omega_c = q * B / m # циклотронная частота (рад/с)

# Обновляем угол (вращение вокруг оси)
theta += omega_c * dt
if theta > 2 * np.pi:
theta -= 2 * np.pi

# Обновляем положение
r = v_perp / omega_c * np.cos(theta)
z += v_parallel * dt

# Сохраняем позиции
positions[i] = [r, z, theta]

# Визуализация
fig = plt.figure()
ax = fig.add_subplot(111, projection='3d')
ax.plot(positions[:, 0] * np.cos(positions[:, 2]),
positions[:, 0] * np.sin(positions[:, 2]),
positions[:, 1], label='Траектория частицы')

ax.set_xlabel('X (м)')
ax.set_ylabel('Y (м)')
ax.set_zlabel('Z (м)')
ax.set_title('Модель удержания частицы в токамаке')
plt.legend()
plt.show()


### Объяснение:
1. Циклотронная частота: Заряженная частица движется по спирали под действием магнитного поля.
2. Магнитная ловушка: Магнитное поле токамака удерживает плазму, предотвращая её контакт со стенками.
3. Параметры: Скорости \( v_\perp \) и \( v_\parallel \) представляют начальные условия частицы.

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

Подпишись 👉🏻 @KodduuPython 🤖
Результат скрипта выше 👆👆👆

Подпишись 👉🏻 @KodduuPython 🤖
👍2