Pandas & NumPy Academy · Pelajaran

Menyambung ke Pangkalan Data dengan SQLAlchemy

Cipta enjin SQLAlchemy untuk SQLite dan PostgreSQL, kemudian hantarkannya kepada pd.read_sql untuk memuatkan jadual ke dalam DataFrame.

Pelajaran 1 daripada 413 langkah

Menyambung ke Pangkalan Data dengan SQLAlchemy ialah pelajaran Pandas & NumPy Academy percuma di CoddyKit. Ini ialah pelajaran 1 daripada 4. Anda boleh membaca keseluruhan pelajaran di bawah secara percuma — kemudian berlatih secara praktikal dalam pelayar menggunakan penyunting kod terbina dalam dan tutor kecerdasan buatan 24/7. Pelajaran ini merupakan sebahagian daripada laluan pembelajaran Pandas & NumPy Academy, dan kemajuan anda disegerakkan merentas web serta aplikasi CoddyKit. Kursus Pandas & NumPy Academy merangkumi sejumlah 4 pelajaran.

Mengapa Menyambungkan Pandas kepada Pangkalan Data?

Kebanyakan data pengeluaran disimpan dalam pangkalan data hubungan — PostgreSQL, MySQL, SQLite atau SQL Server — bukannya fail CSV. Menyambungkan Pandas terus kepada pangkalan data membolehkan anda membuat pertanyaan data ke dalam DataFrame tanpa mengeksportnya ke CSV terlebih dahulu, menghantar DataFrame yang telah dibersihkan kembali ke dalam jadual, serta menggabungkan keupayaan analisis Python dengan keupayaan pengindeksan dan penyambungan pangkalan data. Penghubung antara Pandas dengan pangkalan data ialah SQLAlchemy, iaitu pustaka abstraksi pangkalan data standard Python.

Memasang SQLAlchemy

SQLAlchemy ialah kit alat SQL dan ORM untuk Python. Untuk penyepaduan dengan Pandas, anda hanya memerlukan lapisan Core — bukan ORM. Pasang dengan pip install sqlalchemy. Anda juga memerlukan pemacu pangkalan data khusus: psycopg2 untuk PostgreSQL, pymysql untuk MySQL atau sqlite3 (terbina dalam Python) untuk SQLite. SQLAlchemy bertindak sebagai lapisan abstraksi: kod Pandas yang sama boleh digunakan dengan mana-mana pangkalan data yang disokong dengan hanya menukar rentetan sambungan.

# Install dependencies
# pip install sqlalchemy psycopg2-binary  # for PostgreSQL
# pip install sqlalchemy pymysql           # for MySQL
# sqlite3 is built into Python

import sqlalchemy as sa
import pandas as pd

print('SQLAlchemy version:', sa.__version__)

Mencipta Enjin Sambungan

Langkah pertama ialah mencipta enjin SQLAlchemy menggunakan URL sambungan yang mengandungi jenis pangkalan data, kelayakan, hos, port dan nama pangkalan data. Enjin ialah kilang untuk sambungan pangkalan data — ia tidak membuka sambungan sehingga sambungan itu benar-benar diperlukan. Hantar enjin tersebut kepada fungsi Pandas pd.read_sql() dan df.to_sql(). Jangan sekali-kali menulis kelayakan secara terus dalam kod; baca kelayakan itu daripada pemboleh ubah persekitaran atau pengurus rahsia.

import sqlalchemy as sa
import os

# SQLite (file-based, no server needed)
sqlite_engine = sa.create_engine('sqlite:///mydata.db')

# PostgreSQL
# pg_url = 'postgresql://user:pass@localhost:5432/mydb'
# pg_engine = sa.create_engine(pg_url)

# From environment variable (safer)
# pg_engine = sa.create_engine(os.environ['DATABASE_URL'])

print(sqlite_engine)
print(type(sqlite_engine))

Membaca Jadual dengan pd.read_sql_table()

pd.read_sql_table('table_name', con=engine) membaca keseluruhan jadual pangkalan data ke dalam DataFrame. Fungsi ini menentukan jenis data lajur secara automatik berdasarkan skema pangkalan data — integer kekal sebagai integer, cap masa sebagai datetime dan sebagainya. Kaedah ini lebih tepat berbanding penentuan jenis data CSV. Anda juga boleh mengehadkan lajur dengan argumen columns dan menapis baris dengan schema untuk skema pangkalan data bukan lalai. Berhati-hati dengan jadual yang sangat besar kerana semua data akan dimuatkan ke dalam RAM.

import pandas as pd
import sqlalchemy as sa

engine = sa.create_engine('sqlite:///sales.db')

# Read a full table
df = pd.read_sql_table('orders', con=engine)
print(df.shape)
print(df.dtypes)
print(df.head())

Menjalankan Pertanyaan dengan pd.read_sql_query()

pd.read_sql_query('SELECT ...', con=engine) melaksanakan pernyataan SQL SELECT sewenang-wenangnya dan mengembalikan hasilnya sebagai DataFrame. Ini ialah pendekatan yang paling fleksibel: anda boleh menapis, menyambungkan dan mengagregatkan data dalam SQL sebelum memuatkannya ke dalam Pandas, supaya hanya baris dan lajur yang diperlukan dimuatkan. Tulis pertanyaan itu sebagai rentetan Python biasa. Jangan sekali-kali menggabungkan input pengguna terus ke dalam pertanyaan — gunakan pertanyaan berparameter untuk mengelakkan suntikan SQL.

import pandas as pd
import sqlalchemy as sa

engine = sa.create_engine('sqlite:///sales.db')

query = '''
    SELECT customer_id, SUM(amount) AS total_spent,
           COUNT(*) AS num_orders
    FROM orders
    WHERE status = 'completed'
    GROUP BY customer_id
    ORDER BY total_spent DESC
    LIMIT 100
'''

top_customers = pd.read_sql_query(query, con=engine)
print(top_customers.head())

Pertanyaan Berparameter untuk Keselamatan

Jangan sekali-kali membina pertanyaan SQL dengan penggabungan rentetan yang mengandungi nilai daripada pengguna kerana hal ini membuka kelemahan suntikan SQL. Sebaliknya, gunakan pertanyaan berparameter: hantar parameter sebagai kamus dengan pemegang tempat bernama. SQLAlchemy mengendalikan pelolosan aksara. Sintaks pemegang tempat ialah :name dalam pertanyaan teks SQLAlchemy atau %(name)s untuk pertanyaan gaya psycopg2. Sentiasa gunakan parameterisasi, termasuk untuk skrip dalaman, bagi membentuk tabiat yang baik.

import pandas as pd
import sqlalchemy as sa

engine = sa.create_engine('sqlite:///sales.db')

# Safe: parameterised query
params = {'status': 'completed', 'min_amount': 500.0}
query = sa.text(
    'SELECT * FROM orders WHERE status = :status AND amount > :min_amount'
)

with engine.connect() as conn:
    df = pd.read_sql_query(query, con=conn, params=params)
print(f'Loaded {len(df)} rows')

Mengendalikan Hasil Pertanyaan Besar Mengikut Kelompok

Untuk hasil pertanyaan yang besar, gunakan chunksize dalam pd.read_sql_query() untuk menerima iterator DataFrame dan bukannya memuatkan semuanya serentak. Ini menyerupai tingkah laku pd.read_csv(chunksize=...), tetapi mengambil baris daripada pangkalan data secara kelompok. Gabungkan kaedah ini dengan corak pengumpul berterusan untuk mengagregatkan hasil daripada pertanyaan berjuta-juta baris tanpa memenuhi RAM.

import pandas as pd
import sqlalchemy as sa

engine = sa.create_engine('postgresql://user:pass@host/db')

total = 0.0
count = 0

for chunk in pd.read_sql_query(
    'SELECT amount FROM orders',
    con=engine,
    chunksize=50000
):
    total += chunk['amount'].sum()
    count += len(chunk)

print(f'Mean amount: {total/count:.2f}')

Pengurus Konteks Sambungan

Sentiasa buka sambungan pangkalan data di dalam pengurus konteks (with engine.connect() as conn:) bagi memastikan sambungan ditutup dengan betul walaupun pengecualian berlaku. Kegagalan menutup sambungan menyebabkan kumpulan sambungan kehabisan kapasiti dalam persekitaran pengeluaran, lalu menyebabkan pertanyaan baharu tergantung sementara menunggu slot yang tersedia. Kumpulan sambungan SQLAlchemy menguruskan bilangan sambungan yang tetap dan mengitar semulanya secara automatik apabila pengurus konteks digunakan.

import pandas as pd
import sqlalchemy as sa

engine = sa.create_engine('sqlite:///sales.db')

# Using context manager — connection always closed properly
with engine.connect() as conn:
    df = pd.read_sql_query(
        'SELECT * FROM products WHERE category = "Electronics"',
        con=conn
    )
    print(f'Products loaded: {len(df)}')
# Connection is automatically returned to the pool here

Memeriksa Skema Pangkalan Data

Sebelum menulis pertanyaan, anda perlu mengetahui jadual dan lajur yang tersedia. Inspector SQLAlchemy membolehkan anda mendapatkan skema pangkalan data tanpa menulis SQL mentah. inspector.get_table_names() menyenaraikan semua jadual; inspector.get_columns('table') mengembalikan nama dan jenis lajur. Ini berguna apabila anda bekerja dengan pangkalan data yang tidak biasa dan lebih kemas berbanding menjalankan PRAGMA table_info() atau \d tablename secara manual.

import sqlalchemy as sa

engine = sa.create_engine('sqlite:///sales.db')
inspector = sa.inspect(engine)

# List all tables
tables = inspector.get_table_names()
print('Tables:', tables)

# Get columns for the 'orders' table
for col in inspector.get_columns('orders'):
    print(f'  {col["name"]}: {col["type"]}')

Menutup Enjin dan Amalan Terbaik

Dalam skrip yang berjalan lama atau aplikasi web, panggil engine.dispose() apabila anda selesai untuk menutup semua sambungan dalam kumpulan. Untuk skrip pendek, pemungut sampah Python mengendalikan pembersihan. Amalan terbaik bagi sambungan pangkalan data dalam aliran data: cipta enjin sekali sahaja di bahagian atas skrip dan gunakannya semula, gunakan tetapan lalai pengumpulan sambungan (pool_size=5), dan dayakan pool_pre_ping=True supaya sambungan disambung semula secara automatik jika pelayan pangkalan data dimulakan semula antara pertanyaan.

import sqlalchemy as sa

# Production-grade engine creation
engine = sa.create_engine(
    'postgresql://user:pass@host:5432/mydb',
    pool_size=5,          # max 5 persistent connections
    max_overflow=10,      # allow 10 temporary extra connections
    pool_pre_ping=True,   # verify connection before use
    connect_args={'connect_timeout': 10}
)

# ... run all your queries ...

# At the end of the application/script
engine.dispose()
print('Engine disposed')

Membandingkan Kelajuan read_sql dengan read_csv

Untuk data yang sudah berada dalam pangkalan data dengan indeks yang betul, pd.read_sql_query dengan pertanyaan yang ditapis selalunya lebih pantas berbanding mengeksport data ke CSV dan membacanya. Pelayan pangkalan data menggunakan penapis sebelum menghantar data, sekali gus mengurangkan pemindahan rangkaian dan beban menghurai. Untuk jadual yang sangat lebar, pangkalan data juga boleh memilih hanya lajur yang diperlukan. Walau bagaimanapun, membaca daripada pangkalan data jauh melalui rangkaian yang perlahan mungkin lebih lambat berbanding membaca fail Parquet setempat — sentiasa ukur kedua-dua pilihan untuk persediaan khusus anda.

import pandas as pd
import sqlalchemy as sa
import time

engine = sa.create_engine('sqlite:///data.db')

# Database read with server-side filter
start = time.time()
df_sql = pd.read_sql_query(
    'SELECT * FROM transactions WHERE amount > 100 AND year = 2024',
    con=engine
)
print(f'SQL read: {time.time()-start:.3f}s, {len(df_sql):,} rows')

Semakan Ringkas

Uji pemahaman anda tentang konsep Analisis Data daripada pelajaran ini.

Jawab dalam pelajaran interaktif

Ulang Kaji Pelajaran

Dalam pelajaran ini, anda telah mempelajari bahawa: sa.create_engine() mencipta kilang sambungan yang boleh digunakan semula daripada rentetan URL, pd.read_sql_query() melaksanakan SQL sewenang-wenangnya dan mengembalikan DataFrame, manakala pertanyaan berparameter dengan sa.text() dan params menghalang kelemahan suntikan SQL. Seterusnya, kita akan melihat cara menjalankan pertanyaan SQL yang lebih kompleks daripada Pandas dan menggabungkan SQL dengan logik Python.

Percuma untuk bermula

Pelajari Python dengan tutor kecerdasan buatan — percuma

Tulis dan jalankan kod sebenar dalam pelayar anda, dapatkan bantuan segera daripada tutor kecerdasan buatan yang tersedia 24/7, dan sambung semula dari tempat anda berhenti di web atau dalam aplikasi.

Kursus: 30
Pelajaran: 120

Mula belajar secara percuma Lihat kursus penuh

Soalan Lazim

Adakah pelajaran “Menyambung ke Pangkalan Data dengan SQLAlchemy” percuma?

Ya — teks penuh “Menyambung ke Pangkalan Data dengan SQLAlchemy” boleh dibaca secara percuma di web ini. Untuk berlatih secara interaktif menggunakan penyunting kod terbina dalam dan tutor kecerdasan buatan 24/7, serta membuka kunci baki kursus Pandas & NumPy Academy, tingkat taraf kepada CoddyKit PRO. Kursus Pandas & NumPy Academy merangkumi sejumlah 4 pelajaran.

Apakah yang akan saya pelajari dalam “Menyambung ke Pangkalan Data dengan SQLAlchemy”?

Cipta enjin SQLAlchemy untuk SQLite dan PostgreSQL, kemudian hantarkannya kepada pd.read_sql untuk memuatkan jadual ke dalam DataFrame. Anda berlatih Pandas & NumPy Academy menggunakan kod praktikal yang dijalankan terus dalam pelayar, manakala tutor kecerdasan buatan 24/7 menjawab soalan anda semasa anda mengikuti pelajaran.

Adakah saya memerlukan pengalaman untuk memulakan Pandas & NumPy Academy?

Tiada pengalaman terdahulu diperlukan. Pembelajaran Pandas & NumPy Academy di CoddyKit disusun untuk pelajar daripada peringkat pemula hingga lanjutan, jadi anda boleh bermula di sini atau dari awal dan belajar mengikut kadar anda sendiri. Ini ialah pelajaran 1 daripada 4.

Berapa lamakah pelajaran “Menyambung ke Pangkalan Data dengan SQLAlchemy” diambil?

Kebanyakan pelajaran CoddyKit mengambil masa kira-kira 5–10 minit. Setiap pelajaran ringkas dan interaktif, jadi anda boleh membuat kemajuan secara berterusan dan menyambung tepat dari tempat anda berhenti di web atau aplikasi.

Bolehkah saya menulis dan menjalankan kod dalam pelajaran Pandas & NumPy Academy ini?

Ya. Setiap pelajaran Pandas & NumPy Academy menyertakan penyunting kod terbina dalam, jadi anda boleh menulis dan menjalankan kod sebenar terus dalam pelayar serta menerima maklum balas kecerdasan buatan serta-merta — tanpa memerlukan persediaan setempat.

Semua pelajaran dalam kursus ini

Menyambung ke Pangkalan Data dengan SQLAlchemy
Menjalankan Pertanyaan SQL daripada Pandas
Menulis DataFrames ke Jadual Pangkalan Data
Pandas berbanding SQL: Memilih Alat yang Tepat

← Kembali ke Pandas & NumPy Academy