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

В 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 позволяет стабилизировать поведение программы на время отладки.

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 в основном абстрагирована, поскольку управление памятью автоматически выполняется за счёт встроенного сборщика мусора. Однако, знание некоторых основ и инструментов может помочь лучше оптимизировать программы и избежать утечек памяти.

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 объекты можно разделить на изменяемые и неизменяемые, и это одно из ключевых понятий, которое влияет на то, как ведет себя код. Рассмотрим подробнее, что это означает, и какие сложности могут возникнуть.

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 является мощным инструментом, который может значительно повлиять на производительность и поведение программы. Однако она требует осторожности, особенно при работе с изменяемыми объектами, передаче их в функции и использовании в качестве значений по умолчанию. Понимание этого механизма поможет избежать распространённых ошибок и более эффективно использовать возможности языка.

Сэнки-диаграмма (или 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”] – это список значений потоков, определяющий ширину линий.

Результат:

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

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

Доверительный интервал (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 для различных статистических тестов.

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

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

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

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

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

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

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

Работа со случайными величинами в 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 предоставляет более мощные инструменты для работы с различными распределениями и большими наборами данных.