Pandas Python คืออะไร? ทำความรู้จักกับหัวใจของการวิเคราะห์ข้อมูล
ในยุคที่ข้อมูลกลายเป็นทรัพยากรที่มีค่าที่สุดในโลกดิจิทัล การมีเครื่องมือที่ทรงพลังในการจัดการ วิเคราะห์ และทำความสะอาดข้อมูลจึงเป็นสิ่งจำเป็นสำหรับนักพัฒนา นักวิทยาศาสตร์ข้อมูล และนักวิเคราะห์ธุรกิจ หนึ่งในเครื่องมือที่ได้รับความนิยมสูงสุดในวงการ Data Science คือ Pandas ซึ่งเป็นไลบรารีของภาษา Python ที่ถูกออกแบบมาเพื่อทำงานกับข้อมูลแบบตาราง (Tabular Data) โดยเฉพาะ
Pandas (อ่านว่า แพนด้าส์) เป็นโอเพนซอร์สไลบรารีที่ให้โครงสร้างข้อมูลที่ยืดหยุ่นและฟังก์ชันการทำงานมากมายสำหรับการจัดการข้อมูลเชิงตัวเลขและข้อมูลที่เป็นอนุกรมเวลา (Time Series) คำว่า “Pandas” มาจากคำว่า “Panel Data” ซึ่งเป็นศัพท์ทางเศรษฐมิติที่หมายถึงข้อมูลที่สังเกตการณ์หลายช่วงเวลาในหลายหน่วยตัวอย่าง
จุดเด่นของ Pandas คือความสามารถในการทำงานกับ DataFrames ซึ่งเป็นโครงสร้างข้อมูลสองมิติ (คล้ายตารางใน Excel) ที่ช่วยให้คุณสามารถจัดการข้อมูลได้อย่างมีประสิทธิภาพ ไม่ว่าจะเป็นการกรองข้อมูล การรวมข้อมูล การจัดกลุ่ม การทำความสะอาดข้อมูลที่ขาดหาย หรือการแปลงรูปแบบข้อมูล
ประวัติความเป็นมาและความสำคัญของ Pandas
Pandas ถูกสร้างขึ้นโดย Wes McKinney ในปี 2008 ขณะที่เขาทำงานอยู่ที่ AQR Capital Management โดยมีเป้าหมายเพื่อสร้างเครื่องมือที่สามารถทำงานกับข้อมูลทางการเงินที่ซับซ้อนได้ดีกว่าเครื่องมือที่มีอยู่ในขณะนั้น ตั้งแต่นั้นมา Pandas ได้กลายเป็นมาตรฐานอุตสาหกรรมสำหรับการวิเคราะห์ข้อมูลใน Python และเป็นส่วนหนึ่งของระบบนิเวศ PyData ร่วมกับ NumPy, Matplotlib, และ Scikit-learn
ในปี 2026 Pandas ได้พัฒนาไปไกลมาก โดยมีเวอร์ชันล่าสุดที่รองรับการทำงานแบบ Parallel Computing, การจัดการหน่วยความจำที่ดีขึ้น, และการทำงานร่วมกับ Apache Arrow ซึ่งทำให้การประมวลผลข้อมูลขนาดใหญ่ทำได้รวดเร็วขึ้นกว่าเดิมหลายเท่า
การติดตั้งและการเริ่มต้นใช้งาน Pandas
ก่อนที่เราจะเริ่มต้นใช้งาน Pandas คุณจำเป็นต้องติดตั้งไลบรารีนี้ก่อน ซึ่งสามารถทำได้ง่ายๆ ผ่าน pip หรือ conda package manager
วิธีการติดตั้ง Pandas
# ติดตั้งผ่าน pip (วิธีที่แนะนำ)
pip install pandas
# หรือติดตั้งผ่าน conda
conda install pandas
# หากต้องการติดตั้งเวอร์ชันล่าสุดที่รองรับ Apache Arrow
pip install pandas[arrow]
# ตรวจสอบเวอร์ชันที่ติดตั้ง
python -c "import pandas; print(pandas.__version__)"หลังจากติดตั้งสำเร็จ คุณสามารถเริ่มใช้งาน Pandas ได้โดยการ import ไลบรารี ซึ่งโดยทั่วไปจะใช้ชื่อย่อว่า pd เพื่อความสะดวก
import pandas as pd
import numpy as np # มักใช้คู่กับ pandas
# สร้าง DataFrame อย่างง่าย
data = {
'ชื่อ': ['สมชาย', 'สมหญิง', 'สมหมาย', 'สมศรี'],
'อายุ': [25, 30, 35, 28],
'เงินเดือน': [35000, 45000, 55000, 38000],
'แผนก': ['IT', 'HR', 'IT', 'การเงิน']
}
df = pd.DataFrame(data)
print(df)ผลลัพธ์ที่ได้จะเป็นตารางที่สวยงามและอ่านง่าย:
ชื่อ อายุ เงินเดือน แผนก
0 สมชาย 25 35000 IT
1 สมหญิง 30 45000 HR
2 สมหมาย 35 55000 IT
3 สมศรี 28 38000 การเงินโครงสร้างข้อมูลหลักของ Pandas
Pandas มีโครงสร้างข้อมูลหลัก 2 ประเภทที่คุณต้องทำความรู้จักให้ดี:
1. Series — ข้อมูลหนึ่งมิติ
Series คืออาร์เรย์หนึ่งมิติ (คล้ายลิสต์ใน Python) ที่สามารถเก็บข้อมูลชนิดใดก็ได้ และมี Index (ดัชนี) กำกับแต่ละแถว โดยค่าเริ่มต้น Index จะเป็นตัวเลขตั้งแต่ 0 ถึง n-1 แต่คุณสามารถกำหนด Index เป็นค่าอะไรก็ได้ เช่น วันที่ หรือข้อความ
# สร้าง Series จากลิสต์
ages = pd.Series([25, 30, 35, 28], index=['สมชาย', 'สมหญิง', 'สมหมาย', 'สมศรี'])
print(ages)
# ผลลัพธ์:
# สมชาย 25
# สมหญิง 30
# สมหมาย 35
# สมศรี 28
# dtype: int64
# การเข้าถึงข้อมูล
print(ages['สมชาย']) # ผลลัพธ์: 25
print(ages[ages > 30]) # กรองเฉพาะค่าที่มากกว่า 302. DataFrame — ข้อมูลสองมิติ
DataFrame คือโครงสร้างข้อมูลสองมิติที่มีลักษณะคล้ายตารางในฐานข้อมูลหรือสเปรดชีต โดยแต่ละคอลัมน์สามารถเป็นชนิดข้อมูลที่แตกต่างกันได้ (เช่น ตัวเลข, ข้อความ, วันที่) และแต่ละคอลัมน์ก็คือ Series อันหนึ่ง
# สร้าง DataFrame จาก dictionary
employees = pd.DataFrame({
'รหัสพนักงาน': ['EMP001', 'EMP002', 'EMP003', 'EMP004'],
'ชื่อ': ['สมชาย', 'สมหญิง', 'สมหมาย', 'สมศรี'],
'อายุ': [25, 30, 35, 28],
'แผนก': ['IT', 'HR', 'IT', 'การเงิน'],
'เงินเดือน': [35000, 45000, 55000, 38000],
'วันที่เริ่มงาน': pd.to_datetime(['2020-01-15', '2019-06-01', '2021-03-20', '2022-11-01'])
})
# ดูข้อมูลเบื้องต้น
print(employees.head()) # แสดง 5 แถวแรก
print(employees.info()) # ดูชนิดข้อมูลและจำนวน non-null
print(employees.describe()) # สถิติเชิงพรรณนาสำหรับคอลัมน์ตัวเลขการจัดการข้อมูลเบื้องต้นด้วย Pandas
เมื่อคุณมี DataFrame แล้ว ขั้นตอนต่อไปคือการจัดการข้อมูล ซึ่งเป็นหัวใจสำคัญของการทำงานกับ Pandas ด้านล่างนี้คือเทคนิคพื้นฐานที่คุณต้องรู้:
การเลือกและกรองข้อมูล
Pandas มีวิธีการเลือกข้อมูลหลายรูปแบบ ตั้งแต่การเลือกคอลัมน์เดี่ยว การเลือกหลายคอลัมน์ ไปจนถึงการกรองข้อมูลตามเงื่อนไขที่ซับซ้อน
# เลือกคอลัมน์เดี่ยว (ได้ Series)
names = df['ชื่อ']
# เลือกหลายคอลัมน์ (ได้ DataFrame)
subset = df[['ชื่อ', 'เงินเดือน', 'แผนก']]
# เลือกแถวตามตำแหน่ง (iloc)
first_row = df.iloc[0] # แถวแรก
first_three_rows = df.iloc[0:3] # แถวที่ 0 ถึง 2
# เลือกแถวตาม Index (loc)
row_by_index = df.loc[2] # แถวที่ index = 2
# กรองข้อมูลตามเงื่อนไข
it_employees = df[df['แผนก'] == 'IT']
high_salary = df[df['เงินเดือน'] > 40000]
# กรองหลายเงื่อนไข
it_high_salary = df[(df['แผนก'] == 'IT') & (df['เงินเดือน'] > 40000)]
# ใช้ query() สำหรับเงื่อนไขที่ซับซ้อน
result = df.query('แผนก == "IT" and เงินเดือน > 40000')การจัดการข้อมูลที่ขาดหาย (Missing Data)
ข้อมูลในโลกจริงมักมีค่าที่ขาดหาย (NaN หรือ None) เสมอ Pandas มีเครื่องมือที่ทรงพลังในการจัดการกับปัญหานี้
# สร้างข้อมูลที่มีค่าขาดหาย
df_missing = pd.DataFrame({
'A': [1, 2, None, 4],
'B': [5, None, None, 8],
'C': [9, 10, 11, 12]
})
# ตรวจสอบค่าที่ขาดหาย
print(df_missing.isnull().sum()) # นับจำนวน NaN ในแต่ละคอลัมน์
# ลบแถวที่มี NaN (ระวัง: อาจสูญเสียข้อมูล)
df_cleaned = df_missing.dropna()
# เติมค่าที่ขาดหายด้วยค่าเฉพาะ
df_filled = df_missing.fillna(0) # เติมด้วย 0
df_filled_mean = df_missing.fillna(df_missing.mean()) # เติมด้วยค่าเฉลี่ย
# เติมค่าแบบ forward fill (ใช้ค่าก่อนหน้า)
df_ffill = df_missing.fillna(method='ffill')
# เติมค่าแบบ backward fill (ใช้ค่าถัดไป)
df_bfill = df_missing.fillna(method='bfill')การเพิ่ม ลบ และแก้ไขคอลัมน์
การปรับแต่งโครงสร้างของ DataFrame เป็นเรื่องที่ทำได้ง่ายมากใน Pandas
# เพิ่มคอลัมน์ใหม่
df['โบนัส'] = df['เงินเดือน'] * 0.15 # โบนัส 15% ของเงินเดือน
df['รายรับรวม'] = df['เงินเดือน'] + df['โบนัส']
# เพิ่มคอลัมน์ตามเงื่อนไข
df['ระดับพนักงาน'] = df['เงินเดือน'].apply(
lambda x: 'อาวุโส' if x > 40000 else 'ทั่วไป'
)
# ลบคอลัมน์
df_dropped = df.drop(columns=['โบนัส'])
# เปลี่ยนชื่อคอลัมน์
df_renamed = df.rename(columns={'ชื่อ': 'ชื่อพนักงาน', 'เงินเดือน': 'รายได้'})
# จัดเรียงคอลัมน์ใหม่
df_reordered = df[['รหัสพนักงาน', 'ชื่อ', 'แผนก', 'เงินเดือน']]การวิเคราะห์ข้อมูลขั้นสูงด้วย Pandas
เมื่อคุณเข้าใจพื้นฐานแล้ว มาดูเทคนิคขั้นสูงที่ใช้ในการวิเคราะห์ข้อมูลจริงกัน:
GroupBy — การจัดกลุ่มและรวมข้อมูล
GroupBy เป็นหนึ่งในฟังก์ชันที่มีประโยชน์ที่สุดใน Pandas ช่วยให้คุณสามารถแบ่งข้อมูลออกเป็นกลุ่มตามคอลัมน์ที่กำหนด แล้วคำนวณสถิติต่างๆ ในแต่ละกลุ่ม
# สร้างข้อมูลตัวอย่างที่มีหลายกลุ่ม
sales_data = pd.DataFrame({
'วันที่': pd.date_range('2026-01-01', periods=100, freq='D'),
'สินค้า': np.random.choice(['แล็ปท็อป', 'สมาร์ทโฟน', 'แท็บเล็ต'], 100),
'ภูมิภาค': np.random.choice(['เหนือ', 'ใต้', 'กลาง', 'ตะวันออก'], 100),
'ยอดขาย': np.random.randint(10000, 100000, 100),
'จำนวน': np.random.randint(1, 50, 100)
})
# จัดกลุ่มตามสินค้า และคำนวณยอดขายรวม
product_sales = sales_data.groupby('สินค้า')['ยอดขาย'].sum()
print(product_sales)
# จัดกลุ่มหลายคอลัมน์
region_product = sales_data.groupby(['ภูมิภาค', 'สินค้า']).agg({
'ยอดขาย': 'sum',
'จำนวน': 'mean',
'วันที่': 'count'
}).rename(columns={'วันที่': 'จำนวนครั้งที่ขาย'})
print(region_product)
# การใช้ transform เพื่อเพิ่มสถิติกลับเข้าไปใน DataFrame
sales_data['ยอดขายเฉลี่ยต่อประเภท'] = sales_data.groupby('สินค้า')['ยอดขาย'].transform('mean')
sales_data['สัดส่วนยอดขาย'] = sales_data['ยอดขาย'] / sales_data.groupby('สินค้า')['ยอดขาย'].transform('sum')การรวมข้อมูลจากหลายแหล่ง (Merge & Join)
ในการทำงานจริง คุณมักจะต้องรวมข้อมูลจากหลายแหล่งเข้าด้วยกัน Pandas มีฟังก์ชันที่คล้ายกับ SQL JOIN
# ข้อมูลพนักงาน
employees = pd.DataFrame({
'emp_id': [1, 2, 3, 4, 5],
'name': ['สมชาย', 'สมหญิง', 'สมหมาย', 'สมศรี', 'สมปอง'],
'dept_id': [10, 20, 10, 30, 20]
})
# ข้อมูลแผนก
departments = pd.DataFrame({
'dept_id': [10, 20, 30, 40],
'dept_name': ['IT', 'HR', 'การเงิน', 'การตลาด'],
'location': ['กรุงเทพ', 'เชียงใหม่', 'กรุงเทพ', 'ภูเก็ต']
})
# Inner Join - เฉพาะพนักงานที่มีแผนก
inner_join = pd.merge(employees, departments, on='dept_id', how='inner')
# Left Join - พนักงานทุกคน (แผนกที่ไม่มีจะได้ NaN)
left_join = pd.merge(employees, departments, on='dept_id', how='left')
# Right Join - ทุกแผนก (พนักงานที่ไม่มีจะได้ NaN)
right_join = pd.merge(employees, departments, on='dept_id', how='right')
# Outer Join - ทั้งหมด
outer_join = pd.merge(employees, departments, on='dept_id', how='outer')
# Concatenate - การต่อแถวข้อมูล
df1 = pd.DataFrame({'A': [1, 2], 'B': [3, 4]})
df2 = pd.DataFrame({'A': [5, 6], 'B': [7, 8]})
concat_rows = pd.concat([df1, df2], axis=0) # ต่อแนวตั้ง
concat_cols = pd.concat([df1, df2], axis=1) # ต่อแนวนอนการจัดการข้อมูลอนุกรมเวลา (Time Series)
Pandas มีความสามารถที่ยอดเยี่ยมในการทำงานกับข้อมูลที่มีวันที่และเวลา
# สร้างข้อมูลอนุกรมเวลา
date_range = pd.date_range(start='2026-01-01', end='2026-12-31', freq='D')
ts_data = pd.DataFrame({
'วันที่': date_range,
'ราคาหุ้น': 100 + np.cumsum(np.random.randn(len(date_range)) * 2),
'ปริมาณซื้อขาย': np.random.randint(1000, 10000, len(date_range))
})
# ตั้งค่าวันที่เป็น index
ts_data.set_index('วันที่', inplace=True)
# Resampling - การเปลี่ยนช่วงเวลา
weekly_data = ts_data.resample('W').mean() # เฉลี่ยรายสัปดาห์
monthly_data = ts_data.resample('M').agg({
'ราคาหุ้น': 'last',
'ปริมาณซื้อขาย': 'sum'
}) # ราคาปิดเดือน + ปริมาณรวม
# การเลื่อนข้อมูล (Shift)
ts_data['ราคาวันก่อนหน้า'] = ts_data['ราคาหุ้น'].shift(1)
ts_data['ผลตอบแทนรายวัน'] = (ts_data['ราคาหุ้น'] - ts_data['ราคาวันก่อนหน้า']) / ts_data['ราคาวันก่อนหน้า'] * 100
# การคำนวณค่าเคลื่อนที่ (Rolling)
ts_data['MA_7'] = ts_data['ราคาหุ้น'].rolling(window=7).mean() # ค่าเฉลี่ยเคลื่อนที่ 7 วัน
ts_data['MA_30'] = ts_data['ราคาหุ้น'].rolling(window=30).mean() # ค่าเฉลี่ยเคลื่อนที่ 30 วันการเปรียบเทียบ: Pandas vs เครื่องมืออื่นๆ
เพื่อให้คุณเห็นภาพชัดเจนขึ้น เราได้จัดทำตารางเปรียบเทียบ Pandas กับเครื่องมือยอดนิยมอื่นๆ:
ตารางเปรียบเทียบ Pandas กับ Excel และ SQL
| คุณสมบัติ | Pandas (Python) | Microsoft Excel | SQL |
|---|---|---|---|
| การจัดการข้อมูลขนาดใหญ่ | ดี (รองรับหลายล้านแถว) | จำกัด (ประมาณ 1 ล้านแถว) | ดีเยี่ยม (ขึ้นอยู่กับฐานข้อมูล) |
| ความสามารถในการทำงานอัตโนมัติ | ดีเยี่ยม (เขียนสคริปต์ได้) | ปานกลาง (VBA/Macro) | ดี (Stored Procedures) |
| การวิเคราะห์ทางสถิติ | ดีเยี่ยม (มีฟังก์ชันมากมาย) | ดี (มีฟังก์ชันพื้นฐาน) | จำกัด (ต้องใช้ฟังก์ชันเฉพาะ) |
| การแสดงผลข้อมูล | ต้องใช้ไลบรารีเสริม (Matplotlib, Seaborn) | ดีเยี่ยม (มี Chart ในตัว) | ไม่สามารถทำได้โดยตรง |
| การทำงานกับข้อมูลหลายแหล่ง | ดีเยี่ยม (CSV, Excel, SQL, JSON, Parquet) | จำกัด (Excel, CSV, Text) | ดี (เชื่อมต่อหลายฐานข้อมูล) |
| ความซับซ้อนในการเรียนรู้ | ปานกลาง (ต้องรู้ Python) | ต่ำ (ใช้งานง่าย) | ปานกลาง (ต้องรู้ Syntax) |
| การทำงานซ้ำ (Reproducibility) | ดีเยี่ยม (Code-based) | ต่ำ (Manual process) | ดี (Query-based) |
| การทำงานร่วมกับ Machine Learning | ดีเยี่ยม (Scikit-learn, TensorFlow) | ไม่สามารถทำได้ | จำกัด (ต้องใช้เครื่องมืออื่น) |
ตารางเปรียบเทียบ Pandas รุ่นต่างๆ (2026)
| คุณสมบัติ | Pandas 1.x (Legacy) | Pandas 2.x (Stable) | Pandas 3.x (2026 Beta) |
|---|---|---|---|
| การรองรับ Apache Arrow | ไม่รองรับ | รองรับบางส่วน | รองรับเต็มรูปแบบ (ค่าเริ่มต้น) |
| ประสิทธิภาพการประมวลผล | พื้นฐาน | ดีขึ้น 2-3 เท่า | ดีขึ้น 5-10 เท่า |
| การจัดการหน่วยความจำ | ใช้ RAM สูง | ปรับปรุงแล้ว | ดีเยี่ยม (Copy-on-Write) |
| การทำงานแบบ Parallel | ไม่รองรับ | ผ่าน Modin/Dask | รองรับในตัว (multi-core) |
| การรองรับ PyArrow dtypes | ไม่รองรับ | ทดลองใช้ได้ | ค่าเริ่มต้น |
| การทำงานกับข้อมูลขนาด > RAM | ไม่สามารถ | จำกัด | รองรับ (out-of-core) |
Best Practices ในการใช้ Pandas สำหรับโปรเจกต์จริง
จากการทำงานกับ Pandas ในโปรเจกต์จริงหลายปี เราได้รวบรวมแนวปฏิบัติที่ดีที่สุดที่ควรนำไปใช้:
1. การจัดการประสิทธิภาพ
- ใช้ data types ที่เหมาะสม — แทนที่จะใช้ object สำหรับทุกอย่าง ให้เปลี่ยนเป็น category, int32, float32 เมื่อเป็นไปได้ เพื่อลดการใช้หน่วยความจำ
- หลีกเลี่ยงการใช้ loop — ใช้ vectorized operations (เช่น
df['col'].apply()หรือ numpy functions) แทนการวนลูปแถวต่อแถว - ใช้ inplace=True อย่างระมัดระวัง — ใน Pandas 3.x การใช้ inplace=True ถูก deprecate แล้ว ให้ใช้การ assign กลับไปที่ตัวแปรแทน
- เลือก chunk size ที่เหมาะสม — เมื่ออ่านไฟล์ขนาดใหญ่ ให้ใช้
pd.read_csv(chunksize=10000)เพื่อประมวลผลทีละส่วน
2. การจัดการข้อมูลที่สะอาด
- ตรวจสอบข้อมูลเสมอ — ใช้
df.info(),df.describe(),df.isnull().sum()เพื่อทำความเข้าใจข้อมูลก่อนเริ่มวิเคราะห์ - สร้าง pipeline การทำความสะอาดข้อมูล — เขียนฟังก์ชันที่สามารถ reuse ได้ เช่น
def clean_data(df): ... - บันทึกการเปลี่ยนแปลง — ใช้ version control สำหรับข้อมูล (เช่น DVC) หรืออย่างน้อยบันทึก log การเปลี่ยนแปลง
- ใช้ validation — ตรวจสอบความถูกต้องของข้อมูลหลังการแปลง เช่น ตรวจสอบว่าคอลัมน์ตัวเลขไม่มี string ปน
3. การทำงานร่วมกับทีม
- ใช้ consistent naming convention — ตั้งชื่อคอลัมน์และ DataFrame ให้สื่อความหมาย ใช้ snake_case สำหรับ Python
- เขียน docstring และ comment — อธิบาย logic ที่ซับซ้อน โดยเฉพาะการ transform ข้อมูล
- ใช้ type hints — ระบุชนิดข้อมูลของพารามิเตอร์ในฟังก์ชันเพื่อให้ IDE ช่วยตรวจสอบ
- สร้าง unit tests — ทดสอบฟังก์ชันการจัดการข้อมูลกับข้อมูลตัวอย่างเล็กๆ ก่อนนำไปใช้จริง
4. การจัดการข้อผิดพลาดทั่วไป
# ตัวอย่างการใช้ try-except กับ pandas operations
def safe_read_csv(filepath):
"""อ่านไฟล์ CSV พร้อมจัดการข้อผิดพลาด"""
try:
df = pd.read_csv(filepath, encoding='utf-8')
return df
except FileNotFoundError:
print(f"ไม่พบไฟล์: {filepath}")
return pd.DataFrame()
except UnicodeDecodeError:
# ลองใช้ encoding อื่น
df = pd.read_csv(filepath, encoding='latin1')
return df
except Exception as e:
print(f"เกิดข้อผิดพลาด: {e}")
return pd.DataFrame()
# การจัดการกับ SettingWithCopyWarning
# ไม่ดี:
filtered = df[df['แผนก'] == 'IT']
filtered['โบนัส'] = filtered['เงินเดือน'] * 0.1 # อาจเกิด warning
# ดี:
filtered = df[df['แผนก'] == 'IT'].copy()
filtered['โบนัส'] = filtered['เงินเดือน'] * 0.1 # safeกรณีการใช้งานจริง (Real-World Use Cases)
มาดูตัวอย่างการประยุกต์ใช้ Pandas ในสถานการณ์จริงที่พบบ่อยในธุรกิจ:
Use Case 1: การวิเคราะห์ยอดขายร้านค้าปลีก
ร้านค้าปลีกแห่งหนึ่งต้องการวิเคราะห์ยอดขายประจำวันเพื่อวางแผนสต็อกสินค้า ข้อมูลประกอบด้วยวันที่ขาย ประเภทสินค้า จำนวนที่ขาย และราคา
# โหลดข้อมูลการขาย
sales = pd.read_csv('sales_2026.csv', parse_dates=['sale_date'])
# 1. คำนวณยอดขายรวมต่อวัน
daily_sales = sales.groupby('sale_date')['amount'].sum().reset_index()
# 2. หาวันที่มียอดขายสูงสุด 10 อันดับ
top_10_days = daily_sales.nlargest(10, 'amount')
# 3. วิเคราะห์ยอดขายตามประเภทสินค้าและวันในสัปดาห์
sales['day_of_week'] = sales['sale_date'].dt.day_name()
category_day = sales.groupby(['category', 'day_of_week'])['amount'].agg(['sum', 'mean', 'count'])
# 4. หาสินค้าที่ขายดีที่สุดในแต่ละประเภท
top_products = sales.groupby('category').apply(
lambda x: x.nlargest(3, 'amount')[['product_name', 'amount']]
).reset_index(drop=True)
# 5. คำนวณค่าเฉลี่ยเคลื่อนที่ 7 วัน เพื่อดูแนวโน้ม
daily_sales['MA_7'] = daily_sales['amount'].rolling(window=7, min_periods=1).mean()
# 6. วิเคราะห์ฤดูกาล
sales['month'] = sales['sale_date'].dt.month
monthly_seasonality = sales.groupby('month')['amount'].sum()
print("ยอดขายรายเดือน:", monthly_seasonality)Use Case 2: การทำความสะอาดข้อมูลลูกค้าสำหรับ CRM
บริษัทแห่งหนึ่งได้รับข้อมูลลูกค้าจากหลายแหล่ง ซึ่งมีปัญหาข้อมูลซ้ำซ้อน ข้อมูลไม่สมบูรณ์ และรูปแบบไม่一致
# โหลดข้อมูลลูกค้าจากหลายแหล่ง
customers_web = pd.read_csv('web_customers.csv')
customers_store = pd.read_csv('store_customers.csv')
customers_partner = pd.read_csv('partner_customers.csv')
# รวมข้อมูลทั้งหมด
all_customers = pd.concat([customers_web, customers_store, customers_partner], ignore_index=True)
# 1. ทำความสะอาดเบอร์โทรศัพท์
def clean_phone(phone):
if pd.isna(phone):
return None
# ลบช่องว่างและขีด
phone = str(phone).replace(' ', '').replace('-', '').replace('(', '').replace(')', '')
# ถ้าขึ้นต้นด้วย 0 ให้เพิ่ม 66
if phone.startswith('0') and len(phone) == 10:
phone = '66' + phone[1:]
return phone
all_customers['phone_clean'] = all_customers['phone'].apply(clean_phone)
# 2. จัดการที่อยู่ให้เป็นมาตรฐาน
def standardize_address(address):
if pd.isna(address):
return None
address = str(address).lower()
replacements = {
'ถ.': 'ถนน',
'ซ.': 'ซอย',
'ต.': 'ตำบล',
'อ.': 'อำเภอ',
'จ.': 'จังหวัด',
'รหัส': ''
}
for old, new in replacements.items():
address = address.replace(old, new)
return address.strip()
all_customers['address_std'] = all_customers['address'].apply(standardize_address)
# 3. หาลูกค้าที่ซ้ำซ้อน (duplicate detection)
# ใช้ email เป็น key หลัก
duplicates = all_customers[all_customers.duplicated(subset=['email'], keep=False)]
# หรือใช้เบอร์โทรศัพท์
duplicates_phone = all_customers[all_customers.duplicated(subset=['phone_clean'], keep=False)]
# 4. รวมข้อมูลลูกค้าที่ซ้ำกัน (deduplication)
def merge_duplicates(group):
"""รวมข้อมูลจากหลายแถวของลูกค้าเดียวกัน"""
return pd.Series({
'name': group['name'].iloc[0], # ใช้ชื่อจากแถวแรก
'email': group['email'].iloc[0],
'phone': group['phone_clean'].iloc[0],
'address': group['address_std'].dropna().iloc[0] if not group['address_std'].dropna().empty else None,
'source': ', '.join(group['source'].unique()),
'first_purchase': group['first_purchase'].min(),
'total_spent': group['total_spent'].sum()
})
# จัดกลุ่มตาม email แล้วรวม
deduped_customers = all_customers.groupby('email').apply(merge_duplicates).reset_index()
# 5. เติมข้อมูลที่ขาดหาย
deduped_customers['address'].fillna('ไม่ระบุ', inplace=True)
deduped_customers['phone'].fillna('ไม่ระบุ', inplace=True)
print(f"จำนวนลูกค้าหลังทำความสะอาด: {len(deduped_customers)}")
print(f"จำนวนลูกค้าที่ซ้ำซ้อนที่ถูกรวม: {len(all_customers) - len(deduped_customers)}")Use Case 3: การวิเคราะห์ข้อมูลการเงินส่วนบุคคล
นักลงทุนรายหนึ่งต้องการวิเคราะห์พอร์ตการลงทุนของตนเอง ซึ่งประกอบด้วยหุ้นหลายตัว และต้องการคำนวณผลตอบแทน ความเสี่ยง และการจัดสรรเงิน
# โหลดข้อมูลราคาหุ้นจาก CSV หลายไฟล์
stocks = {
'PTT': pd.read_csv('PTT.csv', parse_dates=['Date'], index_col='Date'),
'SCB': pd.read_csv('SCB.csv', parse_dates=['Date'], index_col='Date'),
'CPALL': pd.read_csv('CPALL.csv', parse_dates=['Date'], index_col='Date'),
'AOT': pd.read_csv('AOT.csv', parse_dates=['Date'], index_col='Date')
}
# รวมราคาปิดของทุกหุ้นเป็น DataFrame เดียว
prices = pd.DataFrame({ticker: data['Close'] for ticker, data in stocks.items()})
print(prices.head())
# 1. คำนวณผลตอบแทนรายวัน
returns = prices.pct_change().dropna()
# 2. คำนวณผลตอบแทนสะสม
cumulative_returns = (1 + returns).cumprod()
# 3. คำนวณสถิติพื้นฐาน
stats = pd.DataFrame({
'ผลตอบแทนเฉลี่ยต่อวัน': returns.mean(),
'ความเสี่ยง (Std)': returns.std(),
'ผลตอบแทนรายปี': returns.mean() * 252,
'ความเสี่ยงรายปี': returns.std() * np.sqrt(252),
'Sharpe Ratio': (returns.mean() * 252) / (returns.std() * np.sqrt(252)),
'Max Drawdown': returns.cummax().apply(lambda x: (x - x.max()) / x.max()).min()
})
print(stats)
# 4. คำนวณ Correlation Matrix
correlation = returns.corr()
print("Correlation Matrix:")
print(correlation)
# 5. การจัดสรรพอร์ต (Portfolio Allocation)
# สมมติว่ามีเงินลงทุน 1,000,000 บาท
initial_capital = 1000000
allocation = {
'PTT': 0.30,
'SCB': 0.25,
'CPALL': 0.25,
'AOT': 0.20
}
# คำนวณมูลค่าพอร์ตในแต่ละวัน
portfolio_value = pd.DataFrame(index=prices.index)
for ticker, weight in allocation.items():
portfolio_value[ticker] = prices[ticker] / prices[ticker].iloc[0] * weight * initial_capital
portfolio_value['Total'] = portfolio_value.sum(axis=1)
# 6. วิเคราะห์ผลตอบแทนพอร์ต
portfolio_returns = portfolio_value['Total'].pct_change().dropna()
print(f"ผลตอบแทนพอร์ตรวม: {(portfolio_value['Total'].iloc[-1] / initial_capital - 1) * 100:.2f}%")
print(f"Sharpe Ratio ของพอร์ต: {
