---
title: "อ่านโค้ด Python ที่ AI เขียนให้ออก: 12 จุดที่คน Excel ต้องรู้"
url: https://www.thepexcel.com/python-pandas-for-excel-users/
type: post
date: 2026-05-31
author: Sira Ekabut
categories: [Python in Excel, "AI & Automation", Programming]
---

# อ่านโค้ด Python ที่ AI เขียนให้ออก: 12 จุดที่คน Excel ต้องรู้

# อ่านโค้ด Python ที่ AI เขียนให้ออก: 12 จุดที่คน Excel ต้องรู้

  

ทุกวันนี้พอบอก ChatGPT หรือ Claude ว่า “ช่วยสรุปยอดขายแยกตามเมืองให้หน่อย” มันก็พ่นโค้ด Python กลับมาให้กองนึง หรือถ้าใช้ Python in Excel ก็จะเจอโค้ดหน้าตาประมาณนี้

 

```python
import pandas as pd

df = pd.read_excel('sales.xlsx')
df = df[df['sales'] > 1000]
summary = df.groupby('city')['sales'].sum().reset_index()
summary['sales_with_vat'] = summary['sales'] * 1.07
summary.to_excel('summary.xlsx', index=False)
```

 

เปิดมาเจอโค้ดแบบนี้แล้วอยากปิดหนีใช่มั้ยครับ? ผมเข้าใจเลย ตอนแรกผมก็มองว่ามันเป็นภาษาต่างดาว แต่พอตั้งสติดูดีๆ จริงๆ มันก็แค่ทำงานที่พี่ๆ ทำใน Excel กันทุกวันนี่แหละ เปิดไฟล์, กรองแถว, จัดกลุ่มหาผลรวม, เพิ่มคอลัมน์ VAT, แล้วเซฟกลับ จบ

 

ผมเลยอยากชวนคุยเรื่องนี้แบบคนเล่นกับ Excel มาด้วยกัน ขอย้ำตรงนี้ก่อน **บทความนี้ไม่ได้สอนให้คุณเขียน Python เป็น** ผมไม่ได้จะสอนติดตั้ง Python ไม่ได้จะสอน set up อะไรทั้งนั้น เป้าหมายเดียวคือ “อ่านออก” คือพอ AI เขียนโค้ดมาให้ คุณดูแล้วรู้ว่ามันกำลังทำอะไรอยู่ จะได้ตรวจได้ว่ามันทำถูกมั้ย หรือบอกมันให้แก้ตรงไหนได้

 

สัญญาเลยครับ จบบทความนี้ คุณจะกลับมาอ่านโค้ด 7 บรรทัดข้างบนนี้ออกทุกบรรทัด เดี๋ยวพอถึงช่วงท้าย ผมจะพากลับมาแกะให้ดูทีละบรรทัดเลยว่าแต่ละบรรทัดแปลว่าอะไร

 

แต่ก่อนจะไปถึงตรงนั้น ขอวาง “แว่น” ให้ก่อน 3 อัน

 

---

 

## กฎ 3 ข้อก่อนเริ่ม

 

โค้ด pandas (ตัวที่ AI ชอบใช้จัดการตารางข้อมูล) มันดูยุ่บยั่บก็จริง แต่ 90% ของความงงมาจากการไม่รู้ “ไวยากรณ์พื้นฐาน” แค่ 3 ข้อนี้ พอจำได้ปุ๊บ โค้ดที่เคยดูเป็นภาษาต่างดาวจะเริ่มอ่านออกทันที

 

ก่อนอื่นขอเคลียร์คำที่จะเจอบ่อยสุดในโค้ดทุกบรรทัดก่อน นั่นคือ `df` ครับ มันคือชื่อที่ตั้งให้กับ “ทั้งตาราง” (ย่อมาจาก dataframe) เห็น `df` เมื่อไหร่ให้นึกถึงทั้งชีต Excel ทั้งหน้าได้เลย และอีกอย่างที่ต้องรู้คือ ชื่อที่อยู่ฝั่งซ้ายของ `=` (เช่น `df`, `summary`, `total`) คือ “ถังที่ติดป้ายชื่อไว้” เอาไว้เก็บผลลัพธ์ พอเห็นชื่อนี้ทีหลังก็คือกำลังหยิบของในถังนั้นมาใช้ต่อ

 

| กฎ | เห็นแบบนี้ | แปลว่า |
| --- | --- | --- |
| **(ก) จุดนำหน้าชื่อย่อ** | `pd.` / `np.` | `pd` คือชื่อย่อของกล่องเครื่องมือ pandas, `np` คือ numpy เห็น `pd.` นำหน้า = กำลังไปหยิบเครื่องมือออกมาจากกล่องนั้น เช่น `pd.read_excel(...)` = “เอาเครื่องมือ read_excel จากกล่อง pandas มาใช้” |
| **(ข) วงเล็บเหลี่ยม vs วงเล็บโค้ง** | `[ ]` กับ `( )` | เหลี่ยม `[ ]` = หยิบของ / เลือก / ชี้ตำแหน่ง · โค้ง `( )` = สั่งทำงาน (เรียกฟังก์ชัน มักมีของใส่ข้างใน) เทียบกัน: `df['sales']` = ชี้ไปที่คอลัมน์ sales · `df.sum()` = สั่งให้รวมยอด |
| **(ค) จุดต่อกันเป็นสายพาน** | `.groupby(...).sum().reset_index()` | จุด `.` หลายตัวต่อกัน = ทำงานทีละสเต็ปต่อเนื่องบนสายพาน อ่านจากซ้ายไปขวา: จัดกลุ่ม → รวมยอด → จัดตารางคืน |

 

กฎ 3 ข้อนี้แหละครับคือ “แว่น” ของเรา ใส่แว่นนี้แล้ว ส่วนถัดไปคือการเอาแว่นไปส่อง 12 จุดที่เจอบ่อยที่สุด พอจับ 12 จุดนี้ได้ โค้ด AI ส่วนใหญ่จะอ่านออก

 

---

 

## 12 จุดที่เจอบ่อย : เห็นแบบนี้ แปลว่าอะไร

 

แต่ละจุดผมจะเล่า 4 อย่างเสมอ: โค้ดตัวอย่าง → แปลว่าอะไร → เทียบกับ Excel → ถ้าอยากเจาะลึกตัวไหนไปดูที่ไหนต่อ พร้อมแล้วเริ่มเลย

 

### Pattern 1 : alias import (ตั้งชื่อย่อ)

 

```python
import pandas as pd
import numpy as np
```

 

**แปลว่า** `import` คือการเรียกกล่องเครื่องมือเข้ามาใช้ ส่วน `as pd` คือ “ตั้งชื่อเล่นให้มันว่า pd จะได้พิมพ์สั้นๆ” พอตั้งชื่อเล่นแล้ว ที่เหลือทั้งโค้ดถึงได้เห็น `pd.` กับ `np.` นำหน้าตลอด (เชื่อมกับกฎข้อ ก. เป๊ะ) เกือบทุกโค้ด pandas จะขึ้นด้วย 2 บรรทัดนี้

 

**เทียบ Excel** เหมือนการตั้ง Named Range ให้ช่วงที่ใช้บ่อย จะได้เรียกด้วยชื่อสั้นๆ แทนที่จะพิมพ์เต็มทุกครั้ง หรือนึกถึงตอนเปิด Power Query / Power Pivot ก่อนเริ่มทำงาน ต้อง “เปิดเครื่องมือ” ก่อนถึงจะใช้ได้

 

อยากเจาะลึกเครื่องมือยอดฮิตในกล่องเหล่านี้ ดูที่ [read_csv](/functions/python/io/pandas-read-csv/) และ [array](/functions/python/creation/numpy-array/)

 

### Pattern 2 : เลือกคอลัมน์

 

```python
df['sales']
df[['name', 'sales']]
```

 

**แปลว่า** `df['sales']` คือหยิบคอลัมน์ชื่อ `sales` ออกมา 1 คอลัมน์ (pandas เรียกว่า Series) ส่วน `df[['name', 'sales']]` ที่มีวงเล็บเหลี่ยมซ้อนกัน 2 ชั้น คือหยิบหลายคอลัมน์ออกมาเป็นตารางย่อย สังเกตว่าชื่อคอลัมน์อยู่ในเครื่องหมายคำพูดเสมอ

 

**เทียบ Excel** ก็คือการเลือก column นั่นแหละ คลิกหัวคอลัมน์ A เลือกอันเดียว = `df['sales']` · กด Ctrl ค้างแล้วเลือกหลายคอลัมน์ = `df[['name', 'sales']]`

 

อยากเจาะลึกการเลือกแบบชี้ตำแหน่งแถว/คอลัมน์ ดูที่หน้า [loc](/functions/python/selection/pandas-loc/) กับ [iloc](/functions/python/selection/pandas-iloc/)

 

### Pattern 3 : กรองแถว (boolean mask)

 

```python
df[df['sales'] > 1000]
```

 

**แปลว่า** ข้างในตรง `df['sales'] > 1000` คือการถามทีละแถวว่า “ยอดขายเกิน 1000 มั้ย” ได้คำตอบเป็น จริง/เท็จ ทุกแถว แล้ว `df[...]` ที่ครอบอยู่ก็เก็บเฉพาะแถวที่ตอบว่า “จริง” ไว้ เขาเรียกเทคนิคนี้ว่า boolean mask หรือพูดง่ายๆ คือ “เอาเงื่อนไขมาเป็นตะแกรงร่อนแถว”

 

**เทียบ Excel** ตรงกับการกด Filter แล้วตั้งเงื่อนไข “มากกว่า 1000” เป๊ะๆ เหลือไว้แต่แถวที่ผ่านเงื่อนไข แต่มีจุดต่างที่ต้องระวังมากๆ ครับ ถ้าโค้ดเขียนเป็น `df = df[...]` (เอาผลกรองทับชื่อ df เดิม) อันนี้ไม่เหมือน Filter ใน Excel ที่แค่ “ซ่อน” แถวไว้แล้วกดเอาคืนได้ แต่ pandas จะ “เขียนทับ” df ของเดิมไปเลย แถวที่ถูกกรองออกหายถาวรตลอดทั้งสคริปต์ที่เหลือ ถ้าอยากได้แถวพวกนั้นคืนต้องไปโหลดไฟล์หรือสร้าง df ขึ้นมาใหม่

 

อยากเจาะลึกการกรองแบบเขียนเงื่อนไขเป็นข้อความ ดูที่ [query](/functions/python/selection/pandas-query/) และ [loc](/functions/python/selection/pandas-loc/)

 

### Pattern 4 : สร้าง / แก้คอลัมน์

 

```python
df['tax'] = df['sales'] * 0.07
```

 

**แปลว่า** ฝั่งซ้ายของ `=` คือคอลัมน์ใหม่ชื่อ `tax` (ถ้ายังไม่มีก็สร้างให้ ถ้ามีอยู่แล้วก็เขียนทับ) ฝั่งขวาคือสูตร เอาทั้งคอลัมน์ `sales` มาคูณ 0.07 pandas คิดให้ทุกแถวพร้อมกันในบรรทัดเดียว ไม่ต้องวนทีละแถว

 

**เทียบ Excel** เหมือนคุณไปที่คอลัมน์ว่างข้างๆ พิมพ์ `=A2*0.07` แล้วลากสูตรลงทั้งคอลัมน์ ต่างกันแค่ pandas ทำให้ทั้งคอลัมน์รวดเดียวโดยไม่ต้องลาก

 

ตรงนี้แหละครับที่อยากให้สังเกตให้ดี ลองเทียบ 2 บรรทัดนี้ `df['sales']  0.07` กับ `df['sales']  1.07` ตัวคูณต่างกันนิดเดียวแต่ความหมายคนละเรื่องเลย ` 0.07` คือได้ “ภาษีล้วนๆ” (7% ของยอด) ส่วน ` 1.07` คือได้ “ราคารวมภาษีแล้ว” (ยอดเต็ม + อีก 7%) ตัวคูณต่าง = ความหมายต่าง นี่แหละครับคือสิ่งที่ต้องอ่านโค้ด AI ให้ออก เพราะ AI มันคูณเลขให้ก็จริง แต่มันคูณถูกตัวมั้ย คูณ 0.07 หรือ 1.07 ตรงกับที่เราต้องการรึเปล่า อันนี้คนตรวจต้องดูเอง ตรงกับเป้าหมายของบทความเป๊ะ ว่าอ่านออกเพื่อ “ตรวจได้ว่ามันทำถูกมั้ย”

 

อยากเจาะลึกการเอาฟังก์ชันมาใส่แต่ละค่า หรือเปลี่ยนชนิดข้อมูล ดูที่ [apply](/functions/python/transform/pandas-apply/) และ [astype](/functions/python/transform/pandas-astype/)

 

### Pattern 5 : method chaining (สายพาน)

 

```python
df.groupby('city')['sales'].sum().reset_index()
```

 

**แปลว่า** นี่คือหัวใจของการอ่านสายพาน (กฎข้อ ค) อ่านซ้ายไปขวาเป็นสายพานทีละสเต็ป: `groupby('city')` จัดกลุ่มตามเมือง → `['sales']` หยิบเฉพาะคอลัมน์ยอดขาย → `.sum()` รวมยอดในแต่ละกลุ่ม → `.reset_index()` ตรงตัวสุดท้ายนี้ไม่ใช่แค่จัดให้สวย แต่หลังจาก `groupby` แล้ว ตัวที่ใช้จัดกลุ่ม (เมือง) มันจะไปกลายเป็น “ดัชนี” (index) ตัวพิเศษ ไม่ใช่คอลัมน์ธรรมดา `.reset_index()` ทำหน้าที่ดึงเมืองกลับมาเป็นคอลัมน์ปกติ ตารางจะได้กลับมาหน้าตาเหมือนตารางทั่วไปที่เราเอาไปใช้ต่อได้ พูดอีกแบบ คือ “จัดกลุ่ม แล้วรวมยอด แล้วทำให้กลับมาเป็นตารางปกติ”

 

**เทียบ Excel** นี่คือ PivotTable ดีๆ นี่เอง ลากเมืองไปช่อง Rows ลากยอดขายไปช่อง Values ตั้งเป็น Sum ผลที่ได้เหมือนกันเป๊ะ

 

อยากเจาะลึกการจัดกลุ่มและจัดตารางคืน ดูที่ [groupby](/functions/python/aggregation/pandas-groupby/) และ [reset_index](/functions/python/transform/pandas-reset-index/)

 

### Pattern 6 : ⭐ ตัวดำเนินการของ pandas (`&` `|` `~`) จุดที่คน Excel พลาดบ่อยที่สุด

 

ตรงนี้คือจุดที่ผมอยากให้ทุกคนหยุดอ่านช้าๆ เพราะเป็นจุดที่คน Excel งงมากที่สุด และเป็นจุดที่ทำให้ผลลัพธ์เพี้ยนแบบไม่รู้ตัวบ่อยที่สุดด้วย

 

```python
df[(df['sales'] > 1000) & (df['city'] == 'Bangkok')]
```

 

**แปลว่า** เวลาจะกรองด้วยเงื่อนไขหลายข้อพร้อมกัน pandas **ไม่ใช้** คำว่า `and` / `or` / `not` แบบที่เราคุ้น แต่ใช้สัญลักษณ์แทน:

 

– `&` = และ (AND) เงื่อนไขต้องจริงทั้งคู่

 

– `|` = หรือ (OR) เงื่อนไขจริงข้อใดข้อหนึ่งก็พอ

 

– `~` = ไม่ (NOT) กลับเงื่อนไขเป็นตรงข้าม

 

และที่สำคัญสุดๆ คือ **เวลามีหลายเงื่อนไขต่อกันด้วย `&` หรือ `|` แต่ละเงื่อนไขต้องมีวงเล็บโค้งคร่อมไว้เสมอ** ถ้าไม่ใส่วงเล็บ มันจะอ่านโจทย์ผิด คือจับคู่เงื่อนไขสลับกันมั่วไปหมด ได้คำตอบที่ไม่ใช่สิ่งที่เราตั้งใจ (เหตุผลทางเทคนิคคือ `&` มีลำดับการคำนวณมาก่อนเครื่องหมายเปรียบเทียบอย่าง `>` `==` แต่ตรงนี้ไม่ต้องจำก็ได้ จำแค่ว่า “ขาดวงเล็บ = อ่านโจทย์ผิด” พอ)

 

ที่น่ากลัวคือ การลืมวงเล็บนี้ บางทีมันก็ฟ้อง error เด้งขึ้นมาเลย (เห็นชัดว่าผิด) แต่บางกรณีมันดันคำนวณออกมาได้ปกติเฉยเลย เพียงแต่ได้ตัวเลขที่ผิด แบบที่เราไม่รู้ตัวว่าผิด อันหลังนี่แหละครับที่อันตรายสุด เพราะถ้าเอาไปส่งงานต่อโดยไม่ทันสังเกต ก็พังเงียบๆ นี่คือเหตุผลที่ผมให้ดาวจุดนี้

 

ลองดูแบบผิด vs แบบถูก:

 

```python
# ❌ ผิด ไม่มีวงเล็บคร่อมแต่ละเงื่อนไข
# บางทีฟ้อง error เด้งขึ้นมา บางทีก็เงียบๆ ได้ผลลัพธ์ผิดแบบไม่รู้ตัว
df[df['sales'] > 1000 & df['city'] == 'Bangkok']

# ✅ ถูก มีวงเล็บคร่อมทุกเงื่อนไข
df[(df['sales'] > 1000) & (df['city'] == 'Bangkok')]
```

 

อีกตัวที่เจอบ่อยคือ `.isin([...])` ใช้เช็คว่า “ค่าอยู่ในรายการนี้มั้ย” และ `~` ไว้กลับด้านเป็น “ไม่อยู่ในรายการ”:

 

```python
df[df['city'].isin(['Bangkok', 'Chiang Mai'])]      # เอาเฉพาะ 2 เมืองนี้
df[~df['city'].isin(['Bangkok', 'Chiang Mai'])]     # เอาทุกเมืองยกเว้น 2 เมืองนี้
```

 

สังเกตว่าตรงนี้มีเงื่อนไขเดียว เลยไม่ต้องมีวงเล็บโค้งคร่อม (กติกาวงเล็บที่ย้ำไปข้างบนใช้ตอนมีหลายเงื่อนไขต่อกันด้วย `&` หรือ `|` เท่านั้น เงื่อนไขเดียวโดดๆ แบบ `~...isin()` นี้ใส่ `~` นำหน้าได้เลย)

 

**เทียบ Excel** ใน Excel เราชินกับ `AND(A2>1000, B2="Bangkok")` หรือ `OR(...)` ใช่มั้ยครับ แต่ pandas สลับมาใช้สัญลักษณ์ `&` `|` `~` แทน และเพิ่มกติกาวงเล็บเข้ามา ตรงนี้แหละที่ดักคนเก่ง Excel มานักต่อนัก เพราะพอเขียนเป็น `and` ตามสัญชาตญาณปุ๊บ มันก็ฟ้อง error ทันที ส่วน `.isin([...])` ก็เทียบได้กับการกรองแบบเลือกหลายค่าใน Filter dropdown ของ Excel นั่นเอง

 

**เคล็ดอ่านโค้ดง่ายๆ:** เห็น `&` `|` `~` ในวงเล็บเหลี่ยมของ `df[...]` เมื่อไหร่ ให้รู้ทันทีว่า “นี่คือกำลังกรองหลายเงื่อนไข” แล้วไล่อ่านทีละวงเล็บโค้ง แต่ละวงเล็บคือ 1 เงื่อนไข

 

อยากเจาะลึกการเขียนเงื่อนไขหลายข้อแบบอ่านง่ายขึ้น ดูที่ [query](/functions/python/selection/pandas-query/) (เขียนเป็นข้อความได้ เช่น `df.query("sales > 1000 and city == 'Bangkok'")` ในโหมดนี้ใช้ `and` ได้ ไม่ต้องใส่วงเล็บแบบข้างบน)

 

### Pattern 7 : lambda

 

```python
df['sales'].apply(lambda x: x * 1.07)
```

 

**แปลว่า** `lambda x: x * 1.07` คือฟังก์ชันใช้แล้วทิ้งสั้นๆ บรรทัดเดียว อ่านว่า “เอาแต่ละค่า (เรียกมันว่า x) ไปคูณ 1.07” แล้ว `.apply(...)` ก็เอาฟังก์ชันนี้ไปวิ่งใส่ทุกค่าในคอลัมน์ พูดง่ายๆ คือ “เอาทุกค่าไปผ่านสูตรนี้”

 

**เทียบ Excel** เหมือนการเขียนสูตรในเซลล์แล้วลากลงทั้งคอลัมน์ ตรง `x` ก็คือ “ค่าในเซลล์ปัจจุบัน” นั่นเอง แค่ pandas ให้คุณเขียนสูตรนั้นเป็นฟังก์ชันเล็กๆ แทน

 

จุดสังเกตเล็กๆ ที่ทำให้อ่านโค้ดเก่งขึ้น ถ้าเห็นคูณ/บวกตรงๆ อย่าง `df['sales'] * 0.07` แบบใน Pattern 4 = pandas คิดทั้งคอลัมน์รวดเดียว แต่ถ้าเห็น `.apply(lambda...)` = มันวิ่งทีละค่า (ช้ากว่าหน่อย แต่แลกมากับการทำของซับซ้อนกว่าได้)

 

อยากเจาะลึกการเอาฟังก์ชันมาวิ่งใส่แต่ละค่า ดูที่ [apply](/functions/python/transform/pandas-apply/)

 

### Pattern 8 : list comprehension

 

```python
[x * 2 for x in nums]
```

 

**แปลว่า** อ่านว่า “เอาแต่ละตัว (x) ในกอง nums มาคูณ 2 แล้วเก็บผลลัพธ์เป็น list ใหม่” มันคือวิธีสร้าง list แบบย่อในบรรทัดเดียว เห็นรูปแบบ `[... for ... in ...]` เมื่อไหร่ให้รู้เลยว่ากำลังวนสร้างของใหม่จากของเดิม

 

**เทียบ Excel** ก็คือการลากสูตรลงทั้งคอลัมน์อีกนั่นแหละ ของเดิมอยู่คอลัมน์ A สูตร `=A2*2` ลากลง ได้คอลัมน์ผลลัพธ์ใหม่ list comprehension ทำเรื่องเดียวกันแต่เขียนรวบในบรรทัดเดียว

 

ถ้าเจอแบบนี้บนข้อมูลตัวเลขเยอะๆ มักจับคู่กับ numpy array (ดู [array](/functions/python/creation/numpy-array/))

 

### Pattern 9 : f-string

 

```python
f"ยอดรวม {total:,.0f} บาท"
```

 

**แปลว่า** เห็นตัว `f` นำหน้าเครื่องหมายคำพูดเมื่อไหร่ แปลว่าเป็นข้อความที่แทรกค่าตัวแปรเข้าไปได้ ตรง `{total}` คือเอาค่าจากตัวแปร `total` มาเสียบ ส่วน `:,.0f` คือจัดรูปแบบ ใส่ comma คั่นหลักพัน และไม่เอาทศนิยม ผลที่ได้เช่น `ยอดรวม 1,250,000 บาท`

 

**เทียบ Excel** เหมือนการต่อข้อความด้วย `="ยอด "&A1` หรือใช้ `TEXT()` จัดรูปแบบตัวเลข เช่น `=TEXT(A1,"#,##0")` ตรง `:,.0f` ก็คือบทบาทเดียวกับ format code ใน `TEXT()` นั่นแหละ

 

### Pattern 10 : slicing (ตัดช่วง)

 

```python
df[0:5]
arr[-1]
lst[::2]
```

 

**แปลว่า** slicing คือการตัดเอาช่วงข้อมูลด้วยเลขตำแหน่งในวงเล็บเหลี่ยม `df[0:5]` = เอา 5 แถวแรก (เริ่มนับจาก 0) · `arr[-1]` = เลขติดลบนับจากท้าย ดังนั้น -1 คือตัวสุดท้าย · `lst[::2]` = เว้นทีละตัว เอาตัวเว้นตัว

 

**เทียบ Excel** `df[0:5]` ก็เหมือนเลือกแถว 1-5 ดูข้อมูลตัวอย่าง · `arr[-1]` เหมือนกระโดดไปแถวล่างสุด (Ctrl+↓) เอาค่าสุดท้าย ระวังนิดเดียว: Python เริ่มนับที่ 0 ไม่ใช่ 1 และช่วง `0:5` จะได้ตำแหน่ง 0,1,2,3,4 (ไม่รวม 5)

 

อยากเจาะลึกการดึงแถวบนๆ มาดู หรือเลือกด้วยตำแหน่ง ดูที่ [head](/functions/python/inspection/pandas-head/) และ [iloc](/functions/python/selection/pandas-iloc/)

 

### Pattern 11 : dict / list literal (ก้อนข้อมูลดิบ)

 

```python
{'name': ['A', 'B'], 'sales': [10, 20]}
```

 

**แปลว่า** ปีกกา `{ }` ที่มีรูปแบบ `'ชื่อ': [ค่า]` คือ dictionary หรือก้อนข้อมูลแบบ “ชื่อคอลัมน์ → รายการค่าในคอลัมน์นั้น” อันนี้บอกว่า คอลัมน์ `name` มีค่า A, B และคอลัมน์ `sales` มีค่า 10, 20 มักเจอตอน AI ป้อนข้อมูลดิบเข้าไปสร้างตาราง (DataFrame)

 

**เทียบ Excel** ก็คือการพิมพ์ตารางลงชีตเปล่าด้วยมือนั่นแหละ หัวคอลัมน์ name กับ sales แล้วใต้แต่ละหัวก็ใส่ค่าลงไป dict literal เขียนตารางเล็กๆ แบบนั้นด้วยตัวอักษร

 

อยากเห็นว่าก้อนนี้กลายเป็นตารางได้ยังไง ดูที่ [dataframe](/functions/python/creation/pandas-dataframe/)

 

### Pattern 12 : block (`:` + ย่อหน้า)

 

```python
for row in data:
    print(row)

if total > 1000:
    print("ผ่านเกณฑ์")
```

 

**แปลว่า** เห็นบรรทัดที่ลงท้ายด้วยเครื่องหมาย `:` แล้วบรรทัดถัดไปย่อหน้าเข้าไป = “ของที่ย่อหน้าอยู่ข้างใน คือสิ่งที่จะทำซ้ำหรือทำตามเงื่อนไข” `for ...:` คือวนทำซ้ำทีละตัว · `if ...:` คือทำเฉพาะเมื่อเงื่อนไขจริง อันนี้แค่ดูออกว่า “อ๋อ มันกำลังวน/เช็คเงื่อนไขนะ” ก็พอแล้ว ไม่ต้องเขียนเองได้

 

**เทียบ Excel** `for` ก็เหมือนการลากสูตรลงทุกแถว (ทำซ้ำกับข้อมูลทีละตัว) ส่วน `if` ก็คือฟังก์ชัน `IF()` ที่เราใช้กันประจำ ทำอันนี้ถ้าเงื่อนไขจริง ความต่างคือ pandas ส่วนใหญ่ทำงานทั้งคอลัมน์รวดเดียว เลยเจอ `for` วนทีละแถวน้อยกว่าที่คิด ถ้าเจอก็แค่รู้ว่ามันกำลังวนอยู่

 

---

 

## กลับมาเฉลย snippet เปิด : ทีละบรรทัด

 

ได้เวลาทำตามสัญญาแล้วครับ ผมเอาโค้ด 7 บรรทัดตอนเปิดบทความกลับมา แล้วแกะให้ดูทีละบรรทัดว่าแต่ละบรรทัดแปลว่าอะไร ตรงกับ pattern ไหนที่เพิ่งเรียนไป

 

```python
import pandas as pd

df = pd.read_excel('sales.xlsx')
df = df[df['sales'] > 1000]
summary = df.groupby('city')['sales'].sum().reset_index()
summary['sales_with_vat'] = summary['sales'] * 1.07
summary.to_excel('summary.xlsx', index=False)
```

 

| บรรทัด | อ่านว่า | Pattern |
| --- | --- | --- |
| `import pandas as pd` | เรียกกล่องเครื่องมือ pandas เข้ามา ตั้งชื่อย่อว่า pd | Pattern 1 |
| `df = pd.read_excel('sales.xlsx')` | เปิดไฟล์ `sales.xlsx` แล้วเก็บข้อมูลเป็นตารางชื่อ df | เครื่องมือ read (กฎข้อ ก.) |
| `df = df[df['sales'] > 1000]` | กรองเอาเฉพาะแถวที่ sales เกิน 1000 (เหมือนกด Filter) | Pattern 3 |
| `df.groupby('city')['sales'].sum().reset_index()` | จัดกลุ่มตาม city → รวม sales → จัดเป็นตาราง (เหมือน PivotTable) | Pattern 5 |
| `summary['sales_with_vat'] = summary['sales'] * 1.07` | เพิ่มคอลัมน์ใหม่ sales_with_vat = ยอดขาย × 1.07 (บวก VAT) | Pattern 4 |
| `summary.to_excel('summary.xlsx', index=False)` | เซฟ summary กลับเป็นไฟล์ Excel ชื่อ summary.xlsx | เครื่องมือ write (กฎข้อ ก.) |

 

เห็นมั้ยครับ พอแกะออกมาทีละบรรทัด มันก็คือ flow งานที่เราทำใน Excel กันทุกวัน เปิดไฟล์ → กรอง → ทำ Pivot → เพิ่มคอลัมน์ VAT → เซฟ ตอนเปิดบทความผมสัญญาไว้ว่าจบแล้วคุณจะอ่าน 7 บรรทัดนี้ออก ตอนนี้คุณอ่านออกแล้วครับ 😎

 

---

 

## Cheat Sheet : เห็น X = แปลว่า Y

 

เซฟตารางนี้ไว้เปิดเวลาเจอโค้ดที่อ่านไม่ออก กวาดตาหาสัญลักษณ์ที่เห็น แล้วดูว่ามันแปลว่าอะไร

 

| เห็นสัญลักษณ์ / โค้ด | แปลว่า | เทียบ Excel |
| --- | --- | --- |
| `import pandas as pd` | เรียกกล่องเครื่องมือ ตั้งชื่อย่อ | เปิด Power Query/Pivot ก่อนใช้ |
| `df['sales']` / `df[['a','b']]` | หยิบ 1 คอลัมน์ / หลายคอลัมน์ | เลือก column |
| `df[df['sales'] > 1000]` | กรองแถวตามเงื่อนไข | Filter |
| `df['tax'] = df['sales'] * 0.07` | สร้าง/แก้คอลัมน์จากสูตร | เขียนสูตรคอลัมน์ว่างแล้วลากลง |
| `.groupby(...).sum().reset_index()` | สายพาน: จัดกลุ่ม→รวม→จัดตาราง | PivotTable |
| `(A) & (B)` · `\|` · `~` · `.isin([...])` | **AND/OR/NOT ต้องมีวงเล็บคร่อมทุกเงื่อนไข!** | `AND()` / `OR()` + Filter หลายค่า |
| `.apply(lambda x: x*1.07)` | เอาทุกค่าไปผ่านสูตรสั้นๆ | ลากสูตรลงทั้งคอลัมน์ |
| `[x*2 for x in nums]` | สร้าง list ใหม่จากของเดิม | ลากสูตรลงทั้งคอลัมน์ |
| `f"ยอด {total:,.0f}"` | แทรกค่าตัวแปรลงข้อความ | `="ยอด "&A1` / `TEXT()` |
| `df[0:5]` / `arr[-1]` / `lst[::2]` | ตัดช่วง: 5 ตัวแรก / ตัวสุดท้าย / เว้นตัว | เลือกช่วงแถว / ค่าสุดท้าย |
| `{'name':['A'], 'sales':[10]}` | ก้อนข้อมูลดิบ (คอลัมน์→ค่า) | พิมพ์ตารางลงชีตด้วยมือ |
| `for ...:` / `if ...:` + ย่อหน้า | ทำซ้ำ / ทำตามเงื่อนไข | ลากสูตรลง / `IF()` |

 

---

 

## ปิดท้าย : สะพานไปดูแต่ละตัวลึกๆ

 

12 จุดนี้คือ “กาว” ที่เชื่อมทุก method เข้าด้วยกันครับ พอจับ pattern พวกนี้ได้ โค้ด AI ส่วนใหญ่จะอ่านออกทันที เพราะมันก็วนเวียนอยู่กับ 12 จุดนี้ผสมกันไปมานี่แหละ ที่เหลือก็แค่ชื่อ method ที่เปลี่ยนไปตามงาน

 

แต่ละ method ที่ผมพาดผ่านในบทความนี้ `groupby`, `merge` (รวมตารางแบบ VLOOKUP), `pivot_table`, `apply` ฯลฯ แต่ละตัวมีรายละเอียดของมัน ถ้าอยากเจาะลึกว่าตัวไหนใช้ยังไง รับ argument อะไรบ้าง ผมรวบรวมไว้ในหน้า Python Function Explainer แล้ว เข้าไปดูได้ที่ [คลังฟังก์ชัน Python](/functions/python/)

 

แล้วคุณล่ะครับ เคยเจอโค้ด Python ที่ AI เขียนมาให้แล้วอ่านไม่ออกตรงไหนบ้าง? พิมพ์โค้ดที่งงมา comment ไว้ได้เลย เดี๋ยวมาช่วยกันแกะครับ

---

_Source: [https://www.thepexcel.com/python-pandas-for-excel-users/](https://www.thepexcel.com/python-pandas-for-excel-users/)_