Постоянный репозиторий по Python @phytonrepoz Channel on Telegram

Постоянный репозиторий по Python

@phytonrepoz


Постоянный репозиторий по Python (Russian)

Добро пожаловать в канал "Постоянный репозиторий по Python"! Если вы увлечены языком программирования Python или просто хотите узнать больше об этой удивительной технологии, то этот канал - идеальное место для вас. Здесь вы найдете самые свежие и актуальные материалы, статьи, уроки и обновления по Python. Мы постоянно обновляем контент, чтобы держать вас в курсе последних тенденций и новостей в мире Python. Наш канал также предоставляет возможность общения с другими участниками, задавать вопросы и делиться своим опытом. Независимо от вашего уровня опыта в программировании, здесь вы найдете что-то интересное и полезное для себя. Присоединяйтесь к нам в канале "Постоянный репозиторий по Python" уже сегодня и расширьте свои знания и навыки в этой увлекательной области!

Постоянный репозиторий по Python

14 Jan, 07:29


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

Основные встроенные функции
1. bin() – преобразует число в двоичную строку.
num = 42
binary = bin(num) # Результат: '0b101010'
print(binary)


2. oct() – преобразует число в восьмеричную строку.
num = 42
octal = oct(num) # Результат: '0o52'
print(octal)


3. hex() – преобразует число в шестнадцатеричную строку.
num = 42
hexadecimal = hex(num) # Результат: '0x2a'
print(hexadecimal)


4. int() – преобразует строку в целое число, поддерживая разные основания (от 2 до 36).
binary_string = "101010"
num = int(binary_string, 2) # Преобразует из двоичной системы в десятичную
print(num) # 42


Преобразование между системами счисления
1. Десятичная в другие системы
• Используйте bin(), oct() и hex() для преобразования числа.
decimal = 42
print(bin(decimal)) # '0b101010'
print(oct(decimal)) # '0o52'
print(hex(decimal)) # '0x2a'


2. Двоичная, восьмеричная, шестнадцатеричная в десятичную
• Используйте int() с указанием основания системы.
binary = "101010"
octal = "52"
hexadecimal = "2a"

print(int(binary, 2)) # 42
print(int(octal, 8)) # 42
print(int(hexadecimal, 16)) # 42


3. Между произвольными системами (например, из двоичной в шестнадцатеричную)
• Сначала преобразуйте исходное число в десятичное, затем в целевую систему.
binary = "101010"
decimal = int(binary, 2) # Преобразуем в десятичное
hexadecimal = hex(decimal) # Преобразуем в шестнадцатеричное
print(hexadecimal) # '0x2a'


Работа с произвольными системами счисления (2–36)

Для преобразования чисел в системы счисления с основаниями от 2 до 36 можно использовать пользовательскую функцию:
def to_base(number, base):
if number == 0:
return "0"
digits = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
result = ""
while number > 0:
result = digits[number % base] + result
number //= base
return result

num = 42
print(to_base(num, 2)) # '101010' (двоичная система)
print(to_base(num, 8)) # '52' (восьмеричная система)
print(to_base(num, 16)) # '2A' (шестнадцатеричная система)
print(to_base(num, 36)) # '16'


Преобразование из произвольной системы счисления в десятичную. Используйте встроенную функцию int():
number = "2A"
base = 16
decimal = int(number, base)
print(decimal) # 42


Примечания
1. Префикс в строках:
• Результаты функций bin(), oct(), hex() содержат префиксы 0b, 0o, 0x, указывающие на систему счисления. Если нужно удалить их, используйте строковые методы:
print(bin(42)[2:])  # '101010'


2. Регистры символов в шестнадцатеричных числах:
• Символы для чисел от 10 до 15 (A-F) в результатах hex() выводятся в нижнем регистре. Для преобразования в верхний регистр:
print(hex(42).upper())  # '0X2A'


3. Ошибки ввода:
• Если строка содержит недопустимые символы для системы счисления, int() вызовет ValueError. Проверяйте входные данные перед обработкой.

Теперь вы можете легко конвертировать числа между различными системами счисления!

Постоянный репозиторий по Python

07 Jan, 08:13


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

Основные поразрядные операции
1. Поразрядное И (AND): &
• Оператор & возвращает 1 в каждом бите результата, если соответствующие биты обоих операндов равны 1.
a = 0b1100  # 12 в двоичной системе
b = 0b1010 # 10 в двоичной системе
result = a & b # Результат: 0b1000 (8 в десятичной системе)
print(bin(result)) # '0b1000'


2. Поразрядное ИЛИ (OR): |
• Оператор | возвращает 1 в каждом бите результата, если хотя бы один из соответствующих битов операндов равен 1.
a = 0b1100
b = 0b1010
result = a | b # Результат: 0b1110 (14 в десятичной системе)
print(bin(result)) # '0b1110'


3. Поразрядное исключающее ИЛИ (XOR): ^
• Оператор ^ возвращает 1 в каждом бите результата, если соответствующие биты операндов различны.
a = 0b1100
b = 0b1010
result = a ^ b # Результат: 0b0110 (6 в десятичной системе)
print(bin(result)) # '0b110'


4. Поразрядное НЕ (NOT): ~
• Оператор ~ инвертирует все биты числа. В Python числа имеют знаковое представление (дополнительный код), поэтому результат инверсии для положительных чисел выглядит как -(число + 1).
a = 0b1100  # 12 в десятичной системе
result = ~a # Результат: -13
print(bin(result)) # '-0b1101'


5. Сдвиг влево (Left Shift): <<
• Оператор << сдвигает биты числа влево на указанное количество позиций. При этом справа добавляются нули.
a = 0b1100
result = a << 2 # Результат: 0b110000 (48 в десятичной системе)
print(bin(result)) # '0b110000'


6. Сдвиг вправо (Right Shift): >>
• Оператор >> сдвигает биты числа вправо на указанное количество позиций. Для положительных чисел слева добавляются нули.
a = 0b1100
result = a >> 2 # Результат: 0b11 (3 в десятичной системе)
print(bin(result)) # '0b11'



Примеры использования
1. Маскирование битов
Используя оператор &, можно выделить только интересующие биты числа.
number = 0b1101  # 13 в десятичной системе
mask = 0b0100 # Оставляем только третий бит
result = number & mask # Результат: 0b0100
print(bin(result)) # '0b100'


2. Установка битов
Для установки определенных битов можно использовать оператор | с маской.
number = 0b1001
mask = 0b0110
result = number | mask # Результат: 0b1111
print(bin(result)) # '0b1111'


3. Инверсия битов
Инвертируем только определенные биты с помощью ^.
number = 0b1100
mask = 0b1010
result = number ^ mask # Результат: 0b0110
print(bin(result)) # '0b110'


4. Проверка флага
Проверить, установлен ли определенный бит, можно с помощью & и сравнения с нулем.
number = 0b1010
flag = 0b0010
is_set = (number & flag) != 0
print(is_set) # True


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

Постоянный репозиторий по Python

30 Dec, 08:20


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

Ключевые особенности Pyodide
1. Кроссплатформенность - работает в любом современном браузере.
2. Полноценный Python - включает стандартные библиотеки Python и поддерживает популярные модули, такие как NumPy, Pandas, Matplotlib.
3. WebAssembly - код выполняется быстро и изолированно в браузере, что улучшает безопасность.
4. Интерактивность - позволяет интегрировать Python с JavaScript, обеспечивая двусторонний обмен данными.
5. Без серверной нагрузки - все вычисления происходят на клиентской стороне, снижая затраты на инфраструктуру.

Как работает Pyodide?
1. Веб-страница загружает Pyodide - Pyodide поставляется как библиотека JavaScript/WebAssembly.
2. Интерпретатор CPython в браузере - Pyodide использует CPython, чтобы исполнять Python-код.
3. Поддержка популярных библиотек - многие Python-библиотеки предварительно скомпилированы для работы в WebAssembly.
4. Интеграция с JavaScript - Python-код может вызывать JavaScript-функции, а JavaScript может использовать Python-библиотеки.

Пример использования Pyodide (Минимальный пример)

HTML-файл для запуска Python-кода:

<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>Pyodide Example</title>
<script src="https://cdn.jsdelivr.net/pyodide/v0.23.0/full/pyodide.js"></script>
</head>
<body>
<textarea id="python-code" rows="10" cols="50">
import math
math.sqrt(16)
</textarea>
<button onclick="runPython()">Run Python</button>
<pre id="output"></pre>

<script>
async function runPython() {
const pyodide = await loadPyodide();
const code = document.getElementById('python-code').value;
try {
const result = await pyodide.runPythonAsync(code);
document.getElementById('output').textContent = result;
} catch (err) {
document.getElementById('output').textContent = `Error: ${err}`;
}
}
</script>
</body>
</html>


Как развернуть проект с Pyodide
Шаг 1: Подготовьте HTML-файл.
Добавьте ссылки на библиотеку Pyodide и создайте интерфейс для ввода и вывода данных.
Шаг 2: Настройте выполнение Python-кода.
Напишите скрипт JavaScript для загрузки Pyodide и выполнения Python-кода.
Шаг 3: Хостинг.
Разместите проект на любом сервере, поддерживающем статические файлы:
• GitHub Pages
• Netlify
• Vercel

Pyodide – мощное решение для создания интерактивных веб-приложений, ориентированных на использование Python. Подходит для образовательных целей, прототипирования и демонстрации кода.

Постоянный репозиторий по Python

28 Dec, 14:05


🥇 Итоги 2024 года от Академии Информационных Систем🥇

Дорогие друзья,

С радостью подводим итоги уходящего года и выражаем огромную благодарность нашим партнерам-вендорам, которые доверяют нам проведение обучающих курсов. Благодаря вашему сотрудничеству мы достигли впечатляющих результатов!

💪В 2024 году мы провели обучение и сертификационные тестирования для более чем 10 000 человек по 300+ курсам. Среди них особое место занимают 100+ технических курсов, посвященных вендорским продуктам, из которых 25 были запущены именно в этом году.

Мы гордимся тем, что сотрудничаем с 20 партнерами — лидерами в разработке ИБ и ИТ продуктов, из которых 9 присоединились к нам в 2024 году. Это позволяет нам постоянно обновлять и расширять наш учебный контент, предлагая самые актуальные знания и навыки.

Что особенно важно, мы гордимся тем, что наша работа напрямую способствует развитию ИТ и ИБ отрасли в нашей стране💓
Мы вносим свой вклад в кадровое обеспечение, которое так необходимо для устойчивого технологического прогресса России. Ведь каждый подготовленный специалист — это шаг к нашему общему успеху и безопасности в цифровом мире.

👍 Спасибо всем нашим партнерам за доверие и поддержку!
Вместе мы продолжаем развивать профессиональное образование и обеспечивать высокий уровень подготовки специалистов, который будет способствовать укреплению нашей страны.

⚡️ С нетерпением ждем новых свершений в наступающем 2025 году!

Постоянный репозиторий по Python

24 Dec, 07:30


Разберем процесс создания десктопного приложения для выполнения арифметических операций на Python с использованием библиотеки PyQt6. Такой проект подходит для освоения основ разработки пользовательских интерфейсов и работы с событийно-ориентированным программированием.

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

Основные этапы реализации

1. Создание главного окна приложения
Основной класс Calculator наследует QMainWindow и отвечает за создание структуры интерфейса, включая поле ввода и расположение кнопок. Задаются базовые параметры окна, такие как заголовок, размеры и привязка центрального виджета через метод initUI.

2. Реализация поля для ввода/вывода данных
Поле для отображения выражений и результатов реализовано с помощью виджета QLineEdit. Оно настроено как только для чтения (чтобы ввод данных происходил исключительно через интерфейс кнопок). Визуальные параметры, такие как размер шрифта и высота поля, настроены для повышения удобства восприятия.

3. Создание сетки кнопок
Для организации кнопок используется QGridLayout. Каждая кнопка создается с помощью QPushButton, а её размещение определяется с использованием координат сетки, заданных в словаре. Также настраиваются визуальные параметры кнопок, такие как размер и шрифт.

4.Обработка событий нажатий кнопок
Метод on_button_click отвечает за логику обработки нажатий:
• Кнопка “C” очищает поле ввода.
• Кнопка “=” выполняет вычисление выражения, введенного пользователем, используя функцию eval.
• Все остальные кнопки добавляют свой текст в строку текущего выражения.

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

Итоговый код программы приведен ниже:

Постоянный репозиторий по Python

24 Dec, 07:30


import sys
from PyQt6.QtWidgets import (
QApplication, QMainWindow, QVBoxLayout, QLineEdit, QPushButton, QWidget, QGridLayout
)


class Calculator(QMainWindow):
def __init__(self):
super().__init__()
self.setWindowTitle("Калькулятор")
self.setGeometry(100, 100, 450, 550) # Увеличиваем размер окна
self.initUI()

def initUI(self):
# Создаем центральный виджет и задаем макет
central_widget = QWidget()
self.setCentralWidget(central_widget)
layout = QVBoxLayout()
central_widget.setLayout(layout)

# Поле для ввода/вывода
self.input_field = QLineEdit()
self.input_field.setReadOnly(True)
self.input_field.setStyleSheet("font-size: 36px; height: 80px; padding: 5px;") # Увеличиваем шрифт, высоту и отступы
layout.addWidget(self.input_field)

# Кнопки калькулятора
self.buttons = QGridLayout()
layout.addLayout(self.buttons)

# Добавляем кнопки
self.add_buttons()

def add_buttons(self):
buttons = {
'7': (0, 0), '8': (0, 1), '9': (0, 2), '/': (0, 3),
'4': (1, 0), '5': (1, 1), '6': (1, 2), '*': (1, 3),
'1': (2, 0), '2': (2, 1), '3': (2, 2), '-': (2, 3),
'0': (3, 0), 'C': (3, 1), '=': (3, 2), '+': (3, 3),
}

for btn_text, pos in buttons.items():
button = QPushButton(btn_text)
button.setStyleSheet("font-size: 24px; height: 70px;") # Увеличиваем кнопки
button.clicked.connect(self.on_button_click)
self.buttons.addWidget(button, pos[0], pos[1])

def on_button_click(self):
sender = self.sender()
btn_text = sender.text()

if btn_text == 'C': # Очистка экрана
self.input_field.clear()
elif btn_text == '=': # Вычисление результата
try:
expression = self.input_field.text()
result = eval(expression)
self.input_field.setText(str(result))
except Exception:
self.input_field.setText("Ошибка")
else: # Добавление текста кнопки к выражению
current_text = self.input_field.text()
self.input_field.setText(current_text + btn_text)


if __name__ == "__main__":
app = QApplication(sys.argv)
calculator = Calculator()
calculator.show()
sys.exit(app.exec())

Постоянный репозиторий по Python

17 Dec, 07:54


Регулярные выражения (regular expressions, или regex) в Python используются для поиска, сопоставления и манипуляции строками с использованием библиотеки re.

Основы работы с регулярными выражениями

Подключение модуля
Для работы с регулярными выражениями нужно подключить модуль re:

import re


Основные функции из модуля re:
1. re.match() – проверяет соответствие шаблона началу строки.
2. re.search() – ищет первое совпадение шаблона в строке.
3. re.findall() – возвращает список всех совпадений шаблона.
4. re.finditer() – возвращает итератор с объектами совпадений.
5. re.sub() – заменяет совпадения на заданную подстроку.
6. re.split() – разбивает строку по шаблону.

Примеры использования
1. Поиск с использованием re.match
Функция проверяет совпадение только в начале строки:

import re

pattern = r'\d+' # Шаблон: одна или более цифр
text = "123abc456"

result = re.match(pattern, text)
if result:
print("Совпадение найдено:", result.group())
else:
print("Совпадение не найдено")
# Совпадение найдено: 123


2. Поиск с использованием re.search
Функция ищет первое совпадение по всей строке:

pattern = r'\d+'
text = "abc123def456"

result = re.search(pattern, text)
if result:
print("Совпадение найдено:", result.group())
# Совпадение найдено: 123


3. Получение всех совпадений с помощью re.findall
Возвращает список всех совпадений:
pattern = r'\d+'
text = "abc123def456ghi789"

matches = re.findall(pattern, text)
print("Все совпадения:", matches)
# Все совпадения: ['123', '456', '789']


4. Замена с re.sub
Функция заменяет совпадения на заданный текст:
pattern = r'\d+'  # Ищем числа
replacement = "NUM"
text = "abc123def456"

new_text = re.sub(pattern, replacement, text)
print("Текст после замены:", new_text)
# Текст после замены: abcNUMdefNUM


5. Разделение строки с re.split
Разбивает строку по совпадениям:
pattern = r'\d+'  # Разделитель – числа
text = "abc123def456ghi"

parts = re.split(pattern, text)
print("Разбитые части:", parts)
# Разбитые части: ['abc', 'def', 'ghi']


6. Использование группировок с ()
Группировки позволяют извлекать части совпадения:
pattern = r'(\d{4})-(\d{2})-(\d{2})'  # Формат даты: YYYY-MM-DD
text = "Дата: 2024-06-17"

result = re.search(pattern, text)
if result:
print("Год:", result.group(1))
print("Месяц:", result.group(2))
print("День:", result.group(3))
# Год: 2024
# Месяц: 06
# День: 17


Флаги для работы с регулярными выражениями
re.IGNORECASE (re.I) – игнорировать регистр.
re.MULTILINE (re.M) – многострочный режим.
re.DOTALL (re.S). совпадает с символом новой строки.

Пример с флагами:
pattern = r'hello'
text = "Hello\nHELLO"

matches = re.findall(pattern, text, re.IGNORECASE)
print("Совпадения:", matches)
# Совпадения: ['Hello', 'HELLO']


Регулярные выражения – мощный инструмент для работы с текстом, позволяющий выполнять сложные поиски и замены. В Python модуль re предоставляет гибкие функции для их использования. Практика работы с регулярными выражениями позволит эффективно обрабатывать строки и автоматизировать текстовые задачи.

Постоянный репозиторий по Python

10 Dec, 07:04


Функция cache из модуля functools была добавлена в Python 3.9. Она автоматически сохраняет результаты выполнения функции (кэширует их), чтобы повторно использовать ранее вычисленные значения для тех же аргументов. Это может значительно ускорить выполнение программы, особенно при многократных вызовах функций с одинаковыми параметрами.
from functools import cache

@cache
def function_name(parameters):
# Тело функции
return result


Как работает кэширование?
• Когда функция с декоратором @cache вызывается, система проверяет, были ли уже вычислены результаты для переданных аргументов.
• Если результаты есть в кэше, они извлекаются и возвращаются, не выполняя тело функции повторно.
• Если аргументы встречаются впервые, функция выполняется, результат сохраняется в кэше, а затем возвращается.

from functools import cache

@cache
def factorial(n):
if n == 0:
return 1
return n * factorial(n - 1)

print(factorial(5)) # Вывод: 120
print(factorial(5)) # Вывод: 120 (быстро, из кэша)


Объяснение:
1. При первом вызове factorial(5) функция вычисляет значение с рекурсией, сохраняя результаты каждого промежуточного вызова.
2. При втором вызове factorial(5) результат извлекается из кэша, без повторного выполнения.

Пример 2: Оптимизация вычислений
Кэширование особенно полезно для функций с тяжелыми вычислениями или большого числа повторов.
from functools import cache
import time

@cache
def slow_function(n):
time.sleep(2) # Симуляция долгой операции
return n * 2

print(slow_function(10)) # Выполняется 2 секунды
print(slow_function(10)) # Мгновенный вывод из кэша


Ограничения cache

1. Изменяемые аргументы:
Аргументы функции, к которой применяется @cache, должны быть неизменяемыми (например, числа, строки, кортежи). Это связано с тем, что кэш использует аргументы в качестве ключей.

@cache
def invalid_function(lst):
return sum(lst)

# Ошибка: TypeError: unhashable type: 'list'
invalid_function([1, 2, 3])


Для таких случаев используйте неизменяемые структуры, например, кортежи:
@cache
def valid_function(tpl):
return sum(tpl)

print(valid_function((1, 2, 3))) # Работает


2. Потребление памяти:
Кэширование увеличивает потребление памяти, так как результаты сохраняются в памяти программы. Будьте осторожны при использовании @cache для функций с большими объемами данных.

Когда использовать cache?
• Рекурсивные функции: Например, при вычислении чисел Фибоначчи, факториалов, решения задач с динамическим программированием.
• Тяжелые вычисления: Для функций, которые выполняются медленно, но часто вызываются с одними и теми же аргументами.
• Часто повторяющиеся вызовы: Если множество вызовов функции повторяется с одинаковыми аргументами, cache исключает избыточные вычисления.

Как очистить кэш?
Для очистки кэша можно использовать метод cache_clear().

@cache
def cached_function(x):
return x * 2

cached_function(10)
cached_function.cache_clear() # Очистка кэша


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

Постоянный репозиторий по Python

04 Dec, 07:36


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

Синтаксис:

 from functools import reduce
result = reduce(function, iterable, initializer)


function — функция, принимающая два аргумента и возвращающая результат.
iterable — итерируемый объект, элементы которого будут обработаны.
initializer (необязательный) — начальное значение, которое используется в качестве первого аргумента на первом шаге.

Пример 1: Суммирование чисел

from functools import reduce

numbers = [1, 2, 3, 4, 5]
result = reduce(lambda x, y: x + y, numbers)
print(result) # Вывод: 15


Как работает:
1. x = 1, y = 2 → результат 3.
2. x = 3, y = 3 → результат 6.
3. Повторение до завершения.

Пример 2: Умножение чисел
numbers = [1, 2, 3, 4]
result = reduce(lambda x, y: x * y, numbers)
print(result) # Вывод: 24


Пример 3: Конкатенация строк

words = ["Hello", "World", "from", "Python"]
result = reduce(lambda x, y: x + " " + y, words)
print(result) # Вывод: "Hello World from Python"


Использование параметра initializer

Если указан initializer, он добавляется как первый элемент в начале итерации:
numbers = [1, 2, 3, 4]
result = reduce(lambda x, y: x * y, numbers, 10)
print(result) # Вывод: 240 (10 * 1 * 2 * 3 * 4)


Когда использовать reduce?
1. Подходит для сложных последовательных операций, когда накопление результата невозможно легко выразить другими способами.
2. Простая альтернатива циклам при обработке последовательностей.

Функция reduce полезна для функционального подхода к работе с данными. Однако ее использование оправдано только тогда, когда код остается читаемым и понятным. В современных практиках Python зачастую предпочитают списковые включения, генераторы или стандартные функции (sum, max, min), если они обеспечивают ту же функциональность.

Постоянный репозиторий по Python

26 Nov, 07:31


Python 3.13, выпущенный 7 октября 2024 года, привнес множество нововведений и улучшений. Вот ключевые из них:

1. Новый интерактивный интерпретатор (REPL):
Интерпретатор был значительно улучшен, теперь поддерживает многострочное редактирование, цветовую подсветку и цветные трассировки исключений. Это делает работу в интерактивном режиме более удобной и наглядной.

2. Экспериментальный режим без глобальной блокировки интерпретатора (GIL):
Введен экспериментальный режим, позволяющий запускать Python без глобальной блокировки интерпретатора, что способствует более эффективному использованию многопоточности. Этот режим доступен в качестве экспериментальной функции в установщиках для Windows и macOS.

3. Предварительный JIT-компилятор:
Добавлен экспериментальный JIT-компилятор, закладывающий основу для значительных улучшений производительности в будущих версиях. Хотя текущие приросты производительности умеренные, ожидается их увеличение в следующих релизах.

4. Определенные семантики для функции `locals()`:
Функция locals() теперь имеет четко определенные семантики при изменении возвращаемого словаря, что позволяет отладчикам работать более последовательно.

5. Включение модифицированной версии `mimalloc`:
Включена модифицированная версия mimalloc, которая опциональна, но по умолчанию включена, если поддерживается платформой, и обязательна для режима без GIL.

6. Удаление начальных отступов в строках документации (`docstrings`):
Теперь начальные отступы в docstrings автоматически удаляются, что снижает использование памяти и размер .pyc файлов. Большинство инструментов уже обрабатывают docstrings таким образом

7. Новый бэкенд dbm.sqlite3:
Модуль dbm получил новый бэкенд dbm.sqlite3, который используется по умолчанию при создании новых файлов.

8. Обновление минимальной поддерживаемой версии macOS:
Минимальная поддерживаемая версия macOS была изменена с 10.9 на 10.13 (High Sierra). Более старые версии macOS больше не поддерживаются.

9. Поддержка новых платформ:

• WASI теперь является платформой уровня 2.
• iOS и Android теперь являются платформами уровня 3.

10. Улучшения в аннотациях типов:
• Поддержка значений по умолчанию в параметрах типов.
• Новая аннотация typing.TypeIs для сужения типов.
• Аннотация для элементов только для чтения в TypedDict.
• Аннотация для обозначения устаревших элементов в системе типов.

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

Постоянный репозиторий по Python

25 Nov, 13:05


🎉 Любите мемы? А Python? Тогда это для вас! 🐍

Мы собрали лучшие мемы про Python – и делимся ими с вами, потому что программирование может (и должно!) быть веселым! 🚀

📢Приглашаем вас на наш курс:
«Программирование на Python. Уровень 1. Основы программирования» 🚀

💭 Почему стоит учить Python?

Это один из самых популярных и востребованных языков программирования.
Идеален для новичков благодаря лаконичному синтаксису и огромным библиотекам.
Применяется в самых горячих сферах: от анализа данных до разработки приложений.

📚 Чему вы научитесь:

🐍
Настраивать среду разработки;
🐍Работать с базовыми конструкциями Python;
🐍Создавать модули и пакеты;
🐍Освоите основы ввода/вывода и структуры данных.

📅 Ближайшие даты обучения:
02–06 декабря 2024 г.
13–17 января 2025 г.
14–18 апреля 2025 г.

📍 Формат обучения: очно или дистанционно
Продолжительность: 5 дней 40 ( ак. ч. ).


🌟Сделайте первый шаг в мир программирования вместе с Python!

📲 Узнать больше и записаться

Постоянный репозиторий по Python

19 Nov, 06:59


Работа с базой данных PostgreSQL в Python выполняется с использованием библиотеки psycopg2, которая предоставляет интерфейс для взаимодействия с базой данных и выполнения запросов SQL. Ниже описан процесс подключения, выполнения запросов и работы с результатами.

Установка библиотеки psycopg2

Для начала нужно установить библиотеку psycopg2, которая является стандартом де-факто для работы с PostgreSQL в Python.

pip install psycopg2


Альтернативой является psycopg2-binary, которая устанавливает двоичный дистрибутив (особенно полезно для разработки):

pip install psycopg2-binary


Подключение к базе данных

Подключение к PostgreSQL выполняется с помощью функции connect, где указываются параметры подключения: имя базы данных, пользователь, пароль, хост и порт.

import psycopg2

# Параметры подключения
conn = psycopg2.connect(
dbname="your_db_name",
user="your_username",
password="your_password",
host="localhost", # IP-адрес или домен сервера
port="5432" # порт PostgreSQL по умолчанию
)

# Открываем курсор для выполнения SQL-запросов
cursor = conn.cursor()


После успешного подключения вы можете использовать cursor для выполнения SQL-запросов.

Выполнение SQL-запросов

1. Выполнение простого запроса

Запросы выполняются с помощью метода execute(). Например, создадим таблицу:

# SQL-запрос на создание таблицы
create_table_query = '''
CREATE TABLE IF NOT EXISTS employees (
id SERIAL PRIMARY KEY,
name VARCHAR(100),
age INTEGER,
department VARCHAR(50)
)
'''

cursor.execute(create_table_query)
conn.commit() # Применение изменений к базе данных
print("Таблица создана")


2. Вставка данных

Для вставки данных можно использовать execute() с параметризованными запросами, чтобы избежать SQL-инъекций:

# SQL-запрос для вставки данных
insert_query = "INSERT INTO employees (name, age, department) VALUES (%s, %s, %s)"
data_to_insert = ("Alice", 30, "HR")
cursor.execute(insert_query, data_to_insert)
conn.commit()
print("Данные вставлены")


3. Вставка нескольких записей

Для вставки нескольких записей используйте executemany():

# Список данных для вставки
data = [
("Bob", 25, "Finance"),
("Charlie", 35, "IT"),
("Diana", 28, "Marketing")
]

cursor.executemany(insert_query, data)
conn.commit()
print("Несколько записей добавлены")


4. Извлечение данных

Для выборки данных используем запрос SELECT и метод fetchall() для получения всех строк:

# Запрос для выборки данных
select_query = "SELECT * FROM employees"
cursor.execute(select_query)

# Получаем все результаты
records = cursor.fetchall()
for row in records:
print(f"ID: {row[0]}, Name: {row[1]}, Age: {row[2]}, Department: {row[3]}")


Также можно использовать fetchone(), чтобы получить только одну строку, или fetchmany(n) для получения n строк.


Обработка транзакций и исключений

Используйте обработку исключений для выполнения транзакций и отката изменений, если что-то пошло не так:

try:
# Начало транзакции
cursor.execute("BEGIN")

# Вставка и другие операции
cursor.execute(insert_query, ("Eve", 29, "Legal"))

# Применяем изменения
conn.commit()
print("Транзакция успешно выполнена")
except Exception as e:
conn.rollback() # Откат изменений в случае ошибки
print("Ошибка транзакции:", e)


Закрытие соединения

После завершения работы с базой данных не забудьте закрыть курсор и соединение:

cursor.close()
conn.close()


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

Постоянный репозиторий по Python

12 Nov, 07:47


Mojo — это новый язык программирования, созданный для высокопроизводительных вычислений и машинного обучения. Mojo сочетает в себе знакомый синтаксис Python с производительностью, близкой к языкам уровня C++. Это делает его привлекательным для задач, требующих высокой скорости и оптимизации, таких как вычислительные задачи, глубокое обучение и обработка больших объемов данных.

Вот несколько ключевых различий между Python и Mojo, подкрепленных примерами.

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

Python — интерпретируемый язык, из-за чего его производительность не всегда высока. Mojo же разработан специально для достижения высокой скорости, сопоставимой с компилируемыми языками, такими как C++.

Python
def sum_numbers(n):
result = 0
for i in range(n):
result += i
return result

print(sum_numbers(1000000)) # Выполнение может занять заметное время


Mojo
fn sum_numbers(n: Int) -> Int:
var result: Int = 0
for i in range(n):
result += i
return result

print(sum_numbers(1000000)) # Выполняется значительно быстрее


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

2. Статическая типизация

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

Python
def multiply(x, y):
return x * y

print(multiply(5, "hello")) # Ошибка обнаружится только при выполнении кода


Mojo
fn multiply(x: Int, y: Int) -> Int:
return x * y

print(multiply(5, "hello")) # Ошибка будет обнаружена компилятором


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

3. Поддержка низкоуровневого программирования

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

Mojo
fn add_arrays(a: Array[Int], b: Array[Int]) -> Array[Int]:
var result: Array[Int] = Array(len(a))
for i in range(len(a)):
result[i] = a[i] + b[i]
return result


Здесь Array[Int] — это низкоуровневая структура данных, которая позволяет Mojo работать быстрее и эффективно управлять памятью. В Python подобный код потребует дополнительных оптимизаций, таких как использование NumPy.

Python (с NumPy для оптимизации)
import numpy as np

a = np.array([1, 2, 3])
b = np.array([4, 5, 6])
result = a + b # NumPy помогает ускорить операции с массивами


4. Простота Python против оптимизированного Mojo

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

Python
# Простой код для сложения элементов массива
def sum_array(arr):
return sum(arr)

print(sum_array([1, 2, 3, 4, 5])) # Просто и понятно



# Тот же код на Mojo, более оптимизированный, но требующий низкоуровневых знаний
fn sum_array(arr: Array[Int]) -> Int:
var result: Int = 0
for i in range(len(arr)):
result += arr[i]
return result

print(sum_array([1, 2, 3, 4, 5]))


• Python остается удобным и простым языком для разработки, особенно для прототипирования, написания скриптов и работы с данными.
• Mojo подходит для задач, требующих высокой производительности, где важны низкоуровневые операции и управление памятью. Он обеспечивает скорость, сопоставимую с C++ и Rust, при этом сохраняя удобный для восприятия синтаксис, схожий с Python.

Оба языка имеют свои сильные стороны, и выбор между ними зависит от требований к скорости и эффективности.

Постоянный репозиторий по Python

05 Nov, 07:35


Лямбда-функции и списочные включения — это удобные инструменты в Python, которые позволяют писать код более кратко и эффективно. Давайте разберем их особенности и примеры использования.

Лямбда-функции

Лямбда-функция — это небольшая анонимная функция, которая создается с помощью ключевого слова lambda. Она особенно удобна, когда нужна простая функция на одно действие, например, в функции map, filter или для сортировки.

Синтаксис:

lambda аргументы: выражение


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

Пример 1: простая лямбда-функция

# Функция для умножения числа на 2
multiply_by_2 = lambda x: x * 2
print(multiply_by_2(5)) # Вывод: 10


Пример 2: использование в функции map

Функция map применяет функцию ко всем элементам последовательности и возвращает новый итератор.

numbers = [1, 2, 3, 4, 5]
squared = list(map(lambda x: x ** 2, numbers))
print(squared) # Вывод: [1, 4, 9, 16, 25]


Пример 3: использование в функции `filter`

Функция filter оставляет только те элементы, которые соответствуют условию.

numbers = [1, 2, 3, 4, 5]
evens = list(filter(lambda x: x % 2 == 0, numbers))
print(evens) # Вывод: [2, 4]


Списочные включения (List Comprehensions)

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

Синтаксис:

[выражение for элемент in последовательность if условие]


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

Пример 1: создание списка квадратов чисел

numbers = [1, 2, 3, 4, 5]
squared = [x ** 2 for x in numbers]
print(squared) # Вывод: [1, 4, 9, 16, 25]


Пример 2: фильтрация с использованием списочного включения

numbers = [1, 2, 3, 4, 5]
evens = [x for x in numbers if x % 2 == 0]
print(evens) # Вывод: [2, 4]


Пример 3: вложенные списочные включения

Списочные включения также поддерживают вложенные циклы.

matrix = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
flattened = [num for row in matrix for num in row]
print(flattened) # Вывод: [1, 2, 3, 4, 5, 6, 7, 8, 9]


Лямбда-функции vs Списочные включения

• Лямбда-функции хороши для кратких одноразовых функций, особенно если их передают в map, filter или sorted.
• Списочные включения удобны для создания новых списков из существующих, особенно если требуется обработать или отфильтровать элементы.

Постоянный репозиторий по Python

29 Oct, 07:49


Для создания программы с графическим интерфейсом (GUI) для решения квадратных уравнений с использованием библиотеки tkinter в Python, мы должны выполнить несколько шагов:

Шаги по созданию программы:

1. Создание окна приложения:
Используя tkinter.Tk(), создадим основное окно для приложения.

2. Элементы интерфейса:
Нам понадобятся следующие элементы:
• Ввод данных для коэффициентов a, b и c (т.е. для квадратного уравнения ax^2 + bx + c = 0).
• Кнопка для запуска вычислений.
• Поле вывода для отображения корней уравнения или сообщения о том, что решения нет.

3. Функция решения уравнения:
Квадратное уравнение решается по формуле дискриминанта:

D = b^2 - 4ac

• Если D > 0, то уравнение имеет два корня.
• Если D = 0, то уравнение имеет один корень.
• Если D < 0, то уравнение не имеет действительных решений.

4. Связывание кнопки с функцией решения:
При нажатии на кнопку должна вызываться функция, которая решает уравнение и выводит результат в поле вывода.

Полный код программы:

import tkinter as tk
from tkinter import messagebox
import math

# Функция для решения квадратного уравнения
def solve_quadratic():
try:
# Получаем значения коэффициентов a, b, c
a = float(entry_a.get())
b = float(entry_b.get())
c = float(entry_c.get())

# Вычисляем дискриминант
D = b**2 - 4*a*c

if D > 0:
# Два действительных корня
x1 = (-b + math.sqrt(D)) / (2 * a)
x2 = (-b - math.sqrt(D)) / (2 * a)
result_label.config(text=f"Два корня: x1 = {x1:.2f}, x2 = {x2:.2f}")
elif D == 0:
# Один корень
x = -b / (2 * a)
result_label.config(text=f"Один корень: x = {x:.2f}")
else:
# Нет действительных корней
result_label.config(text="Нет действительных корней")
except ValueError:
messagebox.showerror("Ошибка", "Введите корректные числовые значения!")
except ZeroDivisionError:
messagebox.showerror("Ошибка", "Коэффициент 'a' не может быть равен нулю!")

# Создание главного окна
root = tk.Tk()
root.title("Решение квадратного уравнения")

# Метки и поля ввода для коэффициентов a, b, c
label_a = tk.Label(root, text="Коэффициент a:")
label_a.grid(row=0, column=0, padx=10, pady=5)
entry_a = tk.Entry(root)
entry_a.grid(row=0, column=1, padx=10, pady=5)

label_b = tk.Label(root, text="Коэффициент b:")
label_b.grid(row=1, column=0, padx=10, pady=5)
entry_b = tk.Entry(root)
entry_b.grid(row=1, column=1, padx=10, pady=5)

label_c = tk.Label(root, text="Коэффициент c:")
label_c.grid(row=2, column=0, padx=10, pady=5)
entry_c = tk.Entry(root)
entry_c.grid(row=2, column=1, padx=10, pady=5)

# Кнопка для решения уравнения
solve_button = tk.Button(root, text="Решить", command=solve_quadratic)
solve_button.grid(row=3, column=0, columnspan=2, padx=10, pady=10)

# Метка для отображения результатов
result_label = tk.Label(root, text="Результат появится здесь")
result_label.grid(row=4, column=0, columnspan=2, padx=10, pady=10)

# Запуск основного цикла
root.mainloop()


Описание программы:


1. Основные элементы GUI:
• Поля ввода для коэффициентов a, b, c.
• Кнопка для запуска функции решения уравнения.
• Поле для вывода результата.

2. Функция решения уравнения:
Функция solve_quadratic() считывает введенные значения коэффициентов, вычисляет дискриминант, определяет количество корней, вычисляет их значения и выводит результат на экран.

3. Обработка ошибок:
Используются блоки try-except для обработки случаев некорректного ввода или деления на ноль.

Постоянный репозиторий по Python

22 Oct, 14:34


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

Как это работает:

Функция random.seed(a=None) инициализирует генератор случайных чисел начальным значением (seed). Если передать одно и то же значение в seed, последовательность “случайных” чисел будет каждый раз одинаковой.

Пример без фиксации начального значения:

import random

# Генерация 3 случайных чисел
for _ in range(3):
print(random.random())


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

Пример с фиксированным seed:

import random

random.seed(42) # Устанавливаем фиксированное значение начального состояния

# Генерация 3 "случайных" чисел
for _ in range(3):
print(random.random())


Если несколько раз запустить этот код с одинаковым seed (в данном случае 42), результат будет всегда одинаковым:

0.6394267984578837
0.025010755222666936
0.27502931836911926

Пример с использованием случайных целых чисел:

import random

random.seed(123)

# Генерация 3 случайных целых чисел в диапазоне от 1 до 100
for _ in range(3):
print(random.randint(1, 100))


Результат с фиксированным seed всегда будет одинаковым:

35
98



Случайное перемешивание списка:

import random

random.seed(10)

my_list = [1, 2, 3, 4, 5]
random.shuffle(my_list)
print(my_list)



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

[2, 3, 5, 4, 1]


Практическое применение фиксации случайности:

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

2. Репродуктивность экспериментов. В научных исследованиях или машинном обучении фиксирование случайности помогает другим исследователям воспроизвести результаты.

3. Отладка кода. Если программа ведет себя непредсказуемо из-за случайных данных, фиксация seed позволяет стабилизировать поведение программы на время отладки.

Постоянный репозиторий по Python

15 Oct, 06:23


Jinja — это мощный шаблонизатор, написанный на Python, который используется для генерации динамических HTML-страниц и других текстовых файлов. Он позволяет разработчикам отделять логику отображения данных от бизнес-логики, упрощая поддержку и развитие кода. Jinja часто используется в веб-разработке в сочетании с фреймворками, такими как Flask и Django, для создания удобных и гибких пользовательских интерфейсов.

Основные возможности Jinja

1. Переменные: Jinja позволяет передавать переменные из кода в шаблон, и эти переменные могут отображаться в HTML или других текстовых форматах. Например, если у вас есть список продуктов, вы можете передать его в шаблон и отобразить элементы этого списка на странице.

2. Циклы и условия: Jinja поддерживает базовую логику, такую как циклы (for) и условия (if). Это позволяет, например, динамически выводить данные, проверять условия и структурировать контент на странице в зависимости от переданных данных.

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

4. Наследование шаблонов: Jinja поддерживает наследование шаблонов, что позволяет создавать базовый шаблон с общими элементами (например, шапка и подвал), а затем расширять его на других страницах. Это упрощает обновление интерфейса и помогает поддерживать единый стиль на всех страницах.

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

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

2. Ускорение разработки: Благодаря возможности повторного использования шаблонов и встроенным инструментам, таким как фильтры и циклы, Jinja упрощает и ускоряет процесс разработки. С его помощью можно сократить количество кода и уменьшить дублирование.

3. Масштабируемость: Jinja позволяет легко добавлять новые страницы и функциональность в проект. Наследование шаблонов и возможность добавления пользовательских фильтров делает систему масштабируемой и легко адаптируемой к изменениям.

4. Интеграция с фреймворками: Jinja отлично интегрируется с популярными веб-фреймворками на Python, такими как Flask и Django, что делает его естественным выбором для создания серверной части веб-приложений. Использование Jinja в сочетании с фреймворками обеспечивает мощный и гибкий способ создания динамических веб-страниц.

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

Простой пример шаблона Jinja:

<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>{{ title }}</title>
</head>
<body>
<h1>{{ title }}</h1>
<ul>
{% for item in items %}
<li>{{ item }}</li>
{% endfor %}
</ul>
</body>
</html>


Этот шаблон будет генерировать HTML-страницу, которая отображает заголовок и список элементов. Переменные title и items передаются из Python-кода, и их значения будут вставлены в соответствующие места в шаблоне.

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

Постоянный репозиторий по Python

08 Oct, 06:46


Работа с памятью в Python в основном абстрагирована, поскольку управление памятью автоматически выполняется за счёт встроенного сборщика мусора. Однако, знание некоторых основ и инструментов может помочь лучше оптимизировать программы и избежать утечек памяти.

1. Сборщик мусора (Garbage Collector)

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

• Подсчёт ссылок: Каждый объект в Python имеет счётчик ссылок, который увеличивается при создании ссылки на объект и уменьшается при удалении. Когда счётчик достигает нуля, объект удаляется из памяти.
• Циклический сборщик: Он позволяет обнаруживать и освобождать циклические ссылки (например, когда два объекта ссылаются друг на друга).

Для взаимодействия со сборщиком мусора можно использовать модуль gc:

import gc

# Вызов сборщика мусора вручную
gc.collect()


2. Управление объектами

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

• Локальные переменные: Очищаются при завершении функции.
• Глобальные переменные: Остаются в памяти, пока программа работает.

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

3. Контекстные менеджеры

Использование контекстных менеджеров (with), позволяет точно контролировать время жизни объектов:

with open('file.txt', 'r') as f:
data = f.read()
# Файл автоматически закрывается и освобождается память


4. Управление крупными структурами данных

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

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

# Генератор
numbers = (x * x for x in range(1000000))


• Модуль array: Хранение чисел в массиве позволяет экономить память по сравнению с обычными списками:

from array import array
a = array('i', [1, 2, 3, 4])


• Модуль numpy: Для массивов чисел, если они используются в численных вычислениях, лучше использовать numpy, поскольку он использует более эффективное представление данных в памяти.

5. Проверка и профилирование памяти

Для анализа использования памяти можно использовать специальные модули:

• sys.getsizeof(): Позволяет узнать, сколько памяти занимает объект.

import sys
a = [1, 2, 3, 4]
print(sys.getsizeof(a))


• Модуль memory_profiler: Показывает потребление памяти, позволяя найти узкие места.

pip install memory_profiler


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

from memory_profiler import profile

@profile
def my_func():
a = [i for i in range(100000)]
return a

my_func()


6. Модуль weakref

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

import weakref

class MyClass:
pass

obj = MyClass()
r = weakref.ref(obj)
print(r()) # Выводит объект
del obj
print(r()) # Выводит None, так как объект удалён


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

Постоянный репозиторий по Python

02 Oct, 07:02


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

1. Изменяемые объекты:
Это объекты, состояние которых может изменяться после их создания. При изменении объекта его идентификатор (ID) остаётся тем же, хотя содержимое меняется.
Примеры изменяемых объектов:
• Списки (list): вы можете добавлять или удалять элементы.
• Множества (set): можно добавлять и удалять элементы.
• Словари (dict): можно изменять значения по ключам, добавлять новые пары ключ-значение.
• Пользовательские объекты классов, если они не используют методы, которые делают их поведение неизменяемым.

my_list = [1, 2, 3]
print(id(my_list)) # Выводит идентификатор объекта
my_list.append(4)
print(my_list) # Список изменился: [1, 2, 3, 4]
print(id(my_list)) # Идентификатор остался тем же


2. Неизменяемые объекты:
Это объекты, которые не могут быть изменены после их создания. Любые операции, которые, казалось бы, изменяют объект, на самом деле создают новый объект с изменённым значением.
Примеры неизменяемых объектов:
• Числа (int, float, complex)
• Строки (str)
• Кортежи (tuple)
• Фроузенсеты (frozenset)

my_string = "Hello"
print(id(my_string)) # Идентификатор строки
my_string += " World"
print(my_string) # Строка изменилась: "Hello World"
print(id(my_string)) # Идентификатор изменился, т.к. создан новый объект


Особенности работы с изменяемыми и неизменяемыми объектами:

• Присваивание неизменяемых объектов:
Когда вы присваиваете новое значение неизменяемому объекту, на самом деле создаётся новый объект, и переменная начинает ссылаться на него.

x = 10
print(id(x)) # Идентификатор объекта, на который ссылается x
x = 20
print(id(x)) # Идентификатор изменился, т.к. создан новый объект


• Присваивание изменяемых объектов:
Если вы присваиваете изменяемый объект другой переменной, обе переменные будут ссылаться на один и тот же объект. Любые изменения, внесённые через одну переменную, отразятся и на другой.

a = [1, 2, 3]
b = a
b.append(4)
print(a) # [1, 2, 3, 4], объект изменился


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

Сложности, возникающие при работе с изменяемыми и неизменяемыми объектами

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

def modify_list(my_list):
my_list.append(4)

a = [1, 2, 3]
modify_list(a)
print(a) # [1, 2, 3, 4], список изменился


Для избегания этого эффекта можно передавать копию списка:

modify_list(a[:])


2. Использование изменяемых объектов как значений по умолчанию:
В Python значения по умолчанию для параметров функции вычисляются один раз при её определении, а не каждый раз при вызове. Это приводит к тому, что если использовать изменяемый объект (например, список) в качестве значения по умолчанию, то изменения, внесённые в одном вызове функции, будут сохранены и для следующих вызовов.

def add_to_list(value, my_list=[]):
my_list.append(value)
return my_list

print(add_to_list(1)) # [1]
print(add_to_list(2)) # [1, 2], а не [2]!


Это можно исправить, установив значение по умолчанию в None, а затем инициализировать список внутри функции:

def add_to_list(value, my_list=None):
if my_list is None:
my_list = []
my_list.append(value)
return my_list


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

Постоянный репозиторий по Python

24 Sep, 07:16


Сэнки-диаграмма (или Sankey diagram) – это визуализация потоков, показывающая, как ресурсы, энергия, деньги или другие объекты перетекают из одного состояния в другое. Основные особенности диаграммы:

1. Ширина стрелок (линий) пропорциональна объему потока между элементами.
2. Элементы (обычно узлы) представляют собой источники или получатели потоков.
3. Стрелки показывают направления потока между элементами.

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

Как строить сэнки-диаграмму в Python

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

Установка библиотеки Plotly

Если библиотека plotly еще не установлена, то ее можно установить с помощью следующей команды:

pip install plotly


Пример построения сэнки-диаграммы

import plotly.graph_objects as go

# Определим узлы (nodes) и потоки (links)
nodes = {
"label": [
"Источник A", # Номер 0
"Источник B", # Номер 1
"Источник C", # Номер 2
"Получатель X", # Номер 3
"Получатель Y", # Номер 4
"Получатель Z", # Номер 5
]
}

# Определяем связи между узлами
links = {
"source": [0, 1, 2, 0, 1, 2], # Источники
"target": [3, 3, 4, 4, 5, 5], # Получатели
"value": [8, 4, 2, 8, 4, 2] # Значения потоков
}

# Создаем объект Sankey диаграммы
fig = go.Figure(go.Sankey(
node=nodes,
link=links
))

# Отображаем диаграмму
fig.show()


Пояснения к коду:

1. nodes[“label”] – это список имен узлов, например, источников и получателей. Каждый узел идентифицируется своим индексом.
2. links[“source”] – это список источников потоков (индексы узлов).
3. links[“target”] – это список получателей потоков (индексы узлов).
4. links[“value”] – это список значений потоков, определяющий ширину линий.

Результат:

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

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

Постоянный репозиторий по Python

18 Sep, 07:53


Доверительный интервал (Confidence Interval) — это диапазон значений, который с определённой вероятностью включает истинное значение оцениваемого параметра. В статистике чаще всего используется доверительный интервал для среднего значения выборки или для разницы средних двух выборок.

Расчет доверительного интервала обычно осуществляется на основе среднего значения выборки и стандартной ошибки.

Пример расчета доверительного интервала в Python:

import numpy as np
import scipy.stats as stats

# Параметры выборки
data = np.array([12, 15, 14, 10, 13, 15, 14, 13, 16, 11])
confidence = 0.95 # уровень доверия 95%

# Среднее значение и стандартное отклонение
mean = np.mean(data)
std_err = stats.sem(data) # стандартная ошибка среднего

# Определение границ доверительного интервала
h = std_err * stats.t.ppf((1 + confidence) / 2., len(data)-1)
ci_lower = mean - h
ci_upper = mean + h

print(f"Доверительный интервал: ({ci_lower}, {ci_upper})")



P-value и уровень значимости
P-value — это вероятность получить значение статистики теста, равное или более экстремальное, чем наблюдаемое значение, при условии, что нулевая гипотеза верна. Если p-value меньше уровня значимости (\alpha), нулевая гипотеза отвергается.

Уровень значимости (\alpha) обычно выбирается 0.05 или 0.01. Это означает, что вероятность случайного получения результата менее экстремального равна 5% или 1% соответственно.

Пример расчета p-value в Python:

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

import numpy as np
from scipy import stats

# Данные выборки
data = np.array([12, 15, 14, 10, 13, 15, 14, 13, 16, 11])

# Гипотетическое среднее значение (например, среднее = 12)
mu = 12

# t-тест
t_stat, p_value = stats.ttest_1samp(data, mu)

print(f"t-статистика: {t_stat}")
print(f"p-value: {p_value}")

# Уровень значимости (например, 5%)
alpha = 0.05

if p_value < alpha:
print("Нулевая гипотеза отвергается.")
else:
print("Нулевая гипотеза не отвергается.")


Объяснение:

1. t-тест проверяет, отличается ли среднее значение выборки от заданного значения (в данном случае 12).
2. p-value показывает вероятность того, что разница между выборочным средним и гипотетическим средним возникла случайно.
3. Если p-value меньше уровня значимости, нулевая гипотеза отвергается, и считается, что средние значения значимо отличаются.
Таким образом, с помощью Python можно вычислить как доверительные интервалы, так и p-value для различных статистических тестов.

Постоянный репозиторий по Python

12 Sep, 11:47


🥳 С днём программиста!

Сегодня мы поздравляем всех программистов с их профессиональным праздником! Ваша работа важна и ценна для развития информационных технологий и общества в целом.

В этот день мы хотим пожелать вам вдохновения, новых идей и успешных проектов. Пусть каждый ваш код будет чистым и эффективным, а проекты — успешными и востребованными 👍

❗️Также хотим напомнить, что в АИС вы найдёте множество разнообразных курсов, которые помогут вам развиваться и повышать свою квалификацию. Особое внимание мы рекомендуем обратить на курсы по разработке ПО.

Почему именно эти курсы?
Потому что АИС предлагает широкий спектр курсов по разработке ПО:
разработка на С, С++;
разработка на JAVA;
разработка на Python;
разработка Web приложений.

👍 Курсы в АИС позволят вам освоить востребованные языки программирования и технологии, необходимые для успешной карьеры в IT.

➡️ Запишитесь на курсы по разработке ПО уже сегодня и откройте для себя новые горизонты в мире программирования.

Постоянный репозиторий по Python

10 Sep, 11:53


Работа со случайными величинами в Python может быть реализована с использованием модуля random (для простых псевдослучайных операций) и модуля numpy.random (для более сложных операций, таких как генерация случайных чисел для различных распределений).

1. Использование модуля random

Модуль random предоставляет простые функции для работы со случайными величинами. Вот несколько примеров:

a. Генерация случайного целого числа в заданном диапазоне

import random

# Случайное целое число от 1 до 10
random_integer = random.randint(1, 10)
print(f"Случайное целое число: {random_integer}")


b. Случайное вещественное число

# Случайное вещественное число в диапазоне от 0 до 1
random_float = random.random()
print(f"Случайное вещественное число: {random_float}")


c. Выбор случайного элемента из списка

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

# Случайный выбор элемента из списка
random_choice = random.choice(my_list)
print(f"Случайный выбор из списка: {random_choice}")


d. Перемешивание элементов списка

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

# Перемешиваем элементы списка
random.shuffle(my_list)
print(f"Перемешанный список: {my_list}")


e. Случайное вещественное число в диапазоне

# Случайное вещественное число в диапазоне от 5 до 15
random_float_range = random.uniform(5, 15)
print(f"Случайное вещественное число в диапазоне от 5 до 15: {random_float_range}")


2. Работа с модулем numpy.random

Если вам нужно сгенерировать случайные величины для специфических распределений (например, нормального или экспоненциального), вы можете использовать модуль numpy.random.

a. Случайные числа из равномерного распределения

import numpy as np

# Генерация 5 случайных чисел из равномерного распределения [0, 1)
random_uniform = np.random.rand(5)
print(f"Случайные числа из равномерного распределения: {random_uniform}")


b. Случайные числа из нормального (гауссовского) распределения

# Генерация 5 случайных чисел из нормального распределения (среднее 0, стандартное отклонение 1)
random_normal = np.random.randn(5)
print(f"Случайные числа из нормального распределения: {random_normal}")


c. Генерация случайных целых чисел

# Генерация случайных целых чисел в диапазоне от 10 до 20 (исключительно)
random_integers = np.random.randint(10, 20, size=5)
print(f"Случайные целые числа: {random_integers}")


d. Случайные числа из любого распределения

# Генерация случайных чисел из нормального распределения с заданным средним и стандартным отклонением
mu, sigma = 0, 0.1 # Среднее и стандартное отклонение
random_normal_dist = np.random.normal(mu, sigma, 1000)

print(f"Пример случайных чисел из нормального распределения: {random_normal_dist[:10]}")


3. Фиксация начального значения генератора случайных чисел (Seed)

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

random.seed(42)  # Для модуля random
np.random.seed(42) # Для модуля numpy.random


Теперь генератор будет выдавать одну и ту же последовательность случайных чисел

Модуль random хорошо подходит для простых задач генерации случайных чисел, в то время как numpy.random предоставляет более мощные инструменты для работы с различными распределениями и большими наборами данных.