สนุกคิด สนุกโค้ด ด้วยภาษาไพทอน

กำลังเรียนในชื่อ:

บทที่ 4: Python Turtle - วาดรูปเล่นด้วยโค้ดกัน!

สารบัญในบทนี้

1. รู้จัก Python Turtle

เรามาเริ่มสั่งเจ้าเต่าวิเศษในโลกของ Python กันเลย! Python Turtle เป็นไลบรารี (เครื่องมือ) สนุกๆ ที่มาพร้อมกับ Python ทำให้เราสามารถเรียนรู้การเขียนโปรแกรมผ่านการวาดภาพได้ การจะเรียกเต่าออกมา เราต้องทำ 2 ขั้นตอนหลักๆ ครับ:

  1. นำเข้าไลบรารี: บอกโปรแกรมว่าเราจะใช้เครื่องมือที่ชื่อ `turtle` ด้วยคำสั่ง import turtle
  2. สร้างตัวละครเต่า: สร้างเต่าของเราขึ้นมาแล้วตั้งชื่อให้มัน เช่น tommy = turtle.Turtle()

ขั้นตอนที่ 1: วาดสี่เหลี่ยมแบบตรงไปตรงมา (The Hard Way)

ถ้าเราอยากวาดสี่เหลี่ยมจัตุรัส เราต้องสั่งให้เต่า "เดินไปข้างหน้า" แล้ว "หันซ้าย 90 องศา" ทั้งหมด 4 ครั้ง ลองดูโค้ดด้านล่างนี้ จะเห็นว่าเราต้องเขียนคำสั่งซ้ำๆ กันหลายบรรทัด

วาดสี่เหลี่ยมด้วยโค้ดแบบยาวและแบบสั้น 
import turtle

# สร้างเต่าของเราชื่อ tommy
tommy = turtle.Turtle()
tommy.shape("turtle")
tommy.speed(1)  # ทำให้เต่าเดินช้าๆ จะได้เห็นภาพ

# ด้านที่ 1
tommy.forward(100)
tommy.left(90)

# ด้านที่ 2
tommy.forward(100)
tommy.left(90)

# ด้านที่ 3
tommy.forward(100)
tommy.left(90)

# ด้านที่ 4
tommy.forward(100)
tommy.left(90)

ขั้นตอนที่ 2: วิธีคิดแบบโปรแกรมเมอร์ - ลดความซ้ำซ้อนด้วย Loop

จากโค้ดด้านบน จะเห็นว่าชุดคำสั่ง tommy.forward(100) และ tommy.left(90) ถูกใช้ซ้ำถึง 4 รอบ ในการเขียนโปรแกรม เรามีเครื่องมือที่เรียกว่า Loop (การวนซ้ำ) เพื่อสั่งให้คอมพิวเตอร์ทำงานซ้ำๆ แทนเราได้ด้วยโค้ดที่สั้นลงมาก!

เราจะใช้ for i in range(4): ซึ่งหมายความว่า "ให้ทำคำสั่งที่อยู่ข้างในนี้วนซ้ำไป 4 รอบ" 

import turtle

tommy = turtle.Turtle()
tommy.shape("turtle")

# ใช้ for loop วาดสี่เหลี่ยม
for i in range(4):
    tommy.forward(100)
    tommy.left(90)

ผลลัพธ์ที่ได้จะเหมือนกันเป๊ะ แต่โค้ดของเราสั้นลงและอ่านง่ายขึ้นเยอะเลย!

ขั้นตอนที่ 3: สร้างรูปแบบซับซ้อนด้วย Loop ซ้อน Loop

เมื่อเราวาดรูปทรงพื้นฐาน (แก้ปัญหาย่อย) ได้แล้ว เราสามารถนำมาประกอบกันเพื่อสร้างรูปที่ซับซ้อนขึ้นได้โดยใช้ Loop ซ้อน Loop (Nested Loop) ซึ่งเป็นการนำหลักการ Pattern Recognition (การหารูปแบบ) มาใช้ คือ "ทำซ้ำ (การวาดสี่เหลี่ยม) ซ้ำอีกที"

ตัวอย่างในภาพด้านล่าง คือการสั่งให้เต่า "วาดสี่เหลี่ยม 1 รูป แล้วหมุน 90 องศา" และทำกระบวนการนี้ซ้ำทั้งหมด 4 ครั้ง ผลลัพธ์ที่ได้คือรูปทรงใหม่ที่เกิดจากการนำสี่เหลี่ยม 4 รูปมาประกอบกัน

การใช้ Loop ซ้อน Loop วาดรูปสี่เหลี่ยม 4 รูปที่หมุนรอบจุดเดียวกัน 
import turtle

tommy = turtle.Turtle()
tommy.shape("turtle")
tommy.speed(0)  # speed(0) คือเร็วที่สุด

# 1. กำหนดสีและขนาดปากกา
tommy.color("green")
tommy.pensize(5)

# 2. Loop นอก: สั่งให้ทำกระบวนการทั้งหมด 4 ครั้ง
for j in range(4):
    # 3. Loop ใน: วาดสี่เหลี่ยม 1 รูป (โค้ดเดิมที่เราคุ้นเคย)
    for i in range(4):
        tommy.forward(100)
        tommy.left(90)
  
    # 4. หลังจากวาดเสร็จ 1 รูป ให้หมุนเต่า 90 องศาเพื่อเตรียมวาดรูปถัดไป
    tommy.left(90)

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

ขั้นตอนที่ 4: เติมชีวิตชีวาด้วยการระบายสีและ List

หลังจากที่เราวาดรูปทรงซับซ้อนด้วย Loop ซ้อน Loop ได้แล้ว ทีนี้เรามาทำให้มันมีสีสันสวยงามกันดีกว่าครับ โดยเราจะเรียนรู้ 2 เรื่องสำคัญคือ: การระบายสี และการใช้ List เพื่อจัดการชุดข้อมูล

List ใน Python ก็เหมือน "กล่องที่เก็บของได้หลายๆ ชิ้น" เราสามารถสร้างลิสต์ของสีที่ต้องการ แล้วใช้ Loop วนไปหยิบสีออกมาใช้ทีละสีได้

  • colors = ['green','pink','blue','yellow']: สร้างลิสต์ชื่อ `colors` เพื่อเก็บชื่อสี 4 สี
  • tommy.color(colors[j]): ในแต่ละรอบของ Loop นอก เราจะสั่งให้เต่าเปลี่ยนสีปากกาตามสีในลิสต์ โดยใช้ `j` (ซึ่งมีค่า 0, 1, 2, 3) เป็นตัวชี้ตำแหน่ง
  • tommy.begin_fill() และ tommy.end_fill(): ใช้สำหรับระบายสีในรูปทรง เราต้องวางคำสั่งวาดรูปทรงไว้ "ระหว่างกลาง" สองคำสั่งนี้
import turtle

tommy = turtle.Turtle()
tommy.shape("turtle")
tommy.speed(0)

# 1. สร้างลิสต์ของสีที่ต้องการใช้
colors = ['green', 'pink', 'blue', 'yellow']

# 2. Loop นอก: ทำซ้ำ 4 ครั้งสำหรับสี่เหลี่ยม 4 รูป
for j in range(4):
    # 3. ตั้งค่าสีปากกา โดยหยิบจากลิสต์
    tommy.color(colors[j]) 
  
    # 4. เริ่มการระบายสี
    tommy.begin_fill()

    # 5. Loop ใน: วาดสี่เหลี่ยม 1 รูป
    for i in range(4):
        tommy.forward(100)
        tommy.left(90)
  
    # 6. สิ้นสุดการระบายสี (รูปสี่เหลี่ยมจะถูกเติมสี)
    tommy.end_fill()

    # 7. หมุนเต่า 90 องศาเพื่อเตรียมวาดรูปถัดไป
    tommy.left(90)

ตัวอย่างผลลัพธ์

การเติมสีและใช้ลิสต์

เพียงเท่านี้ เราก็สามารถสร้างรูปที่มีสีสันแตกต่างกันในแต่ละส่วนได้แล้ว นี่คือพลังของการใช้ Loop ร่วมกับ List เพื่อสร้างสรรค์ผลงานที่น่าทึ่งและจัดการได้ง่าย!

ขั้นตอนที่ 5: ภารกิจท้าทาย - สร้างงานศิลปะด้วย List และ Loop

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

การเติมสีและโจทย์ที่ซับซ้อน

ทดลองเขียนโค้ดของคุณที่นี่

ตอนนี้คุณได้เรียนรู้พื้นฐานทั้งหมดแล้ว! ลองคัดลอกโค้ดจากตัวอย่างต่างๆ หรือลองดัดแปลงโค้ดสุดท้ายนี้เพื่อสร้างผลงานในแบบของคุณเองในกล่องโค้ดด้านล่างได้เลย!

2. เต่าสร้างบ้าน

สุดยอดไปเลย! ตอนนี้เราวาดรูปทรงพื้นฐานและใช้ Loop ได้แล้ว ถึงเวลานำความรู้เหล่านั้นมาประกอบกันเป็นรูปที่ซับซ้อนขึ้น เช่น "บ้าน" ซึ่งเป็นการนำหลักการ Decomposition (การแบ่งย่อยปัญหา) มาใช้ เราจะมองบ้านว่าประกอบด้วย 2 ส่วนหลักๆ คือ ตัวบ้าน (สี่เหลี่ยม) และ หลังคา (สามเหลี่ยม)

ขั้นตอนที่ 1: วาดตัวบ้าน (สี่เหลี่ยม)

ส่วนนี้ง่ายมาก เพราะเราเพิ่งทำกันมาในบทที่แล้ว! เราจะใช้ Loop เพื่อวาดสี่เหลี่ยมจัตุรัสขนาด 150x150 พิกเซล 

# โค้ดสำหรับวาดสี่เหลี่ยม (ทบทวน)
import turtle

t = turtle.Turtle()
t.speed(5)

# วาดสี่เหลี่ยมสีน้ำเงิน
t.color("blue")
for i in range(4):
    t.forward(150)
    t.left(90)

ขั้นตอนที่ 2: วาดหลังคา (สามเหลี่ยม) และความลับของมุม

การวาดสามเหลี่ยมด้านเท่าก็ใช้ Loop เหมือนกัน แต่มีจุดที่ต้องคิดคือ "เต่าต้องหันกี่องศา?"

มุมภายในของสามเหลี่ยมด้านเท่าคือ 60 องศา แต่เต่าของเราเดินอยู่ "ข้างนอก" เส้น ดังนั้นมุมที่เต่าต้องหันคือ มุมภายนอก ซึ่งคำนวณได้จาก 180 - มุมภายใน ดังนั้น เต่าต้องหัน 180 - 60 = 120 องศาครับ 

# โค้ดสำหรับวาดสามเหลี่ยม
import turtle

t = turtle.Turtle()
t.speed(5)

# วาดสามเหลี่ยมสีแดง
t.color("red")
for i in range(3):  # สามเหลี่ยมมี 3 ด้าน
    t.forward(150)
    t.left(120)   # หันด้วยมุมภายนอก

ขั้นตอนที่ 3: สร้าง "สูตรสำเร็จ" ด้วยฟังก์ชัน (Function)

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

เราจะสร้าง 2 ฟังก์ชัน คือ draw_square() สำหรับวาดตัวบ้าน และ draw_triangle() สำหรับวาดหลังคา 

import turtle

t = turtle.Turtle()
t.speed(5)

# ----- สร้างสูตร (ฟังก์ชัน) -----

def draw_square():
    # โค้ดวาดสี่เหลี่ยมจะอยู่ในนี้
    t.color("blue")
    t.begin_fill()
    for i in range(4):
        t.forward(150)
        t.left(90)
    t.end_fill()

def draw_triangle():
    # โค้ดวาดสามเหลี่ยมจะอยู่ในนี้
    t.color("red")
    t.begin_fill()
    for i in range(3):
        t.forward(150)
        t.left(120)
    t.end_fill()

# *** ลองกด Run ดูสิ... จะยังไม่มีอะไรเกิดขึ้น! ***
# เพราะเราแค่สร้างสูตรไว้เฉยๆ ยังไม่ได้เรียกใช้

ขั้นตอนที่ 4: ประกอบร่าง! เรียกใช้ฟังก์ชันวาดบ้านฉบับสมบูรณ์

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

python turtle

ทดลองเขียนโค้ดของคุณที่นี่

3. เต่ากับดอกไม้

หลังจากที่เราสร้าง "สิ่งก่อสร้าง" อย่างบ้านได้แล้ว เรามาลองสร้าง "สิ่งมีชีวิต" จากธรรมชาติอย่างดอกไม้กันบ้างดีกว่าครับ โปรเจกต์นี้จะท้าทายขึ้นอีกนิด แต่จะทำให้เราเข้าใจพลังของฟังก์ชันและ Loop มากขึ้นไปอีก!

แถวดอกไม้ที่วาดด้วย Python Turtle

คำถามชวนคิด: ถ้าจะวาดภาพนี้ เราจะวางแผนอย่างไร?

ใช้หลักการ Decomposition (การแบ่งย่อยปัญหา) อีกครั้งครับ เราจะไม่วาดทั้งหมดในทีเดียว แต่จะแบ่งปัญหาเป็นส่วนเล็กๆ:

  1. วาดดอกไม้แค่ 1 ดอก ให้สำเร็จก่อน
  2. ดอกไม้ 1 ดอก ประกอบด้วยอะไรบ้าง? -> กลีบดอก, ก้าน, และใบ
  3. เรามาเริ่มจากส่วนที่เล็กที่สุด คือ "กลีบดอก 1 กลีบ" กันเลย!

ขั้นตอนที่ 1: วาดกลีบดอก 1 กลีบ

กลีบดอกไม้มีลักษณะโค้งๆ เราสามารถใช้คำสั่ง t.circle(รัศมี, องศา) เพื่อวาดส่วนโค้งของวงกลมได้ กลีบดอก 1 กลีบของเราจะประกอบด้วยเส้นโค้ง 2 เส้นมาประกบกัน 

# โค้ดสำหรับวาดกลีบดอก 1 กลีบ
import turtle

t = turtle.Turtle()
t.color("pink")

t.begin_fill()
t.circle(50, 60) # วาดส่วนโค้งแรก (รัศมี 50, โค้ง 60 องศา)
t.left(120)      # หันเต่าเพื่อวาดส่วนโค้งที่สอง
t.circle(50, 60) # วาดส่วนโค้งที่สอง
t.left(120)      # หันเต่าเพื่อกลับตำแหน่งเดิม
t.end_fill()

ขั้นตอนที่ 2: วาดกลีบดอกให้ครบ (สร้างดอกไม้)

เมื่อวาด 1 กลีบได้แล้ว เราก็ใช้ Loop เพื่อวาดกลีบให้ครบรอบวงกลมได้เลย! ถ้าเราอยากได้ดอกไม้ 10 กลีบ และวงกลมมี 360 องศา หมายความว่าหลังจากวาดแต่ละกลีบ เราต้องหมุนเต่าไป 360 / 10 = 36 องศา 

# โค้ดสำหรับวาดดอกไม้ 10 กลีบ
import turtle

t = turtle.Turtle()
t.speed(0) # ตั้งค่าความเร็วสูงสุด
t.color("pink")

for i in range(10): # ทำซ้ำ 10 ครั้งเพื่อวาด 10 กลีบ
    # --- โค้ดสำหรับวาด 1 กลีบ ---
    t.begin_fill()
    t.circle(50, 60)
    t.left(120)
    t.circle(50, 60)
    t.left(120)
    t.end_fill()
    # --- จบโค้ดวาด 1 กลีบ ---
    
    # หมุน 36 องศาเพื่อเตรียมวาดกลีบถัดไป (360 / 10 = 36)
    t.left(36)

ขั้นตอนที่ 3: วาดก้านและใบ

ส่วนนี้ไม่ยากเลย ก้านก็คือเส้นตรง ส่วนใบไม้ก็ใช้หลักการเดียวกับการวาดกลีบดอก แค่เปลี่ยนสีและปรับมุมเล็กน้อย 

# โค้ดวาดก้านและใบ
import turtle

t = turtle.Turtle()
t.speed(0)

# วาดก้าน
t.color("black")
t.right(90) # หันลง
t.forward(100)

t.right(180) # หันขึ้น
t.forward(50) # ขึ้นไปตรงกลางลำต้น

# วาดใบ (หลักการเดียวกับกลีบดอก)
t.color("green")
t.left(45)
t.begin_fill()
t.circle(40, 90)
t.left(90)
t.circle(40, 90)
t.end_fill()

ขั้นตอนที่ 4: รวมทุกอย่างเป็นฟังก์ชัน draw_flower()

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

# ฟังก์ชันวาดดอกไม้ 1 ดอก
def draw_flower():
    # วาดกลีบ 10 กลีบ
    t.color("pink")
    for i in range(10):
        ...โค้ดวาดกลีบ...
        t.left(36)
    
    # วาดจุดเกสร
    t.color("black")
    t.dot(10)
    
    # วาดก้าน
    t.right(90)
    t.forward(100)
    
    # วาดใบ
    t.color("green")
    ...โค้ดวาดใบ...

ขั้นตอนที่ 5: อัปเกรดฟังก์ชันให้ยืดหยุ่น draw_flower(x, y, size)

เพื่อให้ฟังก์ชันของเราเจ๋งขึ้นไปอีก เราจะเพิ่มความสามารถให้มันวาดดอกไม้ที่ ตำแหน่ง (x, y) และ ขนาด (size) ใดก็ได้ โดยการเพิ่ม พารามิเตอร์ (Parameters) เข้าไป

  • x, y: คือพิกัดที่จะเริ่มวาด เราจะใช้ t.penup(), t.goto(x, y), และ t.pendown() เพื่อย้ายเต่าไปโดยไม่วาดเส้น
  • size: คือตัวเลขที่ใช้ควบคุมขนาดของทุกส่วนในดอกไม้ เช่น รัศมีวงกลมของกลีบ, ความยาวก้าน เราจะเปลี่ยนจากตัวเลขคงที่ (เช่น 50) ไปเป็นตัวแปร `size` แทน

ภารกิจท้าทาย: สร้างทุ่งดอกไม้!

ในกล่องโค้ดด้านล่างนี้ คือฟังก์ชัน draw_flower(x, y, size) ที่สมบูรณ์แล้ว
โจทย์ของคุณคือ: จงใช้ Loop เพื่อเรียกฟังก์ชันนี้ซ้ำๆ และเปลี่ยนแปลงค่า `x` ในแต่ละรอบ เพื่อสร้างแถวดอกไม้ที่สวยงามเหมือนในภาพตัวอย่างให้สำเร็จ!

ทดลองเขียนโค้ดของคุณที่นี่

4. ภารกิจสุดท้าย: บ้านของฉัน

ถึงเวลาใช้ความรู้ทั้งหมดที่เราเรียนมา! ในภารกิจนี้ คุณมีอิสระเต็มที่ในการสร้างสรรค์ภาพ "บ้านของฉัน" ตามจินตนาการ

วาดรูปสวยด้วย Python Turtle

สมุดคำสั่งช่วยจำ (Cheatsheet)

  • t.forward(ระยะทาง) - เดินไปข้างหน้า
  • t.backward(ระยะทาง) - ถอยหลัง
  • t.left(องศา) - หันซ้าย
  • t.right(องศา) - หันขวา
  • t.goto(x, y) - เคลื่อนย้ายไปยังพิกัด (x, y)
  • t.penup() - ยกปากกาขึ้น (เคลื่อนที่โดยไม่วาดเส้น)
  • t.pendown() - วางปากกาลง (กลับมาวาดเส้นตามปกติ)
  • t.pensize(ขนาด) - เปลี่ยนขนาดความหนาของเส้น
  • t.color("ชื่อสี") - เปลี่ยนสีของเส้นปากกา
  • t.circle(รัศมี) - วาดวงกลม
  • t.dot(ขนาด) - วาดจุดทึบ
  • t.begin_fill() - เริ่มกำหนดพื้นที่สำหรับระบายสี
  • t.end_fill() - สั่งให้ระบายสีในพื้นที่ที่กำหนด
  • t.shape("turtle") - เปลี่ยนรูปร่างเป็นเต่า (ใช้ "arrow", "circle" ก็ได้)
  • t.speed(ความเร็ว) - ปรับความเร็ว (0 คือเร็วสุด, 1 คือช้าสุด, 10 คือเร็ว)
  • t.hideturtle() - ซ่อนตัวเต่า
  • t.showturtle() - แสดงตัวเต่า

โจทย์: จงวาดภาพที่มีองค์ประกอบอย่างน้อย 4 อย่าง ได้แก่ บ้าน ภูเขา ต้นไม้หรือดอกไม้ และพระอาทิตย์ โดยใช้ฟังก์ชันเข้ามาช่วย!

ทดลองเขียนโค้ดของคุณที่นี่

✔

ยินดีด้วย!

คุณผ่านบทเรียนนี้แล้ว!

ไปบทต่อไป