คีย์เวิร์ด(Keywords)
คีย์เวิร์ด(keywords) หรือ คำสงวนนั้นเป็นคำที่ถูกจำกัดไว้เพื่อใช้งานเฉพาะเจาะจงสำหรับภาษานั้น เราสามารถใช้คีย์เวิร์ดในการประกาศตัวแปร, ฟังก์ชัน, หรือ identifier ใดๆ
ในภาษา python นั้นการตั้งชื่อตัวพิมพ์เล็กหรือพิมพ์ใหญ่จะมีผลที่แตกต่างกัน โดยในเวอร์ชัน 3.3 จะมีคีย์เวิร์ดทั้งหมด 33 ตัว โดยส่วนใหญ่แล้วจะถูกเขียนด้วยตัวอักษรพิมพ์เล็ก ยกเว้นแต่คีย์เวิร์ด True, False, None ที่ตัวอักษรขึ้นต้นเป็นพิมพ์ใหญ่
คีย์เวิร์ดต่างๆ มีดังนี้
| False | class | finally | is | return |
| None | continue | for | lambda | try |
| True | def | from | nonlocal | while |
| and | del | global | not | with |
| as | elif | if | or | yield |
| assert | else | import | pass | |
| break | except | in | raise |
คีย์เวิร์ด True และ False
บอกค่าความเป็นจริงเป็นเท็จ ตัวอย่างเช่น
a = 3+3 b = 2+4 a == b #(ผลคือ True)
คีย์เวิรด์ None
ค่าคงที่ซึ่งจะบ่งชี้ว่าไม่มีค่าใดๆ อยู่ หรือเป็นค่า null ควรระวังไว้ว่า ค่า None ไม่ได้หมายถึง False , 0, ลิสต์เปล่า (empty list) , ดิกชันนารีเปล่า( empty dictionary ) หรือ empty string ตัวอย่างเช่น
a = None #ระบุด้วยคีย์เวิร์ด None ซึ่งหมายถึงการไม่ระบุค่าใดๆ b = None # ระบุด้วยคีย์เวิร์ด None ซึ่งหมายถึงการไม่ระบุค่าใดๆ c = False # ระบุด้วยคีย์เวิร์ด False a == b # ผลคือ True a == c # ผลคือ False
สำหรับฟังก์ชันที่ไม่มีการคืนค่า( void function ) โปรแกรมจะทำการคืนค่า None โดยอัตโนมัติ อีกทั้งหากทำงานในฟังก์ชันใด แล้วไม่เจอ return statement ประกาศไว้ ก็จะคืนค่า None กลับไปอัตโนมัติ เช่นกัน
def calculate_circle_area(radius):
area = 3.14 * radius * radius
return area
def calculate_circle_circumference(radius):
circumference = 2 * 3.14 * radius
circle_area = calculate_circle_area(10) # เรียกฟังก์ชันซึ่งมีการคืนค่าของข้อมูล
print( circle_area )
# ผลก็คือมีการปรินท์ค่า 314
circle_circumference = calculate_circle_circumference(10) # เรียกฟังก์ชันซึ่งไม่มีการคืนค่าของข้อมูล
print( circle_circumference )
# ผลก็คือมีการปรินท์ค่า None เพราะได้ลืมประกาศการ return ค่ากลับมา โปรแกรมจึงคืนค่า None ให้อัตโนมัติ
คีย์เวิร์ด and, or, not
คือตัวดำเนินการเชิงตรรกะ ไว้เปรียบเทียบความเป็นจริงเท็จของข้อมูล
การใช้ and เปรียบเทียบ ผลจะเป็นจริงก็ต่อเมื่อ ตัวเปรียบเทียบทั้งสองตัวเป็นจริง
Truth table สำหรับ and
| A | B | A and B |
| จริง(True) | จริง(True) | จริง(True) |
| จริง(True) | เท็จ(False) | เท็จ(False) |
| เท็จ(False) | จริง(True) | เท็จ(False) |
| เท็จ(False) | เท็จ(False) | เท็จ(False) |
score = 82
if (score >= 80) and (score <= 100) :
print( "Grade A" )
# ผลก็คือปรินท์ Grade A เพราะคะแนน 82 อยู่ในช่วงระหว่าง 80 - 100
# เงื่อนไขแรก คือ เปรียบเทียบว่า score >= 80 หรือไม่
# เงื่อนไขที่สอง คือ เปรียบเทียบว่า score <= 100 หรือไม่
# นักเรียนคนนี้จะได้เกรด A ก็ต่อเมื่อช่วงคะแนนที่ได้อยู่ระหว่าง 80 - 10
การใช้ or เปรียบเทียบ ผลจะเป็นจริงก็ต่อเมื่อ พจน์ใดพจน์หนึ่งเป็นจริง
Truth table สำหรับ or
| A | B | A or B |
| จริง(True) | จริง(True) | จริง(True) |
| จริง(True) | เท็จ(False) | จริง(True) |
| เท็จ(False) | จริง(True) | จริง(True) |
| เท็จ(False) | เท็จ(False) | จริง(True) |
exam_score = 70
paper_work = 90
if (exam_score > 80) or (paper_work > 80) :
print( "Pass" )
# ผลก็คือปรินท์ว่า Pass แม้นว่า คะแนนสอบจะน้อยกว่า 80 แต่มีคะแนนงานมากกว่า 80 ก็ถือว่าผ่านแล้ว
# เงื่อนไขแรก คือ เปรียบเทียบว่า exam_score > 80 หรือไม่
# เงื่อนไขที่สอง คือ เปรียบเทียบว่า paper_work > 80 หรือไม่
# นักเรียนจะผ่านการสอบนี้ก็ต่อเมื่อ มีคะแนนสอบมากกว่า 80 หรือ มีคะแนนงานมากกว่า 80
not ใช้สำหรับสลับค่าความเป็นจริง หรือ เท็จ
Truth table สำหรับ or
| A | not A |
| จริง( True) | เท็จ(False) |
| เท็จ(False) | จริง(True) |
apply_student = 10
if not (apply_student < 40):
print( "course open" )
# ผลก็คือไม่มีการปรินท์ค่าใดๆ
# คอร์สนี้จะเปิดก็ต่อเมื่อ มีนักเรียนสมัครเข้าเรียนไม่น้อยกว่า 40 คน
คีย์เวิร์ด as
ใช้เป็นตัว alias เมื่อทำการ import module ย่อยๆ และเพื่อที่จะตั้งชื่อ module นั้นๆ เป็นชื่ออื่นที่สะดวกแก่การเรียกใช้ภายในโปรแกรม
import numpy as np # ทำการ import modules ชื่อ numpy แต่ภายในโปรแกรมเราจะเรียกอย่างย่อว่า np student_scores = [85, 70, 90, 69] # กำหนด array ของคะแนนของนักเรียน maximum_score = np.max(student_scores) # ใช้ฟังก์ชัน max ของ library numpy เพื่อหาค่าคะแนนที่มากที่สุดจากอาเรย์ที่กำหนด print( maximum_score ) # จะทำการปรินท์ค่า 90 ออกมา
คีย์เวิร์ด assert
โดยส่วนใหญ่จะใช้เพื่อทำการ debug โปรแกรม เพราะบางครั้งเราต้องการตรวจสอบเงื่อนไขบางอย่างที่ไม่ต้องการให้เกิดในโปรแกรม หากเกิดเงื่อนไขดังกล่าวควรแจ้งให้เราทราบระหว่างทำการทดสอบ
วิธีการใช้ เราจะใช้ assert แล้วตามด้วยเงื่อนไขที่เราต้องการตรวจสอบ
score = 120 assert score <= 100 # ผลก็คือโปรแกรมจะคืนค่า AssertionError ออกมา # เราทำการตรวจสอบค่า score ด้วยการใช้ assert เพราะต้องการให้ score ในโปรแกรมเรานั้นมีค่าน้อยกว่า 100 เท่านั้น
คีย์เวิร์ด break, continue
เราจะใช้คีย์เวิร์ดนี้ภายใน for และ while ลูป เพื่อต้องการจะเปลี่ยนแปลงเงื่อนไขปกติในการวนลูป
break ใช้เพื่อทำการหยุดการดำเนินการของลูปที่อยู่ในกลุ่มคำสั่งเดียวกันลง แล้วข้ามไปทำ คำสั่งต่อไปที่ถัดจากลูปนั้นๆ
for i in range(1, 10):
if i==3:
break
print( i )
# ผลก็คือจะปรินท์ค่า 1, 2
continue ใช้ทำการหยุดเฉพาะลูปของรอบที่ทำอยู่ แล้วข้ามไปยังรอบต่อไปของลูปดังกล่าว
for i in range(1, 10):
if i==3:
continue
print( i )
# ผลก็คือจะปรินท์ค่า 1, 2, 4, 5, 6, 7, 8, 9 ยกว้น 3
คีย์เวิร์ด class
ใช้เพื่อประกาศคลาสใหม่ที่สร้างขึ้น โดยการสร้างคลาสนั้นก็เหมือนเรานิยามวัตถุที่สามารถเทียบเคียงได้ในโลกจริงให้เป็นวัตถุหรือคลาสหนึ่งในโปรแกรม ซึ่งเป็นการใช้ concept ของ OOP(object-oriented programming) จะใช้ในการอธิบายถึง คุณลักษณะ(attribute) และ พฤติกรรม(methods) ของวัตถุนั้นๆ
class Course:
lecturer = "Lecturer name"
description = "Course description here"
def calculate_average_score():
...
จากตัวอย่างข้างต้น เราทำการประกาศคลาสชื่อว่า Course ซึ่ง คลาสนี้มีคุณลักษณะ(attribute)สองอย่างคือ มีชื่อผู้สอน(lecturer) และ รายละเอียดของคอร์ส(description) และจะมีพฤติกรรม(method)ที่ทำได้ คือทำการคำนวณคะแนนเฉลี่ยของคะแนนที่นักเรียนสอบได้ในคลาส
คีย์เวิร์ด def
ใช้สำหรับการประกาศฟังก์ชัน โดยฟังก์ชันก็คือกลุ่มของคำสั่งที่กระทำการเกี่ยวเนื่องกัน ทำต่อเนื่องกันเพื่อต้องการให้ได้ผลลัพท์ดังที่ออกแบบไว้ ซึ่งการรวมคำสั่งเข้าด้วยการเป็นฟังก์ชันจะทำให้สามารถจัดการโค้ดได้ง่ายและสามารถจะเรียกใช้ชุดคำสั่งดังกล่าวใหม่ได้โดยไม่ต้องเขียนซ้ำ
# ฟังก์ชันสำหรับคำนวณค่าเฉลี่ยของคะแนนของนักเรียน
def calculate_average_score(student_scores):
total = 0
for score in student_scores:
total += score
average_score = total/len(student_scores)
return average_score
student_scores = [10, 15, 12, 13]
print( calculate_average_score(student_scores) )
คีย์เวิร์ด del
ใช้สำหรับลบการอ้างอิงถึงวัตถุ(object)ใดๆ
student_name = "David" print( student_name ) # ผลก็คือจะปรินท์ชื่อนักเรียนว่า David del student_name print( student_name ) # ผลก็คือโปรแกรมจะ Error เพราะว่าเราได้ลบการอ้างอิงถึงตัวแปรนั้นไปแล้ว
คีย์เวิร์ด if, else, elif
จะใช้เพื่อสร้างเงื่อนไขของการเรียกใช้แต่ละชุดคำสั่ง
- ใช้ if เพื่อให้ทำคำสั่งภายในบล็อกดังกล่าวหากเงื่อนไขเป็นจริง
- ใช้ elif เพื่อทำคำสั่งในบล็อกหากเงื่อนไขที่กำหนดไว้เป็นจริง และไม่ได้อยู่เป็นบล็อกแรก
- ใช้ else เมื่อไม่เข้าเงื่อนไขใดๆ ใน if หรือ elif แล้ว ก็จะเข้ามาทำคำสั่งในบล็อกนี้
score = 70
if score < 60 :
print( "Grade D" )
elif score < 70 :
print( "Grade C" )
elif score < 80 :
print( "Grade B" )
else :
print( "Grade A" )
# ผลที่ได้คือโปรแกรมจะปรินท์ค่า Grade B
คีย์เวิร์ด except, raise, try
ใช้สำหรับการดักจับข้อผิดพลาดที่เกิดขึ้นเพื่อสามารถระบุเงื่อนไขได้ว่าจะจัดการกับข้อผิดพลาดแต่ละแบบได้อย่างไร แทนที่จะให้โปรแกรมหยุดการทำงานไปเฉยๆ โดยไม่ทราบสาเหตุ ตัวอย่างข้อผิดพลาดที่เกิดขึ้นมีดังนี้ IOError, ValueError, ZeroDivisionError, ImportError, NameError, TypeError, etc.
เราใช้ try…except เพื่อที่จะดักจับข้อผิดพลาดที่เกิดขึ้น และเราสามารถระบุว่าหากเกิดข้อผิดพลาดขึ้นเราต้องการจะให้โปรแกรมทำงานอย่างไร
def calculate_pass_percent(total_students, pass_students):
try :
pass_percent = pass_students/total_students * 100
except:
print( "Exception occur" )
return
return pass_percent
# เราใช้ try, except เพื่อที่จะตรวจสอบหากเกิดข้อผิดพลาดขึ้นเพราะในกรณีนี้ เพราะหากจำนวนนักเรียนที่ส่งเข้ามามีค่าเป็น 0 จะทำให้เกิดข้อผิดพลาดในการคำนวณได้
คีย์เวิร์ด finally
จะใช้ร่วมกับ try…except เพื่อที่จะให้แน่ใจว่า แม้ว่าจะมีข้อผิดพลาดเกิดขึ้น แต่กลุ่มของคำสั่งที่ระบุไว้ใน finally ก็จะถูกเรียกใช้แน่นอน ตัวอย่างการใช้ เช่นในกรณีต้องการ ปรับแต่งข้อมูล, บันทึกข้อมูล, ปิดไฟล์ทีได้เปิดไว้
f = open('score.txt', 'r') # เปิดไฟล์ชื่อ 'score.txt'
try:
score_str = f.read() # ทำการอ่านข้อมูลจากไฟล์ที่เปิดไว้
scores = score_str.split(',')
except:
print("Cannot read data in file")
finally:
f.close()
คีย์เวิร์ด for
ใช้สำหรับการวนลูป โดยทั่วไปมักจะใช้ for เมื่อเรารู้จำนวนรอบในการวนลูปที่แน่นอน
student_names = ["David", "Peter", "Mary", "Adam", "Paul", "Alex"]
for name in student_names:
print("name: "+name)
# ผลที่ได้คือมีการปรินท์ค่า
# name: David
# name: Peter
# name: Mary
# name: Adam
# name: Paul
# name: Alex
คีย์เวิร์ด from, import
import จะใช้สำหรับการ import modules ที่ต้องการใช้เข้ามายัง namespace ที่ใช้อยู่
import numpy as np scores = [90, 75, 80, 69] score_avg = np.average(scores) # เรียกใช้ฟังก์ชัน average จาก numpy ในการหาค่าเฉลี่ย print( score_avg ) # ผลที่ได้คือทำการพิมพ์ 78.5 ออกมาซึ่งเป็นค่าคะแนนเฉลี่ย # มีการเรียกใช้ modules numpy ซึ่งสามารถเรียกใช้ฟังก์ชันทั้งหมดของ modules นี้และทำการ alias ให้ชื่อกระทัดรัดขึ้นโดยใช้ชื่อว่า np # จากนั้นทำการเข้าถึงฟังก์ชัน average จาก modules numpy โดยการเรียก np.average(parameters)
from…import
ใช้เพื่อทำการ import attribute/function ทีเฉพาะเจาะจงลงไป เข้ามาใช้ใน namespace ที่ใช้อยู่ แทนที่จะ import ทั้งหมดเข้ามา
from numpy import average scores = [90, 75, 80, 69] score_avg = average(scores) # เรียกใช้ฟังก์ชัน average จาก library numpy ในการหาค่าเฉลี่ย โดยไม่ต้องระบุถึงชื่อ module อีกเพราะเราได้อ้างถึงด้วย from...import ในบรรทัดด้านบนแล้ว print( score_avg ) # ผลที่ได้คือทำการพิมพ์ 78.5 ออกมาซึ่งเป็นค่าคะแนนเฉลี่ย # มีการเรียกใช้ modules numpy แต่ทำการระบุว่าจะนำเข้ามาแค่ฟังก์ชันเดียวคือ ฟังก์ชัน average # จากนั้นจึงสามารถเข้าถึงฟังก์ชัน average ได้เลยโดยไม่จำเป็นต้องอ้างถึงชื่อ modules อีก
คีย์เวิร์ด global
ใช้สำหรับประกาศว่า ตัวแปรภายในฟังก์ชันที่ต้องการ อนุญาติให้เข้าถึงได้จากภายนอกฟังก์ชันด้วย หากเราต้องการเพียงแค่อ่านค่าจากตัวแปรที่เป็น global จากภายในฟังก์ชัน เราไม่จำเป็นต้องประกาศ global ด้านหน้าตัวแปร แต่หากเราต้องการปรับเปลี่ยนค่าตัวแปรที่เป็น global ภายในฟังก์ชันนั้นเราจำเป็นต้องประกาศ global หน้าตัวแปร ไม่เช่นนั้นแล้ว จะทำให้โปรแกรมสร้างตัวแปรที่เป็น local ขึ้นมาใช้แทน
globvar = 10
def read1():
print(globvar)
def write1():
global globvar
globvar = 5
def write2():
globvar = 15
read1()
write1()
read1()
write2()
read1()
# ผลก็คือโปรแกรมจะปรินท์ค่า
# 10
# 5
# 5
# เรียก read1() ครั้งแรก จะทำการปรินท์ค่าซึ่งประกาศไว้แล้ว คือ 10
# เรียก read1() ครั้งที่สอง เรียกใช้หลังการเรียกฟังก์ชัน write1() ซึ่งทำการแก้ไขค่า globar variable ชื่อ globvar ให้มีค่าเป็น 5 จึงทำการปรินท์ค่า 5 ออกมา
# เรียก read1() ครั้งที่สาม เรียกใช้หลังการเรียกฟังก์ชัน write2() ซึ่งทำการแก้ไขตัวแปรชื่อ globvar เช่นกันแต่เป็น local variable เพราะไม่มี keyword global นำหน้า เมื่อทำการปรินท์ค่าออกมา globvar จึงปรินท์ค่าเดิมคือ 5 ออกมา
คีย์เวิร์ด in
ใช้สำหรับทดสอบว่า ค่าใดๆ อยู่ในกลุ่มข้อมูลประเภท list, tuple, string, etc หรือไม่ โดยจะคืนค่าจริง หากค่านั้นๆ มีอยู่ในกลุ่มของข้อมูล
pass_students = ["Peter", "David", "Alex"] is_peter_pass = "Peter" in pass_students print ( is_peter_pass ) # ผลก็คือโปรแกรมจะปรินท์ค่า True ออกมา เนื่องจากรายชื่อ Peter อยู่ในรายชื่อของนักเรียนที่สอบผ่าน
การใช้ in อีกแบบคือใช้สำหรับ for ลูป ซึ่งใช้ในการเข้าถึงข้อมูลเป็นลำดับ
pass_students = ["Peter", "David", "Alex"]
for name in pass_students:
print( name )
# ผลก็คือโปรแกรมจะปรินท์ค่า
# Peter
# David
# Alex
คีย์เวิร์ด is
ใช้สำหรับทดสอบความเหมือนกันของ 2 วัตถุ(object)ใดๆ ว่าคือตัวเดียวกันหรือไม่
โดยปกติแล้วตัวดำเนินการ == นั้นใช้สำหรับทดสอบว่าตัวแปรสองตัวเท่ากันหรือไม่ แต่เราจะใช้ is ก็ต่อเมื่อต้องการทดสอบว่าตัวแปรสองตัวอ้างอิงถึงวัตถุ( object )ตัวเดียวกันหรือไม่ ซึ่งก็คือชี้ไปที่หน่วยความจำตำแหน่งเดียวกันหรือไม่ ถ้าอ้างถึงตัวเดียวกันจะคืนค่าจริง
สำหรับ True, False และ None นั้น ไม่ว่าภายในโปรแกรมการจะอ้างถึงค่าดังกล่าวจากที่ใด ก็จะอ้างถึงวัตถุ(object)ตัวเดียวกัน ตัวอย่างเช่น ไม่ว่ากำหนดค่า None ให้ตัวแปรใดๆ ทุกตัวจะชี้ไปที่หน่วยความจำตำแหน่งเดียวกัน
a = True is True print( a ) # ปรินท์ค่า True ออกมา b = False is False print( b ) # ปรินท์ค่า True ออกมา c = None is None print( c ) # ปรินท์ค่า True ออกมา d = None e = None f = d is e print( f ) # ปรินท์ค่า True ออกมา
สำหรับ list เปล่า หรือ dictionary เปล่า หากนำมาเปรียบเทียบจะมีค่าเท่ากัน แต่จะชี้ไปที่ memory คนละตำแหน่งกันเสมอ นั่นเป็นเพราะว่าทั้ง list และ dictionary นั้นเป็น mutable คือสามารถเปลี่ยนค่าใดๆ ได้ ดังนั้นตัวแปรแต่ละตัวจึงชี้ไปที่หน่วยความจำคนละตำแหน่ง เพื่อเวลาจะแก้ไขในอนาคตจะไม่มีผลต่อกัน
print([] == [])
# ปรินท์ค่า True ออกมา
print([] is [])
# ปรินท์ค่า False ออกมา
print({} == {})
# ปรินท์ค่า True ออกมา
print({} is {})
# ปรินท์ค่า False ออกมา
สำหรับ string และ tuple ซึ่งเป็นตัวแปรที่แก้ไขค่าไม่ได้หากได้มีการกำหนดค่าแล้ว(immutable) ดังนั้น string หรือ tuple ที่มีค่าเท่ากัน จะอ้างอิงถึงหน่วยความจำที่ตำแหน่งเดียวกัน
print ('' == '')
# ปรินท์ค่า True ออกมา
print ('' is '')
# ปรินท์ค่า True ออกมา
print (() == ())
# ปรินท์ค่า True ออกมา
print (() is ())
# ปรินท์ค่า True ออกมา
คีย์เวิร์ด lambda
ใช้สำหรับสร้างฟังก์ชันใดๆ โดยไม่ระบุชื่อของฟังก์ชัน โดยจะเป็น ฟังก์ชันภายในบรรทัดเดียว(inline) และไม่ต้องระบุส่วนของการ return สำหรับฟังก์ชันไว้โดยฟังก์ชันนี้ จะประกอบด้วย expression คือส่วนของการคำนวณค่า และทำการคืนค่าที่คำนวณ ที่ตำแหน่งนั้นเลย โดยไม่ต้องทำการคืนค่าให้ฟังก์ชันด้วยคำสั่ง return และสามารถเขียนฟังก์ชันได้ภายในบรรทัดเดียว
calculate_score = lambda score: score*2
for i in [15, 20, 10, 30]:
print( calculate_score(i) )
# โปรแกรมจะทำการเพิ่มคะแนนสอบที่ป้อนเข้ามาขึ้นเป็นสองเท่า โดยผลลัพท์ที่ได้จะปรินท์ค่า
# 30
# 40
# 20
# 60
คีย์เวิร์ด nonlocal
คล้ายกับคีย์เวิร์ด global โดยใช้สำหรับประกาศตัวแปรของฟังก์ชันภายในฟังก์ชัน(nested function) ที่ไม่ต้องการจำกัดค่าการเปลี่ยนแปลงให้อยู่ภายในขอบเขตนั้นเท่านั้น หมายความว่า ค่านี้การเปลี่ยนแปลงภายในนี้จะเข้าถึงได้จากภายนอกด้วย ถ้าเราต้องการที่จะทำการเปลี่ยนแปลงค่าของ ตัวแปรที่เป็น non-local ภายใน nested function เราจะต้องประกาศด้วยคีย์เวิร์ด nonlocal กำกับ ไม่เช่นนั้น โปรแกรมจะทำการสร้าง local variable ขึ้นมาด้วยชื่อเดียวกันภายใน nested function ขึ้นมาแทน
def outer_function():
a = 5
def inner_function():
nonlocal a
a = 10
print("Inner function: ",a)
inner_function()
print("Outer function: ",a)
outer_function()
#โปรแกรมจะทำการปรินท์ค่า
# Inner function: 10
# Outer function: 10
จากตัวอย่างข้างต้น ตัวแปร a ซึ่งเป็น ตัวแปรที่เป็น global ถูกประกาศอยู่ภายในฟังก์ชัน outer_function ดังนั้นหากเราต้องการที่จะ เปลี่ยนแปลงค่า a ภายใน inner_function จึงจำเป็นต้องใช้คีย์เวิร์ด nonlocal กำกับตัวแปร a จากนั้นจึงทำการเปลี่ยนแปลงค่า a ซึ่งเมื่อค่า a ถูกเรียกใช้ภายนอกฟังก์ชัน inner_function ค่าดังกล่าวก็จะมีการเปลี่ยนแปลงด้วย
def outer_function():
a = 5
def inner_function():
a = 10
print("Inner function: ",a)
inner_function()
print("Outer function: ",a)
outer_function()
# โปรแกรมจะทำการปรินท์ค่า
# Inner function: 10
# Outer function: 5
ตัวอย่างนี้จะคล้ายตัวอย่างที่แล้ว แต่เราไม่ได้ทำการกำกับตัวแปร a ซึ่งอยู่ภายในฟังก์ชัน inner_function ให้เป็นตัวแปรที่เป็น nonlocal ดังนั้น ค่า a นั้นจะกลายเป็นเพียงตัวแปรที่เป็น local โดยที่ความเปลี่ยนแปลงนั้นมีผลอยู่ภายใต้ฟังก์ชัน inner_function เท่านั้น ส่งผลให้ ค่า a สำหรับฟังก์ชัน outer_function นั้นไม่มีการเปลี่ยนแปลงใดๆ
คีย์เวิร์ด pass
ใช้สำหรับบอกว่าตรงตำแหน่งดังกล่าวยังไม่ทำการระบุคำสั่งใดๆ โดยจะไม่มีอะไรเกิดขึ้นเมื่อโปรแกรมรันมาถึงบรรทัดนี้
ในกรณีที่เราเขียนฟังก์ชันหรือคลาสไว้แต่ยังไม่ต้องการที่จะระบุคำสั่งใดๆ เป็นรายละเอียด เราสามารถจะใช้ pass ระบุเอาไว้ เพื่อหลีกเลียงการเกิด IndentationError ได้
def calculate_grade(scores):
pass
คีย์เวิร์ด return
ใช้ภายในฟังก์ชันเพื่อจะหยุดการทำงานของฟังก์ชัน และคืนค่าออกไป ในฟังก์ชันนั้นถ้าเราไม่ได้ประกาศ return เอาไว้ โปรแกรมจะทำการคืนค่า None สำหรับฟังก์ชันนั้นให้อัตโนมัติ
def plus(a, b):
result = a+b
return result
def minus(a, b):
result = a-b
print( plus(2, 3) )
print( minus(2, 3) )
# โปรแกรมจะปรินท์ค่า
# 5
# None
คีย์เวิร์ด while
ใช้สำหรับการวนลูป โดยจะทำชุดคำสั่งที่กำหนดอยู่ภายในขอบเขตของลูปนั้นจนกระทั่งไม่เป็นไปตามเงื่อนไขที่กำหนดไว้ หรือ โปรแกรมไปเจอ คีย์เวิร์ด break จึงจะออกจากชุดคำสั่งดังกล่าว
value = 100
while(value > 25):
value = value-25
print( value )
# โปรแกรมจะปรินท์ค่า
# 75
# 50
# 25
คีย์เวิร์ด with
ใช้สำหรับครอบกลุ่มของชุดคำสั่งซึ่งกำหนดโดย context manager
context manager คือคลาสที่ implements __enter__ และ __exit__ เมทธอด เราจะใช้ with เพื่อความแน่ใจว่า __exit__ ถูกเรียกเมื่อสิ้นสุดการเรียกใช้ nested block นั้นแล้ว วิธีการนี้คล้ายกับการทำงานของ try…finally
with open('example.txt', 'w') as my_file:
my_file.write('Hello world!')
คำสั่งด้านบนจะทำการเขียนค่า Hello world! ลงในไฟล์ example.txt โดยวัตถุ( object ) my_file นั้นจะมีฟังก์ชัน __enter__ และ __exit__ ประกาศอยู่แล้วด้วย object ดังกล่าวจึงทำงานด้วย context manager ในตัวเอง
โดยในตอนต้น ฟังก์ชัน __enter__ จะถูกเรียกใช้ จากนั้น คำสั่งภายใน with … จะถูกเรียกใช้ และท้ายสุด ฟังก์ชัน __exit__ จะถูกเรียกใช้ด้วยแม้กระทั่งในกรณีที่เกิดข้อผิดพลาดใดๆ ในระหว่างทำการเขียนไฟล์ก็ตาม
คีย์เวิร์ด yield
ใช้ภายในฟังก์ชันทำงานคล้ายกับคีย์เวิร์ด return แต่จะทำการคืนค่า generator แทน
โดย generator คือ การวนลูปเพื่อสร้างแต่ละค่าออกมาทีละตัวในแต่ละรอบ โดยแทนที่จะสร้าง list ใหญ่ๆ ที่ใช้หน่วยความจำมากในการเก็บข้อมูล เราจะใช้ generator นี้ในการสร้างค่าออกมาทีละค่า เพื่อเป็นการประหยัดพื้นที่ในการเก็บข้อมูล
g = (2**x for x in range(100)) print ( next(g) ) # คืนค่า 1 print ( next(g) ) # คืนค่า 2 print ( next(g) ) # คืนค่า 4 print ( next(g) ) # คืนค่า 8 print ( next(g) ) # คืนค่า 16
ตัวอย่างข้างบน เราทำการสร้าง generator g ซึ่งทำการยกกำลังสองของจำนวนที่ป้อนเข้าไป และใช้ ฟังก์ชัน next() เพื่อทำการเข้าถึงข้อมูลในรอบถัดไป
def generator():
for i in range(6):
yield i*i
g = generator()
for i in g:
print(i)
# โปรแกรมทำการปรินท์ค่า
# 0
# 1
# 4
# 9
# 16
# 25
ตัวอย่างข้างต้น ฟังก์ชัน generator() คืนค่า ผลของการคูณกันของเลขที่ถูกป้อนเข้าไป เราระบุการคำนวณด้วยคีย์เวิร์ด yield เพื่อระบุให้การคำนวณนั้นทำงานในรูปแบบ generator จากนั้นเราเรียกใช้ค่าดังกล่าวด้วย for loop เพื่อทำการนำค่าออกมาในแต่ละรอบ โดยไม่มีการเก็บข้อมูลทั้งหมดไว้
Identifiers
Identifiers คือชื่อที่ถูกตั้งให้แก่ คลาส(class), ฟังก์ชัน(function), ตัวแปร(variables) ซึ่งช่วยชี้เฉพาะข้อมูลแต่ละตัว
การตั้งชื่อ identifier นั้นมีกฏดังนี้
- identifier เกิดจากการรวมตัวกันของ ตัวภาษาอังกฤษตัวพิมพ์เล็ก(a-z), ตัวภาษาอังกฤษตัวพิมพ์ใหญ่(A-Z), ตัวเลข(0-9) หรือ underscore(_) ตัวอย่างของการตั้งชื่อเช่น tutorial_101, myFirstPython, python_tutorial
- identifier ไม่สามารถขึ้นด้วยตัวเลข การประกาศที่ไม่ถูกต้องเช่น 4lecture แต่ถ้า lecture4 นั้นสามารถประกาศได้
- คีย์เวิร์ดทั้ง 33 ตัวในข้างต้นไม่สามารถนำมาใช้เป็น identifier ได้
- อักขระพิเศษเช่น !, @, #, $, % ไม่สามารถใช้กับ identifier ได้
- เราสามารถตั้งชื่อของ identifer ด้วยความยาวเท่าไรก็ได้
ข้อควรพิจารณา
- เนื่องจาก python นั้นตัวพิมพ์เล็กและพิมพ์ใหญ่นั้นถือว่าแตกต่างกันดังนั้น lecture กับ Lecture นั้นแตกต่างกัน จึงควรตั้งชื่อ identifiers ให้สมเหตุสมผลเสมอ
- หากเราต้องการเขียนว่า t = 10 เพื่อบอกค่าจำนวนรวมทั้งหมดของสิ่งใดๆ เราควรเขียนว่า total = 10 แทน เพื่อให้ดูมีความหมายและเวลากลับมาอ่านโค้ดอีกครั้งหนึ่งจะทำให้เข้าใจง่ายขึ้น
- เพื่อจะทำให้การตั้งชื่อมีความหมายในการตั้งชื่อตัวหนึ่งอาจจะประกอบด้วยหลายคำ ดังนั้นเราสามารถแยกคำแต่ละคำด้วย _ เช่น total_students หรือแทนที่จะคั่นด้วย เราอาจจะใช้การตั้งชื่อที่ประกอบด้วยหลายคำในรูปแบบ camel-case ซึ่งก็คือให้ตัวอักษรที่ขึ้นต้นคำแต่ละคำนั้นเป็นตัวพิมพ์ใหญ่ทั้งหมดยกเว้นตัวอักษรตัวแรก เช่น totalStudents