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

<ns>0</ns>
 <revision>
 <parentid>35690</parentid>
 <timestamp>2019-09-24T03:47:21Z</timestamp>
 <contributor>
 <username>Geonuch</username>
 </contributor>
 <minor />
 <origin>52666</origin>
 <model>wikitext</model>
 <format>text/x-wiki</format>
บทที่ 3 Functions.
3.1 Function calls.
คุณได้เห็นตัวอย่างของ function call แล้ว
 »> type (“32”)
 <type ‘str’>
 ชื่อของฟังก์ชัน คือ type และมันแสดงชนิดของค่าหรือตัวแปรที่ใส่เข้าไป ค่าหรือตัวแปร ซึ่งถูกเรียกว่า argument ของฟังก์ชัน โดยอยู่ภายใต้วงเล็บ มันเป็นธรรมดาที่ฟังก์ชันจะรับค่า argument และ แสดงผลลัพธ์ออกมา ผลลัพธ์ที่ได้จะเรียกว่า return value 
 แทนที่จะพิมพ์ค่าผลลัพธ์ พวกเราสามารถกำหนดมันเป็นตัวแปรแทน
 »>betty = type(“32”)
 »>print betty 
 <type ‘str’>
 อีกตัวอย่าง ฟังก์ชัน id รับค่าหรือตัวแปร และแสดงค่า integer ที่ไม่ซ้ำใครออกมา
 »> id(3)
 134882108
 »> betty = 3 
 »> id(betty)
 134882108
 ทุกๆ ค่ามี id ซึ่งเป็นค่าที่เป็นเอกลักษณ์ในตัวเอง โดยมันถูกเก็บไว้ในหน่วยความจำของคอมพิวเตอร์ id ของตัวแปรคือ id ของค่าซึ่งมันอ้างอิงถึง
3.2 Type conversion.
ภาษา Python มีการ built-in ฟังก์ชัน ที่ใช้ในการเปลี่ยนค่าชนิดของข้อมูลจากชนิดหนึ่งเป็นอีกชนิดหนึ่ง ฟังก์ชัน int รับค่าและเปลี่ยนเป็น integer ถ้าทำได้ หรือ อธิบายเป็นอย่างอื่นถ้าทำไม่ได้
 »> int(“32”)
 32
 »> int (“Hello”)
 ValueErrr: invalid literal for int: Hello
 int สามารถเปลี่ยน floating-point เป็น integer แต่จำวามันจะตัดเศษหลังจุดทศนิยมทิ้งไป
 »> int(3.99999)
 3
 »> int(-2.3)
 -2
 ฟังก์ชัน float เปลี่ยนจาก integer และ string เป็น floating-point
 »> float(32)
 32.0
 »> float(“3.14159”)
 3.14159
 สุดท้าย ฟังก์ชัน str เปลี่ยนเป็น string
 »> str(32)
 ‘32’
 »> str(3.14149)
 ‘3.14149’
 มันอาจจะดูแปลกที่ ภาษา Python ทำให้เกิดความแตกต่างระว่างค่าของ 1 ที่เป็น integer กับ floating-point มันอาจจะเป็นตัวเลขที่เหมือนกัน แต่เป็นชนิดที่ต่างกัน เหตุผล คือ ค่าที่เก็บภายในคอมพิวเตอร์แตกต่างกัน
3.3 Type coercion.
ขณะนี้พวกเราสามารถเปลี่ยนแปลง types กันได้ พวกเรามีวิธีจัดการกับการหาร integer เมื่อกลับไปดูตัวอย่างของบทก่อนหน้านี้ สมมติว่าเราต้องการคำนวณเศษของชั่วโมงที่ผ่านพ้นไป สิ่งที่แสดงออกมาอย่างชัดเจนคือ นาที/60 และมันจะแสดงค่าออกมาเป็น integer โดยผลลัพธ์ที่ได้จะเป็น 0 เสมอ ถึงแม้จะผ่านมาแล้ว 59 นาทีก็ตาม
 วิธีการแก้ปัญหาเปลี่ยน minute เป็น floating-point และทำการหาร floating-point
 »> minute = 59
 »> float(minute) / 60
 0.983333333333
 อีกวิธีการหนึ่ง พวกเราสามารถใช้ข้อได้เปรียบจากกฎของการเปลี่ยน type อัตโนมัติ ซึ่งเรียกว่า type coercion สำหรับการคำนวณทางคณิตศาสตร์ ถ้าตัวหนึ่งเป็น float อีกตัวจะเปลี่ยนเป็น float ด้วยอัตโนมัติ
 »> minute = 59
 »> minute / 60.0
 0.983333333333
 โดยการทำให้เศษส่วนที่หารเป็น float พวกเราบังคับว่า python จะต้องทำการหารออกมาเป็น floating-point
3.4 Math functions.
ในคณิตศาสตร์ เป็นไปได้มากที่คุณจะได้เห็นในลักษณะของฟังก์ชัน sin และ log และคุณจะได้เรียนในการหาค่าในลักษณะของ sin(pi/2) และ log(1/x) สิ่งแรกคือ คุณต้องหาค่าในวงเล็บ (argument) ออกมาก่อน สำหรับตัวอย่าง pi/2 ค่าโดยประมาณคือ 1.571 และ 1/x คือ 0.1 ถ้า x มีค่าเท่ากับ 10
 แล้วคุณหาค่าฟังก์ชันของตัวมันเอง ถ้าไม่ก็หาค่าจากตาราง หรือ โดยการคำนวณที่หลากหลาย sin 1.571 คือ 1 และ log 0.1 คือ -1 โดยสมมติให้เป็น log ฐาน 10
 กระบวนการนี้สามารถนำไปประยุกต์ใช้ได้บ่อยๆ เพื่อที่จะหาค่าในลักษณะที่ยากขึ้นแบบ log(1/sin(pi/2)) สิ่งแรกคือ คุณต้องหาค่าของ argument ของฟังก์ชันข้างในสุดก่อน แล้วหาค่าของฟังก์ชัน
 Python มี module ของคณิตศาสตร์ ซึ่งเป็นฟังก์ชันทางคณิตศาสตร์ที่รู้จักกันดี module คือ ไฟล์ที่บรรจุการเก็บรวมรวมกลุ่มของฟังก์ชันที่มีความเชื่อมโยงกันเข้าไว้ด้วยกัน
 ก่อนที่พวกเราจะใช้ฟังก์ชันจาก module พวกเราต้องทำการ import ฟังก์ชันเหล่านั้นก่อน
 »> import math
 เมื่อเรียกฟังก์ชันออกมาแล้ว พวกเราต้องกำหนดชื่อของ module และชื่อของฟังก์ชัน แยกกันโดยใช้จุด (.) 
 »> decibel = math.log10 (17.0)
 »> angle = 1.5
 »> height = math.sin(angle)
 statement แรกคือสร้าง decibel log 17 ฐาน 10 ฟังก์ชันจะเรียกlogออกมา ซึ่งเป็น log ฐาน e
 statement ที่สาม หาค่าของ sin ของตัวแปร angle sin และฟังก์ชันตรีโกณมิติอื่นๆ รับค่า argument ใน radians เพื่อเปลี่ยนจาก องศา เป็น radians โดยการหาร 360 และคูณโดยใช้ 2 * pi สำหรับตัวอย่าง หาค่า sin 45 สิ่งแรกคือ คำนวณ angle ใน radians และ take sine เข้าไป
 »> degrees = 45
 »> angle = degrees * 2 * math.pi / 360.0
 »> math.sin(angle)
 0.707106781187 
 ค่าคงที่ของ pi เป็นส่วนหนึ่งของ math module ด้วย คุณสามารถตรวจสอบผลลัพธ์ก่อนหน้านี้โดยเปรียบเทียบกับ รากที่สองของ 2 หาร 2 
 »> math.sqrt(2) / 2.0
 0.707106781187
3.5 Composition.
ฟังก์ชันต่างๆ ใน python สามารถถูกประกอบกันขึ้นได้ หมายความว่า คุณใช้ expression กับส่วนของอีกอันหนึ่ง ดังเช่นตัวอย่าง คุณใช้ expression ใดๆ กับ argument ของฟังก์ชัน
 »> x = math.cos(angle + math.pi/2)
 statement นี้ นำค่าของ pi หาร 2 และบวก ด้วยผลลัพธ์ของ angle ผลรวมที่ได้เป็น argument ที่จะผ่านค่าไปยังฟังก์ชัน cos 
 คุณสามารถนำผลลัพธ์ของฟังก์ชันหนึ่ง และส่งผ่านค่านี้ไปยัง argument อีกอันหนึ่ง
 »> x = math.exp(math.log(10.0))
 statement นี้หาค่าของ log ฐาน e ของ 10 และทำการยกกำลัง e ผลลัพธ์ที่ได้สมมติว่าเป็น x 
3.6 Adding new functions.
จนถึงตอนนี้ พวกเราได้ใช้เพียงฟังก์ชันที่มาจาก python แต่เป็นไปได้ที่เราจะสร้างฟังก์ชันขึ้นใหม่ การสร้างฟังก์ชันใหม่เพื่อที่จะแก้ปัญหาของคุณโดยเฉพาะ คือ ใช้ให้มีประโยชน์มากที่สุดเกี่ยวกับวัตถุประสงค์ทั่วไปของภาษา programming
 ในบริบทของการเขียนโปรแกรม ฟังก์ชันเป็นชื่อของ statement ที่เรียงต่อเนื่องกัน ซึ่งกระทำตามความต้องการของการดำเนินการ การดำเนินการนี้ถูกระบุใน function definition ฟังก์ชันต่างๆ พวกเราได้ใช้และระบุเพื่อพวกเรา และการจำกัดความค่าเหล่านี้จะถูกซ่อนไป นี้คือสิ่งที่ดี เพราะ มันอนุญาตให้พวกเราใช้ฟังก์ชันต่างๆ โดยปราศจากความกังวลเกี่ยวกับรายระเอียดของการจำกัดความ
 syntax สำหรับ function definition คือ 
 def NAME(LIST OF PARAMETERS):
 STATEMENTS
 คุณสามารถสร้างชื่อใดๆ ที่คุณต้องการสำหรับฟังก์ชันที่คุณสร้างขึ้น แต่ยอมรับว่าคุณไม่สามารถใช้ชื่อซึ่งเป็น keyword ใน python ต้องระบุว่าพารามิเตอร์มีข้อมูลอะไร ถ้าอันอื่นๆ คุณต้องเตรียมเพื่อที่จะใช้ฟังก์ชันใหม่
 สามารถมีจำนวน statement ภายในฟังก์ชันได้ แต่ต้องเยื้องเข้าไปจากด้านซ้าย ตัวอย่างในหนังสือเล่มนี้ พวกเราจะใช้การเว้นวรรคเข้าไป 2 ครั้ง
 เริ่มเขียนโดย พวกเราตั้งใจเขียนโดยไม่มีพารามิเตอร์ ดังนั้น syntax ที่ออกมาจะมีลักษณะดังนี้
 def newLine:
 print
 ฟังก์ชันนี้ ชื่อ newLine วงเล็บที่ว่างเปล่าระบุถึงการไม่มีพารามิเตอร์ มันเก็บเพียง statement อันเดียว ซึ่งผลลัพธ์คือ บรรทัดใหม่หนึ่งบรรทัด
 syntax สำหรับการเรียกฟังก์ชันใหม่เหมือนกับ syntax ของฟังก์ชัน built-in
 print "First Line."
 newLine
 print "Second Line."
 ผลลัพธ์ของโปรแกรมนี้ คือ
 First line.
 Second line.
 สังเกตว่าช่องว่างพิเศษระหว่าง 2 บรรทัด อะไรที่เราต้องการถ้าเพิ่มที่ว่างระหว่างบรรทัด พวกเราสามารถเรียกฟังก์ชันเดิมซ้ำๆ ได้
 print "First Line."
 newLine
 newLine
 newLine
 print "Second Line."
 หรือพวกเราสามารถเขียนฟังก์ชันใหม่ ชื่อว่า threeLines โดยพิมพ์บรรทัดว่าง 3 บรรทัด
 def threeLines:
 newLine
 newLine
 newLine
 print "First Line."
 threeLines
 print "Second Line."
 ฟังก์ชันนี้บรรจุ 3 statement โดยทั้งหมดจะทำการเว้นวรรคเข้าไป 2 ครั้ง ตั้งแต่ statement ถัดไปไม่ต้องเยื้องเข้าไป python รู้ว่ามันไม่ใช่ส่วนหนึ่งของฟังก์ชัน
 คุณควรสังเกต 2-3 สิ่งเกี่ยวกับโปรแกรมนี้
 1. คุณสามารถเรียกกระบวนการเดิมซ้ำๆ ในความเป็นจริงมันค่อนข้างเกิดขึ้นบ่อยและเราก็ใช้ประโยชน์จากมัน
 2. คุณสามารถใช้ฟังก์ชันหนึ่งเพื่อเรียกอีกฟังก์ชันหนึ่ง ใน case นี้ threeLines เรียก newLine
 ในตอนนี้มันอาจไม่ชัดเจนว่าทำไมมันเป็นประโยชน์กับปัญหาที่สร้างฟังก์ชันใหม่เหล่านี้ขึ้นมา ตามความเป็นจริง มีเหตุผลมากมาย แต่จากตัวอย่างนี้อธิบายได้ 2 อย่างคือ
 - การสร้างฟังก์ชันใหม่ให้โอกาสในการตั้งชื่อของกลุ่ม statement ฟังก์ชันต่างๆ สามารถทำให้โปรแกรมดูง่ายขึ้น โดยการซ่อนวิธีการคำนวณที่ซับซ้อนไว้ภายใต้ single command โดยแทนด้วยชื่อฟังก์ชันแทนที่โค้ดที่ซ่อนไว้
 - การสร้างฟังก์ชันใหม่สามารถทำให้โปรแกรมเล็กลงโดยกำจัดโค้ดที่ซ้ำๆกันออกไป ตัวอย่างเช่น วิธีที่จะพิมพ์บรรทัดใหม่ออกมา 9 บรรทัดให้เร็วที่สุด ให้เราเรียกใช้ threeLines สามครั้ง
3.7 Definitions and use.
เราดึงโค้ดมาจาก section 3.6
 def newLine:
 print
 def threeLines:
 newLine
 newLine
 newLine
 print "First Line."
 threeLines
 print "Second Line."
 โปรแกรมนี้บรรจุ 2 ฟังก์ชัน definition คือ newLine และ threeLines ฟังก์ชัน definition ได้ execute เหมือนกับ statement อื่นๆ แต่ผลที่ได้คือการสร้างฟังก์ชันใหม่ ฟังก์ชันภายใน statement จะไม่ทำการ execute จนกระทั่ง ฟังก์ชันถูกเรียก และ ฟังก์ชัน definition ไม่สร้างผลลัพธ์ออกมา
 คุณต้องสร้างหนึ่งฟังก์ชันก่อนที่คุณจะ execute มัน ฟังก์ชัน definition ต้อง execute ก่อนครั้งแรกที่มันจะถูกเรียก
3.8 Flow of execution.
เพื่อให้แน่ใจว่าฟังก์ชันถูกระบุก่อนที่มันจะใช้ คุณต้องรู้ว่าคำสั่งใน statement อันไหนที่ถูก execute ซึ่งเรียกว่า flow of execution
 Execution เริ่มต้นที่ statement แรกของโปรแกรมเสมอ statement ถูก execute โดยเรียงตามลำดับจากบนลงล่าง
 ฟังก์ชัน definition ไม่เป็นไปตาม flow of execution ของโปรแกรม แต่จะจำฟังก์ชันภายใน statement ที่ไม่ execute จนกระทั่งฟังก์ชันถูกเรียก ถึงแม้ไม่ได้อยู่ด้วยกัน คุณสามารถระบุฟังก์ชันหนึ่งภายในอีกอันหนึ่งได้ ใน case นี้ ภายใน definition ไม่ถูก execute จนกว่าฟังก์ชันภายนอกจะถูกเรียก
 ฟังก์ชัน calls มีลักษณะเป็น flow of execution ที่วกวน แทนที่การเข้าไปใน statement ถัดไป flow จะข้ามไปยังบรรทัดแรกของการเรียกฟังก์ชัน execute statement ทั้งหมดตรงนั้นและกลับมารับมันออกไป
 มันอาจจะดูเหมือนไม่ซับซ้อน จนกระทั่งคุณจำได้ว่า หนึ่งฟังก์ชันสามารถเรียกอีกฟังก์ชัน ขณะที่ในช่วงกลางของฟังก์ชัน โปรแกรมอาจต้อง execute statement ในอีกฟังก์ชันหนึ่ง แต่ขณะที่กำลัง execute ฟังก์ชันใหม่ โปรแกรมอาจจะยัง execute อีกฟังก์ชันอยู่ด้วย
 โชคดีที่ Python มีประสิทธิภาพในการเก็บรักษา track ที่มันอยู่ ดังนั้นแต่ละครั้งเมื่อฟังก์ชันทำงานเสร็จสมบูรณ์ โปรแกรมจะรับมันออกมาในฟังก์ชัน ซึ่งเรียกมัน เมื่อโปรแกรมทำงานจบลงที่เขียนขึ้นไม่ควรอ่านจากบนสุดมาล่างสุด ควรอ่านตาม flow ของการ execution
3.9 Parameters and arguments.
บางส่วนของฟังก์ชัน built-in ต้องการค่า arguments จะควบคุมค่าต่างๆ อย่างไรเพื่อให้ฟังก์ชันทำงานออกมาได้ ตัวอย่างเช่น ถ้าเราต้องการหาค่า sin ของตัวเลข คุณต้องกำหนดว่าตัวเลขคืออะไร ดังนั้น sin รับค่าตัวเลขเหมือน argument
 บางฟังก์ชันรับค่ามากว่า 1 argument ตัวอย่างเช่น pow รับค่า 2 arguments ตัวเลขพื้นฐานและเลขยกกำลัง ภายในฟังก์ชัน ค่าเหล่านี้จะถูกส่งผ่านไปซึ่งกำหนดเป็นตัวแปรที่เรียกว่า parameters
 นี้คือตัวอย่างของ ฟังก์ชัน user-defined ที่รับค่าพารามิเตอร์
 def printTwice(bruce):
 print bruce, bruce
 ฟังก์ชันนี้รับค่า argument ตัวเดียว และถูกกำหนดให้เป็นพารามิเตอร์ ชื่อ bruce ค่าพารามิเตอร์ถูกพิมพ์ค่าออกมา 2 ครั้ง ชื่อ bruce ถูกเลือกมาใช้เพื่อเป็นการแนะนำ ที่จริงแล้วชื่อของพารามิเตอร์ขึ้นอยู่กับคุณเองว่าจะตั้งอย่างไร แต่ควรให้มีความชัดเจน
 ฟังก์ชัน printTwice ทำงานใน type ที่ต่างชนิดกัน ซึ่งพิมพ์ค่าออกมาดังนี้
 »> printTwice('Spam')
 Spam Spam
 »> printTwice(5)
 5 5
 »> printTwice(3.14159)
 3.14159 3.14159
 ฟังก์ชันแรกที่ถูกเรียกเป็น string ฟังก์ชันที่สองเป็น integer และฟังก์ชันที่สามเป็น float
 หลักขององค์ประกอบที่เหมือนกันที่ประยุกต์ฟังก์ชัน built-in เช่นเดียวกับการประยุกต์ฟังก์ชัน user-defined ดังนั้นพวกเราสามารถใช้ชนิดของ expression ใดๆ สำหรับ printTwice
 »> printTwice('Spam'*4)
 SpamSpamSpamSpam SpamSpamSpamSpam
 »> printTwice(math.cos(math.pi))
 -1.0 -1.0
 ตามปกติ expression จะถูกประเมินค่าก่อนที่ฟังก์ชันจะทำการ run ดังนั้น printTwice prints SpamSpamSpamSpam SpamSpamSpamSpam แทนด้วย 'Spam'*4 'Spam'*4
 พวกเราสามารถใช้ตัวแปรแทน argument ได้ด้วย
 »> michael = 'Eric, the half a bee.'
 »> printTwice(michael)
 Eric, the half a bee. Eric, the half a bee.
 สังเกตว่าสิ่งที่สำคัญมาก คือ ชื่อของตัวแปรที่พวกเราผ่านค่าไปยัง argument (michael) ไม่ได้เกี่ยวข้องกับชื่อของพารามิเตอร์ (bruce) มันไม่เกิดขึ้นกับค่าอะไรก็ตามที่ถูกเรียกกลับไปตอนเริ่มแรก ในที่นี้ printTwice พวกเราเรียกว่า bruce ทุกตัว
3.10 Variables and parameters are local.
เมื่อพวกเราสร้าง local variable ภายในฟังก์ชัน มันจะอยู่ในฟังก์ชันเท่านั้นและคุณไม่สามารถใช้มันออกมาได้ ตัวอย่างเช่น 
def catTwice(part1, part2):
cat = part1 + part2
printTwice(cat)
 ฟังก์ชันนี้รับค่า 2 arguments เชื่อมเข้าด้วยกัน พิมพ์ค่าผลลัพธ์ออกมา 2 ครั้ง พวกเราสามารถเรียกฟังก์ชันที่มี 2 strings ดังนี้
»> chant1 = "Pie Jesu domine, "
»> chant2 = "Dona eis requiem."
»> catTwice(chant1, chant2)
Pie Jesu domine, Dona eis requiem. Pie Jesu domine, Dona eis requiem.
 เมื่อ catTwice สิ้นสุดลง ตัวแปร cat จะถูกทำลายไป ถ้าพวกเราลอง print อีกครั้ง จะได้ค่า error
 »> print cat
 NameError: cat
3.11 Stack diagrams.
การเก็บรักษา track ของตัวแปรสามารถใช้เป็นประโยชน์ในการวาด stack diagram ลักษณะของ stack diagram จะแสดงค่าของแต่ละตัวแปร แต่มันจะแสดงฟังก์ชันซึ่งเป็นของแต่ละตัวแปร
 แต่ละฟังก์ชันถูกทำหน้าที่โดย frame โดย frame คือ กล่องซึ่งมีชื่อของฟังก์ชันอยู่ด้านข้าง และ มีพารามิเตอร์และตัวแปรของฟังก์ชันอยู่ด้านใน ลักษณะตัวอย่าง stack diagram
คำสั่งของ stack แสดง flow of execution โดย printTwice ถูกเรียกโดย catTwice และ catTwice ถูกเรียกโดย __main__ ซึ่งเป็นชื่อพิเศษสำหรับฟังก์ชันสูงสุด เมื่อคุณสร้างตัวแปรภายนอกฟังก์ชันใดๆ มันจะเป็นของ __main__
 แต่ละพารามิเตอร์อ้างอิงถึงค่าที่เหมือนกัน เช่นเดียวกับ argument ที่เหมือนกัน ดังนั้น part 1 มีค่าเหมือนกับ chant 1 , part 2 มีค่าเหมือนกับ chant 2 และ bruce มีค่าเหมือนกับ cat
 ถ้าเกิด error ระหว่างการเรียกใช้ฟังก์ชัน python จะพิมพ์ค่าชื่อของฟังก์ชันและชื่อของฟังก์ชันที่เรียกมัน และชื่อของฟังก์ชันที่เรียกอีกทีหนึ่ง โดยทุกอย่างจะกลับไปสู่ __main__
 ตัวอย่างเช่น ถ้าพวกเราลองเข้าไปยัง cat จากการ printTwice พวกเราจะได้ NameError
 Traceback (innermost last):
 File "test.py", line 13, in __main__
 catTwice(chant1, chant2)
 File "test.py", line 5, in catTwice
 printTwice(cat)
 File "test.py", line 9, in printTwice
 print cat
 NameError: cat
 list ของฟังก์ชันนี้ถูกเรียกว่า traceback มันบอกคุณว่าไฟล์ของโปรแกรมเกิด error อะไร ที่บรรทัดไหน และฟังก์ชันอะไรที่กำลัง execute อยู่ที่เวลานั้น มันจะแสดงบรรทัดที่เป็นเหตุของการเกิด error
 สังเกตถึงความเหมือนระหว่าง traceback และ stack diagram มันจะไม่เกิดขึ้นพร้อมกัน
3.12 Functions with results.
คุณอาจจะสังเกตบางอย่างของฟังก์ชันที่เรากำลังใช้อยู่ เช่น ฟังก์ชัน math ถูกแทนที่ด้วยผลลัพธ์ ฟังก์ชันอื่นๆ เช่น newLine แสดงการกระทำออกมา แต่ไม่มีการ return ค่า จึงยกคำถามเหล่านี้ขึ้นมา
 - จะเกิดอะไรขึ้นถ้าเราเรียกฟังก์ชัน และไม่ได้ผลลัพธ์อะไรออกมา ?
 - เกิดอะไรขึ้นถ้าคุณใช้ฟังก์ชันโดยปราศจากผลลัพธ์ที่เป็นส่วนหนึ่งของ expression เช่น newLine + 7 ?
 - คุณสามารถเขียนฟังก์ชันที่หาค่าผลลัพธ์ หรือ คุณติดกับฟังก์ชันทั่วไปเช่น newLine และ printTwice ?
3.13 Glossary.
function call: A statement that executes a function. It consists of the name of the function followed by a list of arguments enclosed in parentheses.
 argument: A value provided to a function when the function is called. This value is assigned to the corresponding parameter in the function.
 return value: The result of a function. If a function call is used as an expression, the return value is the value of the expression.
 type conversion: An explicit statement that takes a value of one type and computes a corresponding value of another type.
 type coercion: A type conversion that happens automatically according to Python's coercion rules.
 module: A file that contains a collection of related functions and classes.
 dot notation: The syntax for calling a function in another module, specifying the module name followed by a dot (period) and the function name.