Сравним Python и Kotlin — два языка, популярные в разных областях: Python широко используется для веб-разработки, анализа данных и автоматизации, а Kotlin — для разработки мобильных приложений (особенно на Android) и серверных решений.
1. Функции
#### Python:
#### Kotlin:
Отличие: Kotlin требует явного указания типа аргументов и возвращаемого значения. В Python типы не обязательны, но можно использовать аннотации для большей строгости.
2. Классы
#### Python:
#### Kotlin:
Отличие: Kotlin поддерживает конструкторы непосредственно в объявлении класса, что делает код более компактным. Python требует явного определения конструктора через init.
3. Null Safety (Безопасность null)
#### Python:
#### Kotlin:
Отличие: В Kotlin типы по умолчанию не допускают значения null. Чтобы переменная могла быть null, нужно явно указать это через ?. Python позволяет None для любого объекта.
4. Обработка исключений
#### Python:
#### Kotlin:
Отличие: Синтаксис обработки исключений похож, но Kotlin использует фигурные скобки вместо отступов.
5. Асинхронное программирование
#### Python (с использованием `asyncio`):
#### Kotlin (с использованием Coroutines):
Отличие: Kotlin встроенно поддерживает сопрограммы (`coroutines`), которые более естественно интегрированы в язык. В Python используется библиотека asyncio.
6. Лямбда-выражения
#### Python:
#### Kotlin:
Отличие: Kotlin требует явного указания типов аргументов для функций, тогда как Python определяет типы во время выполнения.
Подпишись 👉🏻 @KodduuPython 🤖
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 🤖
Подпишись 👉🏻 @KodduuPython 🤖
⚡2
Сравним Python и GoLang (Golang), два языка, которые широко используются, но с разными целями: Python популярен для скриптов, анализа данных, веб-разработки и автоматизации, а Go — для высокопроизводительных серверных приложений, микросервисов и системного программирования.
1. Функции
#### Python:
#### Go:
Отличие: В Go типы аргументов и возвращаемого значения обязательны. В Python они не нужны, но могут быть добавлены как аннотации.
2. Циклы
#### Python:
#### Go:
Отличие: Go имеет только один вид цикла (`for`), который может использоваться как цикл с условием, итерационный цикл или бесконечный цикл.
2. Работа с коллекциями
#### Python:
#### Go:
Отличие: Python поддерживает включения списков (list comprehensions), а в Go для работы с коллекциями часто используется цикл
3. Многопоточность
#### Python (с использованием `threading`):
#### Go:
Отличие: Go имеет встроенную поддержку многопоточности через
4. Обработка ошибок
#### Python:
#### Go:
Отличие: Go не использует исключения, а вместо этого возвращает ошибки как значения. Python полагается на механизм исключений.
5. Асинхронное программирование
#### Python (с использованием `asyncio`):
#### Go:
Отличие: Go использует
6. Пакеты и модули
#### Python:
#### Go:
Отличие: Go требует явного указания пакетов, а файлы пакетов находятся в строго организованной структуре.
Подпишись 👉🏻 @KodduuPython 🤖
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 🤖
Смоделировать термоядерный синтез на токамаке полностью невозможно из-за сложности физического процесса и необходимых вычислительных ресурсов. Однако можно написать упрощённую модель для демонстрации основных принципов — удержания плазмы в магнитном поле и её нагрева.
Пример кода для визуализации удержания заряженных частиц в магнитной ловушке:
### Объяснение:
1. Циклотронная частота: Заряженная частица движется по спирали под действием магнитного поля.
2. Магнитная ловушка: Магнитное поле токамака удерживает плазму, предотвращая её контакт со стенками.
3. Параметры: Скорости \( v_\perp \) и \( v_\parallel \) представляют начальные условия частицы.
Этот код упрощён, но иллюстрирует траекторию частицы в магнитном поле. Для реальных симуляций нужно учитывать процессы нагрева, взаимодействия частиц, нестабильности плазмы и решать уравнения магнитной гидродинамики (MHD).
Подпишись 👉🏻 @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 🤖
Добавим анимацию траектории движения частицы в токамаке, чтобы увидеть её поведение в динамике. Используем библиотеку
Вот обновлённый код:
### Объяснение:
1. Анимация: Используется
2. Движение частицы: Красная точка показывает текущую позицию частицы, а линия визуализирует её траекторию.
3. Параметры пространства: Установлены ограничения для осей, чтобы траектория была чётко видна.
Этот код позволяет визуально наблюдать движение частицы в магнитном поле токамака в режиме реального времени.
Подпишись 👉🏻 @KodduuPython 🤖
matplotlib.animation для создания анимации.Вот обновлённый код:
import numpy as np
import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d import Axes3D
from matplotlib.animation import FuncAnimation
# Константы
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 = 1000
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')
# Настройка начальной траектории
line, = ax.plot([], [], [], lw=2, label='Траектория частицы')
point, = ax.plot([], [], [], 'ro')
ax.set_xlim([-0.05, 0.05])
ax.set_ylim([-0.05, 0.05])
ax.set_zlim([0, 0.2])
ax.set_xlabel('X (м)')
ax.set_ylabel('Y (м)')
ax.set_zlabel('Z (м)')
ax.set_title('Модель удержания частицы в токамаке')
ax.legend()
# Функция для обновления анимации
def update(num):
x = positions[:num, 0] * np.cos(positions[:num, 2])
y = positions[:num, 0] * np.sin(positions[:num, 2])
z = positions[:num, 1]
line.set_data(x, y)
line.set_3d_properties(z)
point.set_data(x[-1:], y[-1:])
point.set_3d_properties(z[-1:])
return line, point
# Анимация
ani = FuncAnimation(fig, update, frames=len(positions), interval=10, blit=True)
plt.show()
### Объяснение:
1. Анимация: Используется
FuncAnimation из matplotlib.animation для обновления траектории в каждой итерации.2. Движение частицы: Красная точка показывает текущую позицию частицы, а линия визуализирует её траекторию.
3. Параметры пространства: Установлены ограничения для осей, чтобы траектория была чётко видна.
Этот код позволяет визуально наблюдать движение частицы в магнитном поле токамака в режиме реального времени.
Подпишись 👉🏻 @KodduuPython 🤖
Рарные (редкие) вопросы с собеседований на картинке. Их хорошо бы изучить, чтобы блеснуть знаниями 😎 Такие вопросы проверяют глубину знаний Python.
Подпишись 👉🏻 @KodduuPython 🤖
Подпишись 👉🏻 @KodduuPython 🤖
👍2
Вот обновлённый код, в котором добавлено несколько частиц. Каждая частица имеет свои начальные условия для большей наглядности. Это создаёт эффект "облака" частиц, движущихся в магнитном поле.
### Что изменилось:
1. Множественные частицы: Добавлено
2. Обновление позиций: Траектория каждой частицы рассчитывается отдельно и хранится в массиве
3. Анимация для всех частиц: Линии и точки создаются для каждой частицы, и их положение обновляется на каждом шаге.
Теперь вы можете наблюдать движение "облака" частиц в магнитном поле токамака, что лучше демонстрирует работу системы удержания.
Подпишись 👉🏻 @KodduuPython 🤖
import numpy as np
import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d import Axes3D
from matplotlib.animation import FuncAnimation
# Константы
q = 1.6e-19 # заряд частицы (Кулон)
m = 1.67e-27 # масса частицы (кг, протон)
B = 5.0 # магнитное поле (Тесла)
dt = 1e-9 # временной шаг (с)
# Параметры начального состояния
num_particles = 10 # количество частиц
v_perp = np.random.uniform(0.5e6, 1.5e6, num_particles) # скорости перпендикулярно полю (м/с)
v_parallel = np.random.uniform(1e6, 3e6, num_particles) # скорости вдоль поля (м/с)
theta = np.random.uniform(0, 2 * np.pi, num_particles) # начальный угол
# Инициализация позиций частиц
r = np.zeros(num_particles) # радиус
z = np.zeros(num_particles) # положение вдоль оси
positions = np.zeros((num_particles, 1000, 3)) # траектория для каждой частицы
# Моделирование траектории для всех частиц
for p in range(num_particles):
for t in range(1000):
omega_c = q * B / m # циклотронная частота (рад/с)
theta[p] += omega_c * dt
if theta[p] > 2 * np.pi:
theta[p] -= 2 * np.pi
r = v_perp[p] / omega_c * np.cos(theta[p])
z[p] += v_parallel[p] * dt
positions[p, t] = [r, z[p], theta[p]]
# Визуализация
fig = plt.figure()
ax = fig.add_subplot(111, projection='3d')
# Настройка графиков для частиц
lines = [ax.plot([], [], [], lw=1)[0] for _ in range(num_particles)]
points = [ax.plot([], [], [], 'o')[0] for _ in range(num_particles)]
ax.set_xlim([-0.05, 0.05])
ax.set_ylim([-0.05, 0.05])
ax.set_zlim([0, 0.2])
ax.set_xlabel('X (м)')
ax.set_ylabel('Y (м)')
ax.set_zlabel('Z (м)')
ax.set_title('Модель удержания множества частиц в токамаке')
# Функция для обновления анимации
def update(num):
for p in range(num_particles):
x = positions[p, :num, 0] * np.cos(positions[p, :num, 2])
y = positions[p, :num, 0] * np.sin(positions[p, :num, 2])
z = positions[p, :num, 1]
lines[p].set_data(x, y)
lines[p].set_3d_properties(z)
points[p].set_data(x[-1:], y[-1:])
points[p].set_3d_properties(z[-1:])
return lines + points
# Анимация
ani = FuncAnimation(fig, update, frames=1000, interval=10, blit=True)
plt.show()
### Что изменилось:
1. Множественные частицы: Добавлено
num_particles частиц. Каждая из них имеет случайные начальные скорости и углы.2. Обновление позиций: Траектория каждой частицы рассчитывается отдельно и хранится в массиве
positions.3. Анимация для всех частиц: Линии и точки создаются для каждой частицы, и их положение обновляется на каждом шаге.
Теперь вы можете наблюдать движение "облака" частиц в магнитном поле токамака, что лучше демонстрирует работу системы удержания.
Подпишись 👉🏻 @KodduuPython 🤖
Тут я за производтельность, безопасность и чистоту кода. Это кстати очень хориший вопрос на собеседовании, потому что тут все depends... И ответ на этот вопрос сильно определяет ваш уровень. Я люблю такие вопросы.
Линк на сам курс.
Подпишись 👉🏻 @KodduuPython 🤖
Линк на сам курс.
Подпишись 👉🏻 @KodduuPython 🤖
👍3
Познакомимся с редкой библиотекой для задач производительности и удобства работы с многопоточностью — `joblib`. Она полезна для эффективного параллельного выполнения задач и кеширования результатов.
---
### Установка
Если библиотека не установлена:
---
### Пример использования: параллельная обработка
Создадим пример, который выполняет вычисления факториалов для большого набора чисел с использованием многопоточности.
### Объяснение:
1. Параллельное выполнение:
-
-
2. Результаты:
- Код вычисляет факториалы для чисел от 100,000 до 100,009.
- Вместо вывода самих чисел (очень большие), выводится количество цифр в результатах.
3. Время выполнения:
- Параллельное выполнение значительно ускоряет обработку по сравнению с последовательным.
### Преимущества
- Простота использования.
- Поддержка автоматического распараллеливания.
- Возможность кеширования результатов для экономии времени на повторных вычислениях.
Подпишись 👉🏻 @KodduuPython 🤖
---
### Установка
joblibЕсли библиотека не установлена:
pip install joblib
---
### Пример использования: параллельная обработка
Создадим пример, который выполняет вычисления факториалов для большого набора чисел с использованием многопоточности.
from joblib import Parallel, delayed
import math
import time
# Функция для вычисления факториала
def compute_factorial(n):
return math.factorial(n)
def main():
numbers = range(100000, 100010) # Список больших чисел для вычисления факториала
print("Вычисление факториалов параллельно...")
start = time.time()
# Параллельное выполнение
results = Parallel(n_jobs=-1)(delayed(compute_factorial)(n) for n in numbers)
end = time.time()
print(f"Результаты: {[len(str(r)) for r in results]} (количество цифр в каждом факториале)")
print(f"Время выполнения: {end - start:.2f} секунд")
if __name__ == "__main__":
main()
### Объяснение:
1. Параллельное выполнение:
-
Parallel(n_jobs=-1) использует все доступные ядра процессора для вычислений.-
delayed(compute_factorial) указывает функцию и её аргументы для выполнения.2. Результаты:
- Код вычисляет факториалы для чисел от 100,000 до 100,009.
- Вместо вывода самих чисел (очень большие), выводится количество цифр в результатах.
3. Время выполнения:
- Параллельное выполнение значительно ускоряет обработку по сравнению с последовательным.
### Преимущества
joblib:- Простота использования.
- Поддержка автоматического распараллеливания.
- Возможность кеширования результатов для экономии времени на повторных вычислениях.
Подпишись 👉🏻 @KodduuPython 🤖
Вот интересный и полезный лайфхак на чистом Python: реализация LRU (Least Recently Used) кэша без использования дополнительных библиотек.
### Что это?
LRU-кэш сохраняет результаты вызовов функций для ускорения последующих вычислений. Если кэш переполняется, удаляется самый "старый" элемент.
---
### Реализация LRU-кэша:
---
### Как это работает:
1. Кэш:
- Хранит значения по ключам.
-
2. Порядок использования:
-
- Если кэш переполняется, удаляется элемент, добавленный раньше всех.
3. Методы:
-
-
---
### Чем полезно:
- Позволяет ускорить функции, повторяющие одни и те же вычисления.
- Это компактная реализация кэша без использования библиотек, которая полезна в ограниченных средах.
Подпишись 👉🏻 @KodduuPython 🤖
### Что это?
LRU-кэш сохраняет результаты вызовов функций для ускорения последующих вычислений. Если кэш переполняется, удаляется самый "старый" элемент.
---
### Реализация LRU-кэша:
from collections import deque
class LRUCache:
def __init__(self, capacity: int):
self.cache = {} # Хранение данных
self.order = deque() # Порядок использования
self.capacity = capacity
def get(self, key):
if key not in self.cache:
return -1 # Если ключ не найден
# Обновляем порядок использования
self.order.remove(key)
self.order.append(key)
return self.cache[key]
def put(self, key, value):
if key in self.cache:
# Обновляем значение и порядок использования
self.order.remove(key)
elif len(self.cache) >= self.capacity:
# Удаляем самый старый элемент
oldest_key = self.order.popleft()
del self.cache[oldest_key]
# Добавляем новый элемент
self.cache[key] = value
self.order.append(key)
# Пример использования
cache = LRUCache(3)
cache.put(1, "A") # Добавляем ключ 1
cache.put(2, "B") # Добавляем ключ 2
cache.put(3, "C") # Добавляем ключ 3
print(cache.get(1)) # "A" - обновляем порядок ключа 1
cache.put(4, "D") # Добавляем ключ 4, удаляем самый старый (ключ 2)
print(cache.get(2)) # -1 (удалён из-за переполнения)
print(cache.get(3)) # "C"
print(cache.get(4)) # "D"
---
### Как это работает:
1. Кэш:
- Хранит значения по ключам.
-
self.cache — словарь для хранения данных.2. Порядок использования:
-
deque отслеживает порядок добавления/обновления ключей.- Если кэш переполняется, удаляется элемент, добавленный раньше всех.
3. Методы:
-
get: Возвращает значение по ключу и обновляет порядок.-
put: Добавляет новый элемент, удаляя самый старый при необходимости.---
### Чем полезно:
- Позволяет ускорить функции, повторяющие одни и те же вычисления.
- Это компактная реализация кэша без использования библиотек, которая полезна в ограниченных средах.
Подпишись 👉🏻 @KodduuPython 🤖
👍5
Грядет конец года, поэтоиму спрошу - что нужно запустить в 2025 для помощи нашему ламповому комьюнити?
Anonymous Poll
47%
Пиши больше примеров кода
28%
Проводи mock собесы (тестовые собеседования для желающих потренироваться)
40%
Давай нам задачи на кодинг (даешь стране 10 000 строк кода в неделю)
44%
Подключи нас к реальному или mock проекту, чтобы писать настоящий код
7%
Не мешай готовиться к НГ :-)
9%
О чем речь? Что это за канал? :)
👍5
Проблема, связанная с переходом на 2000 год (известная как Y2K), возникала из-за хранения годов в виде двух цифр вместо четырёх, что приводило к ошибкам в вычислениях и интерпретации дат. Вот пример кода, демонстрирующего подобную проблему:
### Объяснение:
1. В
- Если год в диапазоне 00-68, он считается частью 2000-х годов (например,
- Если год в диапазоне 69-99, он считается частью 1900-х годов (например,
### Возможные проблемы:
1. Неправильная интерпретация годов, выходящих за рамки 1900-2099.
2. Зависимость от правил интерпретации двухзначных годов, которые могут быть разными в других системах.
#### Исправление:
Всегда использовать четырёхзначный формат года (`%Y`), чтобы избежать таких проблем:
Подпишись 👉🏻 @KodduuPython 🤖
from datetime import datetime
# Демонстрация хранения года в виде двух цифр
def process_date(two_digit_year):
try:
# Преобразуем дату с фиксированным форматом
date = datetime.strptime(f"01-01-{two_digit_year}", "%d-%m-%y")
return date
except ValueError as e:
return f"Ошибка обработки даты: {e}"
# Пример с корректной интерпретацией дат
print(process_date("99")) # Ожидается: 1999
print(process_date("00")) # Проблема: интерпретируется как 2000
# Пример возможной ошибки
print(process_date("50")) # В интервале 1950-2049 интерпретируется как 2050
print(process_date("49")) # Интерпретируется как 1949
### Объяснение:
1. В
datetime.strptime двухзначный год (`%y`) интерпретируется следующим образом:- Если год в диапазоне 00-68, он считается частью 2000-х годов (например,
00 = 2000, 50 = 2050).- Если год в диапазоне 69-99, он считается частью 1900-х годов (например,
99 = 1999).### Возможные проблемы:
1. Неправильная интерпретация годов, выходящих за рамки 1900-2099.
2. Зависимость от правил интерпретации двухзначных годов, которые могут быть разными в других системах.
#### Исправление:
Всегда использовать четырёхзначный формат года (`%Y`), чтобы избежать таких проблем:
def process_date(four_digit_year):
try:
date = datetime.strptime(f"01-01-{four_digit_year}", "%d-%m-%Y")
return date
except ValueError as e:
return f"Ошибка обработки даты: {e}"
# Теперь даты интерпретируются корректно
print(process_date("1999"))
print(process_date("2000"))
print(process_date("2050"))
Подпишись 👉🏻 @KodduuPython 🤖
Проблема, связанная с миллисекундным отсчетом от определенной эпохи, известна как "Unix Y2K" или "2038 Year Problem". Эта проблема возникает из-за того, что в системах, использующих 32-битные целые числа со знаком для представления времени (например, количество секунд, прошедших с эпохи Unix — 1 января 1970 года), число переполняется 19 января 2038 года.
### Демонстрация проблемы "2038 года" в Python
В этом примере используется библиотека
### Объяснение:
1. Эпоха Unix: Отсчет времени начинается с 1 января 1970 года, 00:00:00 UTC.
2. 32-битное ограничение: Максимальное значение 32-битного целого числа со знаком —
3. Переполнение: При превышении этого значения число переходит в отрицательное, что может быть интерпретировано как время в 1901 году.
### Выход из ситуации:
1. Использование 64-битных целых чисел для представления времени, что решает проблему до 292 млрд лет (в случае signed int).
2. Обновление всех систем, работающих с 32-битным временем.
### Пример безопасного решения:
Современные версии Python уже используют 64-битные значения для работы с временем, поэтому проблемы переполнения нет. Однако, в системах с жестким ограничением разрядности (например, встроенные системы) всё ещё может быть актуальной.
Подпишись 👉🏻 @KodduuPython 🤖
### Демонстрация проблемы "2038 года" в Python
В этом примере используется библиотека
datetime, но мы специально ограничим время 32-битным целым числом, чтобы воспроизвести ошибку:
import time
from datetime import datetime, timedelta
# Симуляция 32-битного ограничения
def simulate_32bit_time(seconds_since_epoch):
# Ограничение на 32-битное значение со знаком (-2^31 до 2^31-1)
MAX_INT_32 = 2**31 - 1
MIN_INT_32 = -2**31
if not (MIN_INT_32 <= seconds_since_epoch <= MAX_INT_32):
raise OverflowError("Время вышло за пределы 32-битного диапазона!")
# Преобразуем в дату
return datetime(1970, 1, 1) + timedelta(seconds=seconds_since_epoch)
# Текущее время в секундах с 1 января 1970 года
current_time = int(time.time())
print("Текущее время:", simulate_32bit_time(current_time))
# Пример даты до переполнения
future_time = 2**31 - 1 # Максимальное значение для 32-битного числа
print("Дата на границе 32-битного диапазона:", simulate_32bit_time(future_time))
# Попытка перейти за границу 32-битного диапазона
try:
overflow_time = 2**31 # Переполнение
print("Дата после переполнения:", simulate_32bit_time(overflow_time))
except OverflowError as e:
print("Ошибка:", e)
### Объяснение:
1. Эпоха Unix: Отсчет времени начинается с 1 января 1970 года, 00:00:00 UTC.
2. 32-битное ограничение: Максимальное значение 32-битного целого числа со знаком —
2,147,483,647 секунд, что соответствует времени 19 января 2038 года, 03:14:07 UTC.3. Переполнение: При превышении этого значения число переходит в отрицательное, что может быть интерпретировано как время в 1901 году.
### Выход из ситуации:
1. Использование 64-битных целых чисел для представления времени, что решает проблему до 292 млрд лет (в случае signed int).
2. Обновление всех систем, работающих с 32-битным временем.
### Пример безопасного решения:
Современные версии Python уже используют 64-битные значения для работы с временем, поэтому проблемы переполнения нет. Однако, в системах с жестким ограничением разрядности (например, встроенные системы) всё ещё может быть актуальной.
Подпишись 👉🏻 @KodduuPython 🤖
👍4👀1
Вот пример кода на Python, который демонстрирует Year 2107 Bug, связанную с ограничениями дат в файловой системе FAT32. Эта файловая система использует 7 бит для представления года (с 1980 года), поэтому максимальный год, который она может представить, — 2107.
### Пример кода:
### Объяснение:
1. Кодирование даты в FAT32:
- Год: Хранится в 7 битах (1980-2107).
- Месяц: Хранится в 4 битах (1-12).
- День: Хранится в 5 битах (1-31).
- Итоговое значение даты представляет 16-битное число.
2. Максимальная дата:
- Максимально возможный год — 2107.
- После 31 декабря 2107 года невозможно корректно представить дату, так как значение года переполняется.
3. Результат работы:
- Корректные даты (например, 2107-12-31) кодируются и декодируются без проблем.
- Попытка закодировать дату 2108-01-01 вызывает ошибку.
### Вывод:
Этот пример демонстрирует, как FAT32 использует ограниченное пространство для представления дат. После 2107 года все операции с датами будут некорректны. Это ограничение связано с жестко заданным форматом данных в FAT32, и для решения проблемы потребуется либо сменить файловую систему, либо обновить формат хранения метаданных.
Подпишись 👉🏻 @KodduuPython 🤖
### Пример кода:
import datetime
def fat32_date_encoding(year, month, day):
"""
Кодирование даты в формате FAT32.
"""
if not (1980 <= year <= 2107):
raise ValueError("Год должен быть в диапазоне от 1980 до 2107 для FAT32!")
# Вычисляем двоичный формат даты FAT32:
encoded_date = ((year - 1980) << 9) | (month << 5) | day
return encoded_date
def fat32_date_decoding(encoded_date):
"""
Декодирование даты из формата FAT32.
"""
year = 1980 + ((encoded_date >> 9) & 0x7F) # 7 бит на год
month = (encoded_date >> 5) & 0x0F # 4 бита на месяц
day = encoded_date & 0x1F # 5 бит на день
return datetime.date(year, month, day)
# Демонстрация
try:
# Кодируем дату 2107-12-31 (максимально возможная дата)
encoded_date = fat32_date_encoding(2107, 12, 31)
print(f"Дата 2107-12-31 закодирована как: {encoded_date:#018b}")
# Декодируем дату обратно
decoded_date = fat32_date_decoding(encoded_date)
print(f"Декодированная дата: {decoded_date}")
# Попытка закодировать дату за пределами допустимого диапазона
encoded_invalid_date = fat32_date_encoding(2108, 1, 1)
print(f"Дата 2108-01-01 закодирована как: {encoded_invalid_date:#018b}")
except ValueError as e:
print("Ошибка:", e)
### Объяснение:
1. Кодирование даты в FAT32:
- Год: Хранится в 7 битах (1980-2107).
- Месяц: Хранится в 4 битах (1-12).
- День: Хранится в 5 битах (1-31).
- Итоговое значение даты представляет 16-битное число.
2. Максимальная дата:
- Максимально возможный год — 2107.
- После 31 декабря 2107 года невозможно корректно представить дату, так как значение года переполняется.
3. Результат работы:
- Корректные даты (например, 2107-12-31) кодируются и декодируются без проблем.
- Попытка закодировать дату 2108-01-01 вызывает ошибку.
### Вывод:
Этот пример демонстрирует, как FAT32 использует ограниченное пространство для представления дат. После 2107 года все операции с датами будут некорректны. Это ограничение связано с жестко заданным форматом данных в FAT32, и для решения проблемы потребуется либо сменить файловую систему, либо обновить формат хранения метаданных.
Подпишись 👉🏻 @KodduuPython 🤖