วิธีคิดแบบนักวิทยาการคอมพิวเตอร์/Variables, expressions and statements

บทที่ 2 Variable, expressions and statements.
2.1 Values and types.
Value เป็นหนึ่งในหลายๆ สิ่งพื้นฐาน เช่นตัวอักษร หรือตัวเลข Value ที่เราได้เห็นจนเดี๋ยวนี้คือ 2(ผลลัพธ์เมื่อเราเพิ่ม 1+1) และ “Hello, World!”
 ค่าเหล่านี้จัดอยู่ในรูปแบบที่ต่างกันคือโดยค่าในที่นี้ จะสามารถแบ่งออกได้เป็นประเภทต่างๆ เช่น 2 เป็น integer(จำนวนเต็ม) และ “Hello, World!” เป็น string(ข้อมูลชนิดข้อความ) ที่เรียกดังนั้นเนื่องจากมันประกอบด้วยชุดของตัวอักษร คุณ(และ interpreter) สามารถระบุ บ่งชี้ string ได้ เนื่องจากมันถูกปิดล้อมอยู่ในเครื่องหมายคำพูด
 print statement สามารถใช้กับ integers เช่นเดียวกัน
 »> print 4
 4
 ถ้าคุณไม่แน่ใจว่า value นั้นมีรูปแบบเป็นชนิดใด interpreter สามารถบอกคุณได้
 »> type("Hello, World!")
 <type ' str '>
 »> type(17)
 <type ' int '>
 อย่างไม่แปลกใจ, string เป็นสมาชิกของรูปแบบ str และ integers เป็น int อย่างเด่นชัด, ตัวเลขที่เป็นทศนิยมเป็นสมาชิกของรูปแบบที่เรียกว่า float, เนื่องจากตัวเลขเหล่านั้นเป็นสัญลักษณ์ของรูปแบบที่เรียกว่า floating-point
 »> type(32)
 <type ' float '>
 แล้วอย่างค่าเช่น “17” และ “32” ล่ะ? พวกมันดูเหมือนจะเป็น numbers, แต่พวกมันอยู่ในเครื่องหมายคำพูดเหมือนกับ strings
 »> type(“17”)
 <type ' str '>
 »> type(“32”) 
 <type ' str '>
พวกมันเป็น strings
 เมื่อคุณพิมพ์ตัวเลขที่มีค่ามากๆ คุณอาจใส่คอมม่าระหว่างกลุ่มของตัวเลขสามหลัก เช่นใน 1,000,000 นี่ไม่ถูกต้องตามหลักใน Python แต่เป็น expression ที่ถูกต้อง
 »> print 1,000,000
 1 0 0
 และนั่นก็เป็นสิ่งที่เราไม่ได้คาดเอาไว้! Python ตรวจสอบ 1,000,000 เป็นการแบ่งแยกจำนวนเต็มสามหลักด้วยคอมม่า ซึ่งมันแสดงอย่างต่อเนื่องกัน นี่เป็นตัวอย่างแรกที่เราได้เห็นความผิดพลาดชนิด semantic error: code รันโดยปราศจากข้อความแสดงการผิดพลาด แต่มันไม่ได้ทำตามผลลัพธ์ที่ถูกต้อง
2.2 Variables.
หนึ่งของลักษณะเฉพาะที่มีประสิทธิภาพมากที่สุดของ Programming language คือความสามารถในการจัดการกับตัวแปร ตัวแปรคือชื่อที่อ้างอิงถึง value(ค่า)
 assignment statement สร้างตัวแปรใหม่และให้ค่ากับตัวแปรเหล่านั้น
 »> message = "What’s up, Doc?"
 »> n = 17
 »> pi = 314159
 ตัวอย่างนี้กำหนดค่าให้กับตัวแปรสามตัว ตัวแรกกำหนด string “What’s up, Doc?” ด้วยตัวแปรที่ชื่อ message ตัวที่สองกำหนด integer 17 ให้กับตัวแปร n และตัวที่สามให้ floating-point 314159 กับ pi
 วิธีทั่วไปที่แทนค่าตัวแปรลงบนกระดาษคือ เขียนชื่อพร้อมกับลูกศรชี้ไปยังค่าของตัวแปรนั้นๆ รูปร่างลักษณะนี้เรียกว่า state diagram เพราะว่ามันแสดงสภาพแต่ละตัวแปรอยู่ในสภาพอะไร diagram นี้แสดงผลลัพธ์ของ assignment statement:
 print statement ทำงานกับตัวแปรด้วยเช่นเดียวกัน
 »> print message
 What’s up, Doc?
 »> print n
 17
 »> print pi
 314159
 ในแต่ละกรณีผลลัพธ์คือค่าของตัวแปร ตัวแปรมีรูปแบบด้วยเช่นกัน
 อีกครั้ง เราสามารถถาม interpreter ว่าพวกมันคืออะไร
 »> type(message)
 <type ‘str’>
 »> type(n)
 <type ‘int’>
 »> type(pi)
 <type ‘float’>
 รูปแบบของตัวแปรคือรูปแบบของค่าที่มันอ้างถึง
2.3 Variable names and keywords.
นักเขียนโปรแกรมโดยทั่วไปมักจะกำหนดชื่อตัวแปรสำหรับตัวแปรให้มีความหมายกับสิ่งที่ตัวแปรนั้นใช้แทน
 ชื่อของตัวแปรสามารถกำหนดให้ยาวได้ตามต้องการ มีได้ทั้งตัวอักษรและตัวเลข แต่มันต้องเริ่มต้นด้วยตัวอักษรเสมอ แม้ว่ามันจะถูกต้องที่ใช้ตัวอักษรพิมพ์ใหญ่ ตามข้อตกลงเราไม่ควรใช้มัน ถ้าคุณใช้ ให้จำไว้ว่า Bruce และ bruce เป็นตัวแปรที่ต่างกัน
 อักขระ(_) สามารถใช้ในกรณีที่ชื่อประกอบด้วยหลายคำ ตัวอย่างเช่น my_name หรือ print_of_tea_in_chaina
 ถ้าคุณให้ชื่อตัวแปรไม่ถูกต้องตามหลักการตั้งชื่อ ก็จะเกิด syntax error
 »> 76trombone = “big parade”
 SyntaxError: invalid syntax
 »> more$ = 1000000
 SyntaxError: invalid syntax
 »> class = “Computer Science 101”
 SyntaxError: invalid syntax
 76trombone ไม่ถูกต้องเนื่องจากมันไม่ได้ขึ้นต้นชื่อด้วยตัวอักษร more$ ไม่ถูกต้องเนื่องจากมันประกอบด้วยอักขระที่ไม่ถูกต้อง dollar sign แต่เกิดอะไรขึ้นกับ class?
class เป็น keywords ตัวหนึ่งของ Python Keywords เป็นตัวกำหนดกฎเกณฑ์และโครงสร้างของภาษา และพวกมันไม่สามารถนำมาใช้เป็นชื่อของตัวแปรได้
 Python มี keywords 29 ตัว:
and def exec if not return
assert del finally import or try
break elif for in pass while
class else from is print yield
continue except global lambda raise
 ถ้า interpreter กล่าวถึงชื่อของตัวแปรหนึ่งและคุณไม่ทราบว่าทำไม ให้ดูว่าชื่อนั้นอยู่ใน list นี้รึปล่าว
2.4 Statements.
Statement เป็นชุดของคำสั่งที่ interpreter ของ Python สามารถดำเนินการได้ ซึ่งที่ได้ผ่านมานั้นเราได้พบ statement อยู่ 2 ตัวคือ print และ assignment
 เมื่อคุณพิมพ์ statement บน command line, Python interpreter ดำเนินการกับมันและแสดงผลลัพธ์ซึ่ง print statement นั้น จะทำการแสดงผลลัพธ์ออกมาเป็นค่าที่เราได้พิมพ์ไป ส่วน assignment statement นั้นจะไม่แสดงผลออกมาเนื่องจาก เป็นการกำหนดค่าให้กับตัวแปรเท่านั้น
 Script โดยปรกติประกอบด้วยลำดับของ statements ถ้ามีมากกว่าหนึ่ง statement ผลลัพธ์ปรากฏขึ้นในครั้งนึงเป็น statement execute
จากตัวอย่างของ script นี้ 
print 1
x = 2
print x
ผลลัพธ์คือ
1
2
อีกครั้ง assignment statement ไม่แสดงผลลัพธ์
2.5 Evaluating expressions.
expression คือการรวมกันของ values(ค่า), variables(ตัวแปร) และ operators(สัญลักษณ์ที่ทำหน้าที่แทนการคำนวณ) ถ้าคุณพิมพ์ expression บน command line interpreter จะทำการประเมินผลและแสดงผลลัพธ์
»> 1+1
2
 แม้ว่า expression ประกอบด้วย values, variables และ operators ไม่จำเป็นที่ทุก expression ต้องประกอบไปด้วย elements เหล่านี้ ด้วยตัวค่าเองทั้งหมดจะถูกพิจารณาว่าเป็น expression และตัวแปรก็เช่นกัน
»> 17
17
»> x
2
 และการประมวลผลของ expression นั้นจะไม่เหมือนกับการสั่ง print โดยทีเดียว สังเกตดีๆ 
ตัวอย่าง
»> message = " What’s up, Doc?"
»> message
" What’s up, Doc?"
»> print message
What’s up, Doc?
 เมื่อ Python แสดงค่าของ expression มันจะใช้รูปแบบเดียวกันกับที่คุณได้ใส่ค่าไป ในกรณีของ strings นั้นหมายถึงรวมทั้งเครื่องหมายคำพูด(“ ”) แต่ print statement แสดงค่าของ expression, ซึ่งในกรณีนี้เป็นหัวข้อของ string
 ใน script โดยตัวของ expression เองเป็น statement ที่ถูกต้อง แต่มันจะไม่ทำอะไรเลย script
17
32
”Hello, World!”
1+1
 ไม่เกิดผลลัพธ์ขึ้นทั้งหมด คุณควรจะเปลี่ยน script เพื่อแสดงค่าของ expressions ทั้งสี่นี้อย่างไร?
2.6 Operators and operands.
 Operators คือ สัญลักษณ์พิเศษที่ทำหน้าที่แทนการคำนวณ อย่างการบวกและการคูณ ค่าที่ใช้กับ Operator นั้นเรียกว่า Operands 
 เหล่านี้เป็น Python expressions ที่ถูกต้อง:
 20+32 hour-1 hour*60+minute minute/60 5**2 (5+2)*(15-7)
 ซึ่งเครื่องหมาย +, -, และ / และวงเล็บสำหรับจัดกลุ่ม ความหมายใน Python มีความหมายเหมือนกับในทางคณิตศาสตร์ * เป็นเครื่องหมายของการคูณ และ ** เปนเครื่องหมายของการยกกำลัง
 ตัวแปรที่ปรากฏเมื่อจะมีการคำนวณเกิดขึ้น ค่าของตัวแปรจะถูกแทนที่ด้วยค่าที่กำหนดก่อนที่จะมีการกระทำใดๆเกิดขึ้น
 การบวก, การลบ, การคูณ และการยกกำลัง ทั้งหมดทำตามที่คุณคาดเอาไว้ แต่คุณอาจประหลาดใจกับการหาร operation เหล่านี้มีผลลัพธ์ที่ไม่เป็นไปตามที่คาดไว้:
»> minute = 59
»> minute/60
0
 ค่าของ minute คือ 59 และตามความจริงแล้วในทางคณิตศาสตร์ 59 หารด้วย 60 คือ 09833, ไม่ใช่ 0 เหตุผลของความแตกต่างกันคือ Python แสดงการหาร integer
 เมื่อ operands ทั้งคู่เป็น integers ผลลัพธ์ต้องเป็น integer ด้วย 
2.7 Order of operations.
เมื่อมี เครื่องหมายทางคณิตศาสตร์เกิดขึ้นมากกว่า 1 ตัวใน expression, คำสั่งของการประมวลผลขึ้นอยู่กับ rule of precedence(กฎของลำดับ) การที่จะทำการคำนวณที่เครื่องหมายใดก่อนนั้น จะเป็นไปตามกฎของลำดับ ดังนี้
 วงเล็บ จะมีลำดับสูงสุดและสามารถใช้เพื่อบังคับ expression ประมวลผลในคำสั่งที่คุณต้องการ expression ที่อยู่ในวงเล็บจะถูกประมวลผลก่อนเป็นลำดับแรก 2 * (3-1) เท่ากับ 4, และ (1+1)**(5-2) เท่ากับ 8 คุณสามารถใช้วงเล็บในการช่วยให้อ่านง่ายขึ้น เช่นใน (minute * 100) / 60 จะไม่ทำให้ผลลัพธ์เปลี่ยนแปลง
 ตัวยกกำลัง จะมีลำดับรองลงมา เช่น 2**1+1 เท่ากับ 3 ไม่ใช่ 4, และ 3*1***3 เท่ากับ 3 ไม่ใช่ 27
 ตัวคูนและตัวหาร จะอยู่ในระดับเดียวกัน ซึ่งจะมีลำดับที่สูงกว่า การบวกและการลบ, ซึ่งมีลำดับที่เท่ากัน เช่น 2*3-1 จะยอมรับว่าเท่ากับ 5 มากกว่าแทนที่จะเป็น 4 และ 2/3-1 เท่ากับ -1 ไม่ใช่ 1 (นึกถึงในการหาร integer 2/3=0)
 เครื่องหมายที่อยู่ในระดับเดียวกันนั้น การทำการคำนวณจะทำการคำนวณจาก ซ้ายไปขวา เช่นใน expression minute*100/60 การคูณจะเกิดขึ้นก่อน, ซึ่งจะได้ 5900/60 ซึ่งจะให้ผลออกมาเป็น 98 ถ้า operations ทำการประมวลผลจากขวาไปซ้าย, ผลลัพธ์ควรจะเป็น 59*1 ซึ่งเท่ากับ 59 ซึ่งเป็นคำตอบที่ผิด
2.8 Operation on strings.
โดยทั่วไปแล้วคุณจะไม่สามารถกระทำสัญลักษณ์ที่ใช้แทนการคำนวณทางคณิตศาสตร์กับ strings ได้ แม้ว่าจะเป็น strings ที่ดูเหมือนเป็นตัวเลข และนี่ก็เป็นตัวอย่างที่ไม่ถูกต้อง (สมมติให้ message เป็น string)
 message-1 "Hello"/123 message*"Hello" "15"+2
 เป็นที่น่าสนใจ เครื่องหมาย + สามารถใช้ร่วมกับ string ได้ ถึงแม้ว่ามันจะไม่ทำอย่างถูกต้องตามที่คุณคาดเอาไว้ สำหรับ string นั้นเครื่องหมาย + ใช้ทำหน้าที่แทนการเชื่อมต่อ ซึ่งเหมือนกับการเชื่อมต่อ ค่าสองค่า ตัวอย่างเช่น
fruit = "banana"
bakedGood = " nut bread"
print fruit + bakedGood
 ผลลัพธ์ที่ได้คือ banana nut bread ช่องว่างก่อนคำว่า nut เป็นส่วนหนึ่งของ string และมันจำเป็นที่จะต้องสร้างช่องว่างระหว่างการเชื่อมต่อ strings
 เครื่องหมาย * ก็ทำงานร่วมกับ string ได้ด้วยเช่นกัน โดยจะเป็นการกระทำซ้ำ เช่น "Fun"*3 จะได้ "FunFunFun" หนึ่งใน operands จะต้องเป็น string; อีกตัวจะต้องเป็น integer
การแปลความหมายของ + และ * เข้าใจด้วยความคล้ายกันกับ การบวกและการคูณ เช่น 4*3 เท่ากับ 4+4+4 เราคาดว่า “Fun”*3 จะเหมือนกันกับ “Fun”+ “Fun”+ “Fun” และมันก็ใช่ ในทางกลับกัน การเชื่อมต่อและการเกิดซ้ำของ string แตกต่างจากการบวกและการคูณของ integer
2.9 Composition.
ถึงตอนนี้ เราได้ดู elements ของโปรแกรม—variables, expressions และ statements--แบบเดี่ยวๆในตัวของมันเอง ซึ่งเราไม่ได้กล่าวถึงการรวม elements เหล่านั้นด้วยกันเลย 
 หนึ่งในลักษณะเฉพาะที่มีประโยชน์ที่สุดของ programming language นั้นก็คือการนำ block เล็กๆมาแล้วประกอบมันเข้าด้วยกัน ตัวอย่างเช่น เรารู้ว่าจะบวกตัวเลขอย่างไรและรู้ว่าจะแสดงผลอย่างไร; กลายเป็นเราสามารถทำทั้งสองอย่างในเวลาเดียวกัน
»> print 17+3
20
 ในความเป็นจริง, การบวกจะเกิดขึ้นก่อน printing(การแสดงผล) ดังนั้นการกระทำไม่ได้เกิดขึ้นพร้อมกันอย่างที่เกิดขึ้นจริง จุดประสงค์คือทุกๆ expression ที่รวม numbers(ข้อมูลชนิดตัวเลข), strings(ข้อมูลชนิดข้อความ) และ variables(ตัวแปร) สามารถใช้ใน print statement คุณได้เห็นตัวอย่างนี้ไปแล้ว
 print “Number of minutes since midnight: ”, hour*60+minute
 คุณสามารถวาง expressions ได้ตามใจชอบเช่นเดียวกันบนด้านขวามือของ assignment statement
 percentage = (minute * 100) / 60
 ความสามารถนี้อาจดูไม่น่าประทับใจในตอนนี้ แต่คุณจะเห็นตัวอย่างอื่นที่ การจัดวางองค์ประกอบทำให้การคำนวณที่ซับซ้อนเป็นไปอย่างเรียบร้อยและรัดกุม
 ข้อระวัง: มีข้อจำกัดของการที่คุณสามารถใช้ expressions บางอย่าง ตัวอย่าง, ด้านซ้ายมือของ assignment statement จะต้องเป็นชื่อของตัวแปร ต้องไม่ใช่ expression ดังเช่น, ตัวอย่างต่อไปนี้ที่ไม่ถูกต้อง: minute+1 = hour
2.10 Comments.
ขณะที่โปรแกรมมีขนาดใหญ่และมีความซับซ้อนมาก, มันจะทำให้ยากต่อการอ่าน Formal language นั้นดูหนาแน่นและขุ่นมัว บ่อยครั้งที่จะทำให้ยากต่อการดูส่วนหนึ่งๆและคิดว่ามันทำอะไรหรืออย่างไร
 ด้วยเหตุผลนี้ มันจึงเป็นความคิดที่ดีที่จะทำการเพิ่มข้อความในโปรแกรมของคุณเพื่ออธิบายใน natural language ว่าโปรแกรมกำลังจะทำอะไร ข้อความเหล่านี้เรียกว่า comments และข้อความอธิบายจะถูกทำเครื่องหมายด้วยสัญลักษณ์ #
 # compute the percentage of the hour that has elapsed
 percentage = (minute * 100) / 60
 ในกรณีนี้ comment ปรากฏอยู่บนบรรทัดด้วยตัวมันเอง คุณสามารถวาง comments ไว้ที่ท้ายสุดของบรรทัดได้เช่นเดียวกัน
 percentage = (minute * 100) / 60 # caution: integer division
 ทุกอย่างจากสัญลักษณ์ # ถึงท้ายสุดของบรรทัดจะถูกเพิกเฉย—มันจะไม่มีผลกระทบต่อโปรแกรม ข้อความมีเป้าหมายสำหรับโปรแกรมเมอร์หรือ โปรแกรมเมอร์ในอนาคตผู้ที่อาจจะใช้ code นี้ ในกรณีนี้ มันเตือนผู้อ่านเกี่ยวกับเรื่องที่เคยประหลาดใจกับการหาร integer
2.11 Glossary.
value: A number or string (or other thing to be named later) that can be stored in a variable or computed in an expression.
 type: A set of values. The type of a value determines how it can be used in expressions. So far, the types you have seen are integers (type int), floating-point numbers (type float), and strings (type string).
 floating-point: A format for representing numbers with fractional parts.
 variable: A name that refers to a value.
 statement: A section of code that represents a command or action. So far, the statements you have seen are assignments and print statements.
 assignment: A statement that assigns a value to a variable.
 state diagram: A graphical representation of a set of variables and the values to which they refer.
 keyword: A reserved word that is used by the compiler to parse a program; you cannot use keywords like if, def, and while as variable names.
 operator: A special symbol that represents a simple computation like addition, multiplication, or string concatenation.
 operand: One of the values on which an operator operates.
 expression: A combination of variables, operators, and values that represents a single result value.
 evaluate: To simplify an expression by performing the operations in order to yield a single value.
 integer division: An operation that divides one integer by another and yields an integer. Integer division yields only the whole number of times that the numerator is divisible by the denominator and discards any remainder.
 rules of precedence: The set of rules governing the order in which expressions involving multiple operators and operands are evaluated.
 concatenate: To join two operands end-to-end.
 composition: The ability to combine simple expressions and statements into compound statements and expressions in order to represent complex computations concisely.
comment: Information in a program that is meant for other programmers (or anyone reading the source code) and has no effect on the execution of the program.