kode python

Python api ke sql server

Semua aplikasi perangkat lunak berinteraksi dengan data, paling sering melalui a. Beberapa bahasa pemrograman hadir dengan modul yang dapat Anda gunakan untuk berinteraksi dengan DBMS, sementara yang lain memerlukan penggunaan paket pihak ketiga. Dalam tutorial ini, Anda akan menjelajahi berbagai pustaka Python SQL yang dapat Anda gunakan. Anda akan mengembangkan aplikasi langsung untuk berinteraksi dengan database SQLite, MySQL, dan PostgreSQL

Dalam tutorial ini, Anda akan mempelajari caranya

Terhubung ke sistem manajemen basis data yang berbeda dengan pustaka Python SQL
Berinteraksi dengan database SQLite, MySQL, dan PostgreSQL
Lakukan kueri basis data umum menggunakan aplikasi Python
Kembangkan aplikasi di berbagai basis data menggunakan skrip Python

Untuk mendapatkan hasil maksimal dari tutorial ini, Anda harus memiliki pengetahuan dasar Python, SQL, dan bekerja dengan sistem manajemen basis data. Anda juga harus dapat mengunduh dan mengimpor paket dengan Python dan mengetahui cara memasang dan menjalankan server basis data yang berbeda secara lokal atau jarak jauh

Unduhan PDF gratis. Lembar Curang Python 3

Memahami Skema Database

Dalam tutorial ini, Anda akan mengembangkan database yang sangat kecil untuk aplikasi media sosial. Database akan terdiri dari empat tabel

create_database_query = "CREATE DATABASE sm_app"
create_database[connection, create_database_query]

create_database_query = "CREATE DATABASE sm_app"
create_database[connection, create_database_query]

create_database_query = "CREATE DATABASE sm_app"
create_database[connection, create_database_query]

create_database_query = "CREATE DATABASE sm_app"
create_database[connection, create_database_query]

Diagram tingkat tinggi dari skema database ditunjukkan di bawah ini

Baik

create_database_query = "CREATE DATABASE sm_app"
create_database[connection, create_database_query]

5 dan

create_database_query = "CREATE DATABASE sm_app"
create_database[connection, create_database_query]

6 akan memiliki hubungan one-to-many karena satu pengguna dapat menyukai banyak postingan. Demikian pula, satu pengguna dapat memposting banyak komentar, dan satu posting juga dapat memiliki banyak komentar. Jadi,

create_database_query = "CREATE DATABASE sm_app"
create_database[connection, create_database_query]

5 dan

create_database_query = "CREATE DATABASE sm_app"
create_database[connection, create_database_query]

6 juga akan memiliki hubungan satu-ke-banyak dengan tabel

create_database_query = "CREATE DATABASE sm_app"
create_database[connection, create_database_query]

7. Ini juga berlaku untuk tabel

create_database_query = "CREATE DATABASE sm_app"
create_database[connection, create_database_query]

_8, jadi baik

create_database_query = "CREATE DATABASE sm_app"
create_database[connection, create_database_query]

5 dan

create_database_query = "CREATE DATABASE sm_app"
create_database[connection, create_database_query]

6 akan memiliki hubungan satu-ke-banyak dengan tabel

create_database_query = "CREATE DATABASE sm_app"
create_database[connection, create_database_query]

Hilangkan iklan

Menggunakan Pustaka Python SQL untuk Menghubungkan ke Basis Data

Sebelum Anda berinteraksi dengan database apa pun melalui Python SQL Library, Anda harus terhubung ke database itu. Di bagian ini, Anda akan melihat cara menghubungkan ke database SQLite, MySQL, dan PostgreSQL dari dalam aplikasi Python

Catatan. Anda harus mengaktifkan dan menjalankan server MySQL dan PostgreSQL sebelum Anda menjalankan skrip di bagian database MySQL dan PostgreSQL. Untuk intro cepat tentang cara memulai server MySQL, lihat bagian MySQL. Untuk mempelajari cara membuat database di PostgreSQL, lihat bagian Menyiapkan Database

Anda disarankan untuk membuat tiga file Python yang berbeda, sehingga Anda memiliki satu untuk masing-masing dari ketiga database tersebut. Anda akan menjalankan skrip untuk setiap database dalam file yang sesuai

SQLite

SQLite mungkin adalah database yang paling mudah untuk terhubung dengan aplikasi Python karena Anda tidak perlu menginstal modul Python SQL eksternal apa pun untuk melakukannya. Secara default, instalasi Python Anda berisi pustaka Python SQL bernama

 1def create_connection[host_name, user_name, user_password, db_name]:
 2    connection = None
 3    try:
 4        connection = mysql.connector.connect[
 5            host=host_name,
 6            user=user_name,
 7            passwd=user_password,
 8            database=db_name
 9        ]
10        print["Connection to MySQL DB successful"]
11    except Error as e:
12        print[f"The error '{e}' occurred"]
13
14    return connection

8 yang dapat Anda gunakan untuk berinteraksi dengan database SQLite

Terlebih lagi, database SQLite tidak memiliki server dan berdiri sendiri, karena mereka membaca dan menulis data ke file. Artinya, tidak seperti MySQL dan PostgreSQL, Anda bahkan tidak perlu menginstal dan menjalankan server SQLite untuk melakukan operasi database

Inilah cara Anda menggunakan

 1def create_connection[host_name, user_name, user_password, db_name]:
 2    connection = None
 3    try:
 4        connection = mysql.connector.connect[
 5            host=host_name,
 6            user=user_name,
 7            passwd=user_password,
 8            database=db_name
 9        ]
10        print["Connection to MySQL DB successful"]
11    except Error as e:
12        print[f"The error '{e}' occurred"]
13
14    return connection

_8 untuk terhubung ke database SQLite dengan Python

 1import sqlite3
 2from sqlite3 import Error
 3
 4def create_connection[path]:
 5    connection = None
 6    try:
 7        connection = sqlite3.connect[path]
 8        print["Connection to SQLite DB successful"]
 9    except Error as e:
10        print[f"The error '{e}' occurred"]
11
12    return connection

Begini cara kerja kode ini

Baris 1 dan 2 mengimpor

 1def create_connection[host_name, user_name, user_password, db_name]:
 2    connection = None
 3    try:
 4        connection = mysql.connector.connect[
 5            host=host_name,
 6            user=user_name,
 7            passwd=user_password,
 8            database=db_name
 9        ]
10        print["Connection to MySQL DB successful"]
11    except Error as e:
12        print[f"The error '{e}' occurred"]
13
14    return connection

_8 dan kelas modul

connection = create_connection["localhost", "root", "", "sm_app"]

Baris 4 mendefinisikan fungsi

connection = create_connection["localhost", "root", "", "sm_app"]

_2 yang menerima jalur ke database SQLite

Baris 7 menggunakan

connection = create_connection["localhost", "root", "", "sm_app"]

3 dari modul

 1def create_connection[host_name, user_name, user_password, db_name]:
 2    connection = None
 3    try:
 4        connection = mysql.connector.connect[
 5            host=host_name,
 6            user=user_name,
 7            passwd=user_password,
 8            database=db_name
 9        ]
10        print["Connection to MySQL DB successful"]
11    except Error as e:
12        print[f"The error '{e}' occurred"]
13
14    return connection

8 dan menggunakan jalur database SQLite sebagai parameter. Jika database ada di lokasi yang ditentukan, maka koneksi ke database dibuat. Jika tidak, database baru dibuat di lokasi yang ditentukan, dan sambungan dibuat

Baris 8 mencetak status koneksi database yang berhasil
Baris 9 menangkap pengecualian apa pun yang mungkin dilemparkan jika
```
connection = create_connection["localhost", "root", "", "sm_app"]
```
3 gagal membuat sambungan
Baris 10 menampilkan pesan kesalahan di konsol

connection = create_connection["localhost", "root", "", "sm_app"]

6 mengembalikan objek

connection = create_connection["localhost", "root", "", "sm_app"]

7, yang pada gilirannya dikembalikan oleh

connection = create_connection["localhost", "root", "", "sm_app"]

8. Objek

connection = create_connection["localhost", "root", "", "sm_app"]

_7 ini dapat digunakan untuk mengeksekusi kueri pada database SQLite. Skrip berikut membuat koneksi ke database SQLite

connection = create_connection["E:\\sm_app.sqlite"]

Setelah Anda menjalankan skrip di atas, Anda akan melihat bahwa file database

$ pip install psycopg2

0 dibuat di direktori root. Perhatikan bahwa Anda dapat mengubah lokasi agar sesuai dengan penyiapan Anda

MySQL

Tidak seperti SQLite, tidak ada modul Python SQL default yang dapat Anda gunakan untuk terhubung ke database MySQL. Sebagai gantinya, Anda harus menginstal driver Python SQL untuk MySQL agar dapat berinteraksi dengan database MySQL dari dalam aplikasi Python. Salah satu pengemudi tersebut adalah

$ pip install psycopg2

_1. Anda dapat mengunduh modul Python SQL ini dengan

$ pip install psycopg2

$ pip install mysql-connector-python

Perhatikan bahwa MySQL adalah sistem manajemen basis data berbasis server. Satu server MySQL dapat memiliki banyak database. Tidak seperti SQLite, di mana membuat koneksi sama saja dengan membuat database, database MySQL memiliki proses dua langkah untuk pembuatan database

Buat koneksi ke server MySQL
Jalankan kueri terpisah untuk membuat database

Tentukan fungsi yang menghubungkan ke server database MySQL dan mengembalikan objek koneksi

 1import mysql.connector
 2from mysql.connector import Error
 3
 4def create_connection[host_name, user_name, user_password]:
 5    connection = None
 6    try:
 7        connection = mysql.connector.connect[
 8            host=host_name,
 9            user=user_name,
10            passwd=user_password
11        ]
12        print["Connection to MySQL DB successful"]
13    except Error as e:
14        print[f"The error '{e}' occurred"]
15
16    return connection
17
18connection = create_connection["localhost", "root", ""]

Dalam skrip di atas, Anda menentukan fungsi

connection = create_connection["localhost", "root", "", "sm_app"]

8 yang menerima tiga parameter

nama_host
nama belakang
user_password

Modul

$ pip install psycopg2

_4 Python SQL berisi metode

connection = create_connection["localhost", "root", "", "sm_app"]

3 yang Anda gunakan di baris 7 untuk terhubung ke server database MySQL. Setelah koneksi dibuat, objek

connection = create_connection["localhost", "root", "", "sm_app"]

_7 dikembalikan ke fungsi panggilan. Terakhir, pada baris 18 Anda memanggil

connection = create_connection["localhost", "root", "", "sm_app"]

8 dengan nama host, nama pengguna, dan kata sandi

Sejauh ini, Anda hanya membuat koneksi. Database belum dibuat. Untuk melakukannya, Anda akan menentukan fungsi lain

$ pip install psycopg2

8 yang menerima dua parameter

connection = create_connection["localhost", "root", "", "sm_app"]

7 adalah objek

connection = create_connection["localhost", "root", "", "sm_app"]

7 ke server basis data tempat Anda ingin berinteraksi

import psycopg2
from psycopg2 import OperationalError

def create_connection[db_name, db_user, db_password, db_host, db_port]:
    connection = None
    try:
        connection = psycopg2.connect[
            database=db_name,
            user=db_user,
            password=db_password,
            host=db_host,
            port=db_port,
        ]
        print["Connection to PostgreSQL DB successful"]
    except OperationalError as e:
        print[f"The error '{e}' occurred"]
    return connection

1 adalah kueri yang membuat database

Seperti inilah tampilan fungsi ini

def create_database[connection, query]:
    cursor = connection.cursor[]
    try:
        cursor.execute[query]
        print["Database created successfully"]
    except Error as e:
        print[f"The error '{e}' occurred"]

Untuk mengeksekusi kueri, Anda menggunakan objek

import psycopg2
from psycopg2 import OperationalError

def create_connection[db_name, db_user, db_password, db_host, db_port]:
    connection = None
    try:
        connection = psycopg2.connect[
            database=db_name,
            user=db_user,
            password=db_password,
            host=db_host,
            port=db_port,
        ]
        print["Connection to PostgreSQL DB successful"]
    except OperationalError as e:
        print[f"The error '{e}' occurred"]
    return connection

import psycopg2
from psycopg2 import OperationalError

def create_connection[db_name, db_user, db_password, db_host, db_port]:
    connection = None
    try:
        connection = psycopg2.connect[
            database=db_name,
            user=db_user,
            password=db_password,
            host=db_host,
            port=db_port,
        ]
        print["Connection to PostgreSQL DB successful"]
    except OperationalError as e:
        print[f"The error '{e}' occurred"]
    return connection

1 yang akan dieksekusi diteruskan ke

import psycopg2
from psycopg2 import OperationalError

def create_connection[db_name, db_user, db_password, db_host, db_port]:
    connection = None
    try:
        connection = psycopg2.connect[
            database=db_name,
            user=db_user,
            password=db_password,
            host=db_host,
            port=db_port,
        ]
        print["Connection to PostgreSQL DB successful"]
    except OperationalError as e:
        print[f"The error '{e}' occurred"]
    return connection

4 dalam format string

Buat database bernama

import psycopg2
from psycopg2 import OperationalError

def create_connection[db_name, db_user, db_password, db_host, db_port]:
    connection = None
    try:
        connection = psycopg2.connect[
            database=db_name,
            user=db_user,
            password=db_password,
            host=db_host,
            port=db_port,
        ]
        print["Connection to PostgreSQL DB successful"]
    except OperationalError as e:
        print[f"The error '{e}' occurred"]
    return connection

_5 untuk aplikasi media sosial Anda di server database MySQL

create_database_query = "CREATE DATABASE sm_app"
create_database[connection, create_database_query]

Sekarang Anda telah membuat database

import psycopg2
from psycopg2 import OperationalError

def create_connection[db_name, db_user, db_password, db_host, db_port]:
    connection = None
    try:
        connection = psycopg2.connect[
            database=db_name,
            user=db_user,
            password=db_password,
            host=db_host,
            port=db_port,
        ]
        print["Connection to PostgreSQL DB successful"]
    except OperationalError as e:
        print[f"The error '{e}' occurred"]
    return connection

5 di server database. Namun, objek

connection = create_connection["localhost", "root", "", "sm_app"]

_7 dikembalikan oleh

connection = create_connection["localhost", "root", "", "sm_app"]

8 terhubung ke server database MySQL. Anda perlu terhubung ke database

import psycopg2
from psycopg2 import OperationalError

def create_connection[db_name, db_user, db_password, db_host, db_port]:
    connection = None
    try:
        connection = psycopg2.connect[
            database=db_name,
            user=db_user,
            password=db_password,
            host=db_host,
            port=db_port,
        ]
        print["Connection to PostgreSQL DB successful"]
    except OperationalError as e:
        print[f"The error '{e}' occurred"]
    return connection

5. Untuk melakukannya, Anda dapat memodifikasi

connection = create_connection["localhost", "root", "", "sm_app"]

_8 sebagai berikut

 1def create_connection[host_name, user_name, user_password, db_name]:
 2    connection = None
 3    try:
 4        connection = mysql.connector.connect[
 5            host=host_name,
 6            user=user_name,
 7            passwd=user_password,
 8            database=db_name
 9        ]
10        print["Connection to MySQL DB successful"]
11    except Error as e:
12        print[f"The error '{e}' occurred"]
13
14    return connection

Anda dapat melihat di baris 8 bahwa

connection = create_connection["localhost", "root", "", "sm_app"]

_8 sekarang menerima parameter tambahan bernama

connection = create_connection["E:\\sm_app.sqlite"]

02. Parameter ini menentukan nama database yang ingin Anda sambungkan. Anda dapat memasukkan nama database yang ingin Anda sambungkan saat Anda memanggil fungsi ini

connection = create_connection["localhost", "root", "", "sm_app"]

Skrip di atas berhasil memanggil

connection = create_connection["localhost", "root", "", "sm_app"]

_8 dan terhubung ke database

import psycopg2
from psycopg2 import OperationalError

def create_connection[db_name, db_user, db_password, db_host, db_port]:
    connection = None
    try:
        connection = psycopg2.connect[
            database=db_name,
            user=db_user,
            password=db_password,
            host=db_host,
            port=db_port,
        ]
        print["Connection to PostgreSQL DB successful"]
    except OperationalError as e:
        print[f"The error '{e}' occurred"]
    return connection

Hilangkan iklan

PostgreSQL

Seperti MySQL, tidak ada pustaka Python SQL default yang dapat Anda gunakan untuk berinteraksi dengan database PostgreSQL. Sebagai gantinya, Anda perlu menginstal driver Python SQL pihak ketiga untuk berinteraksi dengan PostgreSQL. Salah satu driver Python SQL untuk PostgreSQL adalah

connection = create_connection["E:\\sm_app.sqlite"]

05. Jalankan perintah berikut di terminal Anda untuk menginstal modul

connection = create_connection["E:\\sm_app.sqlite"]

05 Python SQL

$ pip install psycopg2

Seperti dengan database SQLite dan MySQL, Anda akan menentukan

connection = create_connection["localhost", "root", "", "sm_app"]

8 untuk membuat koneksi dengan database PostgreSQL Anda

import psycopg2
from psycopg2 import OperationalError

def create_connection[db_name, db_user, db_password, db_host, db_port]:
    connection = None
    try:
        connection = psycopg2.connect[
            database=db_name,
            user=db_user,
            password=db_password,
            host=db_host,
            port=db_port,
        ]
        print["Connection to PostgreSQL DB successful"]
    except OperationalError as e:
        print[f"The error '{e}' occurred"]
    return connection

Anda menggunakan

connection = create_connection["E:\\sm_app.sqlite"]

_08 untuk terhubung ke server PostgreSQL dari dalam aplikasi Python Anda

Anda kemudian dapat menggunakan

connection = create_connection["localhost", "root", "", "sm_app"]

_8 untuk membuat koneksi ke database PostgreSQL. Pertama, Anda akan membuat koneksi dengan database default

connection = create_connection["E:\\sm_app.sqlite"]

10 dengan menggunakan string berikut

connection = create_connection["E:\\sm_app.sqlite"]

Selanjutnya, Anda harus membuat database

import psycopg2
from psycopg2 import OperationalError

def create_connection[db_name, db_user, db_password, db_host, db_port]:
    connection = None
    try:
        connection = psycopg2.connect[
            database=db_name,
            user=db_user,
            password=db_password,
            host=db_host,
            port=db_port,
        ]
        print["Connection to PostgreSQL DB successful"]
    except OperationalError as e:
        print[f"The error '{e}' occurred"]
    return connection

5 di dalam database default

connection = create_connection["E:\\sm_app.sqlite"]

10. Anda dapat menentukan fungsi untuk mengeksekusi kueri SQL apa pun di PostgreSQL. Di bawah ini, Anda mendefinisikan

$ pip install psycopg2

_8 untuk membuat database baru di server database PostgreSQL

connection = create_connection["E:\\sm_app.sqlite"]

Setelah Anda menjalankan skrip di atas, Anda akan melihat database

import psycopg2
from psycopg2 import OperationalError

def create_connection[db_name, db_user, db_password, db_host, db_port]:
    connection = None
    try:
        connection = psycopg2.connect[
            database=db_name,
            user=db_user,
            password=db_password,
            host=db_host,
            port=db_port,
        ]
        print["Connection to PostgreSQL DB successful"]
    except OperationalError as e:
        print[f"The error '{e}' occurred"]
    return connection

5 di server database PostgreSQL Anda

Sebelum Anda menjalankan kueri pada database

import psycopg2
from psycopg2 import OperationalError

def create_connection[db_name, db_user, db_password, db_host, db_port]:
    connection = None
    try:
        connection = psycopg2.connect[
            database=db_name,
            user=db_user,
            password=db_password,
            host=db_host,
            port=db_port,
        ]
        print["Connection to PostgreSQL DB successful"]
    except OperationalError as e:
        print[f"The error '{e}' occurred"]
    return connection

5, Anda harus menyambungkannya

connection = create_connection["E:\\sm_app.sqlite"]

Setelah Anda menjalankan skrip di atas, koneksi akan dibuat dengan database

import psycopg2
from psycopg2 import OperationalError

def create_connection[db_name, db_user, db_password, db_host, db_port]:
    connection = None
    try:
        connection = psycopg2.connect[
            database=db_name,
            user=db_user,
            password=db_password,
            host=db_host,
            port=db_port,
        ]
        print["Connection to PostgreSQL DB successful"]
    except OperationalError as e:
        print[f"The error '{e}' occurred"]
    return connection

5 yang terletak di server database

connection = create_connection["E:\\sm_app.sqlite"]

10. Di sini,

connection = create_connection["E:\\sm_app.sqlite"]

_18 merujuk ke alamat IP host server database, dan

connection = create_connection["E:\\sm_app.sqlite"]

19 merujuk ke nomor port server database

Membuat Tabel

Di bagian sebelumnya, Anda melihat cara terhubung ke server database SQLite, MySQL, dan PostgreSQL menggunakan pustaka Python SQL yang berbeda. Anda membuat database

import psycopg2
from psycopg2 import OperationalError

def create_connection[db_name, db_user, db_password, db_host, db_port]:
    connection = None
    try:
        connection = psycopg2.connect[
            database=db_name,
            user=db_user,
            password=db_password,
            host=db_host,
            port=db_port,
        ]
        print["Connection to PostgreSQL DB successful"]
    except OperationalError as e:
        print[f"The error '{e}' occurred"]
    return connection

_5 di ketiga server database. Di bagian ini, Anda akan melihat cara membuat tabel di dalam tiga database ini

Seperti yang telah dibahas sebelumnya, Anda akan membuat empat tabel

create_database_query = "CREATE DATABASE sm_app"
create_database[connection, create_database_query]

create_database_query = "CREATE DATABASE sm_app"
create_database[connection, create_database_query]

create_database_query = "CREATE DATABASE sm_app"
create_database[connection, create_database_query]

create_database_query = "CREATE DATABASE sm_app"
create_database[connection, create_database_query]

Anda akan mulai dengan SQLite

SQLite

Untuk menjalankan kueri di SQLite, gunakan

import psycopg2
from psycopg2 import OperationalError

def create_connection[db_name, db_user, db_password, db_host, db_port]:
    connection = None
    try:
        connection = psycopg2.connect[
            database=db_name,
            user=db_user,
            password=db_password,
            host=db_host,
            port=db_port,
        ]
        print["Connection to PostgreSQL DB successful"]
    except OperationalError as e:
        print[f"The error '{e}' occurred"]
    return connection

4. Di bagian ini, Anda akan menentukan fungsi ________26______26 yang menggunakan metode ini. Fungsi Anda akan menerima objek

connection = create_connection["localhost", "root", "", "sm_app"]

_7 dan string kueri, yang akan Anda teruskan ke

import psycopg2
from psycopg2 import OperationalError

def create_connection[db_name, db_user, db_password, db_host, db_port]:
    connection = None
    try:
        connection = psycopg2.connect[
            database=db_name,
            user=db_user,
            password=db_password,
            host=db_host,
            port=db_port,
        ]
        print["Connection to PostgreSQL DB successful"]
    except OperationalError as e:
        print[f"The error '{e}' occurred"]
    return connection

connection = create_connection["E:\\sm_app.sqlite"]

29 dapat mengeksekusi kueri apa pun yang diteruskan kepadanya dalam bentuk string. Anda akan menggunakan metode ini untuk membuat tabel di bagian ini. Di bagian yang akan datang, Anda akan menggunakan metode yang sama ini untuk menjalankan pembaruan dan juga menghapus kueri

Catatan. Skrip ini harus dijalankan dalam file yang sama tempat Anda membuat koneksi untuk database SQLite Anda

Inilah definisi fungsi Anda

connection = create_connection["E:\\sm_app.sqlite"]

Kode ini mencoba mengeksekusi

import psycopg2
from psycopg2 import OperationalError

def create_connection[db_name, db_user, db_password, db_host, db_port]:
    connection = None
    try:
        connection = psycopg2.connect[
            database=db_name,
            user=db_user,
            password=db_password,
            host=db_host,
            port=db_port,
        ]
        print["Connection to PostgreSQL DB successful"]
    except OperationalError as e:
        print[f"The error '{e}' occurred"]
    return connection

1 yang diberikan dan mencetak pesan kesalahan jika perlu

Selanjutnya, tulis kueri Anda

connection = create_connection["E:\\sm_app.sqlite"]

Ini mengatakan untuk membuat tabel

create_database_query = "CREATE DATABASE sm_app"
create_database[connection, create_database_query]

_5 dengan lima kolom berikut

connection = create_connection["E:\\sm_app.sqlite"]

_32

connection = create_connection["E:\\sm_app.sqlite"]

_33

connection = create_connection["E:\\sm_app.sqlite"]

_34

connection = create_connection["E:\\sm_app.sqlite"]

_35

connection = create_connection["E:\\sm_app.sqlite"]

_36

Terakhir, Anda akan memanggil

connection = create_connection["E:\\sm_app.sqlite"]

26 untuk membuat tabel. Anda akan meneruskan objek

connection = create_connection["localhost", "root", "", "sm_app"]

_7 yang Anda buat di bagian sebelumnya, bersama dengan string

connection = create_connection["E:\\sm_app.sqlite"]

39 yang berisi kueri buat tabel

connection = create_connection["E:\\sm_app.sqlite"]

Kueri berikut digunakan untuk membuat tabel

create_database_query = "CREATE DATABASE sm_app"
create_database[connection, create_database_query]

connection = create_connection["E:\\sm_app.sqlite"]

Karena ada hubungan satu-ke-banyak antara

create_database_query = "CREATE DATABASE sm_app"
create_database[connection, create_database_query]

5 dan

create_database_query = "CREATE DATABASE sm_app"
create_database[connection, create_database_query]

6, Anda dapat melihat kunci asing

connection = create_connection["E:\\sm_app.sqlite"]

43 di tabel

create_database_query = "CREATE DATABASE sm_app"
create_database[connection, create_database_query]

6 yang mereferensikan kolom

connection = create_connection["E:\\sm_app.sqlite"]

32 di tabel

create_database_query = "CREATE DATABASE sm_app"
create_database[connection, create_database_query]

5. Jalankan skrip berikut untuk membuat tabel

create_database_query = "CREATE DATABASE sm_app"
create_database[connection, create_database_query]

connection = create_connection["E:\\sm_app.sqlite"]

Terakhir, Anda dapat membuat tabel

create_database_query = "CREATE DATABASE sm_app"
create_database[connection, create_database_query]

7 dan

create_database_query = "CREATE DATABASE sm_app"
create_database[connection, create_database_query]

8 dengan skrip berikut

connection = create_connection["E:\\sm_app.sqlite"]

Anda dapat melihat bahwa membuat tabel di SQLite sangat mirip dengan menggunakan SQL mentah. Yang harus Anda lakukan adalah menyimpan kueri dalam variabel string dan kemudian meneruskan variabel itu ke

import psycopg2
from psycopg2 import OperationalError

def create_connection[db_name, db_user, db_password, db_host, db_port]:
    connection = None
    try:
        connection = psycopg2.connect[
            database=db_name,
            user=db_user,
            password=db_password,
            host=db_host,
            port=db_port,
        ]
        print["Connection to PostgreSQL DB successful"]
    except OperationalError as e:
        print[f"The error '{e}' occurred"]
    return connection

Hilangkan iklan

MySQL

Anda akan menggunakan modul

$ pip install psycopg2

_1 Python SQL untuk membuat tabel di MySQL. Sama seperti dengan SQLite, Anda harus meneruskan kueri Anda ke

import psycopg2
from psycopg2 import OperationalError

def create_connection[db_name, db_user, db_password, db_host, db_port]:
    connection = None
    try:
        connection = psycopg2.connect[
            database=db_name,
            user=db_user,
            password=db_password,
            host=db_host,
            port=db_port,
        ]
        print["Connection to PostgreSQL DB successful"]
    except OperationalError as e:
        print[f"The error '{e}' occurred"]
    return connection

4, yang dikembalikan dengan memanggil

connection = create_connection["E:\\sm_app.sqlite"]

53 pada objek

connection = create_connection["localhost", "root", "", "sm_app"]

7. Anda dapat membuat fungsi lain

connection = create_connection["E:\\sm_app.sqlite"]

_26 yang menerima

connection = create_connection["localhost", "root", "", "sm_app"]

7 dan

import psycopg2
from psycopg2 import OperationalError

def create_connection[db_name, db_user, db_password, db_host, db_port]:
    connection = None
    try:
        connection = psycopg2.connect[
            database=db_name,
            user=db_user,
            password=db_password,
            host=db_host,
            port=db_port,
        ]
        print["Connection to PostgreSQL DB successful"]
    except OperationalError as e:
        print[f"The error '{e}' occurred"]
    return connection

1 string

connection = create_connection["E:\\sm_app.sqlite"]

Di baris 4, Anda meneruskan

import psycopg2
from psycopg2 import OperationalError

def create_connection[db_name, db_user, db_password, db_host, db_port]:
    connection = None
    try:
        connection = psycopg2.connect[
            database=db_name,
            user=db_user,
            password=db_password,
            host=db_host,
            port=db_port,
        ]
        print["Connection to PostgreSQL DB successful"]
    except OperationalError as e:
        print[f"The error '{e}' occurred"]
    return connection

1 ke

import psycopg2
from psycopg2 import OperationalError

def create_connection[db_name, db_user, db_password, db_host, db_port]:
    connection = None
    try:
        connection = psycopg2.connect[
            database=db_name,
            user=db_user,
            password=db_password,
            host=db_host,
            port=db_port,
        ]
        print["Connection to PostgreSQL DB successful"]
    except OperationalError as e:
        print[f"The error '{e}' occurred"]
    return connection

Sekarang Anda dapat membuat tabel

create_database_query = "CREATE DATABASE sm_app"
create_database[connection, create_database_query]

_5 menggunakan fungsi ini

$ pip install mysql-connector-python

Kueri untuk mengimplementasikan relasi kunci asing sedikit berbeda di MySQL dibandingkan dengan SQLite. Terlebih lagi, MySQL menggunakan kata kunci

connection = create_connection["E:\\sm_app.sqlite"]

_61 [dibandingkan dengan kata kunci

connection = create_connection["E:\\sm_app.sqlite"]

62 SQLite] untuk membuat kolom di mana nilainya bertambah secara otomatis saat catatan baru dimasukkan

Skrip berikut membuat tabel

create_database_query = "CREATE DATABASE sm_app"
create_database[connection, create_database_query]

6, yang berisi kunci asing

connection = create_connection["E:\\sm_app.sqlite"]

43 yang mereferensikan kolom

connection = create_connection["E:\\sm_app.sqlite"]

32 dari tabel

create_database_query = "CREATE DATABASE sm_app"
create_database[connection, create_database_query]

$ pip install mysql-connector-python

Demikian pula, untuk membuat tabel

create_database_query = "CREATE DATABASE sm_app"
create_database[connection, create_database_query]

7 dan

create_database_query = "CREATE DATABASE sm_app"
create_database[connection, create_database_query]

8, Anda dapat meneruskan kueri

connection = create_connection["E:\\sm_app.sqlite"]

69 yang sesuai ke

connection = create_connection["E:\\sm_app.sqlite"]

PostgreSQL

Seperti database SQLite dan MySQL, objek

connection = create_connection["localhost", "root", "", "sm_app"]

7 yang dikembalikan oleh

connection = create_connection["E:\\sm_app.sqlite"]

08 berisi objek

import psycopg2
from psycopg2 import OperationalError

def create_connection[db_name, db_user, db_password, db_host, db_port]:
    connection = None
    try:
        connection = psycopg2.connect[
            database=db_name,
            user=db_user,
            password=db_password,
            host=db_host,
            port=db_port,
        ]
        print["Connection to PostgreSQL DB successful"]
    except OperationalError as e:
        print[f"The error '{e}' occurred"]
    return connection

2. Anda dapat menggunakan

import psycopg2
from psycopg2 import OperationalError

def create_connection[db_name, db_user, db_password, db_host, db_port]:
    connection = None
    try:
        connection = psycopg2.connect[
            database=db_name,
            user=db_user,
            password=db_password,
            host=db_host,
            port=db_port,
        ]
        print["Connection to PostgreSQL DB successful"]
    except OperationalError as e:
        print[f"The error '{e}' occurred"]
    return connection

_4 untuk mengeksekusi kueri Python SQL pada database PostgreSQL Anda

Tentukan fungsi ________26______26

$ pip install mysql-connector-python

Anda dapat menggunakan fungsi ini untuk membuat tabel, menyisipkan record, memodifikasi record, dan menghapus record di database PostgreSQL Anda

Sekarang buat tabel

create_database_query = "CREATE DATABASE sm_app"
create_database[connection, create_database_query]

5 di dalam database

import psycopg2
from psycopg2 import OperationalError

def create_connection[db_name, db_user, db_password, db_host, db_port]:
    connection = None
    try:
        connection = psycopg2.connect[
            database=db_name,
            user=db_user,
            password=db_password,
            host=db_host,
            port=db_port,
        ]
        print["Connection to PostgreSQL DB successful"]
    except OperationalError as e:
        print[f"The error '{e}' occurred"]
    return connection

$ pip install mysql-connector-python

Anda dapat melihat bahwa kueri untuk membuat tabel

create_database_query = "CREATE DATABASE sm_app"
create_database[connection, create_database_query]

5 di PostgreSQL sedikit berbeda dari SQLite dan MySQL. Di sini, kata kunci

connection = create_connection["E:\\sm_app.sqlite"]

_79 digunakan untuk membuat kolom yang bertambah secara otomatis. Ingatlah bahwa MySQL menggunakan kata kunci ________26______61

Selain itu, referensi kunci asing juga ditentukan secara berbeda, seperti yang ditunjukkan pada skrip berikut yang membuat tabel

create_database_query = "CREATE DATABASE sm_app"
create_database[connection, create_database_query]

$ pip install mysql-connector-python

Untuk membuat tabel

create_database_query = "CREATE DATABASE sm_app"
create_database[connection, create_database_query]

_7, Anda harus menulis kueri

connection = create_connection["E:\\sm_app.sqlite"]

69 untuk tabel

create_database_query = "CREATE DATABASE sm_app"
create_database[connection, create_database_query]

7 dan meneruskannya ke

connection = create_connection["E:\\sm_app.sqlite"]

26. Proses pembuatan tabel

create_database_query = "CREATE DATABASE sm_app"
create_database[connection, create_database_query]

_8 adalah sama. Anda hanya perlu memodifikasi kueri

connection = create_connection["E:\\sm_app.sqlite"]

69 untuk membuat tabel

create_database_query = "CREATE DATABASE sm_app"
create_database[connection, create_database_query]

8 alih-alih tabel

create_database_query = "CREATE DATABASE sm_app"
create_database[connection, create_database_query]

Hilangkan iklan

Memasukkan Catatan

Di bagian sebelumnya, Anda melihat cara membuat tabel di database SQLite, MySQL, dan PostgreSQL dengan menggunakan modul Python SQL yang berbeda. Di bagian ini, Anda akan melihat cara menyisipkan record ke dalam tabel Anda

SQLite

Untuk menyisipkan record ke dalam database SQLite, Anda dapat menggunakan fungsi

connection = create_connection["E:\\sm_app.sqlite"]

26 yang sama dengan yang Anda gunakan untuk membuat tabel. Pertama, Anda harus menyimpan kueri

connection = create_connection["E:\\sm_app.sqlite"]

_91 Anda dalam sebuah string. Kemudian, Anda dapat meneruskan objek

connection = create_connection["localhost", "root", "", "sm_app"]

_7 dan string

import psycopg2
from psycopg2 import OperationalError

def create_connection[db_name, db_user, db_password, db_host, db_port]:
    connection = None
    try:
        connection = psycopg2.connect[
            database=db_name,
            user=db_user,
            password=db_password,
            host=db_host,
            port=db_port,
        ]
        print["Connection to PostgreSQL DB successful"]
    except OperationalError as e:
        print[f"The error '{e}' occurred"]
    return connection

1 ke

connection = create_connection["E:\\sm_app.sqlite"]

26. Mari masukkan lima catatan ke dalam tabel

create_database_query = "CREATE DATABASE sm_app"
create_database[connection, create_database_query]

$ pip install mysql-connector-python

Karena Anda menyetel kolom

connection = create_connection["E:\\sm_app.sqlite"]

32 ke penambahan otomatis, Anda tidak perlu menentukan nilai kolom

connection = create_connection["E:\\sm_app.sqlite"]

32 untuk

create_database_query = "CREATE DATABASE sm_app"
create_database[connection, create_database_query]

5 ini. Tabel

create_database_query = "CREATE DATABASE sm_app"
create_database[connection, create_database_query]

5 akan secara otomatis mengisi kelima rekaman ini dengan

connection = create_connection["E:\\sm_app.sqlite"]

32 nilai dari

$ pip install mysql-connector-python

01 hingga

$ pip install mysql-connector-python

Sekarang masukkan enam catatan ke dalam tabel

create_database_query = "CREATE DATABASE sm_app"
create_database[connection, create_database_query]

$ pip install mysql-connector-python

Penting untuk disebutkan bahwa kolom

connection = create_connection["E:\\sm_app.sqlite"]

_43 dari tabel

create_database_query = "CREATE DATABASE sm_app"
create_database[connection, create_database_query]

6 adalah kunci asing yang mereferensikan kolom

connection = create_connection["E:\\sm_app.sqlite"]

32 dari tabel

create_database_query = "CREATE DATABASE sm_app"
create_database[connection, create_database_query]

5. Ini berarti kolom

connection = create_connection["E:\\sm_app.sqlite"]

_43 harus berisi nilai yang sudah ada di kolom

connection = create_connection["E:\\sm_app.sqlite"]

32 dari tabel

create_database_query = "CREATE DATABASE sm_app"
create_database[connection, create_database_query]

5. Jika tidak ada, maka Anda akan melihat kesalahan

Demikian pula, skrip berikut menyisipkan catatan ke dalam tabel

create_database_query = "CREATE DATABASE sm_app"
create_database[connection, create_database_query]

7 dan

create_database_query = "CREATE DATABASE sm_app"
create_database[connection, create_database_query]

$ pip install mysql-connector-python

Dalam kedua kasus tersebut, Anda menyimpan kueri

connection = create_connection["E:\\sm_app.sqlite"]

_91 Anda sebagai string dan menjalankannya dengan

connection = create_connection["E:\\sm_app.sqlite"]

MySQL

Ada dua cara untuk memasukkan record ke dalam database MySQL dari aplikasi Python. Pendekatan pertama mirip dengan SQLite. Anda dapat menyimpan kueri

connection = create_connection["E:\\sm_app.sqlite"]

_91 dalam sebuah string dan kemudian menggunakan

import psycopg2
from psycopg2 import OperationalError

def create_connection[db_name, db_user, db_password, db_host, db_port]:
    connection = None
    try:
        connection = psycopg2.connect[
            database=db_name,
            user=db_user,
            password=db_password,
            host=db_host,
            port=db_port,
        ]
        print["Connection to PostgreSQL DB successful"]
    except OperationalError as e:
        print[f"The error '{e}' occurred"]
    return connection

4 untuk menyisipkan catatan

Sebelumnya, Anda menentukan fungsi pembungkus ________26______26 yang Anda gunakan untuk menyisipkan catatan. Anda dapat menggunakan fungsi yang sama sekarang untuk memasukkan record ke dalam tabel MySQL Anda. Skrip berikut menyisipkan catatan ke dalam tabel

create_database_query = "CREATE DATABASE sm_app"
create_database[connection, create_database_query]

5 menggunakan

connection = create_connection["E:\\sm_app.sqlite"]

$ pip install mysql-connector-python

Pendekatan kedua menggunakan

$ pip install mysql-connector-python

_20, yang menerima dua parameter

String kueri yang berisi placeholder untuk rekaman yang akan disisipkan
Daftar rekaman yang ingin Anda sisipkan

Lihat contoh berikut, yang menyisipkan dua record ke dalam tabel

create_database_query = "CREATE DATABASE sm_app"
create_database[connection, create_database_query]

$ pip install mysql-connector-python

Terserah Anda pendekatan mana yang Anda pilih untuk memasukkan catatan ke dalam tabel MySQL Anda. Jika Anda ahli dalam SQL, maka Anda dapat menggunakan

connection = create_connection["E:\\sm_app.sqlite"]

29. Jika Anda tidak terlalu paham dengan SQL, mungkin lebih mudah bagi Anda untuk menggunakan

$ pip install mysql-connector-python

23. Dengan salah satu dari dua pendekatan tersebut, Anda dapat berhasil memasukkan rekaman ke dalam tabel

create_database_query = "CREATE DATABASE sm_app"
create_database[connection, create_database_query]

create_database_query = "CREATE DATABASE sm_app"
create_database[connection, create_database_query]

7, dan

create_database_query = "CREATE DATABASE sm_app"
create_database[connection, create_database_query]

Hilangkan iklan

PostgreSQL

Di bagian sebelumnya, Anda melihat dua pendekatan untuk menyisipkan record ke dalam tabel database SQLite. Yang pertama menggunakan kueri string SQL, dan yang kedua menggunakan

$ pip install mysql-connector-python

23.

connection = create_connection["E:\\sm_app.sqlite"]

05 mengikuti pendekatan kedua ini, meskipun

connection = create_connection["E:\\sm_app.sqlite"]

29 digunakan untuk menjalankan kueri berbasis placeholder

Anda meneruskan kueri SQL dengan placeholder dan daftar rekaman ke

connection = create_connection["E:\\sm_app.sqlite"]

29. Setiap catatan dalam daftar akan menjadi tupel, di mana nilai tupel sesuai dengan nilai kolom dalam tabel database. Inilah cara Anda memasukkan catatan pengguna ke dalam tabel

create_database_query = "CREATE DATABASE sm_app"
create_database[connection, create_database_query]

5 di database PostgreSQL

 1import mysql.connector
 2from mysql.connector import Error
 3
 4def create_connection[host_name, user_name, user_password]:
 5    connection = None
 6    try:
 7        connection = mysql.connector.connect[
 8            host=host_name,
 9            user=user_name,
10            passwd=user_password
11        ]
12        print["Connection to MySQL DB successful"]
13    except Error as e:
14        print[f"The error '{e}' occurred"]
15
16    return connection
17
18connection = create_connection["localhost", "root", ""]

Skrip di atas membuat daftar

create_database_query = "CREATE DATABASE sm_app"
create_database[connection, create_database_query]

5 yang berisi lima catatan pengguna dalam bentuk tupel. Selanjutnya, Anda membuat string placeholder dengan lima elemen placeholder [

$ pip install mysql-connector-python

33] yang sesuai dengan lima rekaman pengguna. String placeholder digabungkan dengan kueri yang menyisipkan rekaman ke dalam tabel

create_database_query = "CREATE DATABASE sm_app"
create_database[connection, create_database_query]

5. Terakhir, string kueri dan rekaman pengguna diteruskan ke

connection = create_connection["E:\\sm_app.sqlite"]

29. Skrip di atas berhasil menyisipkan lima record ke dalam tabel

create_database_query = "CREATE DATABASE sm_app"
create_database[connection, create_database_query]

Lihat contoh lain penyisipan record ke dalam tabel PostgreSQL. Skrip berikut menyisipkan catatan ke dalam tabel

create_database_query = "CREATE DATABASE sm_app"
create_database[connection, create_database_query]

 1import mysql.connector
 2from mysql.connector import Error
 3
 4def create_connection[host_name, user_name, user_password]:
 5    connection = None
 6    try:
 7        connection = mysql.connector.connect[
 8            host=host_name,
 9            user=user_name,
10            passwd=user_password
11        ]
12        print["Connection to MySQL DB successful"]
13    except Error as e:
14        print[f"The error '{e}' occurred"]
15
16    return connection
17
18connection = create_connection["localhost", "root", ""]

Anda dapat memasukkan catatan ke dalam tabel

create_database_query = "CREATE DATABASE sm_app"
create_database[connection, create_database_query]

_7 dan

create_database_query = "CREATE DATABASE sm_app"
create_database[connection, create_database_query]

8 dengan pendekatan yang sama

Memilih Catatan

Di bagian ini, Anda akan melihat cara memilih record dari tabel database menggunakan berbagai modul Python SQL. Secara khusus, Anda akan melihat cara melakukan kueri

$ pip install mysql-connector-python

40 pada database SQLite, MySQL, dan PostgreSQL Anda

SQLite

Untuk memilih record menggunakan SQLite, Anda dapat kembali menggunakan

import psycopg2
from psycopg2 import OperationalError

def create_connection[db_name, db_user, db_password, db_host, db_port]:
    connection = None
    try:
        connection = psycopg2.connect[
            database=db_name,
            user=db_user,
            password=db_password,
            host=db_host,
            port=db_port,
        ]
        print["Connection to PostgreSQL DB successful"]
    except OperationalError as e:
        print[f"The error '{e}' occurred"]
    return connection

4. Namun, setelah melakukannya, Anda harus menelepon

$ pip install mysql-connector-python

42. Metode ini mengembalikan daftar tupel di mana setiap tupel dipetakan ke baris yang sesuai dalam rekaman yang diambil

Untuk menyederhanakan prosesnya, Anda dapat membuat fungsi

$ pip install mysql-connector-python

 1import mysql.connector
 2from mysql.connector import Error
 3
 4def create_connection[host_name, user_name, user_password]:
 5    connection = None
 6    try:
 7        connection = mysql.connector.connect[
 8            host=host_name,
 9            user=user_name,
10            passwd=user_password
11        ]
12        print["Connection to MySQL DB successful"]
13    except Error as e:
14        print[f"The error '{e}' occurred"]
15
16    return connection
17
18connection = create_connection["localhost", "root", ""]

Fungsi ini menerima objek

connection = create_connection["localhost", "root", "", "sm_app"]

_7 dan kueri

$ pip install mysql-connector-python

40 dan mengembalikan rekaman yang dipilih

$ pip install mysql-connector-python

_40

Mari sekarang pilih semua record dari tabel

create_database_query = "CREATE DATABASE sm_app"
create_database[connection, create_database_query]

 1import mysql.connector
 2from mysql.connector import Error
 3
 4def create_connection[host_name, user_name, user_password]:
 5    connection = None
 6    try:
 7        connection = mysql.connector.connect[
 8            host=host_name,
 9            user=user_name,
10            passwd=user_password
11        ]
12        print["Connection to MySQL DB successful"]
13    except Error as e:
14        print[f"The error '{e}' occurred"]
15
16    return connection
17
18connection = create_connection["localhost", "root", ""]

Dalam skrip di atas, kueri

$ pip install mysql-connector-python

_40 memilih semua pengguna dari tabel

create_database_query = "CREATE DATABASE sm_app"
create_database[connection, create_database_query]

5. Ini diteruskan ke

$ pip install mysql-connector-python

_43, yang mengembalikan semua rekaman dari tabel

create_database_query = "CREATE DATABASE sm_app"
create_database[connection, create_database_query]

5. Rekaman tersebut kemudian dilintasi dan dicetak ke konsol

Catatan. Tidak disarankan untuk menggunakan

$ pip install mysql-connector-python

_52 pada tabel besar karena dapat mengakibatkan sejumlah besar operasi I/O yang meningkatkan lalu lintas jaringan

Output dari kueri di atas terlihat seperti ini

 1import mysql.connector
 2from mysql.connector import Error
 3
 4def create_connection[host_name, user_name, user_password]:
 5    connection = None
 6    try:
 7        connection = mysql.connector.connect[
 8            host=host_name,
 9            user=user_name,
10            passwd=user_password
11        ]
12        print["Connection to MySQL DB successful"]
13    except Error as e:
14        print[f"The error '{e}' occurred"]
15
16    return connection
17
18connection = create_connection["localhost", "root", ""]

Dengan cara yang sama, Anda dapat mengambil semua catatan dari tabel

create_database_query = "CREATE DATABASE sm_app"
create_database[connection, create_database_query]

6 dengan skrip di bawah ini

 1import mysql.connector
 2from mysql.connector import Error
 3
 4def create_connection[host_name, user_name, user_password]:
 5    connection = None
 6    try:
 7        connection = mysql.connector.connect[
 8            host=host_name,
 9            user=user_name,
10            passwd=user_password
11        ]
12        print["Connection to MySQL DB successful"]
13    except Error as e:
14        print[f"The error '{e}' occurred"]
15
16    return connection
17
18connection = create_connection["localhost", "root", ""]

Outputnya terlihat seperti ini

 1import mysql.connector
 2from mysql.connector import Error
 3
 4def create_connection[host_name, user_name, user_password]:
 5    connection = None
 6    try:
 7        connection = mysql.connector.connect[
 8            host=host_name,
 9            user=user_name,
10            passwd=user_password
11        ]
12        print["Connection to MySQL DB successful"]
13    except Error as e:
14        print[f"The error '{e}' occurred"]
15
16    return connection
17
18connection = create_connection["localhost", "root", ""]

Hasilnya menunjukkan semua catatan dalam tabel

create_database_query = "CREATE DATABASE sm_app"
create_database[connection, create_database_query]

$ pip install mysql-connector-python

Anda juga dapat menjalankan kueri kompleks yang melibatkan

$ pip install mysql-connector-python

55 operasi untuk mengambil data dari dua tabel terkait. Misalnya, skrip berikut mengembalikan id dan nama pengguna, bersama dengan deskripsi postingan yang diposting pengguna tersebut

 1import mysql.connector
 2from mysql.connector import Error
 3
 4def create_connection[host_name, user_name, user_password]:
 5    connection = None
 6    try:
 7        connection = mysql.connector.connect[
 8            host=host_name,
 9            user=user_name,
10            passwd=user_password
11        ]
12        print["Connection to MySQL DB successful"]
13    except Error as e:
14        print[f"The error '{e}' occurred"]
15
16    return connection
17
18connection = create_connection["localhost", "root", ""]

Inilah hasilnya

 1import mysql.connector
 2from mysql.connector import Error
 3
 4def create_connection[host_name, user_name, user_password]:
 5    connection = None
 6    try:
 7        connection = mysql.connector.connect[
 8            host=host_name,
 9            user=user_name,
10            passwd=user_password
11        ]
12        print["Connection to MySQL DB successful"]
13    except Error as e:
14        print[f"The error '{e}' occurred"]
15
16    return connection
17
18connection = create_connection["localhost", "root", ""]

Anda juga dapat memilih data dari tiga tabel terkait dengan menerapkan beberapa operator

$ pip install mysql-connector-python

55. Skrip berikut mengembalikan semua posting, bersama dengan komentar pada posting dan nama pengguna yang memposting komentar

 1import mysql.connector
 2from mysql.connector import Error
 3
 4def create_connection[host_name, user_name, user_password]:
 5    connection = None
 6    try:
 7        connection = mysql.connector.connect[
 8            host=host_name,
 9            user=user_name,
10            passwd=user_password
11        ]
12        print["Connection to MySQL DB successful"]
13    except Error as e:
14        print[f"The error '{e}' occurred"]
15
16    return connection
17
18connection = create_connection["localhost", "root", ""]

Outputnya terlihat seperti ini

def create_database[connection, query]:
    cursor = connection.cursor[]
    try:
        cursor.execute[query]
        print["Database created successfully"]
    except Error as e:
        print[f"The error '{e}' occurred"]

Anda dapat melihat dari keluaran bahwa nama kolom tidak dikembalikan oleh

$ pip install mysql-connector-python

42. Untuk mengembalikan nama kolom, Anda dapat menggunakan atribut

$ pip install mysql-connector-python

59 dari objek

import psycopg2
from psycopg2 import OperationalError

def create_connection[db_name, db_user, db_password, db_host, db_port]:
    connection = None
    try:
        connection = psycopg2.connect[
            database=db_name,
            user=db_user,
            password=db_password,
            host=db_host,
            port=db_port,
        ]
        print["Connection to PostgreSQL DB successful"]
    except OperationalError as e:
        print[f"The error '{e}' occurred"]
    return connection

2. Misalnya, daftar berikut mengembalikan semua nama kolom untuk kueri di atas

def create_database[connection, query]:
    cursor = connection.cursor[]
    try:
        cursor.execute[query]
        print["Database created successfully"]
    except Error as e:
        print[f"The error '{e}' occurred"]

Outputnya terlihat seperti ini

def create_database[connection, query]:
    cursor = connection.cursor[]
    try:
        cursor.execute[query]
        print["Database created successfully"]
    except Error as e:
        print[f"The error '{e}' occurred"]

Anda dapat melihat nama kolom untuk kueri yang diberikan

$ pip install mysql-connector-python

_61

Sekarang Anda akan menjalankan kueri

$ pip install mysql-connector-python

_40 yang mengembalikan kiriman, bersama dengan jumlah total suka yang diterima kiriman

def create_database[connection, query]:
    cursor = connection.cursor[]
    try:
        cursor.execute[query]
        print["Database created successfully"]
    except Error as e:
        print[f"The error '{e}' occurred"]

Outputnya adalah sebagai berikut

def create_database[connection, query]:
    cursor = connection.cursor[]
    try:
        cursor.execute[query]
        print["Database created successfully"]
    except Error as e:
        print[f"The error '{e}' occurred"]

Dengan menggunakan klausa

$ pip install mysql-connector-python

_61, Anda dapat mengembalikan hasil yang lebih spesifik

Hilangkan iklan

MySQL

Proses pemilihan catatan di MySQL benar-benar identik dengan pemilihan catatan di SQLite. Anda dapat menggunakan

import psycopg2
from psycopg2 import OperationalError

def create_connection[db_name, db_user, db_password, db_host, db_port]:
    connection = None
    try:
        connection = psycopg2.connect[
            database=db_name,
            user=db_user,
            password=db_password,
            host=db_host,
            port=db_port,
        ]
        print["Connection to PostgreSQL DB successful"]
    except OperationalError as e:
        print[f"The error '{e}' occurred"]
    return connection

_4 diikuti oleh

$ pip install mysql-connector-python

42. Skrip berikut membuat fungsi pembungkus

$ pip install mysql-connector-python

43 yang dapat Anda gunakan untuk memilih record

 1import mysql.connector
 2from mysql.connector import Error
 3
 4def create_connection[host_name, user_name, user_password]:
 5    connection = None
 6    try:
 7        connection = mysql.connector.connect[
 8            host=host_name,
 9            user=user_name,
10            passwd=user_password
11        ]
12        print["Connection to MySQL DB successful"]
13    except Error as e:
14        print[f"The error '{e}' occurred"]
15
16    return connection
17
18connection = create_connection["localhost", "root", ""]

Sekarang pilih semua rekaman dari tabel

create_database_query = "CREATE DATABASE sm_app"
create_database[connection, create_database_query]

def create_database[connection, query]:
    cursor = connection.cursor[]
    try:
        cursor.execute[query]
        print["Database created successfully"]
    except Error as e:
        print[f"The error '{e}' occurred"]

Outputnya akan mirip dengan apa yang Anda lihat dengan SQLite

PostgreSQL

Proses pemilihan catatan dari tabel PostgreSQL dengan modul

connection = create_connection["E:\\sm_app.sqlite"]

05 Python SQL mirip dengan apa yang Anda lakukan dengan SQLite dan MySQL. Sekali lagi, Anda akan menggunakan

import psycopg2
from psycopg2 import OperationalError

def create_connection[db_name, db_user, db_password, db_host, db_port]:
    connection = None
    try:
        connection = psycopg2.connect[
            database=db_name,
            user=db_user,
            password=db_password,
            host=db_host,
            port=db_port,
        ]
        print["Connection to PostgreSQL DB successful"]
    except OperationalError as e:
        print[f"The error '{e}' occurred"]
    return connection

_4 diikuti oleh

$ pip install mysql-connector-python

42 untuk memilih catatan dari tabel PostgreSQL Anda. Skrip berikut memilih semua rekaman dari tabel

create_database_query = "CREATE DATABASE sm_app"
create_database[connection, create_database_query]

5 dan mencetaknya ke konsol

def create_database[connection, query]:
    cursor = connection.cursor[]
    try:
        cursor.execute[query]
        print["Database created successfully"]
    except Error as e:
        print[f"The error '{e}' occurred"]

Sekali lagi, hasilnya akan mirip dengan yang Anda lihat sebelumnya

Memperbarui Catatan Tabel

Di bagian terakhir, Anda melihat cara memilih record dari database SQLite, MySQL, dan PostgreSQL. Di bagian ini, Anda akan membahas proses memperbarui record menggunakan library Python SQL untuk SQLite, PostgresSQL, dan MySQL

SQLite

Memperbarui catatan di SQLite cukup mudah. Anda dapat kembali menggunakan

connection = create_connection["E:\\sm_app.sqlite"]

26. Sebagai contoh, Anda dapat memperbarui deskripsi postingan dengan

connection = create_connection["E:\\sm_app.sqlite"]

32 dari

$ pip install mysql-connector-python

74. Pertama,

$ pip install mysql-connector-python

_40 deskripsi posting ini

def create_database[connection, query]:
    cursor = connection.cursor[]
    try:
        cursor.execute[query]
        print["Database created successfully"]
    except Error as e:
        print[f"The error '{e}' occurred"]

Anda akan melihat output berikut

def create_database[connection, query]:
    cursor = connection.cursor[]
    try:
        cursor.execute[query]
        print["Database created successfully"]
    except Error as e:
        print[f"The error '{e}' occurred"]

Skrip berikut memperbarui deskripsi

create_database_query = "CREATE DATABASE sm_app"
create_database[connection, create_database_query]

Sekarang, jika Anda menjalankan kueri

$ pip install mysql-connector-python

_40 lagi, Anda akan melihat hasil berikut

create_database_query = "CREATE DATABASE sm_app"
create_database[connection, create_database_query]

Keluaran telah diperbarui

Hilangkan iklan

MySQL

Proses pemutakhiran catatan di MySQL dengan

$ pip install psycopg2

1 juga merupakan salinan dari modul

 1def create_connection[host_name, user_name, user_password, db_name]:
 2    connection = None
 3    try:
 4        connection = mysql.connector.connect[
 5            host=host_name,
 6            user=user_name,
 7            passwd=user_password,
 8            database=db_name
 9        ]
10        print["Connection to MySQL DB successful"]
11    except Error as e:
12        print[f"The error '{e}' occurred"]
13
14    return connection

8 Python SQL. Anda harus meneruskan kueri string ke

import psycopg2
from psycopg2 import OperationalError

def create_connection[db_name, db_user, db_password, db_host, db_port]:
    connection = None
    try:
        connection = psycopg2.connect[
            database=db_name,
            user=db_user,
            password=db_password,
            host=db_host,
            port=db_port,
        ]
        print["Connection to PostgreSQL DB successful"]
    except OperationalError as e:
        print[f"The error '{e}' occurred"]
    return connection

4. Misalnya, skrip berikut memperbarui deskripsi postingan dengan

connection = create_connection["E:\\sm_app.sqlite"]

32 dari

$ pip install mysql-connector-python

create_database_query = "CREATE DATABASE sm_app"
create_database[connection, create_database_query]

Sekali lagi, Anda telah menggunakan fungsi pembungkus Anda

connection = create_connection["E:\\sm_app.sqlite"]

26 untuk memperbarui deskripsi posting

PostgreSQL

Kueri pembaruan untuk PostgreSQL serupa dengan yang Anda lihat dengan SQLite dan MySQL. Anda dapat menggunakan skrip di atas untuk memperbarui catatan di tabel PostgreSQL Anda

Menghapus Rekaman Tabel

Di bagian ini, Anda akan melihat cara menghapus record tabel menggunakan modul Python SQL untuk database SQLite, MySQL, dan PostgreSQL. Proses penghapusan record seragam untuk ketiga database karena kueri ________30______83 untuk ketiga database adalah sama

SQLite

Anda dapat kembali menggunakan

connection = create_connection["E:\\sm_app.sqlite"]

26 untuk menghapus record dari database SQLite ANDA. Yang harus Anda lakukan adalah meneruskan objek

connection = create_connection["localhost", "root", "", "sm_app"]

_7 dan kueri string untuk catatan yang ingin Anda hapus ke

connection = create_connection["E:\\sm_app.sqlite"]

26. Kemudian,

connection = create_connection["E:\\sm_app.sqlite"]

_26 akan membuat objek

import psycopg2
from psycopg2 import OperationalError

def create_connection[db_name, db_user, db_password, db_host, db_port]:
    connection = None
    try:
        connection = psycopg2.connect[
            database=db_name,
            user=db_user,
            password=db_password,
            host=db_host,
            port=db_port,
        ]
        print["Connection to PostgreSQL DB successful"]
    except OperationalError as e:
        print[f"The error '{e}' occurred"]
    return connection

2 menggunakan

connection = create_connection["localhost", "root", "", "sm_app"]

7 dan meneruskan kueri string ke

import psycopg2
from psycopg2 import OperationalError

def create_connection[db_name, db_user, db_password, db_host, db_port]:
    connection = None
    try:
        connection = psycopg2.connect[
            database=db_name,
            user=db_user,
            password=db_password,
            host=db_host,
            port=db_port,
        ]
        print["Connection to PostgreSQL DB successful"]
    except OperationalError as e:
        print[f"The error '{e}' occurred"]
    return connection

4, yang akan menghapus catatan

Sebagai contoh, coba hapus komentar dengan

connection = create_connection["E:\\sm_app.sqlite"]

32 dari

$ pip install mysql-connector-python

create_database_query = "CREATE DATABASE sm_app"
create_database[connection, create_database_query]

Sekarang, jika Anda memilih semua catatan dari tabel

create_database_query = "CREATE DATABASE sm_app"
create_database[connection, create_database_query]

7, Anda akan melihat bahwa komentar kelima telah dihapus

MySQL

Proses penghapusan di MySQL juga mirip dengan SQLite, seperti yang ditunjukkan pada contoh berikut

create_database_query = "CREATE DATABASE sm_app"
create_database[connection, create_database_query]

Di sini, Anda menghapus komentar kedua dari tabel

import psycopg2
from psycopg2 import OperationalError

def create_connection[db_name, db_user, db_password, db_host, db_port]:
    connection = None
    try:
        connection = psycopg2.connect[
            database=db_name,
            user=db_user,
            password=db_password,
            host=db_host,
            port=db_port,
        ]
        print["Connection to PostgreSQL DB successful"]
    except OperationalError as e:
        print[f"The error '{e}' occurred"]
    return connection

5 database

create_database_query = "CREATE DATABASE sm_app"
create_database[connection, create_database_query]

7 di server database MySQL Anda

PostgreSQL

Permintaan penghapusan untuk PostgreSQL juga mirip dengan SQLite dan MySQL. Anda dapat menulis string kueri penghapusan dengan menggunakan kata kunci

$ pip install mysql-connector-python

83 lalu meneruskan kueri dan objek

connection = create_connection["localhost", "root", "", "sm_app"]

7 ke

connection = create_connection["E:\\sm_app.sqlite"]

26. Ini akan menghapus catatan yang ditentukan dari database PostgreSQL Anda

Kesimpulan

Dalam tutorial ini, Anda telah mempelajari cara menggunakan tiga pustaka umum Python SQL.

 1def create_connection[host_name, user_name, user_password, db_name]:
 2    connection = None
 3    try:
 4        connection = mysql.connector.connect[
 5            host=host_name,
 6            user=user_name,
 7            passwd=user_password,
 8            database=db_name
 9        ]
10        print["Connection to MySQL DB successful"]
11    except Error as e:
12        print[f"The error '{e}' occurred"]
13
14    return connection

$ pip install psycopg2

1, dan

connection = create_connection["E:\\sm_app.sqlite"]

05 memungkinkan Anda menghubungkan aplikasi Python ke database SQLite, MySQL, dan PostgreSQL, masing-masing

Sekarang kamu bisa

Berinteraksi dengan database SQLite, MySQL, atau PostgreSQL
Gunakan tiga modul Python SQL yang berbeda
Jalankan query SQL pada berbagai database dari dalam aplikasi Python

Namun, ini hanyalah puncak gunung es. Ada juga pustaka Python SQL untuk pemetaan objek-relasional, seperti SQLAlchemy dan Django ORM, yang mengotomatiskan tugas interaksi basis data dengan Python. Anda akan mempelajari lebih lanjut tentang pustaka ini di tutorial lain di bagian basis data Python kami

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

Kirimi Saya Trik Python »

Tentang Usman Malik

Usman adalah seorang Pythonista yang rajin dan menulis untuk Real Python

» Lebih lanjut tentang Usman

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

Aldren

Geir Arne

Jaya

Joanna

Mike

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 menurut anda?

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 cara menghubungkan dari Python ke SQL Server?

Metode ini mengandalkan pustaka “pyodbc” untuk menyiapkan Integrasi SQL Server Python. .

Langkah 1. Tetapkan Koneksi SQL Server Python. .

Langkah 2. Jalankan Kueri SQL. .

Langkah 3. Ekstrak Hasil Kueri ke Python. .

Langkah 4. Terapkan Modifikasi di SQL Server. .

Langkah 5. Mengotomatiskan Fungsi Python SQL Server

Bagaimana cara membuat API untuk database SQL Server dengan Python?

Lengkapi semua prasyarat yang disebutkan dalam artikel ini. Instal Microsoft ODBC Driver untuk SQL Server di Windows. .

Buat folder proyek

Instal paket yang diperlukan

Terapkan REST API

Uji API

Bagaimana cara mentransfer data dari Python ke SQL?

Langkah Mengimpor file CSV ke SQL Server menggunakan Python .

Langkah 1. Siapkan File CSV. .

Langkah 2. Impor File CSV ke DataFrame. .

Langkah 3. Hubungkan Python ke SQL Server. .

Langkah 4. Buat Tabel di SQL Server menggunakan Python. .

Langkah 5. Masukkan Data DataFrame ke dalam Tabel. .

Langkah 6. Lakukan Tes

Bagaimana cara menyimpan data API di database Python?

Dalam artikel ini, kami akan berfokus pada Cara Menarik data dari API dengan Python. Jadi, mari kita mulai. .

Hubungkan ke API. .

Dapatkan data dari API. .

Parsing data ke dalam format JSON. .

Ekstrak data dan cetak

Memahami Skema Database

Menggunakan Pustaka Python SQL untuk Menghubungkan ke Basis Data

SQLite

MySQL

PostgreSQL

Membuat Tabel

SQLite

MySQL

PostgreSQL

Memasukkan Catatan

SQLite

MySQL

PostgreSQL

Memilih Catatan

SQLite

$ pip install mysql-connector-python _40

$ pip install mysql-connector-python 55

$ pip install mysql-connector-python _61

MySQL

PostgreSQL

Memperbarui Catatan Tabel

SQLite

MySQL

PostgreSQL

Menghapus Rekaman Tabel

SQLite

MySQL

PostgreSQL

Kesimpulan

Bagaimana cara menghubungkan dari Python ke SQL Server?

Bagaimana cara membuat API untuk database SQL Server dengan Python?

Bagaimana cara mentransfer data dari Python ke SQL?

Bagaimana cara menyimpan data API di database Python?

Bài Viết Liên Quan

Toplist mới

Bài mới nhất

Chủ Đề

`$ pip install mysql-connector-python`
_40

`$ pip install mysql-connector-python`
55

`$ pip install mysql-connector-python`
_61