เขียนโค้ดแรกในภาษาไพธอน (Python)#

ในบทนี้เราจะศึกษา

  • การเขียนโค้ดอย่างง่ายในภาษาไพธอน

  • การใช้ข้อมูลหลากหลายชนิดในภาษาไพธอน และการเปลี่ยนชนิดของข้อมูล (Typecasting) เบื่องต้น

  • การใช้ตัวแปร (Variables) และเขียนนิพจน์ (Expressions) โดยใช้ตัวดำเนินการทางคณิตศาสตร์ (Arithmetic operators)

  • การใช้ฟังก์ชัน print() แสดงค่าตัวแปร (ค่านิพจน์) ออกหน้าแสดงผล

Refs:

โปรแกรม “Hello World” ในภาษาไพธอน#

\(\qquad\) เราจะลองเขียนโปรแกรม “Hello World” ซึ่งเป็นโปรแกรมคอมพิวเตอร์พื้นฐานที่ทำการแสดงผลคำว่า “Hello, World” บนอุปกรณ์แสดงผล

โค้ดต่อไปนี้เป็น “Hello World” ในภาษาไพธอน

Tip

รันโค้ดเซลล์ (code cell) ต่อไปนี้ โดยการกดคีย์ Shift + Enter

print('Hello, World')

Hello, World

\(\qquad\) โค้ดตัวอย่างข้างต้น ภายในวงเล็บ "Hello, World" เป็นข้อมูลชนิดสตริง (string) เป็นอาร์กิวเมนต์ (argument) ส่งไปยังฟังก์ชัน print() เพื่อให้แสดงข้อความดังกล่าวออกหน้าจอมอนิเตอร์

Note

\(\qquad\) ฟังก์ชัน print() เป็นฟังก์ชันฝังตัวในภาษาไพธอน (Built-in function: ฟังก์ชันที่ติดตั้งหรือมีอยู่แล้วในภาษา Python) เราสามารถใช้ได้เลยโดยไม่ต้องดำเนินการใดๆ เพิ่มเติม

ฟังก์ชันฝังตัวในภาษาไพธอน นอกจากฟังก์ชัน print() แล้ว ยังมีฟังก์ชันฝังตัวอื่นๆ อีกมากมาย เช่น input(), int(), float(), list(), tuple(), set(), pow(), abs(), id() ฯลฯ ศึกษาเพิ่มเติมเกี่ยวกับฟังก์ชันฝังตัวได้ที่ Python.org: Built-in Functions

\(\qquad\) “Hello World” หรือ “สวัสดีชาวโลก” เป็นคำที่มนุษย์คอมพิวเตอร์ผู้มีอารยธรรม กล่าวทักทายต่อมนุษย์โลก เมื่อได้พบเจอกับมนุษย์โลกเป็นครั้งแรก

\(\qquad\) โปรแกรม “Hello World” โปรแกรมแรกเกิดขึ้น จากหนังสือ “The C Programming Language” ที่แต่งโดย Brian W. Kernighan (ไบรอัน เคอร์นิงแฮน) และ Dennis M. Ritchie (เดนนิส ริตชี) ตีพิมพ์ในปี พ.ศ. 2521 (ค.ศ. 1978)

โปรแกรม “Hello World” เป็นหนึ่งในโปรแกรมที่ง่ายที่สุดในการเขียนภาษาโปรแกรมต่างๆ มักถูกใช้เป็นตัวอย่างในการแสดงรูปแบบการเขียนหรือไวยากรณ์ของภาษาโปรแกรมนั้นๆ (Syntax) โดยมักจะเป็นโปรแกรมแรกที่ผู้เริ่มต้นเขียนโปรแกรมเขียนออกมา นอกเหนือจากนี้ ยังถูกใช้ในการทดสอบว่า ตัว Compiler หรือ Interpreter ที่ติดตั้งทำงานได้ปกติหรือไม่

ตัวอย่างโปรแกรม “Hello World” ในภาษา C, C++, Java และ JavaScript

        /* < C > */
        #include <stdio.h> 
                int main(void) { 
                        printf("hello, world\n"); 
                }

        // < C++ >
        #include <iostream> 
                int main() { 
                        std::cout << "Hello, world!\n"; 
                        return 0; 
                }

        // < Java >
                class HelloWorldApp {
                        public static void main(String[] args) {
                                System.out.println("Hello World!");
                        }
                }

        // < JavaScript >
                document.write('Hello, world!');

การเขียนโปรแกรม “Hello World” ในแต่ละภาษามีอยู่หลายรูปแบบ รูปแบบข้างต้นเป็นตัวอย่างของรูปแบบหนึ่งเท่านั้น

อ่านเพิ่มเติมเกี่ยวกับการเขียนโปรแกรม “Hello, World” ด้วยภาษาอื่นๆ ได้ที่ วิกิพีเดีย:โปรแกรมเฮลโลเวิลด์ในวิกิพีเดีย

การตรวจสอบเวอร์ชั่นของไพธอนที่ใช้งานอยู่#

\(\qquad\) ไพธอนที่ใช้อยู่ในปัจจุบันหลักๆ มีอยู่ 2 เวอร์ชั่น คือ Python 2 และ Python 3

  • Python 2 ถูกเพยแพร่ครั้งแรกในปี 2000 แต่ปัจจุบันถูกระงับการสนับสนุนอย่างเป็นทางการในปี 2020 โดยมีเวอร์ชั่น 2.7.18 เป็นเวอร์ชั่นสุดท้าย

  • Python 3 ถูกเพยแพร่ครั้งแรกในปี 2008 เป็นไพธอนที่ใช้งานกันอยู่ในปัจจุบัน โดยมีมูลนิธิซอฟต์แวร์ไพธอน ([Python Software Foundation, PSF)(https://www.python.org/psf/)] ซึ่งเป็นองค์กรไม่แสวงผลกำไร ทำหน้าที่ดูแลและจัดการทรัพยากรสำหรับการพัฒนาไพธอน สามารถดาวโหลดเวอร์ชั่นล่าสุดได้ที่ Download the latest version

Attention

  1. Python เวอร์ชัน 3 ไม่รองรับเวอร์ชัน 2 นั่นหมายความว่า โค้ดที่เขียนด้วยไพธอนเวอร์ชั่น 2 ไม่สามารถทำงานได้อย่างถูกต้องในไพธอนเวอร์ชั่น 3

    เวอร์ชัน 2 และ เวอร์ชัน 3 แตกต่างกันหลายอย่าง เช่น

    • คำสั่ง print ถ้าเป็นเวอร์ชั่น 2 จะเขียน print "Hello World!\n" แต่ถ้าเป็นเวอร์ชั่น 3 จะถือว่าเป็นฟังก์ชัน จะเขียน print("Hello World!")

    • การหารจำนวนเต็ม 355/113 ถ้าเป็นเวอร์ชั่น 2 จะได้ผลลัพธ์เป็นจำนวนเต็ม 3 แต่ถ้าเป็นเวอร์ชั่น 3 จะได้ผลลัพธ์เป็นทศนิยม 3.1415929203539825 เป็นต้น

    • นอกจากนี้ Python เวอร์ชั่น 3 ยังรองรับ Unicode (ยูนิโค๊ด) UTF-8 (ในขณะที่เวอร์ชั่น 2 รองรับ ASCII (7 bit)) มีฟังก์ชันที่มีความสามารถพิเศษมากกว่า ทำให้เวอร์ชั่น 3 มีโครงสร้างภาษาหรือไวยกรณ์ที่ง่ายกว่า เป็นต้น

    ความแตกต่างระหว่างวอร์ชัน 2 และ 3 สามารอ่านเพิ่มเติมได้ที่ Interviewbit: Difference Between Python 2 and 3

  2. Python ถูกติดตั้งเป็นค่าเริ่มต้นบน Mac และ Linux แต่เป็นเวอร์ชัน 2 ในกรณีที่จะใช้เวอร์ชัน 3 ก็สามารถติดตั้งเวอร์ชัน 3 เพิ่มได้ (สามารถดาวโหลดเวอร์ชั่น 3 เวอร์ชั่นล่าสุดได้ที่ Python.org: Download the latest version)

การตรวจสอบเวอร์ชั่นของไพธอนที่ใช้งานอยู่สามารถทำได้ 2 วิธีหลัก คือ

  1. Command line (–version, -V, -VV) และ

  2. Script (sys, platform)

เราลองใช้วิธี Script กันก่อนโดยเขียนโค้ดต่อไปนี้

import sys
print(sys.version)

3.8.13 (default, Jul 20 2022, 13:16:07) 
[Clang 13.1.6 (clang-1316.0.21.2.5)]

หรือ จะเขียนโดยใช้ sys.version_info

print(sys.version_info)

sys.version_info(major=3, minor=8, micro=13, releaselevel='final', serial=0)

sys เป็นโมดูลที่ฝังตัวอยู่ในภาษาไพธอน (Built-in module) แต่ก่อนใช้งานต้อง import เข้ามาก่อน (รายละเอียดของการ Import จะอธิบายภายหลัง) sys.version จะคืนค่าเป็นข้อความ (String) ที่เป็นรุ่นของไพธอนที่กำลังใช้งานอยู่ ในขณะที่ sys.version_info จะคืนค่าเป็น tuple ที่มีค่าเป็นตัวเลข โดยเวอร์ชั่นจะประกอบไปด้วยตัวเลข 3 ส่วนหลักๆ คือ Major Minor และ Patch (Micro) เช่น 3.8.13 หรือ 3.10.0 ตามลำดับ

Note

ถ้ารันไพธอนผ่านทาง Terminal (ในระบบปฏิบัติการ Mac/Linux) หรือผ่านทาง Command Prompt (Cmd ในระบบปฏิบัติการ Windows) ให้ใช้คำสั่งใด python หรือ python3 โดยใส่ Option --version, -V, -VV คำสั่งหนึ่งต่อไปนี้

  • python –version

  • python -V

  • python -VV

เราสามารถรันคำสั่ง Command line ใน Notebook ได้ รายละเอียดจะอธิบายภายหลัง

การเขียนคอมเมนต์ในภาษาไพธอน (Comments & Docstrings)#

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

การเขียนคอมเมนต์ในภาษาไพธอนมีด้วยกัน 2 วิธีคือ

  1. ใช้เครื่องหมาย hash ("#") นำหน้าบรรทัดที่ต้องการคอมเมนต์

  2. ใช้ DocString คล่อมข้อความหรือโค้ดที่ต้องการคอมเมนต์

วิธีแรกใช้คอมเมนต์บรรทัดเดียว ส่วนวิธีที่สองใช้คอมเมนต์หลายบรรทัด

การเขียนคอมเมนต์บรรทัดเดียวโดยใช้เครื่องหมาย hash#

\(\qquad\) โดยทั้วไป การคอมเมนต์ในภาษาไพธอนจะเริ่มต้นด้วยเครื่องหมาย hash ("#") ข้อความที่อยู่หลัง "#" ไปจนสิ้นสุดบรรทัดนั้นๆ จะไม่มีผลต่อการทำงานของโปรแกรม (ความยาวไม่จำกัด เพียงแค่อยู่ในบรรทัดเดียวกัน)

# บรรทัดนี้ทั้งบรรทัดคือ Comment เพียงแค่เริ่มต้นด้วยเครื่องหมาย hash (#)

# นอกจากนี้ยังสามารถเขียน Comment หลังโค้ดเพื่ออธิบายโค้ดก็ได้
2**8 # คำนวณ 2 ยกกำลัง 8

256

บ่อยครั้ง เราจะใช้เครื่องหมาย hash (‘#’) นำหน้าโค้ดที่ไม่ต้องการให้ถูกรัน (เรียกว่า ถูก “Comment out”)

# 2**8 # คำนวณ 2 ยกกำลัง <-- บรรทัดนี้ถูก Comment out
2**16 # คำนวณจริงๆ คือ 2 ยกกำลัง 16

65536

# *** ข้อควรระวัง ***
เครื่องหมาย hash (#) ใช้
คอมเมนต์ได้แค่บรรทัดเดียว 
หลายบรรทัดแบบนี้ไม่ได้ (จะเกิด Error)

ในกรณีหลายบรรทัดต้องใส่เครื่องหมาย # หน้าบรรทัดทุกบรรทัด

# นี่เป็นตัวอย่างที่ดี
# ที่จะแบ่งคอมเมนต์ออกเป็นหลายบรรทัด
# ทำให้อ่านง่าย

Tip

คีย์ลัด (Shortcut keys)

  1. คีย์ลัดในการเลือกหลายบรรทัด: กดคีย์ Shift ค้างไว้ แล้วเลือกบรรทัดโดยกดคีย์ \(\uparrow\)/\(\downarrow\) (Shift + Arrow) หรือ คลิกซ้ายที่เมาส์ (Shift + Click) (จะเห็นเงาในบรรทัดที่เลือก)

  2. คีย์ลัดในการคอมเมนต์หลายบรรทัด: กดคีย์ Ctrl/Cmd + “/” (เอาคอมเมนต์ออกก็ใช้คีย์ลัดเดียวกัน)

"""
แต่ถ้าไม่ชอบพิมพ์เครื่องหมาย "#"
(เพราะต้องกดกดปุ่ม "Shift")
แถมต้องกดคีย์ 'Enter' จริงๆ
ก็สามารถคอมเมนต์หลายบรรทัด
แบบนี้ โดยใช้ DocString แทนได้
(รายละเอียดอยู่ในหัวข้อถัดไป)
"""

'\nแต่ถ้าไม่ชอบพิมพ์เครื่องหมาย "#"\n(เพราะต้องกดกดปุ่ม "Shift")\nแถมต้องกดคีย์ \'Enter\' จริงๆ\nก็สามารถคอมเมนต์หลายบรรทัด\nแบบนี้ โดยใช้ DocString แทนได้\n(รายละเอียดอยู่ในหัวข้อถัดไป)\n'

คอมเมนต์หลายบรรทัดด้วย DocString#

\(\qquad\) DocString (Triple Quote String) ในภาษาไพธอนคือ ข้อความหรือสายตัวอักษร (String/Literal string) ที่อยู่ภายใน Triple Quote \('''...'''\) หรือ Triple double quotes \("""..."""\)

โดยทั่วไปจะเขียน DocString เป็นบรรทัดแรกภายในโมดูล (Module), ฟังก์ชัน (Function), คลาส (Class), เมธอด (Method) เพื่อใช้เป็นคอมเมนต์บอกว่า โมดูล ฟังก์ชัน คลาสและเมธอด นั้นๆ ใช้ทำอะไร เช่น

'''
Program: rectangle.py
Author: Taitai Smally
Last update modified: 1/1/2022

The purpose of this program is to caculate the area of a rectangle.
The input is an int or float number representing width and length of the rectangle. 
The output is a float number labeled the area of the rectangle.
'''

'\nProgram: rectangle.py\nAuthor: Taitai Smally\nLast update modified: 1/1/2022\n\nThe purpose of this program is to caculate the area of a rectangle.\nThe input is an int or float number representing width and length of the rectangle. \nThe output is a float number labeled the area of the rectangle.\n'

แต่อย่างไรก็ตาม เราสามารถใช้ DocString คอมเมนต์ข้อความหรือโค้ดตรงส่วนใดๆ ในโปรแกรมก็ได้

นอกจากนี้แล้ว ยังเรายังใช้ Docstring กำหนดข้อมูลชนิดสตริง (หลายบรรทัด) ได้อีกด้วย (รายละเอียดของสตริงอยู่ใน (การจัดการกับสตริง (String Operations))[ch2])

Note

PEP8

หลักเกณฑ์หรือสไตล์การเขียนโปรแกรม PEP8 แนะนำการเขียน DocString ที่เหมาะสมด้วยเครื่องหมาย *Triple double quotes \("""..."""\)

[Exercise] ลองเขียนโด้ดไพธอนโค้ดแรกกัน#

“The only way to learn a new programming language is by writing programs in it.”

—Dennis M. Ritchie (1901-1975)

\(\\\)

\(\qquad\) โปรแกรมเมอร์รุ่นพี่ (ไม่ว่าจะรุ่นเก่า รุ่นใหม่) เริ่มต้นการเขียนโค้ดโดยแสดงวลีในตำนาน “hello, world” ออกหน้าจอมอนิเตอร์

\(\\\) ถึงตานักศึกษาแล้ว… \(\\\)

  1. ใช้ฟังก์ชัน print() แสดงวลีในตำนาน "Hello, World!" ออกหน้าจอมอนิเตอร์

  2. ใช้ฟังก์ชัน print() แสดงวลีในตำนานเป็นฉบับภาษาไทย "สวัสดี ชาวโลก!" และใส่คอมเมนต์ต่อท้ายฟังก์ชัน print() "แสดงข้อความ Hello World ฉบับภาษาไทยโดยใช้ฟังก์ชัน print()"

  3. แสดงข้อความหลายบรรทัดต่อไปนี้เพิ่มเติม

"สวัสดี 

ยินดีต้อนรับเข้าสู่ Python"

ไพธอนจะแจ้ง Error ก่อนทำการรันหรือไม่?#

\(\qquad\) ไพธอน (Python) เป็นภาษาอินเตอร์พรีเตอร์ (Interpreted language) ทำงานโดยการแปลคำสั่งทีละคำสั่งด้วยตัวแปลภาษาไพธอน (Python Interpreter) ซึ่งแตกต่างจากภาษาอื่นเช่น C/C++, Java ซึ่งเป็นภาษาคอมไพล์ (Compiled language)

ภาษาคอมไพล์ (Compiled language) เช่น ภาษา C/C++ และ Java จะตรวจสอบโปรแกรมทั้งหมดในเวลาคอมไพล์โดยคอมไพล์เรอร์ (Compiler) และจะแจ้งเกี่ยวกับข้อผิดพลาดทั้งหมดก่อนที่จะแปลงเป็นภาษาเครื่องเพื่อทำการรัน ในขณะที่ภาษาอินเตอร์พรีเตอร์ (Interpreted language) เช่น ภาษา Python, JavaScript และ Ruby ทำงานโดยการแปลคำสั่งทีละคำสั่งด้วยตัวแปลภาษา(Interpreter) เมื่อพบข้อผิดพลาด จะหยุดรันโปรแกรม (เว้นแต่จะมีการจัดการข้อผิดพลาดโดยโปรแกรมเมอร์ ชนิดของข้อผิดพลาดและการจัดการข้อผิดพลาดจะอธิบายรายละเอียดในภายหลัง)

ลองรันโค้ดต่อไปนี้ ดูว่าเกิดจะมีข้อความอะไรอะไรแสดงบ้าง

print("This will be printed out")
printf("This will cause an error (NameError)")
print("This will NOT be printed (This is because Python interpreter has stopped working!)")

This will be printed out

---------------------------------------------------------------------------
NameError                                 Traceback (most recent call last)
Cell In [9], line 2
      1 print("This will be printed out")
----> 2 printf("This will cause an error (NameError)")
      3 print("This will NOT be printed (This is because Python interpreter has stopped working!)")

NameError: name 'printf' is not defined

เมื่อรันเซลล์ ไพธอนจะประมวลผลทีละคำสั่ง โดยรันคำสั่งแรก print("This will be printed out") ไม่มีข้อผิดผลาด จึงแสดงข้อความที่หน้าจอ This will be printed out จากนั้นรันคำสั่งที่ 2 printf("This will cause an error (NameError)") เกิดข้อผิดพลาด ไพธอนจะแจ้งข้อผิดพลาดที่หน้าจอ NameError: name 'printf' is not defined และหยุดรันโปรแกรมทันที โดยไม่ประมวลผลคำสั่งถัดไป

Error (ข้อผิดพลาด) ในภาษาไพธอน#

“Testing leads to failure, and failure leads to understanding.”

—Burt Rutan (1943-)

\(\\\)

\(\qquad\) เมื่อเกิด Error ขึ้น เราจะจำเป็นจะต้องอ่านข้อความเออเรอร์ เพราะจะบอกถึงสาเหตุ และแสดงจุดที่ผิดพลาดตำแหน่งนั้นๆ เช่นในตัวอย่างข้างต้นที่สะกดชื่อฟังก์ชัน print ผิด กลายเป็น printf ไพธอนจะแสดง Error ดังต่อไปนี้

# ลองรันโค้ดต่อไปนี้
# แสดงข้อความ (ข้อผิดผลาด (Error)) ออกหน้าจอ

printf("Hello, Python!")

---------------------------------------------------------------------------
NameError                                 Traceback (most recent call last)
Cell In [10], line 4
      1 # ลองรันโค้ดต่อไปนี้
      2 # แสดงข้อความ (ข้อผิดผลาด (Error)) ออกหน้าจอ
----> 4 printf("Hello, Python!")

NameError: name 'printf' is not defined

ไพธอนพยายามประมวลผลคำสั่ง printf แต่ไม่รู้ว่า printf คืออะไร จึงเกิดข้อผิดพลาดขึ้น

ข้อความเออเรอร์จะบอก…

  • ตำแหน่งที่เกิดข้อผิดพลาด (โดยเฉพาะกับโค้ดยาวๆ) และ

  • ชนิดของข้อผิดพลาด เช่นกรณีข้างต้น เป็นข้อผิดพลาดชนิด NameError (ข้อผิดพลาดที่เกิดเมื่อไม่พบ Identifier) โดยมีข้อความ name 'printf' is not defined (printf ไม่ได้ถูกกำหนดไว้) เป็นส่วนขยายความ แสดงในบรรทัดสุดท้ายของข้อความเออเรอร์

++

ชนิดของข้อผิดพลาด (Type of Errors)

ข้อผิดพลาดที่เกิดขึ้นจากการเขียนโปรแกรมแบ่งออกเป็น 3 ชนิด คือ

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

  2. ข้อผิดพลาดในขณะที่รันโค้ด (Runtime Errors)

  3. ข้อผิดพลาดที่เกิดจากตรรกะโปรแกรม (Logic Errors)

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

\(\qquad\) ข้อผิดพลาดที่เกิดจากไวยากรณ์ หรือ Syntax Errors น่าจะเป็นข้อผิดพลาดที่พบได้บ่อยที่สุดในช่วงเร่ิมเขียนภาษาไพธอน ตัวอย่าง Syntax Errors ที่มักพบมากที่สุดคือ

  • ลืมปิดวงเล็บ

  • ลืมใส่โคลอน ,

  • สับสนระหว่าง = และ ==

  • เยื้อง (Indentation) ผิด

เป็นต้น

ตัวอย่างของ Syntax Errors

ถ้าสตริง (string) ไม่ได้ปิดด้วยเครื่องหมาย 'Single quotes' (หรือ "Double quotes") จะแสดง SyntaxError (โครงสร้าง/รูปแบบไวยากรณ์ของภาษา (Syntax))

# ลองรันโค้ดต่อไปนี้ ดูว่าจะแสดงข้อผิดผลาดอะไร

print("Hello, Python!)

  Cell In [11], line 3
    print("Hello, Python!)
                          ^
SyntaxError: EOL while scanning string literal

ข้อผิดพลาดในขณะที่รันโปรแกรม (Runtime Errors)#

\(\qquad\) Runtime Errors เป็นข้อผิดพลาดที่เกิดในขณะที่ทำการรันโปรแกรม คำสั่งหรือโค้ดอาจจะเขียนถูก (ไม่มี Syntax errors) แต่ไม่สามารถรันได้

ตัวอย่างของข้อผิดพลาดขณะที่ทำการรันโปรแกรม (Runtime Erors) ที่มักจะพบบ่อย เช่น

  • องค์ประกอบของข้อมูล String List ฯลฯ ไม่ถูกต้อง (IndexError, ValueError, …)

  • พิมพ์ชื่อตัวแปร/ชื่อฟังก์ชันผิด (NameError)

  • โมดูล/ไลบรารี่ที่ import เข้ามา ไม่มีหรือไม่ถูกต้อง (ModuleNotFoundError)

  • การประมวลผลและประเภทของข้อมูลที่ไม่สอดคล้องกัน (TypeError, ValueError)

  • การหารด้วยศูนย์ (ZeroDivisionError)

เป็นต้น

ตัวอย่างต่อไปนี้เป็นการหารด้วยศูนย์

# ZeroDivisionError เป็นข้อผิดพลาดที่เกิดเมื่อหาร "/", "//" หรือ "%" (modulo) ด้วยศูนย์
print(1/0)

---------------------------------------------------------------------------
ZeroDivisionError                         Traceback (most recent call last)
Cell In [12], line 2
      1 # ZeroDivisionError เป็นข้อผิดพลาดที่เกิดเมื่อหาร "/", "//" หรือ "%" (modulo) ด้วยศูนย์
----> 2 print(1/0)

ZeroDivisionError: division by zero

ข้อผิดพลาดที่เกิดจากตรรกะโปรแกรม (Logic Errors)#

\(\qquad\) ข้อผิดพลาดที่เกิดจากตรรกะโปรแกรม (Logic Errors) คือ “Bugs” ของโปรแกรม เป็นข้อผิดพลาดที่เกิดจากซอร์สโค้ดซึ่งส่งผลให้ผลลัพธ์ที่ได้ไม่ถูกต้องหรือโปรแกรมทำงานไม่เป็นไปตามที่คาดคิดไว้ เช่น ตัวอย่างต่อไปนี้

Important

ข้อผิดพลาดที่เกิดจากตรรกะโปรแกรม (Logic Errors) เป็นข้อผิดพลาดแบบนี้ไพธอนไม่สามารถตรวจพบได้ ดังนั้นผู้เขียนโปรแกรมจึงต้องมีการตรวจสอบเงื่อนไขหรือสูตรให้ถูกต้อง และขณะเขียนโค้ด ให้ตรวจสอบว่ามีอะไรแตกต่างจากที่เราคาดหวัง หากจำเป็น ให้แทรกคำสั่ง “print()” ลงในโค้ดเพื่อตรวจสอบผลการอินพุต/เอาต์พุต)

ตัวอย่างต่อไปนี้ เป็นการหาค่าเฉลี่ยของตัวเลขสองจำนวน (ที่ผิด)

num1 = 20
num2 = 80

average = num1 + num2 / 2
average

60.0

โค้ดข้างต้นประมวลผลได้ แต่ให้ผลลัพธ์ที่ไม่ถูกต้อง (เนื่องจากค่าเฉลี่ยของ 20 และ 80 ไม่ได้ 50 ตามที่ควรจะเป็น)

ลองแก้โค้ดข้างต้นให้ถูกต้อง

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

ชนิดของออบเจกต์ (Object) พื้นฐานในภาษาไพธอน#

\(\qquad\) ไพธอนเป็นภาษาเชิงวัตถุ (object-oriented programming; OOP) (Wiki: ไพธอน) โดยมองสิ่งต่างๆ ในระบบเป็นวัตถุหรือออบเจกต์ (Object)1 ชิ้นหนึ่ง

\(\qquad\) ออบเจกต์ในภาษาไพธอน มีให้เลือกใช้งานหลากหลายชนิดเช่นเดียวกับภาษาอื่นๆ และแต่ละชนิดก็มีเป้าหมายในการใช้งานที่แตกต่างกัน

ออบเจกต์พื้นฐานในไพธอนสรุปเป็นตารางได้ดังนี้

กลุ่มชนิดข้อมูล

ชนิดข้อมูล

ข้อมูลประเภทตัวอักษร

str

ข้อมูลประเภทตัวเลข

int, float, complex

ข้อมูลประเภท Sequence

list, tuple, range

ข้อมูลประเภท Mapping

dict

ข้อมูลประเภทเซ็ท Set

set, frozenset

ข้อมูลประเภทค่าความจริง

bool

ข้อมูลประเภทไบนารี่

bytes, bytearray, memoryview

ออบเจกต์ (Object) พื้นฐานที่ใช้มากที่สุด คือ str (strings), int (integers) และ float (floats)

types-of-objects

ตัวอย่างต่อไปนี้ เป็นตัวอย่างของจำนวนเต็ม (Integer) จำนวนจริงหรือจำนวนทศนิยม (Float) และแถวตัวอักษร (String) ตามลำดับ

12 # จำนวนเต็ม (Integer) 1 โหล

12

1.618033988749 # จำนวนจริง หรือจำนวนทศนิยม (Float) ค่าของ Golden ratio

1.618033988749

1.6e-19 # เลขทศนิยมในรูปของเลขยกกำลังฐานสิบ ค่าประจุดของอิเล็กตรอน 

1.6e-19

"Hello, Python!" # String แถวอักษรที่อยู่ภายใน Single quote หรือ Double quotes

'Hello, Python!'

ไพธอนมีฟังก์ชัน type() (built-in function) บอกชนิดของออบเจกต์

  • integers \(\rightarrow\) int (<class ‘int’>),

  • floats \(\rightarrow\) float (<class ‘float’>),

  • character strings \(\rightarrow\) str (<class ‘str’>)

ลองใช้ฟังก์ชัน type() แสดงชนิดของออบเจกต์

# ชนิดข้อมูลของ 12

type(12)

int

เป็น int ซึ่งย่อมาจาก integer number (จำนวนเต็ม)

# ชนิดข้อมูลของ 1.618033988749

type(1.618033988749)

float

เป็น float ซึ่งย่อมาจาก floating point number (จำนวนเต็ม)

# ชนิดข้อมูลของ "Hello, Python!"

type("Hello, Python!")

str

เป็น str ซึ่งย่อมาจาก string (สตริงหรือสายอักขระ)

ลองเขียนโค้ด ตรวจสอบดูว่า 7.0 เป็นออบเจกต์ชนิด int หรือ float

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

จำนวนเต็ม (Integers)#

\(\qquad\) จำนวนเต็ม (integers) เป็นได้ทั้งตัวเลขที่เป็นบวกและลบ เช่น

_images/TypesInt.png

เราสามารถตรวจสอบชนิดได้โดยใช้ฟังก์ชัน type()

type(-1)  # ชนิดข้อมูลของ -1

int

type(4) # ชนิดข้อมูลของ 4

int

type(0) # ชนิดข้อมูลของ 0

int

Python ไม่ให้เขียน 0 หน้าจำนวนเต็ม (ห้าม!) มิฉะนั้นจะเกิด SyntaxError

007 # SyntaxError

  Cell In [26], line 1
    007 # SyntaxError
      ^
SyntaxError: leading zeros in decimal integer literals are not permitted; use an 0o prefix for octal integers

Note

เลขจำนวนเต็มในไพธอน …

  • เลขจำนวนเต็มใน Python เวอร์ชัน 2 มี 2 ชนิด คือ int และ long แต่ใน Python 3 มีเพียงชนิดเดียวคือ int และมีสิ่งที่ต่างกับภาษาอื่นๆ คือ มีขนาดไม่จำกัด! ดังนั้น เราสามารถให้จำนวนเต็มมีกี่หลักก็ได้ (แต่แน่นอน ไม่เกินหน่วยความจำ (Memory) ของคอมฯ ที่ใช้เก็บข้อมูล)Mortada Mehyar: Can Integer Operations Overflow in Python?

  • นอกจากเลขจำนวนเต็มฐาน 10 แล้ว ไพธอนยังมีเลขจำนวนเต็มฐาน 2 (binary) ฐาน 8 (octal) และ ฐาน 16 (hexadecimal) อีกด้วย เช่น

0b10 เป็นเลขจำนวนเต็มฐาน 2 มีค่าเท่ากับ 2

0o10 เป็นเลขจำนวนเต็มฐาน 8 มีค่าเท่ากับ 8

0x10 เป็นเลขจำนวนเต็มฐาน 16 มีค่าเท่ากับ 16 เป็นต้น

(ไม่อธิบายรายละเอียดแต่สามารถศึกษาเพิ่มเติมได้ที่เว็บ python.org: PEP 3127 – Integer Literal Support and Syntax)

จำนวนจริง (Floats)#

\(\qquad\) Floats เป็นเลขจำนวนจริง หรือ “ตัวเลขที่มีทศนิยม” (จำนวนจริงเป็น superset ของตัวเลขจำนวนเต็ม)

ทั้ง 1 และ 1.0 มีค่าเท่ากัน แต่ชนิดของข้อมูลต่างกัน

type(1.0) # ข้อสังเกต: 1 เป็นชนิดชนิด int ในขณะที่  1.0 เป็นชนิด float

float

เช่นกัน ทั้ง 0 และ 0.0 มีค่าเท่ากัน แต่ชนิดของข้อมูลต่างกัน

type(0.0)  # ชนิดข้อมูลของ 0.0

float

จำนวนจริงเขียนได้ทั้งในรูปทศนิยม และในรูปของเลขยกกำลังฐานสิบ

ยกตัวอย่าง เช่น ค่าคงตัวของแก๊ส (Gas constant) \(R = 8.314472 \times 10^{-15} J \cdot K^{-1} \cdot mol^{-1}\)

type(8.314472E-15) # ชนิดข้อมูลของ 8.314472E-15 

float

1e0.5 # SyntaxError: เลขชี้กำลังต้องเป็นจำนวนเต็มเท่านั้น

  Cell In [30], line 1
    1e0.5 # SyntaxError: เลขชี้กำลังต้องเป็นจำนวนเต็มเท่านั้น
       ^
SyntaxError: invalid syntax

ในภาษาไพธอน จำนวนเต็มมีขนาดไม่สิ้นสุด! แล้วจำนวนจริงหละ??

\(\qquad\) ตัวเลขที่มากที่สุด (Max) และน้อยที่สุด (Min) ของข้อมูลตัวเลขชนิด Floats สามาถตรวจสอบได้โดยใช้โมดูล sys ใช้ sys.float_info (sys.float_info.max, sys.float_info.min) (รายละเอียดของโมดูล sys )

# System settings about float type
sys.float_info

sys.float_info(max=1.7976931348623157e+308, max_exp=1024, max_10_exp=308, min=2.2250738585072014e-308, min_exp=-1021, min_10_exp=-307, dig=15, mant_dig=53, epsilon=2.220446049250313e-16, radix=2, rounds=1)

เนื่องจากคอมพิวเตอร์ผู้เชียนเป็น 64-bit ตัวเลขจำนวนจริงจะอยู่ระหว่าง 2.2250738585072014e-308 (min) และ 1.7976931348623157e+308 (max) (เทียบเท่าข้อมูลชนิด double (64-bit) ในภาษาอื่น)

sys.float_info.min

2.2250738585072014e-308

sys.float_info.max

1.7976931348623157e+308

เราจะลองทำให้เกิดการ Overflow ในไพธอน ด้วยการบวก 1 เข้าไปยังค่า max

# Overflow in Python
sys.float_info.max + 1 # On my computer (64-bit): 1.7976931348623157e+308

1.7976931348623157e+308

ตัวเลขไม่เปลี่ยน มีค่าเท่าเดิม?

เราลองตรวจสอบยืนยันด้วยโอเปอร์เรเตอร์ == เพื่อดูว่าค่าเท่ากันหรือไม่

print (sys.float_info.max+1 == sys.float_info.max) #  the output will be TRUE (Boolean)

True

ผลลัพธ์ที่ได้คือ True นั่นหมายความว่า ซ้าย sys.float_info.max มีค่าเท่ากับขวา sys.float_info.max + 1 แสดงว่า Python ไม่มีความแม่นยำเพียงพอที่จะเก็บข้อมูลเพิ่ม ทำให้ผลลัพธ์ไม่ถูกต้อง

แต่ถ้าเราบวกเพิ่มเยอะๆ เช่น

sys.float_info.max + sys.float_info.max

inf

จะทำให้เกิดโอเวอร์โฟลว์ชัดเจน และในกรณีนี้ Python จะส่งค่ากลับเป็น inf (infinity) ซึ่งเป็นข้อมูลชนิด float

รายละเอียดของข้อมูลชนิด float(64-bit) และการ Overflow สามารถอ่านเพิ่มเติมได้ที่ Double-precision floating-point format และ Floating Point Numbers

type(sys.float_info.max + sys.float_info.max)

float

Note

ใน Python 3 จำนวนจริง (Floating) เป็นอ็อบเจ็กต์ที่มีขีดจำกัด ในขณะที่ จำนวนเต็มเป็นอ็อบเจ็กต์ที่มีขนาดไม่จำกัด) เมื่อขนาดของตัวเลขใหญ่ขึ้น Python จะปรับหน่วยความจำให้เพิ่มขึ้นโดยอัตโนมัติตามต้องการ ซึ่งหมายความว่าเราสามารถคำนวณตัวเลขจำนวนมากๆ ได้ โดยไม่ต้องทำอะไรเพิ่ม และโดยปกติแล้ว การคำนวณจำนวนเต็มในภาษา Python จะไม่เกิด Overflow (การคำนวณจำนวนที่เกินขีดจำกัด) เหมือนภาษาโปรแกรมอื่นๆ หลายภาษา เช่น C, FORTRAN (ที่จำนวนเต็มมีขนาดคงที่ ซึ่งส่วนใหญ่มีขนาด 4 ไบต์ โดยเก็บค่าได้ \(2^{32}\) ข้อมูลที่มีค่าต่างกัน)

อย่างไรก็ตาม เราต้องตระหนักถึงการเกิด Overflow เมื่อเราใช้ไลบรารีบางตัว เช่น NumPy Pandas ในการคำนวณ เนื่องจากจำนวนเต็มในไลบรารีเหล่านั้นมีขนาด (จำนวนบิตที่ใช้ในการเก็บข้อมูล) คงที่ (เพื่อให้การคำนวณมีประสิทธิภาพมากขึ้นและเนื่องจากมีรากฐานมาจากภาษา C/C++) NumPy: ประเภทข้อมูล (Data types) Numpy เช่น int16 เป็นจำนวนเต็ม 16 บิต โดยเก็บค่าได้ \(2^{16}\) ข้อมูลที่มีค่าต่างกัน โดยจำนวนเต็มสามารถกำหนดให้เก็บค่าได้ทั้งจำนวนที่เป็นบวกและลบ (Signed) และเก็บค่าเฉพาะจำนนวนที่เป็นบวก (Unsigned) ยกตัวอย่างเช่น

  • uint16 (unsigned) มีค่าตั้งแต่ 0 ถึง \(2^{16}-1\)

  • int16 (signed) มีค่าตั้งแต่ \(-2^{15}\) ถึง \(2^{15}-1\)

บูลีน (Boolean)#

\(\qquad\) บูลีน (Boolean) เป็นชนิดของออบเจกต์ที่สำคัญชนิดหนึ่ง ออบเจกต์ Boolean สามารถมีค่าเป็น "True" หรือ "False" อย่างใดอย่างหนึ่ง

True # Value true

True

Attention

True อักษรตัวแรกใช้ตัวพิมพ์ใหญ่ “T” และเช่นกัน False อักษรตัวแรกใช้ตัวพิมพ์ใหญ่ “F”

False # Value false

False

ถ้าลองใช้ฟังก์ชัน type() แสดงชนิดของออบเจกต์บูลีน จะแสดงเป็น bool ซึ่งย่อมาจาก boolean

type(True) # Type of True

bool

type(False) # Type of False

bool

โดยส่วนใหญ่ จะใช้บูลีนสำหรับการตัดสินแบบมีเงื่อนไข (Conditions)

เช่น ตัดสินว่า -1 มากกว่า 3 หรือไม่

-1 > 3

False

ได้ผลลลัพธ์เป็นเท็จ (False) เนื่องจาก -1 ไม่มากกว่า 3

3**3**3 != (3**3)**3

True

ได้ผลลลัพธ์เป็นจริง (True) เนื่องจาก 3**3**3 ไม่เท่ากับ (3**3)**3 จริง (ซ้ายมือมีค่าเท่ากับ 3**(3**3) \(= 3^9\) เนื่องจากการยกกำลังประมวลผลจากขาวไปซ้าย ในขณะที่ขวามือมีค่าเท่ากับ (3**3)**3 \(= 9^3\))

Attention

การยกกำลังประมวลผลจากขาวไปซ้าย

เราสามารถแปลงออบเจกต์บูลีนไปเป็นออบเจกต์ชนิดอื่นได้

หากเราแปลงบูลีนที่มีค่า True เป็นจำนวนเต็มหรือทศนิยม เราก็จะได้ค่า 1 (หนึ่ง) หากเราแปลงบูลีนที่มีค่า False เป็นจำนวนเต็มหรือทศนิยม เราจะได้ 0 (ศูนย์)

ในทำนองเดียวกัน หากเราแปลง 1 ไปเป็นชนิดบูลีน ค่าที่ได้จะเป็น True และถ้าเราแปลง 0 ไปที่เป็นชนิดบูลีน ค่าที่ได้จะเป็น False

# แปลง True เป็น int

int(True)

1

# แปลง 1 เป็น boolean

bool(1)

True

# แปลง 0 เป็น boolean

bool(0)

False

แต่ถ้าเป็นเลขค่าอื่นที่ไม่ใช่ 0 และ 1 จะเป็นอย่างไร?

เช่น ถ้าเป็นเลข 0.1, -1

bool(0.1) 

True

bool(-1) 

True

# แปลง True เป็น float

float(True)

1.0

Note

ไพธอนจะประเมินผลบูลีนว่าเป็น True หรือ False โดยการเปรียบเทียบกับ 0.0 หากเปรียบเทียบแล้วไม่เท่า Python จะให้ค่าบูลีนเป็น True (หรือ 1) แต่หากเท่า Python จะให้ค่าบูลีนเป็น False (0)

ตารางสรุปโอเปอร์เรเตอร์เปรียบเทียบ (Comparison operators) ในภาษาไพธอน

โอเปอร์เรเตอร์ \(\quad \quad\)

ตัวอย่าง \(\quad\)

ความหมาย \(\quad \quad\)

ผลลัพธ์

\==

a==b

เท่ากับ

เป็นจริง (True) ก็ต่อเมื่อค่าของ a เท่ากับค่าของ b มิฉะนั้นผลลัพธ์เป็นเท็จ (False)

!=

a!=b

ไม่เท่ากับ

เป็นจริง (True) ก็ต่อเมื่อค่าของ a ไม่เท่ากับค่าของ b มิฉะนั้นผลลัพธ์เป็นเท็จ (False)

<

a<b

น้อยกว่า

เป็นจริง (True) ก็ต่อเมื่อค่าของ a น้อยกว่าค่าของ b มิฉะนั้นผลลัพธ์เป็นเท็จ (False)

<=

a<=b

น้อยกว่าหรือเท่ากับ

เป็นจริง (True) ก็ต่อเมื่อค่าของ a น้อยกว่าหรือเท่ากับค่าของ b มิฉะนั้นผลลัพธ์เป็นเท็จ (False)

\>

a>b

มากกว่า

เป็นจริง (True) ก็ต่อเมื่อค่าของ a มากกว่าค่าของ b มิฉะนั้นผลลัพธ์เป็นเท็จ (False)

\>=

a>=b

มากกว่าหรือเท่ากับ

เป็นจริง (True) ก็ต่อเมื่อค่าของ a มากกว่าหรือเท่ากับค่าของ b มิฉะนั้นผลลัพธ์เป็นเท็จ (False)

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

สตริง (Strings)#

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

ในภาษาไพธอน จะกำหนดสตริงโดยให้ข้่อความหรือตัวอักษรอยู่ในเครื่องหมายคำพูด single quotes ‘…’ หรือเครื่องหมายคำพูด double quotes “…” ซึ่งทั้งสองรูปแบบให้ผลลัพธ์เหมือนกัน

ดังตัวอย่างต่อไปนี้

type('spam eggs')

str

'spam eggs' == "spam eggs"

True

สายอักขระว่าง (Empty string, null string, empty word) เป็นสตริงที่มีเอกลักษณ์เฉพาะ มีขนาดของสตริงเท่ากับศูนย์

type('') # Empty string, null string, empty word.

str

ในกรณีที่ต้องการสร้างสตริงที่มีเครื่องหมาย ' ให้ใช้เครื่องหมาย "\" (Back slash/Backslash) นำหน้า เช่น

'I doesn\'t care'  # ใช้ '\' แสดงเครื่องหมายคำพูด single quote...

"I doesn't care"

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

"I doesn't care" 

"I doesn't care"

สามารถเชื่อมสตริงด้วยโอเปอเรเตอร์ (Operator) + เช่น

"I doesn't care" + ', ' + 'You don\'t Care' + ', ' + 'who cares?'

"I doesn't care, You don't Care, who cares?"

สรุป ชนิดของออบเจกต์ (ข้อมูล) พื้นฐานที่ใช้ได้ในภาษาไพธอน

ชนิดข้อมูล ฟังก์ชันแปลง

คำอธิบาย

ตัวอย่าง

หมายเหตุ

จำนวนเต็ม int()

(จำนวนที่ไม่มีทศนิยม)

-5, 0, 5

ไม่จำกัดจำนวนหลัก

จำนวนจริง float()

จำนวนที่มีทศนิยม

1.0, \(\qquad \qquad \) 1.6E-19

จำกัดจำนวนหลักของเลขนัยสำคัญและเลขชี้กำลัง ตัวเลขที่มีค่าเยอะมากๆ หรือน้อยมากๆ จะแสดงในรูปเลขทศนิยมยกกำลังฐานสิบ เช่น 1.6E-19 (หรือ 1.6e-19) หมายถึง \(1.6 \times 10^{-19}\) (โดยเลขหลัง E(e) ต้องเป็น int เสมอ)

สติง str()

ข้อความหรือสายอักขระ

'aaa101', \(\quad\) "ภาษาไทย"

สตริงถูกคร่อมภายในเครื่องหมายคำพูด single/double quote

บูลีน bool()

ใช้สำหรับการตัดสินแบบมีเงื่อนไข

True, False

เป็นคำสงวน (ตัวแรกเป็นตัวพิมพ์ใหญ่) โดยมีค่าคงที่ True(1), Falase(0)

การแปลงชนิดของออบเจกต์ (Typecasting)#

\(\qquad\) เราสามารถเปลี่ยนชนิดของออบเจกต์จากชนิดหนึ่งไปเป็นอีกชนิดหนึ่งได้ เราเรียกว่ากระบวนการนี้ว่า การแปลงชนิดข้อมูล (Type Casting)

เราจะลองเปลี่ยนชนิดข้อมูลจากจำนวนเต็ม (int) เป็นจำนวนจริง (float) เช่น จาก 2 เป็น 2.0

โดยเริ่มจาก ตรวจสอบชนิดของข้อมูลของ 2 กันก่อน

type(2)  # ตรวจสอบชนิดของข้อมูลว่าเป็น int

int

แปลง Integers เป็น Floats#

\(\qquad\) แปลงจำนวนเต็ม 2 ให้เป็นจำนวนจริงหรือเลขทศนิยม โดยใช้ฟังก์ชั่น float( )

float(2) # แปลง 2 เป็น float

2.0

ได้ผลลัพธ์เป็น 2.0 ซึ่งเป็นข้อมูลชนิด float

หรือจะทำการแปลงและทำการตรวจสอบพร้อมๆกัน โดยเขียนเป็นบรรทัดเดียว

type(float(2))  # แปลงจำนวนเต็ม 2 เป็น float และตรวจสอบชนิดของข้อมูล

float

การแปลงจำนวนเต็มเป็นจำนวนจริง ผลลัพธ์ที่ได้จะไม่เปลี่ยนค่า ตรวจสอบได้โดยใช้โอเปอร์เรเตอร์ ==

2 == float(2) # ตรวจสอบว่า 2 มีค่าเท่ากับจำนวนจริง 2.0 หรือไม่

True

ผลลัพธ์ที่ได้เป็น True ยืนยันว่าการเปลี่ยนจาก 2 เป็น 2.0 มีค่าเท่าเดิม (ชนิดของข้อมูลเปลี่ยน แต่ค่าของของมูลไม่เปลี่ยน)

แต่ถ้าเราแปลงจำนวนจริงเป็นจำนวนเต็ม ข้อมูลบางส่วนอาจสูญหาย (เพราะ int เป็น subset ของ float) ตัวอย่างเช่น หากเราแปลงเลขทศนิยม 1.1 หรือ 1.9 เป็นจำนวนเต็ม เราจะได้ 1 ค่าไม่เท่าเดิม ข้อมูลทศนิยมหายไป!

int(1.1) # การแปลง 1.1 เป็นจำนวนเต็ม จะทำให้ข้อมูลทศนิยม 0.1 สูญหาย

1

int(1.9) # การแปลง 1.9 เป็นจำนวนเต็ม จะทำให้ข้อมูลทศนิยม 0.9 สูญหาย

1

Attention

ฟังก์ชั่น int() จะแปลงจำนวนทศนิยมเป็นจำนวนเต็มโดยการตัดตัวเลขหลังทศนิยมทิ้ง เช่น int(1.1), int(1.9) จะมีค่าเป็น 1 ฉะนั้นในกรณีที่ต้องการปัดจำนวนทศนิยมขึ้นหรือปัดลงให้เป็นจำนวนเต็ม ให้ใช้ฟังก์ชั่น round() เช่น round(1.1) จะถูกปัดลง มีค่าเป็น 1 แต่ถ้า round(1.9) จะถูกปัดขึ้น มีค่าเป็น 2

round(1.1)

1

round(1.9)

2

แปลงจากสตริง (strings) เป็นจำนวนเต็ม (integers) หรือจำนวนจริง (floats)#

\(\qquad\) ถ้าสตริงเป็นตัวเลข เราสามารถแปลงให้เป็น integer ได้โดยใช้ฟังก์ชัน int()

int('1')

1

แต่ถ้าในสตริงไม่ได้เป็นตัวเลขทั้งหมด จะเกิด Error ดังตัวอย่างต่อไปนี้

int('1 or 2 people')

---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
Cell In [65], line 1
----> 1 int('1 or 2 people')

ValueError: invalid literal for int() with base 10: '1 or 2 people'

แน่นอน ถ้าสตริงเป็นเลขทศนิยม เราก็สามารถแปลงให้เป็นจำนวนจริง (floating number) ได้โดยใช้ฟังก์ชัน float()

เช่น แปลงสตริง 1.2

float('1.2') # แปลงสตริง "1.2" เป็นชนิืด float

1.2

Tip

สตริง (Strings) จะถูกคร่อมด้วย Single quotes เช่น '1.2' หรือ Double quotes เช่น "1.2" ก็ได้ แต่ใช้ผสมกันแบบไม่ได้ เช่น "1.2' (เกิด Error)

แปลงตัวเลขเป็นสตริง#

\(\qquad\) ถ้าเราแปลงสตริงเป็นตัวเลขได้ การแปลงตัวเลขเป็นสตริงก็เป็นเรื่องธรรมดาที่สามารถทำได้เช่นกัน

str(1) # แปลงจำนวนเต็มเป็น string

'1'

จะแปลงตัวเลขทศนิยมเป็นสตริงก็ทำได้

str(1.2) # แปลงจำนวนจริงเป็น string

'1.2'

[Exercise] : Types#

1. ผลลัพธ์ของ 6 / 2 เป็นข้อมูลชนิดใด? (เรียกเครื่องหมาย / ว่า Single slash)

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

2. ผลลัพธ์ของ 6 // 2 เป็นข้อมูลชนิดใด? (เรียกเครื่องหมาย // ว่า Double slash)

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

ตัวแปร (Variable) และนิพจน์ (Expression)#

นิพจน์ (Expression)#

\(\qquad\) นิพจน์ (Expression) คือ กลุ่มของข้อมูลที่เขียนในรูปสัญลักษณ์ซึ่งอาจจะอยู่ในรูปของตัวแปร,ค่าคงที่หรือฟังก์ชันเชื่อมต่อกับตัวดำเนินการโดยใช้เครื่องหมายต่างๆ ไม่ว่าจะเป็นเครื่องหมายทางคณิตศาสตร์ (เช่น +, -, *, / ฯลฯ) เครื่องหมายการเปรียบเทียบ (เช่น ==, !=, >, < ฯลฯ) หรือเครื่องหมายทางตรรกศาสตร์ (เช่น and, or, ฯลฯ) โดยนิพจน์จะมีมีค่าคืนกลับเสมอ ยกตัวอย่างเช่น การคำนวณทางคณิตศาสตร์พื้นฐาน 43+60+16+41 (มีค่าคืนกลับคือ 160)

43 + 60 + 16 + 41   # นิพจน์ทางคณิตศาสตร์ทำการบวก

160

50 - 60   # นิพจน์ทางคณิตศาสตร์ทำการลบ

-10

5 * 5   #  นิพจน์ทางคณิตศาสตร์ทำการคูณ (ใช้เครื่องหมาย * (asterisk/star)

25

25 / 5   # นิพจน์ทางคณิตศาสตร์ทำการหาร (ใช้เครื่องหมาย / (Single slash))

5.0

25 / 6   # นิพจน์ทางคณิตศาสตร์ทำการหาร (ใช้เครื่องหมาย / (Single slash))

4.166666666666667

การหารจำนวนเต็มด้วย Double slash // จะได้ผลหารที่ถูกปัดเศษลง เป็นจำนวนเต็มที่ใกล้เคียงที่สุด

25 // 5   # นิพจน์ทางคณิตศาสตร์ทำการหารปัดเศษทิ้ง (ใช้เครื่องหมาย // (Double slash))

5

25 // 6   # นิพจน์ทางคณิตศาสตร์ทำการหารปัดเศษทิ้ง

4

(-1)//2    # นิพจน์ทางคณิตศาสตร์ทำการหารจำนวนติดลบแบบปัดเศษทิ้ง

-1

1//(-2)   # นิพจน์ทางคณิตศาสตร์ทำการหารจำนวนติดลบแบบปัดเศษทิ้ง

-1

นิพจน์ทางคณิตศาสตร์ในภาษา Python เป็นไปตามหลักคณิตศาสตร์พื้นฐาน

30 + 2 * 60   # นิพจน์ทางคณิตศาสตร์

150

เช่นเดียวกับคณิตศาสตร์ นิพจน์ที่อยู่ในวงเล็บมีลำดับความสำคัญมากกว่าการคูณการหาร

(30 + 2) * 60   # นิพจน์ทางคณิตศาสตร์

1920

[Exercise] นิพจน์ (Expression)#

1. จงเขียนนิพจน์เพื่อคำนวณว่า ในเวลา 24 ชั่วโมง มีกี่วินาที?

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

2. จงเขียนนิพจน์เพื่อคำนวณว่า ในเวลา 160 นาที มีกี่ชั่วโมง?

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

ตัวแปร (Variables)#

\(\qquad\) เช่นเดียวกับภาษาคอมพิวเตอร์อื่นๆ เราสามารถเก็บค่าใน ตัวแปร (Variables) เพื่อนำไปใช้ในภายหลังได้ (ในโปรแกรมคอมพิวเตอร์ เราใช้ตัวแปรเก็บข้อมูล)

การกำหนดค่าตัวแปร#

\(\qquad\) คำสั่งในการกำหนดค่า (Assignment Statements) ในภาษาไพธอนจะใช้เครื่องหมาย (ตัวดำเนินการ) "=" เพื่อกำหนดค่าให้กับตัวแปร (Assignment)

คำสั่ง (Statement) หมายถึง โค้ดที่เขียนขึ้นเพื่อให้โปรแกรมทำงาน ประกอบด้วยตัวแปร หรือนิพจน์ต่างๆ โดยคำสั่งจะไม่ค่าคืนกลับหลังจากที่คำสั่งทำงานเสร็จสิ้น (ในขณะที่นิพจน์ (Expression) จะมีค่าคืนกลับ)

การกำหนดค่าตัวแปรในภาษาไพธอนสามารถกำหนดค่าได้เลย โดยที่ไม่ต้องระบุชนิดของข้อมูล (Data Type) ที่จะเก็บ เนื่องจากไพธอนเป็นภาษา Dynamically typed (ต่างจากภาษา C/C++, Swift ฯลฯ ซึ่งเป็นภาษา Statically typed) ที่ต้องกำหนดชนิดข้อมูล ก่อนเรียกใช้งาน)

กำหนดค่าให้กับตัวแปร x ได้ง่ายๆ โดยใช้ตัวดำเนินการ = ดังนี้

x = 43 + 60 + 16 + 41

ถ้าต้องการแสดงค่าตัวแปร x ใน Notebook ทำได้ง่ายๆ เพรียงแค่พิมพ์ตัวแปรลงในเซลล์ แล้วกดปุ่ม Shift+Enter จะแสดงค่าตัวแปรที่กำหนดไว้

x

160

ตัวแปร x มีค่าเป็น int คือตัวเลขจำนวนเต็ม

print(type(x))

<class 'int'>

เราสามารถดำเนินการกับตัวแปรและเก็บผลลัพธ์ที่ได้ลงในตัวแปรใหม่ได้อีกด้วย

y = x / 60
y

2.6666666666666665

ถ้าเราเซฟค่าลงในตัวแปรเดิมที่มีอยู่ ค่าเดิมจะหายไป จะถูกเซฟทับด้วยค่าใหม่แทน

x = x / 60
x

2.6666666666666665

ณ ตอนนี้ ตัวแปร x มีค่าเป็น 2.6666666666666665 เป็น float

print(type(x))

<class 'float'>

Note

ข้อมูลทุกอย่างในภาษาไพธอนเป็น “ออบเจ็กต์ (Objects)”

\(\qquad\) ใน โปรแกรมเชิงวัตถุ (Object-oriented programming; OOP) คลาส (Class) เป็นต้นแบบ (Blueprint) หรือแม่แบบ (Template) เพื่อสร้างวัตถุหรือออบเจ็กต์ (วัตถุเสมือน; Objects) ขึ้นมา ออบเจ็กต์ที่สร้างมาจากคลาสบางครั้งจะเรียกว่าอินสแตนท์ (Instance) ของคลาสนั้นๆ โดยคลาสหนึ่งสามารถใช้สร้างออบเจ็กต์ได้หลายๆ ออบเจ็กต์ โดยที่แต่ละออบเจ็กต์ต้องมีชื่อที่แตกต่างกันไป (รายละเอียดของคลาและออบเจ็กต์มีอธิบายใน Part 3)

จากตัวอย่างข้างต้น ตัวแปร x เป็นอินสแตนท์ (Instance) ของคลาส float

เราสามารถกำหนดค่าให้กับตัวแปรหลายตัวพร้อมๆ กันได้

a, b, c, d = 43, 60, 16, 41
a+b+c+d

160

คำสั่ง a, b, c, d = 43, 60, 16, 41 เป็นการกำหนดค่าให้ตัวแปร ตามลำดับของตัวแปร เทียบเท่ากับการรันคำสั่ง a = 43; b = 60; c = 16; d = 41

ตรวจสอบดูว่าตัวแปร c มีค่าเป็น 16 หรือไม่โดยพิมพ์คำสั่ง print(c) หรือง่ายๆ แค่พิมพ์ c

c

16

นอกจากนี้ เรายังสามารถกำนดค่าตัวแปรแบบลูกโซ่ (Chained assignment) ได้อีกด้วย

x = y = z = 160
x

160

ตัวแปร x, y และ z มีค่าเป็น 160

หลักในการตั้งชื่อตัวแปร#

\(\qquad\) เราควรตั้งชื่อตัวแปรที่มีความหมาย เพื่อให้ตัวเราเองและคนอื่นๆ สามารถอ่านโค้ดและทำความเข้าใจได้ง่ายขึ้น

สมมุติว่า เราต้องการรวมเวลาของอัลบัม 3 อัลบัม (หน่วยเป็นนาที) แล้วเก็บค่าไว้ในในตัวแปรตัวหนึ่ง จากนี้นเอาตัวแปรดังกล่าวหารด้วย 60 เพื่อเปลี่ยนเป็นหน่วยชั่วโมง แล้วเก็บค่าไว้ในตัวแปรอีกตัวแปรหนึ่ง เราจะเขียนคำสั่งตามดังนี้

total_min = 43 + 42 + 57 # Total length of albums in minutes
total_min

142

total_hours = total_min / 60 # Total length of albums in hours 
total_hours

2.3666666666666667

ชื่อของตัวแปรข้างต้น total_min และ total_hours อ่านแล้วเข้าใจได้เลยว่า เป็นตัวแปรที่เก็บค่าของจำนวนนาทีทั้งหมด และจำนวนชั่วโมงทั้งหมด

เราลองตั้งชื่อตัวแปรที่มีความหมายอีกตัวหนึ่ง โดยใช้ชื่อ and

and = 2
and

  Cell In [95], line 1
    and = 2
    ^
SyntaxError: invalid syntax

เกิด Error (SyntaxError: invalid syntax) !! เพราะเหตุใด?

กฎเกณฑ์ในการตั้งชื่อตัวแปร

  1. ตัวอักษรตัวแรกต้องเป็นภาษาอังกฤษ (A-Z, a-z) ตามด้วยตัวอักษร หรือตัวเลขใดๆ ก็ได้

  2. ชื่อตัวแปรห้ามมีช่องว่าง จุดทศนิยม และสัญลักษณ์พิเศษ ( !, @, #, $, %) ยกเว้น underscore “_” เท่านั้น

  3. การใช้อักษรตัวพิมพ์ใหญ่และอักษรพิมพ์เล็กมีความแตกต่างกัน (Case-sensitive)

  4. ห้ามใช้คำสวงน (Reserved word, Keyword) เป็นชื่อตัวแปร เช่น if, for, and, global, yield … และ ไม่ควรใช้ตั้งชื่อตัวแปรซ้ำกับชื่อฟังก์ชันในไพธอน เช่น int, str, max, sum …

  5. ชื่อควรสื่อความหมายกับข้อมูลที่จะเก็บ เป็นชื่อที่สามารถอ่านและทำความเข้าใจได้ง่าย

    (อ่านเพิ่มเติมได้ใน Dmitri Pavlutin: Coding like Shakespeare: Practical Function Naming Conventions)

Note

PEP8

หลักเกณฑ์หรือสไตล์การเขียนโปรแกรม PEP8 แนะนำไม่ให้ใช้ l (ตัวแอลพิมพ์เล็ก) ,O (ตัวโอพิมพ์ใหญ่), หรือ I (ตัวไอพิพม์ใหญ่) เป็นชื่อตัวแปรโดดๆ เพราะว่ามันจะทำให้เราสับสนกับ เลข 0 และ 1 (ถ้าต้องการใช้ตัวแอลให้ใช้ L (ตัวแอลพิพม์ใหญ่) แทน)

2 สไตล์หลักที่นิยมใช้ในการตั้งชื่อตัวแปร: CamelCase (คาเมลเคส) และ snake_case (สเนคเคส)

  • CamelCase (คาเมลเคส): เป็นการตั้งชื่อตัวแปรโดยเชื่อมคำทั้งหมดเข้าด้วยกัน ไม่มีช่องว่างหรือเครื่องหมายแบ่งคำ แยกแต่ละคำด้วยอักษรพิมพ์ใหญ่ตัวเดียว ทำให้รูปร่างของตัวแปรมีส่วนเว้าส่วนโค้งคล้ายๆ อูฐ เช่น iPhone, eBay, xValue, totalMin, totalHours, phoneNumber (เฉพาะคำแรกเป็นตัวอักษรตัวเล็กทั้งหมด เรียก Lower CamelCase) และ FirstName, LastName, JavaScript (ตัวอักษรตัวแรกของทุกคำเป็นตัวใหญ่ทั้งหมด (ตัวแรกด้วย) เรียก Upper CamelCase) ฯลฯ

  • Snake_case (สเนคเคส): เป็นการตั้งชื่อตัวแปรโดยใช้ตัวพิมพ์เล็กทั้งหมดแล้ว คั่นระหว่างคำขั้นด้วย Underscore "_" ทำให้รูปร่างของตัวแปรมีข่อต่อคล้ายๆ งู เช่น total_min, total_hours, phone_number, c_cpp ฯลฯ

อ่านรายละเอียดเพิ่มเติมเกี่ยวกับ CamelCase และ snake_case ได้ที่ Wiki: Camel case, Wiki: Snake case

Tip

สไตล์ในการตั้งชื่อ (Naming Styles)

— Variable

ตั้งชื่อตัวแปรเป็นตัวอักษรตัวเดียว คำศัพท์ 1 คำ โดยใช้ตัวเล็กทั้งหมด (ไม่ใช้ตัวอักษร l ,o) แต่ถ้ามีมากกว่าหนึ่งคำให้คั่นด้วย underscores คั่น (snake_case) ยกตัวอย่างเช่น x, y, i, j, var, my_variable, count

  • Function

ตั้งชื่อฟังก์ชันเป็นตัวอักษรตัวเล็กหมด แต่ถ้าอยากเพิ่มคำใช้ underscores คั่นระหว่างคำเพื่อให้อ่านง่าน (sname_case) ยกตัวอย่างเช่น function, my_function

— Class

ตั้งชื่อคลาสแบบสไตล์ Upper CamelCase โดยขึ้นต้นด้วยตัวใหญ่เสมอ ไม่ใช้ underscore เพื่อให้อ่านง่าย ยกตัวอย่างเช่น Model, MyClass, ReadFile

— Method

หลักในการตั้งชื่อเมธอดจะเหมือนกับฟังก์ชัน กล่าวคือ เป็นตัวอักษรตัวเล็กหมด ถ้าอยากเพิ่มคำให้ใช้สไตล์ snake_case ยกตัวอย่างเช่น method, class_method, read_file, save_file

— Constant

ค่าคงที่ ใช้ตัวใหญ่ทุกตัวอักษร แต่ถ้าอยากเพิ่มคำให้ใช้ underscores ขั้นระหว่างคำ ยกตัวอย่างเช่น CONSTANT, MY_CONSTANT

— Module

ตั้งชื่อโมดูลเป็นตัวอักษรตัวเล็กหมด แต่ถ้าอยากเพิ่มคำใช้ underscores ขั้นระหว่างคำเพื่อให้อ่านง่าย ยกตัวอย่างเช่น module.py, my_module.py

— Package

ตั้งชื่อ Package เป็นตัวอักษรตัวเล็กทั้งหมด และหลีกเลี่ยงการใช้ underscores (ใช้เป็นตัวอักษรตัวเล็กทั้งหมด) ยกตัวอย่างเช่น package, mypackage

ref: https://realpython.com/python-pep8/#naming-styles

เราสามารถแจงคำสงวนใน Python 3 ออกมาโดยใช้ไลบรารี keyword ของ Python 3 ได้ดังนี้

import keyword

print(keyword.kwlist)

['False', 'None', 'True', 'and', 'as', 'assert', 'async', 'await', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']

ดังนั้นเราจะใช้คำสงวนเหล่านี้ (รวมถึง and ในโค้ดก่อนหน้า) เป็นอย่างอื่นไม่ได้ ไม่ว่าจะใช้เป็นชื่อตัวแปร ชื่อฟังก์ชัน หรือชื่อคลาส ก็ไม่ได้

กรณีข้างต้น เป็นการบวกเวลาของอัลบัม 3 อัลบัม (ที่มีหน่วยเป็นนาที) แล้วเก็บค่าไว้ในตัวแปร total_min หลังจากนั้นหารด้วย 60 เปลี่ยนเป็นหน่วยชั่วโมงและเก็บค่าไว้ในตัวแปร total_hours (2 คำสั่ง)

เราสามารถเขียนให้อยู่ในบรรทัดเดียวได้โดยใช้วงเล็บ (คำสั่งเดียว) ดังนี้

total_hours = (43 + 42 + 57) / 60  # Total hours in a single expression
total_hours

2.3666666666666667

ได้ total_hours เป็นเลขจำนวนชั่วโมงที่เป็นจำนวนทศนิยม

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

total_hours = (43 + 42 + 57) // 60
total_hours

2

Augmented assignment statement#

\(\qquad\) นอกจากโอเปอเรเตอร์กำหนดค่า (Assignment operator) "=" ที่กล่าวแล้วยังมีโอเปอเรเตอร์กำหนดค่าอีกประเภทที่ประกอบด้วยเครื่องหมาย +, -, *, /, %, //, **, ฯลฯ รวมกับเครื่องหมาย = เป็น Augmented assignment operator (ตัวดำเนินการที่รวมระหว่างตัวดำเนินการทางคณิตศาสตร์และตัวดำเนินการกำหนดค่า) เช่น

+=, -=, *=, /=, %=, //=, **= เป็นต้น (ต้องเขียนติดกัน ห้ามมีช่องว่าง)

ยกตัวอย่างเช่น ตัวดำเนินการ += ในภาษาไพธอน เป็นการบวกค่าของสองค่า (ซ้ายและขวาของตัวดำเนินการ) เข้าด้วยกัน และนำผลผลลัพธ์ไปกำหนดค่าใหม่ให้กับตัวแปรฝั่งซ้ายของตัวดำเนินการ

เมื่อนำไปกำหนดค่าตัวแปร หรือนิพจน์ต่างๆ เราจะเรียกว่า “augmented assignment statement” เช่น คำสั่ง total_mins += 5 ในโค้ดต่อไปนี้

total_mins = 70  
total_mins += 5 # total_mins = total_mins + 5
total_mins

75

คำสั่ง total_mins += 5 เป็นการบวกค่าในตัวแปร total_mins กับ 5 แล้วนำผลลัพธ์ไปเก็บไว้ในตัวแปร total_mins มีค่าเหมือนกับ total_mins = total_mins + 5

total_mins = 70
total_mins *= 2
total_mins

140

เช่นเดียวกัน คำสั่งข้างต้นเป็นการคูณค่าในตัวแปร total_mins กับ 2 แล้วนำผลลัพธ์ไปเก็บไว้ในตัวแปร total_mins มีค่าเหมือนกับ total_mins = total_mins * 2

สรุป ตารางสรุปตัวดำเนินการกำหนดค่า (Assignment operator) ใน Python

โอเปอร์เรเตอร์

ตัวอย่าง

ความหมาย

=

a = b

a = b

+=

a += b

a = a + b

-=

a -= b

a = a - b

*

a *= b

a = a * b

/=

a /= b

a = a / b

%=

a %= b

a = a % b

//=

a //= b

a = a // b

**/=

a **= b

a = a ** b

&=

a &= b

a = a & b

|=

a |= b

a = a | b

^=

a ^= b

a = a ^ b

>>=

a >>= b

a = a >> b

<<=

a <<= b

a = a << b

Attention

Augmented assignment operator เป็นตัวดำเนินการที่รวมระหว่างตัวดำเนินการทางคณิตศาสตร์กับตัวดำเนินการกำหนดค่า = เข้าด้วยกัน เช่น + รวมกับ = เป็น += โดยเขียนติดกัน ห้ามมีช่องว่าง และห้ามสลับที่กัน!!!

 x = 10
 x += 5
 x

15

คำสั่ง x += 5 เป็นการบวกค่าในตัวแปร x กับ 5 แล้วนำผลลัพธ์ไปเก็บไว้ในตัวแปร x แต่คำสั่ง x =+ 5 …

x = 10
x =+ 5
x

5

เป็นการกำหนด +5 ให้กับตัวแปร x !!!

Note

PEP8 หลักเกณฑ์หรือสไตล์การเขียนโปรแกรม PEP8 แนะนำให้เว้นช่องว่างทั้งก่อนและหลังตัวดำเนินการ Assignment (=), Augmented assignment (+=, -= ฯลฯ), Comparisons (==, <, >, !=, <>, <=, >=, in, not in, is, is not), Booleans (and, or, not)

[Exercise] นิพจน์ (Expressions) & ตัวแปร (Variables)#

1. ค่า a จะมีค่าเท่าไหร่? ถ้า a = 4+100//3**2%10

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

2. ค่า b จะมีค่าเท่าไหร่? ถ้า

b = 22//3/2+2

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

3. รันต่อจากข้อก่อนหน้า ค่า b จะมีค่าเท่าไหร่? ถ้า b /= 2

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

Attention

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

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

  • ถ้าต้องการให้ชัวร์ ใส่วงเล็บ เช่น b = (22//3)/2+(2**(1**2))

4. ค่า x จะมีค่าเท่าไหร่? ถ้า x = 3 + 2 * 2

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

5. ค่า y จะมีค่าเท่าไหร่? ถ้า y = (3 + 2) * 2

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

6. ค่า z จะมีค่าเท่าไหร่? ถ้า z = x + y

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

7. ค่า x หลังรันโด้ตต่อไปนี้จะมีค่าเท่าไหร่?

x = 2 
x += 1 
x *= 2 

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

8. คำนวณค่า Body Mass Index หรือ BMI (ค่าความหนาของร่างกาย ใช้เป็นมาตรฐานในการประเมินภาวะอ้วนหรือผอมในผู้ใหญ่ตั้งแต่อายุ 20 ปีขึ้นไป) ซึ่งคำนวณได้จาก การใช้น้ำหนักตัว (w) เป็นกิโลกรัมและหารด้วยส่วนสูง (h) ที่วัดเป็นเมตรยกกำลังสอง

\[ BMI = \frac{w}{h^2} \]

จงหาค่า BMI ในกรณีของนาย รักดี ขยันเรียน ซึ่งสูง 177 cm มีน้ำหนัก 100 kg

รูปร่างสมส่วน ค่า BMI จะอยู่ระหว่าง 18.5~22.9 (ดูรายละเอียดได้ที่ลิงค์ ร.พ. บางปะกอก - วีธีคำนวณ ดัชนีมวลกาย (BMI))

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

การใช้ฟังก์ชัน print( ) แสดงผลของตัวแปร (นิพจน์)#

\(\qquad\) เราสามารถใช้ฟังก์ชัน print( ) แสดงผลของตัวแปรได้หลากหลายวิธี เช่น

วิธีที่ 1 แปลงเป็นสตริง (Typecasting)

วิธีนี้เป็นการแปลงตัวแปรที่เป็นตัวเลขให้เป็นสตริง แล้วเชื่อมแต่ละสตริงด้วยเครื่องหมาย "+"

การแปลงเป็นสตริงสามารถทำได้หลายวิธี เช่น ใช้ฟังก์ชัน str() ดังตัวอย่างต่อไปนี้

total_mins = 43 + 42 + 57 # 142 minutes
total_hours = total_mins / 60 # 2.3666666666666667 hours
 
print('Total hours: ' + str(total_hours) + ' (' + str(total_mins) + ' min)')

Total hours: 2.3666666666666667 (142 min)

ตัวอย่างข้างต้นนี้มีสตริงทั้งหมด 5 สตริง คือ "Total hours: ", str(total_hours), " (", str(total_min) และ "min)" เชื่อมต่อเข้าด้วยกันด้วยเครื่องหมาย "+"

หรือจะแปลงเป็นสตริงด้วยโอเปอร์เรเตอร์ % (%-formatting เป็นรูปแบบการเขียนในยุคแรกๆ ของไพธอน) โดยใช้ %s แทนในข้อความ (s ณ ที่นี้ หมายถึงสตริง (String)) เพื่อบอกไพธอนว่าจะแทนค่าของตัวแปรไว้ตรงไหน) และตามด้วยตัวแปรที่ต้องการนำไปแทนค่า ดังตัวอย่างต่อไปนี้

print('Total hours: %s' %total_hours)

Total hours: 2.3666666666666667

ในกรณีที่มีตัวแปรมากกว่าหนึ่งตัว ก็สามารถเขียนแบบนี้ได้ โดยใช้วงเล็บ (เป็นข้อมูลชนิด Tuple รายละเอียดจะอธิบายภายหลัง)

print('Total hours: %s (%s min)' %(total_hours, total_mins))

Total hours: 2.3666666666666667 (142 min)

ข้อเสียของวิธีนี้คือ อ่านยาก โดยเฉพาะเมื่อมีการแทนค่าหลายจำนวน (ต้องใช้ %s ทั้งหมด) และไม่สามารถแทนค่าด้วยค่าเดิมซ้ำๆ ได้

วิธีที่ 2 ส่งผ่านค่า (อาร์กิวเมนต์) ไปยังพารามิเตอร์ของฟังก์ชัน

วิธีนี้เป็นการส่งทั้งสตริงและตัวแปรต่างๆ ผ่านอาร์กิวเมนต์ให้ฟังก์ชันตามลำดับโดยคั่นด้วยเครื่องหมาย ,

# ส่งผ่านค่าไปยังพารามิเตอร์ของฟังก์ชัน
print("Total hours:", total_hours, "(", total_mins, "min)")

Total hours: 2.3666666666666667 ( 142 min)

ตัวอย่างข้างต้นเป็นการส่ง 5 อาร์กิวเมนต์ไปยังฟังก์ชัน print() โดยมี “Total hours:”, “(”, และ “min)” เป็นข้อมูลสตริง ส่วน total_hours และ total_min เป็นตัวแปร)

การแสดงผลในกรณีนี้ จะเรียงจามลำดับตามลำดับของอาร์กิวเมนต์ที่ส่งไปยังฟังก์ชัน และจะคั่นแต่ละอาร์กิวเมนต์ด้วย ช่องว่าง (space) 1 ช่องเสมอ (โดยดีฟอลต์ (Default)) ถ้าหากไม่ต้องการให้มีช่องว่างคั่นหรือต้องการคั่นเป็นตัวอักษรอื่น ก็สามารถทำได้โดยกำหนดที่พารามิเตอร์ sep ดังตัวอย่าง

# Just pass the values as parameters
print("Total hours:", total_hours, "(", total_min, "min)", sep='')

Total hours:2.3666666666666667(142min)

ข้างต้นเป็นการกำหนดพารามิเตอร์ sep ให้เป็น “” หรืออักขระว่าง (Empty string, null string, empty word) ซึ่งจะทำให้แสดงผลแต่ละอาร์กิวเมนต์ ติดกันโดยไม่มีช่องว่างคั่น

วิธีที่ 3 ใช้เมธอด str.format( )

วิธีนี้เป็นการจัดสตริงรูปแบบใหม่โดยใช้เมธอด format() สามารถใช้กับตัวแปรที่เป็นตัวเลขหรือตัวอักษรก็ได้ โดยใช้วงเล็บปีกกา {} ระบุตำแหน่งของตัวแปร

# ใช้เมธอดสตริง str.format()
print("Total hours: {} ({} min)".format(total_hours, total_mins))

Total hours: 2.3666666666666667 (142 min)

วิธีนี้สามารถใช้ร่วมกับตัวเลขดัชนี (Index) ทำให้เราสามารถระบุลำดับของตัวแปรที่จะนำไปแทนค่าได้

# ความสามารถพิเศษของวิธีนี้
# สามารถใช้ร่วมกับเลขดัชนี (Index) ได้
# (ทำให้สะดวกต่อการจัดเรียงลำดับใหม่หรือการพิมพ์ซ้ำหลายครั้ง)

print("Total hours: {0} ({1} min)".format(total_hours, total_mins))
print("Total min: {1} ({0} hrs)".format(total_hours, total_mins))

Total hours: 2.3666666666666667 (142 min)
Total min: 142 (2.3666666666666667 hrs)

หรือจะทำข้อมูลเป็น Dictionary เพื่อให้เรียก Key ชื่อนั้นๆ ได้เลย เช่น

print("Total hours: {x} ({y} min)".format(x=total_hours, y=total_min))

Total hours: 2.3666666666666667 (142 min)

(รายละเอียดของข้อมูลชนิด Dictionary จะอธิบายภายหลัง ณ ตอนนี้ จำรูปแบบการใช้งานไปก่อน)

นอกจาก วิธีนี้จะสามารถจัดเรียงลำดับใหม่ได้โดยใช้เลขดัชนี้แล้ว ยังสามารถแทนค่าด้วยค่าเดิมซ้ำๆ ได้อีกด้วย

print("Total hours: {x} ({y} min) ({x} h = {y} min)".format(x=total_hours, y=total_mins))

Total hours: 2.3666666666666667 (142 min) (2.3666666666666667 h = 142 min)

วิธีที่ 4 เขียนในรูปแบบ f-string (f: formated)

ไพธอนตั้งแต่เวอร์ชัน 3.6 เป็นต้นไป จะสามารถใช้วิธี “f-strings” หรือ “formated string literals” ได้ ซึ่งทำให้การเพิ่มตัวแปรให้กับสตริงทำได้ง่ายขึ้นอย่างมาก

รูปแบบ f-string จะต้องเติมคำนำหน้าสตริงด้วยอักขระ f หรือ F ก่อนเครื่องหมายคำพูด เช่น f’สายอักขระ’, F”สายอักขระอีกสาย”

# ใช้รูปแบบ f-string ใน Python 3.6 ขึ้นไป
print(f"Total hours: {total_hours} ({total_mins} min)")

Total hours: 2.3666666666666667 (142 min)

หากมีการระบุ “=” ไว้ที่จุดสิ้นสุดของนิพจน์ (expression) ที่เป็น f-string ไพธอนจะประเมินนิพจน์เป็นข้อความ (ตัวอักษร) ตามด้วยเครื่องหมาย ‘=’ และตามด้วยค่าของนิพจน์ ฉะนั้นคำสั่งข้างต้น สามารถเขียนใหม่ได้ดังนี้

# หรือจะเขียน f-string ในรูปแบบ  f'{expr=}' แบบนี้ก็ได้
print(f'{total_hours=} ({total_mins=})')

total_hours=2.3666666666666667 (total_mins=142)

Note

การเขียน f-string ในรูปแบบ f'{expr=}' มักถูกใช้ในการตรวจสอบข้อผิดผลาดของโปรแกรม (debugging) เช่น

x = 5 print(f'{x * 9 + 15 = }')

[Output] x * 9 + 15 = 60

วิธีที่ 4 เป็นวิธีเขียนที่เขียนง่าย อ่านง่าย และประมวลผลได้เร็วกว่าการเขียนวิธีอื่นๆ (ชื่อเรียก f-string f ย่อมาจาก “fast” และ “formated string literals” อ่านรายละเอียดเพิ่มเติมได้ที่ลิงค์ The Python Tutorial)

[Exercise] print() Function#

1. จงเขียนโค้ดกำหนดตัวแปร 3 ตัวแปร เก็บข้อมูลชื่อ-นามสกุล ส่วนสูงและน้ำหนัก คำนวณค่า BMI จากส่วนสูงและน้ำหนัก แล้วแสดงผลออกหน้าจอตามตัวอย่างต่อไปนี้

นายรักดี ขยันเรียน น้ำหนัก (w) 100 kg ส่วนสูง (h) 177 cm ค่า BMI ที่ได้ 31.91930798940279

1.1) แสดงผลโดยใช้ฟังก์ชัน print() วิธีที่ 1 แปลงเป็นสตริง (Typecasting)

1.2) แสดงผลโดยใช้ฟังก์ชัน print() วิธีที่ 2 ส่งผ่านค่า (อาร์กิวเมนต์) ไปยังพารามิเตอร์ของฟังก์ชัน

1.3) แสดงผลโดยใช้ฟังก์ชัน print() วิธีที่ 3 ใช้เมธอด str.format( )

1.4) แสดงผลโดยใช้ฟังก์ชัน print() วิธีที่ 4 เขียนในรูปแบบ f-string (f: formated)

ฟังก์ชันในภาษาไพธอนเบื้องต้น#

\(\qquad\) การคำนวณ BMI ในแบบฝึกหัดก่อนหน้านี้ เราต้องคีย์นิพจน์ BMI ทุกครั้งที่มีการเปลี่ยนค่าของตัวแปร ซึ่งเป็นเรื่องที่น่าเบื่อ \(\ddot\frown\)

เราลองมาสร้างฟังก์ชัน bmi ที่คำนวณค่า BMI ด้วยส่วนสูงและน้ำหนักตัวกัน การใช้ฟังก์ชันมีประโยชน์เนื่องจากช่วยให้เราไม่ต้องพิมพ์นิพจน์ BMI ซ้ำๆ

def bmi(height, weight):
    return weight / (height/100.0) ** 2
bmi(177, 100.0)

31.91930798940279

การประกาศฟังก์ชันในภาษาไพธอนมีรูปแบบง่ายๆ ดังนี้

Function syntax:

def <function_name>([<parameters>]):
   <statement-1>
       .
   <statement-N>
   return <statement>

โดยใช้คำสั่ง def ต่อด้วยชื่อของฟังก์ชัน และกำหนดพารามิเตอร์ภายในวงเล็บ () พารามิเตอร์คือ ตัวแปรที่ไว้รับค่าของฟังก์ชัน (มีชื่อเรียกอีกอย่างคือ อาร์กิวเมนต์)

def <function_name>([<parameters>]):

หลังเครื่องหมาย colon (:) จะเป็นบล็อกคำสั่งของฟังก์ชัน

return <statement>

คำสั่ง return เป็นการออกจากฟังก์ชัน โดยจะส่งค่ากลับไปยังจุดที่เรียก

(รายละเอียดของฟังก์ชันจะมีกล่าวในภายหลัง)

bmi(180.0,84.0)

25.925925925925924

1.1*bmi(180.0,84.0)

28.51851851851852

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

1

ออบเจกต์ (Object) ในที่นี้ไม่ได้หมายถึง Instance ของ class ในภาษา OOP เท่านั้น แต่ยังหมายถึงตัวแปรทุกชนิด(ซึ่งโดยปกติในภาษา OOP จะมองว่าเป็น Object ทั้งหมด)