มาเขียนไพธอนก ันดีกว่า

ต ้นฉบับจาก howforge

ไพธอน ชือ ่ นีอ้ าจจะไม่คุ ้นสําหรับใครหลายคนในประเทศไทย แต่ไพธอนมีประสิทธิภาพมากกว่าทีท ่ ก

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

สําหรับหัวข ้อตอนนีย
้ ังมีแค่คร่าวๆ

1. แนะนํ าภาษาไพธอน
2. พืน้ ฐาน
3. ตัวแปร
4. คําสัง่ ควบคุม
5. ฟั งก์ชนั่
6. โมดูล
7. อ๊อบเจ็กและคลาส
8. โมดูลมาตรฐาน

้ ็จะเป็ นเกร็ดการใช ้งานทีแ

นอกจากนีก ่ ทรกเข ้าไปเรือ
่ ยๆ

 ไพธอนคืออะไร
 ติดตัง้ ไพธอน
 สวัสดีชาวโลก
 ชนิดข ้อมูลพืน้ ฐาน
 ตัวแปร
 คําสัง่ ควบคุม
 ฟั งก์ชนั่
 อ๊อบเจ็กและคลาส
 ไพธอนคืออะไร

ไพธอน หรือ Python แปลตามพจนานุกรมได ้ตรงตัวว่างูเหลือม แต่ถ ้าดูความหมายเอียงมาทางคอมพิวเตอร์หรือสําหรับโปรแกรมเมอร์แล ้ว ไพธอนคือ

ภาษาสคริปต์แบบอ๊อบเจ็คภาษาหนึง่ ออกแบบและเริม ่ พัฒนาโดย Guido van Rossum ณ ปั จจุบันไพธอนพัฒนาอย่างต่อเนือ ่ งจนถึงรุน
่ 2.5.2 (26 ก.พ.
2551) โดยมีกลุม
่ โปรแกรมเมอร์ทรี่ ่วมกันพัฒนาเป็ นจํานวนมาก อย่างไรก็ตามทุกคนก็ยังเคารพการตัดสินใจของ Guido แม ้ว่าขณะนี้ Guido ได ้ผันตัวเอง
ไปทํางานที่ Google เป็ นทีเ่ รียบร ้อยแล ้วก็ตาม

 Pythonic

Pythonic

วันนีล
้ องมาอธิบายคําว่า Pythonic กันดีกว่า พอดีมค ี นถามทีC
่ odenone แล ้วตอนนั น ้ ก็ตอบแบบสัน ้ ๆ ช่วงนีพ
้ อมีเวลาเลยลองมาศึกษาให ้ถ่องแท ้ดีกว่า ผม
เองก็ไม่รู ้จะอธิบายยังไงเหมือนกัน คล ้ายกับว่า Pythonic เป็ นปรัชญาชนิดหนึง่ เรียบง่าย ตรงไปตรงมา เข ้าใจอย่างไรก็เป็ นแบบนัน ี วามซับซ ้อน บาง
้ ไม่มค
คนก็บอกว่ามันคือ pseudocode ทีท ่ ํางานได ้จริงๆ ผมเคยลองเขียน pseudocode ด ้วย Python มันก็ดส ู ะอาดดี แต่กม็ ห
ี ลายคนไม่ชอบ เพราะไม่มป ี ี กกา {}
หรือ begin end แล ้วไม่สบายใจ เหมือนชีวต ิ ขาดอะไรไป โชคดีทผ ี่ มไม่ใช่คนแรกทีส ่ งสัย มีคนพยายามตอบหลายครัง้ ผมชอบคําอธิบายที่ Python Secret
Weblog มากทีส ่ ด
ุ เพราะมีตัวอย่างชัดเจน อย่างน ้อยก็เห็นแล ้วร ้อง อ๋อ ไม่ต ้องเสียเวลาจินตนาการ

ยกตัวอย่างแรกสุด เอาแบบง่ายๆ พืน้ ๆ

for (i=0; i<mylist_length; i++) {
do_something(mylist[i]);
}

เวลาแปลงเป็ น Python ตรงๆ จะได ้เป็ น

i=0
while i < mylist_length:
do_something(mylist[i])
i += 1

้ ซักนิด ก็ควรจะใช ้ for กับ range() แทน

แต่จริงๆ แล ้วถ ้าจะเขียนแบบ Python ให ้มากขึน
for i in range(mylist_length):
do_something(mylist[i])

อย่างไรก็ตาม for ไม่ควรใช ้ index แต่ควรทํากับข ้อมูลนั น

้ ตรงๆ
for element in mylist:
do_something(element)

จะเห็นว่าแบบสุดท ้ายกระชับและเข ้าใจง่ายทีส

่ ด ่ อกสโคปของ mylist ให ้เปลืองสมอง ไม่ต ้องใช ้ตัวแปร
ุ โอกาสผิดพลาดตํา่ มาก ไม่ต ้องกลัวว่า i จะอยูน
หลายตัว

ลองมาดูตัวอย่างถัดไป ในภาษาทั่วไปเวลาเราต ้องส่งค่ากลับมาหลายค่าก็ต ้องส่งทางพารามิเตอร์

void foo(int *a,float *b) {
*a = 3;
*b = 5.5;
}

เวลาใช ้ก็แบบนี้
int alpha;
int beta;

foo(&alpha,&beta);

ถ ้าเขียนแบบนีเ้ ป๊ ะๆ ใน Python จะได ้แบบนี้

def foo(a,b):
a[0] = 3
b[0] = 5.5

alpha = [0]
beta = [0]
foo(alpha,beta)
alpha = alpha[0]
beta = beta[0]
ทีต
่ ้องทําแบบนีเ้ พราะว่า alpha กับ beta เป็ นตัวแปรทีเ่ ก็บค่าล ้วนๆ เวลาส่งเป็ นพารามิเตอร์จะส่งไปเฉพาะค่า ไม่มพ
ี อยเตอร์ซะด ้วย ถ ้าอยากจะทําตามนั น
้
จริงๆ ก็ต ้องใช ้ลิสต์เข ้ามาช่วยจําลองพอยเตอร์ จากโค ้ดข ้างบนจะเห็นว่ามันเลวร ้ายมาก ไม่มค ี วาม Pythonic เอาซะเลย ลองมาดูแบบนีบ ้ ้าง
def foo():
return 3,5.5

alpha,beta = foo()

เรียบง่าย ชัดเจน ไม่ได ้หมายความว่าภาษาอืน ่ ทําแบบนีไ ้ ม่ได ้ Ruby Perl PHP ทําแบบนีไ้ ด ้หมด ก็อย่างทีบ ่ อกตัง้ แต่ต ้น มันเป็ นปรัชญา Python ไม่ได ้
สนับสนุนให ้ทําแบบนี้ แต่มันทําได ้ และนอกจากนีท ้ ําแล ้วดีด ้วย เขียน Python มากๆ แล ้วจะรู ้สึกว่าวิธค
ี ด
ิ เปลีย
่ นไป กลายเป็ นคิดแบบ Python คนพวกนีจ ้ ะ
กลายเป็ น Pythonian ทุกภาษามีวถ ิ ขี องตนเอง นีค
่ อื วิถข
ี อง Python

่ ๆ มักสนับสนุนให ้ใช ้ accessor เพือ

ลองมาดูตัวอย่างถัดไป ภาษา OOP อืน ่ สร ้าง setter getter สําหรับการอ่านเขียนค่าทีเ่ ก็บในอ๊อบเจ็ก แต่เรือ
่ งพวกนีไ
้ ม่
จําเป็ นใน Python
class A:
def __init__(self,a,b):
self.a = a
self.b = b

o = A('1',2)
print o.a,o.b
o.b = 3
print o.a,o.b

หลายคนสงสัยว่าแล ้วอย่างนีจ ้ ะปลอดภัยรึเปล่า เรือ

่ งความปลอดภัยและความถูกต ้องเป็ นเรือ ่ งของผู ้พัฒนา ถ ้าเขียนโปรแกรมแล ้วไม่รู ้ว่าควรใส่คา่ อะไรลงใน
ตัวแปรไหน ก็คงไม่ดน ี ัก พูดง่ายๆ ก็คอ
ื เขียนโปรแกรมต ้องมีสติ ถ ้าเขียนโปรแกรมแล ้วต ้องพึง่ IDE เพือ ่ ตรวจสอบทุกอย่าง ก็หมายความว่าโปรแกรมทีไ่ ด ้จะ
ถูกบังคับด ้วยความสามารถของ IDE อะไรที่ IDE ทําไม่ได ้ โปรแกรมเราก็ทําไม่ได ้ กลายเป็ นข ้อจํากัดทีไ่ ม่สามารถแก ้ได ้ ในขณะที่ Python อยากให ้
ผู ้พัฒนารู ้ว่ากําลังทําอะไร และทําให ้ดีแม ้ในส่วนเล็กน ้อยด ้วย ตามหลักการของ bottom-up เราสามารถนํ าชิน ้ ส่วนเล็กๆ มาประกอบเป็ นชิน ้ ส่วนใหญ่ๆ ได ้
้ ส่วนเล็กๆ ไม่มป
ถ ้าชิน ี ั ญหา การเอามาประกอบเป็ นชิน ้ ทีใ่ หญ่ขน ้ ส่วนใหญ่ไม่มป
ึ้ ก็ไม่ควรก่อปั ญหา ถ ้าชิน ี ั ญหาชิน้ ส่วนทีใ่ หญ่กว่าก็ไม่ควรมีปัญหา ขอเพียง
ทําตามนีไ้ ม่วา่ โปรแกรมจะใหญ่แค่ไหนก็สามารถเขียนได ้โดยทีไ่ ม่ต ้องพึง่ IDE

ทิง้ ท ้ายเล็กน ้อย ถ ้าอยากใช ้ getter setter ใน Python จริงๆ ก็สามารถทําได ้ในแบบ Python
class A:
def __init__(self,a,b):
self.a = a
self.b = b

def get_a(self):
return self.a
def set_a(self,v):
self.a = v
a = property(get_a,set_a)

def get_b(self):
return self.b
def set_b(self,v):
self.b = v
b = property(,get_b,set_b)

a = A('1',2)
a.a = '2'
a.b = 3
print a.a,a.b

ตอนใช ้เหมือนปกติ เปลีย

่ นแค่ตอนเขียนเท่านั น
้
 ติดตงไพธอน
ั้

ก่อนทีจ
่ ะเริม
่ หัดไพธอนเราก็ต ้องมีไพธอนประจํ ากายเสียก่อนครับ สําหรับคนทีม ่ ล ิ ุกส์อยูใ่ นครอบครองหรือสามารถหามาใช ้ได ้สามารถข ้ามขัน
ี น ้ นี้ ไปเลยเลย
เพราะลินุกส์ทก ่ ล ้ว แต่สําหรับบางคนทีโ่ ชคร ้ายทีใ่ ช ้ FreeBSD ก็ต ้องลงไพธอนด ้วยครับ เพราะไม่ใช่ของปกติทม
ุ ตัวมีไพธอนอยูแ ี งั ้ แต่ลง รวมไปถึงคนทีใ่ ช ้
ี่ ต
วินโดส์ด ้วยเช่นกัน

เนือ
่ งจากไพธอนเป็ นภาษาแบบโอเพ่นซอร์สจึงทําให ้มีไพธอนหลายแบบ หรือจะพูดง่ายๆ ก็คอ
ื หลายยีห
่ ้อนั่นเอง โดยหลักๆ แล ้วมี 2 ยีห
่ ้อทีพ
่ บเห็นมาก
ทีส
่ ดุ ได ้แก่

1. Python by Python.org
2. ActivePython by ActiveState

ิ ส์ ส่วนใหญ่จะใช ้ Python จาก Python.org เพราะมีมาพร ้อมกับระบบปฏิบัตก

ถ ้าเป็ นบนยูนก ิ ารนัน ่ ล ้ว แต่สําหรับวินโดส์ ActivePython จะเหมาะกว่า
้ ๆ อยูแ
เนือ่ งจาก ActivePython จะเพิม ่ โมดูลทีจ่ ําเป็ นสําหรับการเขียนโปรแกรมติดต่อกับวินโดส์ทล ึ ลับซับ ซ ้อนมาให ้ในตัว นั่ นหมายความว่าไม่ต ้องเสียเวลา
ี่ ก
ติดตัง้ เอง และลดปั ญหาทีอ ่ าจเกิดขึน
้ จากความไม่ตรงกันของรุน ่ ได ้

ั่ เดียวกันคือ 2.5 (27 มกราคม 2550)

ณ ปั จจุบันไพธอนจากทัง้ สองค่ายมีเลขเวอร์ชน

การติดตงไพธอนบน
ั้ Mac OS X

มี 2 วิธค
ี อ
ื

1. ใช ้ Disk Image จาก Python.org

2. ่ python
ลงผ่านระบบแพ็กเกจอย่าง Fink แพ็กเกจชือ

สว ัสดีชาวโลก

โปรแกรมแรกทีท ุ คนมักจะเห็น และมักถูกใช ้เป็ นตัวอย่างของภาษาใดๆ ก็คอ

่ ก ื Hello, World! นั่ นเอง สาเหตุก็เพราะทุกภาษาควรสามารถติดต่อกับผู ้ใช ้ไม่
ุ สิง่ ทีพ
ว่าทางใดก็ทางหนึง่ อย่างน ้อยก็ต ้องมีการอินพุต และเอาต์พต ่ น
ื้ ฐานทีส
่ ด
ุ ก็คอ
ื เอาต์พต
ุ นีเ่ อง เพราะบางโปรแกรมไม่ต ้องรับอินพุตก็ได ้

สมมติวา่ ในกรณีทั่วไปทุกคนมีจอมอนิเตอร์ เพราะฉะนัน

้ Hello, World! ก็คอ
ื การพิมพ์ข ้อความออกหน ้าจอตามปกตินั่นเอง
#!/usr/bin/env python

print 'Hello, World!'

เอาละครับ ข ้างบนนีก ่ ็คอ

ื Hello, World! ในแบบไพธอน บรรทัดแรกนั น ้ คนทีเ่ คยเขียนโปรแกรมบนยูนก ื ใช ้บอกว่าสคริปต์นี้
ิ ส์น่าจะรู ้จักกันดี เพราะมันก็คอ
ทํางานด ้วยโปรแกรมใดกันแน่ อย่าลืมนะครับไพธอนเป็ นภาษาสคริปต์ แปลว่าไม่ต ้องคอมไพล์ แต่ก็ไม่ได ้หมายความว่ามันจะเป็ นอินเตอร์พรีเตอร์ด ้วย จริงๆ
แล ้วไพธอนจะคอมไพล์โค ้ดทัง้ หมดให ้อยูใ่ นรูปของโค ้ดทีส ่ ามารถทํางานได ้เสีย ก่อนแล ้วจึงเริม่ ทํางาน การทํางานตรงนีเ้ หมือนภาษาจาวาครับ คนที่
รังเกียจไพธอนเพราะเกีย ่ งว่าเป็ นสคริปต์ เป็ นอินเตอร์พรีเตอร์ ขอให ้ถามตัวเองว่าจาวานั่ นเป็ นยังไง อย่างจาวาเรียกว่าเป็ นคอมไพเลอร์หรืออินเตอร์พรีเตอร์
กันแน่ ทุกคนทีเ่ ขียนจาวาบอกว่าจาวาเป็ นคอมไพเลอร์ทัง้ นั น ้ แหละครับ ซึง่ ในความจริงแล ้วจาวาก็ทําตัวเป็ นทัง้ คอมไพเลอร์และอินเตอร์พรีเตอร์ในตัว เดียว
เหมือนไพธอนนีเ่ อง เวอชวลแมชชีนของจาวานีแ ่ หละครับอินเตอร์พรีเตอร์ของแท ้ อย่ากระนัน ้ เลยเดีย๋ วจะหาว่าผมเหยียดภาษา แม ้แต่ดอทเน็ ตก็ใช ้หลักการ
เดียวกันนีจ
้ นชาชิน

กลับมาที่ Hello, World! กันต่อ คําสั่งทีใ่ ช ้ในนีม ี ําสัง่ เดียวคือ print คําสัง่ นีเ้ ป็ นคําสั่งพิเศษ ไม่เชิงเป็ นฟั งก์ชน
้ ค ั่ หรือในอีกมุมนึงมันเป็ นฟั งก์ชน
ั่ ทีอ
่ นุญาตให ้
ไม่ต ้องมีวงเล็บครับ ถัดมาคือคําว่า Hello, World! คํานีเ้ ป็ นสตริงก์ เพราะฉะนัน ้ ก็ต ้องอยูใ่ นเครือ
่ งหมายฟั งหนูซะให ้เรียบร ้อย มิฉะนั น
้ ไพธอนจะคิดว่าเป็ นตัว
แปรหรือฟั งก์ชน ั่

้ ฐาน
ชนิดข้อมูลพืน

ไพธอนมีชนิดข ้อมูลหลายประเภท แต่ชนิดข ้อมูลธรรมดามีเพียง 3 ชนิดเท่านัน

้ ได ้แก่

1. จํานวนเต็ม (Integer)
2. จํานวนจริง (Float)
3. สตริง (String)

และชนิดข ้อมูลแบบซับซ ้อนอีก 2 ชนิด

1. ลิสต์ (List)
2. ดิกชันนารี (Dictionary)
คําว่าซับซ ้อนหมายความว่าข ้อมูลเหล่านีจ ้ ะประกอบไปด ้วยข ้อมูลประเภทอืน ่ ายในแล ้วแต่การใช ้งาน เช่น ลิสต์ของจํ านวนเต็ม และดิกชันนารีของ
่ อยูภ
สตริง เป็ นต ้น ลิสต์ในทีน
่ ห
ี้ มายถึงอาเรย์ (Array) ในภาษาอืน่ นั่ นเอง แต่ถ ้าแบ่งประเภทใหญ่ๆ จะประกอบด ้วย

1. ตรรกกะ หรือ บูลน

ี (Boolean)
2. ตัวเลข
3. ลําดับ
4. จับคู่

 ตรรกะ หรือ บูลน

ี
 ตัวเลข
 ลําดับ
 จับคู่

ตรรกะ หรือ บูลน

ี

ความจริงแล ้วข ้อมูลชนิดตรรกะในไพธอนไม่มอ

ี ยูจ
่ ริง เพราะไม่จําเป็ นต ้องมีนั่นเอง ส่งทีไ่ พธอนมีให ้นั น ่ ใช ้แทนตรรกะ จริง และ เท็จ
้ เป็ นเพียงค่าคงทีเ่ พือ
เท่านัน
้ ได ้แก่

 True - แทนค่าจริง มีคา่ เป็ น 1

 False - แทนค่าเท็จ มีคา่ เป็ น 0

้ ใี ช ้ในไพธอนรุ่น 2.2.1 ขึน

ค่าคงทีเ่ หล่านีม ้ ถ ้าต ้องการให ้ใช ้ได ้กับรุ่นเก่ากว่านีต
้ ไปเท่านั น ้ ้องใช ้ค่า 1 0 หรือประกาศไว ้ใช ้งานเอง

ต ัวเลข

ชนิดข ้อมูลประเภทตัวเลขในไพธอนมีหลายชนิดให ้ใช ้งาน แล ้วแต่กรณี แบ่งตามรูปแบบและขนาดของแต่ละชนิดได ้ดังต่อไปนี้

1. จํานวนเต็ม (Integer)
2. จํานวนเต็มแบบยาว (Long Integer)
3. จํานวนจริง (Float)
4. จํานวนเชิงซ ้อน (Complex)

ลําด ับ

ไพธอนมีชนิดข ้อมูลประเภทลําดับให ้เลือกใช ้ 3 ชนิด ขึน

้ อยูก
่ บ ี่ ํ าไปใช ้ ได ้แก่
ั สถานการณ์ทน

1. สายอักขระ หรือ สตริง (String)

2. ทูเปิ้ ล (Tuple)
3. ลิสต์ (List)

แต่ละชนิดมีข ้อดีข ้อเสียแตกต่างกันไป สามารถทํามาใช ้แทนกันได ้ในบางครัง้ แต่สามารถแปลงชนิดได ้เมือ

่ ต ้องการ

จ ับคู่

ชนิดข ้อมูลประเภทจับคู่ (Mapping) หรือ ดิกชัน ่ นารี (Dictionary) อาจรู ้จักกันในชืข ่ อง แฮช (Hash) อธิบายสัน ้ ๆ ได ้ว่าข ้อมูลประเภทนีค ื อาเรย์ทใี่ ช ้
้ อ
สามารถใช ้สตริงเป็ นคีย ์ (Key) ถึงข ้อมูลภายในได ้นั่ นเอง ปกติอาเรย์จะอ ้างถึงข ้อมูลเป็ นตัวเลข เริม
่ ตัง้ แต่ 0 ถึง n-1 เมือ ่ n คือความยาวของอาเรย์

ข ้อมูลชนิดนีไ้ ด ้รับความนิยมใช ้กันมากโดยเฉพาะผู ้ทีเ่ ขียนเพิรล ์ เพราะเก็บข ้อมูลแบบโครงสร ้างได ้ไม่มต

ี กหล่นและยืดหยุน ่ มากๆ ด ้วย ทีเ่ ป็ นเช่นนีเ้ พราะใช ้
คลาสในเพิรล ์ ยาก สร ้างเองก็ยาก สุดท ้ายแล ้วทุกคนชินกับการใช ้แฮชมากกว่า สะดวกรวดเร็ว
สําหรับไพธอนนั น ้ ข ้อมูลแบบนีอ
้ าจไม่สะดวกเท่าเพิรล ์ แต่ก็สามารถนํ าไปใช ้ได ้ ง่ายและรวดเร็วเพียงพอสําหรับงานทั่วไป อย่างไรก็ตามไม่ควรใช ้ดิกชัน ่ นารี
พรํ่าเพรือ
่ เพราะไม่สามารถเพิม ่ กลไลการตรวจสอบข ้อมูลได ้ ทําให ้อาจเกิดความผิดพลาดขึน ้ ระหว่างการเขียน ในขณะทีก ่ ารใช ้คลาสในไพธอนง่ายมาก ถ ้า
ข ้อมูลต ้องมีการเปลีย ่ นแปลงบ่อยๆ ควรใช ้คลาสครอบดิกชัน ่ นารีไว ้เพือ
่ ความสะดวกและปลอดภัยในการเขียนโปรแกรม ขนาดใหญ่
หน ้าตาของดิกชัน ่ นารีในไพธอนนั น ้ จะใช ้เครือ
่ งหมาย { และ : ดังตัวอย่าง

{'a': 1, 'b': 2, 'c': 3}

่ นารีนม
หมายความว่าดิกชัน ี า่ 3 ค่า ได ้แก่ 1 2 และ 3 สามารถเข ้าถึงโดยใช ้สตริง 'a' 'b' และ 'c' เป็ นคียต
ี้ ค ์ ามลําดับ การเข ้าถึงจะใช ้เครือ
่ งหมาย [ ] คร่อม
เช่น

{'a': 1, 'b': 2, 'c': 3}['c']

จะได ้ค่าออกมาเป็ นจํานวนเต็ม 3

ต ัวแปร

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

แต่เอ๊ะ แล ้วทําไมตัวแปรถึงไม่มช ้ ้อมูลจริงๆ นั่นเอง เมือ

ี นิดตามข ้อมูลล่ะ ง่ายนิดเดียวครับ เพราะตัวแปรเป็ นพอยเตอร์ทเี่ อาไว ้ชีข ่ ถึงเวลาใช ้แล ้วนัน
้ ตัวแปร
จะมีชนิดเปลีย ่ นไปตามข ้อมูลทีก ้ ยู่ ด ้วยเหตุนเี้ องทําให ้ตัวแปรของไพธอนไม่มช
่ ําลังชีอ ี นิดทีแ
่ น่นอนตายตัว ทําให ้กลายเป็ นทัง้ ข ้อดีและข ้อเสียในเวลา
เดียวกัน ข ้อดีได ้แก่

1. สะดวก ประหยัด
2. เปลีย
่ นชนิดของตัวแปรระหว่างการทํางานได ้

ในขณะทีข
่ ้อเสีย เช่น

1. ไม่สามารถตรวจสอบความถูกต ้องได ้จนกว่าจะใช ้งานจริง

2. ไม่สามารถรู ้ชนิดของตัวแปรจนกว่าจะใช ้งานจริง

่ น่นอน แต่ตัวแปรจะต ้องถูกกําหนดค่าก่อนนํ าไปใช ้เสมอ การกําหนดค่าครัง้ แรกถือว่าเป็ น

อย่างไรก็ตาม แม ้ว่าตัวแปรของไพธอนจะไม่ต ้องกําหนดชนิดทีแ
การประกาศตัวแปรนัน ้ มาใช ้งานทันที เช่น
้ ขึน
print a
a=1

ู ประกาศก่อนการใช ้งานในบรรทัดแรก ทําให ้โปรแกรมเกิดข ้อผิดพลาดและหยุดทํางานทันที ตัวอย่าง

ตัวอย่างด ้านบนไม่สามารถทํางานได ้เพราะ a ยังไม่ถก
ถัดไปเป็ นตัวอย่างทีถ
่ ก
ู ต ้อง
a=1
print a
a = 1.0
print a
a = 'abc'
print a

 ตัวอย่างตัวแปรตามชนิดข ้อมูล

ต ัวอย่างต ัวแปรตามชนิดข้อมูล

ว่ากันตามจริงแล ้วตัวแปรในไพธอนใช ้เหมือนกันหมดไม่มข ี ้อยกเว ้นกรณีพเิ ศษ ใดๆ สิง่ ทีแ ่ ตกต่างไปของวิธใี ช ้ขึน ้ กับชนิดข ้อมูลของตัวแปรนั น
้ มากกว่า
เพราะไพธอนเป็ นภาษาทีอ ่ งิ การเขียนโปรแกรมเชิงวัตถุ ด ้วยเหตุนต ่ ไี้ ปยังข ้อมูลเหล่านีจ
ี้ ัวแปรทีช ้ งึ มีสภาพคล ้ายกับอ๊อบเจ็กแต่ ไม่ใช่ออ๊ บเจ็ก อย่างไรก็ตาม
การคิดว่าชนิดข ้อมูลเป็ นอ๊อบเจ็กแบบพิเศษก็ไม่ผด ิ อะไรนัก แต่ชนิดข ้อมูลพืน ้ ฐานส่วนใหญ่ไม่มเี มธอดพิเศษเหมือนภาษาอืน ่ โดยเฉพาะอย่างยิง่ ตรรกะและ
ตัวเลข เมธอดทีใ่ ช ้บ่อยมักเกีย ่ วกับลําดับ และจับคู่ ตอนนีเ้ ราก็จะมาว่ากันด ้วยเรือ ่ งของเมธอดทีค ่ วรรู ้กันทีละชุด

สตริง เป็ นชนิดข ้อมูลทีใ่ ช ้บ่อยมากๆ ส่วนใหญ่การทํางานกับสตริงจะเป็ นเรือ

่ งของค ้นหาคํา find() เปลีย
่ นคํา replace() ตัวเล็ก lower() ตัวใหญ่ upper()
แยกคํา split() เป็ นต ้น นอกนั น ้ นีก
้ ็จะเป็ นดึงตัวอักษรบางส่วนออกมาจากสตริง
s = 'Ab,Cd,Ef'
print s.find('d')
print s.find('D')
print s.replace('Cd','Gh')
print s.lower()
print s.upper()
print s.split()
print s.split(',')

โค ้ดด ้านบนจะได ้ผลลัพธ์ดังด ้านล่าง

4
-1
Ab,Gh,Ef
ab,cd,ef
AB,GH,EF
['A','b',',','C','d',',','E','f']
['Ab','Cd','Ef']
ลิสต์ เป็ นชนิดข ้อมูลสารพัดประโยชน์ ได ้ใช ้ทัง้ แบบคิว และสแตก สามารถเรียงข ้อมูลได ้ด ้วยตัวเอง แทรกข ้อมูลได ้
l = [1,2,3,4]
print l
l.append(5)
print l
l.append(1)
print l
print l.count(1),l.count(2)
l.extend([5,6,7])
print l
l.insert(5,8)
print l
print l.pop()
print l
l.remove(5)
print l
l.reverse()
print l
l.sort()
print l

ผลลัพธ์จะเป็ นดังด ้านล่าง

[1, 2, 3, 4]
[1, 2, 3, 4, 5]
[1, 2, 3, 4, 5, 1]
21
[1, 2, 3, 4, 5, 1, 5, 6, 7]
[1, 2, 3, 4, 5, 8, 1, 5, 6, 7]
7
[1, 2, 3, 4, 5, 8, 1, 5, 6]
[1, 2, 3, 4, 8, 1, 5, 6]
[6, 5, 1, 8, 4, 3, 2, 1]
[1, 1, 2, 3, 4, 5, 6, 8]

่ นารี เป็ นชนิดข ้อมูลสารพัดประโยชน์เช่นกัน เพราะใช ้ง่าย สะดวก ไม่ต ้องเขียนคลาสเพิม

ดิกชัน ่ สามารถเข ้าถึงข ้อมูลภายในได ้ด ้วยข ้อมูลชนิดใดก็ได ้
d = {'a': 1, 'b': 2, 'c': 3}
print d
print d.items()
print d.keys()
print d.values()

ตัวอย่างด ้านบนจะให ้ผลดังนี้

{'a': 1, 'c': 3, 'b': 2}
[('a', 1), ('c', 3), ('b', 2)]
['a', 'c', 'b']
[1, 3, 2]
คําสง่ ั ควบคุม

การเขียนโปรแกรมทีท ่ ํางานตัง้ แต่บนลงล่างนัน้ ดูจะธรรมดาเกินไปสําหรับปั ญหา ยากๆ แต่ก็เป็ นไปได ้สําหรับงานทีไ่ ม่ซบั ซ ้อน การออกแบบด ้วยวิธ ี top-
down เป็ นกรรมวิธอ ี ย่างหนึง่ เพือ ั ซ ้อน และมันทํางานแบบบนลงล่าง อย่างไรก็ตามในทีส
่ ให ้โปรแกรมทีไ่ ด ้ไม่ซบ ุ แล ้วโปรแกรมมักซับซ ้อนเกินกว่าทีจ
่ ด ่ ะทํา
แบบบนลงล่างทัง้ หมดได ้ เมือ ่ โปรแกรมมีความซับซ ้อนจึงต ้องมีคําสั่งพิเศษสําหรับควบคุมการทํางาน หรือ Control Flow คําสัง่ ประเภทนีใ้ น ไพธอน จะถือ
เป็ นคําสัง่ เฉพาะ แบ่งเป็ น 2 ประเภทหลักๆ ได ้แก่

1. เงือ
่ นไข (Condition)
2. ลูป (Loop)

 คําสัง่ เงือ
่ นไข
 คําสัง่ ลูป

คําสง่ ั เงือ
่ นไข

คําสัง่ เงือ
่ นไข (Condition) ใน ไพธอน มีเพียงรูปแบบเดียวเท่านัน
้ แต่ก็เพียงพอสําหรับงานทุกประเภท ประยุกต์ได ้หลากหลายมาก มาเข ้าเรือ
่ งกันดีกว่า
คําสัง่ เงือ ้ ะมีสว่ นประกอบ 3 ส่วน ได ้แก่
่ นไขนีจ

1. เงือ
่ นไข
2. คําสัง่ เมือ่ ตรงตามเงือ
่ นไข
3. คําสัง่ เมือ
่ ไม่ตรงตามเงือ่ นไข ส่วนนีอ
้ าจจะมีหรือไม่มก
ี ็ได ้

เมือ
่ นํ ามารวมกันจะอยูใ่ นรูปแบบด ้านล่าง
if expression:
statement1
statement2

จะสังเกตุเห็นว่าคําสัง่ ภายใต ้ if นัน ้ จะเว ้นระยะด ้านหน ้าไว ้ นีค

่ อ
ื ลักษณะพิเศษของ ไพธอน ทีน ่ ่าสนใจ และมีประสิทธิภาพมากอย่างไม่น่าเชือ ่ ถ ้าดูให ้ดีกว่า
นัน
้ สําหรับผู ้ทีเ่ คยเขียนโปรแกรมมาก่อนจะสงสัยเป็ นอย่างยิง่ ว่า begin end endif หรือ { } หายไปไหน เพราะภาษาทั่วไป เช่น C C# Pascal Java Basic
หรือ แม ้แต่ PHP นัน ้ จะมีคําสั่ง if นีแ
้ ละจะถือว่า คําสัง่ ภายใต ้ if มีได ้เพียงคําสัง่ เดียวเท่านัน
้ ถ ้ามีหลายคําสัง่ ต ้องครอบคําสั่งเหล่านั น ้ ด ้วย { } หรือ end หรือ
endif หรืออะไรบางอย่างทีท ่ ําให ้คําสั่งหลายคําสัง่ เสมือนเป็ นคําสั่งเดียว แต่ใน ไพธอน จะมีหลักการทีต ่ า่ งกันไป นั่นคือการจับกลุม ่ ชุดคําสั่งจะไม่มค ี ําสัง่
หรือสัญลักษณ์พเิ ศษใดๆ แต่จะใช ้เพียงการย่อหน ้า หรือ Indent นั่นเอง ดังตัวอย่างข ้างบน ใช ้การย่อหน ้าเข ้ามา 4 ตัวอักษร แปลว่า statement1 และ
statement2 อยูใ่ นระดับเดียวกันผ่านใต ้ if อย่างไรก็ตาม ไพธอน ยังให ้ใช ้เครือ ่ งหมาย : colon เพือ ่ บอกจุดจบของคําสัง่ ทีม ี ําสั่งย่อยต่อไป เช่น if เป็ นต ้น
่ ค
การใช ้ if จะเป็ นดังตัวอย่างต่อไปนี้
a = 10
b = 20
if a > b:
print a,'>',b

ในกรณีทม ี ําสัง่ ทีร่ องรับเงือ

ี่ ค ่ นไข เราสามารถใช ้คําสั่ง else เพือ
่ นไขและนอกเงือ ่ บ่งบอกคําสัง่ เพิม
่ เติมได ้ ดังตัวอย่างถัดไป
if a > b:
print a,'>',b
else:
print a,'<=',b

นอกจากนีย ้ ังมีคําสั่งพิเศษใช ้ในกรณีทม

ี่ เี งือ
่ นไขต่อกันหลายเงือ
่ นไข นั่นคือ elif นั่นเอง ความจริงแล ้ว elif มีการทํางานไม่ตา่ งกับ else if แบบปกติเท่าใด
นัก สามารถเลือกใช ้ตามถนัดได ้
if a > b:
print a,'>',b
elif a < b:
print a,'<',b
else:
print a,'=',b

สําหรับเงือ ่ ับซ ้อนสามารถใช ้ and or not มาเชือ

่ นไขทีซ ่ มได ้ตามจํ าเป็ น เช่น
if a > b or a < b:
print a,'!=',b

สัญลักษณ์การเปรียบเทียบใน ไพธอน จะเหมือนปกติทั่วไป เช่น < > <= >= จะแปลกไปก็คอ

ื การเปรียบเทียบ เท่ากับ == และ ไม่เท่ากับ != เท่านัน
้ เอง
คําสง่ ั ลูป

ลูป (Loop) เป็ นสิง่ ทีจ

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

1. for
2. while

ถ ้าเคยเขียนภาษาอืน ่ มา for กับ while ก็ดจ ่ มีหมด แล ้วอะไรขาดไปกันแน่ สิง่ ทีข

ู ะปกติด ี ภาษาอืน ่ าดไปคือรูปแบบการใช ้ ไม่ใช่คําสั่งครับ ยกตัวอย่างเช่น C
C# และ Java สามารถเขียน for ได ้สารพัดแบบ ทําให ้ for กลายเป็ นสิง่ มหัศจรรย์ ทําทุกอย่างได ้ด ้วย for แล ้วก็งงกันไปหลายตลบ ส่วนใน ไพธอน มี
วิธใี ช ้ for แบบเดียวเท่านัน
้ ครับ for จะต ้องอยูใ่ นรูปแบบดังนี้
for i in lists:
statement1
statement2

ก่อนอืน ่ บอกจุดจบของคําสั่งทีม
่ จะเห็นว่าคล ้ายคล ้าย if ครับ มี colon : เพือ ี ําสัง่ ย่อย จุดทีน
่ ค ่ ่าสนใจอยูท
่ ี่ for i in lists นีแ
่ หละครับ นีค
่ อ
ื รูปแบบทีแ
่ น่นอน
ตายตัว หมายความว่า การวนรอบแต่ละครัง้ ค่า i จะเปลีย ่ นไป โดยค่าทีอ
่ ยูใ่ น i จะถูกนํ ามาจาก ลิสต์ ทีช ่ อื่ lists ตามลําดับจนหมด ยกตัวอย่างเช่น
for i in [0,1,2,3,4]:
print ’i’,i

จะได ้ผลดังนี้
i0
i1
i2
i3
i4

อ่านมาถึงตรงนีผ ้ ู ้ทีเ่ คยเขียนโปรแกรมสารพัดภาษา น่าจะเริม ่ งง แล ้วจะเอาไปใช ้ได ้อย่างไรกัน เรือ

่ งราวไม่ใหญ่โตอย่างทีค
่ ด
ิ ครับ ปั ญหาคือทุกคนมักจะชิน
กับการบวกเลขแล ้วใช ้ index ในการเข ้าถึง อาเรย์ หรืออะไรก็แล ้วตามในทํานองนี้ เพราะนีค ื จุดประสงค์ของการใช ้ ลูป แต่นก
้ อ ี่ ็มันจะเป็ นจุดทีท
่ ําให ้เขียน
โปรแกรมผิดกันนั่ นเอง เพราะเงือ ่ นไขการเริม่ และจบนั น ้ ถูกกําหนดด ้วยเงือ ่ นไข เช่น 0 ถึง 4 แต่ถ ้าค่าเกิดกระโดดขึน
้ มาโดยบังเอิญแทนทีจ ่ ะมีคา่ เป็ น 4 แต่
กลับมีคา่ เป็ น 5 ลูปนีจ ้ ะไม่มวี ันจบ ด ้วยเหตุนเี้ อง ถ ้าเรารู ้ขอบเขตแน่นอนการใช ้ ลิสต์ จะมีความถูกต ้องมากกว่า ดังในกรณีนี้ มีเลขเรียงกัน 0 1 2 3 4 ถ ้าใช ้
ลูปแบบข ้างบน ค่าทีไ่ ด ้จะไม่มวี ันกระโดดเด็ดขาด

อย่าพึง่ ตกใจว่าวิธน ี จ
ี้ ะบานปลายถ ้าต ้องลูปเลข 1 ถึง 1000000 เพราะต ้องมีลส ิ ต์ใหญ่มหาศาล และก็ไม่จําเป็ นต ้องมีซะด ้วย เพราะมันเป็ นเลขเรียงกัน ใช่
แล ้วครับ ไม่จําเป็ น ไพธอน มีวธิ ท
ี งี่ า่ ยกว่า ในกรณีของ for นี้ มันเป็ นการ for ลงไปในชุดเลขทีเ่ รียงกัน เพราะฉะนั น ้ ไพธอน จึงมีฟังก์ชนั่ เอาไว ้สําหรับสร ้าง
ลิสต์ โดยเฉพาะ 2 คําสัง่ ได ้แก่ range() และ xrange() สําหรับตัวอย่างทีผ ่ า่ นมา สามารถเขียนแบบ ไพธอน ได ้ดังนี้
for i in range(5):
print ’i’,i

จริงๆ แล ้ว range() กับ xrange() ให ้ผลเหมือนกันทุกประการ แต่ตา่ งกันทีเ่ วลาทําไปใช ้งาน โดย range() จะสร ้าง ลิสต์ ตามทีร่ ะบุแล ้วคืน ลิสต์ นัน
้
กลับมาทันที แต่ xrange() จะไม่ได ้สร ้าง ลิสต์ ทัง้ หมดขึน
้ มาในทีเดียว แต่ละส่งให ้ทีละค่า วิธข
ี อง xrange() นีเ้ รียกว่า Generator ครับ เหมาะสําหรับงาน
ทีม
่ ข
ี ้อมูลจํานวนมากและไม่จําเป็ นต ้องเก็บทุกอย่างในหน่วยความจําในครัง้ เดียว

้ ตรงไปตรงมาเหมือนกับ while ปกติ แต่กเ็ ช่นเดียวกับคําสั่งอืน

สําหรับ while นัน ่ ๆ ของ ไพธอน ทีม ู แบบการใช ้งานเพียงแบบเดียว ดังนี้
่ รี ป
while expression:
statement
statement

เงือ
่ นไข expression มีลักษณะเดียวกับใน if เพราะฉะนั น
้ ตัวอย่างด ้านบนจะเขียนด ้วย while ได ้ดังต่อไปนี้
i=0
while i < 5:
print ’i’,i
i += 1
 ่ั
ฟังก์ชน

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

ั่ หรือ function ก็คอ

ฟั งก์ชน ื ชุดของคําสัง่ ทีต
่ ้องทําตามลําดับนั่ นเอง แทนทีจ่ ะเป็ นคําสั่ง 10 บรรทัดทีใ่ ช ้ 10 ที่ ทําให ้โปรแกรมยาว 100 บรรทัด เวลาเจอที่
ผิดก็ต ้องแก ้ 10 ที่ ก็เปลีย
่ นเป็ น 10 บรรทัด 1 ทีส ่ ําหรับประกาศ ฟั งก์ชน
ั่ และอย่างละ 1 บรรทัดสําหรับตอนเรียกใช ้งาน

มีหลายคนกลัวการใช ้ ฟั งก์ชน ั่ กลัวว่ายาก กลัวว่าไม่เข ้าใจ กลัวไม่รู ้เรือ

่ ง กลัวพลาด กลัวสารพัด ทุกครัง้ ทีเ่ ขียนก็มักคัดลอกคําสัง่ ชุดนัน ่ ใี่ ช ้โดยไม่
้ ไปทุกทีท
เขียน ฟั งก์ชน ั่ เวลามีใครมาทักก็จะบอกว่า เขียนให ้เสร็จแล ้วค่อยแก ้ก็ได ้ สาเหตุใหญ่ๆ เป็ นเพราะ เข ้าใจผิด ฟั งก์ชน ั่ ไม่ได ้มีไว ้เพือ
่ ให ้โปรแกรมสวย แต่ม ี
่ ทําให ้ความซับซ ้อนของโปรแกรมลดน ้อยลงโดยการทําให ้ส่วนของโปรแกรม ทีท
ไว ้เพือ ื่ เรียกแทนทีจ
่ ําหน ้าทีร่ ว่ มกันมีชอ ่ ะเป็ นคําสัง่ หลายบรรทัดยาวๆ ด ้วย
เหตุนี้ ฟั งก์ชน ั่ จึงช่วยให ้โปรแกรมคล ้ายกับ อัลกอริทม ึ่ และเข ้าใจได ้ง่าย

ใน ไพธอน นัน ั่ ไม่ใช่เรือ

้ ฟั งก์ชน ่ งน่ากลัวแต่อย่างใด ลองมาดูแบบง่ายๆ กันก่อน
def hello():
print 'Hello'

ั่ hello มีไว ้สําหรับพิมพ์คําว่า Hello ออกมาทุกครัง้ ทีถ

ฟั งก์ชน ู เรียกใช ้ วิธเี รียกใช ้นั่นยิง่ ง่าย เพียงแค่เรียก hello() เท่านัน
่ ก ้ เอง เมือ
่ นํ ามารวมกับ ลูป ก็จะดูม ี
ประโยชน์ขน ึ้ มาทันที
hello()
print 'begin'
for i in range(10):
hello()
print 'end'
hello()

ทีนล ั่ มีประโยชน์ยังไง โดยการเปลีย

ี้ องมาดูวา่ ฟั งก์ชน ั่ ก็ต ้องแก ้ 3 ที่ แต่เพราะเราใช ้
่ นโจทย์ให ้พิมพ์คําว่า Hello, World แทน ถ ้าไม่ได ้เขียนด ้วย ฟั งก์ชน
ฟั งก์ชนั่ ผลบุญเลยช่วยให ้แก ้แค่เพียงทีเ่ ดียวเท่านัน
้

ตัวอย่างทีผ ั่ แบบง่าย ไม่ม ี พารามิเตอร์ แต่อย่างใด ฟั งก์ชน

่ า่ นมาเป็ นเพียง ฟั งก์ชน ั่ พวกนีม ่ ้องทําซํ้าๆ กันบ่อยๆ ตัวอย่างถัดมา
้ ันมีไว ้สําหรับงานง่ายๆ ทีต
เป็ น ฟั งก์ชน ั่ ทีม
่ ี พารามิเตอร์ กันบ ้าง
def hello(p):
print 'Hello, World',p
for i in range(10):
hello(i)

ั่ นีจ
ฟั งก์ชน ้ ะรับ พารามิเตอร์ 1 ตัว และนํ ามาพิมพ์ตอ
่ ท ้ายคําว่า Hello, World โดยทีไ่ ม่สนว่า พารามิเตอร์นัน
้ จะเป็ นชนิดอะไร ในกรณีทต
ี่ ้องการส่ง
พารามิเตอร์ มากกว่า 1 ตัวก็สามารถทําได ้โดยใช ้ comma , ขัน ้ ทัง้ ตอนประกาศและเรียกใช ้
def hello(s,i):
print s,i

นอกจากนีแ ั่ ยังสามารถคืนค่ากลับมาได ้ด ้วยคําสัง่ return อีกด ้วย ค่าทีส

้ ล ้ว ฟั งก์ชน ่ ง่ คืนนีม
้ าเป็ นข ้อมูลชนิดใดก็ได ้ รวมไปถึง list tuple และ dictionary
def hello(s,i):
return '%s,%i' % (s,i)
for i in range(10):
print hello('Hello, World',i)

อ๊อบเจ็ กและคลาส

หนึง่ ในคุณสมบติทด ี่ ท
ี ส
ี่ ด
ุ ของไพธอนก็คอื คลาส (Class) นีเ่ อง คลาสเป็ นความสามารถทีแ ่ ถมมากับหลักการ Object-Oriented Programming ซึง่ เหมาะ
กับการพัฒนาโปรแกรมทัง้ ขนาดเล็ก ขนาดกลาง และขนาดใหญ่ มีจด ุ เด่นทีน
่ ่าสนใจของคลาสก็คอ
ื การแบ่งปั ญหาใหญ่ให ้เล็กลงเพือ
่ แก ้ไขในขอบเขตที่
จํากัด ทัง้ ยังช่วยให ้การทดสอบง่ายขึน ้ อีกด ้วย

อย่างไรก็ตามคลาสในไพธอนไม่ตรงตามหลักการของ OOP มากนั ก ดังนั น

้ ไพธอนอาจเหมาะเป็ นภาษาแรก แต่ไม่เหมาะสําหรับการสอน OOP แน่ๆ

กลับมาดูคลาสในไพธอนดีกว่า เริม
่ จากคลาสง่ายๆ
class Person:
pass

ตัวอย่างข ้างบนเป็ นคลาสทีพ

่ น
ื้ ฐานทีส ุ ขณะเดียวกันก็สามารถนํ าไปประยุกต์ใช ้งานได ้มากมาย ก่อนอืน
่ ด ่ ต ้องสร ้างอ๊อบเจ็กขึน
้ มาก่อน

p = Person()

ี้ ็เอา p ไปใช ้ได ้แล ้ว ซึง่ ตอนนีม

แค่นก ้ ส
ี ภาพเหมือนกล่องเปล่า อยากใส่อะไรก็ได ้
p.name = 'Alice'
p.age = 8

print p.name,p.age

อย่างไรก็ตามการใช ้งานแบบข ้างบนจะมีข ้อเสียนิดหน่อย ตรงทีอ

่ อ ่ ของคลาส Person จะไม่ม ี name และ age ซึง่ แก ้ไขได ้โดยการกําหนดค่า
๊ บเจ็กอืน
เริม
่ ต ้น
class Person:
name = 'noname'
age = 0

ซึง่ จะรับประกันได ้ว่า Person ทุกอ็อบเจ็กจะมี name และ age เสมอ แต่ยังไม่สามารถกําหนดค่าเริม
่ ต ้นแบบสวยๆ ได ้
class Person:
def __init__(self,name,age):
self.name = name
self.age = age

วิธก ่ ต ้นจะต ้องใช ้ constructor เข ้ามาช่วย ในไพธอนนัน

ี ําหนดค่าเริม
แรกแทนตัวเอง ซึง่ ปกติจะใช ้ชือ
ไม่ต ้องงงว่า this คืออะไร มีทม
่ __init__ นั่ นเอง ทุกเมธอดในคลาสของไพธอนจะใช ้พารามิเตอร์ตัว
้ จะเป็ นเมธอดชือ
่ self สําหรับคนทีช ิ กับภาษาซี หรือจาวา self ก็คอ
่ น ื this นีเ่ อง วิธแ
ี บบนีท
้ ําให ้การเขียนโปรแกรมเข ้าใจง่ายขึน
้ มาก เพราะ
ี่ าอย่างไร เวลาใช ้จึงเปลีย่ นไปเล็กน ้อย

p = Person('Alice',8)

ถ ้าอยากใส่เมธอดเพิม่ เติมก็ใส่เข ้าไปในคลาสได ้

class Person:
def __init__(self,name,age):
self.name = name
self.age = age

def show(self):
print '%s is %d years old.' % (self.name,self.age)

p = Person('Alice',8)
p.show()

หรือถ ้าจะให ้ดูเป็ นไพธอนมากกว่านีก

้ ็ต ้องแก ้ constructor นิดนึง
class Person:
def __init__(self,**kw):
self.name = kw.get('name','noname')
self.age = kw.get('age',0)

def show(self):
print '%s is %d years old.' % (self.name,self.age)

p = Person(name='Alice',age=8)
p.show()

หรือจะเป็ นแบบข ้างล่างก็ได ้

class Person:
name = 'noname'
age = 0

def __init__(self,**kw):
self.__dict__.update(kw)

def show(self):
print '%s is %d years old.' % (self.name,self.age)

p = Person(name='Alice',age=8)
p.show()
ผมมองว่าไม่ใช่ class นะ แต่เป็ น object ต่างหาก เพราะว่าไม่ม ี information hiding เลย ใครจะล ้วงเอาอะไรไป หรือลบ attribute ของ object ก็ได ้ เช่น
>>> class Person2:
... def __init__(self):
... self.name = "me"
...
>>> p = Person2()
>>> p.name
'me'
>>> del p.name
>>> p.name
Traceback (most recent call last):
File "<stdin>", line 1, in ?
AttributeError: Person2 instance has no attribute 'name'

นอกจากนั น
้ ถ ้าเราสร ้างคลาสแบบนี้
>>> class Person:
... name = "me"
... age = 20

เวลาสร ้าง object นัน

้ attribute name จะไม่ใช่ของ person จริงจนกว่าจะ assign ค่าให ้มัน และพอลบ attribute แล ้วก็ยังสามารถอ ้างไปถึง attribute
ของ class ได ้อีก
>>> p = Person()
>>> p.name
'me'
>>> del p.name
Traceback (most recent call last):
File "<stdin>", line 1, in ?
AttributeError: Person instance has no attribute 'name'
>>> p.name = "hello"
>>> p.name
'hello'
>>> del p.name
>>> p.name
'me'

มันเลยดูงงๆ นิดหน่อย แต่ถ ้าเขียน code ดีๆ ตาม convention ก็จะไม่งงนะครับ

แถมคําถามหน่อย...
่ วรใช ้แบบ Person หรือแบบ Person2 (แบบทีไ่ ม่ใช ้ __init__ กับแบบทีใ่ ช ้ __init__ ตามลําดับ) ดีครับ?
เวลา define class นีค