ข้ามไปยังเนื้อหา
รายวิชา
  • 1 Getting started
    1.1

    โปรแกรมแรกของคุณ

    Python รันโค้ดของคุณทีละบรรทัด แต่ละบรรทัดคือ statement Program ก็แค่รายการของ statements ที่รันจากบนลงล่าง

    ฟังก์ชัน print() แสดงข้อความบนหน้าจอ สิ่งนี้เรียกว่า output ข้อความภายในเครื่องหมายอ้อมคือ string

    print("Hello, world!")
    print("I am learning Python")
    
    • แต่ละ print() เริ่มต้นบรรทัดใหม่
    • Quotes สามารถเป็น "double" หรือ 'single' — ทั้งสองทำให้เป็น string
    • Program จะทำอะไรสักอย่างก็ต่อเมื่อคุณรันมันเท่านั้น
    โค้ดโปรแกรมถูกส่งผ่านตัวแปลภาษาเพื่อสร้างผลลัพธ์
    โค้ดต้นทางจะผ่านตัวตีความเพื่อสร้างผลลัพธ์
    1.2

    Comments & code style

    Comment เริ่มด้วย # Python จะ ignore ทุกอย่างหลัง # บนบรรทัดนั้น Comment อธิบายโค้ดของคุณให้กับผู้อื่น—they do not change what the code does.

    # This line is a note for humans
    print("Hi")        # you can also comment at the end of a line
    

    Good style makes code easy to read:

    • ใช้ชื่อที่ชัดเจนเพื่อระบุความหมายของค่า
    • วางคำสั่งหนึ่งบรรทัดต่อหนึ่งบรรทัด
    • อย่าเพิ่มช่องว่างที่เริ่มต้นบรรทัดปกติ ใน Python การเว้นวรรคที่ต้นบรรทัด (indentation) มีความหมายพิเศษ ดังนั้นช่องว่างที่ผิดจะทำให้เกิดข้อผิดพลาด
    1.3

    ข้อมูลเข้า, กระบวนการ, ข้อมูลออก

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

    ฟังก์ชัน input() อ่านข้อความที่ผู้ใช้พิมพ์ มันจะให้ค่ากลับเป็น string เสมอ

    name = input("What is your name? ")
    print("Hello, " + name)
    
    • input() รอให้ผู้ใช้พิมพ์และกด Enter
    • เก็บข้อความที่พิมพ์ลงในตัวแปรเพื่อให้สามารถใช้งานในภายหลังได้
    • เนื่องจาก input()/value return เป็น string ให้แปลงด้วย int(...) ก่อนหากต้องการใช้ตัวเลข

    ข้อผิดพลาดที่พบบ่อย

    • ลืมเครื่องหมายคำพูด: print(Hello) จะมองหาตัวแปรชื่อ Hello และเกิด NameError ข้อความต้องใส่เครื่องหมายคำพูด: print("Hello")
    • ช่องว่างแปลกๆ ที่ ต้น บรรทัด: Python อ่านการเว้นวรรคเป็นโครงสร้าง จึงเกิด IndentationError
    • สมมติว่า input()/value return เป็นตัวเลข มันให้ค่ากลับเป็น string เสมอ ดังนั้นห่อด้วย int(...) ก่อนทำคณิตศาสตร์ใดๆ
  • 2 Variables, types & operators
    2.1

    ตัวแปร & การกำหนดค่า

    ตัวแปรคือชื่อสำหรับค่า คุณสร้างมันด้วย = ซึ่งเรียกว่า assignment ชื่อไปอยู่ทางซ้าย ค่าไปอยู่ทางขวา

    age = 17
    name = "Mei"
    price = 9.99
    print(age, name, price)
    

    ตอนนี้ age มีค่าเป็น 17 สามารถใช้ชื่อนี้ทุกที่ต้องการค่า และเปลี่ยนค่าได้ในภายหลัง:

    age = 17
    age = age + 1   # age is now 18
    print(age)
    
    ตัวแปรคือชื่อที่ผูกกับค่าที่จัดเก็บไว้
    ชื่อตัวแปรแต่ละตัวชี้ไปยังค่าในหน่วยความจำ
    • สัญญาณ =/sign ไม่หมายถึง "เท่ากับ" แต่หมายถึง "เก็บด้านขวาล่างชื่อด้านซ้าย"
    • เพื่อทดสอบว่าสองค่าเท่ากันหรือไม่ ให้ใช้ == (ดูด้านล่าง)
    2.2

    จำนวน: int & float

    Python มีประเภทจำนวนหลัก 2 แบบ Integer (int) คือจำนวนเต็มเช่น 17 Float (float) มีทศนิยมเช่น 9.99

    ตัวดำเนินการเหล่านี้ทำงานกับจำนวน:

    ตัวดำเนินการ ความหมาย ตัวอย่าง ผลลัพธ์
    + บวก 3 + 2 5
    - ลบ 3 - 2 1
    * คูณ 3 * 2 6
    / หาร (ให้เป็น float เสมอ) 7 / 2 3.5
    // หารเอาเศษ (integer divide) 7 // 2 3
    % เศษเหลือ (modulo) 7 % 2 1
    ** ยกกำลัง 2 ** 3 8
    • //operator ให้ผลเป็น float เสมอ ดังนั้น 4 / 2/result คือ 2.0/result
    • // และ % ทำงานคู่กัน: 17 // 5/result คือ 3/result และ 17 % 5/result คือ 2/result
    2.3

    นิพจน์ & การแปลงประเภท

    นิพจน์คือทุกอย่างที่มีค่า เช่น 3 + 4 * 2 Python ใช้ลำดับคณิตศาสตร์ปกติ (* และ / ทำก่อน + และ -); ใส่วงเล็บเพื่อทำให้ลำดับชัดเจน

    input()/value give string ดังนั้นแปลงมันก่อนทำคณิตศาสตร์ การเปลี่ยนค่าจากประเภทหนึ่งไปอีกประเภทหนึ่งคือการแปลงประเภท (type conversion):

    age = int("17")        # text "17" -> number 17
    price = float("9.99")  # text -> 9.99
    label = str(17)        # number -> text "17"
    print(age, price, label)
    
    • int("abc")/expression fails ดังนั้นแปลงเฉพาะข้อความที่ดูเหมือนตัวเลขเท่านั้น
    • การผสมประเภทก็ล้มเหลวเช่นกัน: "age: " + 17/expression เป็น error; เขียน "age: " + str(17)/expression แทน
    2.4

    Boolean & การเปรียบเทียบ

    Boolean มีเพียงสองค่า: True หรือ False การเปรียบเทียบให้ค่ากลับเป็น Boolean

    ตัวดำเนินการ ความหมาย
    == เท่ากับ
    != ไม่เท่ากับ
    < > น้อยกว่า / มากกว่า
    <= >= น้อยกว่าหรือเท่ากับ / มากกว่าหรือเท่ากับ
    print(7 > 2)        # True
    print(3 == 3.0)     # True
    age = 20
    print(age >= 18)    # True
    

    เชื่อมการเปรียบเทียบด้วย and, or, not:

    age = 20
    print(age >= 13 and age <= 19)   # True only for a teenager
    

    ข้อผิดพลาดที่พบบ่อย

    • //function ให้ผลเป็นfloat เสมอ แม้ 4 / 2/condition จะ 2.0/condition ก็ตาม ใช้ ///function เมื่อต้องการจำนวนเต็ม
    • การใช้ =/assignment แทน ==/comparison: =/symbol assign ค่า, ==/symbol ทดสอบว่าสองค่าเท่ากันหรือไม่
    • การเชื่อม string กับ number: "age: " + 5/expression raise TypeError แปลงก่อนด้วย str(5)/function
    • Floats ไม่ใช่ค่าที่แม่นยำ ดังนั้น 0.1 + 0.2/expression ไม่ใช่ 0.3/value อย่างแท้จริง — หลีกเลี่ยง ==/comparison กับผลลัพธ์ของ float
  • 3 สตริง (Strings)
    3.1

    Indexing

    สตริงคือข้อความภายในเครื่องหมายคำพูด แต่ละตัวอักษรมีตำแหน่งซึ่งเรียกว่า ดัชนี ดัชนีแรกคือ 0 ไม่ใช่ 1

    อ่านตัวอักษรหนึ่งตัวด้วยสี่เหลี่ยมเหลี่ยม:

    word = "Python"
    print(word[0])    # P  (the first character)
    print(word[2])    # t
    print(len(word))  # 6  (how many characters)
    
    • การนับเริ่มที่ 0 ดังนั้น index สุดท้ายคือ len(word) - 1
    • Index เชิงลบนับถอยหลังจากท้าย: word[-1] คือตัวอักษรสุดท้าย
    word = "Python"
    print(word[-1])   # n
    print(word[-2])   # o
    
    • Index ที่ใหญ่เกินไปจะทำให้เกิดข้อผิดพลาด (an IndexError)
    s[start:stop] เป็นหน้าต่างครึ่งเปิดของตัวอักษร
    s[start:stop] เป็นหน้าต่างครึ่งเปิดของตัวอักษร
    3.2

    Slicing

    Slice Takes ส่วนหนึ่งของ string เขียน word[start:end] Slice จะเก็บ start แต่หยุด ก่อน end

    word = "Python"
    print(word[0:3])   # Pyt   (positions 0, 1, 2)
    print(word[2:5])   # tho
    
    • ทิ้ง start ไว้เพื่อเริ่มต้นที่ 0; ทิ้ง end ไว้เพื่อไปจนถึงท้าย
    word = "Python"
    print(word[:3])    # Pyt
    print(word[3:])    # hon
    
    • ตัวเลขที่สามคือขั้นตอน. word[::-1] จะกลับลำดับข้อความ.
    print("Python"[::-1])   # nohtyP
    
    3.3

    String methods & ความยาว

    Method คือฟังก์ชันที่ติดกับค่า คุณเรียกมันด้วยจุด:

    name = "mei chen"
    print(name.upper())     # MEI CHEN
    print(name.title())     # Mei Chen
    print(len(name))        # 8
    

    สตริงเป็นแบบไม่เปลี่ยนแปลง: เมทოდจะคืนค่า สตริงใหม่ และไม่เคยแก้ไขค่าเดิม

    name = "mei"
    print(name.upper())     # MEI  (the returned value)
    print(name)             # mei  (the original is unchanged)
    

    Methods ปกติ (แต่ละตัวให้ค่าใหม่):

    Method ความหมาย ตัวอย่าง ผลลัพธ์
    .upper() / .lower() เปลี่ยนกรณี "Hi".lower() hi
    .strip() ลบช่องว่างขอบ " hi ".strip() hi
    .replace(a, b) สลับข้อความ "cat".replace("c", "b") bat
    .split(sep) แยกเป็น list "a,b".split(",") ['a', 'b']

    เชื่อม strings ด้วย +. นี้เรียกว่า concatenation:

    first = "Mei"
    last = "Chen"
    print(first + " " + last)   # Mei Chen
    
    3.4

    f-strings

    f-string สร้างข้อความจากค่าต่างๆ ใส่ f ก่อนเครื่องหมายอัญประกาศ แล้วเขียน {...} ล้อมรอบค่าที่ต้องการ

    name = "Mei"
    age = 17
    print(f"{name} is {age} years old")   # Mei is 17 years old
    
    • นิพจน์อะไรก็ตามสามารถวางภายในวงเล็บปีกกาได้
    • {value:.2f} จะปัดเศษให้เหลือ 2 ตำแหน่งทศนิยม
    price = 9.5
    print(f"Two cost {price * 2}")        # Two cost 19.0
    print(f"Pi is about {3.14159:.2f}")   # Pi is about 3.14
    

    ข้อผิดพลาดที่พบบ่อย

    • Strings ไม่สามารถเปลี่ยนแปลงใน place: s[0] = "x"/operation raise error สร้าง string ใหม่แทน
    • Indexing เริ่มที่ 0; ตัวอักษรสุดท้ายคือ s[-1], และ s[len(s)] out of range
    • A slice s[a:b] includes a แต่หยุด ก่อน b
    • เมทอดของสตริงจะคืนค่าสตริง NEW: s.upper() จะไม่ทำงานใด ๆ เว้นแต่คุณจัดเก็บผลลัพธ์ไว้
  • 4 การคัดเลือก
    4.1

    if / elif / else

    โปรแกรมเลือกสิ่งที่จะทำกับ if. มันจะรันบล็อกที่เยื้องเฉพาะเมื่อเงื่อนไขเป็นจริง.บรรทัด if ต้องลงท้ายด้วยเครื่องหมายคั่น

    score = 72
    if score >= 60:
        print("pass")
    # pass
    

    เพิ่ม elif (else-if) สำหรับกรณีอื่นๆ และ else สำหรับ "ทุกกรณีที่เหลือ" Python จะรัน สาขาแรก ที่เป็นจริงเท่านั้น แล้วข้ามส่วนที่เหลือ

    score = 72
    if score >= 80:
        print("A")
    elif score >= 60:
        print("B")
    else:
        print("fail")
    # B
    
    • เปรียบเทียบค่าด้วย == (เท่ากับ), != (ไม่เท่ากัน), <, >, <=, >=.
    • การเปรียบเทียบให้ผลลัพธ์เป็น Boolean — คือ True หรือ False เท่านั้น
    if / elif / else: รันเพียงสาขาเดียว
    if / elif / else: รันเพียงสาขาเดียว
    4.2

    การรวมเงื่อนไข

    เชื่อมเงื่อนไขด้วย and, or, not. and ต้องการให้ ทั้งสอง ด้านเป็นจริง; or ต้องการให้ ด้านใดด้านหนึ่ง เป็นจริง; not กลับค่า Boolean

    age = 16
    has_ticket = True
    if age >= 18 and has_ticket:
        print("entry allowed")
    else:
        print("entry refused")
    # entry refused
    
    • ใช้วงเล็บเพื่อทำให้ลำดับชัดเจน: (a or b) and c.
    temp = 30
    if temp > 25 and not temp > 35:
        print("warm but ok")
    # warm but ok
    

    ข้อผิดพลาดที่พบบ่อย

    • เขียน elif, ไม่ใช่ else if.
    • ทุกบรรทัด if / elif / else ลงท้ายด้วยเครื่องหมายคั่น :, และบอดี้ต้องมีการเยื้อง
    • if x = 5: เป็นข้อผิดพลาด — ใช้ == เพื่อเปรียบเทียบ
    • else ไม่ต้องการเงื่อนไข; เฉพาะ if และ elif ที่ต้องการ
  • 5 การวนซ้ำ
    5.1

    ลูป for และ range

    ลูปซ้ำโค้ดลูป for จะซ้ำสำหรับแต่ละรายการในลำดับ range(n) ให้ตัวเลข 0 ถึง n - 1

    for i in range(5):
        print(i)
    # 0, then 1, 2, 3, 4 (each on its own line)
    
    • range(a, b) ไปจาก a ขึ้นไป (แต่ไม่รวม) b
    • range(a, b, step) เพิ่มขั้นตอนในแต่ละครั้ง
    for n in range(2, 11, 2):
        print(n)        # 2 4 6 8 10
    
    for i in range(n): บอดี้รันด้วย i = 0 … n-1
    for i in range(n): บอดี้รันด้วย i = 0 … n-1
    5.2

    รูปแบบตัวสะสม

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

    total = 0
    for n in range(1, 6):
        total = total + n
    print(total)        # 15
    
    • หลักการเดียวกันนี้ใช้นับว่ามีรายการตรงกับการทดสอบกี่รายการ
    count = 0
    for letter in "banana":
        if letter == "a":
            count = count + 1
    print(count)        # 3
    
    5.3

    ลูป while

    ลูป while จะทำซ้ำ ตราบใดที่ เงื่อนไขยังคงเป็นจริง หากไม่มีการเปลี่ยนแปลงภายใน หรือจะไม่หยุด — ลูปไม่มีที่สิ้นสุด

    n = 1
    while n <= 3:
        print(n)
        n = n + 1
    # 1 2 3
    
    • break ออกจากลูปทันที
    total = 0
    while True:
        total = total + 10
        if total >= 30:
            break
    print(total)        # 30
    
    5.4

    Nested loops

    ลูปภายในอีกลูปหนึ่งคือลูปซ้อน ลูปภายในจะรันเต็มรูปแบบสำหรับ แต่ละ รอบของลูปภายนอก

    for row in range(3):
        line = ""
        for col in range(3):
            line = line + "*"
        print(line)
    # ***
    # ***
    # ***
    

    ข้อผิดพลาดที่พบบ่อย

    • range(n) ไปจาก 0 ถึง n - 1, ไม่ใช่ 1 ถึง n — ข้อผิดพลาด off-by-one แบบคลาสสิก
    • การเปลี่ยนลิสต์ขณะวนลูปจะทำให้ข้ามรายการ; ให้วนลูปบนสำเนาถ้าคุณจำเป็นต้องลบบางสิ่ง
    • การลืมเปลี่ยนตัวแปรลูปใน while จะทำให้มันรันตลอดกาล
    • การเยื้องกำหนดว่าอะไรอยู่ในลูป; บรรทัดเยื้องผิดจะรันเพียงครั้งเดียว หลังจบลูป
  • 6 Lists & 2-D lists
    6.1

    รายการ

    ลิสต์เก็บหลายค่าตามลำดับ ภายใน []. แต่ละรายการมีดัชนี (ตั้งแต่ 0).

    scores = [88, 71, 95]
    print(scores[0])      # 88
    print(len(scores))    # 3
    scores.append(60)     # add to the end
    print(scores)         # [88, 71, 95, 60]
    
    • เปลี่ยนรายการโดยใช้ดัชนี: scores[1] = 100.
    • ลิสต์สามารถขยายและหดได้; สตริงไม่สามารถทำได้

    เครื่องมือลิสต์ในชีวิตประจำวัน:

    เครื่องมือ ทำอะไร
    a.append(x) เพิ่ม x ที่ปลายสุด
    a.insert(i, x) แทรก x ที่ตำแหน่ง i
    a.remove(x) ลบ x ตัวแรกออก
    a.pop() / a.pop(i) ลบและคืนค่ารายการสุดท้าย / รายการ i
    a.sort() เรียงลำดับรายการในตำแหน่งเดิม
    sorted(a) คืนค่าลิสต์ที่เรียงลำดับใหม่
    x in a มี x อยู่ในรายการหรือไม่?
    len(a), sum(a), max(a), min(a) ขนาดและการคำนวณเร็ว
    ดัชนีลิสต์เริ่มต้นที่ 0
    ดัชนีลิสต์เริ่มต้นที่ 0
    6.2

    การ traverse ลิสต์

    การ traverse ลิสต์คือการเข้าถึงแต่ละรายการ ลูป for ทำสิ่งนี้ได้โดยไม่ต้องใช้ดัชนี

    scores = [88, 71, 95]
    total = 0
    for s in scores:
        total = total + s
    print(total)          # 254
    
    • ใช้ enumerate เมื่อคุณยังต้องการดัชนีด้วย
    for i, name in enumerate(["a", "b"]):
        print(i, name)    # 0 a  /  1 b
    
    6.3

    ลิสต์ 2 มิติ (ตาราง)

    ลิสต์ 2 มิติคือลิสต์ของลิสต์ — ตารางของแถวและหลัก ใช้สองดัชนี: grid[row][col]

    grid = [[1, 2, 3],
            [4, 5, 6]]
    print(grid[0][2])     # 3
    print(grid[1][0])     # 4
    
    • ลูปซ้อนจะเข้าถึงทุกเซลล์
    grid = [[1, 2], [3, 4]]
    for row in grid:
        for value in row:
            print(value, end=" ")
    print()               # 1 2 3 4
    
    6.4

    List comprehensions

    List comprehension สร้างลิสต์ใหม่ในบรรทัดเดียว: [expression for item in sequence]

    squares = [x * x for x in range(5)]
    print(squares)        # [0, 1, 4, 9, 16]
    
    • เพิ่ม if เพื่อเก็บเฉพาะบางรายการ
    evens = [n for n in range(10) if n % 2 == 0]
    print(evens)          # [0, 2, 4, 6, 8]
    
    6.5

    Tuples & sets

    Tuple เป็นลำดับคงที่ในวงเล็บกลม ไม่สามารถเปลี่ยนแปลงได้หลังจากสร้าง — ใช้สำหรับค่าที่เกี่ยวข้องกัน และแยกมันออกมาเป็นชื่อ

    point = (3, 4)
    x, y = point            # unpacking
    print(x, y)             # 3 4
    

    ฟังก์ชันที่ต้องการส่งผลลัพธ์สองค่าจะคืนค่า tuple:

    def min_max(nums):
        return min(nums), max(nums)
    
    lo, hi = min_max([5, 2, 9])
    print(lo, hi)           # 2 9
    

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

    votes = ["red", "blue", "red", "green", "red"]
    colours = set(votes)
    print(len(colours))         # 3  (duplicates removed)
    print("blue" in colours)    # True
    

    ข้อผิดพลาดที่พบบ่อย

    • b = a ใช้รายการเดียวกัน a.copy() หรือ a[:] สร้างรายการภายนอกใหม่ แต่รายการภายในที่แก้ไขได้ยังคงถูกแบ่งปัน (การคัดลอกแบบตื้น)
    • รายการสุดท้ายคือ a[-1]; a[len(a)]อยู่นอกช่วงที่ยอมรับได้.
    • append เพิ่ม หนึ่ง รายการ; ใช้ extend หรือ + เพื่อรวมลิสต์อื่น
    • การสร้างตารางด้วย [[0]*3]*3 จะสร้างสำเนา แถวเดียวกัน สาม बार ให้สร้างแถวในลูปแทน
    • Tuple ที่มีรายการเดียวต้องมีลูกน้ำ: (5,), ไม่ใช่ (5)
    • Set ไม่มีลำดับและไม่มีความซ้ำซ้อน ดังนั้นคุณไม่สามารถใช้ดัชนีกับ s[0] ได้
  • 7 Dictionaries
    7.1

    Dictionary

    Dictionary (dict) เก็บคู่ key → value คุณค้นหาค่าโดยใช้ key ไม่ใช่ดัชนีตัวเลข

    student = {"name": "Mei", "score": 88}
    print(student["name"])     # Mei
    print(student["score"])    # 88
    

    เพิ่มและอัปเดต

    กำหนดค่าให้ key เพื่อเพิ่มหรือเปลี่ยนแปลงที่มีอยู่

    student = {"name": "Mei"}
    student["score"] = 88      # add a new key
    student["score"] = 90      # update the value
    print(student)             # {'name': 'Mei', 'score': 90}
    

    ตรวจสอบและวนลูป

    ใช้ in เพื่อตรวจสอบว่ามีคีย์หรือไม่วนลูปผ่านคีย์ หรือวนลูปผ่าน .items() เพื่อดึงทั้งคีย์และค่าออกมา

    student = {"name": "Mei", "score": 90}
    print("score" in student)  # True
    for key, value in student.items():
        print(key, "=", value)
    # name = Mei
    # score = 90
    
    • .get(key, default) คืนค่า default เมื่อ key หายไป — ไม่มีข้อผิดพลาด
    student = {"name": "Mei"}
    print(student.get("age", 0))   # 0
    

    รูปแบบข้อสอบคลาสสิก — นับว่าแต่ละค่าปรากฏบ่อยแค่ไหน:

    word = "banana"
    counts = {}
    for letter in word:
        counts[letter] = counts.get(letter, 0) + 1
    print(counts)   # {'b': 1, 'a': 3, 'n': 2}
    
    • .get(letter, 0) จะมอบค่า 0 เมื่อพบคีย์ครั้งแรก ทำให้ไม่มี KeyError

    ข้อผิดพลาดที่พบบ่อย

    • อ่าน key ที่หายไปด้วย d[key] จะเกิด KeyError; ใช้ d.get(key) หรือทดสอบ if key in d ก่อน
    • การกำหนดค่า d[key] อีกครั้งจะทับค่าเก่า — keys เป็นเอกลักษณ์
    • Keys ต้องเป็น immutable เช่น string หรือ number — list ไม่สามารถเป็น key ได้
    Dictionary map each key to one value
    Dictionary map each key to one value
  • 8 Functions & abstraction
    8.1

    การกำหนดและเรียกใช้ฟังก์ชัน

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

    def greet():
        print("Hello!")
    
    greet()        # Hello!
    greet()        # Hello!
    
    • โค้ดภายในจะรันก็ต่อเมื่อคุณเรียกใช้ฟังก์ชัน
    def นิยาม; call เรียกใช้; return ส่งค่ากลับ
    def กำหนดฟังก์ชัน; call เรียกใช้; return ส่งค่ากลับ
    8.2

    ค่าที่ส่งกลับ (Return values)

    ฟังก์ชันสามารถส่งค่ากลับด้วย return การเรียกใช้จะแทนที่ด้วยค่านั้น

    def square(n):
        return n * n
    
    print(square(5))          # 25
    print(square(3) + 1)      # 10
    
    • return จะหยุดการทำงานของฟังก์ชันทันที ฟังก์ชันที่ไม่มี return จะให้ None
    8.3

    พารามิเตอร์, อาร์กิวเมนต์ & สโคป

    พารามิเตอร์คือชื่อใน def อาร์กิวเมนต์คือค่าที่คุณส่งเข้าไป

    def power(base, exp):         # base, exp are parameters
        return base ** exp
    
    print(power(2, 3))            # 8  (2 and 3 are arguments)
    

    ตัวแปรที่สร้างภายในฟังก์ชันจะเป็น Local — มีอยู่เฉพาะที่นั้น พื้นที่นี้คือสโคปของมัน

    def f():
        x = 10            # local to f
        return x
    
    print(f())            # 10
    # print(x) here would be an error: x is not defined outside f
    

    พารามิเตอร์สามารถมีค่าเริ่มต้นได้ ใช้เมื่อผู้เรียกไม่ระบุ:

    def greet(name, greeting="Hello"):
        return greeting + ", " + name
    
    print(greet("Mei"))              # Hello, Mei
    print(greet("Sam", "Welcome"))   # Welcome, Sam
    
    8.4

    การนามธรรมเชิงขั้นตอน (Procedural abstraction)

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

    def area_of_rectangle(w, h):
        return w * h
    
    print(area_of_rectangle(4, 5))   # 20
    
    • ฟังก์ชันที่ดีควรทำหน้าที่เดียว มีชื่อชัดเจน และหลีกเลี่ยงการซ้ำซ้อนของโค้ด
    8.5

    โมดูลและการนำเข้า (Modules & imports)

    โมดูลคือไฟล์ที่มีฟังก์ชันสำเร็จรูป นำเข้าโดยใช้ import

    import random
    random.seed(0)               # makes the result repeatable
    print(random.randint(1, 6))  # a dice roll
    
    import math
    print(math.sqrt(16))         # 4.0
    

    ข้อผิดพลาดที่พบบ่อย

    • ฟังก์ชันจะคืนค่า None เว้นแต่คุณจะเขียน return การพิมพ์ไม่ใช่การส่งค่ากลับ
    • อย่าใช้ค่าเริ่มต้นแบบ mutable เช่น def f(x=[]) — ลิสต์เดียวกันจะถูกแชร์ระหว่างทุกการเรียกใช้
    • ตัวแปรที่สร้างภายในฟังก์ชันเป็น Local และไม่มองเห็นภายนอกได้
    • เรียกใช้ฟังก์ชันด้วย f(); การเขียน f เพียงอย่างเดียวเป็นการตั้งชื่อเท่านั้น
  • 9 Errors, exceptions & testing
    9.1

    ข้อผิดพลาดและการดีบัก (Errors & debugging)

    โค้ดล้มเหลวได้สามแบบ: Syntax error ฝ่าฝืนกฎ Python จึงไม่รัน Runtime error เกิดขณะรัน เช่น หารด้วยศูนย์ Logic error รันได้แต่ให้คำตอบผิด

    Error ปกติของ Python: Syntax, Name, Type, Index
    Error ปกติของ Python: Syntax, Name, Type, Index
    # A runtime error, caught so this block still finishes:
    try:
        print(10 / 0)
    except ZeroDivisionError:
        print("cannot divide by zero")
    # cannot divide by zero
    
    • Python แสดง traceback ที่บอกจุดที่ผิดพลาด อ่านจากด้านล่างขึ้นด้านบน
    9.2

    try / except / raise

    ใส่โค้ดที่เสี่ยงเข้าไปใน try; ถ้าล้มเหลว except จะจัดการกับข้อผิดพลาดแทนการค้าง

    def to_int(text):
        try:
            return int(text)
        except ValueError:
            return 0
    print(to_int("abc"))   # 0
    
    • จับประเภทเฉพาะ (ValueError, ZeroDivisionError, …)
    • raise สร้างข้อผิดพลาดของคุณเองโดยเจตนา
    def set_age(age):
        if age < 0:
            raise ValueError("age cannot be negative")
        return age
    
    try:
        set_age(-1)
    except ValueError as err:
        print("error:", err)
    # error: age cannot be negative
    
    9.3

    การทดสอบและความทนทาน (Testing & robustness)

    การทดสอบตรวจสอบว่าโค้ดให้คำตอบถูกต้อง ลองกรณีปกติ และ กรณีขอบเขต — ข้อมูลว่าง, ศูนย์, ค่ามากพิเศษ

    def average(nums):
        if len(nums) == 0:        # edge case: empty list
            return 0
        return sum(nums) / len(nums)
    
    print(average([2, 4, 6]))     # 4.0
    print(average([]))            # 0
    
    • โค้ดที่ทนทานจะจัดการกับข้อมูลแปลกๆ ได้อย่างเหมาะสมโดยไม่ค้าง

    ข้อผิดพลาดที่พบบ่อย

    • อย่าใช้ bare except: — จับ Error เฉพาะ เช่น except ValueError:
    • Syntax error หยุดโปรแกรมทั้งหมดก่อนรัน ดังนั้นแก้ไขส่วนนั้นก่อน
    • ทดสอบกรณีขอบเขต (ข้อมูลว่าง, ศูนย์, ค่าสูงสุด) ไม่ใช่แค่กรณีง่าย
  • 10 ไฟล์
    10.1

    การอ่านและเขียนไฟล์ข้อความ (Reading & writing text files)

    ไฟล์ข้อความเก็บข้อมูลบนดิสก์ เปิดด้วย open(name, mode) โดย mode บอก read หรือ write ต้องใช้ with ซึ่งปิดไฟล์ให้คุณ

    การเขียน

    Mode "w" เขียนไฟล์ใหม่และลบเก่าออก

    with open("notes.txt", "w") as f:
        f.write("first line\n")
        f.write("second line\n")
    print("saved")            # saved
    

    การอ่าน

    Mode "r" (ค่าเริ่มต้น) อ่าน .read() คืนทั้งไฟล์เป็นสตริงเดียว

    with open("notes.txt", "w") as f:
        f.write("hello\nworld\n")
    with open("notes.txt") as f:
        print(f.read().strip())   # hello / world
    

    อ่านทีบรรทัด

    Loop ผ่านไฟล์เพื่อรับบรรทัดละหนึ่งบรรทัด .strip() ลบ newline ที่ท้ายออก

    with open("data.txt", "w") as f:
        f.write("Mei,88\nSam,71\n")
    with open("data.txt") as f:
        for line in f:
            name, score = line.strip().split(",")
            print(name, "scored", score)
    # Mei scored 88
    # Sam scored 71
    

    การเพิ่มต่อ (Appending)

    Mode "a" เพิ่มต่อ — เพิ่มที่ท้ายโดยไม่ลบ

    with open("log.txt", "w") as f:
        f.write("line 1\n")
    with open("log.txt", "a") as f:
        f.write("line 2\n")
    with open("log.txt") as f:
        print(f.read().strip())   # line 1 / line 2
    
    Mode ความหมาย
    "r" read (ค่าเริ่มต้น)
    "w" write (ลบก่อน)
    "a" append (เพิ่มที่ท้าย)

    ข้อผิดพลาดที่พบบ่อย

    • ปิดไฟล์เสมอ หรือใช้ with open(...) as f: ที่ปิดให้
    • read() ให้ทั้งไฟล์เป็นสตริง และแต่ละบรรทัดยังลงท้ายด้วย \n
    • เปิดด้วย "w" จะลบไฟล์ก่อน; ใช้ "a" เพื่อเพิ่มที่ท้าย
    open → read/write → close (with auto-closes)
    open → read/write → close (with auto-closes)
  • 11 Algorithm design
    11.1

    อัลกอริทึมและการแยกย่อย (Algorithms & decomposition)

    อัลกอริทึมคือรายการขั้นตอนที่ชัดเจนแก้ปัญหา Decomposition คือการแบ่งปัญหาย่อยเป็นชิ้นเล็กๆ แก้ทีละส่วน

    # Algorithm: find the largest number in a list
    def largest(nums):
        best = nums[0]
        for n in nums:
            if n > best:
                best = n
        return best
    
    print(largest([3, 9, 2, 7]))   # 9
    
    • Nามธรรมคือการละรายละเอียด: ใช้ largest(...) โดยไม่ต้องอ่านวิธีการทำงานซ้ำ
    11.2

    รหัสเทียมและแผนภาพไหล (Pseudocode & flowcharts)

    伪代码 (Pseudocode) คือภาษาอังกฤษแบบโครงสร้างสำหรับอัลกอริทึม เขียนก่อนโค้ดจริง ไม่สามารถรันได้

    SET best TO first number
    FOR Each number n
        IF n > best
          THEN
            SET best TO n
    OUTPUT best
    

    Flowchart วาดแผนเดียวกัน: กล่องสำหรับแต่ละขั้นตอน, เพชรสำหรับแต่ละการตัดสินใจ, และลูกศรสำหรับลำดับ

    11.3

    การเรียกซ้ำและ Call stack

    Recursion คือฟังก์ชันเรียกตัวเอง ต้องการ base case (อินพุตง่ายที่คืนค่าทันที) และ recursive case (เรียกตัวเองกับอินพุตเล็กลง)

    Stack ของการเรียก factorial(3): การเรียกแต่ละครั้งรอแล้วคืนค่าตามลำดับย้อนกลับ
    Stack ของการเรียก factorial(3): การเรียกแต่ละครั้งรอแล้วคืนค่าตามลำดับย้อนกลับ
    def fact(n):
        return 1 if n <= 1 else n * fact(n - 1)
    
    print(fact(5))     # 120
    
    • ทุกการเรียกที่ถูกหยุดจะอยู่บน call stack จนกว่าการเรียกด้านบนจะคืนค่า

    ข้อผิดพลาดที่พบบ่อย

    • Recursion จำเป็นต้องมี base case มิฉะนั้นจะเรียกตัวเองตลอดจน call stack ค้าง
    • รหัสเทียมสำหรับการวางแผน — ไม่ต้องรัน แต่ทุกขั้นต้องชัดเจน
    • แบ่งปัญหาย่อยเป็นขั้นเล็กๆ ที่มีชื่อก่อนเขียนโค้ด
  • 12 Data structures
    12.1

    ประเภทข้อมูลนามธรรม (ADTs)

    Abstract data type (ADT) อธิบายข้อมูลพร้อม operation แยกจากวิธีการสร้าง ใช้ผ่าน operation ไม่ใช่การจัดเก็บภายใน

    # A stack ADT, built on a list
    s = []
    s.append(1)        # add
    s.append(2)
    print(s.pop())     # 2  (remove the most recent)
    
    12.2

    Stack

    Stack เป็น Last-in, First-out (LIFO) Push ด้านบน Pop ด้านบน

    Stack ลบจากบน (LIFO); Queue ลบจากหน้า (FIFO)
    Stack ลบจากบน (LIFO); Queue ลบจากหน้า (FIFO)
    stack = []
    stack.append("a")
    stack.append("b")
    print(stack.pop())   # b
    print(stack.pop())   # a
    
    12.3

    Queue

    Queue เป็น First-in, First-out (FIFO) Enqueue หลัง Dequeue หน้า

    queue = []
    queue.append("a")     # enqueue
    queue.append("b")
    print(queue.pop(0))   # a  (dequeue the front)
    print(queue.pop(0))   # b
    
    12.4

    ลิงค์ลิสต์ (Linked lists)

    Linked list คือโซ่ของ Node แต่ละ Node เก็บข้อมูลและ Pointer ไป Node ถัดไป ตัวสุดท้ายชี้ None

    Linked list: แต่ละ Node เก็บข้อมูลและ Pointer ไป Node ถัดไป สิ้นสุดที่ None
    Linked list: แต่ละ Node เก็บข้อมูลและ Pointer ไป Node ถัดไป สิ้นสุดที่ None
    n3 = {"data": 3, "next": None}
    n2 = {"data": 2, "next": n3}
    n1 = {"data": 1, "next": n2}
    node = n1
    while node is not None:      # traverse to the end
        print(node["data"])
        node = node["next"]
    # 1 2 3
    
    12.5

    Hash tables

    ตารางแฮชจับคู่คีย์เข้ากับช่องด้วยฟังก์ชันแฮช คีย์สองตัวอาจตกอยู่ในช่องเดียวกัน — การชน Python ใช้ dict เป็นตารางแฮช ทำให้การค้นหาได้รวดเร็ว

    ฟังก์ชันแฮชจับคู่คีย์แต่ละตัวกับช่อง; คีย์สองตัวอาจชนกันในช่องเดียว
    ฟังก์ชันแฮชจับคู่คีย์แต่ละตัวเข้ากับช่องเก็บข้อมูล; คีย์สองตัวอาจชนกันอยู่ในช่องเดียวกัน
    table = {}
    table["Mei"] = 88
    table["Sam"] = 71
    print(table["Mei"])   # 88  (fast lookup by key)
    
    12.6

    Binary Search Trees

    ต้นไม้ค้นหาแบบเบย์ (BST) รักษาลำดับ: ลูกทางซ้ายมีค่าน้อยกว่าโหนดเสมอ ลูกทางขวามีค่ามากกว่า โน้ดเสมอ การค้นหาจึงรวดเร็ว

    ต้นไม้ค้นหาแบบเบย์: ค่าที่น้อยกว่าไปทางซ้าย, ค่าที่มากกว่าไปทางขวา
    ต้นไม้ค้นหาแบบเบย์: ค่าที่น้อยกว่าไปทางซ้าย, ค่าที่มากกว่าไปทางขวา
    def insert(root, val):
        if root is None:
            return {"val": val, "left": None, "right": None}
        if val < root["val"]:
            root["left"] = insert(root["left"], val)
        else:
            root["right"] = insert(root["right"], val)
        return root
    
    def inorder(root):
        if root is None:
            return []
        return inorder(root["left"]) + [root["val"]] + inorder(root["right"])
    
    tree = None
    for v in [5, 3, 8, 1, 4]:
        tree = insert(tree, v)
    print(inorder(tree))   # [1, 3, 4, 5, 8]
    
    12.7

    Graphs

    กราฟคือชุดของจุดยอดเชื่อมต่อกันด้วยเส้นขอบ วิธีเก็บข้อมูลทั่วไปคือรายการเพื่อนร่วมทาง — dict ของรายการเพื่อนร่วมทาง

    กราฟของจุดยอดและเส้นขอบ พร้อมรูปแบบรายการเพื่อนร่วมทาง
    กราฟของจุดยอดและเส้นขอบ พร้อมรูปแบบรายการเพื่อนร่วมทาง
    graph = {"A": ["B", "D"], "B": ["A", "C"], "C": ["B", "D"], "D": ["A", "C"]}
    for vertex in graph:
        print(vertex, "->", graph[vertex])
    # A -> ['B', 'D']  (and so on for B, C, D)
    

    ข้อผิดพลาดที่พบบ่อย

    • สแต็กเป็นแบบเข้าหลังออกก่อน; ควูเป็นแบบเข้าก่อนออกก่อน อย่าสับสนกัน
    • ตรวจสอบว่าโครงสร้างนั้นว่างหรือไม่ ก่อนที่จะดึงหรือดีคิวจากมัน
    • ในลิงก์ลิสต์ หากสูญเสียพอยเตอร์ head จะทำให้เสียลิงก์ลิสต์ทั้งหมด
  • 13 Searching, sorting & efficiency
    13.1

    Linear & binary search

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

    def linear_search(items, target):
        for i in range(len(items)):
            if items[i] == target:
                return i
        return -1     # not found
    
    print(linear_search([4, 8, 2, 9], 2))   # 2
    

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

    def binary_search(items, target):
        lo, hi = 0, len(items) - 1
        while lo <= hi:
            mid = (lo + hi) // 2
            if items[mid] == target:
                return mid
            elif items[mid] < target:
                lo = mid + 1
            else:
                hi = mid - 1
        return -1
    
    print(binary_search([1, 3, 5, 7, 9], 7))   # 3
    
    การค้นหาแบบเบย์แบ่งช่วงครึ่งหนึ่งในแต่ละขั้นตอน — O(log n) บนลิงก์ลิสต์ที่เรียงลำดับแล้ว
    การค้นหาแบบเบย์แบ่งช่วงครึ่งหนึ่งในแต่ละขั้นตอน — O(log n) บนลิงก์ลิสต์ที่เรียงลำดับแล้ว
    13.2

    การจัดอันดับ (บับเบิล & อินเซอร์ชัน)

    การจัดอันดับคือการวางรายการให้อยู่ในลำดับ บับเบิลโซrts ทำการสลับเพื่อนบ้านที่มีลำดับผิดซ้ำๆ

    def bubble_sort(a):
        a = a[:]                          # work on a copy
        for i in range(len(a)):
            for j in range(len(a) - 1 - i):
                if a[j] > a[j + 1]:
                    a[j], a[j + 1] = a[j + 1], a[j]
        return a
    
    print(bubble_sort([5, 2, 4, 1]))      # [1, 2, 4, 5]
    

    อินเซอร์ชันโซrts สร้างส่วนที่เรียงลำดับแล้วทีละรายการ โดยเลื่อนรายการใหม่กลับเข้าไปในตำแหน่งที่เหมาะสม:

    def insertion_sort(a):
        a = a[:]                           # work on a copy
        for i in range(1, len(a)):
            key = a[i]
            j = i - 1
            while j >= 0 and a[j] > key:   # shift bigger values right
                a[j + 1] = a[j]
                j -= 1
            a[j + 1] = key                 # drop key into the gap
        return a
    
    print(insertion_sort([5, 2, 4, 1]))   # [1, 2, 4, 5]
    
    • ในโค้ดจริง ให้ใช้ sorted() ในPython builtin:
    print(sorted([5, 2, 4, 1]))           # [1, 2, 4, 5]
    
    13.3

    ประสิทธิภาพของอัลกอริทึม

    ประสิทธิภาพถามว่างานเพิ่มขึ้นอย่างไรเมื่อข้อมูลเข้าเพิ่มขึ้น อธิบายได้ด้วย Big-O

    จำนวนขั้นตอนเพิ่มขึ้นตามขนาดอินพุตสำหรับความซับซ้อนทั่วไป
    จำนวนขั้นตอนเพิ่มขึ้นตามขนาดอินพุตสำหรับความซับซ้อนทั่วไป
    Big-O ชื่อ ตัวอย่าง
    $O(1)$ คงที่ ดูค่าดิกชันนารี
    $O(\log n)$ ลอการิทึม การค้นหาแบบเบย์
    $O(n)$ เชิงเส้น การค้นหาเชิงเส้น
    $O(n^2)$ สี่เหลี่ยม บับเบิลโซrts
    def steps(n):           # how many steps a linear scan takes
        count = 0
        for i in range(n):
            count = count + 1
        return count
    
    print(steps(100))       # 100  -> O(n)
    
    13.4

    ความสุ่มและการจำลอง

    โมดูล random ใช้สร้างตัวเลขสุ่ม. ใช้ค่าเริ่มต้น (seed) เพื่อให้ผลลัพธ์ซ้ำกันได้. การจำลองสถานการณ์จะทำการทดลองสุ่มจำนวนมากเพื่อประมาณคำตอบ.

    import random
    random.seed(0)
    rolls = [random.randint(1, 6) for _ in range(1000)]
    print(rolls.count(6))   # about 1/6 of 1000
    

    ข้อผิดพลาดที่พบบ่อย

    • การค้นหาแบบเบย์ใช้ได้เฉพาะกับ ลิงก์ลิสต์ ที่ เรียงลำดับ เท่านั้น
    • Big-O บอกคุณว่าเวลาเพิ่มขึ้นอย่างไร ไม่ใช่เวลาแน่นอน; วิธี O(n²) ดีกว่า O(n) สำหรับอินพุตขนาดเล็กเท่านั้น
    • บับเบิลโซrts เป็น O(n²) — เหมาะสำหรับการเรียนรู้ แต่ช้าสำหรับลิงก์ลิสต์ขนาดใหญ่
  • 14 OOP & paradigms
    14.1

    คลาสและออบเจกต์

    คลาสคือแบบร่าง ออบเจกต์คือสิ่งหนึ่งสร้างจากมัน (instance) __init__ คือ constructor ที่ตั้งค่าแต่ละออบเจกต์; self คือออบเจกต์เอง

    class Dog:
        def __init__(self, name):
            self.name = name            # an attribute
        def speak(self):
            return self.name + " says woof"
    
    d = Dog("Rex")
    print(d.speak())     # Rex says woof
    
    • name เป็นแอททริบิวต์ (ข้อมูลบนออบเจกต์); speak เป็นเมทอด (การกระทำ)

    เพิ่ม __str__ เพื่อควบคุมสิ่งที่ print(obj) แสดง:

    class Dog:
        def __init__(self, name):
            self.name = name
        def __str__(self):
            return f"Dog named {self.name}"
    
    print(Dog("Rex"))    # Dog named Rex
    
    คลาสคือแบบร่าง; การเรียกใช้มันสร้างออบเจกต์
    คลาสคือแบบร่าง; การเรียกใช้มันสร้างออบเจกต์
    14.2

    การสืบทอด การห่อหุ้ม และความหลากหลาย

    การสืบทอดช่วยให้ subclass นำ superclass มาใช้ใหม่ ใช้ super() เพื่อเรียกผู้ปกครอง; Override method เพื่อแก้ไข

    class Animal:
        def speak(self):
            return "some sound"
    
    class Cat(Animal):
        def speak(self):                # override
            return "meow"
    
    print(Cat().speak())   # meow
    

    Encapsulation รวมข้อมูลกับเมทოდและเปิดเผยอินเทอร์เฟซที่กำหนดให้ ใน Python การนำหน้าด้วยขีดล่างบ่งบอกชื่อที่ไม่ควรเข้าถึงสาธารณะ (มักเรียกว่า private) ตามธรรมเนียม; ไม่ป้องกันโค้ดภายนอกจากการเข้าถึง การจัดการชื่อด้วยขีดล่างคู่ช่วยหลีกเลี่ยงความขัดแย้งของชื่อในคลาสลูกโดยไม่ต้องการ แต่ไม่ใช่การบังคับความปลอดภัย

    class Account:
        def __init__(self):
            self._balance = 0           # non-public by convention
        def deposit(self, n):
            self._balance += n
        def balance(self):
            return self._balance
    
    a = Account()
    a.deposit(50)
    print(a.balance())     # 50
    

    Polymorphism หมายถึงชื่อเดียวแต่พฤติกรรมหลายอย่าง — speak ที่ถูกต้องจะถูกเรียกใช้สำหรับแต่ละวัตถุ

    class Cat:
        def speak(self):
            return "meow"
    
    class Cow:
        def speak(self):
            return "moo"
    
    for animal in [Cat(), Cow()]:
        print(animal.speak())   # meow, then moo
    
    14.3

    แนวคิดการเขียนโปรแกรม

    Paradigm คือรูปแบบการเขียนโปรแกรม โค้ดแบบ Procedural เป็นลำดับขั้นตอนและฟังก์ชัน โค้ดแบบ Object-Oriented จัดกลุ่มข้อมูลและเมทოდ์เข้าด้วยกันเป็นออบเจ็กต์ โค้ดแบบ Declarative บอก สิ่งที่ ต้องการ ไม่ใช่วิธีการ (เช่น list comprehension หรือ SQL)

    def total(nums):           # procedural
        t = 0
        for n in nums:
            t += n
        return t
    print(total([1, 2, 3]))    # 6
    
    print(sum([1, 2, 3]))      # 6  (declarative: same result)
    

    ข้อผิดพลาดที่พบบ่อย

    • เมทอดทุกตัวต้องรับ self เป็นพารามิเตอร์แรกเสมอ
    • __init__ ตั้งค่า new object และรันอัตโนมัติเมื่อคุณสร้างมัน
    • Two objects ของ same class มี separate attributes; เปลี่ยน one ไม่ทำให้ other เปลี่ยน
  • 15 Data representation
    15.1

    บิตและระบบเลขฐานสอง

    Bitคือ 0 หรือ 1 เดียว ระบบเลขฐานสองคือระบบเลข base-2: แต่ละตำแหน่งมีค่าเท่าสองเท่าของตำแหน่งทางขวา (1, 2, 4, 8, …) Decimal (base-10) คือตัวเลขปกติของเรา

    ตำแหน่งเลขฐานสอง: 1101 หมายถึง 8 + 4 + 1 = 13
    ตำแหน่งเลขฐานสอง: 1101 หมายถึง 8 + 4 + 1 = 13
    print(bin(13))         # 0b1101
    print(int("1101", 2))  # 13
    
    • 8 bits ทำให้ byte. Width ที่กำหนดสามารถ overflow (wrap around) เมื่อตัวเลขมีค่ามากเกินไป
    x = 250
    x = (x + 10) % 256     # one byte wraps at 256
    print(x)               # 4
    

    Hexadecimal (ฐาน 16) เป็นวิธีอ่านเลขฐานสองที่กระชับ: ตัวเลข hex หนึ่งตัวแทน 4 บิตพอดี Python เขียนเลข hex ด้วย 0x:

    print(hex(255))        # 0xff
    print(0xFF)            # 255
    print(int("ff", 16))   # 255
    
    15.2

    การบีบอัด

    Compressionทำให้ข้อมูลเล็กลง Lossless compressionเก็บทุก bit ดังนั้นคุณจึงสร้างต้นฉบับขึ้นใหม่ได้อย่างแม่นยำ Lossy compressionทิ้งรายละเอียด — เล็กลงแต่ไม่แม่นยำ — และใช้สำหรับรูปถ่ายและเพลง

    Run-length encodingเป็นวิธี lossless ง่าย: เก็บ run (repeat) เป็น count plus ค่า

    def rle(text):
        out = ""
        i = 0
        while i < len(text):
            run = 1
            while i + run < len(text) and text[i + run] == text[i]:
                run += 1
            out += str(run) + text[i]
            i += run
        return out
    
    print(rle("AAAABBBCCD"))   # 4A3B2C1D
    

    ข้อผิดพลาดที่พบบ่อย

    • n บิต สามารถเก็บค่าที่แตกต่างกันได้ 2**n ค่า, ตั้งแต่ 0 ถึง 2**n - 1.
    • Lossy compression ทิ้งรายละเอียดและไม่สามารถย้อนกลับได้; lossless สามารถย้อนกลับได้อย่างแม่นยำ
  • 16 Computing concepts
    16.1

    คอมพิวเตอร์คืออะไรและวงจรการออกแบบ

    Computingหมายถึงการแก้ปัญหาด้วยคอมพิวเตอร์: input, process, output. Softwareที่ดีสร้างในวงจรการออกแบบ — plan, write, test, improve — ทำซ้ำหลายครั้ง

    • แยกปัญหาออก สร้างส่วนเล็กๆ ทดสอบ แล้วเพิ่มมากขึ้น
    • Programmers ทำงานเป็นทีมและนำโค้ดของผู้อื่นกลับมาใช้ใหม่
    16.2

    อินเทอร์เน็ต

    อินเทอร์เน็ตคือเครือข่ายของเครือข่าย ข้อมูลถูกแบ่งเป็นแพ็กเก็ตที่เดินทางแยกกันและรวมกลับที่ปลายทาง กฎร่วมที่เรียกว่าโปรโตคอล (เช่น TCP/IP) ทำให้สิ่งนี้ทำงานได้ หากเส้นทางใดล้มเหลว แพ็กเก็ตจะเลือกเส้นทางอื่น — นี่คือความซ้ำซ้อน ซึ่งให้ความทนทานต่อข้อผิดพลาด

    แผนที่ Internet: เส้นแต่ละเส้นคือเส้นทางระหว่างสอง networks
    แผนที่ Internet: เส้นแต่ละเส้นคือเส้นทางระหว่างสอง networks
    ชั้น งาน
    HTTP ขอและส่งหน้าเว็บ
    TCP ส่งมอบที่เชื่อถือได้ ตามลำดับ
    IP การกำหนดที่อยู่และการส่งต่อข้อมูล
    16.3

    การประมวลผลแบบขนานและการกระจาย

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

    • ไม่ใช่ทุกอย่างที่รันแบบขนานได้: บางขั้นตอนต้องรอผลลัพธ์จากขั้นตอนก่อนหน้า
    16.4

    ผลกระทบของการประมวลผลข้อมูล

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

    ข้อผิดพลาดที่พบบ่อย

    • อินเทอร์เน็ตและ World Wide Web ไม่เหมือนกัน: Web เป็นบริการหนึ่งที่ต้องอาศัยอินเทอร์เน็ตในการดำเนินการ
    • คอร์โปรเซสเซอร์มากขึ้นจะช่วยได้ก็ต่อเมื่องานสามารถแบ่งย่อยให้ทำงานพร้อมกันได้
  • 17 การรวมกัน
    17.1

    โปรเจกต์ย่อยแบบครบวงจร

    โปรเจกต์ย่อยรวมแนวคิดเดิมๆ เข้าด้วยกัน: ข้อมูลในลิสต์ ฟังก์ชันที่มีคำสั่งเลือกภายในลูป และการพิมพ์ผลลัพธ์ นี่คือรูปแบบของ AP Create Performance Task

    โปรเจกต์: คำนวณคะแนนเฉลี่ย

    def average(marks):
        if len(marks) == 0:
            return 0
        return round(sum(marks) / len(marks), 1)
    
    print(average([88, 71, 95, 60]))   # 78.5
    

    โปรเจกต์: นับจำนวนผ่านเกณฑ์

    def count_passes(marks, pass_mark=60):
        passes = 0
        for m in marks:                 # iteration
            if m >= pass_mark:          # selection
                passes += 1
        return passes
    
    print(count_passes([88, 50, 95, 60]))   # 3
    

    โปรเจกต์: กรองข้อมูลลงลิสต์ใหม่

    def merit(marks):
        return [m for m in marks if m >= 80]
    
    print(merit([88, 71, 95, 60]))     # [88, 95]
    

    AP Create Task ต้องการรายการ ขั้นตอนที่มีพารามิเตอร์ซึ่งใช้ selection และ iteration รวมถึง input/output แต่ละโครงการข้างต้นมีลักษณะเช่นนั้นทั้งหมด — สร้างชิ้นส่วนเล็กๆ แล้วนำมารวมกัน

    ข้อผิดพลาดที่พบบ่อย

    • สร้างทีละขั้นและทดสอบแต่ละส่วนก่อนไปต่อ — อย่าเขียนทั้งหมดพร้อมกัน
    • อ่านโจทย์ทั้งหมดก่อน แล้ววางแผนอินพุต → ประมวลผล → เอาต์พุตก่อนเริ่มเขียนโค้ด
    โปรเจกต์ย่อย: ข้อมูล → ฟังก์ชัน → ผลลัพธ์ที่พิมพ์
    โปรเจกต์ย่อย: ข้อมูล → ฟังก์ชัน → ผลลัพธ์ที่พิมพ์

เข้าสู่ระบบหรือสร้างบัญชี

IGCSE, A-Level & AP