คำสั่งรัน Python

python main.py

เชื่อม Git กับ GitHub.com

ตั้งค่า Git เปิด cmd หรือ terminal ใช้คำสั่ง

git config --global user.name "ชื่อ username ของคุณใน github.com"
git config --global user.email "อีเมล ของคุณใน github.com"

คำสั่ง git เบื้องต้น

สร้าง branch

git checkout -b main

บันทึกเวอร์ชั่นโค้ด

git add .
git commit -m "ข้อความ commit"

อัปโหลดเวอร์ชั่นโค้ดขึ้น github.com

git push origin main

ดึงข้อมูลจาก Repository

git pull origin main

โคลน Repository จาก github.com

git clone git@github.com:username/repository-name.git

เชื่อมต่อกับ Repository ที่มีอยู่

git remote add origin git@github.com:username/repository-name.git

ตรวจสอบสถานะ

git status

พื้นฐาน

บทที่ 1: พื้นฐานของคอมพิวเตอร์

บทที่ 1: พื้นฐานของคอมพิวเตอร์

1. เลข 0 และ 1 คืออะไร?

คอมพิวเตอร์ไม่สามารถเข้าใจภาษาแบบที่มนุษย์พูดได้ มันเข้าใจแค่ เลข 0 และ 1 เท่านั้น ซึ่งเราเรียกระบบนี้ว่า เลขฐานสอง (Binary System)

0 หมายถึง ปิด (ไม่มีสัญญาณไฟฟ้า)
1 หมายถึง เปิด (มีสัญญาณไฟฟ้า)

ลองนึกถึงสวิตช์ไฟที่มีแค่ "เปิด" และ "ปิด" นั่นแหละคือวิธีที่คอมพิวเตอร์คิด!

2. วิธีคำนวณเลขฐานสอง

ตัวเลขที่เราคุ้นเคย (0-9) ใช้ระบบ เลขฐานสิบ (Decimal) แต่คอมพิวเตอร์ใช้เลขฐานสองแทน

ตัวอย่างแปลงเลขฐานสิบเป็นฐานสอง:

5 → 101 (เพราะ 1×2² + 0×2¹ + 1×2⁰ = 5)
8 → 1000
12 → 1100

alt text

3. บิต (Bit) คืออะไร?

บิต (Bit) = หน่วยที่เล็กที่สุดของข้อมูล มีค่าได้แค่ 0 หรือ 1 เท่านั้น

8 bits = 1 ไบต์ (Byte)
1024 Bytes = 1 กิโลไบต์ (KB)
1024 KB = 1 เมกะไบต์ (MB)

4. การเข้ารหัสตัวอักษร (Text Encoding)

คอมพิวเตอร์เก็บตัวอักษรเป็นเลขฐานสองผ่าน ASCII หรือ Unicode

ตัวอย่าง ASCII:

A → 01000001
B → 01000010
C → 01000011

5. อัลกอริทึมคืออะไร?

อัลกอริทึม (Algorithm) คือ ขั้นตอนหรือกฎที่ใช้แก้ปัญหาอย่างเป็นระบบ เหมือนสูตรทำอาหาร!

ตัวอย่าง: วิธีล้างมือ

เปิดก๊อกน้ำ
เอามือไปล้างน้ำ
ใส่สบู่
ถูมือให้สะอาด
ล้างสบู่ออก
ปิดก๊อกน้ำ
เช็ดมือให้แห้ง

6. โครงสร้างการควบคุมโปรแกรม

Flowchart ช่วยแสดงลำดับของขั้นตอนในโปรแกรม เรามีโครงสร้าง 3 แบบหลัก:

1. ลำดับ (Sequence)

graph TD;
  A(เริ่มต้น) --> B(ทำขั้นตอนที่ 1);
  B --> C(ทำขั้นตอนที่ 2);
  C --> D(ทำขั้นตอนที่ 3);
  D --> E(จบ);

2. การตัดสินใจ (Decision)

graph TD;
  A(เริ่มต้น) --> B{มีเงินพอไหม?};
  B -- ใช่ --> C(ซื้อของ);
  B -- ไม่ --> D(เก็บเงินเพิ่ม);
  C --> E(จบ);
  D --> E;

3. การทำซ้ำ (Repetitive)

graph TD;
  A(เริ่มต้น) --> B{ทำการบ้านเสร็จหรือยัง?};
  B -- ไม่ --> C(ทำต่อ);
  C --> B;
  B -- ใช่ --> D(ไปเล่นได้!);
  D --> E(จบ);

7. Pseudocode คืออะไร?

Pseudocode คือ การเขียนลำดับคำสั่งของโปรแกรมในรูปแบบที่อ่านง่าย เหมือนภาษามนุษย์

ตัวอย่าง: หาค่าเลขมากสุดจากสองตัวเลข

BEGIN
  รับค่า A และ B
  ถ้า A > B
    แสดง A
  มิฉะนั้น
    แสดง B
END

โจทย์ที่ 1: แปลงเลขฐานสิบเป็นเลขฐานสอง ให้คุณแปลงเลขฐานสิบต่อไปนี้เป็นเลขฐานสอง:

10 → ?
25 → ?
50 → ?
100 → ?
255 → ?

โจทย์ที่ 2: วาด Flowchart และเขียน Pseudocode ให้คุณออกแบบ Flowchart และเขียน Pseudocode สำหรับโจทย์ต่อไปนี้:

โจทย์: "เขียนขั้นตอนการตรวจสอบว่าเลขที่รับเข้ามาเป็นเลขคู่หรือเลขคี่ แล้วแสดงผลลัพธ์ออกมา"

เขียน Flowchart

ตัวอย่าง Input/Output:

รับค่า 8 → แสดงผล "เลขคู่"
รับค่า 15 → แสดงผล "เลขคี่"

บทที่ 2: พื้นฐานของ Python

บทที่ 2: พื้นฐานของ Python

1. ตัวแปรคืออะไร?

ตัวแปร (Variable) คือ กล่อง ที่ใช้เก็บข้อมูลในโปรแกรม ลองนึกถึงการใส่ของลงในกล่อง เช่น:

name = "Alice"
age = 10

ตัวแปร name เก็บคำว่า "Alice"
ตัวแปร age เก็บเลข 10

เหมือนกล่องที่ติดป้ายชื่อไว้ ว่าในกล่องมีอะไรอยู่!

2. กฎการตั้งชื่อตัวแปร

ต้องเริ่มต้นด้วยตัวอักษร หรือ _
ห้ามใช้ตัวเลขนำหน้า
ห้ามใช้คำสงวน เช่น if, while, for
ควรตั้งชื่อให้สื่อความหมาย
ส่วนใหญ่ใช้ตัวพิมพ์เล็กเป็นชื่อตัวแปร ยกเว้น class

ตัวอย่างที่ถูกต้อง ✅:

user_name = "Bob"
count = 5
_speed = 20.5

ตัวอย่างที่ผิด ❌:

1name = "Bob"  # ❌ ผิด เพราะขึ้นต้นด้วยตัวเลข
if = 5         # ❌ ผิด เพราะใช้คำสงวน

3. ชนิดของตัวแปรใน Python

Python มีหลายประเภท เช่น:

ชนิดข้อมูล	คำอธิบาย	ตัวอย่าง
`int`	ตัวเลขจำนวนเต็ม	`10, -5, 1000`
`float`	ตัวเลขทศนิยม	`3.14, -2.5, 0.0`
`str`	ข้อความ	`"Hello", 'Python'`
`bool`	ค่า True/False	`True, False`
`list`	กลุ่มข้อมูล (ใช้สําหรับเก็บค่าหลายค่าในตัวแปรเดียว)	`[1, 2, 3]`
`dict`	ตารางข้อมูล (ใช้สําหรับเก็บค่าไม่ซ้ําที่มีความสัมพันธ์แบบ key-value)	`{ "name": "Alice", "age": 10 }`
`tuple`	กลุ่มข้อมูล (ใช้สำหรับไม่ต้องการแก้ไขข้อมูล)	`(1, 2, 3)`
`set`	กลุ่มข้อมูล (ใช้สําหรับเก็บค่าไม่ซ้ํา)	`{1, 2, 3}`

ตัวอย่างการประกาศตัวแปรแบบกำหนดชนิดข้อมูล:

age: int = 10
price: float = 99.99
message: str = "Hello"
is_student: bool = True
list_of_numbers: list = [1, 2, 3]
movie_info: dict = {"title": "The Matrix", "year": 1999}
coordinates: tuple = (1.0, 1.0)
x, y, z: float = 1.0, 2.0, 3.0
set_of_numbers: set = {1, 2, 3}

4. ฟังก์ชันใน Python

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

ตัวอย่างฟังก์ชันหาผลรวมของตัวเลข:

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

print(add_numbers(3, 5))  # แสดงผล 8

5. ตรวจสอบชนิดข้อมูล

Python มีฟังก์ชัน type() เพื่อตรวจสอบชนิดข้อมูล

print(type(10))      # <class 'int'>
print(type("hello")) # <class 'str'>

ทำไมต้องตรวจสอบชนิดข้อมูล?

เพื่อป้องกันข้อผิดพลาด เช่น การนำตัวเลขไปบวกกับข้อความ

6. การแปลงชนิดข้อมูล

Python สามารถแปลงชนิดข้อมูลได้ เช่น:

num_str = "123"
num_int = int(num_str)  # แปลงเป็นจำนวนเต็ม
print(num_int + 10)  # แสดงผล 133

สิ่งที่แปลงไม่ได้:

int("hello")  # ❌ Error เพราะ "hello" ไม่ใช่ตัวเลข
float("text")  # ❌ Error เพราะ "text" ไม่ใช่ตัวเลข

7. การแสดงผลข้อมูลผ่าน Console

ใช้ print()

print("Hello, World!")

8. รับค่าจากคีย์บอร์ด

ใช้คำสั่ง input()

name = input("กรุณาใส่ชื่อของคุณ: ")
print("สวัสดี", name)

9. การต่อสตริง

first_name = "John"
last_name = "Doe"
full_name = first_name + " " + last_name
print(full_name)  # John Doe

อีกแบบก็คือ

first_name = "John"
last_name = "Doe"
full_name = f"{first_name} {last_name}"
print(full_name)  # John Doe

หรืออีกแบบ

first_name = "John"
last_name = "Doe"
full_name = "{} {}".format(first_name, last_name)
print(full_name)  # John Doe

10. คอมเมนต์ใน Python

คอมเมนต์ ใช้เครื่องหมาย #
ช่วยให้โค้ดอ่านง่าย อะไรที่อยู่หลัง # จะไม่ถูกโปรแกรมรัน
ส่วนใหญ่จะใช้ในการแสดงคําแนะนํา หรือโน๊ตข้อความทิ้งไว้ เพื่ออ้างอิงในอนาคต กรณีลืม

# นี่คือคอมเมนต์
print("Hello")  # คำสั่งแสดงผล

โจทย์ท้ายบท

สร้างตัวแปรชื่อ age และกำหนดค่าเป็น 25
เขียนฟังก์ชันที่รับชื่อและอายุ และแสดงผล "สวัสดี [ชื่อ] อายุ [อายุ] ปี"
ตรวจสอบชนิดข้อมูลของตัวแปร 5.5 และ "Python"
รับค่าตัวเลขจากคีย์บอร์ด และบวกเพิ่ม 10 ก่อนแสดงผล
แปลงตัวเลข 100 เป็นข้อความ แล้วต่อกับ " คะแนน" และแสดงผล

บทที่ 3: ตัวดำเนินการและการควบคุมการไหลของโปรแกรม

บทที่ 3: ตัวดำเนินการและการควบคุมการไหลของโปรแกรม

1. ตัวดำเนินการทางคณิตศาสตร์

ตัวดำเนินการทางคณิตศาสตร์ใน Python ใช้สำหรับคำนวณค่าต่าง ๆ เช่น การบวก ลบ คูณ หาร เป็นต้น

ตัวดำเนินการ	คำอธิบาย	ตัวอย่าง
`+`	บวก	`3 + 2 # ได้ 5`
`-`	ลบ	`7 - 4 # ได้ 3`
`*`	คูณ	`5 * 3 # ได้ 15`
`/`	หาร	`10 / 2 # ได้ 5.0`
`//`	หารแบบปัดเศษลง	`10 // 3 # ได้ 3`
`%`	หารเอาเศษ	`10 % 3 # ได้ 1`
`**`	ยกกำลัง	`2 ** 3 # ได้ 8`

2. ตัวดำเนินการเปรียบเทียบ

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

ตัวดำเนินการ	คำอธิบาย	ตัวอย่าง
`==`	เท่ากับ	`5 == 5 # ได้ True`
`!=`	ไม่เท่ากับ	`5 != 3 # ได้ True`
`>`	มากกว่า	`5 > 3 # ได้ True`
`<`	น้อยกว่า	`2 < 7 # ได้ True`
`>=`	มากกว่าหรือเท่ากับ	`5 >= 5 # ได้ True`
`<=`	น้อยกว่าหรือเท่ากับ	`3 <= 5 # ได้ True`

3. กฎพื้นฐานลำดับการดำเนินการ

Python ใช้กฎ PEMDAS (Parentheses, Exponents, Multiplication/Division, Addition/Subtraction) ในการคำนวณ

ดำเนินการในวงเล็บก่อน จากซ้ายไปขวา
เลขยกกำลัง และ √ จากซ้ายไปขวา
การคูณ และ หาร จากซ้ายไปขวา
การบวก และ การลบ จากซ้ายไปขวา

ตัวอย่าง:

result = (2 + 3) * 4 / 2 ** 2
print(result)  # ได้ 5.0

4. การควบคุมการไหลของโปรแกรม

4.1 คำสั่ง `if`, `elif`, `else`

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

age = 10
if age < 13:
    print("คุณเป็นเด็ก")
elif age < 20:
    print("คุณเป็นวัยรุ่น")
else:
    print("คุณเป็นผู้ใหญ่")

graph TD;
  A(เริ่มต้น) --> B{อายุ < 13?};
  B -- ใช่ --> C(คุณเป็นเด็ก);
  B -- ไม่ --> D{อายุ < 20?};
  D -- ใช่ --> E(คุณเป็นวัยรุ่น);
  D -- ไม่ --> F(คุณเป็นผู้ใหญ่);
  C --> G(จบ);
  E --> G;
  F --> G;

4.2 ลูป `for`

ใช้สำหรับทำซ้ำตามจำนวนครั้งที่กำหนด

for i in range(1, 6):
    print("รอบที่", i)

graph TD;
  A(เริ่มต้น) --> B{i <= 5?};
  B -- ใช่ --> C(แสดงผลรอบที่ i);
  C --> D(เพิ่มค่า i);
  D --> B;
  B -- ไม่ --> E(จบ);

4.3 ลูป `while`

ใช้สำหรับทำซ้ำจนกว่าเงื่อนไขจะเป็น False

x = 3
while x > 0:
    print("ค่า x:", x)
    x -= 1

graph TD;
  A(เริ่มต้น) --> B{x > 0?};
  B -- ใช่ --> C(แสดงผลค่า x);
  C --> D(ลดค่า x ลง 1);
  D --> B;
  B -- ไม่ --> E(จบ);

โจทย์ท้ายบท

เขียนโปรแกรมรับเลขสองตัวจากผู้ใช้ แล้วแสดงผลว่าตัวไหนมากกว่ากัน
สร้างโปรแกรมที่รับอายุจากผู้ใช้ และบอกว่าผู้ใช้อยู่ในช่วงวัยไหน (เด็ก, วัยรุ่น, ผู้ใหญ่)
เขียนโปรแกรมคำนวณหาผลรวมของตัวเลขตั้งแต่ 1 ถึง 10 ด้วยลูป for
ใช้ while loop เพื่อให้ผู้ใช้ป้อนตัวเลข จนกว่าจะป้อนเลข 0
เขียนโปรแกรมใช้ if และ for เพื่อแสดงเลขคู่ตั้งแต่ 1 ถึง 20

บทที่ 4: ฟังก์ชันและการนำโค้ดกลับมาใช้ใหม่

บทที่ 4: ฟังก์ชันและการนำโค้ดกลับมาใช้ใหม่

1. ฟังก์ชันคืออะไร?

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

ตัวอย่างโค้ดฟังก์ชันง่ายๆ:

# ฟังก์ชันแสดงคำทักทาย
def say_hello():
    print("สวัสดี!")

say_hello()

แผนภาพแสดงการเรียกใช้ฟังก์ชัน

graph TD;
  A(เริ่มต้น) --> B(เรียกฟังก์ชัน say_hello);
  B --> C(แสดง สวัสดี!);
  C --> D(จบ);

2. การแบ่งโค้ดเป็นส่วนเล็กๆ

ตัวอย่าง:

def greet(name):
    print(f"สวัสดี {name}!")

greet("เด็กอนุบาล")
greet("นักเรียน")

graph TD;
  A(เริ่มต้น) --> B(รับค่า name);
  B --> C(แสดงคำทักทาย);
  C --> D(จบ);

3. ฟังก์ชันที่สามารถนำกลับมาใช้ใหม่

ตัวอย่าง:

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

result = add(5, 3)
print(result)

graph TD;
  A(เริ่มต้น) --> B(รับค่า a และ b);
  B --> C(คำนวณ a + b);
  C --> D(ส่งค่าผลลัพธ์กลับ);
  D --> E(จบ);

4. ฟังก์ชันคำนวณพื้นที่ของรูปทรงต่างๆ

ตัวอย่าง: คำนวณพื้นที่สี่เหลี่ยมผืนผ้า

def rectangle_area(width, height):
    return width * height

print(rectangle_area(5, 10))

graph TD;
  A(เริ่มต้น) --> B(รับค่า width และ height);
  B --> C(คำนวณพื้นที่ width * height);
  C --> D(ส่งค่าผลลัพธ์กลับ);
  D --> E(จบ);

5. Parameter และ Return Value ของฟังก์ชัน

ตัวอย่าง:

def greet(name="เพื่อน"):  # ค่าเริ่มต้น
    return f"สวัสดี {name}!"

print(greet())
print(greet("เด็กอนุบาล"))

graph TD;
  A(เริ่มต้น) --> B(รับค่า name, ค่าเริ่มต้นคือ เพื่อน);
  B --> C(ส่งค่ากลับเป็นข้อความ);
  C --> D(จบ);

6. ใช้ฟังก์ชันหลายๆ ฟังก์ชันร่วมกัน

ตัวอย่าง: โปรแกรมคำนวณพื้นที่สี่เหลี่ยมแล้วพิมพ์ผลลัพธ์

def rectangle_area(width, height):
    return width * height

def print_area(width, height):
    area = rectangle_area(width, height)
    print(f"พื้นที่คือ: {area} ตารางหน่วย")

print_area(4, 6)

graph TD;
  A(เริ่มต้น) --> B(เรียก print_area);
  B --> C(เรียก rectangle_area);
  C --> D(คำนวณและส่งค่ากลับ);
  D --> E(แสดงค่าพื้นที่);
  E --> F(จบ);

7. Lambda Function

lambda function หรือ Anonymous Function เป็นฟังก์ชันที่ไม่มีชื่อ ใช้ในกรณีที่ต้องการฟังก์ชันแบบสั้นๆ และใช้งานเพียงครั้งเดียว

โครงสร้างของ `lambda function`

lambda parameters: expression

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

# ฟังก์ชันปกติ
def square(x):
    return x * x

print(square(5))  # 25

# ใช้ lambda function
square_lambda = lambda x: x * x
print(square_lambda(5))  # 25

ตัวอย่างการใช้กับ `map()`, `filter()`, และ `sorted()`

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

# ใช้ map() กับ lambda
squared_numbers = list(map(lambda x: x * x, numbers))
print(squared_numbers)  # [1, 4, 9, 16, 25]

# ใช้ filter() กับ lambda
even_numbers = list(filter(lambda x: x % 2 == 0, numbers))
print(even_numbers)  # [2, 4]

# ใช้ sorted() กับ lambda
words = ["apple", "banana", "cherry"]
sorted_words = sorted(words, key=lambda word: len(word))
print(sorted_words)  # ['apple', 'cherry', 'banana']

โจทย์ท้ายบท

คำนวณพื้นที่วงกลม: เขียนฟังก์ชัน circle_area(radius) เพื่อคำนวณพื้นที่วงกลม
- สูตร: pi = 3.14
ตรวจสอบเลขคู่: เขียนฟังก์ชัน is_even(number) เพื่อตรวจสอบว่าเป็นเลขคู่หรือไม่
- เงื่อนไข: ถ้า number % 2 == 0 ให้คืนค่า True ไม่เช่นนั้นคืนค่า False
แปลงอุณหภูมิ: เขียนฟังก์ชัน convert_celsius_to_fahrenheit(celsius) เพื่อแปลงอุณหภูมิจากเซลเซียสเป็นฟาเรนไฮต์
- สูตร: F = (C x 9/5) + 32
หาค่ามากที่สุด: เขียนฟังก์ชัน max_of_three(a, b, c) หาค่ามากที่สุดในสามจำนวน
- ใช้เงื่อนไข if-elif-else เพื่อเปรียบเทียบค่าทั้งสาม
สร้างสามเหลี่ยมดาว: เขียนฟังก์ชัน print_triangle(n) เพื่อพิมพ์สามเหลี่ยมดาว (*) ขนาด n แถว
- ใช้ for loop เพื่อสร้างแต่ละแถวของสามเหลี่ยม

บทที่ 5: โครงสร้างข้อมูลใน Python

บทที่ 5: โครงสร้างข้อมูลใน Python

1. โครงสร้างข้อมูลคืออะไร?

โครงสร้างข้อมูล (Data Structures) คือ วิธีการจัดเก็บและจัดการข้อมูล ในโปรแกรมให้สามารถเรียกใช้ได้ง่ายขึ้น ในภาษา Python มีโครงสร้างข้อมูลที่สำคัญ เช่น list, tuple, และ dictionary

2. List (รายการ)

list เป็น กลุ่มของข้อมูลที่สามารถเปลี่ยนแปลงได้ และสามารถเก็บข้อมูลได้หลายประเภทในรายการเดียวกัน

ตัวอย่างการใช้ `list`

# รายชื่อนักเรียน
students = ["เอ", "บี", "ซี", "ดี"]

# เข้าถึงข้อมูลใน list
print(students[0])  # "เอ"
print(students[2])  # "ซี"

# เพิ่มข้อมูล
students.append("อี")
print(students)  # ["เอ", "บี", "ซี", "ดี", "อี"]

graph TD;
  A(เริ่มต้น) --> B(สร้าง list ชื่อนักเรียน);
  B --> C(เพิ่มชื่อใหม่ใน list);
  C --> D(พิมพ์รายชื่อ);
  D --> E(จบ);

3. Tuple (กลุ่มข้อมูลที่ไม่เปลี่ยนแปลง)

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

ตัวอย่างการใช้ `tuple`

# วันในสัปดาห์ (ไม่เปลี่ยนแปลง)
days = ("จันทร์", "อังคาร", "พุธ", "พฤหัสบดี", "ศุกร์", "เสาร์", "อาทิตย์")

# เข้าถึงข้อมูล
print(days[0])  # "จันทร์"
print(days[-1]) # "อาทิตย์"

graph TD;
  A(เริ่มต้น) --> B(สร้าง tuple วันในสัปดาห์);
  B --> C(เข้าถึงข้อมูล);
  C --> D(แสดงค่า);
  D --> E(จบ);

4. Dictionary (พจนานุกรมข้อมูล)

dictionary ใช้ คู่ของคีย์ (key) และค่า (value) เพื่อเก็บข้อมูล

ตัวอย่างการใช้ `dictionary`

# เก็บข้อมูลนักเรียน (เลขที่ -> ชื่อ)
students = {
    1: "เอ",
    2: "บี",
    3: "ซี",
    4: "ดี"
}

# เข้าถึงข้อมูล
print(students[2])  # "บี"

# เพิ่มข้อมูล
students[5] = "อี"
print(students)

graph TD;
  A(เริ่มต้น) --> B(สร้าง dictionary นักเรียน);
  B --> C(เข้าถึงข้อมูลด้วย key);
  C --> D(เพิ่มข้อมูลใหม่);
  D --> E(จบ);

5. โปรแกรมเก็บข้อมูลนักเรียนใน `dictionary` และ `list`

students = [
    {"เลขที่": 1, "ชื่อ": "เอ", "เกรด": 3.5},
    {"เลขที่": 2, "ชื่อ": "บี", "เกรด": 3.8},
    {"เลขที่": 3, "ชื่อ": "ซี", "เกรด": 4.0}
]

# แสดงข้อมูล
for student in students:
    print(f"เลขที่ {student['เลขที่']}: {student['ชื่อ']} - เกรด {student['เกรด']}")

graph TD;
  A(เริ่มต้น) --> B(สร้าง list ของ dictionary);
  B --> C(วนลูปเพื่อแสดงข้อมูล);
  C --> D(จบ);

6. โปรแกรมค้นหาชื่อนักเรียนจากเลขที่

students = {
    1: "เอ",
    2: "บี",
    3: "ซี",
    4: "ดี"
}

# รับเลขที่จากผู้ใช้
num = int(input("กรุณาใส่เลขที่นักเรียน: "))

# ค้นหานักเรียน
if num in students:
    print(f"นักเรียนเลขที่ {num} คือ {students[num]}")
else:
    print("ไม่พบนักเรียน")

graph TD;
  A(เริ่มต้น) --> B(รับเลขที่นักเรียน);
  B --> C(ตรวจสอบว่ามีใน dictionary หรือไม่);
  C -->|มี| D(แสดงชื่อนักเรียน);
  C -->|ไม่มี| E(แจ้งว่าไม่พบ);
  D --> F(จบ);
  E --> F;

โจทย์ท้ายบท

สร้าง list ของผลไม้ ที่มี "กล้วย", "แอปเปิล", "ส้ม" และเพิ่ม "มะม่วง" ลงไป แล้วพิมพ์ผลลัพธ์
เขียน tuple ของสีรุ้ง ที่ประกอบด้วยสี 7 สี แล้วพิมพ์สีที่อยู่ตำแหน่งที่ 3
สร้าง dictionary ของคะแนนสอบ โดยมีนักเรียน 3 คน (ใช้เลขที่เป็น key และคะแนนเป็น value) แล้วเพิ่มนักเรียนใหม่เข้าไป
เขียนโปรแกรมที่รับเลขที่นักเรียน แล้วแสดงชื่อของนักเรียนคนนั้น (ใช้ dictionary)
เขียนโปรแกรมที่รับค่าชื่อจากผู้ใช้ แล้วตรวจสอบว่ามีอยู่ใน list หรือไม่ ถ้ามีให้พิมพ์ "พบชื่อนี้" ถ้าไม่มีให้พิมพ์ "ไม่พบชื่อนี้"

บทที่ 6: การจัดการไฟล์ใน Python

บทที่ 6: การจัดการไฟล์ใน Python

1. การอ่านและเขียนไฟล์ใน Python

ไฟล์เป็นสิ่งที่ช่วยให้เราสามารถบันทึกข้อมูลและนำกลับมาใช้ใหม่ได้ Python มีฟังก์ชันสำหรับจัดการไฟล์ได้ง่ายๆ

ตัวอย่างการเขียนไฟล์

# เปิดไฟล์เพื่อเขียนข้อมูล
with open("example.txt", "w") as file:
    file.write("สวัสดี Python!")

graph TD;
  A(เริ่มต้น) --> B(เปิดไฟล์ example.txt);
  B --> C(เขียนข้อมูลลงไฟล์);
  C --> D(ปิดไฟล์);
  D --> E(จบ);

ตัวอย่างการอ่านไฟล์

# เปิดไฟล์เพื่ออ่านข้อมูล
with open("example.txt", "r") as file:
    content = file.read()
    print(content)

graph TD;
  A(เริ่มต้น) --> B(เปิดไฟล์ example.txt);
  B --> C(อ่านข้อมูลจากไฟล์);
  C --> D(แสดงข้อมูล);
  D --> E(จบ);

2. การอ่านข้อมูลจากไฟล์ CSV และนำมาประมวลผล

ตัวอย่างการอ่าน CSV

ตัวอย่างไฟล์ students.csv

import csv

with open("students.csv", "r") as file:
    reader = csv.reader(file)
    for row in reader:
        print(row)

graph TD;
  A(เริ่มต้น) --> B(เปิดไฟล์ students.csv);
  B --> C(อ่านข้อมูลแต่ละแถว);
  C --> D(แสดงข้อมูล);
  D --> E(จบ);

3. การจัดการข้อผิดพลาดในการทำงานกับไฟล์

ตัวอย่างการจัดการข้อผิดพลาด

try:
    with open("missing_file.txt", "r") as file:
        content = file.read()
except FileNotFoundError:
    print("ไม่พบไฟล์ที่ระบุ")

graph TD;
  A(เริ่มต้น) --> B(พยายามเปิดไฟล์ missing_file.txt);
  B -->|พบข้อผิดพลาด| C(แจ้งเตือน);
  C --> D(จบ);

4. เขียนโปรแกรมที่บันทึกข้อมูลลงในไฟล์

ตัวอย่างการบันทึกข้อมูล

with open("log.txt", "a") as file:
    file.write("บันทึกข้อมูลใหม่\n")

graph TD;
  A(เริ่มต้น) --> B(เปิดไฟล์ log.txt แบบ append);
  B --> C(เขียนข้อมูลใหม่);
  C --> D(ปิดไฟล์);
  D --> E(จบ);

โจทย์ท้ายบท

เขียนโปรแกรมที่อ่านไฟล์ data.txt แล้วแสดงเนื้อหาในไฟล์
เขียนโปรแกรมที่สร้างไฟล์ output.txt และเขียนข้อความ "Hello, Python!" ลงไป
เขียนโปรแกรมที่อ่านไฟล์ CSV students.csv และแสดงเฉพาะชื่อของนักเรียน
เขียนโปรแกรมที่บันทึกบันทึกคะแนนนักเรียนลงในไฟล์ scores.txt
เขียนโปรแกรมที่ตรวจสอบว่าไฟล์ config.txt มีอยู่หรือไม่ และแจ้งเตือนหากไม่พบ

บทที่ 7: การเขียนโปรแกรมเชิงวัตถุ (Object-Oriented Programming - OOP)

บทที่ 7: การเขียนโปรแกรมเชิงวัตถุ (Object-Oriented Programming - OOP)

1. แนวคิดของการเขียนโปรแกรมเชิงวัตถุ

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

ตัวอย่างโค้ดการสร้างคลาสและวัตถุ

class Animal:
    def __init__(self, name, sound):
        self.name = name
        self.sound = sound

    def make_sound(self):
        print(f"{self.name} ส่งเสียง {self.sound}")

# สร้างวัตถุ
cat = Animal("แมว", "เหมียว")
dog = Animal("สุนัข", "โฮ่ง")

cat.make_sound()
dog.make_sound()

graph TD;
    A(สร้างคลาส Animal) -->|มีคุณสมบัติ name และ sound| B(สร้างวัตถุแมวและสุนัข);
    B --> C(เรียกใช้เมธอด make_sound);

2. Inheritance (การสืบทอดคุณสมบัติ)

Inheritance คือการที่คลาสหนึ่งสามารถสืบทอดคุณสมบัติและพฤติกรรมจากอีกคลาสหนึ่งได้

ตัวอย่างโค้ด

class Animal:
    def __init__(self, name):
        self.name = name

    def speak(self):
        pass  # ให้คลาสลูกกำหนดเอง

class Cat(Animal):
    def speak(self):
        return "เหมียว"

class Dog(Animal):
    def speak(self):
        return "โฮ่ง"

cat = Cat("แมว")
dog = Dog("สุนัข")

print(f"{cat.name} ส่งเสียง {cat.speak()}")
print(f"{dog.name} ส่งเสียง {dog.speak()}")

graph TD;
    A(คลาส Animal) -->|สืบทอด| B(คลาส Cat);
    A -->|สืบทอด| C(คลาส Dog);

3. Polymorphism (พหุสัณฐาน)

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

ตัวอย่างโค้ด

class Bird:
    def fly(self):
        return "บินได้"

class Penguin(Bird):
    def fly(self):
        return "บินไม่ได้ แต่เดินได้"

animals = [Bird(), Penguin()]
for animal in animals:
    print(animal.fly())

graph TD;
    A(คลาส Bird) -->|สืบทอด| B(คลาส Penguin);
    B -->|เปลี่ยนพฤติกรรม fly| C(บินไม่ได้แต่เดินได้);

4. สร้างเกมง่ายๆ โดยใช้ OOP

ตัวอย่าง: เกมตัวละครโจมตีศัตรู

class Character:
    def __init__(self, name, attack_power):
        self.name = name
        self.attack_power = attack_power

    def attack(self, enemy):
        print(f"{self.name} โจมตี {enemy.name} ด้วยพลัง {self.attack_power}")

player = Character("ผู้เล่น", 10)
enemy = Character("ศัตรู", 5)

player.attack(enemy)

graph TD;
    A(สร้างคลาส Character) -->|กำหนดชื่อและพลังโจมตี| B(สร้างตัวละครผู้เล่น);
    A -->|กำหนดชื่อและพลังโจมตี| C(สร้างตัวละครศัตรู);
    B -->|ใช้เมธอด attack| C;

โจทย์ท้ายบท

สร้างคลาส Car ที่มี brand และ speed และเมธอด drive() ที่พิมพ์ว่ารถวิ่งที่ความเร็วเท่าใด
สร้างคลาส Student ที่มี name และ score และเมธอด show_info() ที่แสดงข้อมูลนักเรียน
สร้างคลาส BankAccount ที่มี balance และเมธอด deposit(amount) และ withdraw(amount)
สร้างเกมง่ายๆ ที่มีคลาส Player และ Enemy โดยให้ Player สามารถโจมตี Enemy
ใช้ Inheritance สร้างคลาส Rectangle และ Square โดย Square สืบทอดจาก Rectangle

บทที่ 8: การใช้ไลบรารีและโมดูลใน Python

บทที่ 8: การใช้ไลบรารีและโมดูลใน Python

ในบทนี้เราจะเรียนรู้เกี่ยวกับการใช้ไลบรารีและโมดูลต่างๆ ใน Python ที่ช่วยให้เราทำงานได้ง่ายขึ้นและเร็วขึ้น เราจะเริ่มจากโมดูลพื้นฐานอย่าง math และไลบรารีอื่นๆ ที่น่าสนใจ เช่น requests ที่ใช้สำหรับดึงข้อมูลจากเว็บไซต์

1. การใช้โมดูล `math` สำหรับการคำนวณทางคณิตศาสตร์

โมดูล math เป็นโมดูลพื้นฐานที่ช่วยในการคำนวณทางคณิตศาสตร์ เช่น การหาค่า square root, ค่า sine, cosine, และอื่นๆ

ตัวอย่างโค้ด

import math

# คำนวณ square root ของ 16
result = math.sqrt(16)
print("Square root of 16 is:", result)

# คำนวณค่า sine ของ 90 องศา
angle = math.radians(90)  # แปลงองศาเป็นเรเดียน
sine_value = math.sin(angle)
print("Sine of 90 degrees is:", sine_value)

graph TD
    A[เริ่ม] --> B[import math]
    B --> C[คำนวณ square root ของ 16]
    C --> D[แปลง 90 องศาเป็นเรเดียน]
    D --> E[คำนวณ sine ของมุม]
    E --> F[แสดงผลลัพธ์]
    F --> G[จบ]

2. การใช้ไลบรารี `requests` สำหรับการดึงข้อมูลจากเว็บไซต์

ไลบรารี requests ช่วยให้เราสามารถดึงข้อมูลจากเว็บไซต์ได้ง่ายๆ เช่น การดึงข้อมูลสภาพอากาศจาก API

ตัวอย่างโค้ด

import requests

# URL ของ API สภาพอากาศ
url = "https://api.openweathermap.org/data/2.5/weather?q=Bangkok&appid=your_api_key"

# ส่ง request ไปยัง API
response = requests.get(url)

# แสดงข้อมูลสภาพอากาศ
data = response.json()
print("สภาพอากาศในกรุงเทพฯ:", data['weather'][0]['description'])

graph TD
    A[เริ่ม] --> B[import requests]
    B --> C[กำหนด URL ของ API]
    C --> D[ส่ง request ไปยัง API]
    D --> E[รับข้อมูล JSON]
    E --> F[แสดงข้อมูลสภาพอากาศ]
    F --> G[จบ]

โจทย์ท้ายบท

คำนวณพื้นที่วงกลม: ให้เขียนโปรแกรมที่รับค่ารัศมีของวงกลมและคำนวณพื้นที่วงกลมโดยใช้โมดูล math
แปลงอุณหภูมิ: ให้เขียนโปรแกรมที่แปลงอุณหภูมิจากเซลเซียสเป็นฟาเรนไฮต์โดยใช้สูตร F = C * 9/5 + 32
ดึงข้อมูลประชากร: ให้เขียนโปรแกรมที่ดึงข้อมูลประชากรของประเทศหนึ่งๆ จาก API และแสดงผล
คำนวณค่าเฉลี่ย: ให้เขียนโปรแกรมที่รับค่าตัวเลข 5 จำนวนและคำนวณค่าเฉลี่ย
แสดงข้อมูลเวลา: ให้เขียนโปรแกรมที่แสดงเวลาปัจจุบันโดยใช้โมดูล datetime

บทที่ 9: การพัฒนาเว็บแอปพลิเคชันด้วย Python และ Flask Framework

บทที่ 9: การพัฒนาเว็บแอปพลิเคชันด้วย Python และ Flask Framework

1. แนะนำ Flask Framework

Flask เป็นเฟรมเวิร์กที่ใช้สำหรับสร้างเว็บแอปพลิเคชันด้วยภาษา Python ซึ่งมีความเรียบง่ายและเหมาะสำหรับผู้เริ่มต้น เราจะมาเรียนรู้วิธีการสร้างเว็บแอปพลิเคชันง่ายๆ ที่แสดงข้อมูล พร้อมทั้งสอนเรื่อง routing และ template

2. ติดตั้ง Flask

ก่อนอื่นเราต้องติดตั้ง Flask ก่อน โดยใช้คำสั่งต่อไปนี้ใน terminal:

pip install Flask

3. สร้างเว็บแอปพลิเคชันง่ายๆ

3.1 โครงสร้างโปรเจค

flask-app/
│
├── app.py
├── templates/
│   └── index.html
└── static/
    └── style.css

3.2 สร้างไฟล์ `app.py`

from flask import Flask, render_template

app = Flask(__name__)

@app.route('/')
def home():
    return render_template('index.html', title="หน้าแรก", message="สวัสดีเด็กๆ!")

@app.route('/about')
def about():
    return render_template('index.html', title="เกี่ยวกับเรา", message="นี่คือหน้าเกี่ยวกับเรา")

if __name__ == '__main__':
    app.run(debug=True)

3.3 สร้างไฟล์ `templates/index.html`

<!DOCTYPE html>
<html lang="th">
  <head>
    <meta charset="UTF-8" />
    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
    <title>{{ title }}</title>
    <link
      rel="stylesheet"
      href="{{ url_for('static', filename='style.css') }}"
    />
  </head>
  <body>
    <h1>{{ message }}</h1>
  </body>
</html>

3.4 สร้างไฟล์ `static/style.css`

body {
  font-family: Arial, sans-serif;
  background-color: #f0f0f0;
  text-align: center;
  padding: 50px;
}

h1 {
  color: #333;
}

4. การทำงานของ Routing

Routing คือการกำหนดเส้นทาง URL ไปยังฟังก์ชันที่เราต้องการให้ทำงาน เช่น:

/ จะเรียกฟังก์ชัน home()
/about จะเรียกฟังก์ชัน about()

5. การใช้ Template

Template เป็นไฟล์ HTML ที่เราสามารถส่งข้อมูลจาก Python ไปแสดงผลได้ โดยใช้ render_template และส่งข้อมูลผ่านตัวแปร เช่น title และ message

6. ตัวอย่างการทำงาน

graph TD
    A[ผู้ใช้เข้าถึง URL] --> B{URL}
    B -->|/| C[เรียกฟังก์ชัน home]
    B -->|/about| D[เรียกฟังก์ชัน about]
    C --> E[แสดงหน้าแรก]
    D --> F[แสดงหน้าเกี่ยวกับเรา]

7. รัน และทดสอบเว็บแอปพลิเคชัน

python app.py หรือ flask run --reload

ไปที่ http://127.0.0.1:5000/ (port อาจจะเปลี่ยนไปตามการตั้งค่าในไฟล์ app.py)

ตัวอย่าง

โค้ดตัวอย่าง flask-app.zip

โจทย์ท้ายบท

โจทย์ 1: สร้างหน้าใหม่

ให้สร้างหน้าใหม่ที่ชื่อ /contact และแสดงข้อความ "ติดต่อเรา" เมื่อผู้ใช้เข้าถึง URL นี้

โจทย์ 2: เพิ่มข้อมูลใน Template

ให้เพิ่มข้อมูลใน index.html เพื่อแสดงชื่อและอายุของเด็กๆ โดยส่งข้อมูลจาก app.py ไปยัง template

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

โจทย์ 3: เพิ่มรูปภาพ

ให้เพิ่มรูปภาพในหน้าเว็บ โดยให้รูปภาพแสดงในหน้า /about และใช้ CSS เพื่อจัดวางรูปภาพให้อยู่ตรงกลางหน้า

โจทย์ 4: สร้างแบบฟอร์ม

ให้สร้างหน้าใหม่ที่ชื่อ /form และเพิ่มแบบฟอร์มสำหรับกรอกชื่อและอายุของเด็กๆ โดยเมื่อ กดปุ่มส่งข้อมูล ให้แสดงข้อมูลที่กรอกบนหน้าเว็บ

โจทย์ 5: เพิ่มลิงก์

ให้เพิ่มลิงก์ในหน้าเว็บเพื่อให้ผู้ใช้สามารถคลิกไปยังหน้าต่างๆ ได้ เช่น จากหน้าแรกไปยังหน้าเกี่ยวกับเรา และจากหน้าเกี่ยวกับเราไปยังหน้าติดต่อเรา

บทที่ 10: การวิเคราะห์ข้อมูลและการเรียนรู้ของเครื่อง

บทที่ 10: การวิเคราะห์ข้อมูลและการเรียนรู้ของเครื่อง

ในบทนี้ เราจะเรียนรู้เกี่ยวกับการใช้ Python ในการวิเคราะห์ข้อมูลและการเรียนรู้ของเครื่อง โดยใช้ไลบรารี pandas และ scikit-learn เราจะสร้างโมเดลการเรียนรู้ของเครื่องอย่างง่าย และทดสอบการทำนาย นอกจากนี้เรายังมีโจทย์ให้ลองทำเพื่อฝึกฝนทักษะของคุณ

1. การติดตั้งไลบรารี

ก่อนเริ่มต้น เราต้องติดตั้งไลบรารีที่จำเป็นก่อน คุณสามารถติดตั้งได้โดยใช้คำสั่งต่อไปนี้ใน terminal:

pip install pandas scikit-learn

2. การนำเข้าไลบรารี

หลังจากติดตั้งไลบรารีแล้ว เราสามารถนำเข้าไลบรารีที่จำเป็นใน Python ได้ดังนี้:

import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LinearRegression
from sklearn.metrics import mean_squared_error

3. การโหลดข้อมูล

เราจะใช้ข้อมูลตัวอย่างง่ายๆ เพื่อการเรียนรู้ ในที่นี้เราจะใช้ข้อมูลเกี่ยวกับความสูงและน้ำหนักของเด็กอนุบาล

data = {
    'Height (cm)': [120, 130, 140, 150, 160],
    'Weight (kg)': [22, 28, 35, 42, 50]
}
df = pd.DataFrame(data)

4. การเตรียมข้อมูล

เราจะแบ่งข้อมูลออกเป็นสองส่วน: ข้อมูลฝึกสอน (training data) และข้อมูลทดสอบ (test data)

X = df[['Height (cm)']]
y = df['Weight (kg)']
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

5. การสร้างโมเดล

เราจะใช้โมเดล Linear Regression ใช้ในการทำนายตัวแปรเชิงปริมาณ เพื่อทำนายน้ำหนักจากความสูง

model = LinearRegression()
model.fit(X_train, y_train)

แต่ก็ยังมีอื่นๆด้วยเช่น

Decision Tree:

Decision Tree เป็นโมเดลที่ใช้การแบ่งข้อมูลออกเป็นส่วนๆ ตามเงื่อนไขของฟีเจอร์ต่างๆ เหมาะสำหรับปัญหาทั้งการจำแนกประเภท (Classification) และการทำนายค่า (Regression) ใช้ในการตัดสินใจในงานธุรกิจหรือการประเมินคุณสมบัติ เช่น การเลือกสินค้าหรือการคัดกรองลูกค้าที่มีแนวโน้มในการซื้อ

from sklearn.tree import DecisionTreeRegressor

# สร้างโมเดล Decision Tree
tree_model = DecisionTreeRegressor()
tree_model.fit(X_train, y_train)

# ทำนาย
y_pred = tree_model.predict(X_test)

Random Forest:

Random Forest เป็นโมเดลที่รวม Decision Tree หลายๆ ต้นเข้าด้วยกัน เพื่อลดโอกาส Overfitting และเพิ่มความแม่นยำ ใช้ในงานที่ต้องการลดความผิดพลาดจากการตัดสินใจเพียงครั้งเดียว เช่น การคาดการณ์ผลการเลือกตั้งหรือการทำนายโรคจากอาการต่างๆ

from sklearn.ensemble import RandomForestRegressor

# สร้างโมเดล Random Forest
forest_model = RandomForestRegressor(n_estimators=100)  # n_estimators คือจำนวนต้นไม้
forest_model.fit(X_train, y_train)

# ทำนาย
y_pred = forest_model.predict(X_test)

SVM (Support Vector Machine):

SVM เป็นโมเดลที่ใช้สำหรับการจำแนกประเภท (Classification) และการทำนายค่า (Regression) โดยการหาขอบเขตที่เหมาะสมที่สุดเพื่อแยกข้อมูลออกจากกัน ใช้ในการจำแนกประเภท เช่น การจำแนกอีเมลเป็นสแปมหรือไม่สแปม หรือการตรวจจับวัตถุในภาพ

from sklearn.svm import SVR

# สร้างโมเดล SVM
svm_model = SVR(kernel='linear')  # kernel สามารถเป็น 'linear', 'rbf', 'poly' ได้
svm_model.fit(X_train, y_train)

# ทำนาย
y_pred = svm_model.predict(X_test)

K-Nearest Neighbors (KNN):

KNN เป็นโมเดลที่ใช้หลักการ "เพื่อนบ้านใกล้ที่สุด" โดยการทำนายค่าจากค่าเฉลี่ยของจุดข้อมูลที่ใกล้เคียงที่สุด ใช้ในการจำแนกประเภทหรือทำนายค่าตัวแปร เช่น การทำนายผลการศึกษา หรือแนะนำสินค้าตามความชอบของลูกค้า

from sklearn.neighbors import KNeighborsRegressor

# สร้างโมเดล KNN
knn_model = KNeighborsRegressor(n_neighbors=5)  # n_neighbors คือจำนวนเพื่อนบ้าน
knn_model.fit(X_train, y_train)

# ทำนาย
y_pred = knn_model.predict(X_test)

Neural Networks:

Neural Networks เป็นโมเดลที่เลียนแบบการทำงานของสมองมนุษย์ โดยใช้เลเยอร์ของโหนด (Neurons) หลายชั้น เหมาะสำหรับปัญหาที่ซับซ้อน ใช้ในงานที่ซับซ้อน เช่น การจดจำใบหน้า, การแปลภาษาอัตโนมัติ

from sklearn.neural_network import MLPRegressor

# สร้างโมเดล Neural Network
nn_model = MLPRegressor(hidden_layer_sizes=(10, 10), max_iter=1000)  # hidden_layer_sizes คือจำนวนโหนดในแต่ละเลเยอร์
nn_model.fit(X_train, y_train)

# ทำนาย
y_pred = nn_model.predict(X_test)

Gradient Boosting:

Gradient Boosting เป็นโมเดลที่รวม Decision Tree หลายๆ ต้นเข้าด้วยกัน โดยการปรับปรุงความผิดพลาดทีละขั้นตอน ใช้ในการปรับปรุงโมเดลที่มีความแม่นยำน้อย เช่น การคาดการณ์พฤติกรรมของลูกค้าหรือการประเมินความเสี่ยงทางการเงิน

from sklearn.ensemble import GradientBoostingRegressor

# สร้างโมเดล Gradient Boosting
gb_model = GradientBoostingRegressor(n_estimators=100, learning_rate=0.1)
gb_model.fit(X_train, y_train)

# ทำนาย
y_pred = gb_model.predict(X_test)

6. การทดสอบโมเดล

หลังจากที่โมเดลถูกฝึกสอนแล้ว เราสามารถใช้โมเดลนี้เพื่อทำนายน้ำหนักจากความสูงได้

y_pred = model.predict(X_test)
print(y_pred)

7. การประเมินโมเดล

เราสามารถประเมินประสิทธิภาพของโมเดลโดยใช้ค่า Mean Squared Error (MSE)

MSE ต่ำ: แปลว่าโมเดลทำนายได้ใกล้เคียงกับค่าจริงมาก (ประสิทธิภาพดี)
MSE สูง: แปลว่าโมเดลทำนายได้ห่างจากค่าจริงมาก (ประสิทธิภาพไม่ดี)
ค่า MSE เป็นเพียงหนึ่งในหลายตัวชี้วัดประสิทธิภาพของโมเดล เรายังสามารถใช้ตัวชี้วัดอื่นๆ เช่น R-squared, MAE (Mean Absolute Error), หรือ RMSE (Root Mean Squared Error) ได้อีกด้วย

mse = mean_squared_error(y_test, y_pred)
print(f'Mean Squared Error: {mse}')

8. แผนภาพการทำงานของโมเดล

เราสามารถใช้ Mermaid เพื่อสร้างแผนภาพการทำงานของโมเดลได้ดังนี้:

graph TD
    A[ข้อมูลความสูงและน้ำหนัก] --> B[เตรียมข้อมูล]
    B --> C[แบ่งข้อมูลเป็น training และ test]
    C --> D[สร้างโมเดล Linear Regression]
    D --> E[ฝึกสอนโมเดล]
    E --> F[ทำนายน้ำหนัก]
    F --> G[ประเมินโมเดล]

9. ทำนายด้วยข้อมูลใหม่

new_heights = [[125], [145], [155]]  # ต้องอยู่ในรูปแบบของลิสต์ 2 มิติ

predicted_weights = model.predict(new_heights)

for height, weight in zip(new_heights, predicted_weights):
    print(f"ความสูง {height[0]} cm ทำนายน้ำหนัก {weight:.2f} kg")

ตัวอย่างโค้ด

machine-learning.zip

โจทย์ท้ายบท

โจทย์ที่ 1: ลองเปลี่ยนข้อมูลความสูงและน้ำหนักเป็นข้อมูลของคุณเอง และทำนายน้ำหนักของคุณจากความสูงที่คุณป้อนเข้าไป
โจทย์ที่ 2: ลองใช้ข้อมูลอื่นๆ เช่น อายุและน้ำหนัก เพื่อทำนายความสูง
โจทย์ที่ 3: ลองเปลี่ยนโมเดลจาก Linear Regression เป็น Decision Tree และเปรียบเทียบผลลัพธ์
โจทย์ที่ 4: ลองเพิ่มคอลัมน์ข้อมูลใหม่ เช่น เพศ และดูว่ามีผลต่อการทำนายน้ำหนักหรือไม่
โจทย์ที่ 5: ลองใช้ข้อมูลจากไฟล์ CSV แทนการป้อนข้อมูลด้วยมือ และทำนายน้ำหนักจากความสูง

บทเรียน React

React: เรียนรู้ไลบรารีสุดนิยมสำหรับสร้าง UI

React เป็นไลบรารี JavaScript สำหรับเบราว์เซอร์ที่มุ่งเน้นไปที่การลดความซับซ้อนในการพัฒนาส่วนติดต่อผู้ใช้ (UI)

เรียกว่าไลบรารีฟรอนต์เอนด์ เนื่องจาก React เกี่ยวข้องกับฟรอนต์เอนด์เท่านั้น ซึ่งหมายถึงสิ่งที่ทำงานภายในเบราว์เซอร์

ไม่เกี่ยวข้องกับด้านเซิร์ฟเวอร์หรือวิธีการเข้าถึงข้อมูลจากฐานข้อมูล ซึ่งเป็นสิ่งที่ต้องใช้ไลบรารีอื่นร่วมกับ React หรือเรียกว่าเมตาเฟรมเวิร์ก เช่น Remix และ Next.js

React โดยเนื้อแท้เป็นการแยกส่วนของ DOM API ที่เราได้เห็นในหน่วย DOM

พัฒนาโดย Facebook และเปิดตัวในปี 2013 ไดร์ฟแอพที่ใช้กันอย่างแพร่หลายที่สุดซึ่งขับเคลื่อน Facebook และ Instagram รวมถึงแอพพลิเคชันอื่นๆ อีกมากมาย

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

คุณจะพบปัญหาเบื้องต้นในการเรียนรู้ React แต่เมื่อมันเข้าใจมันแล้ว รับประกันได้เลยว่าจะเป็นหนึ่งในประสบการณ์ที่ดีที่สุดที่คุณจะมีเลย เพราะ React ทำให้สิ่งต่างๆ ง่ายขึ้นมากมายกว่าที่เคย และระบบนิเวศน์ของมันเต็มไปด้วยไลบรารีและเครื่องมือที่ยอดเยี่ยม

การใช้งาน React พื้นฐานต้องการให้คุณรู้จักชุดคุณสมบัติขนาดเล็ก และโดยทั่วไปคุณจำเป็นต้องเข้าใจแนวคิด 4 ประการเพื่อเริ่มต้น:

Components (คอมโพเนนต์)
JSX (JSX)
State (สถานะ)
Props (พร็อพส์)

เราจะสำรวจทั้งหมดนี้ในหน่วยนี้

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

สร้างโปรเจ็กต์ React ด้วย Vite

มีหลายวิธีในการสร้างโปรเจ็กต์ React แต่ขอแนะนำให้ใช้ Vite

Vite เป็นเครื่องมือที่ทันสมัยที่จัดเตรียมเซิร์ฟเวอร์สำหรับการพัฒนา มีความเร็วสูง และนักพัฒนา JS หลายคนต่างเห็นว่าเป็นตัวเลือกที่ดีที่สุด

💁‍♂️ หมายเหตุ: Vite สามารถใช้แทน create-react-app ซึ่งเป็นเครื่องมือยอดนิยมอีกตัวหนึ่งแต่ช้ากว่า คุณสามารถใช้แทนกันได้หากต้องการ แต่พบว่า Vite นั้นยอดเยี่ยมมากและสามารถใช้กับไลบรารีอื่นๆ ได้ไม่ใช่แค่ React

ก่อนอื่นคุณจำเป็นต้องติดตั้ง Node JS เพื่อเป็นตัวพึ่งพาในการใช้งาน react คล้ายกับที่คุณติดตั้ง python นั่นเองโดยไปที่ https://nodejs.org/en/download/ แล้วดาวน์โหลดเวอร์ชั่น LTS เพื่อความเสถียร์ได้เลย

alt text

จากนั้นในการสร้างโปรเจ็กต์โดยใช้ Vite ให้คุณเข้าไปที่โฟลเดอร์ที่คุณจะเก็บโปรเจ็กต์ทั้งหมดของคุณ ในกรณีจะขอใช้เป็นเป็นโฟลเดอร์ที่ชื่อว่า dev ในโฟลเดอร์หลักของผู้ใช้แล้วกัน หากคุณใช้ window คุณสามารถไปที่โฟลเดอร์เก็บโปรเจ็กต์แล้ว พิมพ์ cmd ตรงช่อง address ได้เลย

alt text

จากนั้นเรียกใช้คำสั่งต่อไปนี้

npm  create  vite@latest

alt text

เลือกชื่อสำหรับโปรเจ็กต์ นี่จะเป็นชื่อโฟลเดอร์ของโปรเจ็กต์ของคุณ ในกรณีนี้ขอใช้ชื่อเป็น test แล้วกัน

alt text

ตอนนี้คุณเลือกลูกศร ขึ้นลง เพื่อไปเลือก framework React จากนั้นกด Enter

alt text

เลือก JavaScript เพื่อความง่าย

alt text

เสร็จแล้ว!!

alt text

ตอนนี้ไปที่โฟลเดอร์โครงการที่สร้างขึ้นใหม่ ใช้คำสั่ง

cd test

จากนั้นเปิด Vs Code ด้วยคำสั่ง

code .

การเรียกใช้งานครั้งแรกจะติดตั้งสิ่งต่างๆในไฟล์ แต่ไม่ต้องห่วงเพียงแค่ใช้คำสั่งนี้

npm install

ทำการรันได้เลย!

npm run dev

เว็บแอปพลิเคชันควรจะทํางานที่ http://localhost:5173 ( แต่บางทีพอร์ตอาจแตกต่างกันไป ) แต่คุณสามรถกด ctrl + คลิกเมาส์ซ้าย ที่ตัวลิงก์ที่โปรแกรมแสดงออกมาเพื่อเปิดได้

alt text

ก็จะได้แบบนี้มา alt text

ตอนนี้คุณพร้อมที่จะทํางานกับแอปพลิเคชันนี้แล้ว!

นี่คือโฟลเดอร์แอปพลิเคชันที่เปิดใน VS Code

อย่างที่คุณเห็น Vite สร้างแอปพลิเคชันพื้นฐานให้คุณแล้วและตอนนี้คุณสามารถเปิดที่ไฟล์ src/App.jsx ได้เพื่อเริ่มลุยต่อ

alt text

ความสะดวกอย่างหนึ่งของเครื่องมืออย่าง Vite คือคุณสามารถเพิ่มไฟล์ได้ และ Vite จะจดจำไฟล์เหล่านั้นโดยอัตโนมัติ โดยไม่ต้องรีสตาร์ทแล้วรันใหม่ด้วย npm run dev เหมือนที่เราเคยทำกับโปรเจ็กต์ Node.js

และเมื่อคุณบันทึกคอมโพเนนต์ คอมโพเนนต์นั้นจะได้รับการอัปเดตในเบราว์เซอร์ของคุณโดยอัตโนมัติ

ทำให้การพัฒนาเป็นไปอย่างรวดเร็วและสนุกสนาน!

React : React คอมโพเนนต์ (Component)

React เป็นไลบรารี JavaScript ที่ใช้สำหรับสร้าง user interfaces (UIs) แบบ declarative คอมโพเนนต์เป็นส่วนประกอบพื้นฐานของแอปพลิเคชัน React แต่ละคอมโพเนนต์เป็นฟังก์ชัน JavaScript ที่รับข้อมูล (props) และส่งคืนสิ่งที่จะแสดงบนหน้าจอ (JSX)

และคุณเพิ่งได้เห็นวิธีการสร้างแอปพลิเคชัน React แรกของคุณ.

แอปพลิเคชั่นนี้มาพร้อมกับไฟล์หลายชุดที่ทําสิ่งต่างๆ ส่วนใหญ่เกี่ยวข้องกับการกําหนดค่าต่างๆ แต่ว่ามีไฟล์หนึ่งไฟล์ที่โดดเด่นก็คือ: App.jsx

App.jsx จะเป็น react คอมโพเนนต์แรกของคุณที่คุณจะได้พบ โค้ดจะเป็นในลักษณะนี้

import { useState } from "react";
import reactLogo from "./assets/react.svg";
import "./App.css";

function App() {
  const [count, setCount] = useState(0);

  return (
    <div className="App">
      <div>
        <a href="https://vitejs.dev" target="_blank">
          <img src="/vite.svg" className="logo" alt="Vite logo" />
        </a>
        <a href="https://reactjs.org" target="_blank">
          <img src={reactLogo} className="logo react" alt="React logo" />
        </a>
      </div>
      <h1>Vite + React</h1>
      <div className="card">
        <button onClick={() => setCount((count) => count + 1)}>
          count is {count}
        </button>
        <p>
          Edit <code>src/App.jsx</code> and save to test HMR
        </p>
      </div>
      <p className="read-the-docs">
        Click on the Vite and React logos to learn more
      </p>
    </div>
  );
}

export default App;

แต่อย่าพึ่งตกใจและกลัวไปแค่เอามาแสดงให้ดูเฉยๆ 😎

เอาหล่ะ แอปพลิเคชันที่สร้างขึ้นโดยใช้ React หรือหนึ่งในเฟรมเวิร์ก frontend ยอดนิยมอันอื่นๆ เช่น Vue และ Svelte เหล่านี้ถูกสร้างขึ้นโดยใช้คอมโพเนนต์หลายสิบรายการ

แต่เพื่อให้เริ่มต้นในการวิเคราะห์คอมโพเนนต์แรกนี้ง่ายขึ้น เราจะทําให้โค้ดนี้ง่ายขึ้นดังนี้:

function App() {
  return; /* ทำอะไรบางอย่าง */
}

คุณจะเห็นว่าเรากําหนดฟังก์ชั่นที่เรียกว่า App

App นั้นเป็นฟังก์ชั่นที่ติดตัวมาและตัวอย่างที่โปรแกรมให้มาทำการ return อะไรที่มันดูแปลกๆ

ดูเหมือนว่าจะทั้ง HTML แล้วก็มี JavaScript ฝังอยู่ในนั้นด้วย

เพื่อง่ายขึ้นเราจะทำเป็นแบบนี้กันเริ่ม:

function App() {
  return <p>test</p>;
}

นั่นคือ JSX ซึ่งเป็นภาษาพิเศษที่เราใช้ในการสร้างเอาต์พุตของคอมโพเนนต์

และเราจะพูดถึง JSX เพิ่มเติมในหัวข้อถัดไป

และที่จริงแล้วคอมโพเนนต์ก็คือฟังก์ชัน ดังนั้นคุณสามารถใช้ Arrow Function (ฟังก์ชันลูกศร) เพื่อกำหนดมันได้แบบนี้:

const App = () => {
  return <p>test</p>
}

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

นอกเหนือจากการกำหนด JSX เพื่อใช้ return แล้วคอมโพเนนต์ยังมีลักษณะอื่นๆ อีกหลายประการ

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

คอมโพเนนต์ ยังสามารถรับข้อมูลจากคอมโพเนนต์อื่นๆ ได้ ในกรณีนี้ ที่เราพูดถึงตือ พร็อพส์ (props)

อย่ากังวลไป เราจะพาเข้าไปดูรายละเอียดของคำศัพท์เหล่านั้นทั้งหมดทั้ง (JSX, State และ Props) ในเร็วๆนี้

React : รู้เบื้องต้นเกี่ยวกับ JSX

เราจะไม่สามารถพูดถึง React ได้เลยหากไม่อธิบาย JSX ก่อน

คุณได้พบกับ React คอมโพเนนต์ แรกของคุณไปแล้ว ซึ่งเป็น คอมโพเนนต์ ของแอปที่กำหนดไว้ในแอปพลิเคชันเริ่มต้นที่เราสร้างโดยใช้ Vite

โค้ดของมันคือ:

import { useState } from "react";
import reactLogo from "./assets/react.svg";
import "./App.css";

function App() {
  const [count, setCount] = useState(0);

  return (
    <div className="App">
      <div>
        <a href="https://vitejs.dev" target="_blank">
          <img src="/vite.svg" className="logo" alt="Vite logo" />
        </a>
        <a href="https://reactjs.org" target="_blank">
          <img src={reactLogo} className="logo react" alt="React logo" />
        </a>
      </div>
      <h1>Vite + React</h1>
      <div className="card">
        <button onClick={() => setCount((count) => count + 1)}>
          count is {count}
        </button>
        <p>
          Edit <code>src/App.jsx</code> and save to test HMR
        </p>
      </div>
      <p className="read-the-docs">
        Click on the Vite and React logos to learn more
      </p>
    </div>
  );
}

export default App;

ก่อนหน้านี้เราได้ละเลยทุกสิ่งที่อยู่ในคำสั่ง return และในส่วนนี้ เราจะพูดถึงมัน

เราจะเรียก JSX ทุกอย่างที่อยู่ภายใน return (..) มาให้แบบนี้ ว่าอะไรคือสิ่งที่เราเรียกว่า JSX กันแน่

<div className="App">
  <div>
    <a href="https://vitejs.dev" target="_blank">
      <img src="/vite.svg" className="logo" alt="Vite logo" />
    </a>
    <a href="https://reactjs.org" target="_blank">
      <img src={reactLogo} className="logo react" alt="React logo" />
    </a>
  </div>
  <h1>Vite + React</h1>
  <div className="card">
    <button onClick={() => setCount((count) => count + 1)}>
      count is {count}
    </button>
    <p>
      Edit <code>src/App.jsx</code> and save to test HMR
    </p>
  </div>
  <p className="read-the-docs">
    Click on the Vite and React logos to learn more
  </p>
</div>

ลักษณะดูเหมือน HTML แต่ก็ไม่ใช่ HTML จริงๆ เพราะมันแตกต่างออกไปเล็กน้อย

และมันก็แปลกนิดหน่อยที่จะมีโค้ด HTML ลักษณะนี้อยู่ในไฟล์ JavaScript นี่ดูไม่เหมือน JavaScript เลย!

ภายใต้หลังคาของ React จะทำการประมวลผล JSX จากนั้นก็จะแปลงไปเป็น JavaScript ที่เบราว์เซอร์สามารถเข้าใจได้

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

React ให้เราเราแบบนี้ก็ด้วยเหตุผลเดียวคือ การสร้างอินเทอร์เฟซ UI โดยใช้ JSX นั้นง่ายกว่า

เมื่อคุณจะคุ้นเคยกับมันมากขึ้นแล้วแน่นอนว่า

ในหัวข้อถัดไป เราจะพูดถึงวิธีที่ JSX ช่วยให้คุณสร้าง UI ได้อย่างง่ายดาย จากนั้นเราจะมาดูความแตกต่างกับ HTML ปกติ ที่คุณต้องรู้กัน

React: ความแตกต่างระหว่าง JSX และ HTML

JSX ดูเหมือน HTML แต่ไม่ใช่

ในส่วนนี้ อยากจะแนะนำให้คุณรู้จักกับสิ่งที่สำคัญที่สุดที่คุณต้องจำไว้เมื่อใช้ JSX

ความแตกต่างประการหนึ่งอาจค่อนข้างชัดเจนหากคุณดูที่ component ของแอป JSX: มีแอตทริบิวต์แปลกๆ ที่เรียกว่า className

ใน HTML เราใช้เป็นแอตทริบิวต์ class เป็นคุณลักษณะที่ใช้กันอย่างแพร่หลายมากที่สุด ด้วยเหตุผลหลายประการ แต่หนึ่งในเหตุผลเหล่านั้นคือการทำ CSS แอตทริบิวต์ class ช่วยให้เราสามารถจัดรูปแบบและแต่งองค์ประกอบของ HTML ให้มีความสวยงามได้อย่างง่ายดาย และการใช้เฟรมเวิร์ก CSS เช่น Tailwind แอตทริบิวต์นี้จึงแทบจะเป็นศูนย์กลางของกระบวนการออกแบบอินเทอร์เฟซผู้ใช้เลย

แต่มีปัญหาเกิดขึ้นในขณะที่เรากำลังเขียนโค้ด UI นี้ในไฟล์ JavaScript และ class ในภาษาการเขียนโปรแกรม JavaScript เป็นคำสงวน (keyword) ซะงั้นไป ซึ่งหมายความว่าเราไม่สามารถใช้คำสงวนนี้ตามที่เราต้องการได้ เพราะมันคือการใช้กำหนดคลาสใน JavaScript และผู้สร้าง React เลยต้องเลือกชื่ออื่นแทน

นั่นคือเลยเป็นเหตุผลที่ต้องลงเอยด้วย className แทนที่จะเป็น class ธรรมดา

คุณต้องจำเป็นต้องจำสิ่งนี้ไว้ โดยเฉพาะเมื่อคุณต้องการคัดลอก/วาง HTML เดิมที่มีอยู่แล้ว

React จะพยายามอย่างดีที่สุดเพื่อให้แน่ใจว่าสิ่งต่าง ๆ จะไม่เสียหาย แต่ว่านะอาจจะทำให้เกิดคำเตือนมากมายมหาศาล ในเครื่องมือสำหรับนักพัฒนาได้

เพราะเรื่องแบบนี้เกิดขึ้นบ่อยที่สุด

ความแตกต่างที่สำคัญอีกประการระหว่าง JSX และ HTML ก็คือ HTML นั้นค่อยข้างจะผ่อนคลายมาก ซึ่งเราอาจจะสามารถพูดได้ แม้ว่าคุณจะมีข้อผิดพลาดในรูปแบบไวยากรณ์ หรือเจ้าปิดแท็กผิดไป หรือคุณปิดแท็กไม่ตรงกัน เบราว์เซอร์ก็จะพยายามอย่างเต็มที่ในการตีความหมายของ HTML โดยไม่ทำให้เกิดความเสียหายอะไร

ถือได้ว่าเป็นการช่วยสำหรับผู้เริ่มต้นเป็นอย่างมากเลย

แต่ว่า JSX ไม่ใช่ผู้ใจขนาดนั้น หากว่าคุณลืมปิดแท็กแล้วหล่ะก็ คุณจะมีข้อความแสดงข้อผิดพลาดที่ชัดเจน

โดยปกติแล้ว React จะให้ข้อความแสดงข้อผิดพลาดที่ดี และให้ข้อมูลซึ่งจะนำคุณไปในทิศทางที่ถูกต้องในการแก้ไขปัญหา

ข้อแตกต่างที่สำคัญอีกประการระหว่าง JSX และ HTML ก็คือใน JSX เราสามารถฝัง JavaScript ได้นั้นเอง

เรามาพูดถึงเรื่องนี้ในส่วนถัดไปแล้วกัน

การฝัง JavaScript ใน JSX

หนึ่งในคุณสมบัติที่ดีที่สุดของ React คือเราสามารถฝัง JavaScript ลงใน JSX ได้อย่างง่ายดายนั่นแหละนะ

เฟรมเวิร์กส่วนหน้า (Front-end) อื่นๆ เช่น Angular และ Vue มีวิธีเฉพาะของตนเองในการพิมพ์ค่า JavaScript ลงในเทมเพลตหรือดำเนินการต่างๆ เช่น วนซ้ำ

แต่ React ไม่ได้เพิ่มสิ่งใหม่อะไรเข้ามา แต่ว่าจะช่วยให้เราใช้ JavaScript ใน JSX แทนได้โดยใช้วงเล็บปีกกา { }

ตัวอย่างแรกของสิ่งนี้ที่ จะแสดงให้คุณเห็นนั้นมาจาก Component App มาดูกันโดจตรงเลย

เรานำเข้าไฟล์โลโก้ SVG โดยใช้

import reactLogo from "./assets/react.svg";

จากนั้นใน JSX เรากำหนดให้ไฟล์ SVG นี้เป็นกับค่าของแอตทริบิวต์ src ของแท็ก img:

<img src={reactLogo} className="logo react" alt="React logo" />

ลองอีกสักตัวอย่างนึง สมมติว่า Component App มีตัวแปรที่ชื่อว่า message

เราสามารถเอาค่าของตัวแปรนี้ออกมาแสดงใน JSX ได้โดยการเพิ่ม {message} ที่ใดก็ได้ใน JSX

import "./App.css";

function App() {
  const message = "Hello!";

  return (
    <div className="App">
            <h1>{message}</h1>   {" "}
    </div>
  );
}

export default App;

แล้วลองรันดู! คุณน่าจะเห็นข้อความ Hello! ที่เป็นข้อมูลของ message อยู่บนเบราว์เซอร์

alt text

ภายในวงเล็บปีกกา { } เราสามารถเพิ่มคำสั่ง JavaScript ใดๆลงไปได้หมด

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

{
  message === "Hello!" ? 'The message was "Hello!"' : message;
}

แบบนี้:

function App() {
  const message = "Hello!";

  return (
    <div className="App">
           {" "}
      <h1>{message === "Hello!" ? 'The message was "Hello!"' : message}</h1> 
       {" "}
    </div>
  );
}

export default App;

นี่คือผลลัพธ์:

หากคุณเปลี่ยนเนื้อหาของตัวแปร message จากนั้น JSX ก็จะแสดงค่าอย่างอื่น:

function App() {
  const message = "Test";

  return (
    <div className="App">
           {" "}
      <h1>{message === "Hello!" ? 'The message was "Hello!"' : message}</h1> 
       {" "}
    </div>
  );
}

export default App;

alt text

React: การจัดการเหตุการณ์ (event) ของผู้ใช้

React มอบวิธีง่ายๆ ในการจัดการเหตุการณ์ที่เกิดจากเหตุการณ์ DOM (Document Object Model) เช่น การคลิก เหตุการณ์ในแบบฟอร์ม และอื่นๆ

alt text

เรามาพูดถึงเหตุการณ์การคลิกซึ่งค่อนข้างเข้าใจง่าย

คุณสามารถใช้แอตทริบิวต์ onClick กับองค์ประกอบ (element) JSX ใดก็ได้:

<button
  onClick={(event) => {
    /* จัดการเหตุการณ์ */
  }}
>
  Click here
</button>

เมื่อคลิกองค์ประกอบ (element) ฟังก์ชันที่ส่งผ่านไปยังแอตทริบิวต์ onClick จะเริ่มทำงานทันที

คุณยังสามารถกำหนดฟังก์ชันในการจัดการหลังคลิกภายนอก JSX ได้:

const handleClickEvent = (event) => {
  /* handle the event */
};

function App() {
  return <button onClick={handleClickEvent}>Click here</button>;
}

เมื่อเหตุการณ์คลิกเกิดขึ้นที่ปุ่ม โดย React จะเรียกใช้งานฟังก์ชัน handleClickEvent

React รองรับเหตุการณ์หลายประเภท เช่น onKeyUp, onFocus,onChange, onMouseDown, onSubmit และอื่นๆ อีกมากมาย

React: การจัดการ state

คอมโพเนนต์ React ทุกตัวสามารถมี state (สถานะ) ของตัวเองได้

state หมายถึงอะไร? state คือชุดข้อมูลที่จัดการโดย คอมโพเนนต์

ให้ลองนึกถึง form ดู ว่าแต่ละองค์ประกอบ input ของ form แต่ละตัวนั้นมีหน้าที่รับผิดชอบในการจัดการstate สิ่งที่ผู้ใช้งานเขียนอยู่ข้างในนั้น

และ button (ปุ่ม) มีหน้าที่รับผิดชอบในการรับทราบว่ามีการคลิกหรือเปล่าอะไรแบบนี้

ส่วนเองก็ลิงก์มีหน้าที่รับผิดชอบว่าและตรวจสอบว่าเมาส์วางอยู่บนลิงก์นั้นๆหรือเปล่า

ใน React หรือในเฟรมเวิร์ก/ไลบรารี ที่ใช้คอมโพเนนต์อื่นๆ แอปพลิเคชันทั้งหมดของเราจะอิงและใช้งาน state คอมโพเนนต์ โดยส่วนใหญ่

เราสามารถจัดการstate ทั่วไปได้โดยใช้ useState ที่ React มอบให้มาได้ แต่ในทางเทคนิคแล้วมันคือ hook (คุณไม่จำเป็นต้องรู้รายละเอียดของhookในตอนนี้เท่าไหร่หรอก คิดซะว่ามีมันอยู่ก็พอ)

คุณสามารถ import useState จาก React ด้วยวิธีนี้:

import { useState } from "react";

เมื่อเรียก useState() สิ่งที่คุณจะได้รับกลับมาก็คือ

ตัวแปร state ใหม่
และฟังก์ชันที่เราสามารถเรียกใช้เพื่อเปลี่ยนค่าของมันได้

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

นี่คือตัวอย่างวิธีใช้ useState():

const [count, setCount] = useState(0);

สิ่งนี้สำคัญ: เราไม่สามารถเปลี่ยนค่าของตัวแปรstateได้โดยตรง จากการทำ count++ หรือ count = count + 1

เราต้องเรียกใช้ฟังก์ชันที่ใช้ในการแก้ไขข้อมูลของมันนั่นก็คือ setCount() เท่านั้น

ไม่อย่างนั้น คอมโพเนนต์ React จะไม่อัปเดต UI การเรียกฟังก์ชันนั้นจะเป็นการบอก React ว่าstateของคอมโพเนนต์นี้มีการเปลี่ยนแปลงนะ

แต่ไวยากรณ์ค่อนข้างแปลกใช่ไหม? เนื่องจาก useState() ส่งคืนอาร์เรย์กลับมา ใช้อาร์เรย์ในการรับเพื่อเข้าถึงแต่ละรายการ เช่นนี้: const [count, setCount] = useState(0)

นี่เป็นตัวอย่างโดยรวม:

import { useState } from "react";

const Counter = () => {
  const [count, setCount] = useState(0);

  return (
    <div>
      <p>คลิกไป {count} ครั้ง</p>
      <button onClick={() => setCount(count + 1)}>คลิกที่นี่</button>
    </div>
  );
};

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

const [count, setCount] = useState(0);
const [name, setName] = useState("John");
const [fruits, setFruits] = useState(["Apple", "Banana", "Orange"]);
const [persons, setPersons] = useState([
  { name: "Samai", score: 10 },
  { name: "Danai", score: 8 },
  { name: "Saman", score: 7 },
]);

React: Component props พร็อพของคอมโพเนนต์

เราเรียก props เป็นค่าเริ่มต้นที่ส่งไปยังคอมโพเนนต์

ทำการสร้างคอมโพเนนต์ WelcomeMessage ได้ในลักษณะดังนี้:

function WelcomeMessage() {
  return <p>Welcome!</p>;
}

หรือแบบนี้ก็ได้

const WelcomeMessage = () => {
  return <p>Welcome!</p>;
};

และเราจะใช้งานได้ด้วย

<WelcomeMessage />

ซึ่งคอมโพเนนต์นี้ไม่มีค่าเริ่มต้นอะไรและมันก็ไม่มี props ด้วยเหมือนกัน แต่ว่า props สามารถส่งโดยมันเข้ามาได้โดยผ่าน attributes ใน JSX ได้ในลักษณะแบบนี้:

<WelcomeMessage myprop={"somevalue"} />

และภายในคอมโพเนนต์ตรงสร้างที่สร้างขึ้นเป็นฟังก์ชันเราจะรับpropsเป็นอาร์กิวเมนต์แบบนี้:

function WelcomeMessage(props) {
  return <p>Welcome!</p>;
}

หรือแบบนี้ก็ได้

const WelcomeMessage = (props) => {
  return <p>Welcome!</p>;
};

แต่ว่าใน jsx เราจะต้องรับเข้ามาโดยจะใช้เป็น object destructuring เพื่อรับpropsตามชื่อนั้นๆ:

function WelcomeMessage({ props }) {
  return <p>Welcome!</p>;
}

หรือแบบนี้ก็ได้

const WelcomeMessage = ({ props }) => {
  return <p>Welcome!</p>;
};

ตอนนี้ myprop เป็นหนึ่งในpropsที่มีอยู่ในprops object เช่นนี้: { myprop: 'test' } การใช้ syntax นี้จะเป็นการแยกเฉพาะ myprop ออกมา

ตอนนี้เรามี prop เรียบร้อยแล้ว เราก็จะสามารถใช้มันภายในส่วนของคอมโพเนนต์ได้ เช่น เราสามารถพิมพ์ค่าของมันลงใน JSX ได้ในลักษณะนี้:

function WelcomeMessage({ myprop }) {
  return <p>{myprop}</p>;
}

หรือแบบนี้ก็ได้

const WelcomeMessage = ({ props }) => {
  return <p>{myprop}</p>;
};

วงเล็บปีกกาในที่นี้มีความหมายได้หลากหลาย แต่ในกรณีของอาร์กิวเมนต์ฟังก์ชัน วงเล็บปีกกาจะใช้เป็นส่วนหนึ่งของ syntax object destructuring

จากนั้นเราสามารถใช้มันในการกำหนดบล็อกโค้ดฟังก์ชันได้ และในท้ายที่สุดใน JSX สามารถใช้มันเมื่อเราต้องการค่าอะไรก็ตามใน JavaScript ออกมาแสดงผลได้

การส่งผ่านpropsไปยังคอมโพเนนต์ เป็นวิธีที่ดีในการส่งผ่านค่าต่างๆ ภายในแอปพลิเคชันของคุณ

นอกจากนี้เรายังสามารถส่งฟังก์ชันที่ผ่านpropsได้อีกด้วยดังนั้นคอมโพเนนต์ลูกจึงสามารถเรียกใช้ฟังก์ชันในคอมโพเนนต์แม่ได้

propsพิเศษที่ชื่อ children จะค่าของข้อมูลที่ถูกส่งเข้ามาในช่องระหว่างแท็กเปิดและแท็กปิดของคอมโพเนนต์ เช่น:

<WelcomeMessage>ข้อความอะไรสักอย่าง</WelcomeMessage>

ในกรณีนี้ ภายใน WelcomeMessage เราสามารถเข้าถึงค่าข้อมูลของคำว่า ข้อความอะไรสักอย่าง โดยใช้ propsพิเศษที่ชื่อว่า children ได้:

function WelcomeMessage({ children }) {
  return <p>{children}</p>;
}

หรือแบบนี้ก็ได้

const WelcomeMessage = ({ children }) => {
  return <p>{children}</p>;
};

React: Data flow (การไหลของข้อมูล)

ในแอปพลิเคชัน React การส่งข้อมูลจากอคอมโพเนนต์หลักไปยังคอมโพเนนต์ลูก โดย props ดังที่เราเห็นในส่วนก่อนหน้านี้แบบนี้:

<WelcomeMessage name={"Flavio"} />

หากคุณส่งฟังก์ชันไปยังคอมโพเนนต์ลูก คุณยังสามารถเปลี่ยนตัวแปร state ที่ถูกกำหนดขึ้นจากคอมโพเนนต์หลักจากคอมโพเนนต์ลูกได้เหมือนกันด้วยลักษณะแบบนี้:

<Counter setCount={setCount} count={count} />

สิ่งนี้มีประโยชน์เมื่อคอมโพเนนต์หลักทำหน้าที่ในการจัดการตัวแปร state หรือจะใช้ตัวแปร state ด้วยเหมือนกัน

ภายในคอมโพเนนต์ Counter ตอนนี้เราสามารถเรียก setCount ได้จาก prop และเรียกใช้เพื่ออัปเดตสถานะของ count ที่แสดงอยู่ในคอมโพเนนต์หลักได้:

const Counter = ({ count, setCount }) => {
  return (
    <div>
      <p>คุณคลิกไปแล้ว {count} ครั้ง</p>
      <button
        onClick={() => {
          setCount(count + 1);
        }}
      >
        คลิกที่นี่
      </button>
    </div>
  );
};

นี่คือตัวอย่างแบบเต็ม:

import { useState } from "react";

const Counter = ({ count, setCount }) => {
  return (
    <div>
      <button onClick={() => setCount(count + 1)}>คลิกที่นี่</button>
    </div>
  );
};

function App() {
  const [count, setCount] = useState(0);

  return (
    <div>
      <p>คุณคลิกไปแล้ว {count} ครั้ง</p>
      <Counter setCount={setCount} count={count} />
    </div>
  );
}

export default App;

คุณจำเป็นต้องรู้ว่ามีวิธีการจัดการข้อมูลขั้นสูงกว่านี้

เริ่มต้นจาก Context API แต่ยังรวมถึงไลบรารีเช่น Jotai และ Easy Peasy

บทสอน Flask

Flask

Flask เป็นเฟรมเวิร์กไมโครเว็บที่เขียนด้วยภาษาไพธอน จัดเป็นไมโครเฟรมเวิร์กเนื่องจากไม่ต้องการเครื่องมือหรือไลบรารีเฉพาะ ไม่มีชั้นนามธรรมของฐานข้อมูล การตรวจสอบแบบฟอร์ม หรือส่วนประกอบอื่นใดที่ไลบรารีบุคคลที่สามที่มีอยู่ก่อนมีฟังก์ชันทั่วไป อย่างไรก็ตาม Flask ยังคงให้ฟังก์ชันการทำงานพื้นฐานที่จำเป็นในการสร้างเว็บแอปพลิเคชัน เช่น การจัดการ URL การประมวลผลอินพุตของผู้ใช้ และการแสดงผล HTML

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

คุณสมบัติของ Flask ที่สำคัญ ได้แก่

ใช้งานง่ายและเรียนรู้ได้ง่าย มีประสิทธิภาพสูงและปรับขนาดได้ รองรับภาษาไพธอนเวอร์ชัน 3.6 ขึ้นไป รองรับการเขียนโค้ดในรูปแบบ Pythonic รองรับการเขียนโค้ดแบบ modular รองรับการเขียนโค้ดแบบ testing ตัวอย่างการใช้งาน Flask เช่น การสร้างเว็บแอปพลิเคชันสำหรับแสดงข้อมูล การสร้างเว็บแอปพลิเคชันสำหรับรับและประมวลผลข้อมูลผู้ใช้ การสร้างเว็บแอปพลิเคชันสำหรับทำเว็บไซต์อีคอมเมิร์ซ เป็นต้น

หากคุณต้องการสร้างเว็บแอปพลิเคชันด้วยภาษาไพธอน Flask เป็นตัวเลือกที่คุ้มค่าแก่การพิจารณา

Flask : การติดตั้ง Flask

ในบทนี้เราจะเริ่มต้นด้วยการติดตั้ง Flask เพื่อใช้ในการสร้างเว็บไซต์ของเรา

ก่อนอื่นทำการสร้างโฟลเดอร์ไว้เก็บโปรเจ็คกันก่อนจะเอาไว้ที่ไหนก็ได้จากนั้นเปิดมันแล้วใส่ไว้ในโปรแกรม VSCode ให้เรียบร้อย

alt text

จากนั้นเปิด terminal ขึ้นมาโดยกดปุ่ม ctrl+j หรือ command+j

alt text

การติดตั้ง Flask ก่อนที่เราจะเริ่มต้นใช้งาน Flask เราจำเป็นต้องติดตั้ง Python ก่อน โดย Flask สามารถทำงานได้บน Python เวอร์ชัน 2.7 หรือ 3.5 หรือเวอร์ชันใหม่กว่า ดังนั้นเราควรตรวจสอบเวอร์ชันของ Python ที่เราใช้งานอยู่ก่อนที่จะติดตั้ง Flask โดยทำการเขียนที่ terminal ว่า

python --version

หรือ

python3 --version

alt text

เมื่อเราตรวจสอบและติดตั้ง Python เรียบร้อยแล้ว เราสามารถติดตั้ง Flask ได้โดยใช้คำสั่งต่อไปนี้ในterminal:

pip install flask

หรือ

pip3 install flask

alt text

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

เมื่อการติดตั้งเสร็จสมบูรณ์ เราสามารถทดสอบการติดตั้ง Flask ได้โดยการเขียนโค้ดตัวอย่างง่ายๆโดยสร้างไฟล์ app.py ขึ้นมาแล้วเขียนตามโค้ดด้านล่าง:

from flask import Flask

app = Flask(__name__)

@app.route('/')
def hello():
    return 'สวัสดี Flask!'

if __name__ == '__main__':
    app.run()

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

เพื่อรันแอปพลิเคชัน Flask ของเรา เราสามารถใช้คำสั่งต่อไปนี้ในterminal:

python app.py

หรือ

python3 app.py

เมื่อรันคำสั่งนี้ เราจะเห็นข้อความ "Running on http://127.0.0.1:5000" ใน terminal ซึ่งหมายถึงแอปพลิเคชันของเรากำลังทำงานบนเซิร์ฟเวอร์ที่พอร์ต 5000

เราสามารถเข้าถึงแอปพลิเคชันของเราได้โดยใช้ URL ในเว็บเบราว์เซอร์โดยไปที่ลิงก์ http://127.0.0.1:5000 หรือกดปุ่ม ctrl+click และเราจะเห็นข้อความ "สวัสดี Flask!" ที่แสดงอยู่บนหน้าเว็บ

ปล. ถ้าหากขึ้น ModuleNotFoundError: No module named 'flask' แสดงว่ายังไม่ได้ติดตั้ง Flask ให้ทำการติดตั้งก่อนค่อยรันอีกรอบ

นี่คือขั้นตอนการติดตั้ง Flask เพื่อเริ่มต้นการสร้างเว็บไซต์ของเรา ในบทถัดไป เราจะเริ่มสร้างโครงสร้างของเว็บไซต์และใช้งานเทมเพลตกัน

คุณสามารถอ่านเนื้อหาเพิ่มเติมเกี่ยวกับ Flask และคำสั่งที่ใช้ในการใช้งานได้ในเอกสารอ้างอิง Flask ที่อยู่ในเว็บไซต์ของ Flask ได้ที่นี่ (https://flask.palletsprojects.com/)[https://flask.palletsprojects.com/] แต่ถ้าขี้เกียจอ่านก็ค่อยทำตามทีละขั้นตอนแล้วกันนะ

การสร้างโครงสร้างของเว็บไซต์

ในส่วนนี้เราจะมาเรียนรู้เกี่ยวกับการสร้างโครงสร้างของเว็บไซต์ด้วย Flask กัน การสร้างโครงสร้างของเว็บไซต์เป็นขั้นตอนสำคัญที่จะช่วยให้เราสามารถพัฒนาเว็บไซต์ได้อย่างมีระบบและเป็นระเบียบ โดยเราจะมีการแบ่งโครงสร้างของเว็บไซต์ออกเป็นส่วนย่อยๆ ที่มีหน้าที่แตกต่างกัน ซึ่งจะทำให้เราสามารถจัดการและพัฒนาแต่ละส่วนได้อย่างมีประสิทธิภาพ ภาพจาก https://www.infidigit.com/wp-content/uploads/2019/11/website-structure-1.jpg

โครงสร้างพื้นฐานของ Flask

เมื่อเราเริ่มต้นสร้างเว็บไซต์ด้วย Flask เราจะต้องสร้างโครงสร้างพื้นฐานของโปรเจคก่อน โครงสร้างพื้นฐานนี้ประกอบด้วยไฟล์และโฟลเดอร์ต่างๆ ที่จำเป็นสำหรับการทำงานของเว็บไซต์ เราสามารถสร้างโครงสร้างพื้นฐานดังนี้:

สร้างโฟลเดอร์สำหรับโปรเจค:

เริ่มต้นด้วยการสร้างโฟลเดอร์สำหรับเก็บไฟล์ของโปรเจค เช่น my_website ซึ่งเราสร้างไปแล้วนั้นเองก็คือโฟลเดอร์ที่เก็บไฟล์ app.py ไว้นั่นเอง

สร้างไฟล์ app.py:

ไฟล์นี้จะเป็นจุดเริ่มต้นของการทำงานของเว็บไซต์ เราจะ import Flask และสร้าง instance ของ Flask ขึ้นมา เพื่อใช้ในการกำหนดเส้นทางและการทำงานของแต่ละหน้า

สร้างโฟลเดอร์ templates:

เป็นโฟลเดอร์ที่ใช้เก็บไฟล์เทมเพลตของเว็บไซต์ เราสามารถสร้างไฟล์ HTML และใช้งานเทมเพลตใน Flask ได้ในโฟลเดอร์นี้

สร้างโฟลเดอร์ static:

เป็นโฟลเดอร์ที่ใช้เก็บไฟล์สถิติ เช่น CSS, JavaScript, รูปภาพ เราสามารถเรียกใช้ไฟล์เหล่านี้ในเว็บไซต์ของเราได้

ลงมือสร้างได้เลยให้มีลักษณะดังภาพนี้: alt text

ปล. โฟลเดอร์ env ในภาพไม่ต้องสร้างตามเพราะเป็น environment ใช้เป็นที่เก็บ package ที่ติดตั้งเช่น Flask สำหรับผู้เริ่มต้นไม่แนะนำแต่หากต้องการศึกษาเพิ่มเติมได้ที่ https://docs.python.org/3/library/venv.html

การแบ่งโครงสร้างของเว็บไซต์

เมื่อเราได้สร้างโครงสร้างพื้นฐานของเว็บไซต์แล้ว เราสามารถแบ่งโครงสร้างของเว็บไซต์ออกเป็นส่วนย่อยๆ ที่มีหน้าที่แตกต่างกันได้ เพื่อให้ง่ายต่อการจัดการและพัฒนาเว็บไซต์ในอนาคต ตัวอย่างของโครงสร้างเว็บไซต์ที่เราสามารถแบ่งออกได้คือ:

ส่วนของหน้าแสดงข้อมูล: เป็นส่วนที่ใช้ในการแสดงข้อมูลต่างๆ ที่เราต้องการให้ผู้ใช้เห็น เช่น หน้าแสดงรายการสินค้า, หน้าแสดงรายละเอียดสินค้า เป็นต้น

ส่วนของรูปแบบ CSS: เป็นส่วนที่ใช้ในการกำหนดรูปแบบและสไตล์ของเว็บไซต์ เราสามารถใช้ CSS เพื่อปรับแต่งสีพื้นหลัง, ขนาดตัวอักษร, และการจัดวางขององค์ประกอบต่างๆ ในเว็บไซต์

ส่วนของการใช้งาน JavaScript: เป็นส่วนที่ใช้ในการเพิ่มความสามารถและประสิทธิภาพให้กับเว็บไซต์ เช่น การตรวจสอบข้อมูลก่อนส่งฟอร์ม, การแสดงผลแบบ Real-time เป็นต้น

เช่นในลักษณะแบบนี้:

├── app.py
├── static
│   ├── css
│   │   └── style.css
│   └── js
│       └── app.js
└── templates
    ├── index.html
    ├── product_list.html
    └── product_detail.html

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

Flask : การใช้งานเทมเพลต (Templates)

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

รูปแบบของเทมเพลต (Templates)

เทมเพลตใน Flask คือไฟล์ HTML ที่ใช้สร้างหน้าเว็บของเรา โดยเราสามารถใส่โค้ด Python ลงในไฟล์ HTML ได้นั่นเองเพื่อให้เราสามารถแสดงผลข้อมูลได้ตามต้องการ

เราสามารถใช้เทมเพลตใน Flask ได้โดยใช้โมดูล render_template ที่มีอยู่ใน Flask ซึ่งจะช่วยให้เราสามารถแสดงผลเทมเพลตได้ในหน้าเว็บของเรา

ตัวอย่างการใช้เทมเพลตใน Flask ในapp.py:

from flask import Flask

app = Flask(__name__)

@app.route('/')
def hello():
    return 'สวัสดี Flask!'

if __name__ == '__main__':
    app.run()

เปลี่ยนเป็น

from flask import Flask, render_template

app = Flask(__name__)

@app.route('/')
def hello():
    return 'สวัสดี Flask!'

if __name__ == '__main__':
    app.run()

จากนั้นทำการสร้างไฟล์ index.html ไว้ในโฟลเดอร์ templates ในลักษณะนี้: alt text

จากนั้นเขียนโค้ด HTML แบบง่ายในไฟล์ index.html ดังนี้:

<!DOCTYPE html>
<html lang="en">
  <head>
    <meta charset="UTF-8" />
    <title>สวัสดี</title>
  </head>
  <body>
    <h1>สวัสดี Flask</h1>
  </body>
</html>

อย่าลืม บันทึกด้วยนะโดยการกด ctrl+s จากนั้นในไฟล์ app.py แก้ไขโค้ดดังนี้:

from flask import Flask, render_template

app = Flask(__name__)

@app.route('/')
def hello():
    return render_template('index.html')

if __name__ == '__main__':
    app.run()

จากนั้นทำการรันโดยใช้คำสั่งในterminalดังนี้:

python app.py

ก็จะได้มาในลักษณะนี้: alt text

ในตัวอย่างข้างต้น เราใช้ฟังก์ชัน render_template เพื่อแสดงผลเทมเพลตที่ชื่อว่า index.html ในหน้าเว็บเพื่อให้เราสามารถแสดงผลข้อมูลต่างๆผ่าน Tag HTML ได้นั่นเอง

การส่งข้อมูลไปยังเทมเพลต

เราสามารถส่งข้อมูลไปยังเทมเพลตเพื่อแสดงผลในหน้าเว็บได้ โดยเราสามารถส่งข้อมูลผ่านพารามิเตอร์ของฟังก์ชัน render_template ได้

ตัวอย่างการส่งข้อมูลไปยังเทมเพลต:

@app.route('/')
def home():
    name = 'Danai'
    return render_template('index.html', name=name)

name คือตัวแปรที่เป็นstrโดยมีข้อมูลคือ Danai render_template('index.html', name=name) นอกจากส่งข้อมูลไปยังเทมเพลตเราไฟล์ไหนแล้วเรายีงต้องใส่ตัวแปรชื่อ name เข้าไปเพื่อนำไปใช้ในไฟล์ index.html ในอนาคต name=name อาจจะเป็น data=name ก็ได้หรือเป็นอะไรก็ได้ แต่เพื่อลดความสับสนในอนาคตพยายามใช้ชื่อให้เหมาะสมกับสิ่งที่กำลังจะทำจะทำจะเป็นการดีกว่า

โค้ดโดยรวมของapp.py:

from flask import Flask, render_template

app = Flask(__name__)

@app.route('/')
def home():
    name = 'Danai'
    return render_template('index.html', name=name)

if __name__ == '__main__':
    app.run()

ในตัวอย่างข้างต้น เราส่งข้อมูลชื่อ Danai ไปยังเทมเพลต index.html และเราสามารถใช้ตัวแปร name ในไฟล์ HTML เพื่อแสดงผลชื่อนั้นในหน้าเว็บได้

การใช้งานตัวแปรในเทมเพลต

เราสามารถใช้ตัวแปรในเทมเพลตเพื่อแสดงผลข้อมูลหรือทำการคำนวณต่าง ๆ ได้

ตัวอย่างการใช้งานตัวแปรในเทมเพลตในไฟล์ index.html:

<!DOCTYPE html>
<html lang="en">
  <head>
    <meta charset="UTF-8" />
    <title>สวัสดี, {{ name }}</title>
  </head>
  <body>
    <h1>สวัสดี, {{ name }}</h1>
    <p>ยินดีต้อนรับสู่เว็บไซต์ของเรา</p>
  </body>
</html>

ทำการหยุดเซิฟเวอร์โดยกด Ctrl + C เพื่อหยุดการทำงานและรันเซิฟเวอร์ใหม่แล้วเปิดลิงก์ในเบราว์เซอร์ของเราจะได้ลักษณะนี้: alt text

PPYTHON-BASIC