Шпаргалка по 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/

👉

Что такое хуки? Как они используются в Python?

Хуки (hooks) в программировании — это специальные точки в коде, в которые можно «вклиниться», чтобы изменить или расширить поведение программы без модификации её исходного кода. Хуки позволяют добавлять дополнительную логику или выполнять нужные действия, когда происходят определенные события.


⚫️Как хуки используются в Python?

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

1. Тестовые фреймворки (например, pytest):
В тестовом фреймворке pytest есть хуки для настройки и завершения тестов. Вы можете создать функции, которые будут выполняться до начала тестов (`pytest_runtest_setup`) или после их завершения (`pytest_runtest_teardown`). Это удобно для создания и очистки тестовой среды.

   # Пример hook-функции в pytest
   def pytest_runtest_setup(item):
       print(f"Setting up for test: {item.name}")
   

2. Веб-фреймворки (например, Django):
В Django хуки используются для расширения поведения, например, перед или после сохранения объекта. Так, у моделей Django есть хуки pre_save и post_save, которые позволяют выполнять код до и после сохранения объекта в базе данных.

   from django.db.models.signals import pre_save
   from django.dispatch import receiver
   from .models import MyModel

   (pre_save, sender=MyModel)
   def my_hook(sender, instance, **kwargs):
       print("This runs before saving MyModel instance.")
   

3. Flask (перед/после обработки запроса):
Flask имеет хуки before_request и after_request, которые позволяют выполнить код до обработки HTTP-запроса или после отправки ответа.

   from flask import Flask

   app = Flask(__name__)

   .before_request
   def before_request_func():
       print("This runs before each request")

   .after_request
   def after_request_func(response):
       print("This runs after each request")
       return response
   

4. Логирование и обработка ошибок:
Встроенный модуль logging в Python поддерживает хуки для настраиваемой обработки логов, например, через методы addFilter или создание своих обработчиков (`handlers`), чтобы настроить кастомное поведение логирования.

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

👉

Что такое «сырые» строки (Raw Strings) в Python?

В Python "сырые" строки (или **raw strings**) — это строки, в которых символы обратного слэша \ воспринимаются буквально, а не как специальные символы (например, \n для новой строки, \t для табуляции и т. д.). Они обозначаются префиксом r перед строкой, например: r"строка".

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

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

# Обычная строка
print("C:\\new_folder\\file.txt")  # Выводит: C:\new_folder\file.txt

# Сырая строка
print(r"C:\new_folder\file.txt")   # Выводит: C:\new_folder\file.txt

В первом случае \\ используется для экранирования, чтобы Python не воспринял \n как символ новой строки. В случае сырой строки r"...", экранирование не нужно, так как \ воспринимается буквально.

👉

Типизация в Python

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

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

def find_max(numbers: List[int]) -> int:
    if not numbers:
        raise ValueError(“Список пуст”)
    max_value: int = numbers[0]
    for num in numbers:
        if num > max_value:
            max_value = num
    return max_value

https://telegra.ph/Tipizaciya-v-Python-11-01

👉

Самый быстрый способ чтения Excel в Python: чтение 500 тысяч строк менее чем за 4 секунды

У меня нет данных, чтобы подтвердить это утверждение, но я почти уверен, что Excel — самый распространённый способ хранения, обработки и, да(!), даже передачи данных. Именно поэтому нередко приходится работать с Excel в Python. Недавно мне понадобилось это сделать, и я протестировал и оценил несколько способов чтения файлов Excel в Python.

https://hakibenita.com/fast-excel-python#results-summary

👉

Техническое собеседование на позицию Python Junior

источник

👉

Поиск самой быстрой JSON-библиотеки на Python (8 сравнений)

Большинство тестов производительности, подобных этому, включают всего четыре библиотеки JSON: обычно стандартную библиотеку JSON, orjson, ujson и rapidjson. Однако, благодаря моему максималистскому подходу, я решил пойти гораздо дальше и найти все библиотеки JSON, которые так или иначе можно использовать, и протестировать их. Таким образом я обнаружил некоторых «новых игроков», таких как cysimdjson, yapic.json и pysimdjson.

orjson: ijl/orjson
pysimdjson: TkTech/pysimdjson
yapic.json: zozzz/yapic.json
simplejson: simplejson/simplejson
ujson: ultrajson/ultrajson
python-rapidjson: python-rapidjson/python-rapidjson
cysimdjson: TeskaLabs/cysimdjson
nujson (deprecated): caiyunapp/ultrajson

https://catnotfoundnear.github.io/finding-the-fastest-python-json-library-on-all-python-versions-8-compared.html

👉

Декораторы Python: пошаговое руководство

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

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

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

Сюда входит:
- журналирование,
- обеспечение контроля доступа и аутентификации,
- инструментарий и функции управления временем,
- ограничение скорости,
- кэширование и многое другое.

Rus https://habr.com/ru/companies/otus/articles/727590/

Eng https://dbader.org/blog/python-decorators

👉

Python 3.13, что не попало в заголовки

Python 3.13 — отличный релиз, полный различных фич и улучшений, но уже есть тонна статей, которые подробно разбирают release notes. Если вам нужна хорошая выжимка — у RealPython есть хорошая статья, но я не вижу смысла проходиться по ним еще раз в этой статье.

Так что мы не будем говорить про новый REPL, no‑GIL сборку, экспериментальный JIT‑компилятор, устаревшие штуки, новые плюшки системы типов или улучшенные сообщения об ошибках (как всегда, мое любимое).

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

https://habr.com/ru/companies/beget/articles/856288/

original https://www.bitecode.dev/p/python-313-what-didnt-make-the-headlines

👉

Зачем нужен pdb?

pdb (Python Debugger) — это встроенный отладчик Python, который помогает разработчикам находить и исправлять ошибки в коде. С помощью pdb можно управлять выполнением программы шаг за шагом, просматривать и изменять значения переменных, устанавливать точки останова и диагностировать причину ошибок. Вот основные функции и задачи pdb:

Основные возможности pdb:
1. Точки останова (breakpoints): Можно установить точку в коде, где выполнение программы остановится, чтобы проверить текущее состояние переменных и выполнения.

   import pdb; pdb.set_trace()  # Остановка программы в этом месте
   

2. Шаговое выполнение кода:
- n (next) — Выполняет следующую строку кода.
- s (step) — Переходит внутрь функции, если строка кода — это вызов функции.
- c (continue) — Продолжает выполнение до следующей точки останова.

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

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

5. Динамическое изменение кода:
- Во время отладки можно изменять значения переменных, что помогает тестировать различные сценарии и предположения прямо во время выполнения программы.

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

import pdb

def divide(a, b):
    pdb.set_trace()  # Остановка для проверки переменных
    return a / b

result = divide(10, 0)
print(result)

Этот пример вызовет ошибку деления на ноль, и отладчик pdb остановится перед ошибкой, что позволит просмотреть значения a и b.

Когда использовать pdb
- Для диагностики сложных ошибок, которые трудно отследить с помощью обычных print() или logging.
- При разработке и тестировании сложных функций или алгоритмов.
- В ситуациях, когда необходимо детально понять, почему код работает не так, как ожидалось.

pdb — мощный инструмент, который помогает программистам эффективно находить ошибки и улучшать качество кода.

👉