Как да създавате и манипулирате SQL бази данни с Python

Python и SQL са два от най-важните езици за анализаторите на данни.

В тази статия ще ви преведа през всичко, което трябва да знаете, за да свържете Python и SQL.

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

Заедно ще покрием:

• Защо да научите как да използвате Python и SQL заедно?
• Как да настроите вашата среда на Python и MySQL сървър
• Свързване с MySQL сървър в Python
• Създаване на нова база данни
• Създаване на таблици и връзки на таблици
• Попълване на таблици с данни
• Четене на данни
• Актуализиране на записи
• Изтриване на записи
• Създаване на записи от списъци на Python
• Създаване на функции за повторно използване, за да направим всичко това вместо нас в бъдеще

Това са много полезни и страхотни неща. Нека да влезем в него!

Една бърза бележка, преди да започнем:има Jupyter Notebook, съдържащ целия код, използван в този урок, наличен в това хранилище на GitHub. Препоръчително е да кодирате заедно!

Използваните тук база данни и SQL код са от предишната ми серия Въведение в SQL, публикувана в Towards Data Science (свържете се с мен, ако имате проблеми с разглеждането на статиите и мога да ви изпратя връзка, за да ги видите безплатно).

Ако не сте запознати със SQL и концепциите зад релационни бази данни, бих ви насочил към тази серия (плюс, разбира се, има огромно количество страхотни неща, налични тук във freeCodeCamp!)

Защо Python с SQL?

За анализатори на данни и специалисти по данни, Python има много предимства. Огромна гама от библиотеки с отворен код го правят невероятно полезен инструмент за всеки анализатор на данни.

Имаме pandas, NumPy и Vaex за анализ на данни, Matplotlib, seaborn и Bokeh за визуализация и TensorFlow, scikit-learn и PyTorch за приложения за машинно обучение (плюс много, много други).

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

Така че, ако използваме Python за анализ на данни, си струва да се запитаме – откъде идват всички тези данни?

Въпреки че има огромно разнообразие от източници за набори от данни, в много случаи - особено в корпоративния бизнес - данните ще се съхраняват в релационна база данни. Релационните бази данни са изключително ефективен, мощен и широко използван начин за създаване, четене, актуализиране и изтриване на данни от всякакъв вид.

Най-широко използваните системи за управление на релационни бази данни (RDBMS) - Oracle, MySQL, Microsoft SQL Server, PostgreSQL, IBM DB2 - всички използват Structured Query Language (SQL) за достъп и извършване на промени в данните.

Имайте предвид, че всяка RDBMS използва малко по-различен вкус на SQL, така че SQL кодът, написан за един, обикновено няма да работи в друг без (обикновено сравнително малки) модификации. Но концепциите, структурите и операциите са до голяма степен идентични.

Това означава, че за работещ анализатор на данни силното разбиране на SQL е изключително важно. Знанието как да използвате Python и SQL заедно ще ви даде още по-голямо предимство, когато става въпрос за работа с вашите данни.

Останалата част от тази статия ще бъде посветена на това да ви покажем как точно можем да направим това.

Първи стъпки

Изисквания и инсталиране

За да кодирате заедно с този урок, ще ви е необходима собствена настройка на Python среда.

Използвам Anaconda, но има много начини да направя това. Просто потърсете в Google "как да инсталирате Python", ако имате нужда от допълнителна помощ. Можете също да използвате Binder за кодиране заедно със свързания Jupyter Notebook.

Ще използваме MySQL Community Server, тъй като е безплатен и широко използван в индустрията. Ако използвате Windows, това ръководство ще ви помогне да се настроите. Ето и ръководства за потребители на Mac и Linux (въпреки че може да варира в зависимост от дистрибуцията на Linux).

След като ги настроите, ще трябва да ги накараме да комуникират помежду си.

За това трябва да инсталираме библиотеката MySQL Connector Python. За да направите това, следвайте инструкциите или просто използвайте pip:

pip install mysql-connector-python

Ние също ще използваме pandas, така че се уверете, че сте инсталирали и това.

pip install pandas

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

Както при всеки проект в Python, първото нещо, което искаме да направим, е да импортираме нашите библиотеки.

Най-добрата практика е да импортираме всички библиотеки, които ще използваме в началото на проекта, така че хората, които четат или преглеждат нашия код, да знаят приблизително какво предстои, така че да няма изненади.

За този урок ще използваме само две библиотеки – MySQL Connector и pandas.

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

Импортираме функцията Error отделно, за да имаме лесен достъп до нея за нашите функции.

Свързване с MySQL сървър

До този момент трябва да имаме 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) и да назоваваме аргументите, които тази функция ще приеме (име на хост, потребителско_име и потребителска_парола).

Следващият ред затваря всички съществуващи връзки, така че сървърът да не се бърка с множество отворени връзки.

След това използваме Python try-except блок за обработка на евентуални грешки. Първата част се опитва да създаде връзка със сървъра с помощта на метода 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 Connector използва обектно-ориентирана парадигма за програмиране, така че има много обекти, наследяващи свойства от родителски обекти).

Този обект на курсора има методи като execute, executemany (които ще използваме в този урок) заедно с няколко други полезни метода.

Ако това помогне, можем да мислим за обекта на курсора като за достъп до мигащия курсор в терминален прозорец на MySQL Server.

След това дефинираме заявка за създаване на базата данни и извикваме функцията:

Всички SQL заявки, използвани в този урок, са обяснени в моята серия от уроци Въведение в SQL и пълният код може да бъде намерен в свързания Jupyter Notebook в това хранилище на GitHub, така че няма да давам обяснения за това какво прави SQL кодът в това урок.

Това обаче е може би най-простата възможна SQL заявка. Ако можете да четете английски, вероятно ще разберете какво прави!

Изпълнението на функцията create_database с аргументите, както по-горе, води до създаване на база данни, наречена 'school', в нашия сървър.

Защо нашата база данни се нарича „училище“? Може би сега би било подходящ момент да разгледаме по-подробно какво точно ще приложим в този урок.

Нашата база данни

Следвайки примера от предишната ми серия, ще внедрим базата данни за Международната езикова гимназия - измислена езикова школа, която предоставя професионални езикови уроци на корпоративни клиенти.

Тази диаграма на взаимоотношенията на обектите (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 заявки, са внедрени.

Това ще бъде нашата функция на работния кон, която ще използваме (заедно с 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 за многоредови низове, за да съхраняваме нашата SQL заявка, след което я подаваме в нашата функция execute_query, за да я приложим.

Имайте предвид, че това многоредово форматиране е само в полза на хората, които четат нашия код. Нито SQL, нито Python се „грижат“ дали SQL командата е разпределена по този начин. Докато синтаксисът е правилен, и двата езика ще го приемат.

В полза на хората, които ще четат кода ви обаче (дори ако това ще бъде само за вас!) е много полезно да направите това, за да направите кода по-четлив и разбираем.

Същото важи и за КАПИТАЛИЗАЦИЯТА на операторите в SQL. Това е широко използвана конвенция, която силно се препоръчва, но действителният софтуер, който изпълнява кода, не е чувствителен към малки и големи букви и ще третира „CREATE TABLE teacher“ и „create table teacher“ като идентични команди.

Изпълнението на този код ни дава нашите съобщения за успех. Можем също да проверим това в клиента на командния ред на 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)

Точно това, което очакваме. Функцията работи и с по-сложни заявки, като тази, включваща JOIN на курсови и клиентски таблици.

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)

Форматиране на изхода в pandas DataFrame

За анализатори на данни, използващи Python, pandas е нашият красив и доверен стар приятел. Много е лесно да конвертирате изхода от нашата база данни в 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 е уведомен, че един от съществуващите му клиенти, Федерацията за големия бизнес, премества офиси на 23 Fingiertweg, 14534 Берлин. В този случай администраторът на базата данни (това сме ние!) ще трябва да направи някои промени.

За щастие можем да направим това с нашата функция execute_query заедно с оператора SQL UPDATE.

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 е много важна тук. Ако изпълним тази заявка без клаузата WHERE, тогава всички адреси за всички записи в нашата клиентска таблица ще бъдат актуализирани до 23 Fingiertweg. Това до голяма степен не е това, което искаме да направим.

Също така имайте предвид, че използвахме „WHERE client_id =101“ в заявката UPDATE. Също така би било възможно да се използва "WHERE client_name ='Big Business Federation'" или "WHERE address ='123 Falschungstraße, 10999 Berlin'" или дори "WHERE адрес КАТО '%Falschung%'".

Важното е, че клаузата WHERE ни позволява уникално да идентифицираме записа (или записите), които искаме да актуализираме.

Изтриване на записи

Възможно е също да използвате нашата функция execute_query, за да изтриете записи, като използвате DELETE.

Когато използваме SQL с релационни бази данни, трябва да внимаваме с оператора DELETE. Това не е Windows, няма „Сигурни ли сте, че искате да изтриете това?“ изскачащ прозорец с предупреждение и няма кош за рециклиране. След като изтрием нещо, то наистина го няма.

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

Първо нека си припомним какви курсове имаме.

Да кажем, че курс 20, „Fortgeschrittenes Russisch“ (това е „Advanced Russian“ за вас и мен), е към своя край, така че трябва да го премахнем от нашата база данни.

На този етап изобщо няма да бъдете изненадани от това как правим това – запазете SQL командата като низ, след което я подайте в нашата функция execute_query.

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

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

Нека проверим, за да потвърдим, че има предвидения ефект:

„Advanced Russian“ изчезна, както очаквахме.

Това също работи с изтриване на цели колони с помощта на DROP COLUMN и цели таблици с помощта на команди DROP TABLE, но няма да ги разглеждаме в този урок.

Продължете и експериментирайте с тях обаче – няма значение дали изтривате колона или таблица от база данни за измислено училище и е добра идея да се научите добре с тези команди, преди да преминете към производствена среда.

О, CRUD

До този момент вече сме в състояние да завършим четирите основни операции за постоянно съхранение на данни.

Научихме се как да:

• Създаване – изцяло нови бази данни, таблици и записи
• Четене – извличане на данни от база данни и съхраняване на тези данни в множество формати
• Актуализиране – направете промени в съществуващите записи в базата данни
• Изтриване – премахване на записи, които вече не са необходими

Това са фантастично полезни неща, които можете да правите.

Преди да приключим нещата тук, имаме още едно много удобно умение, което да научим.

Създаване на записи от списъци

Когато попълваме нашите таблици, видяхме, че можем да използваме командата SQL INSERT в нашата функция execute_query, за да вмъкнем записи в нашата база данни.

Като се има предвид, че използваме Python за манипулиране на нашата SQL база данни, би било полезно да можем да вземем структура от данни на Python (като списък) и да я вмъкнем директно в нашата база данни.

Това може да бъде полезно, когато искаме да съхраняваме регистрационни файлове с активността на потребителите в приложение за социални медии, което сме написали на Python, или въведено от потребителите в Wiki, което сме изградили, например. Има толкова много възможни приложения за това, колкото можете да се сетите.

Този метод също е по-сигурен, ако нашата база данни е отворена за нашите потребители по всяко време, тъй като помага за предотвратяване на атаки срещу SQL инжектиране, които могат да повредят или дори да унищожат цялата ни база данни.

За да направим това, ще напишем функция, използвайки метода executemany(), вместо по-простия метод execute(), който използвахме досега.

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' като заместител за нашата стойност. Приликата с заместващия елемент '%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, Ханк и Сю!

This is yet another deeply useful function, allowing us to take data generated in our Python scripts and applications, and enter them directly into our database.

Заключение

We have covered a lot of ground in this tutorial.

We have learned how to use Python and MySQL Connector to create an entirely new database in MySQL Server, create tables within that database, define the relationships between those tables, and populate them with data.

We have covered how to Create, Read, Update and Delete data in our database.

We have looked at how to extract data from existing databases and load them into pandas DataFrames, ready for analysis and further work taking advantage of all the possibilities offered by the PyData stack.

Going in the other direction, we have also learned how to take data generated by our Python scripts and applications, and write those into a database where they can be safely stored for later retrieval and manipulation.

I hope this tutorial has helped you to see how we can use Python and SQL together to be able to manipulate data even more effectively!

If you'd like to see more of my projects and work, please visit my website at craigdoesdata.de. If you have any feedback on this tutorial, please contact me directly - all feedback is warmly received!