Как встроены внутренние библиотеки в Python?

Встроенные библиотеки Python: архитектура и механизмы

Встроенные (built-in) библиотеки Python — это не просто код на Python, а сложная система, состоящая из компонентов на Python, C и других языков. Разберёмся в архитектуре.

1. Типы встроенных библиотек

1.1 Pure Python библиотеки

# Написаны полностью на Python
import json
import collections
import itertools

# Можно посмотреть исходный код
import inspect
print(inspect.getsourcefile(json))
# /usr/lib/python3.9/json/__init__.py

# Посмотреть реализацию функции
print(inspect.getsource(json.dumps))

1.2 C-extensions

# Написаны на C для производительности
import sys
import pickle
import sqlite3

# C-расширения не имеют исходного кода Python
try:
    print(inspect.getsource(pickle.loads))
except TypeError:
    print("C extension - no source available")

1.3 Гибридные библиотеки

# Сочетание Python + C
import os
import datetime

# os содержит как Python-функции, так и C-обёртки
print(type(os.path.exists))  # <class 'builtin_function_or_method'>

2. Где хранятся встроенные библиотеки

import sys

# sys.prefix указывает на корень Python
print(sys.prefix)
# /usr (или /usr/local, или путь виртуального окружения)

# Стандартные библиотеки находятся в:
print(sys.base_prefix)  # /usr

# Посмотреть все пути поиска модулей
for path in sys.path:
    print(path)

# Типичный результат:
# /home/user/project (текущая директория)
# /usr/lib/python3.9
# /usr/lib/python3.9/lib-dynload
# /usr/local/lib/python3.9/site-packages

3. Структура Python Standard Library

/usr/lib/python3.9/
├── builtins.py              # Встроенные типы (len, str, int)
├── json/
│   ├── __init__.py          # json.dumps(), json.loads()
│   ├── encoder.py           # JSONEncoder класс
│   ├── decoder.py           # JSONDecoder класс
│   └── tool.py              # CLI утилита
├── collections/
│   ├── __init__.py
│   ├── abc.py               # Abstract base classes
│   └── defaultdict.py       # Реализации
├── sqlite3.py               # Pure Python обёртка
└── lib-dynload/             # Скомпилированные C расширения
    ├── _sqlite3.cpython-39-x86_64-linux-gnu.so
    ├── _json.cpython-39-x86_64-linux-gnu.so
    ├── _ssl.cpython-39-x86_64-linux-gnu.so
    └── ...

4. Встроенные функции (builtins)

# Встроенные функции находятся в специальном модуле
import builtins

print(dir(builtins))
# ['ArithmeticError', 'AssertionError', ..., 'len', 'list', 'map', ...]

# Это C-функции, скомпилированные в интерпретатор
print(type(len))  # <class 'builtin_function_or_method'>
print(type(int))  # <class 'type'>

# Каждый объект имеет встроенные методы
my_list = [1, 2, 3]
print(type(my_list.append))  # <class 'builtin_function_or_method'>

# Посмотреть сигнатуру
help(len)
# Help on built-in function len in module builtins:
# len(obj, /)
#     Return the length of an object.

5. Как Python импортирует встроенные модули

# 1. При импорте, Python проверяет sys.modules (кэш)
import sys
import os

print('os' in sys.modules)  # True - уже загружен

# 2. Если не найден в кэше, Python ищет в sys.path
import importlib.util
spec = importlib.util.find_spec('json')
print(spec.origin)  # /usr/lib/python3.9/json/__init__.py

# 3. Для C-расширений, Python загружает .so файл
spec = importlib.util.find_spec('_json')
print(spec.origin)  # /usr/lib/python3.9/lib-dynload/_json.cpython-39-x86_64-linux-gnu.so

6. Встроенные типы данных

# Встроенные типы - это C-структуры

# list
my_list = [1, 2, 3]
print(type(my_list))  # <class 'list'>
print(my_list.__class__.__bases__)  # (object,)

# dict
my_dict = {"key": "value"}
print(isinstance(my_dict, dict))  # True

# Всё наследуется от object (главный базовый класс)
print(isinstance(my_list, object))  # True

# Встроенные методы магических объектов
print(dir(my_list))
# [..., '__add__', '__contains__', '__delitem__', '__eq__', ..., 'append', 'clear', 'copy', ...]

7. sys модуль - доступ к интерпретатору

import sys

# Версия Python
print(sys.version)  # 3.9.7 (default, Sep 16 2021, 13:09:58)

# Размер объекта в памяти
print(sys.getsizeof([]))      # 56 bytes
print(sys.getsizeof([1, 2]))  # 64 bytes

# Счётчик ссылок (reference count)
x = [1, 2, 3]
print(sys.getrefcount(x))  # 2 (сама переменная + аргумент getrefcount)

# Рекурсия
print(sys.getrecursionlimit())  # 1000
sys.setrecursionlimit(2000)

# Информация о платформе
print(sys.platform)  # linux
print(sys.executable)  # /usr/bin/python3

8. os модуль - системные вызовы

import os

# Переменные окружения
print(os.environ['PATH'])
print(os.getenv('USER'))  # Безопаснее

# Работа с путями
print(os.getcwd())  # Текущая директория
print(os.path.exists('file.txt'))
print(os.path.join('/home', 'user', 'file.txt'))

# Системные вызовы (обёртка вокруг libc)
os.mkdir('/tmp/test')  # Системный вызов mkdir()
os.remove('/tmp/test')  # Системный вызов unlink()

# Информация о системе
print(os.uname())  # posix.uname_result(sysname='Linux', ...)

9. Встроенный интерпретатор кода

# compile() и exec() - встроенные функции для выполнения кода

# Компилирование Python кода
code = '''
result = 2 + 2
print(result)
'''

# Парсирование и компиляция
compiled = compile(code, '<string>', 'exec')
print(type(compiled))  # <class 'code'>

# Выполнение скомпилированного кода
exec(compiled)  # 4

# Вычисление выражения
result = eval('2 + 2')  # 4

10. Как C-расширения интегрируются

# Python использует Python C API для создания расширений

# Пример: сборка C-расширения (невалидный синтаксис, показано для понимания)

# C код (_mymodule.c):
"""
#include <Python.h>

static PyObject* add(PyObject* self, PyObject* args) {
    int x, y;
    if (!PyArg_ParseTuple(args, "ii", &x, &y))
        return NULL;
    return PyLong_FromLong(x + y);
}

static PyMethodDef methods[] = {
    {"add", add, METH_VARARGS, "Add two integers"},
    {NULL, NULL, 0, NULL}
};

static struct PyModuleDef module = {
    PyModuleDef_HEAD_INIT,
    "_mymodule",
    NULL,
    -1,
    methods
};

PyMODINIT_FUNC PyInit__mymodule(void) {
    return PyModule_Create(&module);
}
"""

# После компиляции становится доступным:
import _mymodule
print(_mymodule.add(2, 3))  # 5

11. Встроенные модули для интроспекции

import inspect
import types
import dis

# inspect - доступ к исходному коду и сигнатурам
def my_function(x, y=10):
    return x + y

sig = inspect.signature(my_function)
print(sig)  # (x, y=10)

# dis - дизассемблирование (байт-код)
def fibonacci(n):
    if n <= 1:
        return n
    return fibonacci(n-1) + fibonacci(n-2)

dis.dis(fibonacci)
# Показывает LOAD_FAST, LOAD_CONST, COMPARE_OP, ...

# types - для проверки типов
print(isinstance(my_function, types.FunctionType))  # True
print(isinstance(len, types.BuiltinFunctionType))  # True

12. Встроенные исключения

# Иерархия исключений - все встроены

print(BaseException.__subclasses__())
# [Exception, GeneratorExit, KeyboardInterrupt, SystemExit]

print(Exception.__subclasses__())
# [StopIteration, ArithmeticError, AssertionError, ..., ValueError, ...]

# Кастомное исключение должно наследовать Exception
class MyError(Exception):
    pass

try:
    raise MyError("Something went wrong")
except MyError as e:
    print(e)  # Something went wrong

Итоговая архитектура

Python Interpreter (CPython)
├── Built-in Functions (C)
│   ├── len(), print(), type(), ...
│   └── Находятся в исполняемом файле python
├── Built-in Types (C)
│   ├── int, str, list, dict, tuple, ...
│   └── Реализованы в Objects/ папке CPython
├── Standard Library (Python + C)
│   ├── Pure Python: json, collections, itertools
│   ├── C Extensions: _json, _sqlite3, _ssl, _pickle
│   └── Расположены в /usr/lib/pythonX.Y/
├── sys Module (C)
│   └── Доступ к интерпретатору и конфигурации
└── os Module (Python + C)
    └── Системные вызовы через libc

Практический примеры использования

# 1. Как узнать, встроенный ли модуль?
import sys
from pathlib import Path

def is_builtin(module_name):
    spec = sys.modules.get(module_name)
    if spec is None:
        return False
    origin = getattr(spec, '__file__', None)
    if origin is None:
        return True  # C-расширение
    stdlib = Path(sys.prefix) / 'lib'
    return str(origin).startswith(str(stdlib))

print(is_builtin('json'))      # True
print(is_builtin('requests'))  # False (сторонний пакет)

# 2. Профилирование встроенных функций
import cProfile
import pstats

def test():
    result = sum(range(1000000))
    return result

cProfile.run('test()')
# Показывает, что встроенная sum() очень быстрая

Заключение

Встроенные библиотеки Python — это сложная система, состоящая из:

• Встроенных функций и типов (написаны на C, в интерпретаторе)
• Standard Library модулей (Python + C-расширения)
• Системных вызовов через libc

Понимание того, какие части встроены на C, помогает оптимизировать код и понимать производительность Python приложений.