SQLite в Python: создание, управление и оптимизация баз данных

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

Инструкции

Иллюстрация для статьи на тему «SQLite в Python: создание, управление и оптимизация баз данных»

23 октября 2025 10 минут

Марина СувороваГлавный редактор блога

Время чтения10 минут

Дата публикации23 октября 2025

Продукты из этой статьи:

Evolution Managed PostgreSQL®

Содержание

Начало работы с SQLite в Python
Создание таблицы
Работа с данными в SQLite
Извлечение данных с помощью SQL-запросов
Фильтрация данных — оператор WHERE
Логические операторы AND и OR
Сортировка данных — ORDER BY
Ограничение количества строк — LIMIT
Оптимизация запросов и управление производительностью
Транзакции и управление данными
Продвинутые техники работы с SQLite в Python
Заключение

Начало работы с SQLite в Python

SQLite — это легкая база данных, которая хранится в одном файле и не требует установки отдельного сервера. Для работы с ней в Python используется встроенная библиотека sqlite3, которая включена в стандартную поставку Python начиная с версии 2.5 и доступна во всех современных версиях, включая Python 3.12 и 3.13.

Установка и настройка Python

Чтобы начать использовать SQLite:

Перейдите на официальный сайт python.org/downloads.
Скачайте и установите последнюю стабильную версию Python для вашей операционной системы.
При установке отметьте пункт Add Python to PATH, чтобы команда python была доступна в терминале.
Проверьте установку — в разных системах команды могут отличаться:

# Windows
py --version
# macOS / Linux
python3 --version

Дарим до 20 000 бонусов

4 000 бонусов — физическим лицам, 20 000 бонусов — юридическим

Если вы видите номер версии — Python установлен корректно.

Теперь можно проверить встроенную поддержку SQLite:

import sqlite3
print(sqlite3.sqlite_version)

Команда выведет текущую версию встроенной SQLite.

Создание новой базы данных и подключение к существующей

Чтобы подключиться к базе данных, используйте функцию sqlite3.connect(). Если файл базы данных существует — соединение откроется, а если файла нет — SQLite создаст новый.

import sqlite3
 
# Создание и подключение к базе данных
connection = sqlite3.connect('my_database.db')
 
# Создание курсора для выполнения SQL-запросов
cursor = connection.cursor()

В этом примере файл my_database.db создается в текущей рабочей папке. Чтобы поместить базу в другое место — укажите полный путь, например:

connection = sqlite3.connect(r'C:\data\my_database.db')

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

connection.close()

Альтернатива — использовать контекстный менеджер, который сам закрывает соединение:

with sqlite3.connect('my_database.db') as connection:
	cursor = connection.cursor()
	# SQL-запросы здесь

Evolution Managed PostgreSQL

Легко управляйте и масштабируйте базы данных в пару кликов: оперативно увеличивайте vCPU, RAM и дисковое пространство, если нагрузка на базу данных возросла.

Узнать больше

Создание таблицы

Теперь создадим простую таблицу users с тремя столбцами:

id — уникальный идентификатор (целое число с автонумерацией);
name — имя пользователя (текст);
age — возраст (целое число).

cursor.execute('''
CREATE TABLE IF NOT EXISTS users (
	id INTEGER PRIMARY KEY AUTOINCREMENT,
	name TEXT,
	age INTEGER
);
''')
 
# Сохраняем изменения
connection.commit()

В этом примере AUTOINCREMENT гарантирует, что идентификаторы не будут переиспользоваться, а команда commit() записывает изменения в файл базы данных.

Основные типы данных в SQLite

SQLite поддерживает динамическую типизацию — при этом тип данных определяется значением, а не столбцом. Тем не менее, каждая колонка имеет тип привязки (type affinity), который определяет, как хранятся данные по умолчанию.

NULL

Используется, если данные отсутствуют.

CREATE TABLE users (
	id INTEGER PRIMARY KEY,
	name TEXT,
	age INTEGER,
	email TEXT
);

Вставка пустого значения:

INSERT INTO users (name, age, email)
VALUES ('Alice', 25, NULL);

INTEGER

Хранит целые числа (до 8 байт, со знаком).

CREATE TABLE products (
	product_id INTEGER PRIMARY KEY,
	price INTEGER
);

REAL

Хранит числа с плавающей точкой (десятичные значения).

CREATE TABLE items (
	item_id INTEGER PRIMARY KEY,
	weight REAL
);

TEXT

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

CREATE TABLE employees (
	employee_id INTEGER PRIMARY KEY,
	name TEXT,
	position TEXT
);

BLOB

Используется для хранения двоичных данных — изображений, файлов и т.п.

CREATE TABLE media (
	media_id INTEGER PRIMARY KEY,
	file BLOB
);

Создание таблицы с разными типами данных

Теперь создадим таблицу products, которая объединит все типы данных SQLite. Каждый столбец будет демонстрировать использование одного из типов: INTEGER, REAL, TEXT, BLOB.

Пример таблицы products:

CREATE TABLE products (
	product_id INTEGER PRIMARY KEY,         	-- INTEGER
	product_name TEXT,                	              	-- TEXT
	price REAL,                                                    	-- REAL
	quantity INTEGER,                                       	-- INTEGER
	description TEXT,                                         	-- TEXT
	image BLOB,                                                  	-- BLOB
	manufacture_date TEXT,                           	-- TEXT (дата как строка)
	discontinued INTEGER DEFAULT 0           	-- INTEGER
);

Расшифровка столбцов:

product_id (INTEGER) — первичный ключ таблицы и идентификатор товара.
product_name (TEXT) — название товара.
price (REAL) — цена товара в виде чисел с плавающей точкой.
quantity (INTEGER) — количество товара на складе.
description (TEXT) — описание товара.
image (BLOB) — изображение товара в виде бинарного потока данных.
manufacture_date (TEXT) — дата производства товара в формате YYYY-MM-DD.
discontinued (INTEGER) — статус товара, доступность. Если позиция отсутствует на складе, в поле будет значение NULL.

В SQLite тип даты — это текст, поэтому формат лучше задавать явно (YYYY-MM-DD). Если нужно работать с датами как с числами, можно использовать Unix timestamp (INTEGER).

Добавление данных (INSERT)

Добавим несколько записей в таблицу:

INSERT INTO products (product_name, price, quantity, description, image, manufacture_date, discontinued)
VALUES ('Smartphone', 499.99, 150, 'Latest model with OLED display',
X'89504E470D0A1A0A0000000D49484452', '2023-03-01', 0);
 
INSERT INTO products (product_name, price, quantity, description, image, manufacture_date, discontinued)
VALUES ('Laptop', 799.99, 80, 'High performance laptop for gaming',
X'89504E470D0A1A0A0000000D49484452', '2022-11-15', 0);
 
INSERT INTO products (product_name, price, quantity, description, image, manufacture_date, discontinued)
VALUES ('Headphones', 149.99, 200, 'Noise-canceling over-ear headphones',
X'89504E470D0A1A0A0000000D49484452', '2023-01-10', 0);
Поле image принимает данные в шестнадцатеричном виде (X'...').

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

product_id	product_name	price	quantity	description	image	manufacture_date	discontinued
1	Smartphone	499.99	150	Latest model with OLED display	(BLOB данных, изображение в бинарном формате)	2023-03-01	0
2	Laptop	799.99	80	High performance laptop for gaming	(BLOB данных, изображение в бинарном формате)	2022-11-15	0
3	Headphones	149.99	200	Noise-canceling over-ear headphones	(BLOB данных, изображение в бинарном формате)	2023-01-10	0

Работа с данными в SQLite

Теперь разберем основные команды для управления содержимым таблиц.

Вставка данных — INSERT

Синтаксис:

INSERT INTO имя_таблицы (колонка1, колонка2, ...)
VALUES (значение1, значение2, ...);

Пример:

INSERT INTO employees (name, age, department)
VALUES ('Alice', 28, 'HR');

Можно добавить несколько строк за один запрос:

INSERT INTO employees (name, age, department)
VALUES
('Bob', 35, 'IT'),
('Charlie', 40, 'Finance');

Обновление данных — UPDATE

Синтаксис:

UPDATE имя_таблицы
SET колонка1 = новое_значение1, колонка2 = новое_значение2
WHERE условие;

Пример:

UPDATE employees
SET age = 36
WHERE name = 'Bob';

Обновит только строки, где name = 'Bob'. При этом без WHERE будут изменены все записи таблицы.

Удаление данных — DELETE

Синтаксис:

DELETE FROM имя_таблицы
WHERE условие;

Пример:

DELETE FROM employees
WHERE name = 'Charlie';
Удалит только запись, где name = 'Charlie'.

Пример комплексной работы с таблицей employees:

1. Создаем таблицу.

CREATE TABLE employees (
	id INTEGER PRIMARY KEY AUTOINCREMENT,
	name TEXT,
	age INTEGER,
	department TEXT
);

2. Добавляем данные.

INSERT INTO employees (name, age, department)
VALUES ('Alice', 28, 'HR'),
   	('Bob', 35, 'IT'),
   	('Charlie', 40, 'Finance');

Теперь таблица employees выглядит так:

Id	Name	Age	Department
1	Alice	28	HR
2	Bob	35	IT
3	Charlie	40	Finance

3. Обновляем данные.

UPDATE employees
SET age = 36
WHERE name = 'Bob';

После выполнения запроса таблица будет выглядеть так:

Id	Name	Age	Department
1	Alice	28	HR
2	Bob	36	IT
3	Charlie	40	Finance

Возраст сотрудника Bob обновился до 36 лет. Предположим, что данные о сотруднике Charlie больше не нужны. Для удаления записи используется оператор DELETE:

DELETE FROM employees
WHERE name = 'Charlie';

После выполнения запроса таблица будет выглядеть так:

Id	Name	Age	Department
1	Alice	28	HR
2	Bob	36	IT

Запись о Charlie удалилась из таблицы.

Извлечение данных с помощью SQL-запросов

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

SELECT

Главная команда для выборок в SQL — это SELECT. Она используется для получения данных из таблицы и может возвращать как все столбцы, так и лишь определенные поля.

Синтаксис:

SELECT столбец1, столбец2, ...
FROM имя_таблицы;

Пример — выбор всех данных:

SELECT *
FROM employees;

Этот запрос извлекает все строки и столбцы из таблицы employees.

FROM

Ключевое слово FROM указывает, из какой таблицы нужно получить данные. Она всегда используется вместе с SELECT.

Пример — выбор отдельных столбцов:

SELECT name, age
FROM employees;

Этот запрос вернет только имена и возраст сотрудников. Если в таблице есть больше столбцов (например, id, department), они в результат не попадут.

Фильтрация данных — оператор WHERE

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

Синтаксис:

SELECT столбец1, столбец2, ...
FROM имя_таблицы
WHERE условие;

Пример — сотрудники старше 30 лет:

SELECT name, age
FROM employees
WHERE age > 30;

Запрос вернет все строки, где значение age больше 30.

В SQLite можно использовать стандартные операторы сравнения: =, >, <, >=, <=, <> (не равно), BETWEEN, LIKE, IN.

Логические операторы AND и OR

Операторы AND и OR позволяют комбинировать несколько условий в одном запросе:

AND — оба условия должны быть истинными.
OR — хотя бы одно из условий должно быть истинным.

Пример с AND — сотрудники отдела IT старше 30 лет:

SELECT name, age, department
FROM employees
WHERE age > 30 AND department = 'IT';

Пример с OR — сотрудники старше 30 лет или из отдела HR:

SELECT name, age, department
FROM employees
WHERE age > 30 OR department = 'HR';

Оба примера корректны и дают предсказуемый результат в SQLite.

При комбинировании условий можно использовать скобки для управления приоритетом: WHERE (department = 'HR' OR department = 'IT') AND age > 25;.

Сортировка данных — ORDER BY

Оператор ORDER BY сортирует результаты запроса по возрастанию (ASC) или по убыванию (DESC).По умолчанию сортировка выполняется в порядке возрастания.

Синтаксис:

SELECT столбец1, столбец2, ...
FROM имя_таблицы
ORDER BY столбец1 [ASC|DESC];

Пример — сортировка по возрасту (по возрастанию):

SELECT name, age
FROM employees
ORDER BY age ASC;

Пример — сортировка по убыванию:

SELECT name, age
FROM employees
ORDER BY age DESC;

Оба варианта рабочие.

Можно сортировать сразу по нескольким полям:

ORDER BY department ASC, age DESC;

С помощью команды будет произведена сортировка по отделу, а внутри отдела — по возрасту (от старшего к младшему).

Ограничение количества строк — LIMIT

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

Синтаксис:

SELECT столбец1, столбец2, ...
FROM имя_таблицы
LIMIT количество;

Пример — получить первых пять сотрудников:

SELECT name, age
FROM employees
LIMIT 5;

SQLite вернет только первые пять записей из таблицы employees.

Можно добавить OFFSET, чтобы пропустить первые N строк:

SELECT name, age
FROM employees
LIMIT 5 OFFSET 10;  -- пропустить первые 10 и взять следующие 5

Оптимизация запросов и управление производительностью

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

Использование индексов

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

Когда стоит использовать индексы

Если таблица содержит действительно много записей — от тысячи и больше, для нее могут пригодиться запросы вида SELECT ... WHERE column = value, а также сортировка (ORDER BY) или связи по ключам.

Для примера создадим таблицу users и добавим индекс на столбец name:

import sqlite3
 
# Подключение к базе данных
connection = sqlite3.connect('my_database.db')
 
# Создание курсора
cursor = connection.cursor()
 
# Создание таблицы
cursor.execute('''
CREATE TABLE IF NOT EXISTS users (
	id INTEGER PRIMARY KEY AUTOINCREMENT,
	name TEXT,
	age INTEGER
);
''')
 
# Создание индекса
cursor.execute('''
CREATE INDEX IF NOT EXISTS idx_name ON users (name);
''')
 
connection.commit()
print("Индекс создан успешно.")

Этот код создает таблицу users и индекс idx_name для ускоренного поиска по полю name. Параметр IF NOT EXISTS предотвращает ошибку, если индекс уже существует.

Добавление данных и использование индекса

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

# Вставка данных
cursor.execute("INSERT INTO users (name, age) VALUES (?, ?)", ('Alice', 30))
cursor.execute("INSERT INTO users (name, age) VALUES (?, ?)", ('Bob', 25))
cursor.execute("INSERT INTO users (name, age) VALUES (?, ?)", ('Charlie', 35))

# Сохраняем изменения
connection.commit()
 
# Поиск по имени (использует индекс)
cursor.execute("SELECT * FROM users WHERE name = 'Bob'")
user = cursor.fetchone()
print(user)

Чтобы проверить, что индекс реально используется, нужно ввести:

EXPLAIN QUERY PLAN SELECT * FROM users WHERE name = 'Bob';

Если в выводе появится USING INDEX, значит SQLite применяет индекс при поиске.

Удаление индекса

Если индекс больше не нужен, его можно удалить командой:

cursor.execute('DROP INDEX IF EXISTS idx_name')
connection.commit()
print("Индекс удалён.")

Пример полного алгоритма — создание базы, таблицы, индекса, вставка данных, поиск и удаление индекса:

import sqlite3
 
# Подключение
connection = sqlite3.connect('my_database.db')
cursor = connection.cursor()
 
# Таблица
cursor.execute('''
CREATE TABLE IF NOT EXISTS users (
	id INTEGER PRIMARY KEY AUTOINCREMENT,
	name TEXT,
	age INTEGER
);
''')
 
# Индекс
cursor.execute('CREATE INDEX IF NOT EXISTS idx_name ON users (name);')
 
# Данные
cursor.execute("INSERT INTO users (name, age) VALUES (?, ?)", ('Alice', 30))
cursor.execute("INSERT INTO users (name, age) VALUES (?, ?)", ('Bob', 25))
cursor.execute("INSERT INTO users (name, age) VALUES (?, ?)", ('Charlie', 35))
connection.commit()
 
# Поиск
cursor.execute("SELECT * FROM users WHERE name = 'Bob'")
user = cursor.fetchone()
print("Найден пользователь:", user)
 
# Удаление индекса
cursor.execute('DROP INDEX IF EXISTS idx_name')
connection.commit()
 
# Закрытие соединения
connection.close()

Этот код можно запускать целиком — он создает базу, индекс, выводит результат поиска и корректно закрывает соединение.

Транзакции и управление данными

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

Транзакции основаны на принципах ACID:

Atomicity (Атомарность). Транзакция выполняется полностью либо не выполняется вообще.
Consistency (Согласованность). После завершения транзакции база данных всегда находится в согласованном состоянии.
Isolation (Изоляция). Каждая транзакция выполняется независимо от других транзакций.
Durability (Долговечность). После завершения транзакции все изменения сохраняются в базе данных.

Пример транзакции:

import sqlite3
 
connection = sqlite3.connect('my_database.db')
cursor = connection.cursor()
 
try:
	# Начало транзакции
	cursor.execute("BEGIN TRANSACTION;")
	
	cursor.execute("INSERT INTO users (name, age) VALUES ('Daniel', 29)")
	cursor.execute("UPDATE users SET age = 30 WHERE name = 'Alice'")
	
	# Подтверждение изменений
    connection.commit()
    print("Транзакция выполнена успешно.")
 
except Exception as e:
	# Откат при ошибке
	connection.rollback()
	print("Ошибка, изменения отменены:", e)
 
finally:
	connection.close()

Если оба запроса выполняются успешно — изменения фиксируются (COMMIT). Если хотя бы один запрос вызовет ошибку — SQLite откатит всё (ROLLBACK).

Ручное управление транзакциями в SQL

Можно управлять транзакциями прямо из SQL:

BEGIN TRANSACTION;
 
INSERT INTO users (name, age) VALUES ('Elena', 27);
UPDATE users SET age = 31 WHERE name = 'Daniel';

По умолчанию SQLite работает в автоматическом режиме транзакций (autocommit). Если вы не используете BEGIN, каждая команда фиксируется сразу.

Продвинутые техники работы с SQLite в Python

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

Использование Prepared Statements

Prepared Statement — это предварительно скомпилированный SQL-шаблон, в который при выполнении можно подставлять разные значения. Это ускоряет работу с повторяющимися запросами и защищает от SQL-инъекций.

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

import sqlite3
 
# Подключение к базе
conn = sqlite3.connect('users.db')
cursor = conn.cursor()
 
# Создание таблицы (если не существует)
cursor.execute('''
CREATE TABLE IF NOT EXISTS users (
	id INTEGER PRIMARY KEY,
	name TEXT,
	age INTEGER
);
''')
 
# Подготовленные запросы с параметрами
cursor.execute("INSERT INTO users (name, age) VALUES (?, ?)", ("Alice", 25))
cursor.execute("INSERT INTO users (name, age) VALUES (?, ?)", ("Bob", 30))
 
# Сохранение изменений
conn.commit()
conn.close()

Этот код безопасен и корректен. Использование ? вместо конкатенации строк предотвращает SQL-инъекции, а SQLite сам оптимизирует многократные вызовы одного запроса.

Работа с представлениями (Views)

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

Использование представлений помогает:

упростить сложные SQL-запросы;
повторно использовать одну выборку;
повысить читаемость и удобство.

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

CREATE VIEW user_info AS
SELECT name, age
FROM users
WHERE age > 18;

После этого можно обращаться к представлению, как к обычной таблице:

SELECT * FROM user_info;

В SQLite представления используются только для чтения — вы не можете напрямую изменять данные через них. Для редактирования применяются реальные таблицы.

Работа с триггерами (Triggers)

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

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

Таблица для логов:

CREATE TABLE IF NOT EXISTS logs (
	id INTEGER PRIMARY KEY AUTOINCREMENT,
	message TEXT
);

Триггер, срабатывающий после вставки данных в users:

CREATE TRIGGER IF NOT EXISTS log_insert
AFTER INSERT ON users
BEGIN
	INSERT INTO logs (message)
	VALUES ('Добавлен новый пользователь');
END;

Теперь при каждом INSERT в таблицу users в таблицу logs автоматически добавляется запись.

Также в SQLite триггеры могут быть связаны с событиями:

AFTER INSERT
AFTER UPDATE
AFTER DELETE

Обработка результатов запросов (методы fetch)

Извлекать записи из результатов выборки помогут команды fetchone(), fetchmany() и fetchall(). В таблице описано, как они работают.

Метод	Описание	Пример
fetchone()	Возвращает следующую строку из результата. Если данных больше нет, команда возвращает None	row = cursor.fetchone()
fetchmany(n)	Возвращает заданное число строк результата	rows = cursor.fetchmany(5)
fetchall()	Возвращает все строки результата в виде списка кортежей	rows = cursor.fetchall()

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

cursor.execute("SELECT * FROM users")
 
# Получить одну строку
print(cursor.fetchone())
 
# Получить пять строк
print(cursor.fetchmany(5))
 
# Получить все строки
print(cursor.fetchall())

Если данных в таблице нет — методы возвращают None или пустой список. Поэтому при работе с fetchone() полезно проверять результат:

row = cursor.fetchone()
if row:
	print("Найдено:", row)
else:
	print("Нет данных")

Создание простого приложения (пример)

Давайте создадим простое консольное приложение для управления списком задач (To-Do List), которое демонстрирует все рассмотренные техники работы с SQLite в Python.

Сперва создайте базу данных:

import sqlite3

class TodoApp:
    def __init__(self):
        self.conn = sqlite3.connect('todo.db')
        self.cursor = self.conn.cursor()
        self.cursor.execute('''
            CREATE TABLE IF NOT EXISTS tasks (
                id INTEGER PRIMARY KEY,
                task TEXT,
                done INTEGER DEFAULT 0
            )
        ''')

Примените методы:

def add_task(self, text):
    """Добавление задачи"""
    self.cursor.execute("INSERT INTO tasks (task) VALUES (?)", (text,))
    self.conn.commit()

def list_tasks(self):
    """Список задач"""
    self.cursor.execute("SELECT * FROM tasks WHERE done = 0")
    for row in self.cursor.fetchall():
        print(f"{row[0]}. {row[1]}")

def complete_task(self, task_id):
    """Завершение задачи"""
    self.cursor.execute("UPDATE tasks SET done = 1 WHERE id = ?", (task_id,))
    self.conn.commit()

А теперь используйте базу и методы:

app = TodoApp()
app.add_task("Изучить SQLite")
app.add_task("Написать приложение")
app.list_tasks()  # Вывод всех задач
app.complete_task(1)  # Отметить первую задачу выполненной

Интеграция SQLite с другими библиотеками

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

Извлечение данных из SQLite в Pandas

Рассмотрим пример на таблице sales, где хранятся данные о продажах. Создадим таблицу, добавим записи, извлечем их через Pandas и выведем результат.

import sqlite3
import pandas as pd
 
# Подключение к базе данных SQLite
connection = sqlite3.connect('sales_data.db')
cursor = connection.cursor()
 
# Создание таблицы с данными о продажах
cursor.execute('''
CREATE TABLE IF NOT EXISTS sales (
	id INTEGER PRIMARY KEY AUTOINCREMENT,
	product_name TEXT,
	amount INTEGER,
	price REAL,
	date TEXT
);
''')
 
# Вставка данных
cursor.executemany('''
INSERT INTO sales (product_name, amount, price, date)
VALUES (?, ?, ?, ?)
''', [
	('Product A', 10, 15.5, '2022-01-01'),
	('Product B', 5, 25.0, '2022-01-02'),
	('Product A', 8, 15.5, '2022-01-03'),
	('Product C', 3, 40.0, '2022-01-04')
])
 
# Сохраняем изменения
connection.commit()
 
# Извлечение данных с помощью Pandas
df = pd.read_sql_query("SELECT * FROM sales", connection)
 
# Вывод данных
print(df)
 
# Закрытие соединения
connection.close()

После запуска этого кода на экране появится таблица продаж в виде DataFrame Pandas:

id	product_name	amount	price
1	Product A	10	15.5
2	Product B	5	25.0
3	Product C	8	15.5
4	Product D	3	40.0

Анализ данных с помощью Pandas

Теперь рассчитаем общую сумму продаж по каждому продукту.

import sqlite3
import pandas as pd
 
# Подключение к базе
connection = sqlite3.connect('sales_data.db')
 
# Извлечение данных
df = pd.read_sql_query("SELECT * FROM sales", connection)
 
# Добавление нового столбца с суммой продаж
df['total_sales'] = df['amount'] * df['price']
 
# Группировка и подсчет общей суммы по каждому продукту
sales_summary = df.groupby('product_name')['total_sales'].sum().reset_index()
 
# Вывод результата
print(sales_summary)
 
# Закрытие соединения
connection.close()

Результат:

Product_name	Total_sales
Product A	279.5
Product B	125.0
Product C	120.0

Pandas позволяет выполнять агрегатные операции значительно проще, чем SQL, а результаты можно визуализировать, построить графики или выгрузить в Excel.

Обновление данных SQLite через Pandas

Теперь изменим данные в Pandas и обновим таблицу sales в базе данных. Увеличим количество проданных единиц для Product A на 5:

import sqlite3
import pandas as pd
 
# Подключение к базе
connection = sqlite3.connect('sales_data.db')
 
# Извлечение данных
df = pd.read_sql_query("SELECT * FROM sales", connection)
 
# Изменение данных: увеличиваем количество у Product A
df.loc[df['product_name'] == 'Product A', 'amount'] += 5
 
# Фильтрация обновленных строк
df_to_update = df[df['product_name'] == 'Product A']
 
# Обновление данных в базе
for _, row in df_to_update.iterrows():
	cursor = connection.cursor()
	cursor.execute('''
    	UPDATE sales
    	SET amount = ?
    	WHERE id = ?
	''', (row['amount'], row['id']))
 
# Сохраняем изменения
connection.commit()
 
# Проверяем результат
df_updated = pd.read_sql_query("SELECT * FROM sales", connection)
print(df_updated)
 
# Закрытие соединения
connection.close()

Теперь количество Product A увеличилось — изменения записаны обратно в базу. Этот подход сочетает простоту анализа в Pandas и надежность транзакций SQLite.

Заключение

SQLite в Python представляет собой оптимальное решение для работы со встраиваемыми базами данных, гармонично сочетая простоту освоения с широкими функциональными возможностями. Главная сила технологии заключается в ее универсальности — она работает «из коробки» на всех платформах без необходимости установки дополнительного серверного ПО, что делает SQLite идеальным инструментом для быстрой разработки прототипов, мобильных приложений и выполнения легких аналитических задач.

Для более сложных и высоконагруженных проектов стоит рассмотреть переход на управляемые базы данных, такие как Evolution Managed PostgreSQL®. Этот сервис предлагает нативную поддержку сложных SQL-запросов, встроенные механизмы репликации и профессиональное администрирование, обеспечивая надежную основу для масштабируемых приложений.

Продукты из этой статьи:

Evolution Managed PostgreSQL®

23 октября 2025

SQLite в Python: создание, управление и оптимизация баз данных

Начало работы с SQLite в Python

Установка и настройка Python

Создание новой базы данных и подключение к существующей

Создание таблицы

NULL

INTEGER

REAL

TEXT

BLOB

Создание таблицы с разными типами данных

Добавление данных (INSERT)

Работа с данными в SQLite

Вставка данных — INSERT

Обновление данных — UPDATE

Удаление данных — DELETE

Извлечение данных с помощью SQL-запросов

SELECT

FROM

Фильтрация данных — оператор WHERE

Логические операторы AND и OR

Сортировка данных — ORDER BY

Ограничение количества строк — LIMIT

Оптимизация запросов и управление производительностью

Использование индексов

Когда стоит использовать индексы

Добавление данных и использование индекса

Удаление индекса

Транзакции и управление данными

Ручное управление транзакциями в SQL

Продвинутые техники работы с SQLite в Python

Использование Prepared Statements

Работа с представлениями (Views)

Работа с триггерами (Triggers)

Обработка результатов запросов (методы fetch)

Создание простого приложения (пример)

Интеграция SQLite с другими библиотеками

Извлечение данных из SQLite в Pandas

Анализ данных с помощью Pandas

Обновление данных SQLite через Pandas

Заключение

Вам может понравиться