พื้นฐาน Python: คู่มือเริ่มต้นสำหรับเขียนโค้ด

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

โปรแกรม Python แรกของคุณ: “Hello, World!”

เริ่มต้นด้วยโปรแกรม “Hello, World!” แบบดั้งเดิม ใน Python สิ่งนี้ตรงไปตรงมาเป็นพิเศษ:

print("Hello, Beginner!")

บรรทัดเดียวนี้ทำสิ่งต่อไปนี้:

1. print(): นี่คือ function ที่ built-in ฟังก์ชันคือบล็อกโค้ดที่นำกลับมาใช้ใหม่ได้ซึ่งทำงานเฉพาะ print() แสดงผลลัพธ์ต่อผู้ใช้
2. ("Hello, Beginner!"): ภายในวงเล็บคือ string literal สตริงคือลำดับของอักขระ อยู่ในเครื่องหมายคำพูดเดี่ยว ('...') หรือคู่ ("...")

เมื่อคุณรันสิ่งนี้ ตัวแปลภาษา Python จะรัน print() โดยแสดง “Hello, Beginner!” บนหน้าจอของคุณ

ตัวแปรใน Python

ตัวแปรมีความสำคัญต่อการจัดเก็บข้อมูล คิดว่ามันเป็นเหมือนตู้คอนเทนเนอร์ที่มีป้ายกำกับ เป็นแนวทางปฏิบัติที่ดีในการใช้ชื่อที่สื่อความหมาย เริ่มต้นด้วยตัวอักษรพิมพ์เล็ก และใช้ขีดล่างเพื่อแยกคำ (เช่น my_variable, user_age) นี่คือตัวอย่าง:

# การกำหนดค่าให้กับตัวแปร
message = "Welcome to Python!"
number = 10
pi = 3.14159

# การพิมพ์ค่าตัวแปร
print(message)
print(number)
print(pi)

คำอธิบาย:

1. message = "Welcome to Python!": ตัวแปรชื่อ message ถูกสร้างขึ้น โดยจัดเก็บสตริง “Welcome to Python!”
2. number = 10: ตัวแปรชื่อ number จัดเก็บจำนวนเต็ม 10
3. pi = 3.14159: ตัวแปรชื่อ pi จัดเก็บเลขทศนิยม 3.14159

print() จะแสดงค่าเหล่านี้ Python เป็น dynamically typed: คุณไม่จำเป็นต้องระบุประเภทของตัวแปร (สตริง, จำนวนเต็ม, ทศนิยม) อย่างชัดเจน Python จะอนุมานจากค่าที่กำหนด

การโต้ตอบกับผู้ใช้ใน Python

โปรแกรมแบบโต้ตอบมักต้องการข้อมูลจากผู้ใช้ นี่คือวิธีรับ:

# การรับข้อมูลจากผู้ใช้
name = input("Please enter your name: ")

# การพิมพ์คำทักทายส่วนตัว
print("Hello, " + name + "!")  # การต่อสตริง

คำอธิบาย:

1. name = input("Please enter your name: "): input() หยุดโปรแกรมชั่วคราว รอให้ผู้ใช้พิมพ์บางอย่างแล้วกด Enter และจัดเก็บเป็นสตริงใน name
2. print("Hello, " + name + "!"): สิ่งนี้พิมพ์คำทักทาย เครื่องหมาย + เมื่อใช้กับสตริง จะทำหน้าที่ string concatenation โดยเชื่อมต่อเข้าด้วยกัน เป็นแนวทางปฏิบัติที่ดีในการเพิ่มช่องว่างรอบๆ + เมื่อทำการต่อสตริงเพื่อให้อ่านง่าย

ตรรกะแบบมีเงื่อนไข: if, else, และ elif

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

age = int(input("Enter your age: "))

if age >= 18:
    print("You are eligible to vote.")
elif age < 0:
    print("That is an incorrect age.")
else:
    print("You are not eligible to vote yet.")

รายละเอียด:

1. age = int(input("Enter your age: ")): รับข้อมูลอายุจากผู้ใช้ int() แปลงข้อมูลที่ป้อนเข้า (ซึ่งเป็นสตริงโดยค่าเริ่มต้น) ให้เป็นจำนวนเต็ม
2. if age >= 18:: ตรวจสอบว่า age มากกว่าหรือเท่ากับ 18 หรือไม่ ถ้าจริง คำสั่ง print ที่เยื้องจะถูกรัน
3. elif age < 0:: หากเงื่อนไข if ก่อนหน้านี้เป็นเท็จ เงื่อนไขนี้จะถูกตรวจสอบ หากเป็นจริง บล็อกที่เกี่ยวข้องจะถูกรัน elif ย่อมาจาก “else if” และอนุญาตให้ตรวจสอบเงื่อนไขหลายๆ เงื่อนไขตามลำดับ
4. else:: ถ้าไม่มีเงื่อนไข if หรือ elif เป็นจริง โค้ดที่เยื้องภายใต้ else จะถูกรัน การเยื้องมีความสำคัญใน Python; มันกำหนดบล็อกโค้ดที่เกี่ยวข้องกับ if, elif, และ else การเยื้องที่สอดคล้องกัน (ปกติคือ 4 ช่องว่าง) เป็นสิ่งสำคัญสำหรับโค้ด Python ที่จะทำงานได้อย่างถูกต้อง

ลูป: การทำซ้ำโค้ดด้วย for

ลูปทำซ้ำบล็อกโค้ด ลูป for ทำซ้ำตามลำดับ (เช่น รายการหรือช่วงของตัวเลข)

# การพิมพ์ตัวเลข 0-4
for i in range(5):
    print(i)

# การพิมพ์องค์ประกอบรายการ
fruits = ["apple", "banana", "cherry"]
for fruit in fruits:
    print(fruit)

คำอธิบาย:

1. for i in range(5):: range(5) สร้างตัวเลขตั้งแต่ 0 ถึง (แต่ ไม่ รวม) 5 ลูปจะวนซ้ำตามลำดับนี้ ในแต่ละรอบ ตัวเลขปัจจุบันจะถูกกำหนดให้กับ i
2. for fruit in fruits:: ลูปนี้วนซ้ำผ่านรายการ fruits ในแต่ละรอบ องค์ประกอบรายการปัจจุบันจะถูกกำหนดให้กับ fruit

ลูป: การทำซ้ำโค้ดด้วย while

ลูป while จะดำเนินต่อไปตราบเท่าที่เงื่อนไขเป็นจริง

count = 0
while count < 5:
    print(count)
    count += 1  # เพิ่มค่า count

คำอธิบาย:

1. count = 0: กำหนดค่าเริ่มต้น count เป็น 0
2. while count < 5:: ลูปจะดำเนินต่อไปตราบเท่าที่ count น้อยกว่า 5
3. count += 1: ภายในลูป count จะเพิ่มขึ้น 1 ในแต่ละรอบ สิ่งนี้ป้องกัน infinite loop (ที่เงื่อนไขจะเป็นจริงเสมอ)

ฟังก์ชัน: บล็อกโค้ดที่นำกลับมาใช้ใหม่ได้

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

# การกำหนดฟังก์ชัน
def greet(name):
    print("Hello, " + name + "!")

# การเรียกใช้ฟังก์ชัน
greet("Alice")
greet("Bob")

ประเด็นสำคัญ:

1. def greet(name):: กำหนดฟังก์ชันชื่อ greet ที่รับ parameter หนึ่งตัวชื่อ name
2. print("Hello, " + name + "!"): body ของฟังก์ชัน—โค้ดที่ถูกรันเมื่อมีการเรียกใช้ฟังก์ชัน
3. greet("Alice"): เรียกใช้ ฟังก์ชัน greet โดยส่ง “Alice” เป็น argument

การรวมแนวคิด: เครื่องคำนวณพื้นที่อย่างง่าย

รวมแนวคิดเข้าเป็นโปรแกรมที่ซับซ้อนขึ้นเล็กน้อย:

def calculate_area(length, width):
    """คำนวณพื้นที่ของสี่เหลี่ยมผืนผ้า"""  # Docstring
    area = length * width
    return area

# รับขนาด
length = float(input("Enter length: "))
width = float(input("Enter width: "))

# คำนวณพื้นที่
rectangle_area = calculate_area(length, width)

# พิมพ์ผลลัพธ์
print("Area:", rectangle_area)

คำอธิบาย:

1. def calculate_area(length, width):: กำหนดฟังก์ชันเพื่อคำนวณพื้นที่สี่เหลี่ยมผืนผ้า โดยรับ length และ width เป็นพารามิเตอร์ """...""" คือ docstring อธิบายฟังก์ชัน Docstrings ใช้สำหรับเอกสารประกอบและสามารถเข้าถึงได้โดยฟังก์ชัน help()
2. return area: ฟังก์ชัน return พื้นที่ที่คำนวณได้ คำสั่ง return ออกจากฟังก์ชันและส่งค่ากลับไปยังตำแหน่งที่เรียกใช้ฟังก์ชัน
3. โปรแกรมรับข้อมูลจากผู้ใช้สำหรับความยาวและความกว้าง แปลงเป็นเลขทศนิยมโดยใช้ float() การใช้ float() ช่วยให้สามารถใช้ค่าทศนิยมได้ ทำให้เครื่องคิดเลขใช้งานได้หลากหลายมากขึ้น
4. มันเรียก calculate_area โดยส่งผ่านขนาด และจัดเก็บค่าที่ส่งคืนใน rectangle_area
5. สุดท้าย มันพิมพ์พื้นที่

เครื่องมือควบคุมโฟลว์เพิ่มเติม

Python มีเครื่องมืออื่นๆ สำหรับควบคุมโฟลว์ของโปรแกรม

break, continue, และ else ในลูป

• break: ออกจากลูป for หรือ while ที่อยู่ด้านในสุด
• continue: ไปยังรอบถัดไปของลูป
• Loop else clause: ใน for จะถูกรันหลังจากลูปเสร็จสิ้น (เว้นแต่จะเกิด break) ใน while จะถูกรันหลังจากเงื่อนไขเป็นเท็จ (เว้นแต่จะเกิด break)

#ตัวอย่างสำหรับ break
numbers = [1, 2, 3, 4, 5]
for number in numbers:
    if number == 3:
        break  # ออกจากลูปเมื่อ number เท่ากับ 3
    print(number)  # ผลลัพธ์: 1 2

#ตัวอย่างสำหรับ continue
numbers = [1, 2, 3, 4, 5]
for number in numbers:
    if number == 3:
        continue  # ข้ามไปยังรอบถัดไปเมื่อ number เท่ากับ 3
    print(number)  # ผลลัพธ์: 1 2 4 5

#ตัวอย่างสำหรับ else
for i in range(5):
    print(i)
else:
    print("Loop finished") #จะถูกรัน

for i in range(5):
    if i==3:
        break
    print(i)
else:
    print("Loop finished") #จะไม่ถูกรัน

คำสั่ง match

match เปรียบเทียบค่ากับรูปแบบ มันเหมือนกับคำสั่ง switch ในภาษาอื่น ๆ แต่มีการจับคู่รูปแบบที่มีประสิทธิภาพมากกว่า ซึ่งใช้งานได้ตั้งแต่ Python 3.10

def http_error(status):
    match status:
        case 400:
            return "Bad request"
        case 401 | 403 | 404:  # หลายกรณี
            return "Not allowed"
        case 418:
            return "I'm a teapot"
        case _:  # ค่าเริ่มต้น
            return "Something's wrong"

print(http_error(404))
print(http_error(500))

_ เป็นสัญลักษณ์แทน (wildcard) จับคู่กับอะไรก็ได้หากไม่มีกรณีอื่นตรงกัน

โครงสร้างข้อมูล

Python มีโครงสร้างข้อมูลในตัวสำหรับการจัดระเบียบข้อมูล

• Lists: ลำดับที่เรียงลำดับและเปลี่ยนแปลงได้ (mutable)

my_list = [1, 2, 3, "apple"]
my_list.append("cherry")  # เพิ่มองค์ประกอบที่ส่วนท้าย
print(my_list[0])       # เข้าถึงองค์ประกอบด้วยดัชนี (เริ่มต้นจาก 0)
my_list.remove(2)        # ลบองค์ประกอบตามค่า
print(my_list)

• Tuples: ลำดับที่เรียงลำดับและเปลี่ยนแปลงไม่ได้ (immutable)

my_tuple = (1, 2, 3, "apple")
# my_tuple[0] = 5  # ข้อผิดพลาด (immutable) - Tuples ไม่สามารถแก้ไขได้หลังจากการสร้าง
print(my_tuple[1])

• Sets: คอลเลกชันขององค์ประกอบ unique ที่ไม่เรียงลำดับ

my_set = {1, 2, 3, 3, 4, 5}  # รายการที่ซ้ำกันจะถูกลบโดยอัตโนมัติ
print(my_set)  # ผลลัพธ์: {1, 2, 3, 4, 5}

• Dictionaries: คู่คีย์-ค่า คีย์ต้องไม่เปลี่ยนรูป (เช่น สตริง ตัวเลข หรือ tuples)

my_dict = {"name": "Alice", "age": 30}
print(my_dict["name"])  # เข้าถึงค่าด้วยคีย์
my_dict["age"] = 31      # แก้ไขค่า
print(my_dict)

• List Comprehensions: ไวยากรณ์ที่กระชับสำหรับการสร้างรายการ

squares = [x**2 for x in range(10)]      # รายการของกำลังสอง
even = [x for x in range(20) if x % 2 == 0]  # เลขคู่
print(squares)
print(even)

โมดูล

โมดูลจัดระเบียบโค้ดเป็นไฟล์ที่นำกลับมาใช้ใหม่ได้ ใช้ import เพื่อเข้าถึงฟังก์ชันจากโมดูลอื่นๆ

import math

print(math.sqrt(16))  # เข้าถึงฟังก์ชัน sqrt จากโมดูล math
print(math.pi)        # เข้าถึงค่าคงที่ pi

from math import sqrt  # นำเข้าฟังก์ชันเฉพาะ

print(sqrt(25))

from math import *  # นำเข้าทั้งหมด (โดยทั่วไปควรหลีกเลี่ยง)

print(pi)

นี่แสดงให้เห็นถึงการใช้โมดูล math (ซึ่งมีฟังก์ชันทางคณิตศาสตร์) การนำเข้าฟังก์ชันหรือค่าคงที่เฉพาะสามารถปรับปรุงความสามารถในการอ่านโค้ดและหลีกเลี่ยงความขัดแย้งในการตั้งชื่อ การนำเข้าทุกอย่างด้วย * โดยทั่วไปไม่แนะนำในโครงการขนาดใหญ่

การกำหนดฟังก์ชัน: เทคนิคขั้นสูง

ค่าเริ่มต้นของอาร์กิวเมนต์

ฟังก์ชันสามารถมีค่าเริ่มต้นสำหรับอาร์กิวเมนต์

def greet(name, greeting="Hello"):
    print(greeting + ", " + name + "!")

greet("Bob")           # ใช้ค่าเริ่มต้นของคำทักทาย
greet("Alice", "Hi")  # แทนที่ค่าเริ่มต้น

อาร์กิวเมนต์แบบ Keyword

เรียกใช้ฟังก์ชันโดยใช้ไวยากรณ์ keyword=value

def describe_pet(animal_type, pet_name):
    print("I have a " + animal_type + " named " + pet_name + ".")

describe_pet(pet_name="Harry", animal_type="hamster")  # ลำดับไม่สำคัญ

รายการอาร์กิวเมนต์แบบ Arbitrary

ฟังก์ชันสามารถรับอาร์กิวเมนต์ตำแหน่งจำนวนเท่าใดก็ได้โดยใช้ *args

def make_pizza(*toppings):
    print("Making a pizza with:")
    for topping in toppings:
        print("- " + topping)

make_pizza("pepperoni")
make_pizza("mushrooms", "cheese", "peppers")

*toppings รวบรวมอาร์กิวเมนต์ตำแหน่งทั้งหมดไว้ใน tuple ชื่อ toppings

อาร์กิวเมนต์แบบ Keyword แบบ Arbitrary

ฟังก์ชันสามารถรับอาร์กิวเมนต์แบบ keyword จำนวนเท่าใดก็ได้โดยใช้ **kwargs

def build_profile(first, last, **kwargs):
    # รวมอาร์กิวเมนต์แบบ keyword ที่คงที่และแบบ arbitrary เพื่อสร้างโปรไฟล์ผู้ใช้
    profile = {'first_name': first, 'last_name': last}
    profile.update(kwargs)  # อัปเดตโปรไฟล์ด้วยคู่คีย์-ค่าจาก kwargs
    return profile

user = build_profile("Albert", "Einstein", location="Princeton", field="physics")
print(user)  # Output: {'first_name': 'Albert', 'last_name': 'Einstein', 'location': 'Princeton', 'field': 'physics'}

**kwargs ย่อมาจาก “keyword arguments” และเป็นแบบแผนการตั้งชื่อทั่วไปสำหรับการรวบรวมอาร์กิวเมนต์ที่มีชื่อเพิ่มเติมลงใน dictionary สิ่งนี้ช่วยให้ฟังก์ชันสามารถจัดการอินพุตที่ยืดหยุ่นได้

นิพจน์ Lambda

ฟังก์ชันขนาดเล็กที่ไม่ระบุชื่อที่สร้างด้วย lambda

add = lambda x, y: x + y
print(add(5, 3))  # ผลลัพธ์: 8

pairs = [(1, 'one'), (2, 'two'), (3, 'three')]
pairs.sort(key=lambda pair: pair[1]) #เรียงลำดับตามองค์ประกอบที่สองของ tuple
print(pairs)

ฟังก์ชัน Lambda มักใช้เป็นอาร์กิวเมนต์สำหรับฟังก์ชันลำดับสูง (ฟังก์ชันที่รับฟังก์ชันอื่นเป็นอาร์กิวเมนต์) เช่น sort ในตัวอย่างนี้

คลาส

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

class Dog:
    def __init__(self, name, age): #constructor
        self.name = name
        self.age = age

    def bark(self):
        print("Woof!")

my_dog = Dog("Buddy", 3) #instance ของคลาส
print(my_dog.name)
my_dog.bark()

คำอธิบาย:

• class Dog:: กำหนดคลาสชื่อ Dog
• def __init__(self, name, age):: นี่คือ constructor (หรือ initializer) มันถูกเรียกโดยอัตโนมัติเมื่อคุณสร้างวัตถุ Dog ใหม่
  • self: อ้างถึง instance ของคลาส (วัตถุ Dog เฉพาะที่คุณกำลังทำงานด้วย) เป็นพารามิเตอร์แรกในทุกเมธอดภายในคลาส
• def bark(self):: นี่คือ method—ฟังก์ชันที่เป็นของคลาส Dog มันสามารถเข้าถึงข้อมูลของสุนัขได้ (เช่น self.name แม้ว่าในตัวอย่างง่ายๆ นี้จะไม่ได้ใช้ก็ตาม)
• my_dog = Dog("Buddy", 3) สร้าง instance ของคลาส Dog ชื่อ my_dog.

Iterators

Iterator คืออ็อบเจกต์ที่ให้เราท่องผ่านองค์ประกอบทั้งหมดของคอลเล็กชัน โดยไม่คำนึงถึงการนำไปใช้งานเฉพาะ

class MyNumbers:
  def __iter__(self):
    self.a = 1
    return self

  def __next__(self):
    x = self.a
    self.a += 1
    return x

myclass = MyNumbers()
myiter = iter(myclass)

print(next(myiter))
print(next(myiter))
print(next(myiter))

Generators

Generator เป็น iterable ประเภทหนึ่ง เหมือนกับ lists หรือ tuples แต่ต่างจาก lists ตรงที่ generators จะไม่เก็บ contents ไว้ในหน่วยความจำ แต่จะสร้าง values ขึ้นมาทันที โดยใช้ keyword yield ทำให้มีประสิทธิภาพในการใช้หน่วยความจำสำหรับ sequences ขนาดใหญ่ และทำให้มันแตกต่างจาก list comprehensions ซึ่งจะสร้าง list ทั้งหมดขึ้นในหน่วยความจำ

def my_generator():
  yield 1
  yield 2
  yield 3

for value in my_generator():
  print(value)

#generator expression
squares = (x*x for x in range(10))
print(list(squares))

พื้นฐานเหล่านี้เป็นรากฐานที่มั่นคงสำหรับการเดินทางใน Python ของคุณ โดยการทดลองกับแนวคิดเหล่านี้และรวมเข้าด้วยกัน คุณสามารถสร้างโปรแกรมที่ซับซ้อนมากขึ้นได้ โปรดจำไว้ว่าการฝึกฝนและการสำรวจเป็นกุญแจสำคัญในการเรียนรู้ภาษาโปรแกรมใดๆ