Python3 (LV.1)

ภาษาไพธอน ระดับพื้นฐาน

การแสดงผลออกหน้าจอ

การพิมพ์ออกหน้าจอ สามารถทำได้โดยใช้ function print

print("Hello World")

จะได้ผลลัพธ์ออกมาเป็น

Hello World

การใช้ Comment

Comment คือส่วนของข้อความที่เราต้องการเขียนไว้บอกให้ developer คนอื่นที่มาอ่าน code ต่อเข้าใจ ไม่ได้มีไว้เพื่อให้โปรแกรมนำไปทำงาน

Comment มีสองแบบ คือ

In-line comment

เป็นการ comment ภายในบรรทัดเดียว ใช้เครื่องหมาย Sharp (#) ข้อความที่อยู่ถัดจากเครื่องหมายดังกล่าว จะไม่ถูกนำไปตีความโดยตัวโปรแกรม

Multi-line comment

เป็นการ comment หลายๆบรรทัด ใช้เครื่องหมาย single quote (') หรือ double quote (") ติดกัน 3 ตัว ครอบหัวท้ายของข้อความที่ต้องการ

'''
This is multi-line comment.
String within triple single-quote or triple double-quote
will be ignore by program.
'''
print("After comment.") # This is in-line comment

จะได้ผลลัพธ์ออกมาเป็น

After comment.

ตัวแปร (Variable)

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

ตัวอย่างเช่น

number = 20
print(number)
print(type(number))
text = "Hello"
print(text)
print(type(text))
str_num = "20"
print(str_num)
print(type(str_num))

จะได้ผลลัพธ์ออกมาเป็น

20
<class 'int'>
Hello
<class 'str'>
20
<class 'str'>

จะสังเกตว่า จากตัวอย่างข้างต้น double quote เป็นตัวบ่งบอกว่า ข้อมูลนั้นเป็น string ดังนั้น "20" จึงหมายถึง string ของอักษรเลขสองและเลขศูนย์ ไม่ใช่ค่า 20 สามารถใช้ double quote หรือ single quote ก็ได้ ความหมายเหมือนกัน

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

กรณีที่เราต้องการให้ข้อมูลตัวเลขเป็นชนิดทศนิยม (float) แทนจำนวนเต็ม (int) ให้ใส่ จุดทศนิยมในเลขด้วย เช่น

float_num = 3.
print(float_num)
print(type(float_num))

จะได้ผลลัพธ์เป็น

3.0
<class 'float'>

ตัวดำเนินการ (Operator)

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

คล้ายของภาษาซี แต่ไม่มี ++ และ --

Operator	ความหมาย	ตัวอย่าง	ผลลัพธ์
+	บวก	4+6	10
-	ลบ	5-4	1
*	คูณ	7*1	7
/	หารเอาผล	4/2	2
%	หารเอาเศษ	5%2	1

ลำดับในการดำเนินการทางคณิตศาสตร์

1. ทำค่าในวงเล็บก่อน

2. ทำคูณและหารก่อน โดยเรียงลำดับจากซ้ายไปขวา

3. ทำบวกและลบ โดยเรียงลำดับจากซ้ายไปขวา

ตัวอย่างการคำนวณ

1000/100%(5+6)+13*7 =1000/100%11+13*7 =10%11+13*7 =10+13*7 =10+91 =101

ตัวดำเนินการเปรียบเทียบ (Comparison Operator)

Operator	ความหมาย	ตัวอย่าง	ผลลัพธ์
==	เท่ากับ	4==3	เท็จ
!=	ไม่เท่ากับ	4!=3	จริง
>	มากกว่า	4>3	จริง
>=	มากกว่าหรือเท่ากับ	3>=3	จริง
<	น้อยกว่า	4<3	เท็จ
<=	น้อยกว่าหรือเท่ากับ	4<=4	จริง

ตัวดำเนินการทางตรรกะ (Logical Operator)

Operator	ควาหมาย
and	และ
or	หรือ
not	นิเสธ

ตัวอย่างเช่น

print(3 == 2 and True) # False
print(1 > 3 or 3 == 3) # True
# Logic for and operator
print(True and True) # True
print(True and False) # False
print(False and True) # False
print(False and False) # False
# Logic for or operator
print(True or True) # True
print(True or False) # True
print(False or True) # True
print(False or False) # False
# Logic for not operator
print(not True) # False
print(not False) # True

ตัวดำเนินการกำหนดค่า (Assignment Operator)

Operator	การใช้งาน	ผลของตัวแปร	ตัวอย่าง	ผลลัพธ์
=	ตัวแปร = ตัวเลข	ตัวเลข	a = 3	a = 3
+=	ตัวแปร += ตัวเลข	ตัวแปร + ตัวเลข	a += 3	a = a+3
-=	ตัวแปร -= ตัวเลข	ตัวแปร - ตัวเลข	a -= 3	a = a-3
*=	ตัวแปร *= ตัวเลข	ตัวแปร * ตัวเลข	a *= 3	a = a*3
/=	ตัวแปร /= ตัวเลข	ตัวแปร / ตัวเลข	a /= 3	a = a/3
%=	ตัวแปร %= ตัวเลข	ตัวแปร % ตัวเลข	a %= 3	a = a%3

การกำหนดค่า ทำการคำนวณค่าฝั่งขวาของเครื่องหมายเท่ากับ (=) และเก็บลงในตัวแปรฝั่งซ้ายของเครื่องหมายเท่ากับ (=)

a = 3 a = a+1 จะเป็นการคำนวณ 3+1 ได้ผลลัพธ์เป็น 4 แล้วเก็บลงตัวแปร a ทำให้ หลังการดำเนินการ a มีค่าเป็น 4

ข้อควรระวัง การหารค่าใน python2 และ python3 อาจจะให้ผลลัพธ์ที่ต่างกันได้ เช่น a = 5 b = 2 print(a/b) ใน python2 จะได้ผลลัพธ์เป็น 2 (int) ใน python3 จะได้ผลลัพธ์เป็น 2.5 (float) ดังนั้นใน python3 หากต้องการผลลัพธ์เป็น int ควรใช้ function เพื่อแปลงชนิดข้อมูล เช่น int(a/b) แทน

การจัดข้อความตามรูปแบบ Template ด้วย string.format()

เราสามารถทำการจัดรูปแบบข้อความก่อนการ print ออกไปได้ด้วยฟังก์ชัน format ภายใต้ class string ตัวอย่างเช่น

template = "Count...{first}...{second}"
print(template.format(first=123, second=456))

จะได้ผลลัพธ์เป็น

Count...123...456

การรับค่าจาก Keyboard Input

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

val = input("Type input value: ")
print(type(val))

จะเป็นการแสดงข้อความว่า

Type input value:

และรอรับค่าจากผู้ใช้ เมื่อผู้ใช้กรอกข้อมูลเข้ามา จะเก็บลงตัวแปร val ชนิดของตัวแปรจะเป็น string ถึงแม้จะกรอกเพียงตัวเลขเข้ามาก็ตาม ดังนั้นหากต้องการเป็น integer ต้องนำ val ไปแปลงค่าอีกทีด้วย function int()

รูปแบบคำสั่งกำหนดเงื่อนไข (Conditional Statements)

IF Statement

จะมีการทำงาน statement ภายใน if ต่อเมื่อ condition มีค่าเป็นจริง มี pattern การเขียนดังนี้

if condition:
  inside_if_statement
outside_if_statement

ใน Python จะไม่มีการใช้ {} ในการกำหนด scope เหมือนอย่างในภาษาซี แต่จะใช้การ indent แทน ดังนั้น statement ใดๆก็ตามที่อยู่ภายใต้ scope level เดียวกัน จะมีการเยื้อง indent ที่ตรงกัน หากใส่ indent ผิด จะทำให้โปรแกรมทำงานผิดหรือ error ได้ และ indent ควรเป็น whitespace ปกติ ไม่ควรใช้ tab

ตัวอย่างเช่น

if a > b:
  print("A is greater than B")

หาก a มีค่ามากกว่า b จะมีการพิมพ์ข้อความออกหน้าจอ แต่หากไม่ใช่ จะไม่มีข้อความใดๆบนหน้าจอ

IF-ELSE Statement

คล้ายกับ IF Statement แต่มีการเพิ่มส่วนกำหนด statement ที่ต้องทำงาน หากเงื่อนไขเป็นเท็จเข้าไปด้วย ตัวอย่างเช่น

if a > b:
  print("A is greater than B")
else:
  print("B is greater than A")

ข้อควรระวัง indent ของ else ต้องอยู่ level เดียวกับ if และ statement ที่อยู่ภายใต้ else จะต้องมีการเยื้อง indent

IF-ELSE IF-ELSE Statement

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

if score >= 80:
  print("You got A")
elif score >= 70:
  print("You got B")
elif score >= 60:
  print("You got C")
elif score >= 50:
  print("You got D")
else:
  print("You got F")

else if ใน Python จะใช้คำว่า elif

รูปแบบคำสั่งทำซ้ำ (Iteration Statements)

While Loop Statement

จะมีการทำงาน Statement ภายใน scope เมื่อเงื่อนไขภายในเป็นจริง และจะทำซ้ำๆ หากเงื่อนไขยังคงเป็นจริง

i = 1
while i < 10:
  print(i) # print number 
  i += 1   # increment i

จะได้ผลลัพธ์เป็น

1
2
3
4
5
6
7
8
9

For Each Statement

หาก list ที่ส่งมาให้ไม่เป็น list ว่าง จะมีการอ่าน item ออกมาทีละตัว ในแต่ละรอบ และดำเนินการตาม Statement ที่กำหนดใน scope ในแต่ละรอบ

fruits = ["apple", "banana", "orange"]
for item in fruits:
  print(item)

จะได้ผลลัพธ์เป็น

apple
banana
orange

จากตัวอย่าง item เป็นเพียงชื่อตัวแปรที่ประกาศขึ้นมา เพื่อทำงานภายใต้ scope for-each ในแต่ละรอบ statement จะเก็บค่าของแต่ละ element ใน list เพื่อให้เรานำไปเรียกใช้ภายใน scope ในการใช้งานอาจจะใช้ชื่อตัวแปรอื่นแทนคำว่า item ก็ได้ ขึ้นกับความเหมาะสมของบริบท เพื่อเพิ่ม readability ในการอ่านโปรแกรมให้เข้าใจง่ายขึ้น

ข้อควรระวัง ชื่อตัวแปรสำหรับ for-each ควรกำหนดอย่างระมัดระวัง และไม่ให้ซ้ำกับชื่อตัวแปรภายนอก scope ไม่เช่นนั้นจะทำให้โปรแกรมทำงานผิดพลาดได้ เพราะตัวแปรดังกล่าว มีผลที่สามารถเรียกใช้งานได้ต่อ แม้จบการทำงานของ scope for-each ไปแล้วก็ตาม

List

list ใช้ในการเก็บข้อมูลที่มีความเกี่ยวข้องกัน และต่อเนื่องกัน จุดสังเกตของการประกาศ list คือ ใช้วงเล็บเหลี่ยม square bracket ( [ ... ] ) เราสามารถประกาศ list เปล่าได้โดยประกาศ square bracket โดยไม่มีค่าใดๆอยู่ภายใน

empty_list = []

การประกาศ list ซึ่งมีค่าภายใน จะใช้ comma (,) ในการคั่นแต่ละ item ภายใน list

listA = [1, 2, 3, 4, 5]

การเข้าถึงข้อมูลภายใน list สามารถทำได้โดยระบุชื่อตัวแปรพร้อมกับ square bracket โดยมีเลข index ของ item นั้น ทั้งนี้เลข index ของ list เริ่มต้นที่ 0

listA = [1, 2, 3, 4, 5]
print(listA[2]) # will print 3

การอัพเดตค่าภายใน list สามารถทำได้โดยการเข้าถึงตำแหน่งโดยอ้างอิงจาก index ได้โดยตรงเช่นกัน

listA = [1, 2, 3, 4, 5]
listA[3] = 10 # replace value at index 3 with value 10
print(listA) # will print [1, 2, 3, 10, 5]

การเพิ่มค่าเข้าไปใน list ขณะ run-time

เพิ่มต่อท้าย ได้โดยใช้ function append ซึ่งเป็นฟังก์ชันภายใต้ class list

listA = [1, 2, 3, 4, 5]
listA.append(10) # append 10 at the end of the list
print(listA) # will print [1, 2, 3, 4, 5, 10]

เพิ่มโดยการแทรกไปยังตำแหน่งที่ต้องการ ได้โดยใช้ฟังก์ชัน insert พร้อมทั้งระบุตำแหน่งที่จะแทรก และค่าที่ต้องการแทรกลงไป

listA = [1, 2, 3, 4, 5]
listA.insert(2, 20) # insert 20 at index 2
print(listA) # will print [1, 2, 20, 3, 4, 5]

การนำค่าออกจาก list ขณะ run-time

นำค่าแรกซึ่งตรงกับที่กำหนด ออกจาก list ได้โดยใช้ฟังก์ชัน remove

listA = [1, 2, 3, 4, 5]
listA.remove(2) # remove value 2
print(listA) # will print [1, 3, 4, 5]

นำค่า ณ ตำแหน่ง index ที่ระบุออกจาก list ได้โดยใช้ฟังก์ชัน pop ฟังก์ชันนี้จะ return ค่าที่นำออกด้วย ดังนั้นเราสามารถกำหนดตัวแปรอื่นมารับค่าซึ่งได้จากการสั่ง pop ออกได้ เพื่อนำไปประมวลผลอย่างอื่น

listA = [1, 2, 3, 4, 5]
pop_val = listA.pop(2) # remove value at index 2
print(pop_val) # will print 3
print(listA) # will print [1, 2, 4, 5]

นอกจากนี้การลบ object ด้วย keyword del ก็สามารถนำมาใช้ในการลบค่าออกจาก list ได้เช่นกัน โดยการระบุตำแหน่งของ index ที่ต้องการลบ

listA = [1, 2, 3, 4, 5]
del listA[2] # remove value at index 2
print(listA) # will print [1, 2, 4, 5]

การหาตำแหน่ง index ของคำที่ตรงกับที่ระบุ

สามารถทำได้โดยใช้ฟังก์ชัน index พร้อมกับระบุค่าที่ต้องการค้นหา

listA = [1, 2, 3, 4, 5]
index = listA.index(4) # find index of value 4
print(index) # will print 3

การหาจำนวน item ภายใน list

ทำได้โดยใช้ built-in function len

listA = [1, 2, 3, 4, 5]
print(len(listA)) # will print 5

การหาค่า min-max ของ item ภายใน list

ทำได้โดยใช้ built-in function min หรือ built-in function max

listA = [1, 2, 3, 4, 5]
print(min(listA)) # will print 1
print(max(listA)) # will print 5

การจัดเรียงลำดับของสิ่งที่อยู่ภายใน list ใหม่

สามารถทำได้โดยใช้ฟัง์ชัน sort ใช้กับค่าซึ่งเป็น string ได้เช่นกัน จะส่งผลให้เกิดการเรียงตามตัวอักษร a-zA-Z0-9 แทน

listA = [1, -1, 3, 14, 5]
listA.sort()
print(listA) # will print [-1, 1, 3, 5, 14]

listB = ["a", "A", "9","10"]
listB.sort()
print(listB) # will print ['10', '9', 'A', 'a']
# '10' is character '1' + character '0'.
# Thus, it come before '9'. 

Dictionary

เป็น set ของคู่ key-value ประกาศได้โดยใช้วงเล็บปีกกา curly bracket ( {...} )

empty_dict = {}

การประกาศ Dictionary โดยมี item ภายใน ทำได้โดยประกาศ string เป็น key และ คั่นด้วย colon (:) หลังจากนั้นตามด้วยการประกาศค่า หากมีหลายคู่ จะใช้ comma (,) ในการคั่นแต่ละ item

dictA = {
'key1': 'val1',
'key2': 3,
'key3': 4.2
}

การเข้าถึงข้อมูลภายใน Dictionary ทำได้โดยระบุชื่อตัวแปร พร้อมกับระบุ key ของค่าที่ต้องการเข้าถึงลงไปใน square bracket

dictA = {
'key1': 'val1',
'key2': 3,
'key3': 4.2
}
print(dictA['key2']) # will print 3

การอัพเดตค่าของ Dictionary ทำได้โดยกำหนดค่าที่ต้องการอัพเดตไปยัง Dictionary ณ ตำแหน่ง key ที่ต้องการอัพเดต

dictA = {
'key1': 'val1',
'key2': 3,
'key3': 4.2
}
dictA['key3'] = 5.5
print(dictA) # will print {'key1': 'val1', 'key2': 3, 'key3': 5.5}

การเพิ่มค่าลงไปใน Dictionary ขณะ run-time

ทำได้โดยการระบุชื่อตัวแปรพร้อม bracket โดยมีชื่อ key ตัวใหม่อยู่ภายใน พร้อมกำหนดค่าลงไป

dictA = {
'key1': 'val1',
'key2': 3,
'key3': 4.2
}
dictA['key4'] = 10
print(dictA) # will print {'key1': 'val1', 'key2': 3, 'key3': 4.2, 'key4': 10}

การลบค่าออกจาก Dictionary ขณะ run-time

ทำได้โดยใช้ keyword del พร้อมกับระบุ Dictionary ณ ตำแหน่งที่ต้องการลบ

dictA = {
'key1': 'val1',
'key2': 3,
'key3': 4.2
}
del dictA['key2']
print(dictA) # will print {'key1': 'val1', 'key3': 4.2}

การหาจำนวน item ภายใน Dictionary

ทำได้โดยใช้ built-in function len

dictA = {
'key1': 'val1',
'key2': 3,
'key3': 4.2
}
print(len(dictA)) # will print 3

Function

ฟังก์ชันช่วยให้เราลดความซ้ำซ้อนในโปรแกรมลงได้ โดยการนำ statement ส่วนที่ซ้ำซ้อนกันมารวมกันอยู่ภายใต้ฟังก์ชัน ทำให้ไม่ต้องเขียน statement เดียวกันไว้หลายที่ ทำให้การแก้ไขง่ายขึ้น ลดความผิดพลาด และยังทำให้โปรแกรมอ่านง่ายขึ้นอีกด้วย

ตัวอย่างการใช้ฟังก์ชัน เช่น

def square(val):
  result = val ** 2
  pattern = "Square of {0} is {1}"
  print(pattern.format(val, result))
  return result

first_result = square(4) # will be 16
second_result = square(7) # will be 49

จากตัวอย่าง จะมี def เป็นจุดสังเกตของการประกาศฟังก์ชัน มีการกำหนดชื่อฟังก์ชันว่า square โดยมี parameter 1 ตัวคือ val มี colon (:) จบท้ายของการประกาศส่วนหัวของฟังก์ชัน บรรทัดถัดไปเป็น statement และต้องมี indent เพื่อบ่งบอกว่าอยู่ใต้ขอบเขตของฟังก์ชันนั้น เมื่อทำงานตามแต่ละ statement ไป จนเจอคำสั่ง return จะเป็นการบ่งบอกว่าให้จบการทำงานของฟังก์ชัน และส่งค่ากลับออกจากฟังก์ชัน

อย่างไรก็ตามส่วนบรรทัดที่ 1 ถึง 5 นั้นเป็นแค่การประกาศบอกว่าฟังก์ชันชื่ออะไร และจำดำเนินการอะไรบ้าง แต่จะไม่ถูกใช้งาน หากไม่มีการเรียกใช้ บรรทัดที่ 7 และ 8 แสดงถึงการเรียกใช้ฟังก์ชัน square และมีค่า argument ที่ส่งเข้าไปในฟังก์ชันซึ่งต่างกัน ถึงแม้การดำเนินการภายในฟังก์ชันจะเหมือนกัน แต่ค่า input ที่ต่างกัน ทำให้ได้ผลลัพธ์กลับออกมาเป็นค่าที่ต่างกันได้

x ** y คือ x ยกกำลัง y

หากฟังก์ชันไม่จำเป็นต้องมีการส่งค่ากลับออกไป ไม่จำเป็นต้องเขียน return ก็ได้ แต่หากต้องการส่งค่ากลับ จะสามารถส่งได้เพียงค่าเดียวผ่านคำสั่ง return

การประกาศค่า default สำหรับ parameter ของฟังก์ชัน

ในบางครั้ง เราอาจต้องการให้ฟังก์ชันถูกเรียกใช้งานได้โดยไม่ต้องมีการส่งค่า argument ให้กับฟังก์ชันก็ได้ และจะให้ฟังก์ชันนั้นทำงานตามค่า default ที่เราประกาศไว้แทน

ตัวอย่างเช่น

def print_val(max = 3):
  rangeA = range(max + 1) # range contains num 0 to max
  i = 0
  for item in rangeA:
    print(item)
    i += 1
    if i > max:
      break # exit for each loop when i > max

print("Show val to 5...")
print_val(5)
'''
Show val to 5...
0
1
2
3
4
5
'''
print("Show val with default val...")
print_val()
'''
Show val with default val...
0
1
2
3
'''

จากตัวอย่าง กำหนดค่า default ให้กับ max เป็น 3 หากมีการเรียกฟังก์ชันและ pass ค่าของ argument มา จะใช้ค่าตามที่ส่งมา หากไม่มีการส่งค่าของ argument มา จะใช้ค่า default ที่กำหนด

การใช้ break และ continue มักจะใช้ร่วมกับ condition statement ซึ่งอยู่ภายใต้ loop ถ้าเงื่อนไขตรงกับที่กำหนด break จะสั่งให้ออกจากลูป แต่ continue จะไม่ออกจากลูป เพียงแต่ไม่สนใจ statement ที่ตามหลังมัน และไปทำงาน loop รอบถัดไปเลย

Class

ในการเขียนโปรแกรมแบบ OOP (Object Oriented Programming) สิ่งหนึ่งที่จะขาดไปไม่ได้เลยคือ Class Class ทำให้เราสามารถมอง variable หนึ่งๆเป็นวัตถุ (object) แต่ละอย่างได้ โดยแต่ละวัตถุนั้น ก็จะมีองค์ประกอบ attribute ที่ต่างกันออกไปได้ เช่น ถ้าเทียบเป็นคน ก็อาจจะมีการประกาศเป็น คนที่หนึ่ง คนที่สอง คนที่สาม กำหนด attribute ให้คนที่แรกชื่อ Bob คนที่สองชื่อ Alice คนที่สามคือ Eve อาจจะมี attribute อื่นๆได้ เช่นเชื้อชาติ กำหนดให้ Bob มีสัญชาติอเมริกัน Alice สัญชาติอังกฤษ Eve สัญชาติออสเตรเลีย หรือต่างคนต่างมีเงินในบัญชีต่างกันออกไป เป็นต้น attribute แต่ละตัวใน Class สามารถมีชนิดต่างกันได้ เช่น ชื่อและสัญชาติเป็น string แต่กระเป๋าเงินเป็น integer

เราสามารถประกาศ Class ได้โดย ใช้ keyword class ตามด้วยชื่อ Class และบรรทัดถัดไปเป็นสิ่งที่อยู่ใน Class โดยต้อง indent เพื่อบ่งบอกว่าอยู่ภายใต้ Class นี้ อย่างไรก็ตาม ส่วนนี้เป็นแค่การประกาศว่าภายใน Class จะมีอะไรบ้าง ต้องมีส่วนของการนำ Class นั้นมาสร้างเป็น object และกำหนดให้กับตัวแปรนั้นๆอีกที

ชื่อ Class จะนิยมขึ้นต้นด้วยตัวพิมพ์ใหญ่ เพื่อป้องกันความสับสนระหว่างการใช้ Function และ Class

การสร้าง object ทำได้โดยใช้ชื่อ Class นั้นตามด้วยวงเล็บ แล้วกำหนดให้กับแต่ละชื่อตัวแปร การเข้าถึง attribute ที่อยู่ภายใต้ object นั้น จะใช้เครื่องหมาย dot (.)

ตัวอย่างการใช้งานดังนี้

class People:
  name = ""
  nationality = ""
  wallet = 0

Bob = People()
Alice = People()
Eve = People()

Bob.name = "Bob"
Bob.nationality = "America"
Bob.wallet = 120
print(Bob.name + " has $" + str(Bob.wallet) + " in his wallet.")
# Bob has $120 in his wallet.

Class Method / Class Function

ในชีวิตจริง object แต่ละอย่างจะมีความสามารถในการดำเนินการบางอย่าง ซึ่งส่งผลให้ attribute ประจำตัว object นั้นเปลี่ยนแปลงไปได้ ตัวอย่างเช่น คน อาจจะต้องการเปลี่ยนชื่อของตนเอง หรือเมื่อมีการจ่ายหรือรับเงิน ก็สามารถมีเงินในกระเป๋าเปลี่ยนแปลงไปได้ ซึ่งการดำเนินการดังนี้จะสามารถทำได้โดยการเรียกใช้ฟังก์ชันที่อยู่ภายใต้ object นั้นๆเอง

การประกาศฟังก์ชันภายใน Class ทำได้โดยวิธีการประกาศฟังก์ชันตามปกติ แต่ต้อง indent อยู่ภายใต้ Class นั้นๆ และจะต้องมี parameter แรกที่อ้างอิงถึงตัว object ตัวเอง ซึ่งปกตินิยมประกาศชื่อ parameter นี้ว่า self การดำเนินการเข้าถึง หรือเปลี่ยนค่าของ attribute ภายในตนเอง จะใช้ self ร่วมกับ dot notation และชื่อ attribute ที่ต้องการใช้งาน ฟังก์ชันจะถูกเรียกใช้โดยใช้ ชื่อตัวแปร ร่วมกับ dot notaion และชื่อของฟังก์ชัน argument ที่ส่งค่าให้กับฟังก์ชัน ให้ใช้ตามปกติ ไม่ต้องสนใจเรื่อง argument สำหรับ Parameter self

class People:
  name = ""
  nationality = ""
  wallet = 0
  def changeName(self, new_name):
    self.name = new_name
  def showWallet(self):
    print(self.name + " has $" + str(self.wallet) + " in his wallet.")

Bob = People()

Bob.name = "Bob"
Bob.nationality = "America"
Bob.wallet = 120
Bob.changeName("Jame")
Bob.showWallet() # Jame has $120 in his wallet.

การกำหนดค่าเมื่อสร้าง Object

เราสามารถกำหนดให้ Class ทำการกำหนดค่าให้กับแต่ละ attribute ได้เลย ตั้งแต่สร้าง object ขึ้นมา โดยใช้สิ่งที่เรียกว่า constructor ซึ่ง constructor จะเป็นฟังก์ชันหนึ่งที่มี statement ต่างๆเพื่อกำหนดค่าให้กับแต่ละ attribute ใน python นั้น constructor จะใช้ชื่อว่า __init__

การส่ง argument ให้ constructor ทำการกำหนดค่า จะทำตอนประกาศสร้าง object โดยการ pass argument ไปในวงเล็บหลังชื่อ Class

class People:
  def __init__(self, name = "", nationality = "", wallet = 0):
    self.name = name
    self.nationality = nationality
    self.wallet = wallet
  def showWallet(self):
    print(self.name + " has $" + str(self.wallet) + " in his/her wallet.")

Bob = People("Bob", "America", 120)
Alice = People("Alice", "English", 200)
Eve = People("Eve", "Australian", 150)

Bob.showWallet()   # Bob has $120 in his/her wallet.
Alice.showWallet() # Alice has $200 in his/her wallet.
Eve.showWallet()   # Eve has $150 in his/her wallet.

Public and Private Member

จากวิธีการใช้งาน attribute หรือ function ในตัวอย่างก่อนๆ จะเห็นได้ว่า เราสามารถเข้าถึงหรือเปลี่ยนแปลงค่าได้โดยตรง ซึ่งการใช้งานในลักษณะนี้เป็นการเรียกใช้ในฐานะที่ attribute หรือ function ดังกล่าวเป็นแบบ Public แต่ในการใช้ Object เราอาจจะมี attribute หรือ function ที่ไม่อยากให้เข้าถึงหรือถูกแก้ไขได้โดยตรงจากภายนอก เราสามารถกำหนด attribute หรือ function นั้นเป็นแบบ private ได้ โดยชื่อ attribute หรือ function นั้น จะต้องขึ้นต้นด้วย underscore (_) 2 ตัวติดกัน

class People:
  def __init__(self, name = "", nationality = "", wallet = 0):
    self.__name = name
    self.__nationality = nationality
    self.__wallet = wallet
  def changeName(self, new_name):
    if self.__name == "Bob":
      # Bob is allow to change name
      self.__name = new_name
    else:
      print(self.__name + " is not allow to change name.")
  def showWallet(self):
    print(self.__name + " has $" + str(self.__wallet) + " in his/her wallet.")

Bob = People("Bob", "America", 120)
Alice = People("Alice", "English", 200)

Bob.changeName("John")
Bob.__name = "Jame" # This won't work
Alice.changeName("Susan") # Alice is not allow to change name.
Bob.showWallet()   # John has $120 in his/her wallet.
Alice.showWallet() # Alice has $200 in his/her wallet.

Private ใน Python ต่างจากภาษาอื่น เพราะไม่ได้ห้ามการเข้าถึงโดยแท้จริง เป็นเพียง private ในเชิง concept การใช้งานเท่านั้น ตัวแปรยังสามารถเข้าถึงได้ผ่าน _object._class__variable เช่น จากตัวอย่างก่อนหน้า ถ้าเราเพิ่ม print(Bob._People__name) ลงไปถัดจากบรรทัดสุดท้าย จะได้ John และเราก็สามารถแก้ไขค่าในนี้ได้โดยตรงอยู่

Module

Module เป็นสิ่งที่ทำให้เราสามารถจัด code ของ Python ได้เป็นระเบียบ และเป็นหมวดหมู่ เมื่อ code ของโปรแกรมมีจำนวนบรรทัดมากขึ้น เราสามารถแยก variable, function และ/หรือ class ซึ่งมีความเกี่ยวข้องกัน ออกไปอยู่ที่อีกไฟล์ และตั้งชื่อสิ่งที่สื่อถึงหมวดหมู่นั้นได้

ใน Python จะมี built-in module ติดมาด้วยอยู่แล้ว ตัวอย่างเช่น module math วิธีการเรียกใช้ module สามารถทำได้โดยใช้ syntax import ตามด้วยชื่อ module ที่ต้องการ load ขึ้นมาใช้ โปรแกรมจะทำการ load variable, function และ class ทั้งหมดที่มีอยู่ใน module เข้ามา เราสามารถเรียกใช้ resource เหล่านั้นได้โดยใช้ ชื่อ module ร่วมกับ dot notation และตามด้วยชื่อ resource นั้น

import math

print(math.floor(2.3)) # 2
print(math.pi)         # 3.141592653589793

วิธีดูว่ามี module อะไรที่สามารถใช้ได้ ทำได้โดยใช้ help('modules')

หากมีชื่อตัวแปรที่ใช้ในโปรแกรมซ้ำอยู่แล้ว เราต้องการเปลี่ยนชื่อ module เป็นอย่างอื่น สามารถทำได้โดย ใช้ import ... as ... แทนได้

import math as abc

print(abc.floor(2.3)) # 2
print(abc.pi)         # 3.141592653589793

การ import module มาทั้งหมด อาจไม่ใช่สิ่งที่เราต้องการ และก็สิ้นเปลือง Memory ที่ใช้ load ขึ้นมา เราสามารถ import แค่บางส่วนของ module ได้ โดยใช้ from ... import ... แทนได้ ดังนี้

from math import floor, pi

print(floor(2.3)) # 2
print(pi)         # 3.141592653589793

การสร้าง module

นอกจากการใช้ built-in module เราสามารถสร้าง module สำหรับโปรแกรมเราเองได้ โดยสร้างไฟล์ .py อื่นขึ้นมา และสั่ง import ชื่อไฟล์นั้น โดยไม่ต้องระบุ suffix .py เช่น

main.py

import mymath # load resource in mymath.py

print(mymath.square(2)) # function square in mymath.py
foo = mymath.myclass()  # class myclass in mymath.py
print(foo.num)
print(mymath.bar)       # variable in mymath.py

mymath.py

def square(num):
  return num ** 2

class myclass:
  num = 2

bar = 4

การ load module จากไฟล์ภายใต้ directory

ในการใช้ module เราอาจจะมี module มากมายอยู่แยก folder ต่างๆกันอออกไป จากตัวอย่างที่ผ่านๆมา หาก module เป็นไฟล์ .py ภายใต้ directory เดียวกัน จะสามารถใช้ import ชื่อไฟล์นั้นได้ตรงๆ แต่หากไฟล์ที่ต้องการ import จัดอยู่ใต้ directory แล้ว จะต้องใช้ชื่อ directory ร่วมกับ dot notation และชื่อไฟล์ เวลา import เช่น

library/ foo/ bar.py main.py

จะต้องใช้ import ดังนี้

import library.foo.bar

library.foo.bar.myfunc()

หากต้องการให้ชื่อเวลาเรียกใช้สั้นลง จะต้อง rename module ด้วย import ... as ...

import library.foo.bar as bar

bar.myfunc()