3  พื้นฐาน Python ที่จำเป็นสำหรับนักเศรษฐศาสตร์

Keywords

Python for Economics, Computational Economics, Applied Econometrics, Python สำหรับเศรษฐศาสตร์, เศรษฐศาสตร์คำนวณ, เศรษฐมิติเชิงประยุกต์

3.0.1 Python ในกระบวนการวิเคราะห์เศรษฐศาสตร์

ในบทก่อนหน้า เราได้เห็นว่า นักเศรษฐศาสตร์ยุคใหม่ทำงานผ่านกระบวนการที่เชื่อมโยงกัน ตั้งแต่การจัดการข้อมูล การวิเคราะห์ ไปจนถึงการสร้างรายงานแบบ reproducible

ในกระบวนการนี้ Python มีบทบาทสำคัญในขั้นตอน:

• การจัดการข้อมูล (Data Preparation)

• การวิเคราะห์ (Analysis)

• การสร้างแบบจำลอง (Modeling)

บทนี้จึงไม่ได้มุ่งเน้นการสอน Python ในฐานะ “ภาษาโปรแกรม” เพียงอย่างเดียว แต่เน้นให้เห็นว่า Python สามารถใช้เป็นเครื่องมือในการคิดและวิเคราะห์ทางเศรษฐศาสตร์ได้อย่างไร

ดังนั้น ในบทนี้เราจะมาทำความรู้จักกับ “ไวยากรณ์” (Syntax) และ “โครงสร้างข้อมูล” ของ Python เปรียบเสมือนการเรียนรู้คำศัพท์และไวยากรณ์ก่อนที่เราจะแต่งประโยคทางเศรษฐศาสตร์ที่ซับซ้อนขึ้น

3.1 ตัวแปรและประเภทข้อมูล (Data Types)

ในทางเศรษฐศาสตร์ เราต้องจัดการกับตัวเลขและข้อความหลายประเภท Python แบ่งประเภทหลักๆ ที่เราต้องใช้ดังนี้:

• Integer (int): จำนวนเต็ม เช่น จำนวนแรงงาน (\(L\)), ปริมาณสินค้า (\(Q\))

• Float (float): ทศนิยม เช่น อัตราดอกเบี้ย (\(r\)), ราคาสินค้า (\(P\)), ค่า Elasticity

• String (str): ข้อความ เช่น ชื่อประเทศ, ชื่อตัวแปร, หรือรหัสหลักทรัพย์

# ตัวอย่างการกำหนดตัวแปรทางเศรษฐศาสตร์
country = "Thailand"       # String
gdp_growth = 3.5           # Float
population = 70000000      # Integer
is_developed = False      # Boolean (ค่าทางตรรกศาสตร์ จริงหรือเท็จ)

Noteค่าความจริง (Boolean)

นอกจากตัวเลขและข้อความแล้ว Python ยังมีประเภทข้อมูลที่เรียกว่า “ค่าความจริง” (Boolean) ซึ่งมีเพียง 2 ค่า คือ:

• True (จริง)
• False (เท็จ)

Boolean มักใช้ร่วมกับเงื่อนไข เช่น:

gdp_growth = -1.2
is_recession = gdp_growth < 0

print(is_recession)  # True แปลว่าเศรษฐกิจถดถอย

True

ในบริบทเศรษฐศาสตร์ Boolean ช่วยให้เราสามารถ “ตัดสินใจเชิงเงื่อนไข” ได้ เช่น การตรวจว่าเศรษฐกิจอยู่ในภาวะถดถอยหรือไม่

3.2 โครงสร้างข้อมูล: Lists และ Dictionaries

1. Lists (รายการข้อมูล) ใช้เก็บข้อมูลที่เป็นลำดับต่อเนื่องกัน เช่น ในทางเศรษฐศาสตร์ เรามักทำงานกับข้อมูลอนุกรมเวลา เช่น อัตราเงินเฟ้อในแต่ละเดือน

# รายการอัตราเงินเฟ้อย้อนหลัง 5 เดือน
inflation_rates = [2.1, 2.5, 3.0, 2.8, 2.2]

# การเข้าถึงข้อมูล (Indexing เริ่มจาก 0)
print(f"เดือนแรก: {inflation_rates[0]}") 

เดือนแรก: 2.1

• การเรียกดูข้อมูล (Accessing) ใช้เพื่อดึงค่าเงินเฟ้อของเดือนที่ต้องการมาวิเคราะห์:

# ดึงค่าเงินเฟ้อเดือนแรก (Index 0)
first_month = inflation_rates[0]  # 2.1

# ดึงค่าเงินเฟ้อเดือนล่าสุด (Index -1)
latest_month = inflation_rates[-1] # 2.2

# ดึงข้อมูล 3 เดือนตรงกลาง (Slicing)
middle_period = inflation_rates[1:4] # [2.5, 3.0, 2.8]

• การแก้ไขข้อมูล (Updating) สมมติว่ามีการตรวจสอบข้อมูลใหม่ แล้วพบว่าเดือนที่ 3 (Index 2) มีความคลาดเคลื่อน ต้องการปรับจาก 3.0 เป็น 3.1:

# แก้ไขค่าตำแหน่งที่ 3
inflation_rates[2] = 3.1

print(inflation_rates) 
# ผลลัพธ์: [2.1, 2.5, 3.1, 2.8, 2.2]

[2.1, 2.5, 3.1, 2.8, 2.2]

• การเพิ่มข้อมูลใหม่ (Appending) เมื่อมีข้อมูลเงินเฟ้อเดือนที่ 6 ประกาศออกมา (เช่น 2.4) ให้เพิ่มต่อท้ายเข้าไป:

inflation_rates.append(2.4)

print(inflation_rates)
# ผลลัพธ์: [2.1, 2.5, 3.1, 2.8, 2.2, 2.4]

[2.1, 2.5, 3.1, 2.8, 2.2, 2.4]

• คำสั่งพื้นฐานที่ควรรู้เช่น len() max() sum() เป็นต้น

len(inflation_rates) # ดูว่ามีข้อมูลกี่เดือน

6

max(inflation_rates) # หาอัตราเงินเฟ้อที่สูงที่สุด

3.1

sum(inflation_rates) / len(inflation_rates) # หาค่าเฉลี่ยเงินเฟ้อ

2.5166666666666666

2. Dictionaries (พจนานุกรมข้อมูล) ใช้เก็บข้อมูลในรูปแบบ Key: Value ซึ่งเหมาะมากสำหรับการเก็บ “ข้อมูลพื้นฐานของแต่ละประเทศ” หรือ “พารามิเตอร์ของโมเดล”

# เก็บพารามิเตอร์ของฟังก์ชันการผลิต (Cobb-Douglas)
params = {
    "alpha": 0.3,
    "beta": 0.7,
    "tech_level": 1.5
}
print(f"ค่าความยืดหยุ่นของทุน (Alpha): {params['alpha']}")

ค่าความยืดหยุ่นของทุน (Alpha): 0.3

• การดึงข้อมูลออกมาใช้งาน (Accessing) ใช้การระบุ Key (ในเครื่องหมายคำพูด) ภายในวงเล็บก้ามปู [] เพื่อดึง Value ออกมา:

# ดึงค่าเทคโนโลยี (tech_level) มาคำนวณ
current_tech = params["tech_level"]
print(f"ระดับเทคโนโลยีปัจจุบัน: {current_tech}")

ระดับเทคโนโลยีปัจจุบัน: 1.5

• การแก้ไขข้อมูล (Updating) หากมีการอัปเกรดเทคโนโลยี หรือต้องการเปลี่ยนค่า Alpha สามารถเขียนทับได้ทันที:

# ปรับระดับเทคโนโลยีเพิ่มเป็น 2.0
params["tech_level"] = 2.0

print(params) 
# ผลลัพธ์: {'alpha': 0.3, 'beta': 0.7, 'tech_level': 2.0}

{'alpha': 0.3, 'beta': 0.7, 'tech_level': 2.0}

• การเพิ่มข้อมูลใหม่ (Adding) สมมติว่าต้องการเพิ่มตัวแปรอื่น เช่น labor_growth เข้าไปในโมเดล:

# เพิ่ม Key ใหม่เข้าไปได้เลย
params["labor_growth"] = 0.05

print(params)

{'alpha': 0.3, 'beta': 0.7, 'tech_level': 2.0, 'labor_growth': 0.05}

• การแสดงรายการทั้งหมด (Looping - สำหรับสายวิเคราะห์) ในกรณีที่พารามิเตอร์เยอะมาก สามารถใช้ Loop เพื่อแสดงค่าทั้งหมดได้:

print("--- รายชื่อพารามิเตอร์ในโมเดล ---")
for key, value in params.items():
    print(f"ตัวแปร {key}: {value}")

--- รายชื่อพารามิเตอร์ในโมเดล ---
ตัวแปร alpha: 0.3
ตัวแปร beta: 0.7
ตัวแปร tech_level: 2.0
ตัวแปร labor_growth: 0.05

3.3 การวนซ้ำ (Loops)

เมื่อเรามีข้อมูลหลายค่า เช่น GDP ของหลายประเทศ เราไม่จำเป็นต้องเขียนโค้ดซ้ำหลายครั้ง แต่สามารถใช้ loop เพื่อทำงานซ้ำได้ เช่น

gdp_list = [1000, 2000, 1500]

for gdp in gdp_list:
    print(gdp * 1.05)

1050.0
2100.0
1575.0

ตัวอย่าง: การรวมรายได้ทั้งหมด

incomes = [20000, 30000, 25000]

total_income = 0

for i in incomes:
    total_income += i

print(total_income)

75000

3.3.1 การวนซ้ำด้วย for loop

ในตัวอย่างก่อนหน้า เราได้เห็นการใช้ for loop เบื้องต้นแล้ว ในส่วนนี้เราจะศึกษาการใช้งาน for loop อย่างเป็นระบบมากขึ้น

for loop ใช้สำหรับการทำงานซ้ำกับข้อมูลที่มีหลายค่า (เช่น list) โดยไม่ต้องเขียนโค้ดซ้ำหลายครั้ง

โครงสร้างพื้นฐานของ for loop คือ:

for variable in sequence:
    # code

โดยที่:

• sequence คือชุดข้อมูล เช่น list

• variable คือค่าที่ถูกนำออกมาทีละตัวจาก sequence

ตัวอย่าง:

gdp_list = [1000, 2000, 1500]

for gdp in gdp_list:
    print(gdp)

1000
2000
1500

ในแต่ละรอบของ loop ตัวแปร gdp จะรับค่าทีละตัวจาก gdp_list

Tipตัวอย่างในบริบทเศรษฐศาสตร์

1. เราสามารถใช้ for loop เพื่อคำนวณค่าที่เกี่ยวข้องกับข้อมูลหลายตัว เช่น การคำนวณ GDP หลังจากเติบโต:

gdp_list = [1000, 2000, 1500]

for gdp in gdp_list:
    new_gdp = gdp * 1.05
    print(new_gdp)

1050.0
2100.0
1575.0

ตัวอย่างนี้แสดงการเพิ่มขึ้นของ GDP 5% สำหรับแต่ละประเทศ

2. การสะสมค่า (Accumulation)

for loop ยังสามารถใช้สำหรับการรวมค่า เช่น การหาผลรวมรายได้:

incomes = [20000, 30000, 25000]

total_income = 0

for income in incomes:
    total_income += income

print(total_income)

75000

แนวคิดนี้มีความสำคัญในเศรษฐศาสตร์ เช่น:

• การรวมรายได้ประชาชาติ
• การคำนวณ aggregate variables

Importantแนวคิดสำคัญ

• for loop เป็นเครื่องมือหลักในการจัดการข้อมูลหลายค่า

• ช่วยลดความซ้ำซ้อนของโค้ด

• ใช้บ่อยมากในการวิเคราะห์ข้อมูลเศรษฐกิจ

3.3.2 การใช้ for loop ร่วมกับ range()

ในบางกรณี เราไม่ได้ต้องการวนซ้ำตามค่าที่อยู่ใน list แต่ต้องการวนซ้ำตาม “จำนวนรอบ” เช่น ตามช่วงเวลา (time periods) ใน Python เราสามารถใช้ range() เพื่อสร้างลำดับของตัวเลขได้

โครงสร้าง:

for i in range(n):
    # code

โดย range(n) จะสร้างตัวเลขตั้งแต่ 0 ถึง n-1

ตัวอย่าง:

for i in range(5):
    print(i)

0
1
2
3
4

Noteตัวอย่างในบริบทเศรษฐศาสตร์

การใช้ range() มีประโยชน์มากเมื่อเราต้องทำงานกับ “เวลา” เช่น การจำลองหลายช่วงเวลา (time periods)

for year in range(1, 6):
    print("Year", year)

Year 1
Year 2
Year 3
Year 4
Year 5

ตัวอย่างนี้แสดงช่วงเวลา 5 ปี

การประยุกต์: การเติบโตตามเวลา

เราสามารถใช้ for + range() เพื่อจำลองการเติบโตของตัวแปรทางเศรษฐศาสตร์:

capital = 100

for t in range(5):
    capital = capital * 1.05
    print(capital)

105.0
110.25
115.7625
121.55062500000001
127.62815625000002

ตัวอย่างนี้แสดงการเพิ่มขึ้นของทุนในแต่ละช่วงเวลา

Importantแนวคิดสำคัญ

• range() ใช้สร้าง “ลำดับของตัวเลข”
• เหมาะสำหรับการจำลองตามช่วงเวลา (time index)
• ใช้บ่อยในแบบจำลองเศรษฐศาสตร์ที่มีมิติของเวลา

3.4 การวนซ้ำด้วย while loop

นอกจาก for loop ซึ่งใช้เมื่อเราทราบจำนวนรอบล่วงหน้าแล้ว ในบางกรณีทางเศรษฐศาสตร์ เราไม่ทราบว่ากระบวนการจะสิ้นสุดเมื่อใด แต่ทราบเพียงว่า “จะหยุดเมื่อเงื่อนไขบางอย่างเป็นจริง” ในกรณีนี้ เราใช้ while loop

โครงสร้างพื้นฐาน:

while condition:
    # code

โดยโปรแกรมจะทำงานซ้ำ “ตราบใดที่เงื่อนไขยังเป็นจริง”

3.5 ตัวอย่าง

1 กระบวนการสะสมทุน (capital accumulation)

capital = 100

while capital < 200:
    capital = capital * 1.05
    print(capital)

105.0
110.25
115.7625
121.55062500000001
127.62815625000002
134.00956406250003
140.71004226562505
147.74554437890632
155.13282159785163
162.8894626777442
171.03393581163144
179.58563260221302
188.56491423232367
197.99315994393987
207.89281794113688

ตัวอย่างนี้แสดงการเพิ่มขึ้นของทุน 5% ในแต่ละรอบ จนกระทั่งทุนมีค่ามากกว่าหรือเท่ากับ 200

การตีความเชิงเศรษฐศาสตร์

while loop เหมาะสำหรับแบบจำลองที่มีลักษณะเป็น “พลวัต” (dynamic process) เช่น:

• การเติบโตของทุน (capital accumulation)

• กระบวนการปรับตัวเข้าสู่ดุลยภาพ (convergence)

• การจำลองระบบที่ดำเนินไปจนถึงเงื่อนไขหนึ่ง

ตัวอย่างเชิงแนวคิด:

เศรษฐกิจจะปรับตัวไปเรื่อย ๆ จนกว่าจะถึงระดับที่กำหนด

การเข้าสู่ระดับเป้าหมาย

income = 100

while income < 500:
    income = income + 50

print(income)

500

Warningข้อควรระวัง: Infinite Loop

หากเงื่อนไขไม่เคยเป็นเท็จ โปรแกรมจะทำงานไม่หยุด

x = 1

while x > 0:
    print(x)

ดังนั้นต้องระวังให้เงื่อนไขสามารถ “หยุดได้จริง”

Importantแนวคิดสำคัญ

• while loop ใช้เมื่อ “ไม่ทราบจำนวนรอบล่วงหน้า”
• เหมาะกับแบบจำลองพลวัต (dynamic models)
• ใช้ในการวิเคราะห์การเข้าสู่ดุลยภาพ (convergence)

3.6 การควบคุมเงื่อนไข (Control Flow)

ในการวิเคราะห์ทางเศรษฐศาสตร์ เรามักต้องตัดสินใจตามเงื่อนไข เช่น การกำหนดอัตราภาษีตามรายได้ หรือการตรวจสอบภาวะเศรษฐกิจ ใน Python เราใช้ if-else สำหรับการตัดสินใจ:

income = 50000

if income > 30000:
    tax_rate = 0.2
else:
    tax_rate = 0.1

ตัวอย่างในบริบทเศรษฐศาสตร์:

gdp_growth = -1.2

if gdp_growth < 0:
    print("Recession")
else:
    print("Expansion")

Recession

แนวคิดสำคัญคือ:

• โปรแกรมสามารถ “เลือกทำ” สิ่งต่าง ๆ ตามเงื่อนไข

• ซึ่งเหมือนกับกฏการตัดสินใจในแบบจำลองเศรษฐศาสตร์

3.6.1 การใช้ elif (หลายเงื่อนไข)

ในบางกรณี เราอาจมีมากกว่าสองเงื่อนไข เช่น การกำหนดอัตราภาษีแบบขั้นบันได (progressive tax)

income = 50000

if income < 20000:
    tax_rate = 0.1
elif income < 50000:
    tax_rate = 0.15
else:
    tax_rate = 0.2

elif ช่วยให้เราสามารถตรวจสอบเงื่อนไขหลายกรณีได้อย่างเป็นลำดับ

3.6.2 การใช้เงื่อนไขร่วมกัน (Logical Operators)

เราสามารถรวมหลายเงื่อนไขเข้าด้วยกันได้ โดยใช้:

• and (และ)

• or (หรือ)

• not (ไม่ใช่)

Noteตัวอย่าง:

income = 40000
age = 30

if income > 30000 and age > 25:
    print("Eligible")

Eligible

ตัวอย่างในบริบทเศรษฐศาสตร์:

inflation = 6
unemployment = 4

if inflation > 5 or unemployment > 6:
    print("Policy intervention needed")

Policy intervention needed

3.6.3 การใช้เงื่อนไขซ้อน (Nested if)

เราสามารถเขียน if ซ้อนกันได้ เพื่อจัดการกับเงื่อนไขที่ซับซ้อนมากขึ้น

income = 50000

if income > 30000:
    if income > 70000:
        tax_rate = 0.25
    else:
        tax_rate = 0.2
else:
    tax_rate = 0.1

Importantแนวคิดสำคัญเพิ่มเติม

• elif ใช้เมื่อมีหลายเงื่อนไข

• logical operators ช่วยให้สร้างเงื่อนไขที่ซับซ้อนได้

• control flow เป็นพื้นฐานของการตัดสินใจในแบบจำลองเศรษฐศาสตร์

3.6.4 การใช้ if ร่วมกับ loop

ในทางปฏิบัติ เรามักใช้ if ร่วมกับ loop เพื่อ “คัดกรอง” หรือ “จัดประเภท” ข้อมูล

Noteตัวอย่าง

incomes = [20000, 40000, 15000, 60000]

for income in incomes:
    if income > 30000:
        print("High income")

High income
High income

ตัวอย่างนี้แสดงการตรวจสอบรายได้ของแต่ละหน่วย และเลือกแสดงเฉพาะกลุ่มที่มีรายได้สูง

ตัวอย่างในบริบทเศรษฐศาสตร์

gdp_growth_rates = [2.5, -1.0, 3.2, -0.5]

for growth in gdp_growth_rates:
    if growth < 0:
        print("Recession")
    else:
        print("Expansion")

Expansion
Recession
Expansion
Recession

ตัวอย่างนี้ใช้เพื่อจำแนกภาวะเศรษฐกิจในแต่ละช่วงเวลา

การประยุกต์: การรวมค่าตามเงื่อนไข

เราสามารถใช้ if ใน loop เพื่อรวมเฉพาะค่าที่ตรงเงื่อนไข เช่น การรวมรายได้ของกลุ่มรายได้สูง:

incomes = [20000, 40000, 15000, 60000]

total_high_income = 0

for income in incomes:
    if income > 30000:
        total_high_income += income

print(total_high_income)

100000

Importantแนวคิดสำคัญ

• การใช้ if ใน loop ช่วยให้เราสามารถ “คัดกรองข้อมูล” (filtering)

• ใช้สำหรับการจัดประเภท (classification)

• เป็นพื้นฐานของการวิเคราะห์ข้อมูลเชิงเศรษฐศาสตร์

3.7 Functions (ฟังก์ชันและการประยุกต์ใช้เชิงเศรษฐศาสตร์)

ในทางเศรษฐศาสตร์ แบบจำลอง (model) มักถูกเขียนในรูปของสมการ เช่น ฟังก์ชันอรรถประโยชน์ หรือฟังก์ชันการผลิต ใน Python เราสามารถแปลงแบบจำลองเหล่านี้ให้เป็นฟังก์ชันได้โดยตรง

ดังนั้น ฟังก์ชันใน Python ไม่ได้เป็นเพียงเครื่องมือทางโปรแกรม แต่สามารถใช้แทน “แบบจำลองทางเศรษฐศาสตร์” ได้

1. การสร้างฟังก์ชันคำนวณทางเศรษฐศาสตร์พื้นฐาน แทนที่จะกดเครื่องคิดเลขเพื่อหาค่า Elasticity หรือ Utility เราจะเขียนฟังก์ชันเพื่อรับค่าแปรผันเหล่านั้น

def calculate_utility(x, y, alpha=0.5):
    """
    คำนวณค่าอรรถประโยชน์แบบ Cobb-Douglas
    U(x, y) = x^alpha * y^(1-alpha)
    """
    utility = (x**alpha) * (y**(1-alpha))
    return utility

# การเรียกใช้งาน (ลองเปลี่ยนพารามิเตอร์ alpha เพื่อดูพฤติกรรมผู้บริโภค)
u_val = calculate_utility(x=10, y=20, alpha=0.4)
print(f"ค่าอรรถประโยชน์ที่คำนวณได้: {u_val:.2f}")

ค่าอรรถประโยชน์ที่คำนวณได้: 15.16

2. ฟังก์ชันกับชุดข้อมูล (Integration with Lists) เราสามารถนำฟังก์ชันไปประมวลผลข้อมูลปริมาณมากที่เก็บอยู่ใน Lists ได้อย่างรวดเร็ว

# รายการราคาสินค้าในตะกร้า
prices = [100, 250, 400, 150]

def apply_tax(price_list, tax_rate=0.07):
    """ฟังก์ชันคำนวณราคาสุทธิรวมภาษีสำหรับรายการสินค้าทั้งหมด"""
    final_prices = [p * (1 + tax_rate) for p in price_list]
    return final_prices

total_prices = apply_tax(prices)
print(f"ราคาสุทธิหลังรวมภาษี: {total_prices}")

ราคาสุทธิหลังรวมภาษี: [107.0, 267.5, 428.0, 160.5]

3. การจัดการพารามิเตอร์แบบจำลอง (Integration with Dictionaries) ในระดับสูง เราจะใช้ Dictionaries เก็บโครงสร้างของระบบเศรษฐกิจ แล้วส่งเข้าไปในฟังก์ชันเพียงตัวเดียว

# พารามิเตอร์ของระบบเศรษฐกิจ
economy_settings = {
    "consumption_rate": 0.8,
    "investment": 500,
    "government_spending": 300,
    "net_export": -50
}

def simple_gdp_model(data):
    """GDP = C + I + G + NX (โดยที่ C คืออัตราการบริโภค * รายได้สมมติ)"""
    # สมมติรายได้พื้นฐาน (Y) ที่ 2000
    c = data["consumption_rate"] * 2000 
    gdp = c + data["investment"] + data["government_spending"] + data["net_export"]
    return gdp

print(f"ค่า GDP จากแบบจำลอง: {simple_gdp_model(economy_settings)}")

ค่า GDP จากแบบจำลอง: 2350.0

ตัวอย่าง การรับค่าพารามิเตอร์ทางเศรษฐศาสตร์ ลองสร้างฟังก์ชันสำหรับคำนวณ มูลค่าอนาคต (Future Value: FV) ซึ่งนักศึกษาต้องใช้บ่อยในวิชาคณิตศาสตร์การเงิน:

def calculate_fv(pv, r, n):
    """
    คำนวณมูลค่าอนาคต (Future Value)
    pv: มูลค่าปัจจุบัน (Present Value)
    r: อัตราดอกเบี้ยต่อปี (เช่น 0.05)
    n: จำนวนปี (Years)
    """
    fv = pv * (1 + r)**n
    return fv

# การใช้งาน: ฝากเงิน 10,000 บาท ดอกเบี้ย 3% เป็นเวลา 5 ปี
result = calculate_fv(pv=10000, r=0.03, n=5)
print(f"เงินรวมเมื่อสิ้นสุดปีที่ 5 คือ: {result:,.2f} บาท")

เงินรวมเมื่อสิ้นสุดปีที่ 5 คือ: 11,592.74 บาท

ตัวอย่าง ฟังก์ชันอุปสงค์ (Demand Function) ในการวิเคราะห์เศรษฐศาสตร์จุลภาค เราสามารถเขียนฟังก์ชันเพื่อคำนวณปริมาณเสนอซื้อ (\(Q_d\)) เมื่อกำหนดราคา (\(P\)) และรายได้ (\(I\)) ได้ดังนี้:

def demand_quantity(price, income, price_elasticity=-0.5, income_elasticity=1.2):
    # สมมติแบบจำลองอย่างง่าย (Log-linear form concept)
    # Q = A * P^e * I^n
    base_quantity = 100
    quantity = base_quantity * (price ** price_elasticity) * (income ** income_elasticity)
    return quantity

# ทดลองคำนวณเมื่อราคาสินค้าเพิ่มขึ้น
q_now = demand_quantity(price=100, income=50000)
q_new = demand_quantity(price=120, income=50000)

print(f"ปริมาณซื้อเดิม: {q_now:.2f}")
print(f"ปริมาณซื้อใหม่เมื่อราคาแพงขึ้น: {q_new:.2f}")

ปริมาณซื้อเดิม: 4352752.82
ปริมาณซื้อใหม่เมื่อราคาแพงขึ้น: 3973501.51

3.7.1 ข้อผิดพลาดที่พบบ่อย (Common Errors)

ในการเขียนโปรแกรม เรามักจะพบข้อผิดพลาด (error) ซึ่งเป็นเรื่องปกติ เช่น

จะไม่ทำการแสดงผลลัพธ์ของ code ให้ผู้อ่านทดลองปฏิบัติด้วยตัวเอง

1. IndexError

gdp_list = [1000, 2000]
print(gdp_list[5])  # ไม่มี index นี้

2. KeyError

gdp_dict = {"Thailand": 500}
print(gdp_dict["USA"])  # ไม่มี key นี้

3. TypeError

print("GDP: " + 1000)  # string + int ทำไม่ได้

แนวทางแก้ไข:

• อ่าน error message

• ดูว่าปัญหาเกิดที่บรรทัดไหน

• ตรวจสอบประเภทข้อมูลและ index

การเข้าใจ error เป็นทักษะสำคัญในการเรียนเขียนโปรแกรม

Importantแนวคิดสำคัญ: ฟังก์ชันคือแบบจำลอง

ในเศรษฐศาสตร์ เราสามารถมองว่า:

ฟังก์ชัน = แบบจำลอง (Model)

ตัวอย่าง:

def gdp(C, I, G, X, M):
    return C + I + G + (X - M)

Importantสรุปบท

ในบทนี้ เราได้เรียนรู้พื้นฐานของ Python ผ่านบริบทของเศรษฐศาสตร์ ได้แก่:

• การจัดการข้อมูลด้วย list และ dictionary

• การวนซ้ำและการตัดสินใจด้วย loop และ condition

• การสร้างฟังก์ชันเพื่อแทนแบบจำลอง

แนวคิดสำคัญคือ Python ไม่ได้เป็นเพียงภาษาโปรแกรม แต่เป็นเครื่องมือที่ช่วยให้เราสามารถ:

• จัดการข้อมูล

• วิเคราะห์ปัญหา

• และสร้างแบบจำลองทางเศรษฐศาสตร์

ในบทถัดไป เราจะนำพื้นฐานเหล่านี้ไปใช้กับข้อมูลและการวิเคราะห์จริง

Géron, Aurélien. 2019. Hands-on Machine Learning with Scikit-Learn, Keras, and TensorFlow. 2nd ed. O’Reilly Media.

Greene, William H. 2018. Econometric Analysis. 8th ed. Pearson.

Hamilton, James D. 1994. Time Series Analysis. Princeton University Press.

Hastie, Trevor, Robert Tibshirani, and Jerome Friedman. 2009a. The Elements of Statistical Learning. Springer.

Hastie, Trevor, Robert Tibshirani, and Jerome Friedman. 2009b. The Elements of Statistical Learning: Data Mining, Inference, and Prediction. 2nd ed. Springer.

Hyndman, Rob J., and George Athanasopoulos. 2021. Forecasting: Principles and Practice. 3rd ed.

McKinney, Wes. 2022. Python for Data Analysis. 3rd ed. O’Reilly Media.

Quarto Team. 2024. Quarto Documentation. https://quarto.org.

Stock, James H., and Mark W. Watson. 2020. Introduction to Econometrics. 4th ed. Pearson.

VanderPlas, Jake. 2016. Python Data Science Handbook. O’Reilly Media.

Wickham, Hadley, Mine Cetinkaya-Rundel, and Garrett Grolemund. 2023. R for Data Science. 2nd ed.

Wooldridge, Jeffrey M. 2020. Introductory Econometrics: A Modern Approach. 7th ed. Cengage Learning.

Xie, Yihui, J. J. Allaire, and Garrett Grolemund. 2018. R Markdown: The Definitive Guide. Chapman; Hall/CRC.