การเชื่อมต่อฐานข้อมูลด้วย SQLAlchemy
สร้าง SQLAlchemy engine สำหรับ SQLite และ PostgreSQL แล้วส่งให้ pd.read_sql เพื่อโหลดตารางเป็น DataFrame
การเชื่อมต่อฐานข้อมูลด้วย SQLAlchemy เป็นบทเรียน Pandas & NumPy Academy ฟรีบน CoddyKit นี่คือบทเรียนที่ 1 จากทั้งหมด 4 บทเรียน คุณสามารถอ่านบทเรียนทั้งหมดด้านล่างฟรี — จากนั้นลองปฏิบัติด้วยตัวคุณเองในเบราว์เซอร์พร้อมตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7 บทเรียนนี้เป็นส่วนหนึ่งของเส้นทางการเรียน Pandas & NumPy Academy และความก้าวหน้าของคุณจะซิงค์ข้ามเว็บและแอป CoddyKit คอร์ส Pandas & NumPy Academy มีบทเรียนทั้งหมด 4 บทเรียน
เหตุใดจึงควรเชื่อมต่อ Pandas กับฐานข้อมูล
ข้อมูลส่วนใหญ่ในระบบใช้งานจริงอยู่ในฐานข้อมูลเชิงสัมพันธ์ เช่น PostgreSQL, MySQL, SQLite หรือ SQL Server ไม่ได้อยู่ในไฟล์ CSV การเชื่อมต่อ Pandas กับฐานข้อมูลโดยตรงช่วยให้คุณ ค้นข้อมูลมาไว้ใน DataFrame ได้โดยไม่ต้องส่งออกเป็น CSV ก่อน ส่ง DataFrame ที่ทำความสะอาดแล้วกลับไปยังตาราง และผสานความสามารถด้านการวิเคราะห์ของ Python เข้ากับความสามารถด้านดัชนีและการเชื่อมตารางของฐานข้อมูล ตัวเชื่อมระหว่าง Pandas กับฐานข้อมูลคือ SQLAlchemy ซึ่งเป็นไลบรารีมาตรฐานของ Python สำหรับสร้างชั้นนามธรรมของฐานข้อมูล
การติดตั้ง SQLAlchemy
SQLAlchemy คือชุดเครื่องมือ SQL และ ORM สำหรับ Python สำหรับการใช้งานร่วมกับ Pandas คุณต้องใช้เพียงชั้น Core ไม่จำเป็นต้องใช้ ORM ติดตั้งด้วย pip install sqlalchemy นอกจากนี้ คุณยังต้องติดตั้งไดรเวอร์ของฐานข้อมูลแต่ละชนิดด้วย ได้แก่ psycopg2 สำหรับ PostgreSQL, pymysql สำหรับ MySQL หรือ sqlite3 (มีมาให้ใน Python) สำหรับ SQLite SQLAlchemy ทำหน้าที่เป็นชั้นนามธรรม ดังนั้นโค้ด Pandas เดิมจึงใช้ได้กับฐานข้อมูลที่รองรับทุกชนิด เพียงเปลี่ยนสตริงการเชื่อมต่อ
# 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__)การสร้างเครื่องมือเชื่อมต่อ
ขั้นตอนแรกคือสร้าง เครื่องมือของ SQLAlchemy โดยใช้ URL การเชื่อมต่อ ซึ่งระบุชนิดฐานข้อมูล ข้อมูลรับรองความถูกต้อง โฮสต์ พอร์ต และชื่อฐานข้อมูล เครื่องมือนี้เป็นตัวสร้างการเชื่อมต่อฐานข้อมูล โดยจะยังไม่เปิดการเชื่อมต่อจนกว่าคุณจะต้องใช้งานจริง ส่งเครื่องมือนี้ให้ฟังก์ชัน pd.read_sql() และ df.to_sql() ของ Pandas อย่าเขียนข้อมูลรับรองความถูกต้องไว้ตายตัว ให้อ่านจากตัวแปรสภาพแวดล้อมหรือเครื่องมือจัดการข้อมูลลับแทน
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))การอ่านตารางด้วย pd.read_sql_table()
pd.read_sql_table('table_name', con=engine) จะอ่านตารางฐานข้อมูลทั้งตารางมาไว้ใน DataFrame โดยจะอนุมานชนิดข้อมูลของคอลัมน์จากโครงสร้างฐานข้อมูลโดยอัตโนมัติ เช่น จำนวนเต็มยังคงเป็นจำนวนเต็ม และการประทับเวลายังคงเป็นวันเวลา วิธีนี้แม่นยำกว่าการอนุมานจาก CSV คุณยังจำกัดคอลัมน์ได้ด้วยอาร์กิวเมนต์ columns และกรองแถวด้วย schema สำหรับโครงสร้างฐานข้อมูลที่ไม่ใช่ค่าเริ่มต้น โปรดใช้ความระมัดระวังกับตารางขนาดใหญ่มาก เพราะการดำเนินการนี้จะโหลดข้อมูลทั้งหมดไว้ใน 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())การเรียกใช้คำค้นด้วย pd.read_sql_query()
pd.read_sql_query('SELECT ...', con=engine) จะเรียกใช้คำสั่ง SQL SELECT ใด ๆ และส่งผลลัพธ์กลับมาเป็น DataFrame วิธีนี้ยืดหยุ่นที่สุด เพราะคุณสามารถกรอง เชื่อมตาราง และรวมข้อมูลใน SQL ก่อนโหลดเข้าสู่ Pandas ทำให้โหลดเฉพาะแถวและคอลัมน์ที่ต้องการ เขียนคำค้นเป็นสตริง Python ธรรมดา อย่านำข้อมูลที่ผู้ใช้ป้อนมาต่อเข้ากับคำค้นโดยตรง ให้ใช้คำค้นแบบมีพารามิเตอร์เพื่อป้องกันการแทรกคำสั่ง 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())คำค้นแบบมีพารามิเตอร์เพื่อความปลอดภัย
อย่าสร้างคำค้น SQL ด้วยการต่อสตริงกับค่าที่ผู้ใช้ป้อน เพราะจะเปิดช่องโหว่ การแทรกคำสั่ง SQL ให้ใช้ คำค้นแบบมีพารามิเตอร์ แทน โดยส่งพารามิเตอร์เป็นพจนานุกรมที่มีตัวแทนค่าซึ่งตั้งชื่อไว้ SQLAlchemy จะจัดการการหลีกอักขระให้เอง รูปแบบของตัวแทนค่าคือ :name ในคำค้นข้อความของ SQLAlchemy หรือ %(name)s สำหรับคำค้นรูปแบบ psycopg2 ควรใช้พารามิเตอร์เสมอ แม้แต่ในสคริปต์ภายใน เพื่อสร้างแนวปฏิบัติที่ดี
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')การจัดการผลลัพธ์คำค้นขนาดใหญ่เป็นส่วน ๆ
สำหรับผลลัพธ์คำค้นขนาดใหญ่ ให้ใช้ chunksize ใน pd.read_sql_query() เพื่อรับตัววนซ้ำของ DataFrame แทนการโหลดทุกอย่างในครั้งเดียว วิธีนี้ทำงานคล้ายกับ pd.read_csv(chunksize=...) แต่จะดึงแถวจากฐานข้อมูลเป็นชุด ๆ ใช้ร่วมกับรูปแบบตัวสะสมที่เพิ่มค่าไปเรื่อย ๆ เพื่อรวมผลลัพธ์จากคำค้นที่มีแถวระดับล้านแถวโดยไม่ใช้ 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}')ตัวจัดการบริบทของการเชื่อมต่อ
เปิดการเชื่อมต่อฐานข้อมูลภายใน ตัวจัดการบริบท เสมอ (with engine.connect() as conn:) เพื่อให้แน่ใจว่าการเชื่อมต่อจะถูกปิดอย่างถูกต้องแม้เกิดข้อยกเว้น หากลืมปิดการเชื่อมต่อ จะทำให้ การเชื่อมต่อในกลุ่มหมดลง ในระบบใช้งานจริง และทำให้คำค้นใหม่หยุดรอช่องว่างที่ว่างอยู่ SQLAlchemy จะจัดการกลุ่มการเชื่อมต่อที่มีจำนวนจำกัด และนำการเชื่อมต่อกลับมาใช้ใหม่โดยอัตโนมัติเมื่อใช้ตัวจัดการบริบท
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การตรวจสอบโครงสร้างฐานข้อมูล
ก่อนเขียนคำค้น คุณต้องทราบว่ามีตารางและคอลัมน์ใดอยู่บ้าง Inspector ของ SQLAlchemy ช่วยให้คุณอ่านโครงสร้างฐานข้อมูลโดยไม่ต้องเขียน SQL ดิบ inspector.get_table_names() แสดงรายชื่อตารางทั้งหมด ส่วน inspector.get_columns('table') ส่งคืนชื่อและชนิดของคอลัมน์ วิธีนี้มีประโยชน์เมื่อทำงานกับฐานข้อมูลที่ไม่คุ้นเคย และสะอาดกว่าการเรียกใช้ PRAGMA table_info() หรือ \d tablename ด้วยตนเอง
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"]}')การปิดเครื่องมือและแนวปฏิบัติที่ดี
ในสคริปต์ที่ทำงานเป็นเวลานานหรือแอปพลิเคชันเว็บ ให้เรียกใช้ engine.dispose() เมื่อทำงานเสร็จ เพื่อปิดการเชื่อมต่อทั้งหมดในกลุ่ม สำหรับสคริปต์ระยะสั้น ตัวเก็บขยะของ Python จะจัดการการล้างทรัพยากรให้ แนวปฏิบัติที่ดีสำหรับการเชื่อมต่อฐานข้อมูลในไปป์ไลน์ข้อมูลมีดังนี้ สร้างเครื่องมือ ครั้งเดียว ที่ด้านบนของสคริปต์แล้วใช้ซ้ำ ใช้ค่าเริ่มต้นของการรวมการเชื่อมต่อ (pool_size=5) และเปิดใช้ pool_pre_ping=True เพื่อเชื่อมต่อใหม่โดยอัตโนมัติหากเซิร์ฟเวอร์ฐานข้อมูลเริ่มทำงานใหม่ระหว่างคำค้น
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')การเปรียบเทียบความเร็วของ read_sql กับ read_csv
สำหรับข้อมูลที่อยู่ในฐานข้อมูลและมีดัชนีที่เหมาะสม pd.read_sql_query พร้อมคำค้นที่กรองข้อมูล มักจะ เร็วกว่าเมื่อเทียบกับการส่งออกเป็น CSV แล้วอ่านไฟล์นั้น เซิร์ฟเวอร์ฐานข้อมูลจะกรองข้อมูลก่อนส่ง ทำให้ลดปริมาณข้อมูลที่ถ่ายโอนผ่านเครือข่ายและภาระในการแยกวิเคราะห์ สำหรับตารางที่มีคอลัมน์จำนวนมาก ฐานข้อมูลยังเลือกส่งเฉพาะคอลัมน์ที่จำเป็นได้ อย่างไรก็ตาม การอ่านจากฐานข้อมูลระยะไกลผ่านเครือข่ายที่ช้าอาจช้ากว่าการอ่านไฟล์ Parquet ในเครื่อง ควรวัดประสิทธิภาพของทั้งสองทางเลือกกับสภาพแวดล้อมของคุณเสมอ
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')ตรวจสอบความเข้าใจอย่างรวดเร็ว
ทดสอบความเข้าใจแนวคิดการวิเคราะห์ข้อมูลจากบทเรียนนี้
ทบทวนบทเรียน
ในบทเรียนนี้ คุณได้เรียนรู้ว่า sa.create_engine() สร้างตัวสร้างการเชื่อมต่อที่นำกลับมาใช้ซ้ำได้จากสตริง URL, pd.read_sql_query() เรียกใช้ SQL ใด ๆ และส่งคืน DataFrame และ คำค้นแบบมีพารามิเตอร์ ที่ใช้ sa.text() และ params ช่วยป้องกันช่องโหว่การแทรกคำสั่ง SQL บทถัดไป เราจะดูวิธีเรียกใช้คำค้น SQL ที่ซับซ้อนยิ่งขึ้นจาก Pandas และผสาน SQL เข้ากับตรรกะของ Python
เรียนรู้ Python ด้วย AI tutor — ฟรี
เขียนและเรียกใช้โค้ดจริงในเบราว์เซอร์ของคุณ รับความช่วยเหลือทันทีจาก AI tutor 24/7 และเรียนรู้ต่อจากที่คุณหยุดบนเว็บหรือในแอป
- คอร์ส
- 30
- บทเรียน
- 120
คำถามที่พบบ่อย
บทเรียน “การเชื่อมต่อฐานข้อมูลด้วย SQLAlchemy” ฟรีหรือไม่
ใช่ — ข้อความเต็มของ “การเชื่อมต่อฐานข้อมูลด้วย SQLAlchemy” ฟรีให้อ่านที่นี่บนเว็บ เพื่อปฏิบัติแบบโต้ตอบ (ตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7) และปลดล็อคส่วนที่เหลือของคอร์ส Pandas & NumPy Academy ให้อัปเกรดเป็น CoddyKit PRO คอร์ส Pandas & NumPy Academy มีบทเรียนทั้งหมด 4 บทเรียน
คุณจะเรียนรู้อะไรในบทเรียน “การเชื่อมต่อฐานข้อมูลด้วย SQLAlchemy”
สร้าง SQLAlchemy engine สำหรับ SQLite และ PostgreSQL แล้วส่งให้ pd.read_sql เพื่อโหลดตารางเป็น DataFrame คุณปฏิบัติ Pandas & NumPy Academy ด้วยโค้ดที่ใช้งานได้จริงที่คุณเรียกใช้โดยตรงในเบราว์เซอร์ และติวเตอร์ AI ตลอด 24/7 ตอบคำถามของคุณขณะที่คุณไปผ่านบทเรียน
คุณต้องมีประสบการณ์ก่อนที่จะเริ่มเรียน Pandas & NumPy Academy หรือไม่
ไม่จำเป็นต้องมีประสบการณ์มาก่อน Pandas & NumPy Academy บน CoddyKit ออกแบบมาสำหรับผู้เริ่มต้นไปจนถึงผู้เรียนขั้นสูง คุณสามารถเริ่มต้นที่นี่หรือเริ่มจากตัวแรกและเรียนด้วยความเร็วของคุณเอง นี่คือบทเรียนที่ 1 จากทั้งหมด 4 บทเรียน
บทเรียน “การเชื่อมต่อฐานข้อมูลด้วย SQLAlchemy” ใช้เวลานานแค่ไหน
บทเรียน CoddyKit ส่วนใหญ่ใช้เวลาประมาณ 5–10 นาที แต่ละบทเรียนจึงสั้นและเป็นแบบโต้ตอบ คุณสามารถก้าวหน้าอย่างต่อเนื่องและกลับมาเรียนต่อจากตรงที่เพิ่งหยุดบนเว็บและแอปได้เลย
ฉันเขียนและรันโค้ดในบทเรียน Pandas & NumPy Academy นี้ได้ไหม
ได้ บทเรียน Pandas & NumPy Academy ทุกบทมีตัวแก้ไขโค้ดในตัว คุณจึงเขียนและรันโค้ดจริงได้เลยในเบราว์เซอร์ และได้รับข้อเสนอแนะจาก AI ในทันที — ไม่ต้องติดตั้งในเครื่องของคุณ
บทเรียนทั้งหมดในหลักสูตรนี้
- การเชื่อมต่อฐานข้อมูลด้วย SQLAlchemy
- การเรียกใช้คำสั่ง SQL จาก Pandas
- การเขียน DataFrames ลงในตารางฐานข้อมูล
- Pandas เทียบกับ SQL: การเลือกเครื่องมือที่เหมาะสม