Модуль fractions для работы с дробями

Создать рациональное число можно через Fraction() из пары целых чисел, другого рационального числа или строки. Numerator — это числитель, а denominator — знаменатель. По умолчанию numerator=0, denominator=1.

Целые и вещественные числа Python можно преобразовать в дробь, передав их Fraction().

С модулем fractions устраняются проблемы с ошибками представления, возникающие в числах с плавающей точкой.

👉

Более эффективный метод объединения строк

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

Дело в том, что строки — неизменяемые объекты в Python. Это означает, что каждый раз при конкатенации вы создаёте новую строку с объединённым содержимым.

Более экономно по памяти и быстрее будет использовать метод join() для списков. При вызове он создаёт единственную строку.

👉

Операции над множествами в Python

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

Примеры основных операций над множествами в Python:

Создание множества

a = {1, 2, 3, 4}
b = {3, 4, 5, 6}

Объединение множеств (union)
Объединение возвращает множество, содержащее все элементы обоих множеств.

c = a.union(b)
# или можно использовать оператор |
c = a | b
print(c)  # {1, 2, 3, 4, 5, 6}

Пересечение множеств (intersection)
Пересечение возвращает множество, содержащее только общие элементы двух множеств.

c = a.intersection(b)
# или можно использовать оператор &
c = a & b
print(c)  # {3, 4}

Разность множеств (difference)
Разность возвращает множество, содержащее элементы, которые находятся только в одном множестве.

c = a.difference(b)
# или можно использовать опера

...

Что делает класс ChainMap() модуля collections

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

Лучше всего посмотреть на примере:

d1 = dict(a=1, b=3)
d2 = dict(a=2, b=4, c=6)

from collections import ChainMap

chain = ChainMap(d1, d2)
print(chain['a']) # -> 1
print(chain['c']) # -> 6


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

Обновление или вставка в ChainMap затрагивают только первый входной словарь. Снова посмотрим на примере:

chain['c'] = -1
print(d1) # -> {'a': 1, 'b': 3, 'c': -1}
print(d2) # -> {'a': 2, 'b': 4, 'c': 6}

👉

Большая обновлённая шпаргалка по Python для начинающих

👉

Создайте мессенджер с помощью Django (за 6 минут) 🌮

0:00 Showing the final product
0:22 Setup Django and Daphne
1:08 Add async and sync views
2:09 Add templates with EventSource
2:52 Explaining how the chat works
3:35 Explaining how sending a message works
4:19 Create models to store data
4:25 Run our server
4:42 Visit our real-time chat app
5:28 Add styling to improve UI
6:00 Benefits and mailing list for more free content

источник

👉

Ускоряем работу python с numba

Numba — это Just-In-Time компилятор, который превращает ваш код на питоне в машинный код на лету. Это не просто мелкая оптимизация, а серьёзно ускорение.

Если вы знакомы с интерпретируемыми языками, вы знаете, что они обычно медленнее компилируемых из-за необходимости анализировать и исполнять код на лету. Но что, если бы вы могли получить лучшее из обоих миров? JIT-компиляция позволяет интерпретируемому языку, каким является питон, динамически компилировать части кода в машинный код, значительно ускоряя исполнение.

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

https://habr.com/ru/companies/otus/articles/784068/

👉

Что делает функция seed() модуля random

Функция seed() в модуле random в Python используется для инициализации генератора случайных чисел. По умолчанию генератор случайных чисел использует текущее системное время, чтобы генерировать случайные числа, но если задать определённое значение с помощью функции seed(), последовательность случайных чисел станет предсказуемой.

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

import random

random.seed(10)
print(random.random())  # Всегда будет генерировать одно и то же число

Основные моменты:
- Если вызвать random.seed() с одним и тем же значением несколько раз, генератор будет создавать одну и ту же последовательность случайных чисел.
- Если seed() не вызывается или вызывается без аргументов, генерация случайных чисел будет происходить на основе текущего времени или другого системного источника.

Таким образом, использование seed() полезно, когда требуется воспроизвести результаты, например, в тестах или для отладки.

👉

Шпаргалка по Python. Часть 2


7. Работа с исключениями

#### Множественные исключения:

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

#### Создание своих исключений:

class MyCustomError(Exception):
    pass

raise MyCustomError("This is a custom error")

8. Операции с числами и математикой

#### Округление и точные вычисления:

import decimal
from decimal import Decimal

decimal.getcontext().prec = 4
x = Decimal('1.12345')
y = Decimal('3.14159')
print(x * y)  # Результат с 4 знаками после запятой

#### Математические операции:

import math

print(math.sqrt(16))  # 4.0
print(math.factorial(5))  # 120

9. Модули и пакеты

#### Импортирование модулей:

from my_module import my_function

my_function()

#### Динамический импорт:

module_name = 'math'
module = __import__(module_name)
print(module.sqrt(16))  # 4.0

10. Тестирование

#### Unittest:

import unittest

def add(a, b):
    return a + b

class TestMath(unittest.TestCase):
    def test_add(self):
        self.assertEqual(add(2, 3), 5)

if __name__ == '__main__':
    unittest.main()

#### Pytest:

def add(a, b):
    return a + b

def test_add():
    assert add(2, 3) == 5

11. Работа с данными и библиотеками

#### NumPy для работы с массивами:

import numpy as np

a = np.array([1, 2, 3])
print(a * 2)  # Умножение каждого элемента массива на 2

#### Pandas для работы с табличными данными:

import pandas as pd

data = {'Name': ['Alice', 'Bob'], 'Age': [25, 30]}
df = pd.DataFrame(data)
print(df)

12. Полезные утилиты

- Enumerate для индексации:

  for index, value in enumerate(['a', 'b', 'c']):
      print(index, value)
  

- Zip для объединения списков:

  names = ['Alice', 'Bob']
  ages = [25, 30]
  for name, age in zip(names, ages):
      print(f"{name} is {age} years old")
  

- Comprehensions для работы со сложными структурами данных:

  matrix = [[i * j for j in range(5)] for i in range(5)]
  

👉

Как разрабатывать (и как не разрабатывать) REST API

За свою карьеру я использовал сотни REST API и создал десятки. Поскольку я часто вижу одни и те же ошибки, повторяющиеся при проектировании API, я подумал, что было бы неплохо написать набор лучших практик. И посмеяться над парой широко используемых API.
Многое из этого может быть «само собой разумеющимся», но, возможно, есть несколько правил, о которых вы еще не задумывались.
Без особого порядка...

Правило №0: НЕ будьте педантичным.
Правило №1: ИСПОЛЬЗУЙТЕ существительные во множественном числе для коллекций.
Правило №2: НЕ добавляйте ненужные сегменты пути.
Правило №3: НЕ добавляйте .json или другие расширения в URL.
Правило №4: НЕ возвращайте массивы как верхнеуровневые ответы.
Правило №5: НЕ возвращайте структуры карт (map).
Правило №6: ИСПОЛЬЗУЙТЕ строки для всех идентификаторов.
Правило №7: ДОБАВЛЯЙТЕ префикс к вашим идентификаторам.
Правило №8: НЕ используйте 404 для указания «не найдено».
Правило №9: БУДЬТЕ последовательными.
Правило №10: ИСПОЛЬЗУЙТЕ структурированный формат ошибок.
Правило №11: ПРЕДОСТАВЛЯЙТЕ механизмы идемпотентности.
Правило №12: ИСПОЛЬЗУЙТЕ строки ISO8601 для отметок времени.

https://github.com/stickfigure/blog/wiki/How-to-(and-how-not-to)-design-REST-APIs

👉

Расскажите про области видимости переменных в Python

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

1. Local (локальная область):
- Это переменные, определённые внутри функции. Они доступны только в пределах этой функции.
- Пример:

     def my_function():
         x = 10  # локальная переменная
         print(x)
     
     my_function()  # выведет 10
     # print(x)  # ошибка, переменная x не существует за пределами функции
     

2. Enclosing (охватывающая область):
- Переменные, определённые в функциях внешнего уровня по отношению к вложенным функциям. Эти переменные доступны вложенным функциям.
- Пример:

     def outer_function():
         x = 5
         def inner_function():
             print(x)  # доступ к переменной из охватывающей области
         inner_function()
     
     outer_function()  # выведет 5
     

3. Global (глобальная область):
- Это переменные, определённые на уровне модуля, вне каких-либо функций. Они доступны во всём модуле.
- Чтобы изменить глобальную переменную внутри функции, нужно использовать ключевое слово global.
- Пример:

     x = 20  # глобальная переменная

     def my_function():
         global x
         x = 10  # изменение глобальной переменной
     
     my_function()
     print(x)  # выведет 10
     

4. Built-in (встроенная область):
- Это встроенные в Python функции и имена, такие как len(), sum(), print() и другие. Эти имена доступны в любой точке программы.
- Пример:

     print(len([1, 2, 3]))  # использует встроенную функцию len
     

Правила поиска переменной (LEGB)

Когда вы обращаетесь к переменной, Python ищет её значение в следующем порядке:
1. Local: Ищет в локальной области.
2. Enclosing: Ищет в охватывающей области, если функция вложена.
3. Global: Ищет среди глобальных переменных модуля.
4. Built-in: Ищет среди встроенных имён.

Таким образом, Python будет использовать ближайшую переменную в соответствии с этим порядком.

👉

Сборник вопросов и ответов для собеседования по Python

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

👉

Функции как объекты в Python

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

Рассмотрим основные аспекты использования функций как объектов:

1. Присваивание функции переменной
Вы можете присвоить функцию переменной и вызывать её через эту переменную.

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

say_hello = greet  # присваиваем функцию переменной
print(say_hello("Alice"))  # вызов через переменную

2. Передача функции в качестве аргумента
Функцию можно передать как аргумент другой функции.

def apply_function(func, value):
    return func(value)

def square(x):
    return x ** 2

result = apply_function(square, 5)
print(result)  # вывод: 25

3. Возврат функции из другой функции
Функция может возвращать другую функцию.

def make_multiplier(factor):
    def multiplier(x):
        return x * factor
    return multiplier

double = make_multiplier(2)
print(double(5))  # вывод: 10

4. Хранение функций в структурах данных
Функции можно хранить в списках, словарях и других структурах данных.

def add(x, y):
    return x + y

def subtract(x, y):
    return x - y

operations = {
    'add': add,
    'subtract': subtract
}

print(operations['add'](10, 5))  # вывод: 15
print(operations['subtract'](10, 5))  # вывод: 5

5. Анонимные функции (lambda)
Вы можете создавать функции "на лету" с помощью выражения lambda.

multiply = lambda x, y: x * y
print(multiply(3, 4))  # вывод: 12

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

👉

Статистика на примерах с Python #1

Содержание:
1.1 Общая информация
1.2 Генеральная совокупность и выборка
1.3 Типы переменных. Количественные и номинативные переменные
1.4 Меры центральной тенденции

https://habr.com/ru/articles/786760/

👉

Как правильно структурировать Python-проект

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

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

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

https://docs.python-guide.org/writing/structure/

👉

Параллелизм в Python с помощью FastAPI

Давайте погрузимся в эту тему с помощью нового крутого фреймворка ASGI, FastAPI. Это concurrent framework, что означает asyncio-friendly. Тианголо, автор, утверждает, что производительность находится на одном уровне с веб-серверами Go и Node.

https://horaceguy.pages.dev/posts/python-concurrency/

👉

PikaScript

Ультралегкий интерпретатор Python, работающий всего с 4 КБ оперативной памяти, с нулевыми зависимостями. Он готов к использованию из коробки, не требует конфигурации и легко расширяется с помощью языка C. Похожие проекты: MicroPython, JerryScript.

Все это позволяет вам программировать на языке Python даже для самых маломощных микроконтроллеров семейства STM32

https://github.com/pikasTech/PikaPython

👉

Справочник по Django
Django Software Foundation (2024)

👉

Сравнение производительности dict() и {} в Python

Какое-то время назад, во время разбора кода, мы обсудили выбор dict() вместо {} в новом коде на Python. Коллега утверждал, что dict() более читаем и чётче выражает предназначение кода, поэтому следует предпочесть его. Меня это не убедило, но в тот момент контраргументов не нашлось, поэтому я воздержался.

Это заставило меня задуматься: в чём разница между типом dict и литеральным выражением {}?


https://habr.com/ru/articles/788440/

original https://madebyme.today/blog/python-dict-vs-curly-brackets/

👉