Python a MySQL: kompletní praktický průvodce, 2. část

Práce se záznamy: vkládání, čtení, úpravy a mazání.

V první části průvodce ses dozvěděl*a, jak připojit MySQL k jazyku Python, jak vytvářet tabulky, upravovat jejich schémata a mazat je.

Teď vyplníš tabulku daty, naučíš se číst záznamy z jedné a více tabulek a upravovat data a mazat záznamy z tabulky.

Vkládání záznamů do tabulky

Pokud jsi postupoval*a podle všech pokynů z předchozí části, měl*a bys teď mít databázi se třemi tabulkami: movies, reviewers a ratings. Teď je naplníme daty.

Existují dva způsoby vkládání záznamů pomocí MySQL Connector pro Python:

metoda .execute() je užitečná, pokud je záznamů málo a mohou být kódovány rigidně;
druhá metoda .executemany() je vhodnější pro reálné scénáře.

Použití metody .execute()

Použijeme metodu cursor.execute(), kterou jsi použil*a dříve. Pro vložení dat do tabulky movies je třeba předat dotaz INSERT INTO.

Nezapomeň, že tabulka movies má pět atributů:

id;
title;
release_year;
genre;
collection_in_mil.

Údaje pro atribut id není třeba přidávat, protože jeho hodnotu automaticky vypočítá funkce AUTO_INCREMENT. Následující skript vloží záznamy do tabulky movies:

insert_movies_query = """
INSERT INTO movies (title, release_year, genre, collection_in_mil)
VALUES
    ("Forrest Gump", 1994, "Drama", 330.2),
    ("3 Idiots", 2009, "Drama", 2.4),
    ("Eternal Sunshine of the Spotless Mind", 2004, "Drama", 34.5),
    ("Good Will Hunting", 1997, "Drama", 138.1),
    ("Skyfall", 2012, "Action", 304.6),
    ("Gladiator", 2000, "Action", 188.7),
    ("Black", 2005, "Drama", 3.0),
    ("Titanic", 1997, "Romance", 659.2),
    ("The Shawshank Redemption", 1994, "Drama",28.4),
    ("Udaan", 2010, "Drama", 1.5),
    ("Home Alone", 1990, "Comedy", 286.9),
    ("Casablanca", 1942, "Romance", 1.0),
    ("Avengers: Endgame", 2019, "Action", 858.8),
    ("Night of the Living Dead", 1968, "Horror", 2.5),
    ("The Godfather", 1972, "Crime", 135.6),
    ("Haider", 2014, "Action", 4.2),
    ("Inception", 2010, "Adventure", 293.7),
    ("Evil", 2003, "Horror", 1.3),
    ("Toy Story 4", 2019, "Animation", 434.9),
    ("Air Force One", 1997, "Drama", 138.1),
    ("The Dark Knight", 2008, "Action",535.4),
    ("Bhaag Milkha Bhaag", 2013, "Sport", 4.1),
    ("The Lion King", 1994, "Animation", 423.6),
    ("Pulp Fiction", 1994, "Crime", 108.8),
    ("Kai Po Che", 2013, "Sport", 6.0),
    ("Beasts of No Nation", 2015, "War", 1.4),
    ("Andadhun", 2018, "Thriller", 2.9),
    ("The Silence of the Lambs", 1991, "Crime", 68.2),
    ("Deadpool", 2016, "Action", 363.6),
    ("Drishyam", 2015, "Mystery", 3.0)
"""
with connection.cursor() as cursor:
    cursor.execute(insert_movies_query)
    connection.commit()

Teď tabulka movies obsahuje třicet záznamů. Na konci kódu je vyvolána metoda connection.commit(). Nezapomeň vyvolat metodu .commit() po provedení jakýchkoli změn v tabulce.

Použití metody .executemany()

Předchozí metoda je užitečná, pokud je záznamů málo a můžeš je umístit do kódu. To je však velmi vzácné. Obvykle jsou data uložena v samostatném souboru nebo generována jiným skriptem a je třeba je vložit do databáze MySQL.

Proto se v reálném životě obvykle používá metoda .executemany(). Ta přijímá dva parametry:

dotaz se specifikacemi záznamů, které mají být vloženy;
seznam obsahující všechny záznamy, které mají být vloženy.

Níže uvedený úryvek kódu vloží záznamy do tabulky reviewers:

insert_reviewers_query = """
INSERT INTO reviewers
(first_name, last_name)
VALUES ( %s, %s )
"""
reviewers_records = [
    ("Chaitanya", "Baweja"),
    ("Mary", "Cooper"),
    ("John", "Wayne"),
    ("Thomas", "Stoneman"),
    ("Penny", "Hofstadter"),
    ("Mitchell", "Marsh"),
    ("Wyatt", "Skaggs"),
    ("Andre", "Veiga"),
    ("Sheldon", "Cooper"),
    ("Kimbra", "Masters"),
    ("Kat", "Dennings"),
    ("Bruce", "Wayne"),
    ("Domingo", "Cortes"),
    ("Rajesh", "Koothrappali"),
    ("Ben", "Glocker"),
    ("Mahinder", "Dhoni"),
    ("Akbar", "Khan"),
    ("Howard", "Wolowitz"),
    ("Pinkie", "Petit"),
    ("Gurkaran", "Singh"),
    ("Amy", "Farah Fowler"),
    ("Marlon", "Crafford"),
]
with connection.cursor() as cursor:
    cursor.executemany(insert_reviewers_query, reviewers_records)
    connection.commit()

Ve výše uvedeném scénáři předáš metodě .executemany() dotaz a seznam záznamů. Tyto záznamy lze převzít ze souboru nebo je může zadat uživatel a uložit je do seznamu reviewers_records.

V tomto kódu je %s použito jako specifikátor pro vložení dvou řetězců, které mají být vloženy do dotazu insert_reviewers_query. Specifikátory označují místo pro vložení hodnoty proměnné do řetězce. Během vykonávání se na toto místo vloží hodnota zadané proměnné.

Teď pomocí metody .executemany() vlož záznamy do tabulky ratings:

insert_ratings_query = """
INSERT INTO ratings
(rating, movie_id, reviewer_id)
VALUES ( %s, %s, %s)
"""
ratings_records = [
    (6.4, 17, 5), (5.6, 19, 1), (6.3, 22, 14), (5.1, 21, 17),
    (5.0, 5, 5), (6.5, 21, 5), (8.5, 30, 13), (9.7, 6, 4),
    (8.5, 24, 12), (9.9, 14, 9), (8.7, 26, 14), (9.9, 6, 10),
    (5.1, 30, 6), (5.4, 18, 16), (6.2, 6, 20), (7.3, 21, 19),
    (8.1, 17, 18), (5.0, 7, 2), (9.8, 23, 3), (8.0, 22, 9),
    (8.5, 11, 13), (5.0, 5, 11), (5.7, 8, 2), (7.6, 25, 19),
    (5.2, 18, 15), (9.7, 13, 3), (5.8, 18, 8), (5.8, 30, 15),
    (8.4, 21, 18), (6.2, 23, 16), (7.0, 10, 18), (9.5, 30, 20),
    (8.9, 3, 19), (6.4, 12, 2), (7.8, 12, 22), (9.9, 15, 13),
    (7.5, 20, 17), (9.0, 25, 6), (8.5, 23, 2), (5.3, 30, 17),
    (6.4, 5, 10), (8.1, 5, 21), (5.7, 22, 1), (6.3, 28, 4),
    (9.8, 13, 1)
]
with connection.cursor() as cursor:
    cursor.executemany(insert_ratings_query, ratings_records)
    connection.commit()

Teď jsou všechny tři tabulky naplněny daty a máš plně funkční databázi s hodnocením filmů.

Dále se musíš naučit, jak s touto databází pracovat.

Čtení záznamů z databáze pomocí příkazu SELECT

Pokud chceš získat záznamy, musíš metodě cursor.execute() předat dotaz SELECT. Poté je třeba použít metodu cursor.fetchall() a získat tabulku jako seznam řádků nebo záznamů.

Napíšeme dotaz MySQL pro výběr záznamů z tabulky movies a předáme jej metodě .execute():

select_movies_query = "SELECT * FROM movies LIMIT 5"
with connection.cursor() as cursor:
    cursor.execute(select_movies_query)
    result = cursor.fetchall()
    for row in result:
        print(row)

Výsledek provedení dotazu:

Proměnná result obsahuje záznamy vrácené metodou .fetchall(). Jedná se o seznam tuplů, které představují jednotlivé záznamy v tabulce.

Výše uvedený dotaz používá klauzuli LIMIT k omezení počtu záznamů, které se načtou z příkazu SELECT. Vývojáři často používají klauzuli LIMIT pro stránkování při zpracování velkého množství dat.

V MySQL má klauzule LIMIT jeden nebo dva nezáporné argumenty. Pokud je použit jeden argument, určuje maximální počet řádků, které mají být vráceny.

Protože tvůj dotaz zadává LIMIT 5, bude vráceno pouze prvních 5 záznamů. Pokud použiješ dva argumenty, první z nich určuje odsazení od prvního záznamu:

SELECT * FROM movies LIMIT 2,5;

První argument udává offset 2 a druhý argument určuje, že má být vráceno 5 záznamů. Výše uvedený dotaz vrátí záznamy od 3 do 7.

Můžeš si také vyžádat data z jednotlivých sloupců:

select_movies_query = "SELECT title, release_year FROM movies LIMIT 5"
with connection.cursor() as cursor:
    cursor.execute(select_movies_query)
    for row in cursor.fetchall():
        print(row)

Výsledek provedení dotazu:

Teď kód zobrazuje hodnoty pouze ze dvou zadaných sloupců: title a release_year.

Filtrování výsledků pomocí klauzule WHERE

Záznamy v tabulce můžete filtrovat podle určitých kritérií pomocí klauzule WHERE. Chcete-li například získat všechny filmy s tržbami vyššími než 300 milionů dolarů, můžete spustit následující dotaz:

SELECT title, collection_in_mil
FROM movies
WHERE collection_in_mil > 300;

V tomto dotazu můžete také použít klauzuli ORDER BY a seřadit výsledky od nejvyšších po nejnižší poplatky:

select_movies_query = """
SELECT title, collection_in_mil
FROM movies
WHERE collection_in_mil > 300
ORDER BY collection_in_mil DESC
"""
with connection.cursor() as cursor:
    cursor.execute(select_movies_query)
    for movie in cursor.fetchall():
        print(movie)

Výsledek provedení dotazu:

MySQL nabízí mnoho operací formátování řetězců, například CONCAT pro spojování řetězců. Aby nedošlo k záměně, často se na webových stránkách uvádí vedle názvu filmu i rok jeho uvedení. Chcete-li získat názvy pěti nejvýdělečnějších filmů a uvést je s rokem uvedení, použijte následující dotaz:

select_movies_query = """
SELECT CONCAT(title, " (", release_year, ")"),
    collection_in_mil
FROM movies
ORDER BY collection_in_mil DESC
LIMIT 5
"""
with connection.cursor() as cursor:
    cursor.execute(select_movies_query)
    for movie in cursor.fetchall():
        print(movie)

Výsledek provedení dotazu:

Pokud nechceš použít klauzuli LIMIT a nepotřebuješ vrátit všechny záznamy, můžeš použít metody objektu cursor .fetchone() a .fetchmany():

.fetchone() získá další výsledný řetězec jako tuple nebo None, pokud žádné řetězce neexistují;
.fetchmany() získá další sadu výsledných řetězců jako seznam tuplů. Přijímá argument size, který je ve výchozím nastavení 1. Udává, kolik řádků se má načíst. Když řádky dojdou, metoda vrátí prázdný seznam.

Přepišme kód tak, abychom získali pět nejvýdělečnějších filmů podle roku vydání pomocí metody .fetchmany():

select_movies_query = """
SELECT CONCAT(title, " (", release_year, ")"),
    collection_in_mil
FROM movies
ORDER BY collection_in_mil DESC
"""
with connection.cursor() as cursor:
    cursor.execute(select_movies_query)
    for movie in cursor.fetchmany(size=5):
        print(movie)
    cursor.fetchall()

Výsledek provedení dotazu:

Výstup při použití metody .fetchmany() je podobný výstupu získanému pomocí klauzule LIMIT. Možná sis všiml*a dodatečného vyvolání metody cursor.fetchall() na konci. To se provádí za účelem vymazání zbytku výsledků, které nebyly načteny metodou .fetchmany().

Pokud chceš po provedení jednoho příkazu s určitým připojením použít stejné připojení k provedení dalšího příkazu, musíš nejprve vymazat všechny nepřečtené výsledky. Pokud tak neučiníš, bude vyhozena výjimka InternalError: Unread result found.

Práce s více tabulkami pomocí klauzule JOIN

Pokud chceš zjistit názvy pěti nejvýdělečnějších filmů v databázi, můžeš spustit následující dotaz:

select_movies_query = """
SELECT title, AVG(rating) as average_rating
FROM ratings
INNER JOIN movies
    ON movies.id = ratings.movie_id
GROUP BY movie_id
ORDER BY average_rating DESC
LIMIT 5
"""
with connection.cursor() as cursor:
    cursor.execute(select_movies_query)
    for movie in cursor.fetchall():
        print(movie)

Výsledek provedení dotazu:

Jak je uvedeno výše, nejlépe hodnocenými filmy ve tvojí databázi jsou Kmotr (The Godfather) a Noc oživlých mrtvol (Night of the Living Dead).

Pokud chceš zjistit jméno uživatele, který udělil nejvíce hodnocení, odešli následující požadavek:

select_movies_query = """
SELECT CONCAT(first_name, " ", last_name), COUNT(*) as num
FROM reviewers
INNER JOIN ratings
    ON reviewers.id = ratings.reviewer_id
GROUP BY reviewer_id
ORDER BY num DESC
LIMIT 1
"""
with connection.cursor() as cursor:
    cursor.execute(select_movies_query)
    for movie in cursor.fetchall():
        print(movie)

Výsledek provedení dotazu:

Mary Cooper má v této databázi nejvyšší počet hodnocení.

Jak vidíš, na složitosti dotazu nezáleží, protože jej nakonec zpracuje server MySQL. A pro tebe se tento proces v každém případě bude skládat z následujících kroků:

předat požadavek metodě cursor.execute();
získat výsledek pomocí metody .fetchall().

Aktualizace záznamů a jejich odstranění z databáze

Příkaz UPDATE

Představme si, že máš následující úkol: postava Amy Farah Fowler se vdává za Sheldona Coopera a mění si příjmení, takže je třeba provést změny v databázi. K aktualizaci záznamů používá MySQL příkaz UPDATE:

update_query = """
UPDATE
    reviewers
SET
    last_name = "Cooper"
WHERE
    first_name = "Amy"
"""
with connection.cursor() as cursor:
    cursor.execute(update_query)
    connection.commit()

Tento kód odešle požadavek na aktualizaci metodě cursor.execute() a metoda .commit() provede potřebné změny v tabulce reviewers.

Poznámka. V dotazu UPDATE můžeš pomocí klauzule WHERE určit záznamy, které chceš aktualizovat. Pokud klauzuli WHERE nepoužiješ, budou aktualizovány všechny záznamy.

Řekněme, že potřebujeme možnost, která uživatelům umožní změnit hodnocení. Uživatel zadá tři hodnoty:

movie_id;
reviewer_id;
nový význam rating.

Kód zobrazí záznam po zadání požadovaných změn.

Předpokládejme, že movie_id = 18, reviewer_id = 15 a nová hodnota hodnocení je 5,0. Pro provedení změny použij následující dotazy MySQL:

UPDATE
    ratings
SET
    rating = 5.0
WHERE
    movie_id = 18 AND reviewer_id = 15;

SELECT *
FROM ratings
WHERE
    movie_id = 18 AND reviewer_id = 15;

Výše uvedené dotazy nejprve změní hodnocení a poté vrátí hodnotu. Můžeš vytvořit skript v jazyce Python, který se připojí k databázi a umožní uživateli změnit hodnocení:

from getpass import getpass
from mysql.connector import connect, Error

movie_id = input("Введіть id фільму: ")
reviewer_id = input("Введіть id користувача: ")
new_rating = input("Введіть новий рейтинг: ")
update_query = """
UPDATE
    ratings
SET
    rating = "%s"
WHERE
    movie_id = "%s" AND reviewer_id = "%s";

SELECT *
FROM ratings
WHERE
    movie_id = "%s" AND reviewer_id = "%s"
""" % (
    new_rating,
    movie_id,
    reviewer_id,
    movie_id,
    reviewer_id,
)

try:
    with connect(
        host="localhost",
        user=input("Введіть ім'я користувача: "),
        password=getpass("Введіть пароль: "),
        database="movie_rating",
    ) as connection:
        with connection.cursor() as cursor:
            for result in cursor.execute(update_query, multi=True):
                if result.with_rows:
                    print(result.fetchall())
            connection.commit()
except Error as e:
    print(e)

Tento kód ulož do souboru s názvem modify_ratings.py.

Výše uvedený kód používá specifikátory %s k nahrazení přijatého vstupu do řetězce update_query. Poprvé v této příručce je v jednom řádku předáno více dotazů. Pokud chceš metodě cursor.execute() předat více dotazů, musíš parametr multi nastavit na hodnotu True.

Pokud je hodnota multi True, funkce cursor.execute() vrací iterátor. Každý prvek iterátoru odpovídá objektu kurzoru, který provede příkaz předaný v požadavku. Ve výše uvedeném kódu je na tento iterátor aplikována smyčka for a poté je pro každý objekt kurzoru vyvolána metoda .fetchall().

Poznámka: Je velmi důležité vyvolat metodu .fetchall() pro všechny kurzory. Když chceš provést nový příkaz pomocí stejného spojení, musíš se zbavit nepřečtených záznamů, které zůstaly z předchozích provedení. Pokud existují nepřečtené výsledky, bude vyhozena výjimka.

Pokud operace nevrátí sadu výsledků, funkce .fetchall() vyhodí výjimku. Abychom se této chybě vyhnuli, používá výše uvedený kód vlastnost cursor.with_rows, která indikuje, zda předchozí operace vrátila řádky.

Přestože tento kód splní tvůj úkol, klauzule WHERE je často využívána hackery. Je zranitelná vůči takzvaným útokům SQL injection, které útočníkům umožňují poškodit data nebo použít tvoji databázi pro vlastní účely.

Upozornění: V případě, že se ti podaří získat údaje z databáze, můžeš je použít jako zdrojové kódy. Nepoužívej následující vstupní data pro svoji databázi. Poškodí tabulku a budeš ji muset vytvořit znovu.

Pokud například uživatel zadá movie_id=18, reviewer_id=15 a rating=5,0, bude výstup vypadat následovně:

Hodnoty rating pro movie_id=18 a reviewer_id=15 byly změněny na 5,0. Pokud bys však byl*a hacker*ka, mohl*a bys zadat skrytý příkaz:

Výstup opět ukazuje, že zadané hodnocení bylo změněno na 5,0. Co se změnilo?

Hacker*ka upravil*a aktualizační dotaz při zadávání údajů pro reviewer_id. Aktualizační dotaz update reviewers set lastname = „A“ změnil hodnotu last_name všech záznamů v tabulce reviewers na „A“. Tuto změnu můžeš vidět při vypisování tabulky reviewers:

 select_query = """
... SELECT first_name, last_name
... FROM reviewers
... """
 with connection.cursor() as cursor:
...     cursor.execute(select_query)
...     for reviewer in cursor.fetchall():
...         print(reviewer)

Výsledek provedení dotazu:

Výše uvedený kód zobrazí firstname a lastname pro všechny záznamy v tabulce reviewers. Útok SQL injection poškodil tabulku tím, že u všech záznamů změnil last_name na A.

Existuje rychlá oprava, která takovým útokům zabrání. Nepřidávej hodnoty zadané uživatelem přímo do řetězce dotazu. Místo toho uprav skript modify_ratings.py tak, aby tyto hodnoty předával jako argumenty příkazu .execute():

from getpass import getpass
from mysql.connector import connect, Error

movie_id = input("Enter movie id: ")
reviewer_id = input("Enter reviewer id: ")
new_rating = input("Enter new rating: ")
update_query = """
UPDATE
    ratings
SET
    rating = %s
WHERE
    movie_id = %s AND reviewer_id = %s;

SELECT *
FROM ratings
WHERE
    movie_id = %s AND reviewer_id = %s
"""
val_tuple = (
    new_rating,
    movie_id,
    reviewer_id,
    movie_id,
    reviewer_id,
)

try:
    with connect(
        host="localhost",
        user=input("Enter username: "),
        password=getpass("Enter password: "),
        database="online_movie_rating",
    ) as connection:
        with connection.cursor() as cursor:
            for result in cursor.execute(update_query, val_tuple, multi=True):
                if result.with_rows:
                    print(result.fetchall())
            connection.commit()
except Error as e:
    print(e)

Upozorňujeme, že specifikátory %s jsou teď bez uvozovek. Řetězce předávané ve specifikátorech mohou obsahovat speciální znaky. V případě potřeby je můžeš escapovat pomocí knihovny.

Funkce cursor.execute() zajistí, aby hodnoty z tuple přijaté jako argument byly požadovaného datového typu. Pokud se uživatel pokusí vložit speciální znaky, kód vyhodí výjimku:

cursor.execute() vyhodí výjimku, pokud v uživatelském vstupu najde neplatné znaky. Tento přístup by měl být použit vždy, když do dotazu vkládáš uživatelský vstup. Existují i další způsoby, jak zabránit útokům SQL injection.

Operátor DELETE

Proces mazání záznamů je podobný procesu jejich aktualizace. Pro odstranění vybraných záznamů použij příkaz DELETE.

Důležité! Odstranění je nevratný proces. Pokud nepoužiješ klauzuli WHERE, budou odstraněny všechny záznamy ze zadané tabulky. Pokud chceš obnovit smazané záznamy, musíš znovu provést dotaz INSERT INTO.

Doporučujeme nejprve spustit dotaz SELECT se stejným filtrem, aby ses ujistil*a, že mažeš příslušné záznamy. Pokud chceš například odstranit všechna hodnocení zadaná uživatelem s reviewer_id = 2, musíš nejprve spustit dotaz SELECT se stejným filtrem:

select_movies_query = """
SELECT reviewer_id, movie_id FROM ratings
WHERE reviewer_id = 2
"""
with connection.cursor() as cursor:
    cursor.execute(select_movies_query)
    for movie in cursor.fetchall():
         print(movie)

Výsledek provedení dotazu:

Výše uvedený úryvek kódu zobrazí reviewer_id a movie_id pro záznamy v tabulce ratings, kde reviewer_id = 2. Jakmile si budeš jistý*jistá tím, že se jedná o záznamy, které chceš odstranit, můžeš spustit dotaz DELETE se stejným filtrem:

delete_query = "DELETE FROM ratings WHERE reviewer_id = 2"
with connection.cursor() as cursor:
    cursor.execute(delete_query)
    connection.commit()

Tímto dotazem odstraníš z tabulky hodnocení všechna hodnocení uživatele s reviewer_id = 2.

Další způsoby připojení Python k MySQL

V celém tomto průvodci jsi používal*a MySQL Connector/Python, což je oficiálně doporučený způsob interakce s databází MySQL z prostředí Pythonu. Existují ještě dva další populární konektory:

mysqlclient je knihovna, která je blízkou konkurencí oficiálního konektoru a je aktivně aktualizována o nové funkce. Jelikož je jádro této knihovny napsáno v jazyce C, je její výkon vyšší než u oficiálního konektoru, který je napsán v čistém jazyce Python. Velkou nevýhodou mysqlclient je složitost instalace a konfigurace, zejména v systému Windows.
MySQLdb je zastaralý software, který se stále používá v komerčních aplikacích. Je napsán v jazyce C a je rychlejší než MySQL Connector/Python, ale je k dispozici pouze pro Python 2.

Tyto konektory slouží jako rozhraní mezi aplikací a databází MySQL, přes které se odesílají dotazy SQL. Mnoho vývojářů však dává při správě databází přednost objektově orientovanému paradigmatu před SQL.

Objektově-relační mapování (ORM) je technologie, která umožňuje číst a spravovat data přímo z databáze pomocí objektově orientovaného jazyka.

Knihovna ORM zapouzdřuje kód potřebný ke správě dat, čímž eliminuje potřebu používat jazyk SQL. Tady jsou nejoblíbenější ORM v jazyce Python pro databáze založené na SQL:

SQLAlchemy je ORM, který zjednodušuje interakci mezi databázemi Python a SQL. Můžeš vytvářet subsystémy pro různé databáze, například MySQL, PostgreSQL, SQLite atd. SQLAlchemy se obvykle používá s knihovnou Pandas, která poskytuje plnohodnotný datový workflow.
Peewee je malý a rychlý ORM, který lze rychle nastavit. Je velmi efektivní, pokud potřebuješ z databáze získat pouze několik záznamů. Pokud například potřebuješ zkopírovat vybrané záznamy z databáze MySQL do souboru CSV, může být peewee tou nejlepší volbou.
Django ORM je jednou z nejvýkonnějších funkcí Django a a je dodáván s webovým frameworkem Django. Tento ORM může spolupracovat s různými databázemi, včetně SQLite, PostgreSQL a MySQL. Mnoho aplikací založených na Django používá Django ORM pro modelování dat a základní dotazy, ale pro složitější případy používají SQLAlchemy.

Možná, že jeden z těchto přístupů bude pro tvoji aplikaci užitečnější. Pokud ale nevíš, který z nich použít, je lepší použít oficiálně doporučovaný konektor MySQL/Python.

Závěr

V tomto průvodci ses dozvěděl*a, jak pomocí nástroje MySQL Connector/Python integrovat databázi MySQL s aplikací v jazyce Python, o některých jedinečných vlastnostech MySQL, které ji odlišují od systémů pro správu databází založených na SQL, a o programovacích pokynech pro navázání spojení, vytváření tabulek, vkládání a úpravu záznamů v databázové aplikaci.

Vypracoval*a jsi také příklad databáze MySQL pro systém hodnocení filmů a přímou interakci s ní z programu v jazyce Python.

Autor: Andriy Denysenko

Sdílet: