เขียนโค้ด Python ให้สะอาด: คอมเมนต์ docstring และ PEP 8

เริ่มต้น15 นาที4 แบบฝึกหัด90 XP

บทเรียนนี้แปลจากต้นฉบับภาษาอังกฤษRead in English Leer en español Читать на русском Ler em português แจ้งข้อผิดพลาดในการแปล

ก่อนเริ่มเรียน

การแปลงชนิดข้อมูลใน Python: แปลงข้อมูลระหว่างชนิดต่าง ๆ

0/4 แบบฝึกหัด

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

นักพัฒนามืออาชีพใช้เวลา อ่าน โค้ดมากกว่าเขียนโค้ดหลายเท่า Robert C. Martin ผู้เขียนหนังสือ Clean Code ประเมินว่าสัดส่วนนี้สูงกว่า 10 ต่อ 1 อยู่มาก การเขียนโค้ดให้อ่านง่ายจึงเป็นทักษะที่มีค่าที่สุดอย่างหนึ่งที่คุณเรียนได้

ในบทเรียนนี้ คุณจะได้เรียนวิธีเขียน Python ที่คนอื่น (รวมถึงตัวคุณเองในอนาคต) อ่านแล้วสบายตา เราจะพูดถึงคอมเมนต์ (comment) docstring หลักการตั้งชื่อ และ PEP 8 ซึ่งเป็นคู่มือสไตล์การเขียนโค้ด (style guide) อย่างเป็นทางการของ Python

ทำไมโค้ดที่สะอาดจึงสำคัญ

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

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

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

โค้ดยุ่งเหยิงกับโค้ดสะอาด: ผลลัพธ์เหมือนกัน แต่อ่านแล้วต่างกันมาก

# Which version would you rather read?

# Version A

x = 3.14159

y = 10

z = x * y * y

print(z)

# Version B

pi = 3.14159

radius = 10

circle_area = pi * radius * radius

print(f"Area of circle: {circle_area}")

ผลลัพธ์

314.159
Area of circle: 314.159

ทั้งสองแบบคำนวณสิ่งเดียวกัน แต่ Version B บอกได้ทันทีว่าโค้ดทำอะไร โดยไม่ต้องมีคำอธิบายเพิ่มเติมเลย ชื่อตัวแปรคือเอกสารประกอบในตัว

วิธีเขียนคอมเมนต์ที่ดีใน Python

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

คอมเมนต์ที่ดีอธิบายว่าทำไมจึงทำแบบนั้น ไม่ใช่อธิบายว่าโค้ดทำอะไร ถ้าโค้ดชัดเจนพอ แค่อ่านก็รู้แล้วว่ามันทำ "อะไร"

❌ คอมเมนต์ที่ไม่ดี (อธิบายสิ่งที่เห็นอยู่แล้ว)

# Set x to 5
x = 5

# Add 1 to x
x = x + 1

# Print x
print(x)

✓ คอมเมนต์ที่ดี (อธิบายว่าทำไม)

# Start with 5 retries (server sometimes drops first request)
retry_count = 5

# Move to next attempt
retry_count = retry_count + 1

print(retry_count)

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

ควรเขียนคอมเมนต์ในโค้ด Python เมื่อไร

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

คอมเมนต์ที่มีประโยชน์จริง

# Good reasons to comment:

price = 9.99

tax = price * 0.0825 # Texas sales tax rate (8.25%)

# Multiply by 100 to avoid floating-point rounding errors

price_in_cents = int(price * 100)

# TODO: Replace with database lookup once API is ready

user_name = "Guest"

ผลลัพธ์

(ไม่มีผลลัพธ์)

ใช้คอมเมนต์เขียนโน้ต TODO ได้ด้วย ซึ่งเป็นการเตือนตัวเองถึงสิ่งที่ตั้งใจจะแก้ไขหรือปรับปรุงในภายหลัง โปรแกรมเขียนโค้ด (code editor) ส่วนใหญ่จะไฮไลต์คอมเมนต์ TODO ให้หาเจอได้ง่าย

เมื่อไรที่ไม่ควรเขียนคอมเมนต์

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

❌ คอมเมนต์ช่วยปิดบังโค้ดที่ไม่ชัดเจน

# Calculate the final price with 20% discount
p = x - (x * 0.2)

✓ โค้ดที่ชัดเจนไม่ต้องมีคอมเมนต์

discount_rate = 0.20
final_price = original_price - (original_price * discount_rate)

Docstring ใน Python คืออะไร

docstring คือสตริงพิเศษที่อธิบายว่าฟังก์ชัน คลาส หรือโมดูลทำอะไร เขียนไว้บนสุดของตัวฟังก์ชัน และครอบด้วยเครื่องหมายคำพูดสามตัว (""")

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

ฟังก์ชันที่มี docstring อย่างถูกต้อง

def calculate_tip(bill_amount, tip_percent):

"""Calculate the tip amount for a restaurant bill.

Args:

bill_amount: The total bill in dollars.

tip_percent: The tip percentage (e.g., 20 for 20%).

Returns:

The tip amount in dollars.

"""

return bill_amount * (tip_percent / 100)

# Using the function

tip = calculate_tip(50.00, 20)

print(f"Tip: ${tip:.2f}")

# You can view any function's docstring with help()

help(calculate_tip)

ผลลัพธ์

Tip: $10.00
Help on function calculate_tip in module __main__:

calculate_tip(bill_amount, tip_percent)
    Calculate the tip amount for a restaurant bill.

    Args:
        bill_amount: The total bill in dollars.
        tip_percent: The tip percentage (e.g., 20 for 20%).

    Returns:
        The tip amount in dollars.

เมื่อเรียก help() กับฟังก์ชันใด Python จะแสดง docstring ของฟังก์ชันนั้น ฟังก์ชันในตัว (built-in) เช่น print() และ len() ก็แสดงเอกสารประกอบของมันด้วยวิธีนี้เช่นกัน

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

docstring บรรทัดเดียวแบบง่าย

# Simple function - one-line docstring is fine

def square(n):

"""Return the square of a number."""

return n * n

print(square(7))

print(square(12))

ผลลัพธ์

49
144

หลักการตั้งชื่อใน Python: ตั้งชื่อตัวแปรอย่างไร

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

Python ใช้รูปแบบที่เรียกว่า snake_case กับชื่อตัวแปรและชื่อฟังก์ชัน คือเขียนด้วยตัวพิมพ์เล็กทั้งหมด และคั่นแต่ละคำด้วยขีดล่าง (underscore)

หลักการตั้งชื่อของ Python ในการใช้งานจริง

# snake_case - the Python way

user_name = "Alice"

total_price = 29.99

is_logged_in = True

max_retry_count = 3

# Use these in practice

print(f"User: {user_name}")

print(f"Total: ${total_price}")

print(f"Logged in: {is_logged_in}")

print(f"Max retries: {max_retry_count}")

ผลลัพธ์

User: Alice
Total: $29.99
Logged in: True
Max retries: 3

หลักการตั้งชื่อสำคัญที่นักพัฒนา Python ใช้กันมีดังนี้

หลักการตั้งชื่อสำหรับสิ่งต่าง ๆ

# Variables and functions: snake_case

player_score = 100

def calculate_average(numbers):

"""Return the average of a list of numbers."""

return sum(numbers) / len(numbers)

# Constants: UPPER_SNAKE_CASE

MAX_SPEED = 120

PI = 3.14159

DATABASE_URL = "localhost:5432"

# Classes: PascalCase (you'll learn classes later)

# class PlayerCharacter:

# class ShoppingCart:

print(f"Player score: {player_score}")

print(f"Max speed: {MAX_SPEED}")

print(f"Pi: {PI}")

ผลลัพธ์

Player score: 100
Max speed: 120
Pi: 3.14159

วิธีเลือกชื่อตัวแปรที่มีความหมาย

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

❌ ชื่อกำกวมหรือเข้าใจยาก

x = "Alice"
n = 25
f = True
temp = 3
data = 98.6
my_list = ["math", "science"]

✓ ชื่อที่สื่อความหมายชัดเจน

student_name = "Alice"
student_age = 25
is_enrolled = True
max_attempts = 3
body_temperature = 98.6
course_list = ["math", "science"]

ชื่อตัวอักษรเดียวอย่าง x, n และ i ใช้ได้ในสูตรคณิตศาสตร์สั้น ๆ หรือลูปเล็ก ๆ แต่ในกรณีอื่น ให้ใช้ชื่อที่เป็นคำจริงและบอกจุดประสงค์

PEP 8 คืออะไร: พื้นฐานคู่มือสไตล์ของ Python

PEP 8 คือคู่มือสไตล์การเขียนโค้ดอย่างเป็นทางการของ Python คำว่า PEP ย่อมาจาก "Python Enhancement Proposal" (ข้อเสนอเพื่อปรับปรุง Python) และฉบับที่ 8 คือฉบับที่ว่าด้วยสไตล์การเขียนโค้ด เปรียบได้กับระเบียบการแต่งเครื่องแบบของโค้ด Python ทุกคนทำตามกฎเดียวกัน โค้ด Python ทุกที่จึงหน้าตาคุ้นเคย

คุณไม่จำเป็นต้องจำทุกกฎ ต่อไปนี้คือกฎที่สำคัญที่สุดสำหรับผู้เริ่มต้น

วิธีเยื้องโค้ดใน Python (4 ช่องว่าง)

Python ใช้การเยื้อง (indentation) เพื่อจัดกลุ่มโค้ด มาตรฐานคือช่องว่าง 4 ช่องต่อหนึ่งระดับ อย่าใช้แท็บปนกับช่องว่าง ให้เลือกอย่างใดอย่างหนึ่ง (ช่องว่าง) แล้วใช้อย่างนั้นตลอด

การเยื้องด้วยช่องว่าง 4 ช่องอย่างถูกต้อง

# Correct: 4 spaces for each indentation level

def greet(name):

"""Print a greeting message."""

if name:

message = f"Hello, {name}!"

print(message)

else:

print("Hello, stranger!")

greet("Alice")

greet("")

ผลลัพธ์

Hello, Alice!
Hello, stranger!

วิธีใช้บรรทัดว่างในโค้ด Python

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

ใช้บรรทัดว่างแยกส่วนต่าง ๆ ของโค้ด

# Two blank lines before a function definition

def calculate_area(width, height):

"""Calculate the area of a rectangle."""

return width * height

def calculate_perimeter(width, height):

"""Calculate the perimeter of a rectangle."""

return 2 * (width + height)

# Use the functions

area = calculate_area(5, 3)

perimeter = calculate_perimeter(5, 3)

print(f"Area: {area}")

print(f"Perimeter: {perimeter}")

ผลลัพธ์

Area: 15
Perimeter: 16

เว้นบรรทัดว่าง 2 บรรทัดก่อนและหลังการนิยามฟังก์ชันที่ระดับบนสุด และเว้นบรรทัดว่าง 1 บรรทัดเพื่อแยกส่วนต่าง ๆ ตามตรรกะภายในฟังก์ชัน

วิธีเว้นวรรครอบตัวดำเนินการใน Python

เว้นวรรคหนึ่งช่องทั้งสองข้างของตัวดำเนินการ (operator) อย่าง =, +, -, == และ != แค่นี้ก็ทำให้อ่านโค้ดได้ง่ายขึ้นมากในแวบเดียว

❌ ไม่เว้นวรรค (อ่านยาก)

total=price*quantity+tax
is_valid=age>=18 and name!=""
result=x**2+y**2

✓ เว้นวรรครอบตัวดำเนินการ (อ่านง่าย)

total = price * quantity + tax
is_valid = age >= 18 and name != ""
result = x**2 + y**2

ข้อผิดพลาดด้านสไตล์ที่พบบ่อยใน Python และวิธีแก้

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

❌ เปรียบเทียบกับ True/False/None โดยตรง

if is_active == True:
    print("Active")

if result == None:
    print("No result")

✓ ใช้วิธีแบบ Python (Pythonic)

if is_active:
    print("Active")

if result is None:
    print("No result")

อย่าเปรียบเทียบกับ True หรือ False ด้วย == ให้ใช้ตัวแปรนั้นโดยตรงได้เลย ส่วน None ให้ใช้ is None เสมอ แทน == None

❌ สไตล์ไม่สม่ำเสมอ

userName = "Alice"      # camelCase
total_Price = 29.99     # mixed style
def CalculateTotal():   # PascalCase for function
    pass

✓ ใช้ snake_case อย่างสม่ำเสมอ

user_name = "Alice"     # snake_case
total_price = 29.99     # snake_case
def calculate_total():   # snake_case
    pass

เลือกสไตล์หนึ่งแล้วใช้ให้สม่ำเสมอ ใน Python สไตล์นั้นคือ snake_case สำหรับตัวแปรและฟังก์ชัน การใช้หลายสไตล์ปนกันทำให้โค้ดดูวุ่นวาย

❌ บรรทัดว่างมากเกินไป หรือไม่มีเลย

def add(a, b):
    return a + b
def subtract(a, b):
    return a - b
def multiply(a, b):
    return a * b

✓ บรรทัดว่าง 2 บรรทัดระหว่างฟังก์ชัน

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


def subtract(a, b):
    return a - b


def multiply(a, b):
    return a * b

Linter ของ Python: เครื่องมือตรวจสไตล์โค้ดให้อัตโนมัติ

คุณไม่ต้องจำกฎ PEP 8 ทุกข้อ เครื่องมือที่เรียกว่า linter ตรวจหาปัญหาด้านสไตล์ในโค้ดให้ได้โดยอัตโนมัติ ให้คิดว่า linter เป็นเหมือนตัวตรวจคำสะกด แต่ใช้ตรวจสไตล์ของโค้ด

linter ของ Python ที่นิยมที่สุด และเครื่องมือจัดรูปแบบโค้ดอีกหนึ่งตัว มีดังนี้

flake8: ตรวจหาจุดที่ไม่ตรงตาม PEP 8 และข้อผิดพลาดที่พบบ่อย เหมาะมากสำหรับมือใหม่

pylint: ตรวจละเอียดกว่า และให้คำแนะนำเรื่องคุณภาพโค้ดด้วย

ruff: น้องใหม่มาแรง ทำงานเร็วมากและรวมความสามารถของเครื่องมือหลายตัวไว้ด้วยกัน

black: ไม่ใช่ linter แต่เป็นเครื่องมือจัดรูปแบบโค้ดอัตโนมัติ (auto-formatter) แทนที่จะเตือน black จะแก้สไตล์ให้คุณโดยอัตโนมัติ

โปรแกรมเขียนโค้ดส่วนใหญ่ (เช่น VS Code) รัน linter อยู่เบื้องหลังได้ และจะขีดเส้นใต้จุดที่มีปัญหาด้านสไตล์ขณะที่คุณพิมพ์ เหมือนมีโค้ชด้านสไตล์นั่งอยู่ข้าง ๆ

แบบฝึกหัด

ได้เวลาฝึกแล้ว แบบฝึกหัดเหล่านี้จะช่วยสร้างนิสัยการเขียนโค้ด Python ที่สะอาดและอ่านง่าย

แบบฝึกหัดที่ 1: เพิ่มคอมเมนต์และ docstring

เขียนโค้ด

เขียนฟังก์ชันชื่อ celsius_to_fahrenheit ที่รับอุณหภูมิเป็นองศาเซลเซียส แล้วคืนค่าเป็นองศาฟาเรนไฮต์

สูตรคือ fahrenheit = celsius * 9/5 + 32

ฟังก์ชันของคุณต้องมี

docstring ที่อธิบายว่าฟังก์ชันทำอะไร

คอมเมนต์ ที่อธิบายสูตร

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

212.0

# Write your function with a docstring and comment

แบบฝึกหัดที่ 2: แก้ชื่อตัวแปรที่ไม่ดี

แก้บั๊ก

โค้ดนี้ทำงานได้ แต่ชื่อตัวแปรแย่มาก ไม่มีใครรู้ว่า x, y, z, a และ b หมายถึงอะไร

เปลี่ยนชื่อตัวแปรให้ มีความหมาย และใช้ snake_case โค้ดนี้คำนวณค่าแรงรายสัปดาห์ของพนักงานคนหนึ่ง ผลลัพธ์ต้องเหมือนเดิมทุกตัวอักษร:

Weekly pay: $450.0
With overtime: $562.5

x = 15.0

y = 30

z = x * y

a = 5

b = x * 1.5 * a

print(f"Weekly pay: ${z}")

print(f"With overtime: ${z + b}")

แบบฝึกหัดที่ 3: เขียนโค้ดที่ยุ่งเหยิงใหม่ตามสไตล์ PEP 8

เขียนโค้ด

โค้ดด้านล่างยุ่งเหยิง ให้เขียนใหม่ตามกฎของ PEP 8

def calcArea(W,H):
  result=W*H
  return result
def calcPerimeter(W,H):
  result=2*(W+H)
  return result
w=8
h=5
print(f"Area: {calcArea(w,h)}")
print(f"Perimeter: {calcPerimeter(w,h)}")

แก้ปัญหาเหล่านี้

ชื่อฟังก์ชันควรเป็น snake_case

ใช้ช่องว่าง 4 ช่องในการเยื้อง

เว้นวรรครอบตัวดำเนินการและหลังเครื่องหมายจุลภาค

เว้นบรรทัดว่าง 2 บรรทัดระหว่างการนิยามฟังก์ชัน

ใช้ชื่อตัวแปรที่มีความหมาย

ผลลัพธ์ต้องเป็น

Area: 40
Perimeter: 26

# Rewrite the messy code from the instructions above, following PEP 8 rules

แบบฝึกหัดที่ 4: รีแฟกเตอร์ (refactor) โค้ดนี้ให้สะอาด

ปรับปรุงโค้ด

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

def d(p,r):
  a=p*r/100
  t=p-a
  return t
print(d(200,15))

เวอร์ชันที่ปรับแล้วต้อง

ตั้งชื่อฟังก์ชันที่มีความหมาย (ฟังก์ชันนี้คำนวณราคาหลังหักส่วนลด)

ใช้ชื่อพารามิเตอร์ที่สื่อความหมาย

เพิ่ม docstring ที่อธิบายว่าฟังก์ชันทำอะไร

เว้นวรรคตาม PEP 8 (เยื้อง 4 ช่องว่าง เว้นวรรครอบตัวดำเนินการ)

เว้นบรรทัดว่าง 2 บรรทัดก่อนการเรียกฟังก์ชัน

ผลลัพธ์ต้องเป็น

170.0

# Refactor the messy code into clean, professional Python

สรุป: สิ่งที่ได้เรียนรู้เกี่ยวกับโค้ด Python ที่สะอาด

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

แนวคิด	กฎสำคัญ	ตัวอย่าง
คอมเมนต์ (`#`)	อธิบายว่าทำไม ไม่ใช่ทำอะไร	`# Texas tax rate (8.25%)`
Docstring (`"""`)	อธิบายว่าฟังก์ชันทำอะไร	`"""Convert Celsius to Fahrenheit."""`
ชื่อตัวแปร	สื่อความหมาย ใช้ `snake_case`	`total_price`, `is_valid`
ค่าคงที่	`UPPER_SNAKE_CASE`	`MAX_SPEED = 120`
การเยื้อง	ช่องว่าง 4 ช่องเสมอ	`def greet():` แล้วเยื้อง 4 ช่อง
บรรทัดว่าง	2 บรรทัดระหว่างฟังก์ชัน	แยกส่วนต่าง ๆ ตามตรรกะ
ตัวดำเนินการ	เว้นวรรครอบ `=`, `+` ฯลฯ	`x = a + b`
PEP 8	คู่มือสไตล์อย่างเป็นทางการของ Python	ความสม่ำเสมอสำคัญที่สุด

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

เรียนอะไรต่อ

คุณเรียนจบหมวดพื้นฐาน Python แล้ว ตอนนี้คุณมีพื้นฐาน Python ที่แน่นพอ ต่อไปคุณจะได้เรียนการควบคุมลำดับการทำงาน (Control Flow) ซึ่งสอนให้โปรแกรมตัดสินใจด้วยคำสั่ง if และทำงานซ้ำด้วยลูป

ทำไมโค้ดที่สะอาดจึงสำคัญ

วิธีเขียนคอมเมนต์ที่ดีใน Python

ควรเขียนคอมเมนต์ในโค้ด Python เมื่อไร

เมื่อไรที่ไม่ควรเขียนคอมเมนต์

Docstring ใน Python คืออะไร

หลักการตั้งชื่อใน Python: ตั้งชื่อตัวแปรอย่างไร

วิธีเลือกชื่อตัวแปรที่มีความหมาย

PEP 8 คืออะไร: พื้นฐานคู่มือสไตล์ของ Python

วิธีเยื้องโค้ดใน Python (4 ช่องว่าง)

วิธีใช้บรรทัดว่างในโค้ด Python

วิธีเว้นวรรครอบตัวดำเนินการใน Python

ข้อผิดพลาดด้านสไตล์ที่พบบ่อยใน Python และวิธีแก้

Linter ของ Python: เครื่องมือตรวจสไตล์โค้ดให้อัตโนมัติ

แบบฝึกหัด

สรุป: สิ่งที่ได้เรียนรู้เกี่ยวกับโค้ด Python ที่สะอาด

เรียนอะไรต่อ

บทเรียนที่เกี่ยวข้อง