[Update] รวม syntax พื้นฐานของภาษา Python ฉบับรวบรัด – TAmemo.com | none ใช้ยังไง – NATAVIGUIDES

คราวที่แล้วเขียนบทความรวม syntax พื้นฐานของภาษา Java ไปแล้ว คราวนี้จะมาเขียนของภาษายอดนิยมอีกตัวหนึ่งคือ Python กันบ้าง

ในตอนนี้ Python ถือว่าเป็นหนึ่งในภาษายอดนิยมเพราะสามารถเอาไปใช้งานในด้าน Data Sci. ได้เป็นอย่างดี (เอาไปทำอย่างอื่นเช่นเขียนเว็บก็ได้นะ) เลยมีคนสนใจเยอะมาก

ในบทความนี้จะพูดถึง syntax พื้นฐานการเขียน Python ซึ่งจะเน้นที่เวอร์ชั่น 3 เป็นหลัก

Running Mode

สำหรับภาษา Python นั้นเป็นภาษาแบบ interpreter ซึ่งทำให้เรารันโปรแกรมได้ 2 รูปแบบคือ

terminal

เป็นการรัน Python ใน terminal หรือ command-line ซึ่งจะเป็นการพิมพ์คำสั่งทีละคำสั่ง โดยไม่ต้องสร้างไฟล์ .py ขึ้นมา

วิธีการใช้คือรันคำสั่ง python หลังจากนั้นก็จะเป็น terminal ของ Python เด้งขึ้นต่อมาให้พิมพ์โค้ดได้เลย

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

file

วิธีที่ 2 ส่วนใหญ่จะใช้กับการเขียนโปรแกรมแบบปกติ จะต้องเขียนโค้ดในไฟล์นามสกุล .py ของ Python ส่วนวิธีการรันโปรแกรมจะใช้คำสั่งเหมือนกับโหมด terminal แต่ต้องเพิ่มชื่อไฟล์ตามหลังด้วย เช่น python main.py เป็นต้น

หรืออีกวิธีคือใช้ IDE สำหรับเขียน Python โดยเฉพาะเช่น PyCharm,  Anaconda, หรือ Canopy  ซึ่งโปรแกรมพวกนี้สามารถรันได้ในตัวเองอยู่แล้ว

Input/Output

การรับค่าในภาษา Python จะใช้คำสั่ง input() ส่วนการปริ๊นค่าออกมาจะใช้คำสั่ง print() ซึ่งในจุดนี้สำหรับ python2 และ python3 จะเขียนต่างกันพอสมควรเลย

#python2
num = input("input the number: ")
name = raw_input("input your name: ")

#python3
x = input() #always get String

สำหรับ python2 การรับค่าที่เป็นตัวเลขจะใช้ input() ธรรมดาส่วนถ้าอยากได้ค่าเป็น string จะใช้ต้อง raw_input() แทน

ส่วน python3 จะเหลือแค่ input() ตัวเดียวซึ่งให้ค่าเป็น string เสมอ แต่ถ้าอยากได้เป็นตัวเลข ก็สามารถ cast string ให้เป็น int หรือตัวแปรชนิดอื่นๆ ได้ด้วยคำสั่งพวก int() และ float()

#python3
num = int(input("input the number: "))
name = input("input your name: ")

ส่วนการ print ก็ต่างกันเช่นกัน แบบนี้

#python2
print "hello world!"

#python3
print("hello world!")

นั่นคือใน python2 นั้น print จะถือว่าเป็นคำสั่งประเภทนึง แต่ใน python3 นั้นจะถือว่า print() นั้นเป็นฟังก์ชัน ดังนั้นต้องใส่ ( ) ทุกรอบ

 

Comment

มีสองแบบคือ

• inline
• block

#ตรงนี้เป็นคอมเมนท์นะ

print("hello") #ตรงนี้ก็เป็นคอมเมนท์นะ

"""
อันนี้เป็นคอมเมนท์
แบบblock
ละนะ
"""

 

Variable

ตัวแปรในภาษา Python เป็นแบบ dynamic-type คือสามารถเป็น value ได้ทุกชนิดโดยไม่ต้องกำหนดประเภทของชนิดข้อมูล (ไม่เหมือนพวกภาษา C, Java ที่ต้องกำหนดตัวแปรเช่น int x สำหรับเก็บจำนวนเต็มโดยเฉพาะ)

Data Type หลักๆ ของ Python มี

• int

     –

   จำนวนเต็ม เช่น 1, 200, 1024

• float

  –

   ทศนิยม เช่น 12.34, 3.1416

• str

     –

   ตัวอักษรและอักขระ ในภาษานี้ไม่ได้แยกเป็น char เป็นนับรวมๆ เป็นตัวอักษรทั้งหมดเลย เช่น “Tamemo.com” หรือ “This is a book” (ใช้ได้ทั้งแบบ “…” double-quote และแบบ ‘…’ single-quote)

• bool

    –

   ค่าความจริงซึ่งมีแค่ 2 ค่าเท่านั้นคือ

  True

  /

  False

• None

    –

   มีค่าคล้ายๆ กับค่า

  null

  หรือ

  nil

  ในภาษาอื่น คือค่าที่ไม่มีค่าใดๆ (แต่จะทำให้ตัวแปรเกิดขึ้นได้ ใช้กับกรณีที่ต้องการให้ตัวแปร ซึ่งฐานนะของตัวแปรตัวนั้นจะต่างจากตัวแปรที่ยังไม่ได้กำหนดค่ามาก่อนที่เป็น undefined)

เนื่องจากภาษา Python เป็นภาษาแบบ interpreter เลยไม่มีปัญหากับการจองขนาดหน่วยความจำ (เพราะยังไงก็ต้องคำนวนตำแหน่งหน่วยความจำแบบ pointer อยู่แล้ว) ตัวแปรประเภทตัวเลขเลยสามารถเก็บกี่หลักก็ได้ไม่มีปัญหาแบบภาษาตระกูล C ที่ต้องกำหนดขนาดของตัวเลขให้ชัดเจนว่าใช้กี่ byte ในภาษานี้เลยแบ่งเป็นแค่ int กับ float ก็เพียงพอแล้ว

เราสามารถกำหนดค่าให้ตัวแปรและทำ operation ทางคณิตศาสตร์ได้แบบนี้

x = 10 #กำหนดค่า
x = 1 + 1 #บวก
x = 2 - 3 #ลบ
x = 4 * 5 #คูณ
x = 8 / 4 #หาร
x = 7 % 3 #หารเอาเศษ
x = 2 ** 5 #ยกกำลัง

x += 1 #มีค่าเท่ากับการเขียนว่า x = x + 1

10 == 10 #ได้ค่าเป็น True เป็นการเช็กว่าค่าทั้งสองเท่ากันหรือไม่ (ในกรณี 1 กัย "1" จะถือว่าไม่เท่ากันนะ)
1 != 2 #จะได้ค่าเป็น False เอาไว้เช็กว่าไม่เท่ากับกัน

แล้วก็ภาษานี้ไม่มีการใส่ ; หลังจบประโยคนะ

การทำ Type Casting หรือการแปลชนิดของตัวแปรจะใช้คำสั่งตามชนิดของตัวแปรชนิดนั้น เช่น

x = 1
y = float(x) #แปลง int เป็น float

x = 1.5
y = int(x) #แปลง float เป็น int

x = "2385"
y = int(x) #แปลง str เป็น int

สำหรับการเช็กว่า variable หรือ value ต่างๆ เป็น data type ชนิดไหนจะใช้คำสั่ง type() ในการเช็ก

x = 10
type(x) #int

y = 3.1416
type(y) #float

name = "tamemo.com"
type(name) #str

b = True
type(b) #bool

n = None
type(n) #NoneType

การแสดงค่าใน Python จะใช้คำสั่ง print() แบบนี้

print("hello world!")

x = 10
print(x)

แต่การใช้ print ในภาษานี้จะต่างจากภาษาอื่นๆ นิดหน่อยคือมันจะ auto new-line หรือปริ๊นค่าเสร็จแล้วขึ้่นบรรทัดใหม่ให้ทันทีเลย

ข้อแตกต่างระหว่าง python2: ใน Python3 คำสั่ง print นั้นถือว่าเป็น function ดังนั้นต้องเขียน ( ) ด้วยทุกครั้ง ต่างจาก python2 ที่เขียนแค่ print “hello world!” ได้

สำหรับการลบตัวแปรทิ้งจะใช้คำสั่ง del เช่น del x

 

Data Structure

เป็นชนิดตัวแปรแบบ data struct ในภาษา Python ประกอบด้วย

list

เป็นตัวแปรที่เก็บได้หลายค่าในตัวเดียว เทียบเท่ากับ array ในภาษาอื่น แต่ไม่จำกัดความยาว สามารถเพิ่มสมาชิกหรือลบทิ้งออกไปได้เรื่อยๆ index ของ list ใช้แบบ zero-base หรือเริ่มต้นค่าแรกใน list จะเริ่มต้นที่ตำแหน่ง 0 แบบภาษา C

num = [10, 20, 30, 40]
manga = ["One Piece", "Bleach", "Naruto"]

print(num[0]) #10
num[0] = 100 #ตอนนี้ num จะมีค่าเป็น [100, 20, 30, 40]

คำสั่งเริ่มสำหรับการจัดการข้อมูลใน list อื่นๆ เช่น len(), .append(), .insert(), .pop() แบบนี้

data = [1, 2, 3, 4]

#ถามขนาดของ list
len(data)
#4

#เพิ่มค่าเข้า list ในตำแหน่งท้ายสุด
data.append(5)
#[1, 2, 3, 4, 5]

#เพิ่มข้อมูลใส่ list ในตำแหน่งที่ระบุ
data.insert(0, 100)
#[100, 1, 2, 3, 4, 5]
data.insert(2, 200)
#[100, 1, 200, 2, 3, 4, 5]

#ขึ้นข้อมูลออกจาก list (ดึงออกมาจากข้อมูลจะถูกลบทิ้งออกไปจาก list เลยนะ)
x = data.pop(0)
#x จะมีค่าเป็น 100 ส่วน data จะเหลือแค่ [1, 200, 2, 3, 4, 5]
y = data.pop()
#ถ้าไม่ระบบตำแหน่ง จะหมายถึงตำแหน่งท้ายสุด
#y จะมีค่าเป็น 5 สวน data จะเหลือแค่ [1, 200, 2, 3, 4]

list ใน Python มีฟีเจอร์น่าสนใจอีกตัวคือ “sub-list” หรือการตัด list ออกมาเป็นช่วง จะใช้เครื่องหมาย [x:y] โดย x แทนตำแหน่งเริ่มตัด และ y แทนตำแหน่งหยุดตัด

data = ["A", "B", "C", "D", "E"]

data[1:3]
#["B", "C"]

data[2:5]
#["C", "D", "E"]

data[:3]
#["A", "B", "C"]

data[2:]
#["C", "D", "E"]

data[:]
#["A", "B", "C", "D", "E"]

ถ้าไม่กำหนด x จะหมายถึงเริ่มตั้งแต่ต้น list ส่วนถ้าไม่ได้กำหนด y หมายถึงเอาจนถึงตำแหน่งสุดท้ายของ list เลย

ในการใช้ list ต้องระวังไว้อย่างนึงคือ list เป็นตัวแปรแบบ reference-type หรือเป็น pointer นั่นเอง การสั่ง = อาจจะมีปัญหาในบางครั้งได้ เช่น

a = [1, 2, 3]
b = a
b[0] = 100

#b จะมีค่าเป็น [100, 2, 3]
#แต่เนื่องจากส่งค่ากับเป็นแบบ ref ดังนั้นค่าของ a เลยโดยด้วยเป็น [100, 2, 3] เช่นกัน

#ส่วนวิธีแก้จะใช้การ casting หรือการ sub-list ได้ทั้ง 2 วิธีแบบนี้
b = a[:]
#หรือ
b = list(a)

tuple

มันคือ list ที่ไม่สามารถแก้ไขข้อมูลได้ (รวมถึงไม่สามารถ เพิ่ม/ลด data ได้ด้วย) พูดง่ายๆ มันคือ const list หรือ final list นั่นเอง วิธีการสร้างจะคล้ายๆ กับ list แต่เปลี่ยนเครื่องหมาย [ ] เป็น ( ) เท่านั้นเอง

data = (10, 20, 30, 40)

print(data[0]) #10

dictionary

หรือชนิดตัวแปรประเภท dict เป็นการเป็นข้อมูลแบบ key-value เทียบได้กับ HashMap ในภาษา Java หรือ โครงสร้างข้อมูลยอดฮิตแบบ JSON

สำหรับคนที่ไม่รู้จัก dict จะคล้ายๆ กับ list ที่ต้องกำหนดชื่อของ index ด้วยตัวเอง เป็นชื่ออะไรก็ได้ (ปกติแล้วการอ้างอิงข้อมูลใน list เราจะใช้ตัวเลข index เริ่มจาก 0,1,2,… ไปเรื่อยๆ) โดยสัญลักษณ์ของ dict จะใช้ {key:val}

data = {
    "name": "Momo",
    "score": 100,
    "pass": true
}

set

ตัวนี้จะใช้หลักการตามวิชาคณิตศาสตร์เลย คือสมาชิกของ set จะมีแค่ 1 ตัวต่อ 1 ค่า หรือพูดง่ายๆ คือจะมี value ไม่ซ้ำกันเลย (unique list นั่นเอง) สัญลักษณ์ของ set จะใช้คล้ายๆ กับ dict คือ { } ดังนั้นระวังใช้สับสน

data = {10, 20, 30, 10, 20, 40}
#data จะเหลือแค่ {10, 20, 30, 40} เพราะ 10 กับ 20 ซ้ำนั่นเอง

contains

ในการเช็กว่ามี value ตัวนี้ใน data structure นั้นๆ หรือไม่เราจะใช้คำสั่ง in ในการเช็กนะ แบบนี้

data = [10, 20, 30, 40]
10 in data #True

data = (10, 20, 30, 40)
10 in data #True

data = {"A": 10, "B": 20, "C": 30}
10 in data #False
"A" in data #True

สังเกตอย่างนึงคือการเช็ก dict นั้นจะเช็กด้วย key ไม่ใช่ value แบบตัวอื่นๆ

 

String

ประโยคใน Python จะใช้ได้ทั้ง ” (double quote) และ ‘ (single quote) ซึ่งใช้ตัวไหนก็ได้ มีค่าเท่ากันเลย … แต่มีตัวพิเศษเรียกว่า triple quote เขียนแบบนี้ “”” (มันคือการเขียน double quote ต่อกัน 3 ตัว) ซึ่งวิธีการใช้ “”” จะต่างกับ ” และ ‘ คือเราสามารถเขียน newline (ขึ้นบรรทัดใหม่) ได้ด้วย

name = "Momo"

website = 'TAMEMO.com'

content = """
this is a book.
not a pen
"""

สำหรับการต่อ string หรือ concat จะใช้ + แบบปกติ แต่สิ่งที่ต้องระวังคือ string ในภาษา Python ไม่สามารถ + กับข้อมูลชนิดอื่นได้ เช่น str + int (พูดง่ายๆ คือมันไม่มี auto toString นั่นเอง) จะต้องแปลงข้อมูลชนิดอื่นให้เป็น str ซะก่อน

name = "Momo"
print("hello " + name)

x = 10
print("answer is " + str(x))

และใน Python นั้น string สามารถเอามา * ได้ด้วยนะ แบบนี้

"A" * 10
#AAAAAAAAAA

และคุณสมบัติอีกอย่างคือ string นั้นจะทำตัวเหมือนกับ list ของ character ดังนั้น list ทำอะไรได้ string ก็ทำแบบนั้นได้แหละ

sentence = "www.TAMEMO.com"

"""
0  1  2  3  4  5  6  7  8  9  10 11 12 13
w  w  w  .  T  A  M  E  M  O  .  c  o  m
"""

sentence[0] #w
sentence[4] #T
sentence[-1] #m ถ้าใช้ค่า - จะหมายถึง index จากฝั่งท้ายแถว

sentence[4:10] #TAMEMO

len(sentence) #14

"TA" in sentence #True

string format

คล้ายๆ กับ printf ในภาษา C คือเราสามารถ string format ใน Python ได้เช่นกันโดนใช้ % ในการระบุตัวแปรตามหลัง

• %d

  :

  แสดงค่าจำนวนเต็ม

• %f

  :

  แสดงค่าจุดทศนิยม

• %s

  :

  แสดงผล string

x = 123
"x value is %d" % x
#x value is 123

x = 1
y = 2
"%d + %d = %d" % (x, y, x+y)
#1 + 2 = 3

name = "Momo"
"welcome, %s" % name

pi = 3.1416
"PI is %.2f" % pi
#PI is 3.14

ในกรณีที่มีตัวแปรหลายตัวจะต้องครอบตัวแปรทั้งหมดด้วย ( ) หรือ tuple

หรืออีกวิธีนึงคือใช้ .format() แทน

x = 10
y = 20
"{0} and {1} and {0}".format(x, y)
#10 and 20 and 10

x = 12.345
y = 6.7890
"{0:.2} {1:.1}".format(x, y)
#12.34 6.7

และใช้ upper() กับ lower() ในการทำให้ตัวอักษรเป็นตัวใหญ่ทั้งหมด และตัวเล็กทั้งหมด

"TAmemo".upper()
#TAMEMO

"TAmemo".lower()
#tamemo

 

Control Flow

ตัวควบคุมการทำงานของโปรแกรม ส่วนนี้จะคล้ายๆ กับภาษาอื่นๆ คือมี if-else  while  for ให้ใช้ (แต่ไม่มี do..while นะ)

แต่สิ่งที่แตกต่างจากภาษาอื่นๆ แบบชัดๆ คือ “code block” ของ Python นั้นจะไม่ใช่การเขียนด้วย { } หรือ BEGIN-END แบบภาษาอื่นแต่ใช้ indent ในการแบ่ง code block แทน

สำหรับ indent คืออะไร มาดูกันในตัวอย่างแรกกับ if

if

เอาไว้เช็กว่าถ้า condition เป็นจริง จะทำงาน statement ในคำสั่ง if แบบนี้

if x > 10:
    print("x more than ten")

สังเกตว่าในภาษา Python จะไม่มีการกำหนด { } ครอบส่วนที่เป็น block ของ if แต่จะใช้การ “space เว้นวรรค (มาตราฐานคือ 4 space)” หรือการใช้ “tab แท็บ 1 ครั้ง” แทน

statement ของ if ทั้งหมดจะถูกบังคับให้ indent ออกไป 1 ครั้งจนกว่า indent จะกลับมาอยู่ในระดับเดิม ถึงจะถือว่าจบ if แล้ว

if x > 10:
    print("x more than ten")
    print("นี่ก็ยังถือว่าอยู่ใน if อยู่ล่ะ")

print("ถ้าอันนี้คือออกจาก if แล้ว")

ส่วนถ้าจะเขียน nested-if (if ซ้อน if) ใน if ชั้นที่ 2 ก็จะต้อง indent เข้าไปอีกครั้งนึงแบบนี้

if x > 10:
    print("x more than ten")
    if x % 2 == 0:
        print("and also is even")

ถ้าเทียบกับภาษาตระกูล C ก็คือ

if(x > 10){
    print("x more than ten")
    if( x % 2 == 0){
        print("and also is even")
    }
}

สำหรับ logical operator … เวลาเรามีหลาย condition เราสามารถเชื่อมประโยคได้ด้วยการใช้ and or และ not ซึ่งในภาษา Python จะใช้ตรงๆ เลยคือใช้ and  or  not (ซึ่งเทียบได้กับ &&  ||  ! ในภาษาตระกูล C)

else

เป็นส่วนเสริมของ if เอาไว้เช็กในกรณี condition เป็น False จะลงไปทำ statement ใน else แทน … แน่นอนว่าใช้การแบ่ง block ด้วย indent เหมือนเดิมแบบนี้

if x > 10:
    print("x more than ten")
else:
    print("not more than ten")

และเนื่องจาก Python แบ่ง block ด้วย indent ดังนั้นถ้าเราเขียน nested if-else หลายๆ ชั้นมันจะออกมาเป็นแบบนี้

if x > 10:
    print("...")
else:
    if y == 5:
        print("...")
    else:
        if not z:
            print("...")
        else:
            print("...")

แน่นอนว่ามันใช้ได้นะ แต่มันก็ดูเขียนยาก แถมอ่านยากอีกตั้งหาด เขาก็เลยมีคำสั่ง elif มาให้ใช้

if x > 10:
    print("...")
elif y == 5:
    print("...")
elif not z:
    print("...")
else:
    print("...")

while

อันนี้เป็น loop แบบเบสิกมากๆ เลย วิธีการใช้จะคล้ายๆ if เป็นจะวนทำซ้ำไปจนกว่า condition จะเป็น False

i = 1
while i < 5:
    print(i)
    i += 1

#1 2 3 4

การแบ่ง block ของ while ก็เหมือนกับ if ละนะ คือต้องใช้ indent ในการบอกว่าส่วนใหญ่ยังเป็น statement ของ while อยู่

for

ปกติแล้วถ้าใครเคยเขียนโปรแกรมในภาษาอื่นๆ มาก่อน การเขียน loop ประเภท for จะออกมาหน้าตาประมาณนี้

var data = [10, 20, 30, 40];
for(i = 0; i<data.length; i++){
    print( data[i] );
}

//10 20 30 40

นั่นคือ for ถูกสร้างขึ้นมาเพื่อจัดรูปแบบการเขียนลูปให้เป็นระเบียบขึ้นจากการใช้ while นั่นเอง แต่สำหรับ Python แล้วเราจะไม่สามารถเขียน for แบบนี้ได้อีกต่อไป แต่จะเป็นแบบนี้

data = [10, 20, 30, 40]

for x in data:
    print( x )

# 10 20 30 40

for ใน Python นั้นจะใช้สำหรับการวนข้อมูลประเภท list, tuple, dict เป็นหลัก โดยจะทำการวนลูปตั้งแต่ตัวแรกจนถึงข้อมูลตัวสุดท้ายให้ ซึ่งเราไม่ต้องสร้าง counter หรือตัวแปรเอามานับรอบ (เช่นในตัวอย่างนี้คือตัวแปร i) แต่ให้สร้างตัวแปรมาหนึ่งตัว เป็นตัวแทนของ data[i] มาแทน (ในตัวอย่างคือตัวแปร x …แต่ก็สร้างเป็นชื่ออะไรก็ได้นะ) ที่เหลือ Python จะจัดการให้ทั้งหมด

ดูๆ ไปแล้วมันก็เหมือนกับ foreach สินะ? … ใช่แล้ว! for ใน Python ก็คือ foreach ในภาษาอื่นๆ นั่นเอง (หรือก็คือ for-in for-of นั่นแหละ แล้วแต่ภาษาไหนจะเรียกอะไร)

แต่ถ้าเราต้องการจะใช้ for ในการวนลูปนับเลขเหมือนเดิมก็สามารถทำได้โดยการใช้ range() เข้ามาช่วย ซึ่งเจ้าฟังก์ชัน range ตัวนี้จะเป็นฟังก์ชันสำหรับสร้าง list ของตัวเลขขนาดตามที่กำหนดลงไปขึ้นมา แบบนี้

range(10)
#0 1 2 3 4 5 6 7 8 9 (ใน python2 จะให้ค่าออกมาเป็น list เลย)

list(range(10))
#0 1 2 3 4 5 6 7 8 9 แต่ถ้าเป็น python3 จะให้ค่าออกมาเป็น generator ถ้าอยากให้มันเป็น list จะต้อง cast มันอีกทีนึง
#ซึ่งคำสั่ง range ใน python3 จะเทียบได้กับ xrange ใน python2 นั่นเอง

range(5,10)
#5 6 7 8 9 หรือกำหนดค่าเริ่มต้นให้มันก็ได้

พอมันให้ค่าออกมาเป็น list ของตัวเลข ทำให้เราเอาไปวนลูปได้ แบบนี้

for i in range(10):
    print(i)
#0 1 2 3 4 5 6 7 8 9

for i in list(range(10)):
    print(i)
#0 1 2 3 4 5 6 7 8 9 ให้ค่าออกมาแบบเดียวกันเลย แต่ใช้วิธีแรกอีกกว่านะ

data = [10, 20, 30, 40]
for i in range(len(data)):
    print( data[i] )
#10 20 30 40

หรือจะใช้คำสั่ง enumerate ในการวนลูปเพื่อให้แต่ละรอบในการวน จะได้ทั้ง item และ index

data = [10, 20, 30, 40]
for i,item in enumerate(data):
    print(i, item)
#(0, 10)
#(1, 20)
#(2, 30)
#(3, 40)

ส่วนคำสั่ง break และ continue ที่เอาไว้ควบคุมการหยุด/ข้ามรอบของลูปก็ยังใช้ได้ปกติไม่มีปัญหาอะไรนะ

ส่วนการวนลูป dict นั้น iterator ที่ได้มาจะเป็นส่วนของ key นะ ไม่ใช่ value

data = {
    "A": 1,
    "B": 2,
    "C": 3
}

for k in data:
    print(k)
#A B C

for k in data:
    print(data[k])
#1 2 3

pass

ในภาษาอื่นๆ เราสร้าง block ได้ด้วยการใช้พวก { } แต่พอ Python ใช้ indent แทน บางครั้งมันก็จะมีปัญหา เช่น

if( x > 10){
    //do nothing~
}
else{
    print("not more than ten")
}

คือเกิดกรณีที่ภายใน block ไม่มี statement อะไรเลย ถ้าเอาไปเขียนเป็น Python ก็จะออกมาแบบนี้

if x > 10:
 
else:
    print("not more than ten")

ซึ่งการเขียนแบบนี้จะผิดทันที! เพราะภายใน if ไม่มี statement อะไรอยู่เลย (Python ไม่ให้ล่ะ อย่างน้อยต้องมี 1 indent)

วิธีแก้คือเติมคำสั่ง pass ลงไปแทน

if x > 10:
    pass
else:
    print("not more than ten")

 

Function

การประกาศใช้ฟังก์ชันใน Python จะทำผ่านคีย์เวิร์ด def และส่วน body ของฟังก์ชันจะต้องแบ่งด้วย code block แบบ indent เช่นกัน

def hi():
    print("hello, yo yo!")

ซึ่งการใช้ function นั้นไม่จำเป็นต้องระบุ return-type ลงไป คือถ้าอยากจะ return อะไรก็รีเทิร์นได้เลย นอกจากนี้ยังสามารถรับ parameter แบบภาษาทั่วไปได้เช่นกัน

def say_hello(name):
    print("hello, " + name)

say_hello("Momo")
#hello, Momo


def plus(a, b):
    return a + b

print(plus(10, 20))
#30

และก็เหมือนกับภาษาระดับสูงใหม่ๆ ทั่วไปคือเราสามารถใส่ default parameter ได้

def f(x = 1):
    print(x)

f() #1
f(2) #2

 

จริงๆ ภาษา Python ยังมีอะไรที่น่ารู้อีกเยอะ เช่นเรื่องของ list, dict และ การสร้าง class หรือการทำ module แต่เนื่องจากถ้าเขียนต่อไปเนื้อหาจะยาวเกินไป ไว้ต่อในบล๊อกหน้าละกันนะ

4285 Total Views

9 Views Today

จากตอนก่อน เราคุยกันในเรื่องของ Built-in Data Structure ใน Python ทั้งแต่ Array, List, Dict, Set และ Tuple วันนี้เรามาดู Data Structure ที่ Advance ขึ้นไปอีก และ ไม่มีมาให้ Python เราจะต้อง Implement เองอย่าง Linked List, Stack, Queue, Tree และ Graph เราลองเขียนแล้วพบว่ามันยาวมาก ๆ วันนี้เราจะเอา Linked List มาเล่าก่อน แล้วสัปดาห์ต่อ ๆ ไป เราค่อยมาดูเรื่องที่เหลือกัน

Linked List

Linked List เป็น Data Structure ประเภทหนึ่งที่มีลักษณะเป็นเส้นตรง ของข้อมูลต่อ ๆ กัน โดยส่วนประกอบของแต่ละ Node เราจะแบ่งเป็น 2 ส่วนคือ Data สำหรับเก็บข้อมูล และ Next สำหรับ Reference ของ Node ต่อไป

ใน Node แรก เราจะเรียกว่า Head จากนั้นใน Next ของ Head จะชี้ไปที่ Node ต่อไป ทำแบบนี้ไปเรื่อย ๆ จนถึง Node สุดท้าย ก็จะชี้ไปที่ None เป็นอันจบ เข้าใจ Concept แล้ว เราลองมาเขียนใน Python กัน

class Node :
	def __init__ (self, data) :
    	self.data = data
        self.next = None

class LinkedList :
	def __init__ (self): 
    	self.head = None

จาก Code ด้านบน เราสร้าง Class ขึ้นมา 2 Class คือ Node และ LinkedList โดยที่ใน Class Node จะแทน Node ตามชื่อถึงอย่างที่เราเล่า มันจะมีส่วนประกอบทั้งหมด 2 อย่างด้วยกันคือ Data และ Next ใน Consturctor เราจะเริ่มต้นให้เป็น None ไปก่อน ไว้ เราจะต่อ เราค่อยกำหนดค่าให้มันได้

และ Class LinkedList เป็น Class สำหรับสร้างเป็น Instance ของ Linked List ซึ่งแน่นอนว่า เราจะต้องเก็บหัวของมัน

first_node = Node(1)
second_node = Node(2)
third_node = Node(3)

ในตัวอย่างนี้ เราจะเริ่มต้นจากการสร้าง Node 3 ตัวขึ้นมาก่อน โดยที่ ปลายทางเราต้องการให้ต่อเป็น 1 -> 2 -> 3

linked_list = LinkedList()
linked_list.head = first_node

เราเริ่มจากสร้าง LinkedList ขึ้นมา พร้อมกับบอกมันว่า Head จะเป็น first_node

second_node.next = third_node

linked_list.head.next = second_node

ในขั้นตอนต่อไป เราจะทำการต่อ second_node และ third_node เข้ากับ first_node ที่เป็น Head ใน Linked List ที่เราสร้างเอาไว้แล้ว เราเริ่มจาก ต่อ second_node และ third_node เข้าด้วยกันก่อน โดยบอกว่า next ของ second_node เป็น third_node และขั้นตอนต่อไป เราก็เอา second_node และ thrid_node ที่ต่อแล้ว ต่อเข้ากับ first_node ก็เป็นอันจบ

Traversal

เราลองมาดูกันบ้างดีกว่า ว่าถ้าเราอยากจะ Traversal เราจะทำยังไง เราต้องอย่าลืมนะว่า Linked List ไม่ใช่ List ที่เราจะเข้าถึงข้อมูลจาก Index ตรง ๆ ได้ เราจะต้องเข้าถึงจาก Head แล้วชี้ไปที่ Element ต่อไปเท่านั้น

def __str__ (self) :
	final_string = ''
    
    current_node = self.head
    while current_node != None :
    	final_string += str(current_node.data)
        
    	if current_node.next != None :
        	final_string += str(current_node.data) + ' -> '
         
        current_node = current_node.next

ในตัวอย่างนี้เราจะมาเขียน Method ที่เมื่อเราเรียก str() กับ Object เราจะให้มันออกมาหน้าตาเป็นอย่างไร อันนี้ลองไปอ่านเพิ่มเติมในเรื่อง Class ใน Python ได้ ซึ่งเป้าหมายที่เราต้องการให้มันออก คือ “1 -> 2 -> 3”

เราเลยเขียนง่าย ๆ เลย จุดเริ่มต้น เราจะต้องเริ่มจาก Head ก่อน ใน Linked List เราหยิบ Node Head มาก่อน ให้เป็น current_node จากนั้น เราก็ While Loop ไป โดยที่เรารู้ว่า Node สุดท้าย Next มันต้องเป็น None แน่ ๆ เราก็ Loop ไปเรื่อย ๆ จน กว่าเราจะเจอว่า current_node เป็น None ก็จบแล้ว

ใน Loop เราก็ให้มัน Append ค่าของ Node ปัจจุบันเข้าไป จากนั้นเราจะเอาลูกศรใส่เข้าไป แต่ปัญหาคือ ถ้าเราใส่เข้าไปตรง ๆ เลย เราจะได้ออกมาเป็น “1 -> 2 -> 3 ->”  จะเห็นว่าอันสุดท้าย มันมีลูกศรเกินมาตัวนึง

คิดเร็ว ๆ เราก็แก้ง่าย ๆ เขียนเงื่อนไขขึ้นมาเพิ่มว่า ถ้า Node ต่อไป ไม่ใช่ None หมายความว่า มันมี Node ต่อไปแน่ ๆ เราก็ใส่ลูกศร เพื่อให้ Data ของ Node ต่อไปมา มันจะได้มีลูกศรคั่นก่อนนั่นเอง

Searching

อีกหนึ่ง Application ของ Traversal คือการทำ Search เพื่อหาว่าใน Linked List มันมี Data ที่เราต้องการรึเปล่า ใช้วิธีการเดียวกับ Traversal เลย แต่เราเพียงเพิ่มเงื่อนไขว่า ถ้าเจอแล้วให้ Return เป็น True เท่านั้นเอง

def search (self, target) :
    found = False
    current_node = self.head
    
    while current_node != None and found != True :
    	if current_node.data == target :
        	found = True
    
    return found

จากด้านบน เราเริ่มจากการกำหนด Boolean ขึ้นมาตัวนึงเป็น Flag ว่าเราเจอรึยัง จากนั้น เราก็ Traversal ปกติ แต่เราเพิ่มการเช็คว่า มันเจอ Data ตรงกับที่เราต้องการจะหารึยังเท่านั้นเลย ถ้าไม่เจอมันก็จะลูปจนเจอตัวสุดท้ายแล้วหลุดออกมา

Adding Data

ถัดไปคือ เราจะมาเพิ่มข้อมูลกัน เริ่มจากอะไรที่ง่าย ๆ ก่อนคือการเติม Node เข้าไปที่อันแรกของ Linked List พูดง่าย ๆ คือ Head จะเป็น Node ใหม่นั่นเอง ทำยังไงดีละ

def insert (self, data) :
    new_node = Node(data)
    new_node.next = self.head
    self.head = new_node
    

ก็คือ เราเริ่มจากเราสร้าง Node โดยอัด Data ไปก่อน ทีนี้เราบอกว่า เราอยากจะเพิ่ม Node เข้าไปที่หัวของมันแปลว่า Node ที่เราสร้างขึ้นมาใหม่ Node ต่อไปของมันจะต้องเป็น Head อันปัจจุบัน เราก็เซ็ตไปในบรรทัดที่ 3 ของ Code ด้านบน และ สุดท้าย ก็ให้ Head ของ Linked List ตัวนี้เป็น Node ใหม่ก็เรียบร้อยแล้ว จะเห็นว่า เรียบง่ายตาม Logic ทั่ว ๆ ไปเลย และ ใช้ O(1) เท่านั้น เร็วมาก ๆ

ลองมาดูอะไรที่พิเรนทร์กว่านั้นกัน เราทำสลับกันบ้าง ถ้าเราอยากจะ Append ไปที่อันสุดท้าย เราจะทำยังไงดี ???

def append (self, data) :
	new_node = Node(data)
    
    current_node = self.head
    while current_node != None :
    	if current_node.next == None :
        	current_node.next = new_node

Goal ของเราคือ เราจะต้องทำให้ Next ของ Node สุดท้ายจาก None เป็น Node ที่เราสร้างขึ้นใหม่ ซึ่งคิดเข้าไปอีก Node สุดท้ายก็คือ Node ที่ Next เป็น None นั่นเอง ทำให้เราจะต้อง Loop หาไปเรื่อย ๆ จนกว่าจะเจอว่า Next ของ Node ไหนเป็น None จากใน Condition ที่อยู่ใน For Loop และ เรากำหนด Next ให้เป็น Node ใหม่ก็จะเรียบร้อย ดังนั้นวิธีนี้เราจะใช้ O(n) นั่นเอง

Deleting

และสุดท้าย เรามาลองลบข้อมูลออกจาก Linked List กันบ้าง วิธีการก็คือ เมื่อเราเจอ Node ที่เราต้องการ เราก็เอามันออก และ Link Previous Node เข้ากับ Next Next Node ลองมาดู Code กัน

def delete_node (self, target) :
	current_node = self.head
    
    while current_node != None :
    	if current_node.next.data == target :
        	current_node.next = current_node.next.next

จะเห็นว่า เราทำง่าย ๆ เลย เราแค่ เช็คเลยว่า ถ้า Node ต่อไป data เป็นสิ่งที่เราต้องการ เราก็ตัดสายอันต่อไป แล้วเปลี่ยนเป็นอันถัด ๆ ไปแทน ก็เรียบร้อยแล้ว

สรุป

Linked List เป็น Data Structure ประเภทนึงที่การเข้าถึงข้อมูลเราไม่สามารถที่จะเข้าถึงตรง ๆ ได้ เราสามารถเข้าถึงได้จากหัว (Head) เท่านั้น โดยที่ใน Data เราสามารถเก็บอะไรก็ได้ลงไป สนใจแค่ Core Concept ที่ว่า มันจะต้องต่อ ๆ กันเป็นเส้นเท่านั้นเองใน Linked List ที่เราสอนในวันนี้เป็น Singly Linked List ที่เราจะเก็บแค่ Data กับ Next Node เท่านั้น แต่ถ้าเป็น Doubly Linked List เราจะเก็บ Previous เพื่อเป็น Pointer สำหรับชี้ไปที่ Node ก่อนหน้า ทำให้เราสามารถเดินย้อนกลับไป Node ก่อนหน้าได้ อาทิตย์ต่อไป เราจะมา Implement เรื่องของ Queue และ Stack กัน