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

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

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

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

นอกจากนี้ก็จะเป็นเกร็ดการใช้งานที่แทรกเข้าไปเรื่อยๆ

ไพธอนคืออะไร

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

ติดตั้งไพธอน

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

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

Python by Python.org
ActivePython by ActiveState

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

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

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

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

สมมติว่าในกรณีทั่วไปทุกคนมีจอมอนิเตอร์ เพราะฉะนั้น Hello, World! ก็คือการพิมพ์ข้อความออกหน้าจอตามปกตินั่นเอง

#!/usr/bin/env python

print "Hello, World!"

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

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

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

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

จำนวนเต็ม (Integer)
จำนวนจริง (Float)
สตริง (String)

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

ลิสต์ (List)
ดิกชันนารี (Dictionary)

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

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

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

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

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

ตัวเลข

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

จำนวนเต็ม (Integer)
จำนวนเต็มแบบยาว (Long Integer)
จำนวนจริง (Float)
จำนวนเชิงซ้อน (Complex)

ลำดับ

ไพธอนมีชนิดข้อมูลประเภทลำดับให้เลือกใช้ 3 ชนิด ขึ้นอยู่กับสถานการณ์ที่นำไปใช้ ได้แก่

สายอักขระ หรือ สตริง (String)
ทูเปิ้ล (Tuple)
ลิสต์ (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) นั่นเอง สำหรับผู้ที่เคยมีประสบการณ์เขียนโปรแกรมด้วยภาษาระดับกลางถึงต่ำเช่น ปาสคาล หรือซี เป็นต้น คำว่าพอยเตอร์อาจทำให้ขยาด แต่ในไพธอนแล้วพอยเตอร์เป็นเรื่องธรรมชาติที่เข้าใจได้ง่ายกว่ามาก เพราะไม่มีสัญลักษณ์และรูปแบบที่หลากหลายรวมถึงตัวแปรทุกตัวถือว่าเป็นพอยเตอร์อยู่แล้วจึงไม่สับสนกับชนิดของตัวแปร

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

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

ในขณะที่ข้อเสีย ได้แก่

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

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

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]
2 1
[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 ประเภทหลักๆ ได้แก่

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

คำสั่งเงื่อนไข

คำสั่งเงื่อนไข (Condition) ใน ไพธอน มีเพียงรูปแบบเดียวเท่านั้น แต่ก็เพียงพอสำหรับงานทุกประเภท ประยุกต์ได้หลากหลายมาก มาเข้าเรื่องกันดีกว่า คำสั่งเงื่อนไขนี้จะมีส่วนประกอบ 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 แบบเท่านั้น ไม่มีมากกว่านี้เด็ดขาด ได้แก่

for
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

จะได้ผลดังนี้

i 0
i 1
i 2
i 3
i 4

อ่านมาถึงตรงนี้ผู้ที่เคยเขียนโปรแกรมสารพัดภาษา น่าจะเริ่มงง แล้วจะเอาไปใช้ได้อย่างไรกัน เรื่องราวไม่ใหญ่โตอย่างที่คิดครับ ปัญหาคือทุกคนมักจะชินกับการบวกเลขแล้วใช้ 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()

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

ตัวอย่างที่ผ่านมาเป็นเพียง ฟังก์ชั่น แบบง่าย ไม่มี พารามิเตอร์ แต่อย่างใด ฟังก์ชั่นพวกนี้มันมีไว้สำหรับงานง่ายๆ ที่ต้องทำซ้ำๆ กันบ่อยๆ ตัวอย่างถัดมาเป็น ฟังก์ชั่น ที่มี พารามิเตอร์ กันบ้าง

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)