search

Metode apa yang digunakan untuk terhubung ke database dengan python?

1 years ago
Komentar: 0
Dibaca: 182

Langkah 1. buat koneksi menggunakan metode connect() dan berikan nama database File Menghubungkan ke database pada langkah 2 berarti meneruskan nama database yang akan diakses. Jika database sudah ada koneksi akan terbuka sama. Jika tidak, Python akan membuka file database baru dengan nama yang ditentukan

Show

# menghubungkan ke database

koneksi = sqlite3. terhubung (“Akademi. db”)

MySQL adalah salah satu yang paling populer di pasaran saat ini. Itu peringkat kedua setelah Oracle DBMS di DB-Engines Ranking tahun ini. Karena sebagian besar aplikasi perangkat lunak perlu berinteraksi dengan data dalam beberapa bentuk, bahasa pemrograman seperti Python menyediakan alat untuk menyimpan dan mengakses sumber data ini

Dengan menggunakan teknik yang dibahas dalam tutorial ini, Anda akan dapat mengintegrasikan database MySQL secara efisien dengan aplikasi Python. Anda akan mengembangkan database MySQL kecil untuk sistem rating film dan mempelajari cara menanyakannya langsung dari kode Python Anda

Di akhir tutorial ini, Anda akan bisa

  • Identifikasi fitur unik dari MySQL
  • Hubungkan aplikasi Anda ke database MySQL
  • Permintaan database untuk mengambil data yang diperlukan
  • Tangani pengecualian yang terjadi saat mengakses database
  • Gunakan praktik terbaik saat membuat aplikasi database

Untuk mendapatkan hasil maksimal dari tutorial ini, Anda harus memiliki pengetahuan tentang konsep Python seperti 

cursor = connection.cursor()
0 loop, fungsi, penanganan pengecualian, dan menginstal paket Python menggunakan 
cursor = connection.cursor()
1. Anda juga harus memiliki pemahaman dasar tentang sistem manajemen basis data relasional dan kueri SQL seperti 
cursor = connection.cursor()
2, 
cursor = connection.cursor()
3, 
cursor = connection.cursor()
4, dan 
cursor = connection.cursor()
5

Download Gratis. Dapatkan contoh bab dari Trik Python. Buku yang menunjukkan kepada Anda praktik terbaik Python dengan contoh sederhana yang dapat Anda terapkan secara instan untuk menulis kode + Pythonic yang lebih indah

Membandingkan MySQL dengan Database SQL Lainnya

SQL adalah singkatan dari Structured Query Language dan merupakan bahasa pemrograman yang banyak digunakan untuk mengelola basis data relasional. Anda mungkin pernah mendengar tentang rasa yang berbeda dari DBMS berbasis SQL. Yang paling populer termasuk MySQL, PostgreSQL, SQLite, dan SQL Server. Semua database ini sesuai dengan standar SQL tetapi dengan berbagai tingkat kepatuhan

Menjadi open source sejak didirikan pada tahun 1995, MySQL dengan cepat menjadi pemimpin pasar di antara solusi SQL. MySQL juga merupakan bagian dari ekosistem Oracle. Meskipun fungsionalitas intinya benar-benar gratis, ada beberapa add-on berbayar juga. Saat ini, MySQL digunakan oleh semua perusahaan teknologi besar, termasuk Google, LinkedIn, Uber, Netflix, Twitter, dan lainnya

Terlepas dari dukungan komunitas open source yang besar, ada banyak alasan lain untuk kesuksesan MySQL

  1. Kemudahan instalasi. MySQL dirancang agar mudah digunakan. Cukup mudah untuk menyiapkan database MySQL, dan beberapa alat pihak ketiga yang tersedia secara luas, seperti phpMyAdmin, semakin merampingkan proses penyiapan. MySQL tersedia untuk semua sistem operasi utama, termasuk Windows, macOS, Linux, dan Solaris

  2. Kecepatan. MySQL memiliki reputasi sebagai solusi database yang sangat cepat. Ini memiliki footprint yang relatif lebih kecil dan sangat terukur dalam jangka panjang

  3. Hak istimewa dan keamanan pengguna. MySQL hadir dengan skrip yang memungkinkan Anda mengatur tingkat keamanan kata sandi, menetapkan kata sandi admin, dan menambah dan menghapus hak istimewa akun pengguna. Skrip ini memperumit proses admin untuk portal manajemen pengguna hosting web. DBMS lain, seperti PostgreSQL, menggunakan file konfigurasi yang lebih rumit untuk digunakan

Meskipun MySQL terkenal dengan kecepatan dan kemudahan penggunaannya, Anda bisa mendapatkan fitur yang lebih canggih dengan PostgreSQL. Selain itu, MySQL tidak sepenuhnya sesuai dengan SQL dan memiliki batasan fungsional tertentu, seperti tidak ada dukungan untuk klausa 

cursor = connection.cursor()
6

Anda mungkin juga menghadapi beberapa masalah dengan membaca dan menulis secara bersamaan di MySQL. Jika perangkat lunak Anda memiliki banyak pengguna yang menulis data sekaligus, maka PostgreSQL mungkin merupakan pilihan yang lebih cocok

Catatan. Untuk perbandingan MySQL dan PostgreSQL yang lebih mendalam dalam konteks dunia nyata, lihat Mengapa Teknik Uber Beralih dari Postgres ke MySQL

SQL Server juga merupakan DBMS yang sangat populer dan terkenal dengan keandalan, efisiensi, dan keamanannya. Ini disukai oleh perusahaan, terutama di domain perbankan, yang secara teratur berurusan dengan beban kerja lalu lintas yang besar. Ini adalah solusi komersial dan merupakan salah satu sistem yang paling kompatibel dengan layanan Windows

Pada tahun 2010, ketika Oracle mengakuisisi Sun Microsystems dan MySQL, banyak yang mengkhawatirkan masa depan MySQL. Pada saat itu, Oracle adalah pesaing terbesar MySQL. Pengembang khawatir ini adalah pengambilalihan yang tidak bersahabat dari Oracle dengan tujuan menghancurkan MySQL

Beberapa pengembang yang dipimpin oleh Michael Widenius, penulis asli MySQL, membuat cabang dari basis kode MySQL dan meletakkan dasar MariaDB. Tujuannya adalah untuk mengamankan akses ke MySQL dan menjaganya tetap gratis selamanya

Sampai saat ini, MariaDB tetap memiliki lisensi GPL sepenuhnya, menjaganya sepenuhnya dalam domain publik. Beberapa fitur MySQL, di sisi lain, hanya tersedia dengan lisensi berbayar. Selain itu, MariaDB menyediakan beberapa fitur yang sangat berguna yang tidak didukung oleh server MySQL, seperti SQL terdistribusi dan penyimpanan kolom. Anda dapat menemukan lebih banyak perbedaan antara MySQL dan MariaDB yang terdaftar di situs web MariaDB

MySQL menggunakan sintaks yang sangat mirip dengan SQL Standar. Namun, ada beberapa perbedaan penting yang disebutkan dalam dokumentasi resmi

Hilangkan iklan

Menginstal Server MySQL dan Konektor MySQL/Python

Sekarang, untuk mulai mengerjakan tutorial ini, Anda perlu menyiapkan dua hal. server MySQL dan konektor MySQL. Server MySQL akan menyediakan semua layanan yang diperlukan untuk menangani database Anda. Setelah server aktif dan berjalan, Anda dapat menghubungkan aplikasi Python Anda dengannya menggunakan MySQL Connector/Python

Menginstal Server MySQL

Dokumentasi resmi merinci cara yang disarankan untuk mengunduh dan menginstal server MySQL. Anda akan menemukan petunjuk untuk semua sistem operasi populer, termasuk Windows, macOS, Solaris, Linux, dan banyak lagi

Untuk Windows, cara terbaik adalah mengunduh Penginstal MySQL dan membiarkannya menangani seluruh proses. Manajer instalasi juga membantu Anda mengonfigurasi pengaturan keamanan server MySQL. Pada halaman Akun dan Peran, Anda perlu memasukkan kata sandi untuk akun root (admin) dan juga secara opsional menambahkan pengguna lain dengan berbagai hak istimewa

Metode apa yang digunakan untuk terhubung ke database dengan python?
Pengaturan Akun Pemasang MySQL

Meskipun Anda harus menentukan kredensial untuk akun root selama penyiapan, Anda dapat mengubah setelan ini nanti

Catatan. Ingat nama host, nama pengguna, dan kata sandi karena ini akan diperlukan untuk membuat koneksi dengan server MySQL nanti

Meskipun Anda hanya memerlukan server MySQL untuk tutorial ini, Anda juga dapat menyiapkan alat bermanfaat lainnya seperti MySQL Workbench menggunakan penginstal ini. Jika Anda tidak ingin menginstal MySQL langsung di sistem operasi Anda, menggunakan MySQL di Linux dengan Docker adalah alternatif yang nyaman

Memasang Konektor MySQL/Python

Driver basis data adalah perangkat lunak yang memungkinkan aplikasi untuk terhubung dan berinteraksi dengan sistem basis data. Bahasa pemrograman seperti Python memerlukan driver khusus sebelum mereka dapat berbicara ke database dari vendor tertentu

Driver ini biasanya diperoleh sebagai modul pihak ketiga. Python Database API (DB-API) mendefinisikan antarmuka standar yang harus dipatuhi oleh semua driver database Python. Rincian ini didokumentasikan dalam PEP 249. Semua driver database Python, seperti sqlite3 untuk SQLite, psycopg untuk PostgreSQL, dan MySQL Connector/Python untuk MySQL, ikuti aturan implementasi ini

Catatan. Dokumentasi resmi MySQL menggunakan istilah konektor alih-alih driver. Secara teknis, konektor dikaitkan hanya dengan menghubungkan ke database, bukan berinteraksi dengannya. Namun, istilah ini sering digunakan untuk seluruh modul akses database yang terdiri dari konektor dan driver

Untuk menjaga konsistensi dengan dokumentasi, Anda akan melihat istilah konektor setiap kali MySQL disebutkan

Banyak bahasa pemrograman populer memiliki database API sendiri. Misalnya, Java memiliki Java Database Connectivity (JDBC) API. Jika Anda perlu menghubungkan aplikasi Java ke database MySQL, maka Anda perlu menggunakan konektor MySQL JDBC, yang mengikuti JDBC API

Demikian pula, di Python Anda perlu menginstal konektor Python MySQL untuk berinteraksi dengan database MySQL. Banyak paket mengikuti standar DB-API, tetapi yang paling populer di antaranya adalah MySQL Connector/Python. Anda bisa mendapatkannya dengan 

cursor = connection.cursor()
1

$ pip install mysql-connector-python
_

cursor = connection.cursor()
1 menginstal konektor sebagai modul pihak ketiga di lingkungan virtual yang sedang aktif. Anda disarankan untuk menyiapkan lingkungan virtual yang terisolasi untuk proyek beserta semua dependensinya

Untuk menguji apakah instalasi berhasil, ketikkan perintah berikut di terminal Python Anda

>>> 

>>> import mysql.connector
_

Jika kode di atas dijalankan tanpa kesalahan, maka 

cursor = connection.cursor()
9 sudah terpasang dan siap digunakan. Jika Anda menemukan kesalahan, pastikan Anda berada di lingkungan virtual yang benar dan Anda menggunakan juru bahasa Python yang tepat

Pastikan Anda menginstal paket 

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

try:
    with connect(
        host="localhost",
        user=input("Enter username: "),
        password=getpass("Enter password: "),
    ) as connection:
        create_db_query = "CREATE DATABASE online_movie_rating"
        with connection.cursor() as cursor:
            cursor.execute(create_db_query)
except Error as e:
    print(e)
0 yang benar, yang merupakan implementasi murni-Python. Waspadalah terhadap konektor dengan nama yang sama tetapi sekarang disusutkan seperti 
from getpass import getpass
from mysql.connector import connect, Error

try:
    with connect(
        host="localhost",
        user=input("Enter username: "),
        password=getpass("Enter password: "),
    ) as connection:
        create_db_query = "CREATE DATABASE online_movie_rating"
        with connection.cursor() as cursor:
            cursor.execute(create_db_query)
except Error as e:
    print(e)
1

Hilangkan iklan

Membuat Koneksi Dengan Server MySQL

MySQL adalah sistem manajemen basis data berbasis server. Satu server mungkin berisi beberapa database. Untuk berinteraksi dengan database, Anda harus terlebih dahulu membuat koneksi dengan server. Alur kerja umum program Python yang berinteraksi dengan database berbasis MySQL adalah sebagai berikut

  1. Hubungkan ke server MySQL
  2. Buat basis data baru
  3. Sambungkan ke database yang baru dibuat atau yang sudah ada
  4. Jalankan kueri SQL dan ambil hasilnya
  5. Beri tahu database jika ada perubahan yang dilakukan pada tabel
  6. Tutup koneksi ke server MySQL

Ini adalah alur kerja umum yang mungkin berbeda tergantung pada aplikasi individual. Tapi apa pun aplikasinya, langkah pertama adalah menghubungkan database Anda dengan aplikasi Anda

Membangun Koneksi

Langkah pertama dalam berinteraksi dengan server MySQL adalah membuat koneksi. Untuk melakukan ini, Anda memerlukan 

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

try:
    with connect(
        host="localhost",
        user=input("Enter username: "),
        password=getpass("Enter password: "),
    ) as connection:
        create_db_query = "CREATE DATABASE online_movie_rating"
        with connection.cursor() as cursor:
            cursor.execute(create_db_query)
except Error as e:
    print(e)
_2 dari modul 
cursor = connection.cursor()
9. Fungsi ini mengambil parameter seperti 
from getpass import getpass
from mysql.connector import connect, Error

try:
    with connect(
        host="localhost",
        user=input("Enter username: "),
        password=getpass("Enter password: "),
    ) as connection:
        create_db_query = "CREATE DATABASE online_movie_rating"
        with connection.cursor() as cursor:
            cursor.execute(create_db_query)
except Error as e:
    print(e)
_4, 
from getpass import getpass
from mysql.connector import connect, Error

try:
    with connect(
        host="localhost",
        user=input("Enter username: "),
        password=getpass("Enter password: "),
    ) as connection:
        create_db_query = "CREATE DATABASE online_movie_rating"
        with connection.cursor() as cursor:
            cursor.execute(create_db_query)
except Error as e:
    print(e)
5, dan 
from getpass import getpass
from mysql.connector import connect, Error

try:
    with connect(
        host="localhost",
        user=input("Enter username: "),
        password=getpass("Enter password: "),
    ) as connection:
        create_db_query = "CREATE DATABASE online_movie_rating"
        with connection.cursor() as cursor:
            cursor.execute(create_db_query)
except Error as e:
    print(e)
6 dan mengembalikan objek 
from getpass import getpass
from mysql.connector import connect, Error

try:
    with connect(
        host="localhost",
        user=input("Enter username: "),
        password=getpass("Enter password: "),
    ) as connection:
        create_db_query = "CREATE DATABASE online_movie_rating"
        with connection.cursor() as cursor:
            cursor.execute(create_db_query)
except Error as e:
    print(e)
7. Anda dapat menerima kredensial ini sebagai masukan dari pengguna dan meneruskannya ke 
from getpass import getpass
from mysql.connector import connect, Error

try:
    with connect(
        host="localhost",
        user=input("Enter username: "),
        password=getpass("Enter password: "),
    ) as connection:
        create_db_query = "CREATE DATABASE online_movie_rating"
        with connection.cursor() as cursor:
            cursor.execute(create_db_query)
except Error as e:
    print(e)
2

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

try:
    with connect(
        host="localhost",
        user=input("Enter username: "),
        password=getpass("Enter password: "),
    ) as connection:
        print(connection)
except Error as e:
    print(e)

Kode di atas menggunakan kredensial login yang dimasukkan untuk membuat koneksi dengan server MySQL Anda. Sebagai imbalannya, Anda mendapatkan objek 

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

try:
    with connect(
        host="localhost",
        user=input("Enter username: "),
        password=getpass("Enter password: "),
    ) as connection:
        create_db_query = "CREATE DATABASE online_movie_rating"
        with connection.cursor() as cursor:
            cursor.execute(create_db_query)
except Error as e:
    print(e)
_7, yang disimpan dalam variabel 
>>> show_db_query = "SHOW DATABASES"
>>> with connection.cursor() as cursor:
..     cursor.execute(show_db_query)
..     for db in cursor:
..         print(db)
...
('information_schema',)
('mysql',)
('online_movie_rating',)
('performance_schema',)
('sys',)
0. Mulai sekarang, Anda akan menggunakan variabel ini untuk mengakses server MySQL Anda

Ada beberapa hal penting yang perlu diperhatikan pada kode di atas

  • Anda harus selalu menangani pengecualian yang mungkin muncul saat membuat koneksi ke server MySQL. Inilah sebabnya mengapa Anda menggunakan 

    >>> show_db_query = "SHOW DATABASES"
>>> with connection.cursor() as cursor:
..     cursor.execute(show_db_query)
..     for db in cursor:
..         print(db)
...
('information_schema',)
('mysql',)
('online_movie_rating',)
('performance_schema',)
('sys',)
    _1 … 
    >>> show_db_query = "SHOW DATABASES"
>>> with connection.cursor() as cursor:
..     cursor.execute(show_db_query)
..     for db in cursor:
..         print(db)
...
('information_schema',)
('mysql',)
('online_movie_rating',)
('performance_schema',)
('sys',)
    2 blok untuk menangkap dan mencetak pengecualian yang mungkin Anda temui

  • Anda harus selalu menutup koneksi setelah selesai mengakses database. Membiarkan koneksi terbuka yang tidak terpakai dapat menyebabkan beberapa kesalahan tak terduga dan masalah kinerja. Kode di atas memanfaatkan pengelola konteks menggunakan 

    >>> show_db_query = "SHOW DATABASES"
>>> with connection.cursor() as cursor:
..     cursor.execute(show_db_query)
..     for db in cursor:
..         print(db)
...
('information_schema',)
('mysql',)
('online_movie_rating',)
('performance_schema',)
('sys',)
    3, yang meringkas proses pembersihan koneksi

  • Anda tidak boleh meng-hard-code kredensial login Anda, yaitu nama pengguna dan kata sandi Anda, langsung dalam skrip Python. Ini adalah praktik buruk untuk penyebaran dan menimbulkan ancaman keamanan yang serius. Kode di atas meminta pengguna untuk kredensial masuk. Ini menggunakan modul 

    >>> show_db_query = "SHOW DATABASES"
>>> with connection.cursor() as cursor:
..     cursor.execute(show_db_query)
..     for db in cursor:
..         print(db)
...
('information_schema',)
('mysql',)
('online_movie_rating',)
('performance_schema',)
('sys',)
    4 bawaan untuk menyembunyikan kata sandi. Meskipun ini lebih baik daripada hard-coding, ada cara lain yang lebih aman untuk menyimpan informasi sensitif, seperti menggunakan variabel lingkungan

Anda sekarang telah membuat koneksi antara program Anda dan server MySQL Anda, tetapi Anda masih perlu membuat database baru atau menyambung ke database yang ada di dalam server

Membuat Basis Data Baru

Di bagian terakhir, Anda membuat koneksi dengan server MySQL Anda. Untuk membuat database baru, Anda perlu menjalankan pernyataan SQL

CREATE DATABASE books_db;

Pernyataan di atas akan membuat database baru dengan nama 

>>> show_db_query = "SHOW DATABASES"
>>> with connection.cursor() as cursor:
..     cursor.execute(show_db_query)
..     for db in cursor:
..         print(db)
...
('information_schema',)
('mysql',)
('online_movie_rating',)
('performance_schema',)
('sys',)
5

Catatan. Di MySQL, wajib untuk meletakkan titik koma (

>>> show_db_query = "SHOW DATABASES"
>>> with connection.cursor() as cursor:
..     cursor.execute(show_db_query)
..     for db in cursor:
..         print(db)
...
('information_schema',)
('mysql',)
('online_movie_rating',)
('performance_schema',)
('sys',)
6) di akhir pernyataan, yang menunjukkan penghentian kueri. Namun, Konektor MySQL/Python secara otomatis menambahkan titik koma di akhir kueri Anda, jadi tidak perlu menggunakannya dalam kode Python Anda

Untuk mengeksekusi kueri SQL dengan Python, Anda harus menggunakan kursor, yang memisahkan akses ke catatan basis data. Konektor MySQL/Python memberi Anda kelas 

>>> show_db_query = "SHOW DATABASES"
>>> with connection.cursor() as cursor:
..     cursor.execute(show_db_query)
..     for db in cursor:
..         print(db)
...
('information_schema',)
('mysql',)
('online_movie_rating',)
('performance_schema',)
('sys',)
7, yang memberi contoh objek yang dapat mengeksekusi kueri MySQL dengan Python. Contoh kelas 
>>> show_db_query = "SHOW DATABASES"
>>> with connection.cursor() as cursor:
..     cursor.execute(show_db_query)
..     for db in cursor:
..         print(db)
...
('information_schema',)
('mysql',)
('online_movie_rating',)
('performance_schema',)
('sys',)
_7 juga disebut 
>>> show_db_query = "SHOW DATABASES"
>>> with connection.cursor() as cursor:
..     cursor.execute(show_db_query)
..     for db in cursor:
..         print(db)
...
('information_schema',)
('mysql',)
('online_movie_rating',)
('performance_schema',)
('sys',)
9

>>> show_db_query = "SHOW DATABASES"
>>> with connection.cursor() as cursor:
..     cursor.execute(show_db_query)
..     for db in cursor:
..         print(db)
...
('information_schema',)
('mysql',)
('online_movie_rating',)
('performance_schema',)
('sys',)
_9 objek menggunakan objek 
from getpass import getpass
from mysql.connector import connect, Error

try:
    with connect(
        host="localhost",
        user=input("Enter username: "),
        password=getpass("Enter password: "),
    ) as connection:
        create_db_query = "CREATE DATABASE online_movie_rating"
        with connection.cursor() as cursor:
            cursor.execute(create_db_query)
except Error as e:
    print(e)
7 untuk berinteraksi dengan server MySQL Anda. Untuk membuat 
>>> show_db_query = "SHOW DATABASES"
>>> with connection.cursor() as cursor:
..     cursor.execute(show_db_query)
..     for db in cursor:
..         print(db)
...
('information_schema',)
('mysql',)
('online_movie_rating',)
('performance_schema',)
('sys',)
_9, gunakan metode 
from getpass import getpass
from mysql.connector import connect, Error

try:
    with connect(
        host="localhost",
        user=input("Enter username: "),
        password=getpass("Enter password: "),
        database="online_movie_rating",
    ) as connection:
        print(connection)
except Error as e:
    print(e)
3 dari variabel 
>>> show_db_query = "SHOW DATABASES"
>>> with connection.cursor() as cursor:
..     cursor.execute(show_db_query)
..     for db in cursor:
..         print(db)
...
('information_schema',)
('mysql',)
('online_movie_rating',)
('performance_schema',)
('sys',)
0 Anda

cursor = connection.cursor()

Kode di atas memberi Anda turunan dari kelas ________23______7

Kueri yang perlu dieksekusi dikirim ke 

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

try:
    with connect(
        host="localhost",
        user=input("Enter username: "),
        password=getpass("Enter password: "),
        database="online_movie_rating",
    ) as connection:
        print(connection)
except Error as e:
    print(e)
6 dalam format string. Dalam kesempatan khusus ini, Anda akan mengirimkan kueri 
from getpass import getpass
from mysql.connector import connect, Error

try:
    with connect(
        host="localhost",
        user=input("Enter username: "),
        password=getpass("Enter password: "),
        database="online_movie_rating",
    ) as connection:
        print(connection)
except Error as e:
    print(e)
7 ke 
from getpass import getpass
from mysql.connector import connect, Error

try:
    with connect(
        host="localhost",
        user=input("Enter username: "),
        password=getpass("Enter password: "),
        database="online_movie_rating",
    ) as connection:
        print(connection)
except Error as e:
    print(e)
6

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

try:
    with connect(
        host="localhost",
        user=input("Enter username: "),
        password=getpass("Enter password: "),
    ) as connection:
        create_db_query = "CREATE DATABASE online_movie_rating"
        with connection.cursor() as cursor:
            cursor.execute(create_db_query)
except Error as e:
    print(e)

Setelah mengeksekusi kode di atas, Anda akan memiliki database baru bernama 

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

try:
    with connect(
        host="localhost",
        user=input("Enter username: "),
        password=getpass("Enter password: "),
        database="online_movie_rating",
    ) as connection:
        print(connection)
except Error as e:
    print(e)
9 di server MySQL Anda

Kueri 

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

try:
    with connect(
        host="localhost",
        user=input("Enter username: "),
        password=getpass("Enter password: "),
        database="online_movie_rating",
    ) as connection:
        print(connection)
except Error as e:
    print(e)
_7 disimpan sebagai string dalam variabel 
CREATE TABLE movies(
    id INT AUTO_INCREMENT PRIMARY KEY,
    title VARCHAR(100),
    release_year YEAR(4),
    genre VARCHAR(100),
    collection_in_mil INT
);
1 dan kemudian diteruskan ke 
from getpass import getpass
from mysql.connector import connect, Error

try:
    with connect(
        host="localhost",
        user=input("Enter username: "),
        password=getpass("Enter password: "),
        database="online_movie_rating",
    ) as connection:
        print(connection)
except Error as e:
    print(e)
6 untuk dieksekusi. Kode menggunakan pengelola konteks dengan objek 
>>> show_db_query = "SHOW DATABASES"
>>> with connection.cursor() as cursor:
..     cursor.execute(show_db_query)
..     for db in cursor:
..         print(db)
...
('information_schema',)
('mysql',)
('online_movie_rating',)
('performance_schema',)
('sys',)
9 untuk menangani proses pembersihan

Anda mungkin menerima kesalahan di sini jika database dengan nama yang sama sudah ada di server Anda. Untuk mengonfirmasi ini, Anda dapat menampilkan nama semua database di server Anda. Menggunakan objek 

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

try:
    with connect(
        host="localhost",
        user=input("Enter username: "),
        password=getpass("Enter password: "),
    ) as connection:
        create_db_query = "CREATE DATABASE online_movie_rating"
        with connection.cursor() as cursor:
            cursor.execute(create_db_query)
except Error as e:
    print(e)
_7 yang sama dari sebelumnya, jalankan pernyataan 
CREATE TABLE movies(
    id INT AUTO_INCREMENT PRIMARY KEY,
    title VARCHAR(100),
    release_year YEAR(4),
    genre VARCHAR(100),
    collection_in_mil INT
);
5

>>> 

>>> show_db_query = "SHOW DATABASES"
>>> with connection.cursor() as cursor:
..     cursor.execute(show_db_query)
..     for db in cursor:
..         print(db)
...
('information_schema',)
('mysql',)
('online_movie_rating',)
('performance_schema',)
('sys',)
_

Kode di atas mencetak nama semua database yang saat ini ada di server MySQL Anda. Perintah 

CREATE TABLE movies(
    id INT AUTO_INCREMENT PRIMARY KEY,
    title VARCHAR(100),
    release_year YEAR(4),
    genre VARCHAR(100),
    collection_in_mil INT
);
_5 juga menampilkan beberapa database yang tidak Anda buat di server Anda, seperti 
CREATE TABLE movies(
    id INT AUTO_INCREMENT PRIMARY KEY,
    title VARCHAR(100),
    release_year YEAR(4),
    genre VARCHAR(100),
    collection_in_mil INT
);
7, 
CREATE TABLE movies(
    id INT AUTO_INCREMENT PRIMARY KEY,
    title VARCHAR(100),
    release_year YEAR(4),
    genre VARCHAR(100),
    collection_in_mil INT
);
8, dan seterusnya. Database ini dihasilkan secara otomatis oleh server MySQL dan menyediakan akses ke berbagai metadata database dan pengaturan server MySQL

Anda membuat database baru di bagian ini dengan menjalankan pernyataan 

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

try:
    with connect(
        host="localhost",
        user=input("Enter username: "),
        password=getpass("Enter password: "),
        database="online_movie_rating",
    ) as connection:
        print(connection)
except Error as e:
    print(e)
7. Di bagian selanjutnya, Anda akan melihat cara menghubungkan ke database yang sudah ada

Hilangkan iklan

Menghubungkan ke Database yang Ada

Di bagian terakhir, Anda membuat database baru bernama 

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

try:
    with connect(
        host="localhost",
        user=input("Enter username: "),
        password=getpass("Enter password: "),
        database="online_movie_rating",
    ) as connection:
        print(connection)
except Error as e:
    print(e)
9. Namun, Anda masih belum terhubung dengannya. Dalam banyak situasi, Anda sudah memiliki database MySQL yang ingin Anda sambungkan dengan aplikasi Python Anda

Anda dapat melakukannya menggunakan fungsi 

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

try:
    with connect(
        host="localhost",
        user=input("Enter username: "),
        password=getpass("Enter password: "),
    ) as connection:
        create_db_query = "CREATE DATABASE online_movie_rating"
        with connection.cursor() as cursor:
            cursor.execute(create_db_query)
except Error as e:
    print(e)
_2 yang sama dengan yang Anda gunakan sebelumnya dengan mengirimkan parameter tambahan bernama 
create_movies_table_query = """
CREATE TABLE movies(
    id INT AUTO_INCREMENT PRIMARY KEY,
    title VARCHAR(100),
    release_year YEAR(4),
    genre VARCHAR(100),
    collection_in_mil INT
)
"""
with connection.cursor() as cursor:
    cursor.execute(create_movies_table_query)
    connection.commit()
2

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

try:
    with connect(
        host="localhost",
        user=input("Enter username: "),
        password=getpass("Enter password: "),
        database="online_movie_rating",
    ) as connection:
        print(connection)
except Error as e:
    print(e)

Kode di atas sangat mirip dengan skrip koneksi yang Anda gunakan sebelumnya. Satu-satunya perubahan di sini adalah parameter 

create_movies_table_query = """
CREATE TABLE movies(
    id INT AUTO_INCREMENT PRIMARY KEY,
    title VARCHAR(100),
    release_year YEAR(4),
    genre VARCHAR(100),
    collection_in_mil INT
)
"""
with connection.cursor() as cursor:
    cursor.execute(create_movies_table_query)
    connection.commit()
_2 tambahan, di mana nama database Anda diteruskan ke 
from getpass import getpass
from mysql.connector import connect, Error

try:
    with connect(
        host="localhost",
        user=input("Enter username: "),
        password=getpass("Enter password: "),
    ) as connection:
        create_db_query = "CREATE DATABASE online_movie_rating"
        with connection.cursor() as cursor:
            cursor.execute(create_db_query)
except Error as e:
    print(e)
2. Setelah Anda menjalankan skrip ini, Anda akan terhubung ke database 
from getpass import getpass
from mysql.connector import connect, Error

try:
    with connect(
        host="localhost",
        user=input("Enter username: "),
        password=getpass("Enter password: "),
        database="online_movie_rating",
    ) as connection:
        print(connection)
except Error as e:
    print(e)
9

Membuat, Mengubah, dan Menjatuhkan Tabel

Di bagian ini, Anda akan mempelajari cara melakukan beberapa kueri DDL dasar seperti 

cursor = connection.cursor()
4, 
cursor = connection.cursor()
3, dan 
create_movies_table_query = """
CREATE TABLE movies(
    id INT AUTO_INCREMENT PRIMARY KEY,
    title VARCHAR(100),
    release_year YEAR(4),
    genre VARCHAR(100),
    collection_in_mil INT
)
"""
with connection.cursor() as cursor:
    cursor.execute(create_movies_table_query)
    connection.commit()
8 dengan Python. Anda akan melihat sekilas database MySQL yang akan Anda gunakan di sisa tutorial ini. Anda juga akan membuat semua tabel yang diperlukan untuk database dan mempelajari cara melakukan modifikasi pada tabel ini nanti

Mendefinisikan Skema Database

Anda bisa mulai dengan membuat skema database untuk sistem rating film online. Database akan terdiri dari tiga tabel

  1. create_movies_table_query = """
CREATE TABLE movies(
    id INT AUTO_INCREMENT PRIMARY KEY,
    title VARCHAR(100),
    release_year YEAR(4),
    genre VARCHAR(100),
    collection_in_mil INT
)
"""
with connection.cursor() as cursor:
    cursor.execute(create_movies_table_query)
    connection.commit()
    9 berisi informasi umum tentang film dan memiliki atribut berikut
    • >>> import mysql.connector
      _00
    • >>> import mysql.connector
      _01
    • >>> import mysql.connector
      _02
    • >>> import mysql.connector
      _03
    • >>> import mysql.connector
      _04
  2. >>> import mysql.connector
    _05 berisi informasi tentang orang yang memposting ulasan atau peringkat dan memiliki atribut berikut
    • >>> import mysql.connector
      _00
    • >>> import mysql.connector
      _07
    • >>> import mysql.connector
      _08
  3. >>> import mysql.connector
    _09 berisi informasi tentang peringkat yang telah diposting dan memiliki atribut sebagai berikut
    • >>> import mysql.connector
      _10 (kunci asing)
    • >>> import mysql.connector
      _11 (kunci asing)
    • >>> import mysql.connector
      _12

Sistem peringkat film dunia nyata, seperti IMDb, perlu menyimpan banyak atribut lain, seperti email, daftar pemeran film, dan sebagainya. Jika mau, Anda bisa menambahkan lebih banyak tabel dan atribut ke database ini. Tapi ketiga tabel ini sudah cukup untuk tujuan tutorial ini

Gambar di bawah menggambarkan skema database

Metode apa yang digunakan untuk terhubung ke database dengan python?
Diagram Skema Sistem Rating Film Online

Tabel-tabel dalam database ini saling terkait satu sama lain. 

create_movies_table_query = """
CREATE TABLE movies(
    id INT AUTO_INCREMENT PRIMARY KEY,
    title VARCHAR(100),
    release_year YEAR(4),
    genre VARCHAR(100),
    collection_in_mil INT
)
"""
with connection.cursor() as cursor:
    cursor.execute(create_movies_table_query)
    connection.commit()
9 dan 
>>> import mysql.connector
05 akan memiliki hubungan banyak-ke-banyak karena satu film dapat ditinjau oleh beberapa pengulas dan satu pengulas dapat meninjau beberapa film. Tabel 
>>> import mysql.connector
_09 menghubungkan tabel 
create_movies_table_query = """
CREATE TABLE movies(
    id INT AUTO_INCREMENT PRIMARY KEY,
    title VARCHAR(100),
    release_year YEAR(4),
    genre VARCHAR(100),
    collection_in_mil INT
)
"""
with connection.cursor() as cursor:
    cursor.execute(create_movies_table_query)
    connection.commit()
9 dengan tabel 
>>> import mysql.connector
05

Membuat Tabel Menggunakan Pernyataan >>> import mysql.connector _18

Sekarang, untuk membuat tabel baru di MySQL, Anda perlu menggunakan pernyataan 

>>> import mysql.connector
18. Kueri MySQL berikut akan membuat tabel 
create_movies_table_query = """
CREATE TABLE movies(
    id INT AUTO_INCREMENT PRIMARY KEY,
    title VARCHAR(100),
    release_year YEAR(4),
    genre VARCHAR(100),
    collection_in_mil INT
)
"""
with connection.cursor() as cursor:
    cursor.execute(create_movies_table_query)
    connection.commit()
9 untuk database 
from getpass import getpass
from mysql.connector import connect, Error

try:
    with connect(
        host="localhost",
        user=input("Enter username: "),
        password=getpass("Enter password: "),
        database="online_movie_rating",
    ) as connection:
        print(connection)
except Error as e:
    print(e)
9 Anda

CREATE TABLE movies(
    id INT AUTO_INCREMENT PRIMARY KEY,
    title VARCHAR(100),
    release_year YEAR(4),
    genre VARCHAR(100),
    collection_in_mil INT
);

Jika Anda telah melihat pernyataan SQL sebelumnya, sebagian besar kueri di atas mungkin masuk akal. Namun ada beberapa perbedaan sintaks MySQL yang harus Anda ketahui

Misalnya, MySQL memiliki berbagai jenis data untuk Anda teliti, termasuk 

>>> import mysql.connector
22, 
>>> import mysql.connector
23, 
>>> import mysql.connector
24, dan seterusnya. Selain itu, MySQL menggunakan kata kunci 
>>> import mysql.connector
_25 ketika nilai kolom harus ditambahkan secara otomatis saat penyisipan catatan baru

Untuk membuat tabel baru, Anda harus meneruskan kueri ini ke 

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

try:
    with connect(
        host="localhost",
        user=input("Enter username: "),
        password=getpass("Enter password: "),
        database="online_movie_rating",
    ) as connection:
        print(connection)
except Error as e:
    print(e)
6, yang menerima kueri MySQL dan mengeksekusi kueri pada database MySQL yang terhubung

create_movies_table_query = """
CREATE TABLE movies(
    id INT AUTO_INCREMENT PRIMARY KEY,
    title VARCHAR(100),
    release_year YEAR(4),
    genre VARCHAR(100),
    collection_in_mil INT
)
"""
with connection.cursor() as cursor:
    cursor.execute(create_movies_table_query)
    connection.commit()

Sekarang Anda memiliki tabel 

create_movies_table_query = """
CREATE TABLE movies(
    id INT AUTO_INCREMENT PRIMARY KEY,
    title VARCHAR(100),
    release_year YEAR(4),
    genre VARCHAR(100),
    collection_in_mil INT
)
"""
with connection.cursor() as cursor:
    cursor.execute(create_movies_table_query)
    connection.commit()
_9 di database Anda. Anda meneruskan 
>>> import mysql.connector
_28 ke 
from getpass import getpass
from mysql.connector import connect, Error

try:
    with connect(
        host="localhost",
        user=input("Enter username: "),
        password=getpass("Enter password: "),
        database="online_movie_rating",
    ) as connection:
        print(connection)
except Error as e:
    print(e)
6, yang melakukan eksekusi yang diperlukan

Catatan. Variabel 

>>> show_db_query = "SHOW DATABASES"
>>> with connection.cursor() as cursor:
..     cursor.execute(show_db_query)
..     for db in cursor:
..         print(db)
...
('information_schema',)
('mysql',)
('online_movie_rating',)
('performance_schema',)
('sys',)
_0 mengacu pada objek 
from getpass import getpass
from mysql.connector import connect, Error

try:
    with connect(
        host="localhost",
        user=input("Enter username: "),
        password=getpass("Enter password: "),
    ) as connection:
        create_db_query = "CREATE DATABASE online_movie_rating"
        with connection.cursor() as cursor:
            cursor.execute(create_db_query)
except Error as e:
    print(e)
7 yang dikembalikan saat Anda terhubung ke database Anda

Perhatikan juga pernyataan 

>>> import mysql.connector
_32 di akhir kode. Secara default, konektor MySQL Anda tidak melakukan autocommit. Di MySQL, modifikasi yang disebutkan dalam transaksi hanya terjadi ketika Anda menggunakan perintah ________10______33 pada akhirnya. Selalu panggil metode ini setelah setiap transaksi untuk melakukan perubahan pada tabel sebenarnya

Seperti yang Anda lakukan dengan tabel 

create_movies_table_query = """
CREATE TABLE movies(
    id INT AUTO_INCREMENT PRIMARY KEY,
    title VARCHAR(100),
    release_year YEAR(4),
    genre VARCHAR(100),
    collection_in_mil INT
)
"""
with connection.cursor() as cursor:
    cursor.execute(create_movies_table_query)
    connection.commit()
_9, jalankan skrip berikut untuk membuat tabel 
>>> import mysql.connector
05

>>> import mysql.connector
_0

Jika diperlukan, Anda dapat menambahkan lebih banyak informasi tentang pengulas, seperti ID email atau informasi demografis mereka. Tapi 

>>> import mysql.connector
_07 dan 
>>> import mysql.connector
08 akan melayani tujuan Anda untuk saat ini

Terakhir, Anda dapat membuat tabel 

>>> import mysql.connector
_09 menggunakan skrip berikut

>>> import mysql.connector
_1

Penerapan hubungan kunci asing di MySQL sedikit berbeda dan terbatas dibandingkan dengan SQL standar. Di MySQL, induk dan anak dalam batasan kunci asing harus menggunakan mesin penyimpanan yang sama

Mesin penyimpanan adalah komponen perangkat lunak dasar yang digunakan sistem manajemen basis data untuk melakukan operasi SQL. Di MySQL, mesin penyimpanan hadir dalam dua rasa berbeda

  1. Mesin penyimpanan transaksional aman untuk transaksi dan memungkinkan Anda memutar kembali transaksi menggunakan perintah sederhana seperti 

    >>> import mysql.connector
    39. Banyak mesin MySQL populer, termasuk InnoDB dan NDB, termasuk dalam kategori ini

  2. Mesin penyimpanan nontransaksional bergantung pada kode manual yang rumit untuk membatalkan pernyataan yang dilakukan pada database. MyISAM, MEMORY, dan banyak mesin MySQL lainnya bersifat nontransaksional

InnoDB adalah mesin penyimpanan default dan paling populer. Ini membantu menjaga integritas data dengan mendukung batasan kunci asing. Ini berarti bahwa setiap operasi CRUD pada kunci asing diperiksa untuk memastikan bahwa itu tidak menyebabkan ketidakkonsistenan pada tabel yang berbeda.

Juga, perhatikan bahwa tabel 

>>> import mysql.connector
_09 menggunakan kolom 
>>> import mysql.connector
10 dan 
>>> import mysql.connector
11, keduanya kunci asing, bersama-sama sebagai kunci utama. Langkah ini memastikan bahwa pengulas tidak dapat menilai film yang sama dua kali

Anda dapat memilih untuk menggunakan kembali kursor yang sama untuk beberapa eksekusi. Dalam hal ini, semua eksekusi akan menjadi satu transaksi atom daripada beberapa transaksi terpisah. Misalnya, Anda dapat menjalankan semua pernyataan 

>>> import mysql.connector
_18 dengan satu kursor dan kemudian melakukan transaksi Anda hanya sekali

>>> import mysql.connector
_2

Kode di atas pertama-tama akan mengeksekusi ketiga pernyataan 

cursor = connection.cursor()
4. Kemudian itu akan mengirimkan perintah 
>>> import mysql.connector
_33 ke server MySQL yang melakukan transaksi Anda. Anda juga dapat menggunakan 
>>> import mysql.connector
_46 untuk mengirim perintah 
>>> import mysql.connector
47 ke server MySQL dan menghapus semua perubahan data dari transaksi

Hilangkan iklan

Menampilkan Skema Tabel Menggunakan Pernyataan >>> import mysql.connector 48

Sekarang, setelah Anda membuat ketiga tabel tersebut, Anda dapat melihat skemanya menggunakan pernyataan SQL berikut

>>> import mysql.connector
_3

Untuk mendapatkan beberapa hasil kembali dari objek 

>>> show_db_query = "SHOW DATABASES"
>>> with connection.cursor() as cursor:
..     cursor.execute(show_db_query)
..     for db in cursor:
..         print(db)
...
('information_schema',)
('mysql',)
('online_movie_rating',)
('performance_schema',)
('sys',)
_9, Anda perlu menggunakan 
>>> import mysql.connector
50. Metode ini mengambil semua baris dari pernyataan terakhir yang dieksekusi. Dengan asumsi Anda sudah memiliki objek 
from getpass import getpass
from mysql.connector import connect, Error

try:
    with connect(
        host="localhost",
        user=input("Enter username: "),
        password=getpass("Enter password: "),
    ) as connection:
        create_db_query = "CREATE DATABASE online_movie_rating"
        with connection.cursor() as cursor:
            cursor.execute(create_db_query)
except Error as e:
    print(e)
_7 dalam variabel 
>>> show_db_query = "SHOW DATABASES"
>>> with connection.cursor() as cursor:
..     cursor.execute(show_db_query)
..     for db in cursor:
..         print(db)
...
('information_schema',)
('mysql',)
('online_movie_rating',)
('performance_schema',)
('sys',)
0, Anda dapat mencetak semua hasil yang diambil oleh 
>>> import mysql.connector
50

>>> 

>>> import mysql.connector
4

Setelah Anda menjalankan kode di atas, Anda akan menerima tabel yang berisi informasi tentang semua kolom di tabel 

create_movies_table_query = """
CREATE TABLE movies(
    id INT AUTO_INCREMENT PRIMARY KEY,
    title VARCHAR(100),
    release_year YEAR(4),
    genre VARCHAR(100),
    collection_in_mil INT
)
"""
with connection.cursor() as cursor:
    cursor.execute(create_movies_table_query)
    connection.commit()
9. Untuk setiap kolom, Anda akan menerima detail seperti tipe data kolom, apakah kolom tersebut adalah kunci utama, dan seterusnya

Memodifikasi Skema Tabel Menggunakan create_movies_table_query = """ CREATE TABLE movies( id INT AUTO_INCREMENT PRIMARY KEY, title VARCHAR(100), release_year YEAR(4), genre VARCHAR(100), collection_in_mil INT ) """ with connection.cursor() as cursor: cursor.execute(create_movies_table_query) connection.commit() 8 Pernyataan

Di tabel 

create_movies_table_query = """
CREATE TABLE movies(
    id INT AUTO_INCREMENT PRIMARY KEY,
    title VARCHAR(100),
    release_year YEAR(4),
    genre VARCHAR(100),
    collection_in_mil INT
)
"""
with connection.cursor() as cursor:
    cursor.execute(create_movies_table_query)
    connection.commit()
_9, Anda memiliki kolom bernama 
>>> import mysql.connector
04, yang berisi koleksi film box office dalam jutaan dolar. Anda dapat menulis pernyataan MySQL berikut untuk mengubah tipe data atribut 
>>> import mysql.connector
04 dari 
>>> import mysql.connector
23 menjadi 
>>> import mysql.connector
60

>>> import mysql.connector
_5

>>> import mysql.connector
_61 berarti angka desimal yang dapat memiliki maksimal 
>>> import mysql.connector
62 digit, dimana 
>>> import mysql.connector
63 adalah desimal, seperti 
>>> import mysql.connector
64, 
>>> import mysql.connector
65, 
>>> import mysql.connector
66, dan seterusnya. Setelah menjalankan pernyataan 
>>> import mysql.connector
_67, Anda dapat menampilkan skema tabel yang diperbarui menggunakan 
>>> import mysql.connector
48

>>> 

>>> import mysql.connector
6

Seperti yang ditunjukkan pada output, atribut 

>>> import mysql.connector
04 sekarang bertipe 
>>> import mysql.connector
61. Perhatikan juga bahwa dalam kode di atas, Anda memanggil 
from getpass import getpass
from mysql.connector import connect, Error

try:
    with connect(
        host="localhost",
        user=input("Enter username: "),
        password=getpass("Enter password: "),
        database="online_movie_rating",
    ) as connection:
        print(connection)
except Error as e:
    print(e)
6 dua kali. Tapi 
>>> import mysql.connector
_50 mengambil baris hanya dari kueri yang dieksekusi terakhir, yaitu 
>>> import mysql.connector
73

Menghapus Tabel Menggunakan Pernyataan cursor = connection.cursor() 3

Untuk menghapus tabel, Anda perlu menjalankan pernyataan 

>>> import mysql.connector
75 di MySQL. Menghapus tabel adalah proses yang tidak dapat diubah. Jika Anda menjalankan kode di bawah ini, maka Anda harus memanggil kueri 
>>> import mysql.connector
18 lagi untuk menggunakan tabel 
>>> import mysql.connector
09 di bagian yang akan datang

Untuk menghapus tabel 

>>> import mysql.connector
_09, kirim 
>>> import mysql.connector
79 ke 
from getpass import getpass
from mysql.connector import connect, Error

try:
    with connect(
        host="localhost",
        user=input("Enter username: "),
        password=getpass("Enter password: "),
        database="online_movie_rating",
    ) as connection:
        print(connection)
except Error as e:
    print(e)
6

>>> import mysql.connector
_7

Jika Anda menjalankan kode di atas, Anda akan berhasil menghapus tabel 

>>> import mysql.connector
09

Memasukkan Record ke dalam Tabel

Di bagian terakhir, Anda membuat tiga tabel di database Anda. 

create_movies_table_query = """
CREATE TABLE movies(
    id INT AUTO_INCREMENT PRIMARY KEY,
    title VARCHAR(100),
    release_year YEAR(4),
    genre VARCHAR(100),
    collection_in_mil INT
)
"""
with connection.cursor() as cursor:
    cursor.execute(create_movies_table_query)
    connection.commit()
9, 
>>> import mysql.connector
05, dan 
>>> import mysql.connector
09. Sekarang Anda perlu mengisi tabel ini dengan data. Bagian ini akan membahas dua cara berbeda untuk menyisipkan catatan di Konektor MySQL untuk Python

Metode pertama, 

>>> import mysql.connector
_85, bekerja dengan baik ketika jumlah record sedikit dan record dapat di-hard-coded. Metode kedua, 
>>> import mysql.connector
_86, lebih populer dan lebih cocok untuk skenario dunia nyata

Hilangkan iklan

Menggunakan >>> import mysql.connector _85

Pendekatan pertama menggunakan metode 

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

try:
    with connect(
        host="localhost",
        user=input("Enter username: "),
        password=getpass("Enter password: "),
        database="online_movie_rating",
    ) as connection:
        print(connection)
except Error as e:
    print(e)
_6 yang sama yang telah Anda gunakan sampai sekarang. Anda menulis kueri 
>>> import mysql.connector
_89 dalam sebuah string dan meneruskannya ke 
from getpass import getpass
from mysql.connector import connect, Error

try:
    with connect(
        host="localhost",
        user=input("Enter username: "),
        password=getpass("Enter password: "),
        database="online_movie_rating",
    ) as connection:
        print(connection)
except Error as e:
    print(e)
6. Anda dapat menggunakan metode ini untuk memasukkan data ke dalam tabel 
create_movies_table_query = """
CREATE TABLE movies(
    id INT AUTO_INCREMENT PRIMARY KEY,
    title VARCHAR(100),
    release_year YEAR(4),
    genre VARCHAR(100),
    collection_in_mil INT
)
"""
with connection.cursor() as cursor:
    cursor.execute(create_movies_table_query)
    connection.commit()
9

Sebagai referensi, tabel 

create_movies_table_query = """
CREATE TABLE movies(
    id INT AUTO_INCREMENT PRIMARY KEY,
    title VARCHAR(100),
    release_year YEAR(4),
    genre VARCHAR(100),
    collection_in_mil INT
)
"""
with connection.cursor() as cursor:
    cursor.execute(create_movies_table_query)
    connection.commit()
_9 memiliki lima atribut

  1. >>> import mysql.connector
    _00
  2. >>> import mysql.connector
    _01
  3. >>> import mysql.connector
    _02
  4. >>> import mysql.connector
    _03
  5. >>> import mysql.connector
    _04

Anda tidak perlu menambahkan data untuk 

>>> import mysql.connector
_00 karena 
>>> import mysql.connector
25 otomatis menghitung 
>>> import mysql.connector
00 untuk Anda. Skrip berikut menyisipkan rekaman ke dalam tabel ________59______9

>>> import mysql.connector
_8

Tabel 

create_movies_table_query = """
CREATE TABLE movies(
    id INT AUTO_INCREMENT PRIMARY KEY,
    title VARCHAR(100),
    release_year YEAR(4),
    genre VARCHAR(100),
    collection_in_mil INT
)
"""
with connection.cursor() as cursor:
    cursor.execute(create_movies_table_query)
    connection.commit()
_9 sekarang dimuat dengan tiga puluh record. Kode memanggil 
>>> import mysql.connector
_32 di bagian akhir. Sangat penting untuk memanggil 
from getpass import getpass
from mysql.connector import connect, Error

try:
    with connect(
        host="localhost",
        user=input("Enter username: "),
        password=getpass("Enter password: "),
    ) as connection:
        print(connection)
except Error as e:
    print(e)
_04 setelah melakukan modifikasi apa pun pada tabel

Menggunakan >>> import mysql.connector _86

Pendekatan sebelumnya lebih cocok bila jumlah record cukup kecil dan Anda dapat menulis record ini langsung ke dalam kode. Tapi ini jarang benar. Anda akan sering menyimpan data ini di beberapa file lain, atau data akan dihasilkan oleh skrip yang berbeda dan perlu ditambahkan ke database MySQL

Di sinilah 

>>> import mysql.connector
_86 berguna. Ia menerima dua parameter

  1. Kueri yang berisi placeholder untuk rekaman yang perlu disisipkan
  2. Daftar yang berisi semua catatan yang ingin Anda sisipkan

Contoh berikut menyisipkan rekaman untuk tabel 

>>> import mysql.connector
_05

>>> import mysql.connector
_9

Dalam skrip di atas, Anda meneruskan kueri dan daftar rekaman sebagai argumen ke 

>>> import mysql.connector
86. Rekaman ini dapat diambil dari file atau dari pengguna dan disimpan dalam daftar 
from getpass import getpass
from mysql.connector import connect, Error

try:
    with connect(
        host="localhost",
        user=input("Enter username: "),
        password=getpass("Enter password: "),
    ) as connection:
        print(connection)
except Error as e:
    print(e)
09

Kode menggunakan 

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

try:
    with connect(
        host="localhost",
        user=input("Enter username: "),
        password=getpass("Enter password: "),
    ) as connection:
        print(connection)
except Error as e:
    print(e)
10 sebagai pengganti untuk dua string yang harus dimasukkan ke dalam 
from getpass import getpass
from mysql.connector import connect, Error

try:
    with connect(
        host="localhost",
        user=input("Enter username: "),
        password=getpass("Enter password: "),
    ) as connection:
        print(connection)
except Error as e:
    print(e)
11. Placeholder bertindak sebagai penentu format dan membantu mencadangkan tempat untuk variabel di dalam string. Variabel yang ditentukan kemudian ditambahkan ke tempat ini selama eksekusi

Anda juga dapat menggunakan 

>>> import mysql.connector
_86 untuk menyisipkan catatan di tabel 
>>> import mysql.connector
09

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

try:
    with connect(
        host="localhost",
        user=input("Enter username: "),
        password=getpass("Enter password: "),
    ) as connection:
        print(connection)
except Error as e:
    print(e)
0

Ketiga tabel sekarang diisi dengan data. Anda sekarang memiliki database peringkat film online yang berfungsi penuh. Langkah selanjutnya adalah memahami bagaimana berinteraksi dengan database ini

Membaca Catatan Dari Database

Sampai sekarang, Anda telah membangun database Anda. Sekarang saatnya untuk melakukan beberapa kueri dan menemukan beberapa properti menarik dari kumpulan data ini. Di bagian ini, Anda akan mempelajari cara membaca record dari tabel database menggunakan pernyataan 

cursor = connection.cursor()
2

Hilangkan iklan

Membaca Catatan Menggunakan Pernyataan cursor = connection.cursor() 2

Untuk mengambil rekaman, Anda perlu mengirim kueri 

cursor = connection.cursor()
2 ke 
from getpass import getpass
from mysql.connector import connect, Error

try:
    with connect(
        host="localhost",
        user=input("Enter username: "),
        password=getpass("Enter password: "),
        database="online_movie_rating",
    ) as connection:
        print(connection)
except Error as e:
    print(e)
6. Kemudian Anda menggunakan 
>>> import mysql.connector
_50 untuk mengekstrak tabel yang diambil dalam bentuk daftar baris atau catatan

Coba tulis kueri MySQL untuk memilih semua rekaman dari tabel 

create_movies_table_query = """
CREATE TABLE movies(
    id INT AUTO_INCREMENT PRIMARY KEY,
    title VARCHAR(100),
    release_year YEAR(4),
    genre VARCHAR(100),
    collection_in_mil INT
)
"""
with connection.cursor() as cursor:
    cursor.execute(create_movies_table_query)
    connection.commit()
9 dan kirimkan ke 
>>> import mysql.connector
85

>>> 

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

try:
    with connect(
        host="localhost",
        user=input("Enter username: "),
        password=getpass("Enter password: "),
    ) as connection:
        print(connection)
except Error as e:
    print(e)
1

Variabel 

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

try:
    with connect(
        host="localhost",
        user=input("Enter username: "),
        password=getpass("Enter password: "),
    ) as connection:
        print(connection)
except Error as e:
    print(e)
_21 menampung catatan yang dikembalikan dari penggunaan 
from getpass import getpass
from mysql.connector import connect, Error

try:
    with connect(
        host="localhost",
        user=input("Enter username: "),
        password=getpass("Enter password: "),
    ) as connection:
        print(connection)
except Error as e:
    print(e)
22. Ini adalah daftar tupel yang mewakili catatan individual dari tabel

Dalam kueri di atas, Anda menggunakan klausa 

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

try:
    with connect(
        host="localhost",
        user=input("Enter username: "),
        password=getpass("Enter password: "),
    ) as connection:
        print(connection)
except Error as e:
    print(e)
_23 untuk membatasi jumlah baris yang diterima dari pernyataan 
cursor = connection.cursor()
2. Pengembang sering menggunakan 
from getpass import getpass
from mysql.connector import connect, Error

try:
    with connect(
        host="localhost",
        user=input("Enter username: "),
        password=getpass("Enter password: "),
    ) as connection:
        print(connection)
except Error as e:
    print(e)
23 untuk bekerja saat menangani volume data yang besar

Di MySQL, klausa 

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

try:
    with connect(
        host="localhost",
        user=input("Enter username: "),
        password=getpass("Enter password: "),
    ) as connection:
        print(connection)
except Error as e:
    print(e)
_23 membutuhkan satu atau dua argumen numerik nonnegatif. Saat menggunakan satu argumen, Anda menentukan jumlah baris maksimum yang akan dikembalikan. Karena kueri Anda menyertakan 
from getpass import getpass
from mysql.connector import connect, Error

try:
    with connect(
        host="localhost",
        user=input("Enter username: "),
        password=getpass("Enter password: "),
    ) as connection:
        print(connection)
except Error as e:
    print(e)
_27, hanya catatan ________21______28 pertama yang diambil. Saat menggunakan kedua argumen, Anda juga dapat menentukan offset baris pertama yang akan ditampilkan

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

try:
    with connect(
        host="localhost",
        user=input("Enter username: "),
        password=getpass("Enter password: "),
    ) as connection:
        print(connection)
except Error as e:
    print(e)
2

Argumen pertama menentukan offset 

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

try:
    with connect(
        host="localhost",
        user=input("Enter username: "),
        password=getpass("Enter password: "),
    ) as connection:
        print(connection)
except Error as e:
    print(e)
29, dan argumen kedua membatasi jumlah baris yang dikembalikan ke 
from getpass import getpass
from mysql.connector import connect, Error

try:
    with connect(
        host="localhost",
        user=input("Enter username: "),
        password=getpass("Enter password: "),
    ) as connection:
        print(connection)
except Error as e:
    print(e)
28. Kueri di atas akan mengembalikan baris 3 hingga 7

Anda juga dapat meminta kolom yang dipilih

>>> ________21______3

Sekarang, kode hanya menampilkan nilai dari dua kolom yang ditentukan. 

>>> import mysql.connector
_01 dan 
>>> import mysql.connector
02

Memfilter Hasil Menggunakan from getpass import getpass from mysql.connector import connect, Error try: with connect( host="localhost", user=input("Enter username: "), password=getpass("Enter password: "), ) as connection: print(connection) except Error as e: print(e) _33 Klausul

Anda dapat memfilter rekaman tabel menurut kriteria tertentu menggunakan klausa 

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

try:
    with connect(
        host="localhost",
        user=input("Enter username: "),
        password=getpass("Enter password: "),
    ) as connection:
        print(connection)
except Error as e:
    print(e)
33. Misalnya, untuk mengambil semua film dengan koleksi box office lebih dari $300 juta, Anda dapat menjalankan kueri berikut

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

try:
    with connect(
        host="localhost",
        user=input("Enter username: "),
        password=getpass("Enter password: "),
    ) as connection:
        print(connection)
except Error as e:
    print(e)
4

Anda juga dapat menggunakan klausa 

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

try:
    with connect(
        host="localhost",
        user=input("Enter username: "),
        password=getpass("Enter password: "),
    ) as connection:
        print(connection)
except Error as e:
    print(e)
_35 di kueri terakhir untuk mengurutkan hasil dari penerima tertinggi hingga terendah

>>> 

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

try:
    with connect(
        host="localhost",
        user=input("Enter username: "),
        password=getpass("Enter password: "),
    ) as connection:
        print(connection)
except Error as e:
    print(e)
5

MySQL menawarkan banyak operasi pemformatan string seperti 

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

try:
    with connect(
        host="localhost",
        user=input("Enter username: "),
        password=getpass("Enter password: "),
    ) as connection:
        print(connection)
except Error as e:
    print(e)
36 untuk menggabungkan string. Seringkali, situs web akan menampilkan judul film beserta tahun rilisnya untuk menghindari kebingungan. Untuk mengambil judul dari lima film terlaris, digabungkan dengan tahun rilisnya, Anda dapat menulis kueri berikut

>>> 

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

try:
    with connect(
        host="localhost",
        user=input("Enter username: "),
        password=getpass("Enter password: "),
    ) as connection:
        print(connection)
except Error as e:
    print(e)
6

Jika Anda tidak ingin menggunakan klausa 

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

try:
    with connect(
        host="localhost",
        user=input("Enter username: "),
        password=getpass("Enter password: "),
    ) as connection:
        print(connection)
except Error as e:
    print(e)
23 dan Anda tidak perlu mengambil semua rekaman, maka objek 
>>> show_db_query = "SHOW DATABASES"
>>> with connection.cursor() as cursor:
..     cursor.execute(show_db_query)
..     for db in cursor:
..         print(db)
...
('information_schema',)
('mysql',)
('online_movie_rating',)
('performance_schema',)
('sys',)
9 memiliki metode 
from getpass import getpass
from mysql.connector import connect, Error

try:
    with connect(
        host="localhost",
        user=input("Enter username: "),
        password=getpass("Enter password: "),
    ) as connection:
        print(connection)
except Error as e:
    print(e)
39 dan 
from getpass import getpass
from mysql.connector import connect, Error

try:
    with connect(
        host="localhost",
        user=input("Enter username: "),
        password=getpass("Enter password: "),
    ) as connection:
        print(connection)
except Error as e:
    print(e)
40 juga

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

try:
    with connect(
        host="localhost",
        user=input("Enter username: "),
        password=getpass("Enter password: "),
    ) as connection:
        print(connection)
except Error as e:
    print(e)
    39 mengambil baris berikutnya dari hasil, sebagai tuple, atau 
    from getpass import getpass
from mysql.connector import connect, Error

try:
    with connect(
        host="localhost",
        user=input("Enter username: "),
        password=getpass("Enter password: "),
    ) as connection:
        print(connection)
except Error as e:
    print(e)
    42 jika tidak ada lagi baris yang tersedia
  • from getpass import getpass
from mysql.connector import connect, Error

try:
    with connect(
        host="localhost",
        user=input("Enter username: "),
        password=getpass("Enter password: "),
    ) as connection:
        print(connection)
except Error as e:
    print(e)
    40 mengambil kumpulan baris berikutnya dari hasil sebagai daftar tupel. Ini memiliki 
    from getpass import getpass
from mysql.connector import connect, Error

try:
    with connect(
        host="localhost",
        user=input("Enter username: "),
        password=getpass("Enter password: "),
    ) as connection:
        print(connection)
except Error as e:
    print(e)
    44 argumen, yang defaultnya adalah 
    >>> import mysql.connector
    63, yang dapat Anda gunakan untuk menentukan jumlah baris yang perlu Anda ambil. Jika tidak ada lagi baris yang tersedia, maka metode mengembalikan daftar kosong

Coba ambil lagi judul dari lima film berpenghasilan tertinggi yang digabungkan dengan tahun perilisannya, tetapi kali ini gunakan 

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

try:
    with connect(
        host="localhost",
        user=input("Enter username: "),
        password=getpass("Enter password: "),
    ) as connection:
        print(connection)
except Error as e:
    print(e)
40

>>> ________21______7

Output dengan 

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

try:
    with connect(
        host="localhost",
        user=input("Enter username: "),
        password=getpass("Enter password: "),
    ) as connection:
        print(connection)
except Error as e:
    print(e)
_40 mirip dengan apa yang Anda terima ketika Anda menggunakan klausa 
from getpass import getpass
from mysql.connector import connect, Error

try:
    with connect(
        host="localhost",
        user=input("Enter username: "),
        password=getpass("Enter password: "),
    ) as connection:
        print(connection)
except Error as e:
    print(e)
23. Anda mungkin telah memperhatikan panggilan 
>>> import mysql.connector
_50 tambahan di bagian akhir. Anda melakukan ini untuk membersihkan semua sisa hasil yang tidak terbaca oleh 
from getpass import getpass
from mysql.connector import connect, Error

try:
    with connect(
        host="localhost",
        user=input("Enter username: "),
        password=getpass("Enter password: "),
    ) as connection:
        print(connection)
except Error as e:
    print(e)
40

Penting untuk membersihkan semua hasil yang belum dibaca sebelum menjalankan pernyataan lain pada koneksi yang sama. Jika tidak, pengecualian 

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

try:
    with connect(
        host="localhost",
        user=input("Enter username: "),
        password=getpass("Enter password: "),
    ) as connection:
        print(connection)
except Error as e:
    print(e)
_51 akan dimunculkan

Hilangkan iklan

Menangani Banyak Tabel Menggunakan Pernyataan cursor = connection.cursor() 5

Jika Anda menemukan kueri di bagian terakhir cukup mudah, jangan khawatir. Anda dapat membuat kueri 

cursor = connection.cursor()
_2 Anda serumit yang Anda inginkan menggunakan metode yang sama dari bagian terakhir

Mari kita lihat beberapa kueri 

cursor = connection.cursor()
5 yang sedikit lebih rumit. Jika Anda ingin mengetahui nama dari lima film dengan rating tertinggi di database Anda, maka Anda dapat menjalankan kueri berikut

>>> ________21______8

Seperti yang ditunjukkan di atas, Night of the Living Dead dan The Godfather diikat sebagai film dengan rating tertinggi di database 

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

try:
    with connect(
        host="localhost",
        user=input("Enter username: "),
        password=getpass("Enter password: "),
        database="online_movie_rating",
    ) as connection:
        print(connection)
except Error as e:
    print(e)
9 Anda

Untuk mengetahui nama pengulas yang memberi peringkat terbanyak, tulis kueri berikut

>>> 

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

try:
    with connect(
        host="localhost",
        user=input("Enter username: "),
        password=getpass("Enter password: "),
    ) as connection:
        print(connection)
except Error as e:
    print(e)
9

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

try:
    with connect(
        host="localhost",
        user=input("Enter username: "),
        password=getpass("Enter password: "),
    ) as connection:
        print(connection)
except Error as e:
    print(e)
56 adalah reviewer paling sering dalam database ini. Seperti yang terlihat di atas, tidak masalah seberapa rumit kueri karena pada akhirnya ditangani oleh server MySQL. Proses Anda untuk mengeksekusi kueri akan selalu tetap sama. teruskan kueri ke 
from getpass import getpass
from mysql.connector import connect, Error

try:
    with connect(
        host="localhost",
        user=input("Enter username: "),
        password=getpass("Enter password: "),
        database="online_movie_rating",
    ) as connection:
        print(connection)
except Error as e:
    print(e)
6 dan ambil hasilnya menggunakan 
from getpass import getpass
from mysql.connector import connect, Error

try:
    with connect(
        host="localhost",
        user=input("Enter username: "),
        password=getpass("Enter password: "),
    ) as connection:
        print(connection)
except Error as e:
    print(e)
22

Memperbarui dan Menghapus Catatan Dari Database

Di bagian ini, Anda akan memperbarui dan menghapus record dari database. Kedua operasi ini dapat dilakukan pada satu record atau beberapa record dalam tabel. Anda akan memilih baris yang perlu dimodifikasi menggunakan klausa ________21______33

from getpass import getpass from mysql.connector import connect, Error try: with connect( host="localhost", user=input("Enter username: "), password=getpass("Enter password: "), ) as connection: print(connection) except Error as e: print(e) 60 Perintah

Salah satu peninjau di basis data Anda, ________21______61, sekarang menikah dengan 

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

try:
    with connect(
        host="localhost",
        user=input("Enter username: "),
        password=getpass("Enter password: "),
    ) as connection:
        print(connection)
except Error as e:
    print(e)
62. Nama belakangnya sekarang telah berubah menjadi 
from getpass import getpass
from mysql.connector import connect, Error

try:
    with connect(
        host="localhost",
        user=input("Enter username: "),
        password=getpass("Enter password: "),
    ) as connection:
        print(connection)
except Error as e:
    print(e)
63, jadi Anda perlu memperbarui database Anda sesuai dengan itu. Untuk memperbarui record, MySQL menggunakan pernyataan ________21______60

CREATE DATABASE books_db;
0

Kode meneruskan kueri pembaruan ke 

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

try:
    with connect(
        host="localhost",
        user=input("Enter username: "),
        password=getpass("Enter password: "),
        database="online_movie_rating",
    ) as connection:
        print(connection)
except Error as e:
    print(e)
6, dan 
from getpass import getpass
from mysql.connector import connect, Error

try:
    with connect(
        host="localhost",
        user=input("Enter username: "),
        password=getpass("Enter password: "),
    ) as connection:
        print(connection)
except Error as e:
    print(e)
04 membawa perubahan yang diperlukan ke tabel 
>>> import mysql.connector
05

Catatan. Dalam kueri 

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

try:
    with connect(
        host="localhost",
        user=input("Enter username: "),
        password=getpass("Enter password: "),
    ) as connection:
        print(connection)
except Error as e:
    print(e)
_60, klausa 
from getpass import getpass
from mysql.connector import connect, Error

try:
    with connect(
        host="localhost",
        user=input("Enter username: "),
        password=getpass("Enter password: "),
    ) as connection:
        print(connection)
except Error as e:
    print(e)
33 membantu menentukan rekaman yang perlu diperbarui. Jika Anda tidak menggunakan 
from getpass import getpass
from mysql.connector import connect, Error

try:
    with connect(
        host="localhost",
        user=input("Enter username: "),
        password=getpass("Enter password: "),
    ) as connection:
        print(connection)
except Error as e:
    print(e)
_33, maka semua rekaman akan diperbarui

Misalkan Anda perlu memberikan opsi yang memungkinkan pengulas mengubah peringkat. Peninjau akan memberikan tiga nilai, 

>>> import mysql.connector
10, 
>>> import mysql.connector
11, dan 
>>> import mysql.connector
12 baru. Kode akan menampilkan catatan setelah melakukan modifikasi yang ditentukan

Dengan asumsi bahwa 

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

try:
    with connect(
        host="localhost",
        user=input("Enter username: "),
        password=getpass("Enter password: "),
    ) as connection:
        print(connection)
except Error as e:
    print(e)
_74, 
from getpass import getpass
from mysql.connector import connect, Error

try:
    with connect(
        host="localhost",
        user=input("Enter username: "),
        password=getpass("Enter password: "),
    ) as connection:
        print(connection)
except Error as e:
    print(e)
75, dan 
from getpass import getpass
from mysql.connector import connect, Error

try:
    with connect(
        host="localhost",
        user=input("Enter username: "),
        password=getpass("Enter password: "),
    ) as connection:
        print(connection)
except Error as e:
    print(e)
76 baru, Anda dapat menggunakan kueri MySQL berikut untuk melakukan modifikasi yang diperlukan

CREATE DATABASE books_db;
1

Kueri di atas pertama-tama memperbarui peringkat dan kemudian menampilkannya. Anda dapat membuat skrip Python lengkap yang membuat koneksi dengan database dan memungkinkan pengulas mengubah peringkat

CREATE DATABASE books_db;
2

Simpan kode ini ke file bernama ________21______77. Kode di atas menggunakan 

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

try:
    with connect(
        host="localhost",
        user=input("Enter username: "),
        password=getpass("Enter password: "),
    ) as connection:
        print(connection)
except Error as e:
    print(e)
_10 placeholder untuk memasukkan input yang diterima dalam string 
from getpass import getpass
from mysql.connector import connect, Error

try:
    with connect(
        host="localhost",
        user=input("Enter username: "),
        password=getpass("Enter password: "),
    ) as connection:
        print(connection)
except Error as e:
    print(e)
79. Untuk pertama kalinya dalam tutorial ini, Anda memiliki banyak kueri di dalam satu string. Untuk meneruskan beberapa kueri ke satu 
from getpass import getpass
from mysql.connector import connect, Error

try:
    with connect(
        host="localhost",
        user=input("Enter username: "),
        password=getpass("Enter password: "),
        database="online_movie_rating",
    ) as connection:
        print(connection)
except Error as e:
    print(e)
_6, Anda perlu menyetel argumen metode 
from getpass import getpass
from mysql.connector import connect, Error

try:
    with connect(
        host="localhost",
        user=input("Enter username: "),
        password=getpass("Enter password: "),
    ) as connection:
        print(connection)
except Error as e:
    print(e)
81 ke 
from getpass import getpass
from mysql.connector import connect, Error

try:
    with connect(
        host="localhost",
        user=input("Enter username: "),
        password=getpass("Enter password: "),
    ) as connection:
        print(connection)
except Error as e:
    print(e)
82

Jika 

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

try:
    with connect(
        host="localhost",
        user=input("Enter username: "),
        password=getpass("Enter password: "),
    ) as connection:
        print(connection)
except Error as e:
    print(e)
_81 adalah 
from getpass import getpass
from mysql.connector import connect, Error

try:
    with connect(
        host="localhost",
        user=input("Enter username: "),
        password=getpass("Enter password: "),
    ) as connection:
        print(connection)
except Error as e:
    print(e)
82, maka 
from getpass import getpass
from mysql.connector import connect, Error

try:
    with connect(
        host="localhost",
        user=input("Enter username: "),
        password=getpass("Enter password: "),
        database="online_movie_rating",
    ) as connection:
        print(connection)
except Error as e:
    print(e)
6 mengembalikan sebuah iterator. Setiap item dalam iterator sesuai dengan objek 
>>> show_db_query = "SHOW DATABASES"
>>> with connection.cursor() as cursor:
..     cursor.execute(show_db_query)
..     for db in cursor:
..         print(db)
...
('information_schema',)
('mysql',)
('online_movie_rating',)
('performance_schema',)
('sys',)
9 yang mengeksekusi pernyataan yang diteruskan dalam kueri. Kode di atas menjalankan 
cursor = connection.cursor()
0 loop pada iterator ini dan kemudian memanggil 
from getpass import getpass
from mysql.connector import connect, Error

try:
    with connect(
        host="localhost",
        user=input("Enter username: "),
        password=getpass("Enter password: "),
    ) as connection:
        print(connection)
except Error as e:
    print(e)
22 pada setiap objek 
>>> show_db_query = "SHOW DATABASES"
>>> with connection.cursor() as cursor:
..     cursor.execute(show_db_query)
..     for db in cursor:
..         print(db)
...
('information_schema',)
('mysql',)
('online_movie_rating',)
('performance_schema',)
('sys',)
9

Catatan. Menjalankan 

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

try:
    with connect(
        host="localhost",
        user=input("Enter username: "),
        password=getpass("Enter password: "),
    ) as connection:
        print(connection)
except Error as e:
    print(e)
_22 pada semua objek kursor adalah penting. Untuk mengeksekusi pernyataan baru pada koneksi yang sama, Anda harus memastikan tidak ada hasil yang belum dibaca dari eksekusi sebelumnya. Jika ada hasil yang belum dibaca, Anda akan menerima pengecualian

Jika tidak ada set hasil yang diambil pada suatu operasi, maka 

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

try:
    with connect(
        host="localhost",
        user=input("Enter username: "),
        password=getpass("Enter password: "),
    ) as connection:
        print(connection)
except Error as e:
    print(e)
22 memunculkan pengecualian. Untuk menghindari kesalahan ini, pada kode di atas Anda menggunakan properti 
from getpass import getpass
from mysql.connector import connect, Error

try:
    with connect(
        host="localhost",
        user=input("Enter username: "),
        password=getpass("Enter password: "),
    ) as connection:
        print(connection)
except Error as e:
    print(e)
92, yang menunjukkan apakah operasi yang terakhir dijalankan menghasilkan baris

Meskipun kode ini harus menyelesaikan tujuan Anda, klausa 

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

try:
    with connect(
        host="localhost",
        user=input("Enter username: "),
        password=getpass("Enter password: "),
    ) as connection:
        print(connection)
except Error as e:
    print(e)
33 adalah target utama peretas web dalam kondisi saat ini. Itu rentan terhadap apa yang disebut serangan injeksi SQL, yang dapat memungkinkan aktor jahat merusak atau menyalahgunakan database Anda

Peringatan. Jangan coba input di bawah ini di database Anda. Mereka akan merusak meja Anda dan Anda harus membuatnya kembali

Misalnya, jika pengguna mengirim 

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

try:
    with connect(
        host="localhost",
        user=input("Enter username: "),
        password=getpass("Enter password: "),
    ) as connection:
        print(connection)
except Error as e:
    print(e)
94, 
from getpass import getpass
from mysql.connector import connect, Error

try:
    with connect(
        host="localhost",
        user=input("Enter username: "),
        password=getpass("Enter password: "),
    ) as connection:
        print(connection)
except Error as e:
    print(e)
95, dan 
from getpass import getpass
from mysql.connector import connect, Error

try:
    with connect(
        host="localhost",
        user=input("Enter username: "),
        password=getpass("Enter password: "),
    ) as connection:
        print(connection)
except Error as e:
    print(e)
96 baru sebagai input, maka outputnya akan terlihat seperti ini

CREATE DATABASE books_db;
3

>>> import mysql.connector
_12 dengan 
from getpass import getpass
from mysql.connector import connect, Error

try:
    with connect(
        host="localhost",
        user=input("Enter username: "),
        password=getpass("Enter password: "),
    ) as connection:
        print(connection)
except Error as e:
    print(e)
94 dan 
from getpass import getpass
from mysql.connector import connect, Error

try:
    with connect(
        host="localhost",
        user=input("Enter username: "),
        password=getpass("Enter password: "),
    ) as connection:
        print(connection)
except Error as e:
    print(e)
95 telah diubah menjadi 
CREATE DATABASE books_db;
00. Tetapi jika Anda adalah peretas, Anda mungkin mengirim perintah tersembunyi di input Anda

CREATE DATABASE books_db;
4

Sekali lagi, output menunjukkan bahwa 

>>> import mysql.connector
_12 yang ditentukan telah diubah menjadi 
CREATE DATABASE books_db;
00. Apa yang berubah?

Peretas menyelinap dalam kueri pembaruan saat memasukkan 

>>> import mysql.connector
11. Kueri pembaruan, 
CREATE DATABASE books_db;
04, mengubah 
>>> import mysql.connector
08 dari semua catatan dalam tabel 
>>> import mysql.connector
05 menjadi 
CREATE DATABASE books_db;
07. Anda dapat melihat perubahan ini jika Anda mencetak tabel 
>>> import mysql.connector
05

>>> 

CREATE DATABASE books_db;
5

Kode di atas menampilkan 

>>> import mysql.connector
_07 dan 
>>> import mysql.connector
08 untuk semua catatan dalam tabel 
>>> import mysql.connector
05. Serangan injeksi SQL merusak tabel ini dengan mengubah 
>>> import mysql.connector
08 dari semua catatan menjadi 
CREATE DATABASE books_db;
07

Ada perbaikan cepat untuk mencegah serangan semacam itu. Jangan tambahkan nilai kueri yang diberikan oleh pengguna secara langsung ke string kueri Anda. Sebagai gantinya, perbarui skrip 

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

try:
    with connect(
        host="localhost",
        user=input("Enter username: "),
        password=getpass("Enter password: "),
    ) as connection:
        print(connection)
except Error as e:
    print(e)
_77 untuk mengirim nilai kueri ini sebagai argumen ke 
>>> import mysql.connector
85

CREATE DATABASE books_db;
6

Perhatikan bahwa placeholder 

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

try:
    with connect(
        host="localhost",
        user=input("Enter username: "),
        password=getpass("Enter password: "),
    ) as connection:
        print(connection)
except Error as e:
    print(e)
10 tidak lagi dalam tanda kutip string. String yang diteruskan ke placeholder mungkin berisi beberapa karakter khusus. Jika perlu, ini dapat diloloskan dengan benar oleh pustaka yang mendasarinya

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

try:
    with connect(
        host="localhost",
        user=input("Enter username: "),
        password=getpass("Enter password: "),
        database="online_movie_rating",
    ) as connection:
        print(connection)
except Error as e:
    print(e)
_6 memastikan bahwa nilai dalam tuple yang diterima sebagai argumen adalah dari tipe data yang diperlukan. Jika pengguna mencoba menyelinap di beberapa karakter bermasalah, maka kode tersebut akan memunculkan pengecualian

CREATE DATABASE books_db;
7

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

try:
    with connect(
        host="localhost",
        user=input("Enter username: "),
        password=getpass("Enter password: "),
        database="online_movie_rating",
    ) as connection:
        print(connection)
except Error as e:
    print(e)
6 akan memunculkan pengecualian jika menemukan karakter yang tidak diinginkan dalam input pengguna. Anda harus menggunakan pendekatan ini setiap kali memasukkan masukan pengguna ke dalam kueri. Ada cara lain untuk mencegah serangan injeksi SQL juga

Hilangkan iklan

CREATE DATABASE books_db; 19 Perintah

Menghapus catatan bekerja sangat mirip dengan memperbarui catatan. Anda menggunakan pernyataan 

CREATE DATABASE books_db;
_19 untuk menghapus rekaman yang dipilih

Catatan. Menghapus adalah proses yang tidak dapat diubah. Jika Anda tidak menggunakan klausa ________21______33, maka semua catatan dari tabel yang ditentukan akan dihapus. Anda harus menjalankan kueri 

>>> import mysql.connector
_89 lagi untuk mendapatkan kembali catatan yang dihapus

Sebaiknya Anda menjalankan kueri 

cursor = connection.cursor()
2 terlebih dahulu dengan filter yang sama untuk memastikan bahwa Anda menghapus rekaman yang benar. Misalnya, untuk menghapus semua peringkat yang diberikan oleh 
CREATE DATABASE books_db;
24, Anda harus terlebih dahulu menjalankan kueri 
cursor = connection.cursor()
2 yang sesuai

>>> ________28______8

Cuplikan kode di atas menampilkan 

>>> import mysql.connector
11 dan 
>>> import mysql.connector
10 untuk catatan dalam tabel 
>>> import mysql.connector
09 di mana 
CREATE DATABASE books_db;
24. Setelah Anda mengonfirmasi bahwa ini adalah rekaman yang perlu Anda hapus, Anda dapat menjalankan kueri ________28______19 dengan filter yang sama

CREATE DATABASE books_db;
_9

Dengan kueri ini, Anda menghapus semua peringkat yang diberikan oleh pengulas dengan 

CREATE DATABASE books_db;
24 dari tabel 
>>> import mysql.connector
09

Cara Lain untuk Menghubungkan Python dan MySQL

Dalam tutorial ini, Anda melihat MySQL Connector/Python, yang merupakan sarana yang direkomendasikan secara resmi untuk berinteraksi dengan database MySQL dari aplikasi Python. Ada dua konektor populer lainnya

  1. mysqlclient adalah perpustakaan yang merupakan pesaing dekat konektor resmi dan diperbarui secara aktif dengan fitur-fitur baru. Karena intinya ditulis dalam C, ia memiliki kinerja yang lebih baik daripada konektor resmi Python murni. Kelemahan besar adalah cukup sulit untuk menyiapkan dan menginstal, terutama di Windows

  2. MySQLdb adalah perangkat lunak lawas yang masih digunakan dalam aplikasi komersial. Itu ditulis dalam C dan lebih cepat dari MySQL Connector/Python tetapi hanya tersedia untuk Python 2

Konektor ini bertindak sebagai antarmuka antara program Anda dan database MySQL, dan Anda mengirimkan kueri SQL melaluinya. Tetapi banyak pengembang lebih suka menggunakan paradigma berorientasi objek daripada kueri SQL untuk memanipulasi data

Pemetaan objek-relasional (ORM) adalah teknik yang memungkinkan Anda untuk meminta dan memanipulasi data dari database secara langsung menggunakan bahasa berorientasi objek. Pustaka ORM merangkum kode yang diperlukan untuk memanipulasi data, yang menghilangkan kebutuhan untuk menggunakan sedikit SQL. Berikut adalah ORM Python paling populer untuk database berbasis SQL

  1. SQLAlchemy adalah ORM yang memfasilitasi komunikasi antara Python dan database SQL lainnya. Anda dapat membuat mesin yang berbeda untuk database yang berbeda seperti MySQL, PostgreSQL, SQLite, dan sebagainya. SQLAlchemy umumnya digunakan untuk menyediakan fungsionalitas penanganan data yang lengkap

  2. peewee adalah ORM yang ringan dan cepat yang cepat disiapkan. Ini cukup berguna ketika interaksi Anda dengan database terbatas pada penggalian beberapa record. Misalnya, jika Anda perlu menyalin record yang dipilih dari database MySQL ke dalam file CSV, maka peewee mungkin merupakan pilihan terbaik Anda

  3. Django ORM adalah salah satu fitur paling kuat dari Django dan disediakan bersama kerangka web Django. Itu dapat berinteraksi dengan berbagai database seperti SQLite, PostgreSQL, dan MySQL. Banyak aplikasi berbasis Django menggunakan Django ORM untuk pemodelan data dan kueri dasar tetapi sering beralih ke SQLAlchemy untuk persyaratan yang lebih kompleks

Anda mungkin menemukan salah satu dari pendekatan ini lebih cocok untuk aplikasi Anda. Jika Anda tidak yakin mana yang akan digunakan, sebaiknya gunakan MySQL Connector/Python yang direkomendasikan secara resmi yang Anda lihat beraksi di tutorial ini

Kesimpulan

Dalam tutorial ini, Anda melihat cara menggunakan MySQL Connector/Python untuk mengintegrasikan database MySQL dengan aplikasi Python Anda. Anda juga melihat beberapa fitur unik dari database MySQL yang membedakannya dari database SQL lainnya

Sepanjang jalan, Anda mempelajari beberapa praktik terbaik pemrograman yang layak dipertimbangkan saat membangun koneksi, membuat tabel, dan menyisipkan serta memperbarui catatan dalam aplikasi database. Anda juga mengembangkan contoh database MySQL untuk sistem rating film online dan berinteraksi langsung dengannya dari aplikasi Python Anda

Dalam tutorial ini, Anda belajar caranya

  • Hubungkan aplikasi Python Anda dengan database MySQL
  • Bawa data dari database MySQL ke Python untuk analisis lebih lanjut
  • Jalankan kueri SQL dari aplikasi Python Anda
  • Tangani pengecualian saat mengakses database
  • Cegah serangan injeksi SQL pada aplikasi Anda

Jika Anda tertarik, Python juga memiliki konektor untuk DBMS lain seperti MongoDB dan PostgreSQL. Untuk informasi lebih lanjut, lihat Tutorial Database Python

Tandai sebagai Selesai

🐍 Trik Python 💌

Dapatkan Trik Python singkat & manis yang dikirim ke kotak masuk Anda setiap beberapa hari. Tidak pernah ada spam. Berhenti berlangganan kapan saja. Dikuratori oleh tim Real Python

Metode apa yang digunakan untuk terhubung ke database dengan python?

Kirimi Saya Trik Python »

Tentang Chaitanya Baweja

Metode apa yang digunakan untuk terhubung ke database dengan python?
Metode apa yang digunakan untuk terhubung ke database dengan python?

Chaitanya adalah seorang Pythonista yang rajin dan menulis untuk Real Python

» Lebih lanjut tentang Chaitanya

Setiap tutorial di Real Python dibuat oleh tim pengembang sehingga memenuhi standar kualitas tinggi kami. Anggota tim yang mengerjakan tutorial ini adalah

Metode apa yang digunakan untuk terhubung ke database dengan python?

Aldren

Metode apa yang digunakan untuk terhubung ke database dengan python?

Bartosz

Metode apa yang digunakan untuk terhubung ke database dengan python?

Geir Arne

Metode apa yang digunakan untuk terhubung ke database dengan python?

Joanna

Metode apa yang digunakan untuk terhubung ke database dengan python?

Yakub

Master Keterampilan Python Dunia Nyata Dengan Akses Tanpa Batas ke Python Nyata

Bergabunglah dengan kami dan dapatkan akses ke ribuan tutorial, kursus video langsung, dan komunitas pakar Pythonista

Tingkatkan Keterampilan Python Anda »

Guru Keterampilan Python Dunia Nyata
Dengan Akses Tak Terbatas ke Real Python

Bergabunglah dengan kami dan dapatkan akses ke ribuan tutorial, kursus video langsung, dan komunitas ahli Pythonista

Tingkatkan Keterampilan Python Anda »

Bagaimana menurutmu?

Nilai artikel ini

Tweet Bagikan Bagikan Email

Apa takeaway # 1 Anda atau hal favorit yang Anda pelajari?

Kiat Berkomentar. Komentar yang paling berguna adalah yang ditulis dengan tujuan belajar dari atau membantu siswa lain. dan dapatkan jawaban atas pertanyaan umum di portal dukungan kami

Bagaimana saya bisa terhubung ke database dengan Python?

Cara menghubungkan database MySQL dengan Python .
Instal modul konektor MySQL. Gunakan perintah pip untuk menginstal konektor MySQL Python. .
Impor modul konektor MySQL. .
Gunakan metode connect(). .
Gunakan metode kursor(). .
Gunakan metode eksekusi(). .
Ekstrak hasil menggunakan fetchall().
Tutup objek kursor dan koneksi

Metode apa yang digunakan untuk menghubungkan database?

Metode getConnection() dari kelas DriverManager digunakan untuk membuat koneksi dengan database.

Metode apa yang digunakan untuk menghubungkan database di Python Mcq?

Jawaban. Untuk membuat koneksi antara database MySQL dan aplikasi python, digunakan fungsi connect( ) .

kode python

Pos Terkait

Menambah dan menghapus item dari listbox menggunakan javascript
Menambah dan menghapus item dari listbox menggunakan javascript

Bagaimana cara keluar dari tampilan hanya di google sheets?
Bagaimana cara keluar dari tampilan hanya di google sheets?

Cara menggunakan import txt to excel
Cara menggunakan import txt to excel

Cara menggunakan open file php online
Cara menggunakan open file php online

Tulis skrip python untuk menggabungkan kamus berikut untuk membuat yang baru
Tulis skrip python untuk menggabungkan kamus berikut untuk membuat yang baru

Bagaimana mengambil data dari database di php dan ditampilkan di kotak teks?
Bagaimana mengambil data dari database di php dan ditampilkan di kotak teks?

Cara membuat database postgresql di windows
Cara membuat database postgresql di windows

Perbarui data di php menggunakan formulir
Perbarui data di php menggunakan formulir

Dapatkan data mongodb di node js
Dapatkan data mongodb di node js

Cara menggunakan is php software free?
Cara menggunakan is php software free?

Periklanan

BERITA TERKINI

Cara menggunakan email html
1 years ago . by LegitimateSubcommittee
JavaScript substring first and last character
1 years ago . by UsualShopping
Bagaimana cara menjalankan tugas cron dalam skrip php?
1 years ago . by SerialSubscription
Php dan modul mysql pdf
1 years ago . by ShockingSwimmer
Print range list Python
1 years ago . by InspirationalCollaborator
Php dapatkan semua variabel lingkungan
1 years ago . by PrimaryIrrigation
Cara menggunakan dateiff postgresql
1 years ago . by PreviousLiner
Can you lock a Google sheet from editing?
1 years ago . by Double-breastedDollar
Bagaimana cara menambahkan data dari api ke google sheets?
1 years ago . by ExtensiveBingo
Bagaimana cara memasukkan skrip ke google sheets?
1 years ago . by MadStorey

Toplist Popular

#1
Top 7 rothenburg ob der tauber sehenswürdigkeiten stadtplan 2022
1 years ago
#2
Top 8 rufumleitung für bestimmte nummern android 2022
1 years ago
#3
Top 8 mündliche prüfung 2. staatsexamen jura bayern 2022
1 years ago
#4
Top 8 wenn kleinigkeiten am partner stören 2022
1 years ago
#5
Top 7 hilfsmittel für behinderte im alltag 2022
1 years ago
#6
Top 8 wann gilt lkw-fahrverbot in deutschland? 2022
1 years ago
#7
Top 7 wookie und copilot von han solo in star wars 2022
1 years ago
#8
Top 6 cafe da manha pobre 2022
1 years ago
#9
Top 7 bildung und teilhabe mühlhausen telefonnummer 2022
1 years ago
#10
Top 6 tiguan allspace 3 sitzreihe nachrüsten 2022
1 years ago

Periklanan

Terpopuler

Token Data

Periklanan

Tentang Kami

Legal

Dukungan

Social

homeentr
Copyright © 2024 kemunculan Inc.