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

<ns>0</ns>
 <revision>
 <parentid>37097</parentid>
 <timestamp>2019-09-24T03:50:43Z</timestamp>
 <contributor>
 <username>Geonuch</username>
 </contributor>
 <origin>52669</origin>
 <model>wikitext</model>
 <format>text/x-wiki</format>
บทที่ 6 Iteration.
6.1 Multiple assignment.
คุณอาจจะเคยเจอ มันถูกต้องในการกำหนดค่าที่มากกว่า 1 ค่า ให้กับตัวแปรตัวเดียวกัน การกำหนดค่าใหม่ทำให้ตัวแปรที่มีอยู่อ้างถึงค่าใหม่ที่ได้กำหนด (และหยุดอ้างอิงถึงค่าตัวเก่า)
 bruce = 5
 print bruce,
 bruce = 7
 print bruce
 ผลที่ออกมาของโปรแกรมนี้คือ 5 7 เพราะว่าในครั้งแรกที่ปริ้น bruce ค่าของมันคือ 5 และในครั้งที่สอง ค่าของมันคือ 7 คอมม่า ที่ตามหลัง print statement ในครั้งแรกหยุดการขึ้นบรรทัดใหม่หลังจากแสดงผล ซึ่งเป็นว่าทำไมจึงมีผลของทั้ง 2 print statement ปรากฏบนบรรทัดเดียวกัน.
นี่คือ multiple assignment ใน state diagram:
ซึ่ง multiple assignment โดยเฉพาะมันมีความสำคัญในการ จำแนกความแตกต่างระหว่าง การกำหนดค่าให้กับตัวแปร และ ชุดคำสั่งที่แสดงความเท่ากัน เพราะว่า Python ใช้เครื่องหมาย (=) สำหรับการกำหนดค่า มันจะพยายามที่จะแปล statement อย่าง a = b เป็น statement ของการเท่ากัน แต่มันไม่ใช่!
 อย่างแรก การเท่ากัน คือ การเปลี่ยนที่โดยผลลัพธ์ไม่เปลี่ยนแปลง และ การกำนหดค่านั้นไม่ใช่ ตัวอย่าง ในท่างคณิตศาสตร์ ถ้า a = 7 ฉะนั้น 7 = a. แต่ใน Python statement ที่ a = 7 นั้นถูกต้อง และ 7 = a นั้นผิด
 นอกจากนี้ ในทางคณิตศาสตร์ statement ของการเท่าเทียมกันนั้นจะถูกต้องเสมอ ถ้าตอนนี้ a = b ฉะนั้น a จะเท่ากันกับ b เสมอ ใน Python, statement ของการกำหนดค่าให้กับตัวแปร สามารถทำให้ตัวแปรสองตัวมีค่าเท่ากันได้ แต่ไม่จำเป็นต้องเป็นแบบนั้นเสมอไป
 a = 5
6.2 The while statement.
คอมพิวเตอร์มักจะถูกใช้กับงานซึ่งเกิดขึ้นซ้ำให้เป็นไปโดยอัตโนมัติ กระทำซ้ำกับงานที่เหมือนหรือคล้ายกันโดยปราศจากข้อผิดพลาดซึ่งเป็นสิ่งที่คอมพิวเตอร์สามารถทำได้ดีและมนุษย์ทำได้ไม่ดีพอ
 เราได้เห็นโปรแกรม 2 โปรแกรมกันไปแล้ว nLines และ countdown ซึ่งใช้การเรียกตัวเองซ้ำเพื่อกระทำซ้ำ ซึ่งเป็นเช่นเดียวกับที่เรียกว่า Iteration(การดำเนินการซ้ำของชุดของคำสั่งโดยการใช้ recursive function call หรือ loop) เนื่องจาก Iteration เป็นอะไรที่ธรรมดา Python ได้จัดสรรภาษาที่มีลักษณะเฉพาะไว้หลากหลายซึ่งจะทำให้มันง่ายขึ้น ลักษณะเฉพาะอย่างแรกที่เรากำลังจะดูกันก็คือ while statement
 นี่คือ countdown ที่ใช้ while statement:
 def countdown(n):
 while n > 0:
 print n
 n = n-1
 print “Blastoff!”
 หลังจากที่เราทำการย้ายการเรียกซ้ำออก ฟังก์ชั่นนี้ก็จะไม่มีการเรียกตัวเองซ้ำ
คุณสามารถที่จะอ่าน while statement เช่นเดียวกันว่าเป็นภาษาอังกฤษ มันหมายความว่า “ขณะที่ n มากกว่า 0 ให้ทำการแสดงค่าของ n และหลังจากนั้นก็ทำการลดค่าของ n ลง 1 โดยทำอย่างต่อเนื่อง เมื่อลดลงถึง 0 ให้แสดงข้อความ Blastoff!”
 อย่างเป็นทางการมากกว่านี้ นี่เป็นการไหลของการดำเนินการสำหรับ while statement:
1. ประเมิลผลของเงื่อไข ยอมรับว่าเป็น 0 หรือ 1
2. ถ้าเงื่อนไขเป็น false (0) ออกจาก while statement และทำการดำเนินการกับ statement ถัดไป
3. ถ้าเงื่อนไขเป็น True (1) ทำการดำเนินการแต่ละ statement ใน body แล้วหลังจากนั้นก็ย้อนกลับไปยังขั้นตอนที่ 1
 body ประกอบด้วย statement ทั้งหมดที่อยู่ใต้ header ซึ่งทำการย่อหน้าเหมือนกัน.
การไหลของโปรแกรมในลักษณะนี้เรียกว่า loop เนื่องจากในขั้นตอนที่ 3 มีการวนกลับไปยังจุดเริ่มอีกครั้ง ข้อสังเกต ถ้าเงื่อนไขเป็น false ในครั้งแรกที่ผ่านเข้าไปใน loop, statement ภายใน loop จะไม่ได้ถูกดำเนินการ
 body ของ loop ควรเปลี่ยนค่าของตัวแปร 1 ตัวหรือมากกว่านั้น ดังนั้นในที่สุดเงื่อนไขจะกลายมาเป็น false และ loop จะถูกยกเลิก. มิฉะนั้น loop ก็จะทำซ้ำกันตลอดไป ซึ่งจะเรียกว่า infinite loop แหล่งที่ไม่สิ้นสุดของความลื่นรมย์สำหรับนักวิทยาศาสตร์คอมพิวเตอร์ก็คือการสังเกตคำแนะนำบนขวดแชมพู, “Lather, rinse, repeat,” ซึ่งเป็น infinite loop.
ในกรณีของ countdown เราสามารถพิสูจน์ว่า loop ยุติ เพราะว่าเรารู้ว่าค่า n นั้นมีขอบเขต แล้วก็ได้เห็นว่าค่า n นั้นมีค่าน้อยลงในแต่ละครั้งที่ผ่านเข้าไปใน loop ในที่สุดก็จะถึง 0 ในกรณีอื่นๆ มันไม่ง่ายที่จะบอกได้:
 def sequence(n):
 while n != 1:
 print n,
 if n%2 == 0: # n is even (เป็นจำนวนคู่)
 n = n/2 
 else: # n is odd (เป็นจำนวนคี่)
 n = n*3+1
 เงื่อนไขสำหรับ loop นี้คือ n != 1(n ไม่เท่ากับ 1) ดังนั้น loop จะวนไปเรื่อยๆจนค่าของ n เป็น 1 ซึ่งจะทำให้เงื่อนไขเป็น false
 แต่ละครั้งที่ผ่านเข้าไปใน loop โปรแกรมจะให้ผลลัพธ์ค่า n และหลังจากนั้นก็ทำหารเช็คว่ามันจะเป็น even หรือ odd. ถ้าเป็น even ค่าของ n จะถูกหารด้วย 2. ถ้าเป็น odd ค่าของ n จะถูกแทนที่ด้วย n*3+1 ตัวอย่าง ถ้าค่าเริ่มต้นเป็น 3 ลำดับของผลลัพธ์ที่ได้จะเป็นดังนี้ 3, 10, 5, 16, 8, 4, 2, 1
 n ในบางครั้งนั้นเพิ่มขึ้นและบางครั้งก็ลดลง ไม่สามารถที่จะตรวจสอบได้อย่างชัดเจนเลยว่า n จะมีค่ามาถึง 1 หรือ โปรแกรมจะถูกยุติ สำหรับเฉพาะค่าบางตัวของ n เราสามารถตรวจสอบการยุติได้ ตัวอย่าง ถ้าค่าเริ่มต้นเป็นกำลังของสอง แล้วค่าของ n จะเป็น even ในแต่ละครั้งที่ผ่านเข้าไปใน loop จนมันกลายเป็น 1 ตัวอย่างที่แล้วจบลงด้วยลำดับที่ต่อเนื่องกัน เริ่มต้นด้วย 16 โดยเฉพาะค่าที่ข้างต้น เป็นคำถามที่น่าสนใจว่าเราจะสามารถตรวจสอบว่าโปรแกรมจะถูกยุติสำหรับทุกค่าของ n จนเดี๋ยวนี้ยังไม่มีใครที่สามารถตรวจสอบมันได้หรือตรวจสอบว่ามันผิดได้!
 b = a # a และ b มีค่าเท่ากัน 
 a = 3 # a และ b ไม่เท่ากันอีกต่อไป
 บรรทัดที่ 3 เปลี่ยนค่าของ a แต่จะไม่ทำให้ค่าของ b เปลี่ยน ดังนั้นจึงไม่เท่ากันอีกต่อไป (ในบางภาษา, เครื่องหมายที่แตกต่าง ถูกใช้สำหรับเป็นการกำหนดค่า เช่น <- หรือ := เพื่อหลีกเลี่ยงความสับสน.)
 ถึงแม้ว่า multiple assignment เป็นประโยชน์บ่อยๆ คุณควรใช้มันอย่างระมัดระวัง ถ้าค่าของตัวแปรเปลี่ยนบ่อยๆ มันจะทำให้โค๊ดนั้นอ่านยากและยังยากต่อการแก้ไขข้อผิดพลาด
6.3 Tables.
ข้อดีอีกอย่างหนึ่งของ loop ก็คือการสร้างข้อมูลที่เป็นตาราง ก่อนที่คอมพิวเตอร์จะมี คนก็ทำการคำนวณ คณิตศาสตร์ลอการิทึม sines และ cosines และทำการคำนวณอื่นๆทางคณิตศาสตร์ด้วยมือ เพื่อจะทำให้มันง่ายขึ้น เมื่อครั้งที่คอมพิวเตอร์ได้มีขึ้น การตอบสนองในครั้งแรกคือ “มันเยี่ยมมาก! เราสามารถที่จะใช้คอมพิวเตอร์ในการสร้างตาราง และมันก็ทำได้ดีไม่มีข้อผิดพลาด” มันกลายเป็นจริง (โดยส่วนใหญ่) แต่ก็ยังไม่ค่อยรอบคอบ หลังจากนั้นไม่นานคอมพิวเตอร์และเครื่องคิดเลขได้แพร่หลายเป็นผลทำให้ ตาราง กลายเป็นสิ่งที่ล้าสมัย
 สำหรับการดำเนินการบางอย่างเกือบทั้งหมด คอมพิวเตอร์ใช้ตารางของค่าในการหาค่าประมาณและหลังจากนั้นกระทำการปรับปรุงการประมาณนั้น
 แม้ว่า ตาราง log จะไม่มีประโยชน์อย่างที่มันเคยเป็นมาก่อน มันก็ยังเป็นตัวอย่างที่ดีของ iteration โปรแกรมต่อไปนี้แสดงผลลัพธ์เป็นลำดับของค่าในแถวทางด้านซ้ายมือ และค่า logarithm ของค่านั้นๆในแถวด้านขวามือ
 x = 1.0
 while x < 10.0:
 print x, ‘\t’ , math.log(x)
 x = x + 1.0
 sting ‘\t’ ทำหน้าที่แทน tab.
 characters และ stings ที่ถูกแสดงบนจอ เครื่องหมายซึ่งมองไม่เห็นนั้นเรียกว่า cursor ควบคุมเส้นทางของตัวอักษรที่จะปรากฏต่อไป. หลังจาก print statement โดยปรกติ cursor จะไปเริ่มต้นที่บรรทัดใหม่
 tab จะย้าย cursor ไปยังด้านขวากระทั่งถึงจุดที่ tab หยุด Tabs มีประโยชน์ สำหรับการสร้างแถวของเนื้อหาที่เรียงกัน อย่างในผลลัพธ์ของโปรแกรมที่ได้กล่าวมาข้างต้น:
 1.0 0.0
 2.0 0.69314718056
 3.0 1.09861228867
 4.0 1.38629436112
 5.0 1.60943791243
 6.0 1.79175946923
 7.0 1.94591014906
 8.0 2.07944154168
 9.0 2.19722457734
 ถ้าค่าเหล่านี้ดูเหมือนว่าแปลกๆ จำไว้ว่า การทำงานของ log นั้นใช้ฐาน e เมื่อครั้งกำลังของสอง มีความสำคัญใน วิทยาศาสตร์คอมพิวเตอร์ บ่อยครั้งที่เราต้องการที่จะหาค่า logarithm กับ ความสัมพันธ์ของฐาน 2 ในการทำเช่นนั้น เราสามารถใช้สูตรดังนี้:
เปลี่ยนชุดคำสั่งแสดงผลเป็น:
 print x, ‘\t’ , math.log(x)/math.log(2.0)
 ผลคือ:
 1.0 0.0
 2.0 1.0
 3.0 1.58496250072
 4.0 2.0
 5.0 2.32192809489
 6.0 2.58496250072
 7.0 2.80735492206
 8.0 3.0
 9.0 3.16992500144
 เราเห็นได้ว่า 1, 2, 4, และ8 เป็นค่ากำลังของสองเนื่องจากค่า logarithm ของมันฐานสองเป็นตัวเลขจำนวนเต็ม ถ้าเราต้องการที่จะหาค่า logarithm ของตัวอื่นๆที่เป็นค่ากำลังของสอง เราสามารถที่จะแก้ไขโปรแกรมดังนี้:
 x = 1.0
 while x < 100.0:
 print x, ‘\t’ , math.log(x)/math.log(2.0)
 x = x * 2.0
 ตอนนี้แทนที่จะบวกบางอย่างกับ x ในแต่ละครั้งที่ผ่านเข้าไปใน loop ด้วยแทนที่ด้วยลำดับของเลขคณิต เราคูณ x ด้วยบางอย่าง ผลลัพธ์ที่ได้คือ:
 1.0 0.0
2.0 1.0
 4.0 2.0
 8.0 3.0
 16.0 4.0
 32.0 5.0
 64.0 6.0
 เนื่องจาก tab ระหว่างแถว ตำแหน่งของแถวที่สองไม่ได้ขึ้นอยู่กับตัวเลขในแถวแรก.
ตาราง logarithm อาจไม่มีประโยชน์อีกต่อไป แต่สำหรับนักวิทยาศาสตร์คอมพิวเตอร์ การรู้กำลังของสองยังคงมีประโยชน์อยู่!
 ตัวอักษร Blackslash ใน ‘\t’ แสดงถึงการเริ่มต้นของ escape sequence escape sequence จะใช้ทำหน้าที่แทนตัวอักษรซึ่งมองไม่เห็นอย่างเช่น tabs และ newlines \n ทำหน้าที่แทนการขึ้นบรรทัดใหม่
 escape sequence สามารถปรากฏได้ทุกที่ใน sting; ในตัวอย่าง, tab escape sequence คือสิ่งเดียวใน sting?
6.4 Two-dimensional tables.
ตาราง 2 มิติ คือตารางซึ่งคุณอ่านค่าที่จุดตัดของ row และ column ตารางสูตรคูณเป็นตัวอย่างที่ดีอันหนึ่ง ให้บอกมาว่าคุณต้องการที่จะแสดงตารางสูตรคูณสำหรับค่าตั้งแต่ 1 ถึง 6
การเริ่มต้นที่ดีคือเขียน loop ที่จะทำการแสดงการคูณของ 2 ทั้งหมดลงบนบรรทัดเดียว:
 i = 1
 while i <= 6:
 print 2*i, ‘ ‘,
 i = i + 1
 print
 บรรทัดแรกกำนหดตัวแปรชื่อ i ซึ่งทำหน้าที่เป็นตัวนับหรือเป็น loop variable. ขณะที่ loop ดำเนินการ ค่าของ i จะเพิ่มจาก 1 ถึง 6. เมื่อ i เป็น 7, loop จะยุติ ในแต่ละครั้งที่ผ่านเข้าไปใน loop มันจะแสดงค่าของ 2*i แล้วตามด้วย space 3ช่อง
 อีกครั้ง คอมม่า  ใน print statement จะทำการยกเลิกการขึ้นบรรทัดใหม่ หลังจากที่ loop เสร็จสิ้นแล้ว ตัวที่สองของ print statement จะทำการขึ้นบรรทัดใหม่
ผลลัพธ์ของโปรแกรมคือ:
2 4 6 8 10 12
 ขั้นต่อไปคือ encapsulate และ generalize 
6.5 Encapsulation and generalization.
Encapsulation คือกระบวนการตัดเอาส่วนของ code เป็น function เพื่อให้คุณได้เอาข้อดีของฟังก์ชั่น ที่ดีสำหรับคุณไป คุณได้เห็นตัว 2 อย่างของ encapsulation: printParity ในตอนที่ 4.5; และ isDivisible ในตอนที่ 5.4
 Generalization หมายถึงการนำเอาบางอย่างที่พิเศษหรือโดยเฉพาะ เช่นการแสดงของการคูณของ 2 และทำให้มันเป็นมากกว่าทั่วๆไป เช่นแสดงการคูณของจำนวนเต็มใดๆ
ฟังก์ชั่นนี้ทำการตัดเอาส่วนของ previous loop และทำการเอามันมาทำการแสดงผลการคูณของ n:
def printMultiples(n):
 i = 1
 while i <= 6:
 print n*i, ‘\t’ ,
 i = i + 1
 print
 ในการ encapsulate สิ่งที่เราต้องทำคือ เพิ่มบรรทัดแรก, ซึ่งประกาศชื่อของฟังก์ชั่นและค่าพารามิเตอร์(ค่าที่จะส่งเข้าไปประมวลผลภายใน) การ generalize ที่เราต้องทำคือ แทนค่า 2 ที่พรารามิเตอร์ n
 หากเราเรียกฟังก์ชั่นนี้ด้วย argument 2(ตัวแปรที่ใช้รับค่าเข้าฟังก์ชั่น), เราจะได้ผลลัพธ์เช่นเดียวกับก่อนหน้านี้
 ด้วยค่า argument 3 ผลลัพธ์คือ:
 3 6 9 12 15 18
 ด้วยค่า argument 4, ผลลัพธ์คือ:
 4 8 12 16 20 24
 ตอนนี้คุณสามารถที่จะคาดเดาได้ว่าจะแสดงตารางสูตรคูณได้อย่างไร—ด้วยการเรียก printMultiples อย่างซ้ำๆ ด้วยค่า argument ที่ต่างกัน จริงๆแล้ว เราสามารถใช้ loop อื่นๆ:
 i = 1
 while i <= 6;
 printMultiples(i)
 i = i + 1
 ข้อสังเกต loop นี้เหมือนกันกับ loop ใน printMultiples b อย่างไร ทั้งหมดที่เราทำคือแทนที่ print statement ด้วย function call
 ผลลัพธ์ของโปรแกรมเป็นตารางสูตรคูณ:
 1 2 3 4 5 6
 2 4 6 8 10 12
 3 6 9 12 15 18
 4 8 12 16 20 24
 5 10 15 20 25 30
 6 12 18 24 30 36
6.6 More encapsulation.
เพื่ออธิบาย encapsulation อีกครั้ง นำเอา code จากตอนท้ายของตอนที่ 6.5 และตัดมาเป็น function:
 def printMultTable:
 i = 1
 while i <= 6:
 printMultiples(i)
 i = i + 1
 กระบวนการนี้เป็น development plan(กระบวนการสำหรับโปรแกรมที่กำลังพัฒนา ในบทนี้ เราได้สาธิตรูปแบบของการพัฒนาซึ่งตั้งอยู่บนการพัฒนาสิ่งที่เฉพาะให้ง่ายขึ้นและทำการ encapsulating และ generalizing) เราพัฒนา code โดยการเขียนบรรทัดของ code ไว้นอก function หรือพิมพ์มันใน interpreter เมื่อเราได้ code ที่ใช้งานได้ เราจึงตัด code นั้นมาเป็น function
development plan มีประโยชน์อย่างยิ่ง ซึ่งถ้าคุณไม่รู้ เมื่อคุณเริ่มต้นการเขียน จะทำการแยกโปรแกรมไปเป็น function ได้อย่างไร การเข้าใกล้นี้จะช่วยให้คุณออกแบบในขณะที่คุณดำเนินต่อ
6.7 Local variables.
คุณอาจจะสงสัยว่าเราใช้ตัวแปรที่เหมือนกันได้อย่างไร, i, ในทั้งสอง function คือ printMultiples และ printMultTable มันจะไม่ทำให้เกิดปัญหาเหรอ เมื่อ function หนึ่งเปลี่ยนค่าของตัวแปร?
 คำตอบคือไม่ เพราะว่า i ใน printMultiples และ i ใน printMultTable ไม่ได้เป็นตัวแปรตัวเดียวกัน
 ตัวแปรถูกสร้างขึ้นภายใน function ที่กำหนดให้เป็น local; คุณไม่สามารถเข้าถึงตัวแปรที่เป็น local ได้จากภายนอก function ของมัน นั่นหมายถึงคุณมีอิสระที่จะมีตัวแปรที่มีชื่อเดียวกันได้หลายตัวตราบเท่าที่มันไม่ได้อยู่ภายใน function เดียวกัน
stack diagram สำหรับโปรแกรมนี้แสดงให้เห็นว่าตัวแปรที่ชื่อ i ไม่ได้เป็นตัวแปรเดียวกัน พวกมันสามารถอ้างถึงค่าที่แตกต่างกัน และเมื่อตัวหนึ่งมีการเปลี่ยนค่าก็จะไม่ส่งผลต่ออีกตัวหนึ่ง
ค่าของ i ใน printMultiples วิ่งจาก 1 ถึง 6 ใน diagram จะเกิดขึ้นแค่ 3 ครั้งต่อไปที่วิ่งเข้า loop มันจะกลายเป็น 4 ในแต่ละครั้งที่เข้าไปใน loop, printMultTable จะเรียก printMultiples ด้วยค่าปัจจุบันของ i เป็น argument ค่านั้นจะกำนหดค่าให้กับ parameter n
 ภายใน printMultiples ค่าของ i วิ่งจาก 1 ถึง 6 ใน diagram จะเกิดขึ้นแค่ 2. การเปลี่ยนคตัวแปรนี้จะไม่มีผลต่อค่า i ใน printMultTable
 มันธรรมดาและถูกต้องอย่างแท้จริงที่มีตัวแปร local ที่ต่างกัน ซึ่งมีชื่อเหมือนกัน โดยเฉพาะ ชื่ออย่าง i และ j ซึ่งถูกใช้บ่อยครั้ง เป็น ตัวแปร loop ถ้าคุณหลีกเลี่ยงที่จะใช้มันใน function เนื่องจากคุณเคยใช้มันในที่ใดที่หนึ่ง, เป็นไปได้ที่คุณจะทำให้โปรแกรมนั้นอ่านยากขึ้น
6.8 More generalization.
อย่างตัวอย่างอื่นๆของ generalization ลองคิดว่าคุณต้องการโปรแกรมที่จะแสดงผลของตารางสูตรคูณได้ทุกขนาด ไม่ใช่แค่เพียงตารางขนาด 6x6 คุณสามารถเพิ่ม parameter ใน printMultTable:
 def printMultTable(high):
 i = 1
 while i <= hight:
 printMultiples(i)
 i = i + 1
 เราแทนที่ค่า 6 ด้วย parameter high. ถ้าเราเรียก printMultTable ด้วยค่า argument 7, มันจะแสดงดังนี้:
 1 2 3 4 5 6
 2 4 6 8 10 12
 3 6 9 12 15 18
 4 8 12 16 20 24
 5 10 15 20 25 30
 6 12 18 24 30 36
 7 14 21 28 35 42
 ยอดเยี่ม ยกเว้นบางทีเราต้องการตารางที่เป็นสี่เหลี่ยมที่มีจำนวน row และ column เท่ากัน ซึ่งจะทำเช่นนั้น เราเพิ่ม parameter ตัวอื่นเข้าไปยัง printMultiples เพื่อกำหนดว่าควรจะมี column เท่าไหร่
 function ที่ต่างกันสามารถมี parameter ที่มีชื่อเดียวกันได้(เช่นเดียวกับ local variable)
นี่คือโปรแกรมทั้งหมด:
 def printMultiples(n, high):
 i = 1
 while i <= high:
 print n*i, ‘\t’,
 i = i +1
 print
 def printMultTable(high):
 i = 1
 while i <= high:
 printMultiples(i, high)
 i = i +1
 ข้อสังเกต เมื่อเราได้เพิ่ม parameter ใหม่ เราต้องทำการเปลี่ยนบรรทัดแรกของ function (function heading) และเราก็ต้องเปลี่ยนที่ที่ function ถูกเรียกใน printMultTable
อย่างที่คาดเอาไว้ โปรแกรมนี้สร้างตารางขนาด 7x7:
 1 2 3 4 5 6 7
 2 4 6 8 10 12 14
 3 6 9 12 15 18 21
 4 8 12 16 20 24 28
 5 10 15 20 25 30 35
 6 12 18 24 30 36 42
 7 14 21 28 35 42 49
 เมื่อคุณ generalize function อย่างเหมาะสมแล้ว คุณมักจะได้โปรแกรมกับความสามารถที่คุณไม่ได้ออกแบบเอาไว้ ตัวอย่าง คุณอาจจะสังเกตเห็น เนื่องจาก ab = ba การบันทึกลงในตารางทั้งหมดเกิดขึ้นสองครั้ง คุณสามารถประหยัดหมึกโดยการสั่งปริ้นท์เพียงครึ่งเดียวของตาราง การทำเช่นนั้น คุณเพียงเปลี่ยนบรรทัดเดียวของ printMultTable
 เปลี่ยน
 printMultiples(i, high)
 เป็น
 printMultiples(i, i)
 และคุณจะได้
 1 
 2 4
 3 6 9
 4 8 12 16
 5 10 15 20 25
 6 12 18 24 30 36
 7 14 21 28 35 42 49
6.9 Functions.
เพียงไม่กี่ครั้งในคราวนี้ เราได้กล่าวถึง “หน้าที่ต่างๆที่ดีสำหรับทุกๆสิ่ง” ถึงตอนนี้ ท่านอาจแปลกใจว่าสิ่งเหล่านี้คืออะไรกันแน่ นี่คือบางสิ่ง:
• ให้ชื่อกับลำดับของ statement ทำให้โปรแกรมของคุณง่ายต่อการอ่านและง่ายต่อการแก้ไขข้อผิดพลาด
• แยกโปรแกรมที่ยาวๆออกเป็น function อนุญาตให้คุณแยกส่วนของโปรแกรม แยกการ debug โปรแกรมแบบเดี่ยวๆ และทำการประกอบมันเข้าทั้งหมด
• function ที่ออกแบบดี จะมีประโยชน์สำหรับหลายๆโปรแกรม ครั้งหนึ่งที่คุณเขียนโปรแกรมและแก้ไขมัน คุณสามารถนำมันมาใช้อีกได้
6.10 Glossary.
multiple assignment: Making more than one assignment to the same variable during the execution of a program.
 iteration: Repeated execution of a set of statements using either a recursive function call or a loop.
 loop: A statement or group of statements that execute repeatedly until a terminating condition is satisfied.
 infinite loop: A loop in which the terminating condition is never satisfied.
 body: The statements inside a loop.
 loop variable: A variable used as part of the terminating condition of a loop.
 tab: A special character that causes the cursor to move to the next tab stop on the current line.
 newline: A special character that causes the cursor to move to the beginning of the next line.
 cursor: An invisible marker that keeps track of where the next character will be printed.
 escape sequence: An escape character (n) followed by one or more printable characters used to designate a nonprintable character.
 encapsulate: To divide a large complex program into components (like functions) and isolate the components from each other (by using local variables, for example).
 generalize: To replace something unnecessarily specific (like a constant value) with something appropriately general (like a variable or parameter). Generalization makes code more versatile, more likely to be reused, and sometimes even easier to write.
 development plan: A process for developing a program. In this chapter, we demonstrated a style of development based on developing code to do simple,
specific things and then encapsulating and generalizing.