วิธีคิดแบบนักวิทยาการคอมพิวเตอร์/Classes and functions

0
 
 35700
 2019-09-24T03:53:29Z
 
 Geonuch
 
 wikitext
 text/x-wiki
บทที่ 13 Classes and functions
13.1 Time
บทที่ 13 Classes and functions.
13.1 Time.
ขณะที่ตัวตัวอย่างอื่นๆ เป็นแบบ user-defined type นั้น คราวนี้เราจะ define ( กำหนด ) class ที่เรียกว่า Time ที่ใช้บันทึกเวลา 
class Time:
pass
 เราสามารถสร้าง Time object ขึ้นมาใหม่ได้ และกำหนด attribute สำหรับบอกชั่วโมง นาที และวินาที
time = Time
time.hours = 11
time.minutes = 59
time.seconds = 30
 แผนภาพแสดงของ Time object
13.2 Pure functions
13.2 Pure functions.
ในส่วนต่อมา เราจะทำการเขียน function ชุดที่สอง หรือที่เรียกว่า addTime โดยที่สามารถคำนวณผลรวมของ 2 เวลาได้ โดยจะพิสูจน์ให้เห็นว่า function 2 ชนิดนี้ คือ pure functions and modifiers.
ด่านล่างเป็นตัวอย่างคร่าวๆ ขอชุดคำสั่ง addTime :
 def addTime(t1, t2):
sum = Time
sum.hours = t1.hours + t2.hours
sum.minutes = t1.minutes + t2.minutes
sum.seconds = t1.seconds + t2.seconds
return sum
function นี้เป็นการสร้าง Time object ขึ้นมาใหม่ ตอนแรกมันมี attribute ในตัวของมันเอง และกลับคืนค่าอ้างอิงไปที่ object อันใหม่ เรียกว่า pure function เพราะว่า ไม่มีการแก้ไขในส่วนใดของ object แล้วผ่านค่าไปเป็น parameters และมันไม่มีผลกระทบ เช่น ค่าที่แสดงออกมา หรือค่าที่นำใส่เข้าไป
ในตัวอย่างนี้แสดงให้เห็นถึงการใช้งาน function ซึ่งเราจะต้องสร้าง Time object ขึ้นมา 2 ตัว โดยให้ตัว currentTime นั้นใส่ค่าเวลาในปัจจุบัน และตัว breadTime นั้นใส่จำนวนเวลาที่เพิ่มขึ้นมา จากนั้นเราจะใช้ addTime ในการคำนวณ ถ้าคุณยังทำในส่วนของ printTime ไม่ได้ ให้ไปดูใน section 14.2 ก่อนที่จะมาทำในส่วนนี้ใหม่
»> currentTime = Time
»> currentTime.hours = 9
»> currentTime.minutes = 14
»> currentTime.seconds = 30
»> breadTime = Time
»> breadTime.hours = 3
»> breadTime.minutes = 35
»> breadTime.seconds = 0
»> doneTime = addTime(currentTime, breadTime)
 »> printTime(doneTime)
 ผลลัพธ์ของโปรแกรมที่คำนวณได้ถูกต้อง คือ 12:49:30 แต่ในอีกแง่หนึ่งในกรณีนี้จะมีผลลัพธ์บางแห่งที่ไม่ถูกต้อง 
 ปัญหาที่ว่านี้ ใน Function จะไม่ถูกต้องถ้าจำนวนค่าในส่วนของวินาทีแสดงออกมามากกว่า 60 เมื่อเกิดเหตุการณ์เช่นนี้เราจะต้อง “carry” ในส่วนของวินาทีที่เกินมา ไปไว้ในส่วนของนาที หรือ ในส่วนของนาทีที่เกินมาไปไว้ในส่วนของชั่วโมง
Function การแสดงผลของวินาทีที่ถูกต้อง
 def addTime(t1, t2):
sum = Time
sum.hours = t1.hours + t2.hours
sum.minutes = t1.minutes + t2.minutes
sum.seconds = t1.seconds + t2.seconds
if sum.seconds >= 60:
 sum.seconds = sum.seconds - 60
 sum.minutes = sum.minutes + 1
if sum.minutes >= 60:
 sum.minutes = sum.minutes - 60
 sum.hours = sum.hours + 1
return sum
 แม้ว่าใน function นี้จะมีความถูกต้องแล้ว แต่มันมีขนาดที่ใหญ่ หลังจากนี้เราจะแนะนำทางเลือกที่ใกล้เคียงที่มี code สั้นกว่า
13.3 Modifiers
13.3 Modifiers.
เวลานั้นจะเป็นประโยชน์สำหรับ function เพื่อใช้ในการแก้ไขในส่วนต่างๆ ของ objects ที่มันกลายเป็นเหมือน parameters โดยปกติแล้วชื่อที่ใช้เรียกจะถูกเก็บไว้อ้างอิงไปยัง objects ที่มันเปลี่ยนแปลง ฉะนั้นการเปลี่ยนแปลง function จะเห็นชัดเจนในการเรียกใช้งาน functions ที่ทำงานอยู่นี้จะเรียกว่า modifiers
 increment ไว้สำหรับการเพิ่มจำนวนของเวลาในส่วนของ Time object และสามารถนำมาเขียนให้มีความเรียบง่ายกว่าตามตัวอย่างที่ได้รับการแก้ไขนี้
 def increment(time, seconds):
time.seconds = time.seconds + seconds
if time.seconds >= 60:
 time.seconds = time.seconds - 60
 time.minutes = time.minutes + 1
if time.minutes >= 60:
 time.minutes = time.minutes - 60
 time.hours = time.hours + 1
 ในบรรทัดแรกที่แสดงนั้นเป็นการคำสั่งดำเนินงานพื้นฐานทั่วไป ส่วนที่เหลือนั้นจะเกี่ยวข้องถึงกรณีเฉพาะที่ได้กล่าวมาแล้ว
 Function นี้ถูกต้องแล้วหรือ? จะเกิดอะไร ถ้า parameter seconds มีค่าเกินกว่า 60 แล้ว
ในกรณีนี้ มันไม่สามารถที่จะทำการ carry ได้ภายในครั้งเดียว ดังนั้นจึงควรรักษาการทำงานนี้ไว้จนกว่า seconds จะมีค่าน้อยกว่า 60 ทางออกอย่างหนึ่งคือ การเปลี่ยนจาก if statement ด้วย
While statements
 def increment(time, seconds):
time.seconds = time.seconds + seconds
while time.seconds >= 60:
 time.seconds = time.seconds - 60
 time.minutes = time.minutes + 1
while time.minutes >= 60:
 time.minutes = time.minutes - 60
 time.hours = time.hours + 1
Function นี้มีความถูกต้องสมบูรณ์แล้ว แต่มันก็ยังไม่ใช่ทางออกที่มีประสิทธิภาพมากนัก
13.4 Which is better?
13.4 Which is better?
อะไรก็ตามที่สามารถทำการแก้ไขด้วยการ modifiersได้ ก็สามารถที่จะใช้ pure function ด้วยเช่นเดียวกัน แต่ในความเป็นจริงแล้วในการเขียนโปรแกรมบางภาษาเท่านั้นที่ทำงานได้ ซึ่งนี่เป็นจุดเด่นของภาษาที่สามารถใช้ pure function ได้ และมีข้อบกพร่องน้อยกว่าการ modifiers แต่
กระนั้น การ modifiers เองก็ยังมีความเหมาะสมกว่าในเวลาที่การทำงานนั้นขาดประสิทธิภาพ
 ในกรณีทั่วไป จะแนะนำให้ใช้ pure functions แต่เมื่อใดที่มีเหตุสมควร หรือไม่มีทางเลือกที่ดีกว่าก็ใช้การ modifiers แทน ซึ่งลักษณะเหล่านี้คือ functional programming style
13.5 Prototype development versus planning
13.5 Prototype development versus planning.
ในบทนี้แสดงให้เห็นถึงการเริ่มพัฒนาโปรแกรมที่เรียกว่า prototype development โดยในแต่ละกรณี ( case ) จะมีตัวอย่างต้นแบบ ( prototype ) ที่นำไปปฏิบัติได้ และหลังจากที่ได้ทำการทดสอบในกรณีต่างๆ แล้ว ก็จะพบช่องโหว่และจุดบกพร่องเอง
 แม้ว่าการทำงานจะมีความสมบูรณ์ มันก็สามารถก่อให้เกิด code ที่ไม่จำเป็น หรือมีความซับซ้อน ดังที่ได้ปฏิบัติในหลายๆ case ที่ผ่านมา การเขียนโปรแกรมที่พบข้อผิดพลาดบ่อยๆนั้นทำให้ขาดความน่าเชื่อถือด้วย
 ทางเลือกคือ planned development การใช้ความเข้าใจที่ดีในการแก้ปัญหานั้นสามารถทำให้การเขียนโปรแกรมมีความง่ายยิ่งขึ้น ใน case นี้ สิ่งที่ต้องทำความเข้าใจนั่นคือ Time object ซึ่งจริงๆแล้วมันมี อยู่ 3 จำนวน และอยู่ในเลขฐาน 60 ในส่วนของวินาทีจะประกอบไปด้วย 1 คอลัมน์
ส่วนของนาทีจะประกอบไปด้วย 60 คอลัมน์ และชั่วโมงประกอบไปด้วย 3600 คอลัมน์
 เมื่อทำการเขียน addTime และ increment แล้ว 
 คำแนะนำอีกอย่างในการจัดการกับปัญหาทั้งหมดนั้น เราสามารถเปลี่ยน Time object ไปเป็น single number และทำให้รูปแบบมีความง่ายต่อการคำนวนตัวเลขของคอมพิวเตอร์ 
ด้านล่างเป็น function ที่เปลี่ยนค่า Time object ไปเป็น integer
def convertToSeconds(t):
 minutes = t.hours * 60 + t.minutes
 seconds = minutes * 60 + t.seconds
 return seconds
ขณะนี้ เราต้องการวิธีที่จะเปลี่ยน integer ไปเป็น Time object
def makeTime(seconds):
 time = Time
 time.hours = seconds // 3600
 time.minutes = (seconds%3600) // 60
 time.seconds = seconds%60
 return time
คุณจะต้องใช้ความคิดซักเล็กน้อยในการทำให้ตัวเองแน่ใจว่า function นี้มันถูกต้อง
ถ้าแน่ใจแล้ว คุณสามารถใช้มันและ convertToSeconds ไปแก้ไขในส่วนของ addTime 
def addTime(t1, t2):
 seconds = convertToSeconds(t1) + convertToSeconds(t2)
 return makeTime(seconds)
ในรูปแบบนี้มีความสั้นกว่าแบบเดิมมาก และง่ายต่อการตรวจสอบว่ามันถูกต้องด้วย
13.6 Generalization
13.6 Generalization.
ในบางครั้งการเปลี่ยนจากฐาน 60 เป็น ฐาน 10 แล้วแปลงกลับมานั้นยากกว่าที่จะต้องติดต่อ ( dealing ) กับเวลาให้พอดี การเปลี่ยนฐานจะค่อนข้างเป็นนามธรรมมากกว่า แต่จากความรู้สึกของสัญชาตญาณนั้น การติดต่อร่วมกับเวลาจะมีความเหมาะสมมากกว่า
 แต่ถ้าเรามีความเข้าใจเกี่ยวกับเวลาด้วยเลขฐาน 60 และเขียนการเปลี่ยน function 
(convertToSeconds and makeTime) เราจะพบว่าโปรแกรมนี้มันสั้น ง่ายต่อการอ่านและแก้ไข
ข้อบกพร่อง และมีความน่าเชื่อถือ
 เช่นเดียวกันนั้น การเพิ่ม features ในภายหลังก็ทำได้ง่ายขึ้นด้วย ในตัวอย่าง ลองคิดถึงการลบกันของ 2 ช่วงเวลา จะพบช่วงเวลาระหว่างพวกมันอยู่ การจะให้ใกล้จุดมุ่งหมายนั้นควรจะใช้เครื่องมือสำหรับการลบด้วยการยืม ( borrowing ) การใช้การแปลง function จะมีความง่ายและโอกาสถูกต้องสูง
 น่าแปลกใจที่บางครั้งการสร้างปัญหานั้นก็ยากกว่าการจะทำให้มันถูกต้อง ( เพราะมีแค่บางกรณีและบางโอกาสเท่านั้นที่จะเกิดข้อผิดพลาด )
13.7 Algorithms
13.7 Algorithms.
เมื่อคุณเขียนการแก้ปัญหาทั่วไปสำหรับ class ของปัญหา โดยไม่ยอมรับชนิดของทางออกที่เป็นปัญหาอย่างหนึ่ง คุณต้องเขียนเป็นขั้นตอนวิธีการ เรากล่าวถึงคำนี้ก่อนแต่อย่าเพิ่งไปกำหนดอะไรแน่ชัด มันไม่ง่ายที่จะกำหนด ดังนั้นควรจะพยายามเชื่อมกันในสิ่งที่คล้ายกัน
 ครั้งแรก พิจารณาว่าบางสิ่งนั้นไม่มีวิธีคิดที่แน่นอน เมื่อคุณเรียนรู้เพื่อคูณตัวเลขหลักเดี่ยว
เชื่อแน่ว่าคุณจะต้องนึกถึงตารางการคูณตัวเลข ในสิ่งที่เกิดขึ้นนี้ คุณจะต้องจดจำชนิดของทางออกนับร้อย แต่นั้นเป็นเพียงชนิดของความรู้ ไม่ใช่วิธีคิด
 แต่ถ้าคุณขี้เกียจแล้ว คุณน่าจะหลีกเลี่ยงมันโดยการศึกษากลเม็ดเหล่านี้ซักเล็กน้อย เช่น
การหาผลที่เกิดขึ้นของ n และ 9 ซึ่งคุณสามารถเขียน n-1 เป็นตัวแรกและ 10-n เป็นตัวที่สอง และเทคนิคนี้คือการแก้ปัญหาทั่วไปสำหรับคูณตัวเลขหลักเดี่ยวใดๆ หรือเรียกว่า algorithms 
 ในทำนองเดียวกัน ความชำนาญนั้นสอนให้คุณเรียนรู้การเพิ่ม (addition) ด้วยการ carrying
การลบ (subtraction) ด้วยการ borrowing และการหารยาวก็เป็น algorithms ด้วยทั้งหมด ลักษณะพิเศษอย่างหนึ่งของ algorithme คือ มันไม่ต้องการความสามารถในการคิดและเรียนรู้เพื่อทำให้สมบูรณ์ มีระบบการทำงานอัตโนมัติเป็นขั้นตอนตามข้อกำหนดพื้นฐาน
 ในความเห็นส่วนตัวนั้นเห็นว่า มันดูน่าอึดอัดใจ ที่คนส่วนใหญ่จะใช้เวลาจำนวนมากที่โรงเรียนในการเรียนรู้ที่จะจัดการกับ algorithms แต่ที่จริงแล้วนั้นมันไม่มีประโยชน์เลย
 ในทางกลับกัน เทคนิคกระบวนการในการออกแบบ algorithms นั้นมีความน่าสนใจ มันท้าท้ายความสามารถของสติปัญญา และมันยังเป็นส่วนสำคัญ หรือที่เรียกว่า programming
 การกระทำในบางครั้งนั้น ผู้คนโดยทั่วไปมักจะทำไปตามธรรมชาติ โดยปราศจากการฝึกฝนหรือขาดการตระหนักในความคิดนั้นต้องอาศัยความพยายามอย่างสูงในการแสดงออกทางด้าน algorithmically การเข้าใจในพื้นฐานภาษาเป็นแบบอย่างที่ดี ทุกๆคนทำได้แต่จนถึงทุกวันนี้ก็ไม่มีใครสามารถอธิบายได้ว่า เราต้องทำอย่างไร อย่างน้อยที่สุดมันก็ไม่ใช่ในรูปของ algorithm
13.8 Glossary
13.8 Glossary.
pure function: A function that does not modify any of the objects it receives as parameters. Most pure functions are fruitful.
 modifier: A function that changes one or more of the objects it receives as parameters. Most modifiers are fruitless. 
 functional programming style: A style of program design in which the majority of functions are pure.
 prototype development: A way of developing programs starting with a prototype and gradually testing and improving it.
 planned development: A way of developing programs that involves high-level insight into the problem and more planning than incremental development or prototype development.
 algorithm: A set of instructions for solving a class of problems by a mechanical, unintelligent process.