Pandas & NumPy Academy · บทเรียน

Pandas เทียบกับ SQL: การเลือกเครื่องมือที่เหมาะสม

เปรียบเทียบ groupby/merge ใน Pandas กับ GROUP BY/JOIN ใน SQL และตัดสินใจว่าควรให้ชั้นใดจัดการการแปลงข้อมูลแต่ละรายการ

บทเรียน 4 จาก 413 ขั้นตอน

Pandas เทียบกับ SQL: การเลือกเครื่องมือที่เหมาะสม เป็นบทเรียน Pandas & NumPy Academy ฟรีบน CoddyKit นี่คือบทเรียนที่ 4 จากทั้งหมด 4 บทเรียน คุณสามารถอ่านบทเรียนทั้งหมดด้านล่างฟรี — จากนั้นลองปฏิบัติด้วยตัวคุณเองในเบราว์เซอร์พร้อมตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7 บทเรียนนี้เป็นส่วนหนึ่งของเส้นทางการเรียน Pandas & NumPy Academy และความก้าวหน้าของคุณจะซิงค์ข้ามเว็บและแอป CoddyKit คอร์ส Pandas & NumPy Academy มีบทเรียนทั้งหมด 4 บทเรียน

เครื่องมือสองชนิด จุดแข็งที่เสริมกัน

ทั้ง Pandas และ SQL เป็นเครื่องมือสำหรับจัดการข้อมูล และนักวิเคราะห์ข้อมูลมืออาชีพก็ใช้ทั้งสองชนิด ประเด็นสำคัญคือทั้งสองเป็น เครื่องมือที่เสริมกัน ไม่ใช่คู่แข่งกัน: SQL โดดเด่นด้านการดำเนินการกับชุดข้อมูลแบบประกาศบนตารางขนาดใหญ่ที่จัดเก็บในฐานข้อมูลเชิงสัมพันธ์ ขณะที่ Pandas โดดเด่นด้านการแปลงข้อมูลแบบเชิงคำสั่ง ทีละแถว และการแปลงด้วยอัลกอริทึมที่ซับซ้อนกับข้อมูลที่โหลดไว้ในหน่วยความจำแล้ว pipeline ที่ดีที่สุดจะใช้เครื่องมือแต่ละชนิดกับงานที่เครื่องมือนั้นทำได้ดีที่สุด

จุดแข็งของ SQL: สิ่งที่ SQL ทำได้ดีกว่า

โดยทั่วไป SQL เหมาะกว่าเมื่อ: ข้อมูลมีขนาดใหญ่ (ระดับกิกะไบต์ถึงเทราไบต์) และต้องกรองก่อนโหลด; การเชื่อมข้อมูลครอบคลุมหลายตารางขนาดใหญ่ ซึ่งดัชนีของฐานข้อมูลช่วยเพิ่มความเร็วได้หลายเท่าตัว; การรวมข้อมูลไม่ซับซ้อน (SUM, COUNT, GROUP BY); ชุดผลลัพธ์มีขนาดเล็ก เมื่อเทียบกับข้อมูลนำเข้า; หรือจำเป็นต้องมี การอ่านและเขียนพร้อมกัน (ฐานข้อมูลจะจัดการธุรกรรมและการล็อก) ไวยากรณ์แบบประกาศของ SQL ยังช่วยให้เครื่องมือปรับประสิทธิภาพคำสั่งเลือกแผนทางกายภาพที่ดีที่สุดได้โดยอัตโนมัติ

-- SQL excels at:
-- 1. Filtering billions of rows using an index
SELECT * FROM orders WHERE customer_id = 12345;

-- 2. Joining large tables efficiently
SELECT o.order_id, c.name, SUM(o.amount)
FROM orders o
JOIN customers c ON o.customer_id = c.id
GROUP BY o.order_id, c.name;

-- 3. Window functions on ordered data
SELECT order_id, amount,
       SUM(amount) OVER (PARTITION BY customer_id ORDER BY order_date)
FROM orders;

จุดแข็งของ Pandas: สิ่งที่ Pandas ทำได้ดีกว่า

โดยทั่วไป Pandas เหมาะกว่าเมื่อ: คุณต้องใช้ ตรรกะ Python แบบกำหนดเอง ที่ SQL ไม่สามารถเขียนแทนได้ (การเตรียมข้อมูลสำหรับการเรียนรู้ของเครื่อง การแยกวิเคราะห์สตริงแบบกำหนดเอง อัลกอริทึมที่ซับซ้อน); ลำดับการแปลงข้อมูล มีหลายขั้นตอน; คุณต้องการ การแสดงข้อมูลเป็นภาพ ทันทีหลังการวิเคราะห์; ข้อมูล อยู่ในหน่วยความจำแล้ว และการส่งคำสั่ง SQL ไปกลับเพิ่มเติมจะเพิ่มความหน่วง; หรือคุณกำลังทำ การวิเคราะห์เชิงสำรวจ ที่ต้องการทดลองแบบโต้ตอบได้ Pandas ยังรองรับการดำเนินการที่ไม่ใช่แบบตาราง เช่น การคำนวณเมทริกซ์และการทำให้อนุกรมเวลาราบเรียบ

import pandas as pd

# Pandas excels at:
# 1. Custom Python logic that SQL cannot express
df['clean_name'] = df['name'].str.strip().str.title().str.replace(r'[^a-zA-Z ]', '', regex=True)

# 2. Vectorised string parsing
df[['first', 'last']] = df['full_name'].str.split(' ', n=1, expand=True)

# 3. Rolling statistics and time series
df['7day_avg'] = df['daily_sales'].rolling(7).mean()

# 4. Direct visualisation
# df.groupby('category')['sales'].sum().plot(kind='bar')

การจับคู่การดำเนินการของ SQL กับ Pandas

การดำเนินการส่วนใหญ่ของ SQL มีสิ่งที่เทียบเท่าได้โดยตรงใน Pandas การรู้ไวยากรณ์ทั้งสองแบบช่วยให้คุณทำงานได้ยืดหยุ่นขึ้น และช่วยให้แปลงรูปแบบไปมาระหว่างเครื่องมือได้เมื่อเปลี่ยนเครื่องมือ WHERE จะกลายเป็นการทำดัชนีแบบบูลีนหรือ .query(); GROUP BY + SUM จะกลายเป็น .groupby().sum(); JOIN จะกลายเป็น pd.merge(); ORDER BY จะกลายเป็น .sort_values(); และ DISTINCT จะกลายเป็น .drop_duplicates() ความหมายเชิงอรรถศาสตร์เหมือนกัน ต่างกันเพียงไวยากรณ์

import pandas as pd

df = pd.DataFrame({'region': ['N','S','N','E'], 'amount': [100,200,150,300]})

# SQL: SELECT region, SUM(amount) FROM df WHERE amount>100 GROUP BY region ORDER BY region
# Pandas:
result = (
    df[df['amount'] > 100]
    .groupby('region')['amount']
    .sum()
    .reset_index()
    .sort_values('region')
)
print(result)

เมื่อขนาดข้อมูลเป็นตัวกำหนดทางเลือก

กรอบการตัดสินใจเชิงปฏิบัติตามขนาดข้อมูล: ต่ำกว่า 100 MB — ใช้ Pandas ทั้งหมด เพราะค่าใช้จ่ายของ SQL ไม่คุ้มค่า; 100 MB – 10 GB — กรองและรวมข้อมูลใน SQL แล้วโหลด DataFrame สรุปเข้าสู่ Pandas; 10 GB – 1 TB — ใช้ SQL หรือ Dask ในการประมวลผล และใช้ Pandas เฉพาะสำหรับสรุปผลขั้นสุดท้าย; มากกว่า 1 TB — ใช้ SQL แบบกระจาย (BigQuery, Spark SQL, Redshift) อย่าพยายามโหลดตารางขนาด 100 GB เข้าสู่ Pandas บนแล็ปท็อปที่มีหน่วยความจำ 16 GB เพราะโปรแกรมจะหยุดทำงานหรือทำให้ดิสก์ทำงานหนักจนระบบช้าลง

import pandas as pd
import sqlalchemy as sa

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

# Right approach: SQL handles the heavy lifting
summary_df = pd.read_sql_query(
    '''
    SELECT region, product_category,
           SUM(revenue) AS total_revenue,
           COUNT(DISTINCT customer_id) AS unique_customers
    FROM orders
    WHERE order_date >= '2024-01-01'
    GROUP BY region, product_category
    ''',
    con=engine
)
# summary_df is small — now do Pandas things on it
print(summary_df.sort_values('total_revenue', ascending=False))

ฟังก์ชันหน้าต่างของ SQL เทียบกับ Rolling ของ Pandas

ฟังก์ชันหน้าต่างของ SQL (OVER (PARTITION BY ... ORDER BY ...)) มีประสิทธิภาพสูง แต่ก็มีข้อจำกัด กล่าวคือทำอันดับสะสม ค่าเลื่อนย้อนหลัง/ไปข้างหน้า และการรวมค่าแบบหน้าต่างอย่างง่ายได้ดี แต่ไม่สามารถเขียนสถิติแบบหน้าต่างที่ซับซ้อน เช่น สหสัมพันธ์เพียร์สันแบบหน้าต่าง ใน SQL ได้ ฟังก์ชัน rolling() และ expanding() ของ Pandas ครอบคลุมการคำนวณแบบหน้าต่างได้หลากหลายกว่ามาก รวมถึงฟังก์ชันกำหนดเองผ่าน .apply() สำหรับฟังก์ชันหน้าต่างมาตรฐานบนข้อมูลขนาดใหญ่ ควรเลือกใช้ SQL ส่วนตรรกะแบบหน้าต่างที่ซับซ้อน ควรเลือกใช้ Pandas

import pandas as pd

df = pd.DataFrame({
    'date': pd.date_range('2024-01-01', periods=30),
    'sales': [100 + i*10 + (i%7)*20 for i in range(30)]
})

# Pandas rolling — easy with arbitrary window functions
df['7d_mean'] = df['sales'].rolling(7).mean()
df['7d_std']  = df['sales'].rolling(7).std()
df['7d_corr'] = df['sales'].rolling(7).corr(df['sales'].shift(1))
print(df.tail())

การเชื่อมโยงที่ซับซ้อน: ความยืดหยุ่นของ Pandas

การเชื่อมโยงตารางใน SQL อาศัยความเท่ากันของคีย์เป็นหลัก (แม้จะมีข้อยกเว้นบางกรณี) ส่วน pd.merge_asof() ของ Pandas รองรับ การเชื่อมโยงแบบคลุมเครือตามเวลา (จับคู่คีย์ที่ใกล้ที่สุดแทนการเท่ากันแบบตรงตัว) ซึ่งมีประโยชน์อย่างยิ่งสำหรับการจัดแนวอนุกรมเวลา เช่น การเชื่อมราคาหุ้นกับเหตุการณ์ซื้อขายโดยใช้ราคาก่อนหน้าที่ใกล้ที่สุด นอกจากนี้ Pandas ยังรองรับการเชื่อมโยงแบบมีเงื่อนไขโดยใช้ merge แล้วกรองข้อมูล ซึ่งใน SQL ต้องเขียนเป็นแบบสอบถามย่อยหรือการเชื่อมโยง LATERAL รูปแบบการเชื่อมโยงขั้นสูงเหล่านี้เป็นหนึ่งในด้านที่ Pandas เหนือกว่าอย่างชัดเจน

import pandas as pd

trades = pd.DataFrame({
    'time': pd.to_datetime(['2024-01-01 10:00', '2024-01-01 10:05', '2024-01-01 10:12']),
    'symbol': ['AAPL', 'AAPL', 'AAPL'],
    'shares': [100, 200, 50]
})
prices = pd.DataFrame({
    'time': pd.to_datetime(['2024-01-01 10:00', '2024-01-01 10:10']),
    'price': [185.0, 186.5]
})

# Fuzzy join: match each trade to the nearest preceding price
result = pd.merge_asof(trades.sort_values('time'),
                       prices.sort_values('time'),
                       on='time', direction='backward')
print(result)

Pandas สำหรับการทำโปรไฟล์ข้อมูล, SQL สำหรับการใช้งานจริง

รูปแบบกระบวนการทำงานที่พบได้ทั่วไปคือ ใช้ Pandas สำหรับ EDA และการทำโปรไฟล์ข้อมูล จากตัวอย่างข้อมูลที่เป็นตัวแทน เช่น แถวหนึ่งล้านแถวแรก จากนั้นพัฒนาตรรกะการแปลงข้อมูลแบบวนซ้ำ แล้วแปลงขั้นตอนสำคัญเป็น SQL เพื่อรองรับ ขนาดข้อมูลระดับใช้งานจริง Pandas ช่วยให้ปรับแก้และทดลองได้รวดเร็วพร้อมเห็นผลในรูปภาพทันที ส่วน SQL ทำงานในระดับขนาดใหญ่ได้อย่างเสถียรโดยใช้โครงสร้างพื้นฐานเพียงเล็กน้อย ควรทำให้ทั้งสองส่วนสอดคล้องกัน เมื่อเพิ่มคุณลักษณะใหม่ใน Pandas ให้เขียนกระบวนงานที่เก็บไว้หรือมุมมองใน SQL ที่เทียบเท่ากันสำหรับการใช้งานจริง

import pandas as pd
import sqlalchemy as sa

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

# Development: sample in Pandas for fast iteration
df_sample = pd.read_sql_query(
    'SELECT * FROM orders ORDER BY RANDOM() LIMIT 10000',
    con=engine
)
# Explore and prototype:
df_sample['revenue_tier'] = pd.cut(
    df_sample['amount'],
    bins=[0, 100, 500, float('inf')],
    labels=['low', 'mid', 'high']
)
print(df_sample['revenue_tier'].value_counts())
# Production: translate cut logic to SQL CASE WHEN

pandasql: การเขียน SQL กับ DataFrames

ไลบรารี pandasql ช่วยให้คุณเขียนแบบสอบถาม SQL ได้โดยตรง กับ DataFrames ของ Pandas โดยเบื้องหลังใช้ SQLite คำสั่ง sqldf('SELECT * FROM df WHERE amount > 100', locals()) จะเรียกใช้แบบสอบถามกับ DataFrame df วิธีนี้มีประโยชน์หากคุณคิดเป็น SQL แต่ข้อมูลอยู่ใน Pandas แล้ว หรือใช้สอนแนวคิด SQL กับข้อมูลในหน่วยความจำ อย่างไรก็ตาม สำหรับการดำเนินการส่วนใหญ่ วิธีนี้ช้ากว่า Pandas โดยตรง จึงควรใช้เพื่อความคุ้นเคย ไม่ใช่เพื่อประสิทธิภาพ

# pip install pandasql
import pandas as pd
# from pandasql import sqldf

df = pd.DataFrame({
    'product': ['A', 'B', 'A', 'C', 'B'],
    'sales': [100, 200, 150, 80, 220]
})

# With pandasql (commented out as it requires install):
# result = sqldf('SELECT product, SUM(sales) AS total FROM df GROUP BY product', locals())

# Equivalent native Pandas:
result = df.groupby('product')['sales'].sum().reset_index()
print(result)

กรอบการตัดสินใจ: ข้อมูลอ้างอิงฉบับย่อ

ใช้แนวทางการตัดสินใจนี้เมื่อต้องเลือกระหว่าง SQL กับ Pandas:

ข้อมูลอยู่ในฐานข้อมูลและมีขนาดใหญ่หรือไม่? กรองและรวมข้อมูลใน SQL ก่อน
ต้องใช้ตรรกะ Python แบบกำหนดเองหรือไม่? ใช้ Pandas หลังจากกรองข้อมูลเบื้องต้นด้วย SQL
ต้องวิเคราะห์เชิงสำรวจกับตัวอย่างข้อมูลหรือไม่? Pandas ช่วยให้ทดลองปรับแก้ได้รวดเร็วกว่า
เป็นอนุกรมเวลาที่มีสถิติแบบหน้าต่างซับซ้อนหรือไม่? ใช้ rolling/ewm ของ Pandas
ต้องใช้ GROUP BY อย่างง่ายกับข้อมูลหลายล้านแถวหรือไม่? ใช้ SQL ร่วมกับดัชนี
มี DataFrames ขนาดเล็กหลายรายการอยู่ในหน่วยความจำแล้วหรือไม่? ใช้ pd.merge() ได้
ต้องการธุรกรรม ACID หรือไม่? ใช้ฐานข้อมูล SQL ไม่ใช่ Pandas

การรวมทั้งสองแบบ: กระบวนการทำงานแบบผสม

แนวทางที่ใช้งานได้จริงที่สุดคือ กระบวนการทำงานแบบผสมที่ใช้จุดแข็งของเครื่องมือแต่ละชนิด SQL จัดการการนำเข้าข้อมูล การกรองข้อมูลเบื้องต้น และการรวมข้อมูลมาตรฐานบนตารางดิบขนาดใหญ่ จากนั้นส่งผลลัพธ์ ซึ่งเป็น DataFrame ที่มีขนาดจัดการได้ ให้ Pandas เพื่อสร้างคุณลักษณะ เมตริกแบบกำหนดเอง สถิติแบบหน้าต่าง และการแสดงผลข้อมูล หากต้องการ ก็สามารถเขียนผลลัพธ์กลับไปยังฐานข้อมูลเพื่อให้บริการได้ กระบวนการนี้อ่านเข้าใจง่าย ปรับขนาดได้ และดูแลรักษาได้โดยนักวิเคราะห์ที่รู้จักทั้ง SQL และ Python

import pandas as pd
import sqlalchemy as sa

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

# Step 1: SQL coarse aggregation
df = pd.read_sql_query('''
    SELECT DATE(order_date) AS date, region, SUM(amount) AS daily_revenue
    FROM orders WHERE status = 'completed'
    GROUP BY DATE(order_date), region
    ORDER BY date
''', con=engine, parse_dates=['date'])

# Step 2: Pandas rolling and pivoting (hard in SQL)
df['7d_avg'] = df.groupby('region')['daily_revenue'].transform(
    lambda x: x.rolling(7, min_periods=1).mean()
)
pivot = df.pivot(index='date', columns='region', values='7d_avg')
print(pivot.tail())

ตรวจสอบความเข้าใจอย่างรวดเร็ว

ทดสอบความเข้าใจแนวคิดการวิเคราะห์ข้อมูลจากบทเรียนนี้

ตอบคำถามในบทเรียนแบบโต้ตอบ

ทบทวนบทเรียน

ในบทเรียนนี้ คุณได้เรียนรู้ว่า SQL มีความโดดเด่นด้านการกรอง การเชื่อมโยง และการรวมข้อมูลอย่างง่ายในข้อมูลขนาดใหญ่ที่มีดัชนี ส่วน Pandas มีความโดดเด่นด้านตรรกะ Python แบบกำหนดเอง สถิติแบบหน้าต่างที่ซับซ้อน และการวิเคราะห์เชิงสำรวจ โดยกลยุทธ์ที่ดีที่สุดคือ กระบวนการทำงานแบบผสมที่ใช้ SQL ลดขนาดข้อมูลเบื้องต้น และใช้ Pandas แปลงข้อมูลที่ซับซ้อนบนผลลัพธ์ซึ่งมีขนาดจัดการได้ บทถัดไป เราจะเริ่มเรียนสถิติอนุมานด้วย SciPy โดยเริ่มจากการทดสอบการแจกแจงปกติและสถิติเชิงพรรณนา

เริ่มต้นได้ฟรี

เรียนรู้ Python ด้วย AI tutor — ฟรี

เขียนและเรียกใช้โค้ดจริงในเบราว์เซอร์ของคุณ รับความช่วยเหลือทันทีจาก AI tutor 24/7 และเรียนรู้ต่อจากที่คุณหยุดบนเว็บหรือในแอป

คอร์ส: 30
บทเรียน: 120

เริ่มเรียนฟรี ดูหลักสูตรเต็ม

คำถามที่พบบ่อย

บทเรียน “Pandas เทียบกับ SQL: การเลือกเครื่องมือที่เหมาะสม” ฟรีหรือไม่

ใช่ — ข้อความเต็มของ “Pandas เทียบกับ SQL: การเลือกเครื่องมือที่เหมาะสม” ฟรีให้อ่านที่นี่บนเว็บ เพื่อปฏิบัติแบบโต้ตอบ (ตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7) และปลดล็อคส่วนที่เหลือของคอร์ส Pandas & NumPy Academy ให้อัปเกรดเป็น CoddyKit PRO คอร์ส Pandas & NumPy Academy มีบทเรียนทั้งหมด 4 บทเรียน

คุณจะเรียนรู้อะไรในบทเรียน “Pandas เทียบกับ SQL: การเลือกเครื่องมือที่เหมาะสม”

เปรียบเทียบ groupby/merge ใน Pandas กับ GROUP BY/JOIN ใน SQL และตัดสินใจว่าควรให้ชั้นใดจัดการการแปลงข้อมูลแต่ละรายการ คุณปฏิบัติ Pandas & NumPy Academy ด้วยโค้ดที่ใช้งานได้จริงที่คุณเรียกใช้โดยตรงในเบราว์เซอร์ และติวเตอร์ AI ตลอด 24/7 ตอบคำถามของคุณขณะที่คุณไปผ่านบทเรียน

คุณต้องมีประสบการณ์ก่อนที่จะเริ่มเรียน Pandas & NumPy Academy หรือไม่

ไม่จำเป็นต้องมีประสบการณ์มาก่อน Pandas & NumPy Academy บน CoddyKit ออกแบบมาสำหรับผู้เริ่มต้นไปจนถึงผู้เรียนขั้นสูง คุณสามารถเริ่มต้นที่นี่หรือเริ่มจากตัวแรกและเรียนด้วยความเร็วของคุณเอง นี่คือบทเรียนที่ 4 จากทั้งหมด 4 บทเรียน

บทเรียน “Pandas เทียบกับ SQL: การเลือกเครื่องมือที่เหมาะสม” ใช้เวลานานแค่ไหน

บทเรียน CoddyKit ส่วนใหญ่ใช้เวลาประมาณ 5–10 นาที แต่ละบทเรียนจึงสั้นและเป็นแบบโต้ตอบ คุณสามารถก้าวหน้าอย่างต่อเนื่องและกลับมาเรียนต่อจากตรงที่เพิ่งหยุดบนเว็บและแอปได้เลย

ฉันเขียนและรันโค้ดในบทเรียน Pandas & NumPy Academy นี้ได้ไหม

ได้ บทเรียน Pandas & NumPy Academy ทุกบทมีตัวแก้ไขโค้ดในตัว คุณจึงเขียนและรันโค้ดจริงได้เลยในเบราว์เซอร์ และได้รับข้อเสนอแนะจาก AI ในทันที — ไม่ต้องติดตั้งในเครื่องของคุณ

บทเรียนทั้งหมดในหลักสูตรนี้

การเชื่อมต่อฐานข้อมูลด้วย SQLAlchemy
การเรียกใช้คำสั่ง SQL จาก Pandas
การเขียน DataFrames ลงในตารางฐานข้อมูล
Pandas เทียบกับ SQL: การเลือกเครื่องมือที่เหมาะสม

← กลับไปที่ Pandas & NumPy Academy