ใช้งานไพธอนเป็นเครื่องคิดเลข (Python as a Calculator)#

10 minutes

วัตถุประสงค์#

หลังจากทำทำแล็บ นศ.จะสามารถ

  • ใช้ Jupyter Notebook ขั้นพื้นฐานได้

  • ใช้ Python เป็นเครื่องคิดเลข (ตัวดำเนินการทางคณิตศาสตร์) ได้

  • เข้าใจลำดับการรทำงานของตัวดำเนินการทางคณิตศาสตร์

  • ใช้ฟังก์ชันทางคณิตศาสตร์ (Import math) อย่างง่ายได้

  • ใช้ Python จัดดการสตริง/แสดงสตริงขั้นพื้นฐานได้

  • เชื่อมและก็อปปี้สตริงด้วยเครื่องหมาย + และ * ได้

ไพธอน (Python) เป็นภาษาอินเตอร์พรีเตอร์ (Interpreted Programming Languages) ทำงานโดยการแปลคำสั่งทีละคำสั่งด้วยตัวแปลภาษาไพธอน (Python Interpreter) ซึ่งแตกต่างจากภาษาอื่นเช่น C C++ หรือ Java (Compiled Programming Languages) ที่ต้องผ่านกระบวนแปลคำสั่งทั้งหมดในคราวเดียวก่อน (โดยคอมไพเลอร์ของภาษานั้นๆ) จึงจะเรียกใช้งานโปรแกรมได้ การสั่งงานคอมพิวเตอร์ด้วยภาษาไพธอนจึงสามารถทำได้ทั้งในโหมดโต้ตอบ (Interactive mode) และโหมดสคริปต์ (Script mode) ในปัจจุบัน มีเครื่องมือบางอย่างเช่น Jupyter Notebook (Ipython Notebook) ทำให้เราสามารถใช้งานทั้งสองโหมดผสมผสานกันได้

  • โหมดโต้ตอบ (Interactive mode) เหมาะกับการเขียนคำสั่งไพธอนที่มีความยาวบรรทัดเดียวหรือบล็อกเดียว ตัวแปลภาษาจะแปลคำสั่งทันที ทำให้เราสามารถเห็นผลลัพธ์ของแต่ละคำสั่งได้โดยไม่ต้องเสียเวลาสร้างไฟล์และคอมไพล์โปรแกรม

  • โหมดสคริปต์ (Script mode) เหมาะกับการเขียนคำสั่งที่มีความยาวหลายบรรทัดหรือหลายบล็อก โดยคำสั่งทั้งหมดต้องบันทึกเป็นไฟล์ไว้ก่อน เพื่อจะสั่งให้ตัวแปลภาษาทำงานตามคำสั่งตั้งแต่คำสั่งแรก จนถึงคำสั่งสุดท้าย

ในบทนี้ เราจะใช้ไพธอนเป็นเครื่องคิดเลขอย่างง่าย โดยเขียนนิพจน์ (Expression) ซึ่งประกอบไปด้วย ตัวดำเนินการ (Operators) เช่น +, -, *, / และตัวถูกดำเนินการ (Operands) ลงไปในเซลล์ แล้วรันโดยกดคีย์ Shift + Enter ไพธอนจะทำการประมวลผลและแสดงผลลัพธ์ให้เราดูทันที

Ref:

ตัวเลข - การคำนวณทางคณิตศาสตร์อย่างง่าย#

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

เราจะลองเขียนคำสั่งไพธอนแบบง่ายๆ โดยคำนวณ 20 + 50

ลองพิมพ์ 20 + 50 ลงในเซลล์ถัดไป จากนั้นทำการรันโดยกดคีย์ Shift ค้างไว้ แล้วกด Enter ผลลัพธ์ของการประมวลผลจะแสดงอยู่ใต้เซลล์

Note

รัน Code cell โดยการกดคีย์ Shift + Enter (กดพร้อมกัน) หรือกดที่ไอคอน “Play (Run)” ใต้แถบเมนู

20 + 50

70

แค่นี้ เราก็สามารถใช้ Python แทนเครื่องคิดเลขได้แล้ว

เราเรียกสิ่งที่อยู่ในเซลล์ว่า นิพจน์ (Expression)

นิพจน์ (Expression) จะประกอบด้วยส่วนประกอบ 2 ส่วน 1. ตัวดำเนินการ (Operators) และ 2. ตัวถูกดำเนินการ (Operands) โดยนิพจน์จะให้ผลลัพธ์เสมอ

นิพจน์ข้างต้นมี + (การบวก) เป็นตัวดำเนินการ และมีตัวเลขซ้ายและขวา (20, 50) เป็นตัวถูกดำเนินการ โดยให้ผลลลัพธ์เป็น 70

วิธีการเขียนนิพจน์ในภาษาไพธอนก็เหมือนภาษาอื่นๆ (เช่น C, C++ และ Java) ใช้ตัวดำเนินการ +,-, *, / สำหรับการบวก การลบ การคูณ การหารใช้วงเล็บ ( ) สำหรับการจัดกลุ่ม

ตัวถูกดำเนินการอาจจะเป็นค่าคงที่ (* การคูณ)

20 * 50

1000

หรืออาจจะเป็นตัวแปรก็ได้

a = 20
b = 50
a * b

1000

Attention

ในกรณีของสูตรในคณิตศาสตร์เราจะเขียน \(a \cdot b\) หรือ \(ab\) แสดงถึงการคูณระหว่าง a และ b แต่ในการเขียนโค้ดต้องเขียนตัวดำเนินการคูณ * ให้ชัดเจน

ตัวถูกดำเนินการอาจอยู่ในรูปนิพจน์ที่มีความซับซ้อน เช่น \(7 \left( {\frac{a\cdot{b}}{a+b}} \right)\) (การหารใช้เครื่องหมาย \(/\) )

7*((a * b) / (a + b))

100.0

หรือเป็นรูปนิพจน์แบบยาวๆ เช่นการบวกเลขอนุกรม 1, 2, 3, …., 50 แบบนี้ก็ได้

1+2+3+4+5+6+7+8+9+10+11+12+13+14+15+16+17+18+19+20+21+22+23+24+25+26+27+28+29+30+31+32+33+34+35+36+37+38+39+40+41+42+43+44+45+46+47+48+49+50

1275

Tip

ในกรณีของไพธอน เราสามารถเขียนคำสั่งแบบหลายบรรทัดได้ โดยใช้อักขระ "\" (Backslash) แยกบรรทัด (ไพธอนไม่สนเครื่องหมาย "\" จะตีความว่า มีต่อในบรรทัดถัดไป (Ignored (a continuation) “\“))

1+2+3+4+5+6+7+8+9+10+11+12+13+14+15+16+17+18+19+20+21+22+23+24+25+26+ \
27+28+29+30+31+32+33+34+35+36+37+38+39+40+41+42+43+44+45+46+47+48+49+50

1275

Note

ระหว่างตัวดำเนินการและตัวถูกดำเนินการ จะเขียนติดๆ กันโดยไม่เว้นระยะห่างเลย หรือจะเว้นระยะห่างกี่ช่องก็ได้ แต่ต้องอยู่ในบรรทัดเดียวกัน (เพราะในบางกรณี การเขียนหลายบรรทัด อาจทำให้การประมวลผลผิดพลาด) ในกรณีที่จำเป็นต้องแยกบรรทัด ให้ใช้ เครื่องหมาย "\"

อย่างไรก็ตาม เราความปรับระยะห่างระหว่างตัวดำเนินการและตัวถูกดำเนินการให้เหมาะสม ให้สามารถอ่านโค้ดได้ง่าย

1*2*3*4*5*6*7*8*9

362880

1*2*3*4* \
5*6*7*8*9

362880

1*2*3*4* 
5*6*7*8*9

  Cell In [9], line 1
    1*2*3*4*
             ^
SyntaxError: invalid syntax

Note

[PEP8]

ผู้สร้าง (Guido van Rossum) และนักพัฒนาหลักภาษาไพธอนได้เขียน “หลักเกณฑ์หรือสไตล์การเขียนโปรแกรมของภาษา Python” หรือที่รู้จักกันในชื่อ Python PEP8 ได้แนะนำจำนวนอักษรต่อบรรทัดให้ไม่เกิน 79 ตัวอักษร (รวมช่องว่าง (Space))

รายละเอียดของ PEP8 ดูได้ใน Python.org: PEP 8 – Style Guide for Python Code เนื่องจากสไตล์การเขียนที่กำหนดใน PEP8 มีหลักการมากมาย ทำให้การเขียนโค้ดที่ถูกต้องตาม PEP8 แบบครบถ้วนเป็นไปได้ยาก ในปัจจุบัน มีเครื่องมือที่ใช้ในการตรวจเช็คโค้ดว่าถูกต้องตาม PEP8 หรือไม่ เช่น pycodestyle, เครื่องมือสำหรับปรับโค้ดให้ถูกต้องตาม PEP8 อัตโนมัติ เช่น autopep8 ที่ต้องติดตั้งเอง หรือ PEP8 online ที่เป็นบริการออนไลน์ก็มี

ตัวดำเนินการทางคณิตศาสตร์ (Arithmetic Operators)#

ตัวดำเนินการทางคณิตศาสตร์ (Arithmetic operators) คือตัวดำเนินการที่ใช้สำหรับการคำนวณทางคณิตศาสตร์ขั้นพื้นฐาน เช่น การบวก การลบ การคูณ และการหาร นอกจากนี้ ภาษา Python ยังมีตัวดำเนินการทางคณิตศาสตร์เพิ่มเติม เช่น การหารเอาเศษ (Modulo (mod)) การหารแบบปัดเศษทิ้ง และการยกกำลัง เป็นต้น

ตัวดำเนินการทางคณิตศาสตร์ในภาษาไพธอน

  • โอเปอร์เรเตอร์ยูนารี (Unary Operators) เป็นโอเปอร์เรเตอร์ที่กระทํากับข้อมูลหรือนิพจน์เดียว : -, +

  • โอเปอร์เรเตอร์ไบนาร (Binary Operators) เป็นโอเปอร์เรเตอร์ที่กระทํากับข้อมูลหรือนิพจน์สองตัว : -, +, *, / …

ตารางสรุปตัวดำเนินการทางคณิตศาสตร์ในภาษา Python

ตัวดำเนินการ

ตัวอย่าง

ความหมาย

ผลลัพธ์

+ (unary)

+a

เครื่องหมายแสดงจำนวนลบ

a
มีไว้สำหรับแสดงความเป็นจำนวนบวก แต่ไม่มีผลใดๆ (เนื่องจาก แม้ไม่ใส่ก็ถือว่าเป็นจำนวนบวก)

+ (binary)

a + b

การบวก

ผลรวมระหว่าง a และ b

- (unary)

-a

เครื่องหมายแสดงจำนวนลบ

มีไว้สำหรับแสดงความเป็นจำนวนลบ

- (binary)

a - b

การลบ

ผลต่างระหว่าง a และ b (a ลบออกด้วย b)

*

a * b

การคูณ

ผลคูณระหว่าง a และ b

/

a / b

การหาร

ผลหารของการหาร a ด้วย b
โดยผลลัพธ์เป็นเลขทศนิยมเสมอ

%

a % b

การหารเอาเศษ (Modulus)

เศษที่ได้จากการหาร a ด้วย b

//

a // b

การหารปัดเศษทิ้ง (Floor Division) (หรือ หารปัดเศษ)

ผลหารของการหาร a ด้วย b โดยปัดเศษทิ้ง ได้ผลลัพธ์เป็นเลขจำนวนเต็ม (หารแบบไม่เอาเศษ (ปัดเศษทิ้ง))

**

a ** b

การคูณยกกำลัง

a ยกกำลัง b

src: https://realpython.com/python-operators-expressions/

Attention

ภาษาไพธอนไม่มีตัวดำเนินการ ++ (Increment operator), และ -- (Decrement operator) เหมือนในภาษา C/C++, Java

+, - ยังสามารถใช้เป็นโอเปอร์เรเตอร์ยูนารี (Unary Operators) ได้อีกด้วย

-3

-3

+3

3

การหารในภาษาไพธอน จะใช้ / เป็นการหารทศนิยม โดยผลหารจะเป็นเลขทศนิยมเสมอ

17 / 3

5.666666666666667

ใช้ // (เขียนติดกัน ห้ามเว้นเช่องว่าง) เป็นการหารแบบไม่เอาเศษ (ปัดเศษทศนิยมทิ้ง))

ถ้าเป็นจำนวนเต็ม //กัน ผลหารจะเป็นจำนวนเต็ม

17 // 3

5

17 / / 3

  Cell In [97], line 1
    17 / / 3
         ^
SyntaxError: invalid syntax

หากต้องการหา เศษ ของการหารเลขจำนวนเต็ม ให้ใช้ตัวดำเนินการ % จำนวนเต็ม %กัน ได้เศษของการหาร (แน่นอนเป็นจำนวนเต็ม)

17 % 3

2

ผลหารปัดเศษ * ตัวหาร + เศษ

5 * 3 + 2

17

การยกกำลังในภาษาไพธอน จะใช้ตัวดำเนินการ ** (เขียนติดกัน ห้ามเว้นเช่องว่าง)

ตัวอย่าง \(2^7\)

2 ** 7

128

2 * * 7

  Cell In [101], line 1
    2 * * 7
        ^
SyntaxError: invalid syntax

การยกกำลังในบางภาษาจะใช้ตัวดำเนินการ ^ (เช่น MATLAB, Latex)

แต่ในภาษาไพธอน ^ เป็นโอเปอเรเตอร์ระดับบิต (Bitwise Operator) เป็น Exclusive OR (XOR)

ถ้าไม่คุ้นเคยกับตัวดำเนินการ XOR ให้ดูรายละเอียดใน BitwiseOperators

(โอเปอเรเตอร์ระดับบิต (Bitwise Operator) ในภาษาไพธอน “Bitwise AND”: &, “Bitwise OR”: |, “Bitwise NOT”: ~, “Bitwise XOR”: ^ )

ถ้าเขียน 2 ^ 7 จะได้ผลลัพธ์เป็น 5 เนื่องจาก

2 (Decimal) => 0010 (Binary) 7 (Decimal) => 0111 (Binary)

0010 XOR 0111 = 0101 (Binary) => 5 (Decimal)

2 ^ 7 

5

Tip

พิเศษเฉพาะในโหมด Interactive Mode

ค่าที่ถูกพิมพ์ออกมาเป็นครั้งสุดท้าย จะถูกเก็บไว้ในตัวแปรพิเศษคือ "_" เราอาจนำตัวแปรนี้ไปใช้ในการคำนวนค่าต่อๆ ไปได้

หากต้องการเปรียบเทียบผลการรันล่าสุดว่ามีค่าเท่ากับ 2**7 หรือไม่ เราจะใช้ตัวดำเนินการเปรียบเทียบ == (รายละเอียดจะอธิบายภายหลัง)

_ == 2**7

False

จำนวนเต็ม (Integer number) และจำนวนจริง (Floating point number)#

สำหรับเลขจำนวนเต็มและเลขจำนวนจริง (หรือเลขทศนิยม) ในภาษาไพธอน ถึงแม้ว่าในทางคณิตศาสตร์จะมีค่าเท่ากัน แต่รูปแบบของข้อมูลที่ถูกจัดเก็บในคอมฯ นั้นต่างกัน ดังนั้นการแสดงผลจึงต่างกัน

17 / 1

17.0

17 // 1

17

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

17/1 == 17//1

True

การหารด้วย / จะได้ผลลัพธ์เป็นทศนิยมเสมอ

17 / 17

1.0

17 / 3

5.666666666666667

ในกรณีของ +, -, *, //, %, ** ถ้าตัวเลขทั้งสองตัวเป็นเลขจำนวนเต็ม ผลลัพธ์ที่ได้จะเป็นจำนวนเต็ม แต่ถ้าตัวใดตัวหนึ่งเป็นเลขจำนวนจริง ผลลัพธ์ที่ได้จะกลายเป็นจำนวนจริง

หารปัดเศษทิ้งของเลขจำนวนเต็ม

17 // 3 

5

หารเอาเศษของเลขจำนวนเต็ม

17 % 3

2

แต่ถ้าตัวใดตัวหนึ่งเป็นเลขจำนวนจริง ผลลัพธ์จะกลายเป็นจำนวนจริง

17 + 3.0

20.0

ลองคีย์ตัวเลข (อะไรก็ได้) และเครื่องหมาย +, -, *, //, %, ** ทดสอบดูว่าผลลัพธ์เป็นอย่างที่คิดหรือไม่

เลขทศนิยมในรูปของเลขยกกำลังฐานสิบ (Scientific Notation/Exponential Notation)#

ลองคำนวณว่า 1000 บิต (bits) จะเก็บข้อมูลได้กี่รูปแบบ (คำตอบคือ \(2^{1000}\))

2.0 ** 1000

1.0715086071862673e+301

ผลลัพธ์ที่ได้เป็นจำนวนจริง เนื่องจากมี 2.0 เป็นจำนวนจริง

ไพธอนจะแสดงเลขจำนวนจริงที่มีค่ามากๆ ในรูปของเลขทศนิยมยกกำลังฐานสิบ (สัญกรณ์วิทยาศาสตร์ (อังกฤษ: Scientific Notation หรือ Exponential Notation))

ในภาษาไพธอน e หรือ E หมายถึง 10 ยกกำลัง

ดังนั้นผลคำนวณข้างต้น \(e+301\) จึงหมายถึง \(\times 10^{301}\)

2.0 ** -1000

9.332636185032189e-302

จำนวนจริงที่มีค่าน้อยมากๆ ก็แสดงในรูปของเลขทศนิยมยกกำลังสิบเช่นกัน

\(9.332636185032189e{+}302 \Leftrightarrow 9.332636185032189 \times 10^{302}\)

จำนวนเต็มในไพธอนมีขนาดไม่สิ้นสุด!#

2 ** 1000

10715086071862673209484250490600018105614048117055336074437503883703510511249361224931983788156958581275946729175531468251871452856923140435984577574698574803934567774824230985421074605062371141877954182153046474983581941267398767559165543946077062914571196477686542167660429831652624386837205668069376

กรณีข้างต้นได้ผลลัพธ์เป็นจำนวนเต็ม ตัวเลขเยอะ (301 หลัก)!!!

ในภาษาไพธอน จำนวนเต็มมีขนาดไม่สิ้นสุด! (แต่แน่นอน ได้ไม่เกินหน่วยความจำ (Memory) ของคอมฯ ที่ใช้เก็บข้อมูล)

ลองคำนวน 2 ยกกำลัง 2 ยกกำลัง 2 ยกกำลัง 2 \( \left(2^{2^{2^{2}}}\right)\)

2**2**2**2

65536

2 ยกกำลังซ้อนกัน 4 ตัวยังไม่เท่าไหร่ ลอง 5 ตัวดู \( \left(2^{2^{2^{2^{2}}}}\right)\) …

# ลองเขียนโค้ดลงในเซลล์นี้

การเปลี่ยนชนิดข้อมูลระหว่างจำนวนเต็มและจำนวนจริง#

ในการแปลงชนิดข้อมูล (Typecasting) จากจำนวนจริงให้เป็นจำนวนเต็ม ให้ใช้ฟังก์ชัน int() (รายละเอียดจะอธิบายภายหลัง) ฟังก์ชั่น int() คืนค่าผลลัพธ์เป็นจำนวนเต็มโดยการปัดทศนิยมทิ้ง (ปัดเศษทิ้ง)

int(2.718281828459045)

2

int(-2.718281828459045)

-2

ในทางกลับกัน ถ้าต้องการเปลี่ยนจำนวนเต็มให้เป็นจำนวนจริง ให้ใช้ฟังก์ชัน float()

(รายละเอียดจะอธิบายภายหลัง เขียนโค้ดแรกในภาษาไพธอน (Python)(การแปลงชนิดของออบเจกต์ (Typecasting)

float(2)

2.0

float(-2)

-2.0

ได้ผลลัพธ์เช่นเดียวกับการบวกด้วย 0.0

-2 + 0.0

-2.0

ลำดับการประมวลผลของตัวดำเนินการและวงเล็บ ( )#

ในการประมวลผล \*, \/ จะถูกดำเนินการก่อน +, - กล่าวคือ ภาษาไพธอนกำหนดให้ \*, \/ มีลำดับความสำคัญสูงกว่า +, -

9 - 9 * 3

-18

(9 - 9) * 3

0

ตัวอย่างข้างต้นแสดงให้เห็นว่า 9 - 9 * 3 มีค่าเท่ากับ 9 - (9 * 3)

ลำดับความสำคัญเรียงจากสูงไปต่ำ ได้ดังนี้ :

()วงเล็บ \(\rightarrow\) ** \(\rightarrow\) *, /, //, % \(\rightarrow\) +, - ตามลำดับ

22 // 3 + 5 - 2 ** 2

8

จากตัวอย่างข้างต้น การยกกำลัง 2**2 จะถูกประมวลผลก่อน จากนั้น ประมวลผลการหาร 22 // 3 และประมวลผลการบวกลบ (7) + 5 - (4) เป็นลำดับสุดท้าย

ตัวอย่างข้างต้น เราสามารถใช้วงเล็บ () กำหนดลำดับได้

(22 // 3) + 5 - (2 ** 2)

8

ถ้าลำดับความสำคัญเท่ากัน จะประมวลผลจากซ้ายไปขวาเสมอ

2 / 2 * 9

9.0

ยกเว้น ** ประมวลผลจากขวาไปซ้าย

2 ** 3 ** 4

2417851639229258349412352

2 ** (3 ** 4)

2417851639229258349412352

ตัวดำเนินการทางคณิตศาตร์มีลำดับในการประมวลผล ดังนั้นต้องระวัง!!

ลองทดสอบดู

# เขียนโค้ดด้านล่าง แล้วกด Shift+Enter

Attention

  • ต้องเข้าใจลำดับการประมวลผลของตัวดำเนินการ (operator) (จำ) ลำดับความสำคัญ (สูง \(\rightarrow\) ต่ำ) : ( ) วงเล็บ \(\rightarrow\) ** \(\rightarrow\) *, /, //, % \(\rightarrow\) +, - ตามลำดับ

  • ถ้าลำดับความสำคัญเท่ากัน จะประมวลผลจากซ้ายไปขวาเสมอ เช่น 20/2*9 จะได้ (20/2)*9 (ยกเว้น เครื่องหมายยกกำลัง ** จะประมวลผลจากขวาไปซ้าย!)

  • ถ้าต้องการให้ชัวร์ ใส่วงเล็บ เช่น (22//3)+5-(2**2) สามารถช่วยป้องกันความผิดพลาดได้

Ternary conditional operator (condition)?([on_true]:[on_false] ในภาษาไพธอน#

ในภาษาไพธอนไม่มีโอเปอร์เรเตอร์เทอร์นารี (Ternary Operator (Conditional operator)) (condition)?([on_true]:[on_false] เหมือนในภาษา C/C++, Java หรือ JavaScript แต่สามารถเขียนแทนด้วยคำสั่ง if-else บรรทัดเดียวได้

Syntax :

[on_true] if [expression(condition)] else [on_false]

[ในกรณีภาษา C/C++]

/* Ternary Operator (Conditional operator) - C/Cpp ternary operator. */

a = True

a?100:60

Output: 100

ในกรณีภาษาไพธอน ใช้คำสั่ง if-else เขียนแทนได้ (รายละเอียดของคำสั่ง if-else บรรทัดเดียวจะอธิบายทีหลัง)

a = True
60 if a == True else 100

60

Error (ข้อผิดพลาด) ตัวแรก…#

หลังจากได้ลองเขียนโค้ดกันมา ก็น่าจะเกิด ** Error ** (ความผิดพลาด/ข้อผิดพลาด) บ้างไม่มากก็น้อย

Error คือ ข้อผิดพลาดที่ทำให้โปรแกรมหยุดทำงาน หรือไม่สามารถทำงานต่อได้

Error ต่อไปนี้เป็นตัวอย่างของข้อผิดพลาดที่อาจเกิดขึ้นได้ขณะเขียนโปรแกรม

22/0

---------------------------------------------------------------------------
ZeroDivisionError                         Traceback (most recent call last)
Cell In [131], line 1
----> 1 22/0

ZeroDivisionError: division by zero

ข้อผิดพลาดนี้เกิดขึ้นเนื่องจากหารด้วยศูนย์ (ZeroDivisionError) เป็น ข้อผิดพลาดที่เกิดในขณะรันโปรแกรม (Runtime Errors)

ในกรณีที่ Error เกิดขึ้น เราสามารถทำการแก้ไขแล้วรันใหม่ได้

ในตัวอย่างข้างต้น ลองแก้โค้ดใหม่โดยเปลี่ยนตัวหารจาก 0 เป็น 7 แล้วลองรันใหม่ดู

22/7

3.142857142857143

ข้อผิดพลาดนี้เป็น ** ข้อผิดพลาดที่เกิดจากไวยากรณ์ (Syntax Errors) ** กล่าวคือ เขียนคำสั่งผิดรูปแบบไวยากรณ์ (Syntax) ไม่ตรงตามรูปแบบของภาษาที่กำหนดไว้ ทำให้ไม่สามารถประมวลผลได้ (เป็นข้อผิดพลาดที่เกิดขึ้นบ่อยที่สุด ขณะเรียนรู้เขียนโปรแกรม โดยจะมีเครื่องหมาย ^ ระบุตำแหน่งที่ผิด (คร่าวๆ))

รายละเอียดของข้อผิดพลาดอยู่ในบทถัดไปในหัวข้อ ไพธอนจะแจ้ง Error ก่อนทําการรันหรือไม่?

[Exercise]: ตัวเลขและตัวดำเนินการทางคณิตศาสตร์#

1. จงเขียนโด้ดเพื่อคำนวณ \( 9^{2 \times 3.1415} + 2^{0.5} + 9/2 \)

2. จงเขียนโด้ดเพื่อแสดงผลลัพธ์ของสมการต่อไปนี้

  1. \(2^3 + 9 \times 7\)

  2. \(\dfrac{1}{2} + \dfrac{1}{3} + \dfrac{1}{4} +\dfrac{1}{5} \)

  3. \(\sqrt{3^2 - 4 \times 1 \times 2} \)

  4. \(\dfrac{\sqrt{4 \times 3 \times 7}}{2 \times 3} \)

Tip

สามารถเพิ่มเซลล์ (cell) ได้โดย

    1. กดปุ่ม + ในแถบเครื่องมือเพื่อเพิ่มเซลล์ด้านล่างเซลล์ที่กำลังเลือกอยู่ หรือ

    1. กดคำสั่งที่เมนู Insert >> Insert Cell Above เพื่อเพิ่มเซลล์ด้านบน หรือ Insert Cell Below เพื่อเพิ่มเซลล์ด้านล่างเซลล์ที่กำลังเลือกอยู่ หรือ

    1. กดคีย์ A (Above) หรือ B (Below) ในโหมด Command mode เพื่อพิ่มเซลล์ด้านบน หรือด้านล่างเซลล์ที่กำลังเลือกอยู่

ฟังก์ชันทางคณิตศาสตร์ - math module (Import module)#

import math

math.sqrt(2)

1.4142135623730951

ภาษาไพธอนมีฟังก์ชันทางคณิตศาสตร์ต่างๆ ที่ถูกจัดเตรียมไว้ในรูปของไลบรารี (Library หรือ Module (โมดูล)) ที่ชื่อ math หากต้องการใช้ก็สามารถทำได้โดยใช้รันคำสั่ง import library_name ดังที่แสดงไว้ข้างต้น

คำสั่ง import math เป็นคำสั่งนำเข้าไลบรารี่ math เข้ามาในโปรแกรม หลังจากรันคำสั่งแล้ว เราจะสามารถใช้ฟังก์ชันในรูปแบบ math.function_name() ได้

ในตัวอย่างข้างต้น เราเรียกใช้ฟังก์ชัน math.sqrt() เพื่อคำนวณรากที่สองของ \((\sqrt{2})\)

นอกจากนี้ ยังมีฟังก์ชั่น sin(), cos() ดังตัวอย่างต่อไปนี้

ศึกษารายละเอียดฟังก์ชันต่างๆ ที่อยู่ในไลบรารี math ได้ที่ Python.org (math — Mathematical functions)

math.sin(0)

0.0

math.pi

3.141592653589793

math.sin(math.pi)

1.2246467991473532e-16

ในความเป็นจริง sin(\(\pi\)) มีค่าศูนย์ แต่ไพธอนคำนวณได้ \(1.2246467991473532 \times 10^{-16} \) แม้จะเข้าใกล้ศูนย์ แต่ไม่เท่ากับศูนย์ เพราะเหตุใด??

ทั้งนี้เพราะค่า \(\pi\) ที่ใช้ในการคำนวณมีค่า \(3.141592653589793 \) ซึ่งเป็นค่าโดยประมาณ ไม่ใช่ค่าของ \(\pi\) ที่แท้จริง [Stackoverflow]

หากต้องการดูว่าโมดูล (ไลบรารี) math มีฟังก์ชั่นอะไรให้ใช้บ้าง ให้ใช้คำสั่ง help() ดังตัวอย่างต่อไปนี้

help(math)

Help on module math:

NAME
    math

MODULE REFERENCE
    https://docs.python.org/3.8/library/math
    
    The following documentation is automatically generated from the Python
    source files.  It may be incomplete, incorrect or include features that
    are considered implementation detail and may vary between Python
    implementations.  When in doubt, consult the module reference at the
    location listed above.

DESCRIPTION
    This module provides access to the mathematical functions
    defined by the C standard.

FUNCTIONS
    acos(x, /)
        Return the arc cosine (measured in radians) of x.
    
    acosh(x, /)
        Return the inverse hyperbolic cosine of x.
    
    asin(x, /)
        Return the arc sine (measured in radians) of x.
    
    asinh(x, /)
        Return the inverse hyperbolic sine of x.
    
    atan(x, /)
        Return the arc tangent (measured in radians) of x.
    
    atan2(y, x, /)
        Return the arc tangent (measured in radians) of y/x.
        
        Unlike atan(y/x), the signs of both x and y are considered.
    
    atanh(x, /)
        Return the inverse hyperbolic tangent of x.
    
    ceil(x, /)
        Return the ceiling of x as an Integral.
        
        This is the smallest integer >= x.
    
    comb(n, k, /)
        Number of ways to choose k items from n items without repetition and without order.
        
        Evaluates to n! / (k! * (n - k)!) when k <= n and evaluates
        to zero when k > n.
        
        Also called the binomial coefficient because it is equivalent
        to the coefficient of k-th term in polynomial expansion of the
        expression (1 + x)**n.
        
        Raises TypeError if either of the arguments are not integers.
        Raises ValueError if either of the arguments are negative.
    
    copysign(x, y, /)
        Return a float with the magnitude (absolute value) of x but the sign of y.
        
        On platforms that support signed zeros, copysign(1.0, -0.0)
        returns -1.0.
    
    cos(x, /)
        Return the cosine of x (measured in radians).
    
    cosh(x, /)
        Return the hyperbolic cosine of x.
    
    degrees(x, /)
        Convert angle x from radians to degrees.
    
    dist(p, q, /)
        Return the Euclidean distance between two points p and q.
        
        The points should be specified as sequences (or iterables) of
        coordinates.  Both inputs must have the same dimension.
        
        Roughly equivalent to:
            sqrt(sum((px - qx) ** 2.0 for px, qx in zip(p, q)))
    
    erf(x, /)
        Error function at x.
    
    erfc(x, /)
        Complementary error function at x.
    
    exp(x, /)
        Return e raised to the power of x.
    
    expm1(x, /)
        Return exp(x)-1.
        
        This function avoids the loss of precision involved in the direct evaluation of exp(x)-1 for small x.
    
    fabs(x, /)
        Return the absolute value of the float x.
    
    factorial(x, /)
        Find x!.
        
        Raise a ValueError if x is negative or non-integral.
    
    floor(x, /)
        Return the floor of x as an Integral.
        
        This is the largest integer <= x.
    
    fmod(x, y, /)
        Return fmod(x, y), according to platform C.
        
        x % y may differ.
    
    frexp(x, /)
        Return the mantissa and exponent of x, as pair (m, e).
        
        m is a float and e is an int, such that x = m * 2.**e.
        If x is 0, m and e are both 0.  Else 0.5 <= abs(m) < 1.0.
    
    fsum(seq, /)
        Return an accurate floating point sum of values in the iterable seq.
        
        Assumes IEEE-754 floating point arithmetic.
    
    gamma(x, /)
        Gamma function at x.
    
    gcd(x, y, /)
        greatest common divisor of x and y
    
    hypot(...)
        hypot(*coordinates) -> value
        
        Multidimensional Euclidean distance from the origin to a point.
        
        Roughly equivalent to:
            sqrt(sum(x**2 for x in coordinates))
        
        For a two dimensional point (x, y), gives the hypotenuse
        using the Pythagorean theorem:  sqrt(x*x + y*y).
        
        For example, the hypotenuse of a 3/4/5 right triangle is:
        
            >>> hypot(3.0, 4.0)
            5.0
    
    isclose(a, b, *, rel_tol=1e-09, abs_tol=0.0)
        Determine whether two floating point numbers are close in value.
        
          rel_tol
            maximum difference for being considered "close", relative to the
            magnitude of the input values
          abs_tol
            maximum difference for being considered "close", regardless of the
            magnitude of the input values
        
        Return True if a is close in value to b, and False otherwise.
        
        For the values to be considered close, the difference between them
        must be smaller than at least one of the tolerances.
        
        -inf, inf and NaN behave similarly to the IEEE 754 Standard.  That
        is, NaN is not close to anything, even itself.  inf and -inf are
        only close to themselves.
    
    isfinite(x, /)
        Return True if x is neither an infinity nor a NaN, and False otherwise.
    
    isinf(x, /)
        Return True if x is a positive or negative infinity, and False otherwise.
    
    isnan(x, /)
        Return True if x is a NaN (not a number), and False otherwise.
    
    isqrt(n, /)
        Return the integer part of the square root of the input.
    
    ldexp(x, i, /)
        Return x * (2**i).
        
        This is essentially the inverse of frexp().
    
    lgamma(x, /)
        Natural logarithm of absolute value of Gamma function at x.
    
    log(...)
        log(x, [base=math.e])
        Return the logarithm of x to the given base.
        
        If the base not specified, returns the natural logarithm (base e) of x.
    
    log10(x, /)
        Return the base 10 logarithm of x.
    
    log1p(x, /)
        Return the natural logarithm of 1+x (base e).
        
        The result is computed in a way which is accurate for x near zero.
    
    log2(x, /)
        Return the base 2 logarithm of x.
    
    modf(x, /)
        Return the fractional and integer parts of x.
        
        Both results carry the sign of x and are floats.
    
    perm(n, k=None, /)
        Number of ways to choose k items from n items without repetition and with order.
        
        Evaluates to n! / (n - k)! when k <= n and evaluates
        to zero when k > n.
        
        If k is not specified or is None, then k defaults to n
        and the function returns n!.
        
        Raises TypeError if either of the arguments are not integers.
        Raises ValueError if either of the arguments are negative.
    
    pow(x, y, /)
        Return x**y (x to the power of y).
    
    prod(iterable, /, *, start=1)
        Calculate the product of all the elements in the input iterable.
        
        The default start value for the product is 1.
        
        When the iterable is empty, return the start value.  This function is
        intended specifically for use with numeric values and may reject
        non-numeric types.
    
    radians(x, /)
        Convert angle x from degrees to radians.
    
    remainder(x, y, /)
        Difference between x and the closest integer multiple of y.
        
        Return x - n*y where n*y is the closest integer multiple of y.
        In the case where x is exactly halfway between two multiples of
        y, the nearest even value of n is used. The result is always exact.
    
    sin(x, /)
        Return the sine of x (measured in radians).
    
    sinh(x, /)
        Return the hyperbolic sine of x.
    
    sqrt(x, /)
        Return the square root of x.
    
    tan(x, /)
        Return the tangent of x (measured in radians).
    
    tanh(x, /)
        Return the hyperbolic tangent of x.
    
    trunc(x, /)
        Truncates the Real x to the nearest Integral toward 0.
        
        Uses the __trunc__ magic method.

DATA
    e = 2.718281828459045
    inf = inf
    nan = nan
    pi = 3.141592653589793
    tau = 6.283185307179586

FILE
    /Users/tube.sc/.pyenv/versions/3.8.13/lib/python3.8/lib-dynload/math.cpython-38-darwin.so

math.sin(math.pi/2)

1.0

เนื่องจากหน่วยของมุมในโมดูล math มีหน่วยเป็นเรเดียน ถ้าหน่วยของมุมเป็นองศา ต้องใช้ฟังก์ชัน math.radians()) แปลงเป็นเรเดียนก่อน แล้วคำนวณค่า sin จากฟังก์ชัน math.sin()

math.sin(math.radians(90))

1.0

[Exercise]: โมดูล math#

1. จงใช้่ไลบรารี math เขียนโด้ดหาค่าอัตราส่วนทอง (Golden ratio) WIKI โดยอัตราส่วนทองมีค่าเท่ากับ รากที่สองของ 5 บวกกับ 1 แล้วหารด้วย 2 ซึ่งจะมีค่าประมาณ 1.618

\[ \dfrac{1+\sqrt{5}} {2} \]
# เขียนโค้ดด้านล่าง แล้วกด Shift+Enter
import math

2. จงใช้่ไลบรารี math เขียนโด้ดเพื่อแสดงผลลัพธ์ของสมการต่อไปนี้

2.1) \(2^3 + 9 \times 7\)

2.2) \( ln(\dfrac{1}{2} + \dfrac{1}{3} + \dfrac{1}{4} +\dfrac{1}{5}) \)

2.3) \(\sqrt{3^2 - 4 \times 1 \times 2} \)

2.4) \(\left(\dfrac{\sqrt{4 \times 3 \times 7}}{2 \times 3} \right)^{10}\)

Tip

สามารถเพิ่มเซลล์ (cell) ได้โดย 1. กดปุ่ม + ในแถบเครื่องมือเพื่อเพิ่มเซลล์ด้านล่างเซลล์ที่กำลังเลือกอยู่ หรือ 2. กดคำสั่งที่เมนู Insert >> Insert Cell Above เพื่อเพิ่มเซลล์ด้านบน หรือ Insert Cell Below เพื่อเพิ่มเซลล์ด้านล่างเซลล์ที่กำลังเลือกอยู่ หรือ 3. กดคีย์ A (Above) หรือ B (Below) ในโหมด Command mode เพื่อพิ่มเซลล์ด้านบน หรือด้านล่างเซลล์ที่กำลังเลือกอยู่

# เขียนโค้ดด้านล่าง แล้วกด Shift+Enter
import math

3. จงหาพื้นผิวของโลกในหน่วยตารางเมตร กำหนดให้รัศมีของโลกมีค่าเป็น 6,371 km

# เขียนโค้ดด้านล่าง แล้วกด Shift+Enter
import math

4. ให้เขียนโค้ดกำหนดค่าให้กับตัวแปร \(n\) (จะกำหนดค่าเป็นเท่าไหร่ก็ได้) แล้วคำนวณสมการ \(\left(1+\dfrac{1}{n}\right)^n\) ถามว่า ถ้า \(n\) มีค่าเพิ่มมากขึ้นๆ ผลลัพธ์ของสมการจะมีค่าเท่าไหร่

[Hint] เปลี่ยนค่า n ให้เพิ่มมากขึ้น (ด้วยมือ) แล้วดูว่าผลลัพธ์ของสมการจะลู่เข้าสู่ค่าอะไร?

\[ \lim_{n\to\infty}(1+\frac{1}{n})^n \]
# เขียนโค้ดด้านล่าง แล้วกด Shift+Enter
import math

(เพิ่มเติม) สตริง (Strings; ข้อความ/สายอักขระ)#

นอกจากตัวเลขแล้ว Python ยังสามารถจัดการกับสตริงได้อย่างง่ายๆ เช่นกัน

สตริง (String) คือ ชนิดของข้อมูลที่เป็นข้อความหรือตัวอักษร/อักขระ (Character) หลายๆ ตัวเรียงต่อๆ กัน

ซึ่งสามารถแสดงได้หลายวิธี เช่น

  1. อยู่ในเครื่องหมายคำพูดเดี่ยว single quotes (’…’) หรือ

  2. อยู่ในเครื่องหมายคำพูดคู่ double quotes (”…”)

ซึ่งทั้งสองวิธีให้ผลลัพธ์เหมือนกัน

'Scrambled egg'

'Scrambled egg'

"ไข่คน หรือ ไข่กวน" 

'ไข่คน หรือ ไข่กวน'

Escape Sequences ในภาษาไพธอน#

รหัสพิเศษ (Escape Sequences) ในภาษาไพธอนจะเริ่มต้นด้วยเครื่องหมาย "\" (Back slash/Backslash)

ภาษาไพธอนจะใช้เครื่องหมายคำพูด single quotes ' ' หรือ double quotes " " คล่อมข้อความเพื่อสร้างสตริง แต่ในกรณีที่ภายในข้อความมีเครื่องหมายคำพูดปนอยู่ด้วย จะต้องใช้รหัสพิเศษ "\" นำหน้า

ยกตัวอย่าง ในกรณีที่ข้อความมีเครื่องหมายคำพูด ' ปนอยู่ด้วย ถ้าเขียนแบบนี้

'I doesn't care' 

  Cell In [146], line 1
    'I doesn't care'
             ^
SyntaxError: invalid syntax

จะเกิด ข้อผิดพลาดที่เกิดจากไวยากรณ์ (Syntax Errors)

ในกรณีนี้ เราจะใช้รหัสพิเศษ \' แทน ' ดังนี้

'I doesn\'t care' 

"I doesn't care"

หรือจะใช้ Double quotes คล่อมทั้งข้อความแทน Single quotes แบบนี้ก็ได้

"I doesn't care" 

"I doesn't care"

ในภาษาไพทอน เราสามารถใช้ Single quote สลับกับ Double quote ได้ โดยไม่จำเป็นว่าจะต้องเป็นตัวไหนขึ้นก่อน กล่าวคือ ถ้าภายในข้อความมี Double quote ก็ให้ใช้ Single quotes คล่อม

'"Yes," he said.'

'"Yes," he said.'

แต่ถ้าภายในข้อความมี Single quote ก็ให้ใช้ Double quotes คล่อม

"'Yes,' he said. "

"'Yes,' he said. "

แต่ถ้าเป็นข้อความมีทั้ง Double quotes และ Single quote หรือเป็นประโยคยาวๆ การใช้รหัสพิเศษ \ เข้ามาช่วย ก็จะช่วยทำให้โค้ดอ่านได้ง่ายขึ้นเยอะทีเดียว

'"It isn\'t", he said.'

'"It isn\'t", he said.'

นอกจากนี้ ยังมีรหัสพิเศษ (Escape Sequences) อื่นๆ อีก เช่น \n คือ newline (ขึ้นบรรทัดใหม่)

s = 'First line.\nSecond line.'

ฟังก์ชั่น print() เป็นฟังก์ชั่นที่ใช้สร้างสตริงและแสดงข้อมูลสตริงออกทางจอภาพ สามารถใช้ได้กับทั้งสตริงและตัวเลข

รายละเอียดดูใน [python.org > tutotial > Input and Output]

ถ้าเราไม่ใช้คำสั่ง print() เอาต์พุตที่ได้จะมีรหัสพิเศษ \n รวมอยู่ในข้อความ

s

'First line.\nSecond line.'

ถ้าใช้คำสั่ง print() \n จะขึ้นบรรทัดใหม่

print(s) 

First line.
Second line.

ยกตัวอย่างในกรณีของ Path directory เช่น C:\some\name

ถ้าเราเขียนโค้ดแบบนนี้ จะแสดงข้อความเป็น …

print('C:\some\name')  

C:\some
ame

เนื่องจาก \n เป็นการขึ้นบรรทัดใหม่ ฉะนั้น ในกรณีนี้ ต้องเขียนเป็นรหัสพิเศษ \\n

print('C:\some\\name')  

C:\some\name

หรือจะใช้ตัวอักษร r ก่อนหน้าเครื่องหมาย Single quotes หรือ Double quotes ก็ได้

print(r'C:\some\name')  

C:\some\name

ณ ที่นี้ r ใช้ในการกำหนดค่าแบบ “raw string” ซึ่งคือ การกำหนดค่าแบบที่เป็นข้อความที่ไม่มีการตัดคำออกจากข้อความ

dirname = r'C:\temp\parts'
dirname

'C:\\temp\\parts'

print(dirname)

C:\temp\parts

print('C:\\temp\\parts')

C:\temp\parts

สตริงหลายบรรทัด (โดยใช้ Triple-quotes)#

สตริงสามารถมีหลายบรรทัดได้ วิธีการหนึ่งคือการใช้ triple-quotes: """...""" หรือ '''...'''.

'''
เวลาคือเงิน
Time is money
Time is ฿
'''

'\nเวลาคือเงิน\nTime is money\nTime is ฿\n'

print('\nเวลาคือเงิน\nTime is money\nTime is ฿\n')

เวลาคือเงิน
Time is money
Time is ฿

triple_double_quoted = """
"เวลาคือเงิน"
Time is money
Time is ฿'
"""
print(triple_double_quoted)

"เวลาคือเงิน"
Time is money
Time is ฿'

การเชื่อมและการก็อปปี้สตริง (ด้วยเครื่องหมาย +, *)#

สตริงสามารถต่อกัน (ติดกาวเข้าด้วยกัน) ด้วยตัวดำเนินการ + และสามารถทำซ้ำ (ก็อปปี้) ด้วยตัวดำเนินการ *

ยกตัวอย่างเช่น ‘(^^)’ (Joyful face) 3 ครั้ง ต่อท้ายด้วย ‘(><)’ (Troubled face)

3 * '(^_^)' + '(>_<)'

'(^_^)(^_^)(^_^)(>_<)'

ถ้าสตริงตั้งแต่สองตัวขึ้นไป อยู่ในบรรทัดเดียวกัน จะถูกเชื่อมติดกันโดยอัตโนมัติ

'Py' 'thon' 

'Python'

print('Py' 'thon')

Python

[Exercise]: สตริง#

1. จงเขียนโด้ดแสดงผลลัพธ์ให้เป็นรูปสามเหลี่ยมแบบนี้ (ระหว่าง * ในบรรทัดเดียวกัน ไม่มีช่องว่าง)

\[\begin{split} *\\ ***\\ *****\\ *******\\ *********\\ ***********\\ \end{split}\]
# เขียนโค้ดด้านล่าง แล้วกด Shift+Enter

2. จงเขียนโด้ดเพื่อแสดงผลลัพธ์ต่อไปนี้ โดยใช้คำสั่ง print

\[ "I\ think\ it's\ sad\ if\ it\ isn't,"\ he\ said.\]
# เขียนโค้ดด้านล่าง แล้วกด Shift+Enter

Author#

S.C.

Change Log#

Date

Version

Change Description

08-08-2021

0.1

First edition

05-05-2022

0.2

Fix the typo, minor change