Cara Membuat dan Memanipulasi Database SQL dengan Python

Python dan SQL adalah dua bahasa terpenting bagi Analis Data.

Dalam artikel ini saya akan memandu Anda melalui semua yang perlu Anda ketahui untuk menghubungkan Python dan SQL.

Anda akan belajar cara menarik data dari database relasional langsung ke saluran pembelajaran mesin Anda, menyimpan data dari aplikasi Python Anda dalam database Anda sendiri, atau kasus penggunaan lain apa pun yang mungkin Anda temukan.

Bersama-sama kita akan membahas:

• Mengapa mempelajari cara menggunakan Python dan SQL bersama-sama?
• Cara menyiapkan lingkungan Python dan Server MySQL
• Menghubungkan ke Server MySQL dengan Python
• Membuat Basis Data baru
• Membuat Tabel dan Hubungan Tabel
• Mengisi Tabel dengan Data
• Membaca Data
• Memperbarui Catatan
• Menghapus Catatan
• Membuat Catatan dari Daftar Python
• Membuat fungsi yang dapat digunakan kembali untuk melakukan semua ini untuk kita di masa mendatang

Itu banyak hal yang sangat berguna dan sangat keren. Mari kita masuk ke dalamnya!

Catatan singkat sebelum kita mulai:ada Jupyter Notebook yang berisi semua kode yang digunakan dalam tutorial ini yang tersedia di repositori GitHub ini. Pengkodean bersama sangat dianjurkan!

Basis data dan kode SQL yang digunakan di sini semuanya dari seri Pengantar SQL saya sebelumnya yang diposting di Towards Data Science (hubungi saya jika Anda memiliki masalah dalam melihat artikel dan saya dapat mengirimi Anda tautan untuk melihatnya secara gratis).

Jika Anda tidak terbiasa dengan SQL dan konsep di balik basis data relasional, saya akan mengarahkan Anda ke seri itu (ditambah tentu saja ada banyak hal hebat yang tersedia di sini di freeCodeCamp!)

Mengapa Python dengan SQL?

Untuk Analis Data dan Ilmuwan Data, Python memiliki banyak keunggulan. Sejumlah besar pustaka sumber terbuka menjadikannya alat yang sangat berguna untuk Analis Data mana pun.

Kami memiliki panda, NumPy, dan Vaex untuk analisis data, Matplotlib, seaborn, dan Bokeh untuk visualisasi, serta TensorFlow, scikit-learn, dan PyTorch untuk aplikasi pembelajaran mesin (ditambah banyak lagi).

Dengan kurva belajar yang (relatif) mudah dan keserbagunaannya, tidak mengherankan jika Python adalah salah satu bahasa pemrograman yang tumbuh paling cepat di luar sana.

Jadi jika kita menggunakan Python untuk analisis data, ada baiknya bertanya - dari mana semua data ini berasal?

Meskipun ada banyak sekali sumber untuk kumpulan data, dalam banyak kasus - terutama dalam bisnis perusahaan - data akan disimpan dalam database relasional. Basis data relasional adalah cara yang sangat efisien, kuat, dan banyak digunakan untuk membuat, membaca, memperbarui, dan menghapus semua jenis data.

Sistem manajemen basis data relasional (RDBMS) yang paling banyak digunakan - Oracle, MySQL, Microsoft SQL Server, PostgreSQL, IBM DB2 - semuanya menggunakan Structured Query Language (SQL) untuk mengakses dan membuat perubahan pada data.

Perhatikan bahwa setiap RDBMS menggunakan rasa SQL yang sedikit berbeda, jadi kode SQL yang ditulis untuk satu biasanya tidak akan berfungsi di yang lain tanpa modifikasi (biasanya cukup kecil). Tetapi konsep, struktur, dan operasinya sebagian besar identik.

Ini berarti untuk Analis Data yang bekerja, pemahaman yang kuat tentang SQL sangat penting. Mengetahui cara menggunakan Python dan SQL bersama-sama akan memberi Anda lebih banyak keuntungan dalam hal bekerja dengan data Anda.

Bagian selanjutnya dari artikel ini akan dikhususkan untuk menunjukkan kepada Anda bagaimana kami dapat melakukannya.

Memulai

Persyaratan &Pemasangan

Untuk membuat kode bersama dengan tutorial ini, Anda memerlukan pengaturan lingkungan Python Anda sendiri.

Saya menggunakan Anaconda, tetapi ada banyak cara untuk melakukan ini. Hanya google "cara menginstal Python" jika Anda memerlukan bantuan lebih lanjut. Anda juga dapat menggunakan Binder untuk membuat kode bersama dengan Jupyter Notebook terkait.

Kami akan menggunakan MySQL Community Server karena gratis dan banyak digunakan di industri. Jika Anda menggunakan Windows, panduan ini akan membantu Anda mengatur. Berikut adalah panduan untuk pengguna Mac dan Linux juga (walaupun mungkin berbeda menurut distribusi Linux).

Setelah Anda mengaturnya, kita perlu membuatnya berkomunikasi satu sama lain.

Untuk itu, kita perlu menginstal library Python Connector MySQL. Untuk melakukannya, ikuti petunjuknya, atau cukup gunakan pip:

pip install mysql-connector-python

Kami juga akan menggunakan panda, jadi pastikan Anda juga menginstalnya.

pip install pandas

Mengimpor Perpustakaan

Seperti setiap proyek di Python, hal pertama yang ingin kita lakukan adalah mengimpor perpustakaan kita.

Ini adalah praktik terbaik untuk mengimpor semua perpustakaan yang akan kita gunakan di awal proyek, sehingga orang yang membaca atau meninjau kode kita tahu kira-kira apa yang akan datang sehingga tidak ada kejutan.

Untuk tutorial ini, kita hanya akan menggunakan dua library - MySQL Connector dan pandas.

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

Kami mengimpor fungsi Error secara terpisah sehingga kami memiliki akses mudah ke fungsi tersebut.

Menghubungkan ke Server MySQL

Pada titik ini kita harus sudah menyiapkan Server Komunitas MySQL di sistem kita. Sekarang kita perlu menulis beberapa kode dalam Python yang memungkinkan kita membuat koneksi ke server itu.

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

Membuat fungsi yang dapat digunakan kembali untuk kode seperti ini adalah praktik terbaik, sehingga kita dapat menggunakannya lagi dan lagi dengan sedikit usaha. Setelah ini ditulis, Anda dapat menggunakannya kembali di semua proyek Anda di masa mendatang juga, jadi di masa mendatang-Anda akan berterima kasih!

Mari kita bahas baris demi baris agar kita memahami apa yang terjadi di sini:

Baris pertama adalah kita memberi nama fungsi (create_server_connection) dan memberi nama argumen yang akan digunakan fungsi itu (host_name, user_name dan user_password).

Baris berikutnya menutup koneksi yang ada sehingga server tidak bingung dengan beberapa koneksi terbuka.

Selanjutnya kita menggunakan blok coba-kecuali Python untuk menangani potensi kesalahan apa pun. Bagian pertama mencoba membuat koneksi ke server menggunakan metode mysql.connector.connect() menggunakan detail yang ditentukan oleh pengguna dalam argumen. Jika ini berhasil, fungsi akan mencetak pesan sukses kecil yang menyenangkan.

Bagian kecuali dari blok mencetak kesalahan yang dikembalikan Server MySQL, dalam keadaan yang tidak menguntungkan bahwa ada kesalahan.

Terakhir, jika koneksi berhasil, fungsi mengembalikan objek koneksi.

Kami menggunakan ini dalam praktik dengan menetapkan output fungsi ke variabel, yang kemudian menjadi objek koneksi kami. Kami kemudian dapat menerapkan metode lain (seperti kursor) padanya dan membuat objek berguna lainnya.

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

Ini akan menghasilkan pesan sukses:

Membuat Database Baru

Sekarang kita telah membuat koneksi, langkah kita selanjutnya adalah membuat database baru di server kita.

Dalam tutorial ini kita akan melakukan ini hanya sekali, tetapi sekali lagi kita akan menulis ini sebagai fungsi yang dapat digunakan kembali sehingga kita memiliki fungsi berguna yang bagus yang dapat kita gunakan kembali untuk proyek mendatang.

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

Fungsi ini membutuhkan dua argumen, koneksi (objek koneksi kami) dan kueri (kueri SQL yang akan kami tulis di langkah berikutnya). Itu mengeksekusi kueri di server melalui koneksi.

Kami menggunakan metode kursor pada objek koneksi kami untuk membuat objek kursor (Konektor MySQL menggunakan paradigma pemrograman berorientasi objek, jadi ada banyak objek yang mewarisi properti dari objek induk).

Objek kursor ini memiliki metode seperti mengeksekusi, mengeksekusi banyak (yang akan kita gunakan dalam tutorial ini) bersama dengan beberapa metode berguna lainnya.

Jika itu membantu, kita dapat menganggap objek kursor sebagai memberikan kita akses ke kursor yang berkedip di jendela terminal Server MySQL.

Selanjutnya kita mendefinisikan query untuk membuat database dan memanggil fungsi:

Semua kueri SQL yang digunakan dalam tutorial ini dijelaskan dalam seri tutorial Pengantar SQL saya, dan kode lengkapnya dapat ditemukan di Jupyter Notebook terkait di repositori GitHub ini, jadi saya tidak akan memberikan penjelasan tentang apa yang dilakukan kode SQL dalam hal ini. tutorial.

Ini mungkin kueri SQL yang paling sederhana. Jika Anda dapat membaca bahasa Inggris, Anda mungkin dapat mengetahui apa fungsinya!

Menjalankan fungsi create_database dengan argumen seperti di atas menghasilkan database yang disebut 'sekolah' yang dibuat di server kami.

Mengapa database kami disebut 'sekolah'? Mungkin sekarang saat yang tepat untuk melihat lebih detail apa yang akan kita terapkan dalam tutorial ini.

Database Kami

Mengikuti contoh di seri saya sebelumnya, kami akan mengimplementasikan database untuk International Language School - sekolah pelatihan bahasa fiksi yang menyediakan pelajaran bahasa profesional untuk klien korporat.

Diagram Hubungan Entitas (ERD) ini memaparkan entitas kami (Guru, Klien, Kursus, dan Peserta) dan mendefinisikan hubungan di antara mereka.

Semua informasi mengenai apa itu ERD dan apa yang harus dipertimbangkan saat membuat dan mendesain database dapat ditemukan di artikel ini.

Kode SQL mentah, persyaratan database, dan data untuk masuk ke database semuanya terkandung dalam repositori GitHub ini, tetapi Anda akan melihat semuanya saat kita melalui tutorial ini juga.

Menghubungkan ke Basis Data

Sekarang kita telah membuat database di MySQL Server, kita dapat memodifikasi fungsi create_server_connection kita untuk terhubung langsung ke database ini.

Perhatikan bahwa mungkin - umum, pada kenyataannya - untuk memiliki beberapa database pada satu Server MySQL, jadi kami ingin selalu dan secara otomatis terhubung ke database yang kami minati.

Kita bisa melakukan ini seperti ini:

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

Ini adalah fungsi yang sama persis, tetapi sekarang kita mengambil satu argumen lagi - nama database - dan meneruskannya sebagai argumen ke metode connect().

Membuat Fungsi Eksekusi Kueri

Fungsi terakhir yang akan kita buat (untuk saat ini) adalah fungsi yang sangat vital - fungsi eksekusi kueri. Ini akan mengambil kueri SQL kami, disimpan dalam Python sebagai string, dan meneruskannya ke metode cursor.execute() untuk mengeksekusinya di server.

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}'")

Fungsi ini sama persis dengan fungsi create_database kami sebelumnya, kecuali bahwa ia menggunakan metode connection.commit() untuk memastikan bahwa perintah yang dirinci dalam kueri SQL kami diimplementasikan.

Ini akan menjadi fungsi pekerja keras kami, yang akan kami gunakan (bersama create_db_connection) untuk membuat tabel, membangun hubungan antara tabel tersebut, mengisi tabel dengan data, dan memperbarui dan menghapus catatan dalam database kami.

Jika Anda seorang ahli SQL, fungsi ini akan memungkinkan Anda mengeksekusi setiap dan semua perintah dan kueri kompleks yang mungkin Anda miliki, langsung dari skrip Python. Ini bisa menjadi alat yang sangat ampuh untuk mengelola data Anda.

Membuat Tabel

Sekarang kita siap untuk mulai menjalankan perintah SQL ke Server kita dan mulai membangun database kita. Hal pertama yang ingin kita lakukan adalah membuat tabel yang diperlukan.

Mari kita mulai dengan tabel Guru kita:

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

Pertama-tama kami menetapkan perintah SQL kami (dijelaskan secara rinci di sini) ke variabel dengan nama yang sesuai.

Dalam hal ini kami menggunakan notasi kutipan tiga kali lipat Python untuk string multi-baris untuk menyimpan kueri SQL kami, lalu kami memasukkannya ke dalam fungsi execute_query kami untuk mengimplementasikannya.

Perhatikan bahwa pemformatan multi-baris ini murni untuk kepentingan manusia yang membaca kode kami. Baik SQL maupun Python tidak 'peduli' jika perintah SQL disebarkan seperti ini. Selama sintaksnya benar, kedua bahasa akan menerimanya.

Namun, untuk kepentingan manusia yang akan membaca kode Anda (walaupun itu hanya akan terjadi di masa depan Anda!), hal ini sangat berguna untuk membuat kode lebih mudah dibaca dan dimengerti.

Hal yang sama berlaku untuk KApitalisasi operator di SQL. Ini adalah konvensi yang digunakan secara luas yang sangat disarankan, tetapi perangkat lunak sebenarnya yang menjalankan kode tidak peka huruf besar-kecil dan akan memperlakukan 'CREATE TABLE teacher' dan 'create table teacher' sebagai perintah yang identik.

Menjalankan kode ini memberi kami pesan sukses kami. Kami juga dapat memverifikasi ini di Klien Baris Perintah Server MySQL:

Besar! Sekarang mari kita buat tabel yang tersisa.

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)

Ini menciptakan empat tabel yang diperlukan untuk empat entitas kita.

Sekarang kita ingin mendefinisikan hubungan di antara mereka dan membuat satu tabel lagi untuk menangani hubungan banyak ke banyak antara peserta dan tabel kursus (lihat di sini untuk lebih jelasnya).

Kami melakukannya dengan cara yang persis sama:

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)

Sekarang tabel kami dibuat, bersama dengan batasan yang sesuai, kunci utama, dan hubungan kunci asing.

Mengisi Tabel

Langkah selanjutnya adalah menambahkan beberapa record ke tabel. Sekali lagi kami menggunakan execute_query untuk memasukkan perintah SQL yang ada ke dalam Server. Mari kita mulai lagi dengan tabel Guru.

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)

Apakah ini bekerja? Kita bisa cek lagi di MySQL Command Line Client kita:

Sekarang untuk mengisi tabel yang tersisa.

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)

Luar biasa! Sekarang kita telah membuat database lengkap dengan relasi, batasan, dan catatan di MySQL, hanya menggunakan perintah Python.

Kami telah melalui langkah demi langkah ini untuk membuatnya tetap dimengerti. Tetapi pada titik ini Anda dapat melihat bahwa ini semua dapat dengan mudah ditulis ke dalam satu skrip Python dan dieksekusi dalam satu perintah di terminal. Hal-hal yang kuat.

Membaca Data

Sekarang kami memiliki database fungsional untuk digunakan. Sebagai Analis Data, Anda kemungkinan akan berhubungan dengan database yang ada di organisasi tempat Anda bekerja. Akan sangat berguna untuk mengetahui cara menarik data dari database tersebut sehingga dapat dimasukkan ke dalam pipa data python Anda. Inilah yang akan kita kerjakan selanjutnya.

Untuk ini, kita membutuhkan satu fungsi lagi, kali ini menggunakan cursor.fetchall() bukan cursor.commit(). Dengan fungsi ini, kami membaca data dari database dan tidak akan membuat perubahan apa pun.

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}'")

Sekali lagi, kita akan mengimplementasikan ini dengan cara yang sangat mirip dengan execution_query. Mari kita coba dengan kueri sederhana untuk melihat cara kerjanya.

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

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

for result in results:
  print(result)

Persis apa yang kita harapkan. Fungsi ini juga bekerja dengan kueri yang lebih kompleks, seperti yang melibatkan GABUNG pada tabel kursus dan klien.

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)

Bagus sekali.

Untuk alur data dan alur kerja kami dengan Python, kami mungkin ingin mendapatkan hasil ini dalam format yang berbeda untuk membuatnya lebih berguna atau siap untuk kami manipulasi.

Mari kita lihat beberapa contoh untuk melihat bagaimana kita bisa melakukannya.

Memformat Output menjadi Daftar

#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)

Memformat Output menjadi Daftar Daftar

# Returns a list of lists
from_db = []

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

Memformat Output menjadi panda DataFrame

Untuk Analis Data yang menggunakan Python, panda adalah teman lama kami yang cantik dan tepercaya. Sangat mudah untuk mengubah output dari database kami menjadi DataFrame, dan dari sana kemungkinannya tidak terbatas!

# 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)

Semoga Anda dapat melihat kemungkinan yang terbentang di depan Anda di sini. Hanya dengan beberapa baris kode, kami dapat dengan mudah mengekstrak semua data yang dapat kami tangani dari basis data relasional tempat ia berada, dan menariknya ke dalam saluran analitik data kami yang canggih. Ini hal yang sangat membantu.

Memperbarui Catatan

Saat kami memelihara database, terkadang kami perlu membuat perubahan pada catatan yang ada. Di bagian ini kita akan melihat bagaimana melakukannya.

Katakanlah ILS diberi tahu bahwa salah satu kliennya yang ada, Federasi Bisnis Besar, memindahkan kantor ke 23 Finiertweg, 14534 Berlin. Dalam hal ini, administrator basis data (yaitu kami!) perlu membuat beberapa perubahan.

Untungnya, kita dapat melakukan ini dengan fungsi execute_query bersama dengan pernyataan 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)

Perhatikan bahwa klausa WHERE sangat penting di sini. Jika kami menjalankan kueri ini tanpa klausa WHERE, maka semua alamat untuk semua catatan di tabel Klien kami akan diperbarui menjadi 23 Fingertweg. Bukan itu yang ingin kami lakukan.

Perhatikan juga bahwa kami menggunakan "WHERE client_id =101" dalam kueri UPDATE. Mungkin juga menggunakan "WHERE client_name ='Federasi Bisnis Besar'" atau "WHERE address ='123 Falschungstraße, 10999 Berlin'" atau bahkan "WHERE address LIKE '%Falschung%'".

Yang penting adalah bahwa klausa WHERE memungkinkan kita untuk secara unik mengidentifikasi record (atau record) yang ingin kita perbarui.

Menghapus Catatan

Mungkin juga menggunakan fungsi execute_query kami untuk menghapus catatan, dengan menggunakan DELETE.

Saat menggunakan SQL dengan database relasional, kita perlu berhati-hati menggunakan operator DELETE. Ini bukan Windows, tidak ada 'Apakah Anda yakin ingin menghapus ini?' pop-up peringatan, dan tidak ada tempat sampah daur ulang. Setelah kami menghapus sesuatu, itu benar-benar hilang.

Dengan itu, terkadang kita benar-benar perlu menghapus sesuatu. Jadi mari kita lihat itu dengan menghapus kursus dari tabel Kursus kami.

Pertama-tama mari kita ingatkan diri kita sendiri kursus apa yang kita miliki.

Katakanlah kursus 20, 'Fortgeschrittenes Russisch' (artinya 'Bahasa Rusia Tingkat Lanjut' bagi Anda dan saya), akan segera berakhir, jadi kami harus menghapusnya dari database kami.

Pada tahap ini, Anda tidak akan terkejut sama sekali dengan cara kami melakukan ini - simpan perintah SQL sebagai string, lalu masukkan ke dalam fungsi execute_query pekerja keras kami.

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

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

Mari kita periksa untuk memastikan bahwa itu memiliki efek yang diinginkan:

'Bahasa Rusia Lanjutan' hilang, seperti yang kami harapkan.

Ini juga berfungsi dengan menghapus seluruh kolom menggunakan DROP COLUMN dan seluruh tabel menggunakan perintah DROP TABLE, tetapi kami tidak akan membahasnya dalam tutorial ini.

Namun, lanjutkan dan bereksperimenlah dengannya - tidak masalah jika Anda menghapus kolom atau tabel dari database untuk sekolah fiksi, dan sebaiknya Anda membiasakan diri dengan perintah ini sebelum pindah ke lingkungan produksi.

Oh CRUD

Pada titik ini, kami sekarang dapat menyelesaikan empat operasi utama untuk penyimpanan data persisten.

Kami telah mempelajari cara:

• Buat - database, tabel, dan catatan baru
• Baca - ekstrak data dari database, dan simpan data tersebut dalam berbagai format
• Perbarui - buat perubahan pada catatan yang ada di database
• Hapus - hapus catatan yang tidak lagi diperlukan

Ini adalah hal-hal yang sangat berguna untuk dapat dilakukan.

Sebelum kita menyelesaikan semuanya di sini, kita memiliki satu keterampilan lagi yang sangat berguna untuk dipelajari.

Membuat Catatan dari Daftar

Kami melihat ketika mengisi tabel kami bahwa kami dapat menggunakan perintah SQL INSERT dalam fungsi execute_query kami untuk memasukkan catatan ke dalam database kami.

Mengingat bahwa kita menggunakan Python untuk memanipulasi database SQL kita, akan sangat berguna jika kita dapat mengambil struktur data Python (seperti daftar) dan memasukkannya langsung ke database kita.

Ini bisa berguna ketika kita ingin menyimpan log aktivitas pengguna di aplikasi media sosial yang telah kita tulis dengan Python, atau masukan dari pengguna ke Wiki yang telah kita buat, misalnya. Ada sebanyak mungkin kegunaan untuk ini yang dapat Anda pikirkan.

Metode ini juga lebih aman jika database kami terbuka untuk pengguna kami kapan saja, karena membantu mencegah serangan SQL Injection, yang dapat merusak atau bahkan menghancurkan seluruh database kami.

Untuk melakukan ini, kita akan menulis sebuah fungsi menggunakan metode executemany(), alih-alih metode execute() yang lebih sederhana yang telah kita gunakan sejauh ini.

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}'")

Sekarang kita memiliki fungsinya, kita perlu mendefinisikan perintah SQL ('sql') dan daftar yang berisi nilai-nilai yang ingin kita masukkan ke dalam database ('val'). Nilai harus disimpan sebagai daftar tupel, yang merupakan cara yang cukup umum untuk menyimpan data dengan Python.

Untuk menambahkan dua guru baru ke database, kita dapat menulis beberapa kode seperti ini:

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')
]

Perhatikan di sini bahwa dalam kode 'sql' kita menggunakan '%s' sebagai pengganti nilai kita. Kemiripan dengan '%s' placeholder untuk string di python hanya kebetulan (dan terus terang, sangat membingungkan), kami ingin menggunakan '%s' untuk semua tipe data (string, int, tanggal, dll) dengan MySQL Python Penyambung.

Anda dapat melihat sejumlah pertanyaan di Stackoverflow di mana seseorang menjadi bingung dan mencoba menggunakan placeholder '%d' untuk bilangan bulat karena mereka terbiasa melakukan ini dengan Python. Ini tidak akan berfungsi di sini - kita perlu menggunakan '%s' untuk setiap kolom yang ingin kita tambahkan nilai.

Fungsi executemany kemudian mengambil setiap tuple dalam daftar 'val' kami dan memasukkan nilai yang relevan untuk kolom tersebut sebagai pengganti placeholder dan mengeksekusi perintah SQL untuk setiap tuple yang terdapat dalam daftar.

Ini dapat dilakukan untuk beberapa baris data, asalkan diformat dengan benar. Dalam contoh kami, kami hanya akan menambahkan dua guru baru, untuk tujuan ilustrasi, tetapi pada prinsipnya kami dapat menambahkan sebanyak yang kami inginkan.

Mari lanjutkan dan jalankan kueri ini dan tambahkan pengajar ke database kami.

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

Selamat datang di ILS, Hank dan Sue!

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.

Kesimpulan

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!