Как создавать и манипулировать базы данных SQL с Python

Автор оригинала: Craig Dickson.

Python и SQL два из самых важных языков для аналитиков данных.

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

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

Вместе мы охватим:

• Зачем участвовать, как использовать Python и SQL вместе?
• Как настроить свою среду Python и MySQL Server
• Подключение к MySQL Server в Python
• Создание новой базы данных
• Создание таблиц и табличных отношений
• Заполнение таблиц с данными
• Чтение данных
• Обновление записей
• Удаление записей
• Создание записей из списков Python
• Создание повторных пригодных функций, чтобы сделать все это для нас в будущем

Это много очень полезных и очень крутых вещей. Давайте попадаем в это!

Быстрая нота, прежде чем мы начинаем: есть ноутбук Jupyter, содержащий весь код, используемый в этом руководстве, имеющем доступный в Этот репозиторий Github Отказ Кодирование вдоль настоятельно рекомендуется!

База данных и код SQL используются здесь, это все от моего предыдущего Введение в SQL Серия опубликована на К науке данных ( Свяжитесь со мной Если у вас есть какие-либо проблемы, просматривая статьи, и я могу отправить вам ссылку, чтобы увидеть их бесплатно).

Если вы не знакомы с SQL и концепциями реляционных баз данных, я бы указывал на эта серия (Плюс, конечно, есть огромное количество отличных вещей, доступных здесь на FreeCodeCamp !)

Почему python с sql?

Для аналитиков данных и ученых данных Python имеет много преимуществ. Огромный ассортимент библиотек открытых источников делает его невероятно полезным инструментом для любого аналитика данных.

У нас есть Пандас , Numpy и VAEX Для анализа данных Матплотлиб , S Эр ворск и Боке Для визуализации и Tensorflow , Scikit – Учите и Pytorch Для машинного обучения приложений (плюс много, многое другое).

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

Так что, если мы используем Python для анализа данных, это стоит спросить – откуда приходят все эти данные?

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

Наиболее широко используемые системы управления реляционными базами данных (RDBMSS) – Oracle , MySQL , Microsoft SQL Server , PostgreSQL , IBM DB2 – Все использовать Язык структурированного запроса (SQL) для доступа и внесения изменений в данные.

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

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

Остальная часть этой статьи будет посвящена, чтобы показать вам именно, как мы можем сделать это.

Начиная

Требования и установка

Чтобы кодировать вместе с этим уроком, вам понадобится ваш собственный Питонская среда настраивать.

Я использую Анаконда , но есть много способов сделать это. Просто Google “Как установить Python”, если вам нужна дополнительная помощь. Вы также можете использовать Связующее Для кода вместе со связанным Jupyter ноутбук Отказ

Мы будем использовать MySQL Community Server Как это бесплатно и широко используется в отрасли. Если вы используете Windows, Это руководство поможет вам настроить. Вот гиды для Mac и Linux Пользователи тоже (хотя это может варьироваться от распространения Linux).

Как только у вас есть те, которые настроили, нам нужно будет заставить их общаться друг с другом.

Для этого нам нужно установить Разъем MySQL Библиотека Python. Чтобы сделать это, следуйте за Инструкции или просто используйте PIP:

pip install mysql-connector-python

Мы также собираемся использовать Пандас Так что убедитесь, что у вас тоже это установлено.

pip install pandas

Импорт библиотек

Как и в случае каждого проекта в Python, самое первое, что мы хотим сделать, это импортировать наши библиотеки.

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

Для этого учебника мы собираемся использовать только две библиотеки – Разъем MySQL и Пандас Отказ

import mysql.connector
from mysql.connector import Error
import pandas as pd

Мы импортируем функцию ошибки отдельно, чтобы у нас легкий доступ к нему для наших функций.

Подключение к MySQL Server

К этому моменту мы должны иметь MySQL Community Server настроить на нашу систему. Теперь нам нужно написать какой-нибудь код в Python, который позволяет нам установить соединение с этим сервером.

def create_server_connection(host_name, user_name, user_password):
    connection = None
    try:
        connection = mysql.connector.connect(
            host=host_name,
            user=user_name,
            passwd=user_password
        )
        print("MySQL Database connection successful")
    except Error as err:
        print(f"Error: '{err}'")

    return connection

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

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

Первая строка заключается в том, что мы называем функцию (create_server_connection) и название аргументов, которые выполнят эту функцию (host_name, user_name и user_password).

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

Далее мы используем Python попробуйте за исключением блока обрабатывать любые потенциальные ошибки. Первая часть пытается создать соединение с сервером, используя mysql.connector.connect () Метод Использование деталей, указанных пользователем в аргументах. Если это работает, функция печатает счастливое маленькое сообщение успеха.

За исключением части блока печатает ошибку, которая возвращает MySQL Server, в несчастных случаях, когда есть ошибка.

Наконец, если соединение успешно, функция возвращает Объект соединения Отказ

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

connection = create_server_connection("localhost", "root", pw)

Это должно дать сообщение успеха:

Создание новой базы данных

Теперь, когда мы создали соединение, наш следующий шаг – создать новую базу данных на нашем сервере.

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

def create_database(connection, query):
    cursor = connection.cursor()
    try:
        cursor.execute(query)
        print("Database created successfully")
    except Error as err:
        print(f"Error: '{err}'")

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

Мы используем Курсор Метод нашего соединения Объект для создания объекта курсора (разъем MySQL использует Object-ориентированную на объектно-ориентированную парадигку программирования , поэтому существует множество объектов, наследующих свойства от родительских объектов).

Этот объект курсора имеет такие методы, как Выполнить , ExecuteMany (который мы будем использовать в этом руководстве) вместе с несколькими другими полезными методами.

Если это поможет, мы можем подумать об объекте курсора как предоставляя нам доступ к мигающему курсору в окне терминала сервера MySQL.

Далее мы определяем запрос для создания базы данных и позвоните в функцию:

Все запросы SQL, используемые в этом руководстве, объяснены в моем Введение в SQL Tutorial Series и полный код можно найти в ассоциированной ноутбуке Jupyter в Этот репозиторий Github Поэтому я не буду предоставлять объяснения того, что в этом руководстве делает код SQL.

Это, пожалуй, самый простой запрос SQL возможен. Если вы можете прочитать английский, вы, вероятно, можете разработать то, что он делает!

Запуск функции Create_Database с аргументами как выше результаты в базе данных, называемой «школой», создаваемой на нашем сервере.

Почему наша база данных под названием «школа»? Возможно, теперь будет хорошее время, чтобы посмотреть более подробно в точности то, что мы собираемся реализовать в этом руководстве.

Наша база данных

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

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

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

Необработанный код SQL, требования к базе данных и данные для перехода в базу данных, содержится в Этот репозиторий Github , но вы увидите все это, когда мы тоже проходим через этот учебник.

Подключение к базе данных

Теперь, когда мы создали базу данных на MySQL Server, мы можем изменить функцию create_server_connection для подключения напрямую к этой базе данных.

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

Мы можем сделать это так:

def create_db_connection(host_name, user_name, user_password, db_name):
    connection = None
    try:
        connection = mysql.connector.connect(
            host=host_name,
            user=user_name,
            passwd=user_password,
            database=db_name
        )
        print("MySQL Database connection successful")
    except Error as err:
        print(f"Error: '{err}'")

    return connection

Это то же самое функция, но теперь мы принимаем еще один аргумент – имя базы данных – и пропустите, что в качестве аргумента к методу Connect ().

Создание функции выполнения запросов

Окончательная функция, которую мы собираемся создавать (на данный момент), является чрезвычайно важной – функция выполнения запросов. Это собирается взять наши SQL-запросы, хранящиеся в Python в качестве строк, и передайте их на Cursor.execute () Способ выполнить их на сервере.

def execute_query(connection, query):
    cursor = connection.cursor()
    try:
        cursor.execute(query)
        connection.commit()
        print("Query successful")
    except Error as err:
        print(f"Error: '{err}'")

Эта функция точно такой же, как наша функция create_database с ранее, за исключением того, что она использует Connection.comMit () Метод, чтобы убедиться, что команды, подробные в наших запросах SQL.

Это будет наша функция Workhorse, которую мы будем использовать (наряду с Create_db_connection) для создания таблиц, устанавливают отношения между этими таблицами, заполняют таблицы с данными, и обновлять и удалять записи в нашей базе данных.

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

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

Теперь мы все настроем, чтобы начать запустить команды SQL на нашем сервере и начать строить нашу базу данных. Первое, что мы хотим сделать, это создать необходимые таблицы.

Начнем с нашего стола учителя:

create_teacher_table = """
CREATE TABLE teacher (
  teacher_id INT PRIMARY KEY,
  first_name VARCHAR(40) NOT NULL,
  last_name VARCHAR(40) NOT NULL,
  language_1 VARCHAR(3) NOT NULL,
  language_2 VARCHAR(3),
  dob DATE,
  tax_id INT UNIQUE,
  phone_no VARCHAR(20)
  );
 """

connection = create_db_connection("localhost", "root", pw, db) # Connect to the Database
execute_query(connection, create_teacher_table) # Execute our defined query

Прежде всего мы назначаем нашу команду SQL (подробно описано здесь ) в переменной с соответствующим именем.

В этом случае мы используем Python’s Обозначение тройной цитаты для многострочных струн Чтобы сохранить наш запрос SQL, затем мы проводим его в нашу функцию Execute_Query для его реализации.

Обратите внимание, что это многострочное форматирование является исключительно в интересах людей, читающих наш код. Ни SQL, ни Python «Ware», если команда SQL распространяется как это. До тех пор, пока синтаксис правильный, оба языка примут его.

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

То же самое верно для капитализации операторов в SQL. Это широко используемая конвенция, которая настоятельно рекомендуется, но фактическое программное обеспечение, которое запускает код, является нечувствительным к регистру и будет лечить «Создать учитель таблицы» и «Создать учитель таблицы» в качестве идентичных команд.

Запуск этого кода дает нам наши сообщения успеха. Мы также можем проверить это в клиенте командной строки MySQL Server:

Большой! Теперь давайте создадим оставшиеся таблицы.

create_client_table = """
CREATE TABLE client (
  client_id INT PRIMARY KEY,
  client_name VARCHAR(40) NOT NULL,
  address VARCHAR(60) NOT NULL,
  industry VARCHAR(20)
);
 """

create_participant_table = """
CREATE TABLE participant (
  participant_id INT PRIMARY KEY,
  first_name VARCHAR(40) NOT NULL,
  last_name VARCHAR(40) NOT NULL,
  phone_no VARCHAR(20),
  client INT
);
"""

create_course_table = """
CREATE TABLE course (
  course_id INT PRIMARY KEY,
  course_name VARCHAR(40) NOT NULL,
  language VARCHAR(3) NOT NULL,
  level VARCHAR(2),
  course_length_weeks INT,
  start_date DATE,
  in_school BOOLEAN,
  teacher INT,
  client INT
);
"""


connection = create_db_connection("localhost", "root", pw, db)
execute_query(connection, create_client_table)
execute_query(connection, create_participant_table)
execute_query(connection, create_course_table)

Это создает четыре стола, необходимые для наших четырех объектов.

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

Мы делаем это точно так же:

alter_participant = """
ALTER TABLE participant
ADD FOREIGN KEY(client)
REFERENCES client(client_id)
ON DELETE SET NULL;
"""

alter_course = """
ALTER TABLE course
ADD FOREIGN KEY(teacher)
REFERENCES teacher(teacher_id)
ON DELETE SET NULL;
"""

alter_course_again = """
ALTER TABLE course
ADD FOREIGN KEY(client)
REFERENCES client(client_id)
ON DELETE SET NULL;
"""

create_takescourse_table = """
CREATE TABLE takes_course (
  participant_id INT,
  course_id INT,
  PRIMARY KEY(participant_id, course_id),
  FOREIGN KEY(participant_id) REFERENCES participant(participant_id) ON DELETE CASCADE,
  FOREIGN KEY(course_id) REFERENCES course(course_id) ON DELETE CASCADE
);
"""

connection = create_db_connection("localhost", "root", pw, db)
execute_query(connection, alter_participant)
execute_query(connection, alter_course)
execute_query(connection, alter_course_again)
execute_query(connection, create_takescourse_table)

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

Заполнение таблиц

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

pop_teacher = """
INSERT INTO teacher VALUES
(1,  'James', 'Smith', 'ENG', NULL, '1985-04-20', 12345, '+491774553676'),
(2, 'Stefanie',  'Martin',  'FRA', NULL,  '1970-02-17', 23456, '+491234567890'), 
(3, 'Steve', 'Wang',  'MAN', 'ENG', '1990-11-12', 34567, '+447840921333'),
(4, 'Friederike',  'Müller-Rossi', 'DEU', 'ITA', '1987-07-07',  45678, '+492345678901'),
(5, 'Isobel', 'Ivanova', 'RUS', 'ENG', '1963-05-30',  56789, '+491772635467'),
(6, 'Niamh', 'Murphy', 'ENG', 'IRI', '1995-09-08',  67890, '+491231231232');
"""

connection = create_db_connection("localhost", "root", pw, db)
execute_query(connection, pop_teacher)

Это работает? Мы можем снова проверить в нашем клиенте командной строки MySQL:

Теперь заполнить оставшиеся таблицы.

pop_client = """
INSERT INTO client VALUES
(101, 'Big Business Federation', '123 Falschungstraße, 10999 Berlin', 'NGO'),
(102, 'eCommerce GmbH', '27 Ersatz Allee, 10317 Berlin', 'Retail'),
(103, 'AutoMaker AG',  '20 Künstlichstraße, 10023 Berlin', 'Auto'),
(104, 'Banko Bank',  '12 Betrugstraße, 12345 Berlin', 'Banking'),
(105, 'WeMoveIt GmbH', '138 Arglistweg, 10065 Berlin', 'Logistics');
"""

pop_participant = """
INSERT INTO participant VALUES
(101, 'Marina', 'Berg','491635558182', 101),
(102, 'Andrea', 'Duerr', '49159555740', 101),
(103, 'Philipp', 'Probst',  '49155555692', 102),
(104, 'René',  'Brandt',  '4916355546',  102),
(105, 'Susanne', 'Shuster', '49155555779', 102),
(106, 'Christian', 'Schreiner', '49162555375', 101),
(107, 'Harry', 'Kim', '49177555633', 101),
(108, 'Jan', 'Nowak', '49151555824', 101),
(109, 'Pablo', 'Garcia',  '49162555176', 101),
(110, 'Melanie', 'Dreschler', '49151555527', 103),
(111, 'Dieter', 'Durr',  '49178555311', 103),
(112, 'Max', 'Mustermann', '49152555195', 104),
(113, 'Maxine', 'Mustermann', '49177555355', 104),
(114, 'Heiko', 'Fleischer', '49155555581', 105);
"""

pop_course = """
INSERT INTO course VALUES
(12, 'English for Logistics', 'ENG', 'A1', 10, '2020-02-01', TRUE,  1, 105),
(13, 'Beginner English', 'ENG', 'A2', 40, '2019-11-12',  FALSE, 6, 101),
(14, 'Intermediate English', 'ENG', 'B2', 40, '2019-11-12', FALSE, 6, 101),
(15, 'Advanced English', 'ENG', 'C1', 40, '2019-11-12', FALSE, 6, 101),
(16, 'Mandarin für Autoindustrie', 'MAN', 'B1', 15, '2020-01-15', TRUE, 3, 103),
(17, 'Français intermédiaire', 'FRA', 'B1',  18, '2020-04-03', FALSE, 2, 101),
(18, 'Deutsch für Anfänger', 'DEU', 'A2', 8, '2020-02-14', TRUE, 4, 102),
(19, 'Intermediate English', 'ENG', 'B2', 10, '2020-03-29', FALSE, 1, 104),
(20, 'Fortgeschrittenes Russisch', 'RUS', 'C1',  4, '2020-04-08',  FALSE, 5, 103);
"""

pop_takescourse = """
INSERT INTO takes_course VALUES
(101, 15),
(101, 17),
(102, 17),
(103, 18),
(104, 18),
(105, 18),
(106, 13),
(107, 13),
(108, 13),
(109, 14),
(109, 15),
(110, 16),
(110, 20),
(111, 16),
(114, 12),
(112, 19),
(113, 19);
"""

connection = create_db_connection("localhost", "root", pw, db)
execute_query(connection, pop_client)
execute_query(connection, pop_participant)
execute_query(connection, pop_course)
execute_query(connection, pop_takescourse)

Удивительный! Теперь мы создали базу данных в комплекте с отношениями, ограничениями и записями в MySQL, используя ничего, кроме команд Python.

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

Чтение данных

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

Для этого нам понадобится еще одна функция, на этот раз, используя Cursor.fetchall () вместо cursor.commit () Отказ С этой функцией мы читаем данные из базы данных и не будем принимать никаких изменений.

def read_query(connection, query):
    cursor = connection.cursor()
    result = None
    try:
        cursor.execute(query)
        result = cursor.fetchall()
        return result
    except Error as err:
        print(f"Error: '{err}'")

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

q1 = """
SELECT *
FROM teacher;
"""

connection = create_db_connection("localhost", "root", pw, db)
results = read_query(connection, q1)

for result in results:
  print(result)

Именно то, что мы ожидаем. Функция также работает с более сложными запросами, такими как этот с участием Присоединяйтесь к на курсе и клиентских таблицах.

q5 = """
SELECT course.course_id, course.course_name, course.language, client.client_name, client.address
FROM course
JOIN client
ON course.client = client.client_id
WHERE course.in_school = FALSE;
"""

connection = create_db_connection("localhost", "root", pw, db)
results = read_query(connection, q5)

for result in results:
  print(result)

Очень хорошо.

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

Давайте пройдем через пару примеров, чтобы увидеть, как мы можем сделать это.

Форматирование выхода в список

#Initialise empty list
from_db = []

# Loop over the results and append them into our list

# Returns a list of tuples
for result in results:
  result = result
  from_db.append(result)

Форматирование выхода в список списков

# Returns a list of lists
from_db = []

for result in results:
  result = list(result)
  from_db.append(result)

Форматирование вывода в PandaFrame PandaS

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

# Returns a list of lists and then creates a pandas DataFrame
from_db = []

for result in results:
  result = list(result)
  from_db.append(result)


columns = ["course_id", "course_name", "language", "client_name", "address"]
df = pd.DataFrame(from_db, columns=columns)

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

Обновление записей

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

Покажем, что ILS уведомляется о том, что один из его существующих клиентов, Федерация Big Business – это переезд до 23 фигуртов, 14534 Берлина. В этом случае администратор базы данных (это нас!), Нужно будет внести некоторые изменения.

К счастью, мы можем сделать это с нашей функцией Execute_Query рядом с SQL Обновить утверждение.

update = """
UPDATE client 
SET address = '23 Fingiertweg, 14534 Berlin' 
WHERE client_id = 101;
"""

connection = create_db_connection("localhost", "root", pw, db)
execute_query(connection, update)

Обратите внимание, что предложение, где здесь очень важно. Если мы запустим этот запрос без предложения Where, то все адреса для всех записей в нашей клиентской таблице будут обновлены до 23 фигуртов. Это очень не то, что мы стремимся сделать.

Также обратите внимание, что мы использовали «где» в запросе обновления. Было бы также возможно использовать «где» или «где» или даже «где адрес как«% falschung% ».

Важно то, что предложение This позволяет нам однозначно идентифицировать запись (или записи), которые мы хотим обновить.

Удаление записей

Также возможно использовать нашу функцию Execute_Query для удаления записей, используя Удалить Отказ

При использовании SQL с реляционными базами данных мы должны быть осторожны с помощью оператора удаления. Это не Windows, нет «Вы уверены, что хотите удалить это?» Предупреждение всплывающее, и нет утилизации корзины. Как только мы что-то удалите, это действительно ушло.

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

Прежде всего, давайте напомним себе, какие курсы у нас есть.

Давайте скажем, курс 20, «Фортгесвядцы России» (это «продвинутый русский» для вас и мной), подходит к концу, поэтому нам нужно удалить его из нашей базы данных.

На этом этапе вы вообще не будете удивлены тем, как мы это делаем – сохраните команду SQL в качестве строки, затем подайте ее в нашу функцию Workhorse Execute_Query.

delete_course = """
DELETE FROM course 
WHERE course_id = 20;
"""

connection = create_db_connection("localhost", "root", pw, db)
execute_query(connection, delete_course)

Давайте проверим, чтобы подтвердить, что имел предполагаемый эффект:

«Расширенный русский» ушел, как мы ожидали.

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

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

О, Круд

К этому моменту мы можем выполнить четыре основных операции для постоянного хранения данных.

Мы узнали, как:

• Создание – совершенно новые базы данных, таблицы и записи
• Читайте – извлечь данные из базы данных и храните эти данные в нескольких форматах
• Обновление – вносить изменения в существующие записи в базе данных
• Удалить – удалить записи, которые больше не нужны

Это фантастически полезные вещи, чтобы иметь возможность сделать.

Прежде чем мы закончим здесь, у нас есть еще один очень удобный навык, чтобы учиться.

Создание записей из списков

Мы видели, когда заполните наши таблицы, которые мы можем использовать SQL Вставить Команда в нашей функции Execute_Query для вставки записей в нашу базу данных.

Учитывая, что мы используем Python для манипулирования нашей базой данных SQL, было бы полезно иметь возможность принимать структуру данных Python (например, A List ) и вставить ее непосредственно в нашу базу данных.

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

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

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

def execute_list_query(connection, sql, val):
    cursor = connection.cursor()
    try:
        cursor.executemany(sql, val)
        connection.commit()
        print("Query successful")
    except Error as err:
        print(f"Error: '{err}'")

Теперь у нас есть функция, нам нужно определить команду SQL («SQL»), а список, содержащий значения, которые, как мы хотим ввести в базу данных (‘val’). Значения должны храниться как Список кортежи , который является довольно распространенным способом хранения данных в Python.

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

sql = '''
    INSERT INTO teacher (teacher_id, first_name, last_name, language_1, language_2, dob, tax_id, phone_no) 
    VALUES (%s, %s, %s, %s, %s, %s, %s, %s)
    '''
    
val = [
    (7, 'Hank', 'Dodson', 'ENG', None, '1991-12-23', 11111, '+491772345678'), 
    (8, 'Sue', 'Perkins', 'MAN', 'ENG', '1976-02-02', 22222, '+491443456432')
]

Уведомление здесь, что в коде «SQL» мы используем «% s» в качестве заполнителя для нашей стоимости. Сходство к Placholder ‘% S’ Для строки в Python просто совпадают (и откровенно, очень запутанно), мы хотим использовать «% s» для всех типов данных (строки, INTS, даты и т. Д.) с разъемом MySQL Python.

Вы можете увидеть ряд вопросов на Stackoverflow где кто-то запутался и пытался использовать «% D» заполнители Для целых чисел, потому что они используются для этого в Python. Это не будет работать здесь – нам нужно использовать «% s» для каждого столбца, который мы хотим добавить значение.

Функция ExecuteMany затем принимает каждый кортеж в нашем списке «VAL» и вставляет соответствующее значение для этого столбца вместо заполнителей и выполняет команду SQL для каждого кортежа, содержащегося в списке.

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

Давайте пойдем вперед и выполним этот запрос и добавьте учителей в нашу базу данных.

connection = create_db_connection("localhost", "root", pw, db)
execute_list_query(connection, sql, val)

Добро пожаловать в ILS, HANK и SUE!

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

Заключение

Мы охватили много земли в этом руководстве.

Мы узнали, как использовать Python и MySQL Connector для создания совершенно новой базы данных в MySQL Server, создавать таблицы в этой базе данных, определить отношения между этими таблицами и заполнить их с помощью данных.

Мы покрыли, как Создать, прочитать, обновлять и удалять Данные в нашей базе данных.

Мы посмотрели, как извлечь данные из существующих баз данных и загружать их в Pandas DataFrames, готовые к анализу и дальнейшей работы, используя преимущества всех возможностей, предлагаемых Pydata Stack Отказ

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

Я надеюсь, что это учебное пособие помогло вам посмотреть, как мы можем использовать Python и SQL вместе, чтобы еще более эффективно манипулировать данными!

Если вы хотите увидеть больше моих проектов и работы, пожалуйста, посетите мой сайт в craigdoesdata.de Отказ Если у вас есть какие-либо отзывы в этом руководстве, пожалуйста, свяжитесь со мной Прямо – все отзывы тепло получаются!