Bỏ qua nội dung
Môn học
  • 1 Bắt đầu
    1.1

    Chương trình đầu tiên của bạn

    Python chạy mã của bạn từng dòng một. Mỗi dòng là một mệnh lệnh. Một chương trình chỉ là một danh sách các mệnh lệnh được thực thi từ trên xuống dưới.

    Hàm print() hiển thị văn bản lên màn hình. Đây được gọi là đầu ra. Văn bản nằm trong dấu ngoặc kép là chuỗi (string).

    print("Hello, world!")
    print("I am learning Python")
    
    • Mỗi print() bắt đầu một dòng mới.
    • Dấu ngoặc có thể là "double" hoặc 'single' — cả hai đều tạo thành một chuỗi.
    • Một chương trình không làm gì cả cho đến khi bạn chạy nó.
    Mã nguồn chạy qua interpreter để tạo ra kết quả
    Mã nguồn chạy qua trình biên dịch để tạo ra kết quả
    1.2

    Nhận xét & phong cách viết mã

    Một nhận bắt đầu bằng #. Python bỏ qua mọi thứ sau ký tự # trên dòng đó. Nhận giải thích mã của bạn cho người đọc; chúng không thay đổi hành vi của mã.

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

    Phong cách tốt giúp mã dễ đọc hơn:

    • Sử dụng tên rõ ràng để thể hiện ý nghĩa của giá trị.
    • Đặt một câu lệnh trên mỗi dòng.
    • Không thêm khoảng trắng ở đầu một dòng bình thường. Trong Python, khoảng trắng ở đầu (độ thụt vào) có ý nghĩa đặc biệt, vì vậy khoảng trắng sai sẽ gây ra lỗi.
    1.3

    Đầu vào, xử lý, đầu ra

    Nhiều chương trình tuân theo kế hoạch đơn giản: đầu vào → xử lý → đầu ra. Bạn nhận được dữ liệu, thực hiện thao tác với nó, sau đó hiển thị kết quả.

    Hàm input() đọc văn bản mà người dùng nhập. Nó luôn trả về một chuỗi ký tự (string).

    name = input("What is your name? ")
    print("Hello, " + name)
    
    • input() chờ người dùng nhập và nhấn Enter.
    • Lưu văn bản đã nhập vào biến để sử dụng sau này.
    • Vì input() trả về chuỗi, hãy chuyển đổi nó bằng int(...) trước nếu bạn cần số.

    Lỗi thường gặp

    • Quên dấu ngoặc: print(Hello) sẽ tìm kiếm biến tên là Hello và gây ra lỗi NameError. Văn bản cần dấu ngoặc: print("Hello").
    • Một khoảng trắng thừa ở đầu dòng: Python đọc độ thụt vào như cấu trúc, nên sẽ gây ra lỗi IndentationError.
    • Giả sử rằng input() trả về số. Nó luôn trả về chuỗi, vì vậy hãy bọc nó trong int(...) trước khi thực hiện bất kỳ phép tính nào.
  • 2 Biến, kiểu & toán tử
    2.1

    Biến & gán giá trị

    Biến là tên gọi cho một giá trị. Bạn tạo nó bằng cách gán =, còn gọi là gán giá trị. Tên biến nằm bên trái; giá trị nằm bên phải.

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

    Bây giờ age chứa 17. Sử dụng tên biến ở bất cứ đâu bạn cần giá trị, và thay đổi nó sau này:

    age = 17
    age = age + 1   # age is now 18
    print(age)
    
    Biến là tên gắn với giá trị đã lưu trữ
    Mỗi tên biến trỏ đến một giá trị trong bộ nhớ
    • Dấu = không có nghĩa là "bằng". Nó có nghĩa là "lưu giá trị vế phải dưới tên vế trái".
    • Để kiểm tra xem hai giá trị có bằng nhau hay không, hãy sử dụng == (xem phần dưới).
    2.2

    Số: int & float

    Python có hai loại số chính. Số nguyên (int) là một số nguyên như 17. Số thập phân (float) có dấu phẩy thập phân như 9.99.

    Các toán tử sau hoạt động trên các con số:

    Toán tử Ý nghĩa Ví dụ Kết quả
    + cộng 3 + 2 5
    - trừ 3 - 2 1
    * nhân 3 * 2 6
    / chia (luôn là số thập phân) 7 / 2 3.5
    // chia lấy phần nguyên 7 // 2 3
    % phần dư (modulo) 7 % 2 1
    ** lũy thừa 2 ** 3 8
    • / luôn trả về số thập phân, vì vậy 4 / 2 là 2.0.
    • // và % đi kèm với nhau: 17 // 5 là 3, và 17 % 5 là 2.
    2.3

    Biểu thức & chuyển đổi kiểu

    Một biểu thức là bất cứ thứ gì có giá trị, ví dụ như 3 + 4 * 2. Python tuân theo thứ tự toán học thông thường (* và / thực hiện trước + và -); hãy thêm ngoặc đơn để làm rõ thứ tự.

    input() trả về chuỗi, vì vậy hãy chuyển đổi nó trước khi thực hiện phép tính. Thay đổi giá trị từ kiểu này sang kiểu khác được gọi là chuyển đổi kiểu:

    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") thất bại, vì vậy chỉ chuyển đổi văn bản trông giống như số.
    • Trộn lẫn các kiểu cũng sẽ thất bại: "age: " + 17 là lỗi; hãy viết "age: " + str(17).
    2.4

    Giá trị logic & So sánh

    Một布尔值 (Boolean) chỉ có hai giá trị: True hoặc False. Một phép so sánh sẽ trả về布尔值 (Boolean).

    Toán tử Ý nghĩa
    == bằng với
    != khác với
    < > nhỏ hơn / lớn hơn
    <= >= nhỏ hơn / lớn hơn hoặc bằng
    print(7 > 2)        # True
    print(3 == 3.0)     # True
    age = 20
    print(age >= 18)    # True
    

    Nối các phép so sánh với and, or, not:

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

    Lỗi thường gặp

    • / luôn trả về số thập phân, ngay cả khi 4 / 2 là 2.0. Hãy sử dụng // khi bạn muốn số nguyên.
    • Sử dụng = nơi bạn có ý định là ==: = gán giá trị, == kiểm tra xem hai giá trị có bằng nhau hay không.
    • Ghép chuỗi và số: "age: " + 5 gây ra lỗi TypeError. Hãy chuyển đổi trước bằng str(5).
    • Số thập phân không chính xác tuyệt đối, vì vậy 0.1 + 0.2 không hoàn toàn bằng 0.3 — tránh == trên kết quả số thập phân.
  • 3 Chuỗi ký tự
    3.1

    Chỉ mục

    Một chuỗi là văn bản nằm trong dấu ngoặc kép. Mỗi ký tự đều có vị trí, được gọi là chỉ mục. Chỉ mục đầu tiên là 0, không phải 1.

    Đọc một ký tự với ngoặc vuông:

    word = "Python"
    print(word[0])    # P  (the first character)
    print(word[2])    # t
    print(len(word))  # 6  (how many characters)
    
    • Đếm bắt đầu từ 0, vì vậy chỉ mục cuối cùng là len(word) - 1.
    • Chỉ số âm đếm ngược từ cuối: word[-1] là ký tự cuối cùng.
    word = "Python"
    print(word[-1])   # n
    print(word[-2])   # o
    
    • Một chỉ mục quá lớn sẽ gây ra lỗi (một lỗi IndexError).
    s[start:stop] là cửa sổ mở một nửa các ký tự
    s[start:stop] là cửa sổ mở một nửa các ký tự
    3.2

    Cắt chuỗi (Slicing)

    Cắt chuỗi lấy một phần của chuỗi. Viết word[start:end]. Phần cắt giữ start nhưng dừng lại trước end.

    word = "Python"
    print(word[0:3])   # Pyt   (positions 0, 1, 2)
    print(word[2:5])   # tho
    
    • Bỏ qua start để bắt đầu từ 0; bỏ qua end để đi đến cuối.
    word = "Python"
    print(word[:3])    # Pyt
    print(word[3:])    # hon
    
    • Một số thứ ba là bước nhảy. word[::-1] đảo ngược chuỗi.
    print("Python"[::-1])   # nohtyP
    
    3.3

    Phương thức chuỗi & độ dài

    Một phương thức là một hàm thuộc về một giá trị. Bạn gọi nó bằng dấu chấm:

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

    Chuỗi không thể thay đổi tại chỗ: một phương thức trả về chuỗi mới và không bao giờ thay đổi chuỗi gốc.

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

    Các phương thức phổ biến (mỗi cái trả về một giá trị mới):

    Phương thức Ý nghĩa Ví dụ Kết quả
    .upper() / .lower() thay đổi chữ hoa/thường "Hi".lower() hi
    .strip() xóa khoảng trắng ở cạnh " hi ".strip() hi
    .replace(a, b) hoán đổi chữ hoa/thường "cat".replace("c", "b") bat
    .split(sep) tách thành danh sách "a,b".split(",") ['a', 'b']

    Ghép chuỗi với +. Điều này được gọi là nối chuỗi:

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

    f-strings

    f-string xây dựng văn bản từ các giá trị. Đặt f trước dấu ngoặc kép, sau đó viết {...} quanh một giá trị.

    name = "Mei"
    age = 17
    print(f"{name} is {age} years old")   # Mei is 17 years old
    
    • Bất kỳ biểu thức nào cũng có thể đặt trong dấu ngoặc nhọn.
    • {value:.2f} làm tròn đến 2 chữ số thập phân.
    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
    

    Lỗi thường gặp

    • Chuỗi không thể thay đổi tại chỗ: s[0] = "x" gây ra lỗi. Hãy xây dựng chuỗi mới thay thế.
    • Chỉ số bắt đầu từ 0; ký tự cuối cùng là s[-1], và s[len(s)] nằm ngoài phạm vi hợp lệ.
    • Một phần cắt s[a:b] bao gồm a nhưng dừng lại trước b.
    • Các phương thức chuỗi trả về MỘT CHUỖI MỚI: s.upper() không làm gì cả trừ khi bạn lưu kết quả.
  • 4 Sự lựa chọn
    4.1

    if / elif / else

    Một chương trình chọn thực hiện if. Nó chạy một khối thụt vào trong chỉ khi điều kiện là đúng. Dòng if kết thúc bằng dấu hai chấm.

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

    Thêm elif (else-if) cho nhiều trường hợp hơn và else cho "bất cứ điều gì khác". Python chỉ thực thi nhánh đầu tiên đúng, sau đó bỏ qua phần còn lại.

    score = 72
    if score >= 80:
        print("A")
    elif score >= 60:
        print("B")
    else:
        print("fail")
    # B
    
    • So sánh giá trị với == (bằng), != (khác), <, >, <=, >=.
    • Một phép so sánh trả về giá trị Boolean — hoặc True hoặc False.
    if / elif / else: chỉ một nhánh được thực thi
    if / elif / else: chỉ một nhánh được thực thi
    4.2

    Kết hợp các điều kiện

    Nối các điều kiện bằng and, or, not. and cần cả hai vế đều đúng; or cần một trong hai vế đúng; not đảo ngược giá trị Boolean.

    age = 16
    has_ticket = True
    if age >= 18 and has_ticket:
        print("entry allowed")
    else:
        print("entry refused")
    # entry refused
    
    • Sử dụng ngoặc đơn để làm rõ thứ tự: (a or b) and c.
    temp = 30
    if temp > 25 and not temp > 35:
        print("warm but ok")
    # warm but ok
    

    Lỗi thường gặp

    • Viết elif, không phải else if.
    • Mỗi dòng if / elif / else đều kết thúc bằng dấu hai chấm :, và thân của nó phải được thụt vào trong.
    • if x = 5: là lỗi — hãy dùng == để so sánh.
    • else không nhận điều kiện; chỉ có if và elif mới làm được.
  • 5 Lặp lại
    5.1

    Vòng lặp for và range

    Vòng lặp thực thi lặp lại mã. Một vòng lặp for sẽ lặp lại một lần cho mỗi phần tử trong một dãy. range(n) tạo ra các số từ 0 đến n - 1.

    for i in range(5):
        print(i)
    # 0, then 1, 2, 3, 4 (each on its own line)
    
    • range(a, b) đi từ a lên (nhưng không bao gồm) b.
    • range(a, b, step) thêm một bước nhảy mỗi lần.
    for n in range(2, 11, 2):
        print(n)        # 2 4 6 8 10
    
    for i in range(n): thân vòng lặp chạy với i = 0 … n-1
    for i in range(n): thân vòng lặp chạy với i = 0 … n-1
    5.2

    Mẫu bộ tích lũy

    Để xây dựng kết quả qua vòng lặp, khởi tạo một biến trước vòng lặp, sau đó cập nhật nó mỗi lượt. Đây là mẫu bộ tích lũy.

    total = 0
    for n in range(1, 6):
        total = total + n
    print(total)        # 15
    
    • Ý tưởng tương tự cũng đếm số lượng mục khớp với kiểm tra.
    count = 0
    for letter in "banana":
        if letter == "a":
            count = count + 1
    print(count)        # 3
    
    5.3

    Vòng lặp while

    Một vòng lặp while lặp lại miễn là điều kiện vẫn đúng. Thay đổi gì đó bên trong, nếu không nó sẽ không bao giờ dừng lại — vòng lặp vô hạn.

    n = 1
    while n <= 3:
        print(n)
        n = n + 1
    # 1 2 3
    
    • break thoát khỏi vòng lặp ngay lập tức.
    total = 0
    while True:
        total = total + 10
        if total >= 30:
            break
    print(total)        # 30
    
    5.4

    Vòng lặp lồng nhau

    Một vòng lặp nằm trong một vòng lặp khác là vòng lặp lồng nhau. Vòng lặp bên trong chạy trọn vẹn cho mỗi lượt của vòng lặp ngoài.

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

    Lỗi thường gặp

    • range(n) đi từ 0 đến n - 1, không phải từ 1 đến n — đây là lỗi off-by-one kinh điển.
    • Thay đổi danh sách trong khi duyệt qua nó sẽ bỏ sót các mục; hãy duyệt qua bản sao nếu bạn bắt buộc phải xóa những thứ gì đó.
    • Unquên thay đổi biến vòng lặp trong một while khiến nó chạy mãi mãi.
    • Thụt vào trong quyết định cái gì nằm trong vòng lặp; một dòng bị thụt sai sẽ chỉ chạy một lần, sau khi vòng lặp kết thúc.
  • 6 List & list 2-D
    6.1

    Danh sách

    Một danh sách chứa nhiều giá trị theo thứ tự, bên trong []. Mỗi mục có một chỉ số (từ 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]
    
    • Thay đổi một mục bằng chỉ số của nó: scores[1] = 100.
    • Một danh sách có thể tăng và giảm; một chuỗi ký tự thì không.

    Các công cụ danh sách thông thường:

    Công cụ Tác dụng
    a.append(x) thêm x vào cuối
    a.insert(i, x) chèn x tại vị trí i
    a.remove(x) xóa mục x đầu tiên
    a.pop() / a.pop(i) xóa và trả về phần tử cuối cùng / phần tử i
    a.sort() sắp xếp danh sách tại chỗ
    sorted(a) trả về một DANH SÁCH MỚI đã sắp xếp
    x in a có phải là x trong danh sách?
    len(a), sum(a), max(a), min(a) kích thước và toán học nhanh
    Chỉ mục của danh sách bắt đầu từ 0
    Chỉ số của danh sách bắt đầu từ 0
    6.2

    Duyệt qua một danh sách

    Duyệt qua một danh sách nghĩa là ghé thăm từng mục. Một vòng lặp for làm điều này mà không cần chỉ số.

    scores = [88, 71, 95]
    total = 0
    for s in scores:
        total = total + s
    print(total)          # 254
    
    • Dùng enumerate khi bạn cũng cần cả chỉ số.
    for i, name in enumerate(["a", "b"]):
        print(i, name)    # 0 a  /  1 b
    
    6.3

    Danh sách 2 chiều (lưới ô)

    Một danh sách 2 chiều là một danh sách chứa các danh sách — một lưới gồm các hàng và cột. Sử dụng hai chỉ số: grid[row][col].

    grid = [[1, 2, 3],
            [4, 5, 6]]
    print(grid[0][2])     # 3
    print(grid[1][0])     # 4
    
    • Một vòng lặp lồng nhau ghé thăm mọi ô.
    grid = [[1, 2], [3, 4]]
    for row in grid:
        for value in row:
            print(value, end=" ")
    print()               # 1 2 3 4
    
    6.4

    comprehension của danh sách

    Comprehension của danh sách xây dựng một danh sách mới trong một dòng: [expression for item in sequence].

    squares = [x * x for x in range(5)]
    print(squares)        # [0, 1, 4, 9, 16]
    
    • Thêm if để giữ lại chỉ một số mục.
    evens = [n for n in range(10) if n % 2 == 0]
    print(evens)          # [0, 2, 4, 6, 8]
    
    6.5

    Tuple & tập hợp

    Tuple là một dãy cố định trong ngoặc tròn. Nó không thể bị thay đổi sau khi được tạo — hãy dùng nó cho các giá trị thuộc về nhau, và giải nén nó thành các tên riêng.

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

    Một hàm cần trả về hai kết quả sẽ trả về một tuple:

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

    Một tập hợp lưu trữ mỗi giá trị chỉ một lần, không có thứ tự. Nó hoàn hảo để loại bỏ trùng lặp và kiểm tra thành viên nhanh chóng.

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

    Lỗi thường gặp

    • b = a chia sẻ chung một danh sách. a.copy() hoặc a[:] tạo ra một danh sách ngoài mới, nhưng các mục có thể thay đổi nằm lồng nhau vẫn được chia sẻ (bản sao nông).
    • Mục cuối cùng là a[-1]; a[len(a)] nằm ngoài phạm vi.
    • append thêm MỘT mục; hãy dùng extend hoặc + để nối một danh sách khác.
    • Xây dựng lưới với [[0]*3]*3 sẽ tạo ba bản sao của cùng một hàng. Hãy xây dựng các hàng trong vòng lặp thay thế.
    • Tuple có một phần tử cần dấu phẩy: (5,), không phải (5).
    • Tập hợp không có thứ tự và không có trùng lặp, nên bạn không thể dùng chỉ số như s[0] để truy cập.
  • 7 Dictionary
    7.1

    Từ điển

    Từ điển (dict) lưu trữ các cặp khóa → giá trị. Bạn tìm kiếm giá trị theo khóa của nó, không phải theo chỉ số số.

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

    Thêm và cập nhật

    Gán cho một khóa để thêm vào, hoặc để thay đổi một khóa đã tồn tại.

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

    Kiểm tra và lặp

    Dùng in để kiểm tra sự tồn tại của một khóa. Lặp qua các khóa, hoặc lặp qua .items() để lấy cả khóa lẫn giá trị.

    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) trả về giá trị mặc định khi khóa bị thiếu — không gây lỗi.
    student = {"name": "Mei"}
    print(student.get("age", 0))   # 0
    

    Mẫu đề thi kinh điển — đếm xem mỗi giá trị xuất hiện bao nhiêu lần:

    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) cung cấp 0 lần đầu tiên khi gặp một khóa, vì vậy sẽ không có KeyError.

    Lỗi thường gặp

    • Đọc một khóa bị thiếu bằng d[key] sẽ gây ra KeyError; hãy dùng d.get(key) hoặc kiểm tra if key in d trước.
    • Gán lại d[key] sẽ ghi đè giá trị cũ — các khóa phải duy nhất.
    • Khóa phải là bất biến, chẳng hạn như chuỗi ký tự hoặc số — danh sách không thể là khóa.
    Từ điển ánh xạ mỗi khóa với một giá trị
    Từ điển ánh xạ mỗi khóa với một giá trị
  • 8 Hàm & trừu tượng hóa
    8.1

    Định nghĩa & gọi hàm

    Hàm là một khối mã code có tên mà bạn có thể tái sử dụng. Định nghĩa nó bằng def, sau đó gọi nó bằng tên.

    def greet():
        print("Hello!")
    
    greet()        # Hello!
    greet()        # Hello!
    
    • Mã code bên trong chỉ chạy khi bạn gọi hàm.
    def định nghĩa; call chạy; return gửi giá trị trở lại
    def định nghĩa; call thực thi; return gửi lại một giá trị
    8.2

    Trả về giá trị

    Hàm có thể trả về một giá trị bằng return. Khi đó, lời gọi hàm sẽ đại diện cho giá trị đó.

    def square(n):
        return n * n
    
    print(square(5))          # 25
    print(square(3) + 1)      # 10
    
    • return kết thúc hàm ngay lập tức. Một hàm không có return sẽ trả về None.
    8.3

    Tham số, đối số & phạm vi

    Tham số là tên trong def. Đối số là giá trị bạn truyền vào.

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

    Biến được tạo bên trong hàm là biến cục bộ — nó chỉ tồn tại ở đó. Khu vực đó chính là phạm vi của nó.

    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
    

    Tham số có thể có giá trị mặc định, được sử dụng khi người gọi bỏ qua:

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

    Trừu tượng hóa thủ tục

    Trừ抽象 hóa thủ tục có nghĩa là che giấu chi tiết behind a name. Bạn sử dụng hàm bằng tên và chức năng của nó, chứ không phải cách thức hoạt động.

    def area_of_rectangle(w, h):
        return w * h
    
    print(area_of_rectangle(4, 5))   # 20
    
    • Một hàm tốt làm một việc, có tên rõ ràng, và tránh lặp lại mã.
    8.5

    Mô-đun & import

    Một mô-đun là tập tin chứa các hàm sẵn có. Hãy đưa vào bằng 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
    

    Lỗi thường gặp

    • Hàm sẽ trả về None trừ khi bạn viết return. In ra không giống với việc trả về.
    • Không bao giờ dùng mặc định có thể thay đổi như def f(x=[]) — cùng danh sách đó được chia sẻ giữa tất cả các lần gọi.
    • Biến được tạo bên trong hàm là cục bộ và không thể nhìn thấy từ bên ngoài.
    • Chạy hàm với f(); việc viết f đơn thuần chỉ đặt tên cho nó.
  • 9 Lỗi, ngoại lệ & kiểm thử
    9.1

    Lỗi & gỡ lỗi

    Mã có thể thất bại theo ba cách. Lỗi cú pháp vi phạm quy tắc của Python, nên nó không bao giờ chạy. Lỗi thời gian chạy xảy ra khi đang chạy, ví dụ như chia cho 0. Lỗi logic chạy nhưng trả về kết quả sai.

    Các lỗi Python phổ biến: Cú pháp, Tên, Kiểu, Chỉ mục
    Các lỗi Python phổ biến: Cú pháp, Tên, Kiểu, Chỉ mục
    # 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 in ra traceback hiển thị vị trí bị lỗi. Đọc từ dưới lên trên.
    9.2

    try / except / raise

    Đặt đoạn mã rủi ro trong try; nếu nó thất bại, except sẽ bắt ngoại lệ thay vì gây crash.

    def to_int(text):
        try:
            return int(text)
        except ValueError:
            return 0
    print(to_int("abc"))   # 0
    
    • Bắt một loại cụ thể (ValueError, ZeroDivisionError, …).
    • raise tạo ra lỗi của riêng bạn một cách chủ ý.
    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

    Kiểm thử & độ bền

    Kiểm thử xác nhận rằng mã trả về đáp án đúng. Thử các trường hợp bình thường và trường hợp biên — đầu vào rỗng, số 0, giá trị rất lớn.

    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
    
    • Mã bền vững xử lý đầu vào lạ một cách êm đẹp thay vì gây crash.

    Lỗi thường gặp

    • Không dùng bare except: — hãy bắt lỗi cụ thể, ví dụ except ValueError:.
    • Lỗi cú pháp dừng toàn bộ chương trình trước khi chạy, nên sửa những lỗi đó trước.
    • Kiểm thử các trường hợp biên (đầu vào rỗng, số 0, giá trị lớn nhất), không chỉ trường hợp dễ.
  • 10 Tệp tin
    10.1

    Đọc & ghi tập tin văn bản

    Tập tin văn bản lưu trữ văn bản trên ổ đĩa. Mở nó với open(name, mode) nơi mode chỉ định đọc hoặc ghi. Luôn dùng with, đóng tập tin cho bạn.

    Ghi

    Mode "w" ghi một tập tin mới và xóa bất kỳ tập tin cũ nào.

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

    Đọc

    Mode "r" (mặc định) đọc. .read() trả về toàn bộ tập tin như một chuỗi duy nhất.

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

    Theo dòng

    Lặp qua tệp để lấy từng dòng một. .strip() xóa ký tự xuống dòng ở cuối.

    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
    

    Ghi thêm

    Mode "a" ghi thêm — nó thêm vào cuối mà không xó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 Ý nghĩa
    "r" đọc (mặc định)
    "w" ghi (xóa trước)
    "a" ghi thêm (thêm vào cuối)

    Lỗi thường gặp

    • Luôn đóng tập tin, hoặc dùng with open(...) as f: đóng tập tin cho bạn.
    • read() trả về toàn bộ tệp dưới dạng một chuỗi, và mỗi dòng vẫn kết thúc bằng \n.
    • Mở với "w" sẽ xóa tập tin trước; dùng "a" để thêm vào cuối.
    open → đọc/ghi → close (với auto-closes)
    open → đọc/ghi → close (với auto-closes)
  • 11 Thiết kế thuật toán
    11.1

    Thuật toán & phân tách

    Thuật toán là danh sách các bước rõ ràng giải quyết một vấn đề. Phân tách có nghĩa là chia nhỏ vấn đề lớn thành các phần nhỏ hơn mà bạn có thể giải quyết từng phần một.

    # 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
    
    • Trừ抽象 hóa có nghĩa là bỏ qua chi tiết: bạn sử dụng largest(...) mà không cần đọc lại cách nó hoạt động.
    11.2

    Mã giả & sơ đồ luồng

    伪代码 là tiếng Anh đơn giản, có cấu trúc cho thuật toán, được viết trước mã thật. Nó không được chạy.

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

    Sơ đồ khối vẽ cùng kế hoạch đó: ô vuông cho mỗi bước, hình thoi cho mỗi quyết định, và mũi tên cho thứ tự.

    11.3

    Đệ quy & ngăn xếp lời gọi

    Đệ quy là khi một hàm gọi chính nó. Nó cần một trường hợp cơ sở (input đơn giản trả về ngay) và trường hợp đệ quy (nó gọi chính nó trên input nhỏ hơn).

    Call stack cho factorial(3): mỗi cuộc gọi chờ đợi, rồi trả về theo thứ tự ngược lại
    Call stack cho factorial(3): mỗi cuộc gọi chờ đợi, rồi trả về theo thứ tự ngược lại
    def fact(n):
        return 1 if n <= 1 else n * fact(n - 1)
    
    print(fact(5))     # 120
    
    • Mỗi lời gọi tạm dừng nằm trên ngăn xếp lời gọi cho đến khi lời gọi phía trên trả về.

    Lỗi thường gặp

    • Đệ quy cần trường hợp cơ sở, nếu không nó sẽ gọi chính nó mãi mãi và làm sập ngăn xếp lời gọi.
    • 伪代码 dành cho lập kế hoạch — nó không cần chạy, nhưng mọi bước đều phải không mơ hồ.
    • Chia nhỏ vấn đề lớn thành các bước nhỏ có tên trước khi viết bất kỳ mã nào.
  • 12 Cấu trúc dữ liệu
    12.1

    Kiểu Dữ Liệu Trừ Tượng (ADT)

    Kiểu dữ liệu trừu tượng (ADT) mô tả một phần dữ liệu cùng các thao tác trên đó, tách biệt với cách xây dựng. Bạn sử dụng nó thông qua các thao tác, không phải qua bộ nhớ lưu trữ bên trong.

    # 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

    Ngăn xếp (Stacks)

    Ngăn xếp là last-in, first-out (LIFO). Bạn push lên trên cùng và pop từ trên cùng.

    Ngăn xếp lấy từ trên cùng (LIFO); hàng đợi lấy từ đầu (FIFO)
    Ngăn xếp lấy từ trên cùng (LIFO); hàng đợi lấy từ đầu (FIFO)
    stack = []
    stack.append("a")
    stack.append("b")
    print(stack.pop())   # b
    print(stack.pop())   # a
    
    12.3

    Hàng đợi

    Hàng đợi là first-in, first-out (FIFO). Bạn enqueue ở phía sau và dequeue từ phía trước.

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

    Danh sách liên kết

    Danh sách liên kết là chuỗi các nút. Mỗi nút chứa dữ liệu và con trỏ đến nút tiếp theo; nút cuối trỏ về None.

    Danh sách liên kết: mỗi nút chứa dữ liệu và con trỏ đến nút tiếp theo, kết thúc ở None
    Danh sách liên kết: mỗi nút chứa dữ liệu và con trỏ đến nút tiếp theo, kết thúc ở 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

    Bảng băm

    Bảng băm ánh xạ khóa sang một slot bằng hàm băm. Hai khóa có thể rơi vào cùng một slot — va chạm. Python's dict là bảng băm, nên tra cứu rất nhanh.

    Hàm băm ánh xạ mỗi khóa sang một slot; hai khóa có thể va chạm trong một slot
    Hàm hash ánh xạ mỗi khóa vào một ô; hai khóa có thể va chạm trong cùng một ô
    table = {}
    table["Mei"] = 88
    table["Sam"] = 71
    print(table["Mei"])   # 88  (fast lookup by key)
    
    12.6

    Cây tìm kiếm nhị phân

    Cây tìm kiếm nhị phân (BST) giữ thứ tự: mọi con trái nhỏ hơn node của nó, mọi con phải lớn hơn. Tìm kiếm vẫn nhanh.

    Cây tìm kiếm nhị phân: giá trị nhỏ đi sang trái, giá trị lớn đi sang phải
    Cây tìm kiếm nhị phân: giá trị nhỏ đi sang trái, giá trị lớn đi sang phải
    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

    Đồ thị

    Đồ thị là tập hợp các đỉnh nối với nhau bằng cạnh. Danh sách kề — một dict chứa danh sách lân cận — là cách phổ biến để lưu trữ một đồ thị.

    Một đồ thị gồm các đỉnh và cạnh, kèm dạng danh sách kề của nó
    Một đồ thị gồm các đỉnh và cạnh, kèm dạng danh sách kề của nó
    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)
    

    Lỗi thường gặp

    • Ngăn xếp (stack) là cuối vào trước ra; hàng đợi (queue) là đầu vào trước ra. Đừng nhầm lẫn chúng.
    • Kiểm tra xem cấu trúc có trống không trước khi xóa phần tử từ trên cùng hoặc lấy phần tử ra khỏi hàng đợi.
    • Trong danh sách liên kết, mất con trỏ head sẽ mất cả danh sách.
  • 13 Tìm kiếm, sắp xếp & hiệu suất
    13.1

    Tìm kiếm tuyến tính & nhị phân

    Tìm kiếm là tìm vị trí của một giá trị. Tìm kiếm tuyến tính kiểm tra từng mục theo thứ tự, nên hoạt động trên bất kỳ danh sách nào.

    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
    

    Tìm kiếm nhị phân nhanh hơn nhiều nhưng cần danh sách đã sắp xếp. Nó thu hẹp phạm vi đi một nửa ở mỗi bước.

    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
    
    Tìm kiếm nhị phân thu hẹp phạm vi đi một nửa ở mỗi bước — O(log n) trên danh sách đã sắp xếp
    Tìm kiếm nhị phân thu hẹp phạm vi đi một nửa ở mỗi bước — O(log n) trên danh sách đã sắp xếp
    13.2

    Sắp xếp (bọt & chèn)

    Sắp xếp là đặt các mục theo thứ tự. Sắp xếp nổi bọt lặp đi lặp lại hoán đổi các cặp lân cận nằm sai thứ tự.

    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]
    

    Sắp xếp chèn xây dựng một phần đã sắp xếp từng mục một, trượt mỗi mục mới về đúng vị trí:

    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]
    
    • Trong code thực tế, dùng hàm built-in của Python sorted():
    print(sorted([5, 2, 4, 1]))           # [1, 2, 4, 5]
    
    13.3

    Hiệu suất thuật toán

    Hiệu suất hỏi công việc tăng trưởng như thế nào khi dữ liệu đầu vào tăng. Chúng ta mô tả nó bằng Big-O.

    Cách số bước tăng trưởng theo kích thước đầu vào cho độ phức tạp thường gặp
    Cách số bước tăng trưởng theo kích thước đầu vào cho độ phức tạp thường gặp
    Big-O Tên Ví dụ
    $O(1)$ hằng số tra cứu key của dict
    $O(\log n)$ logarit tìm kiếm nhị phân
    $O(n)$ tuyến tính tìm kiếm tuyến tính
    $O(n^2)$ bậc hai sắp xếp bọt
    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

    Ngẫu nhiên & Mô phỏng

    Mô-đun random tạo số ngẫu nhiên. Dùng seed để làm kết quả có thể lặp lại. Một mô phỏng chạy nhiều lần thử ngẫu nhiên để ước lượng câu trả lời.

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

    Lỗi thường gặp

    • Tìm kiếm nhị phân chỉ hoạt động trên một danh sách đã sắp xếp.
    • Big-O cho bạn biết thời gian TĂNG TRƯỞNG như thế nào, không phải thời gian chính xác; phương pháp O(n²) tốt hơn O(n) chỉ với đầu vào cực nhỏ.
    • Sắp xếp bọt là O(n²) — ổn để học, nhưng chậm trên danh sách lớn.
  • 14 OOP & paradigm
    14.1

    Lớp & Đối tượng

    Lớp là bản thiết kế. Một đối tượng là một thứ được xây dựng từ nó (một instance). __init__ là constructor thiết lập mỗi đối tượng; self là đối tượng đó.

    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 là thuộc tính (dữ liệu trên đối tượng); speak là phương thức (hành động).

    Thêm __str__ để điều khiển những gì print(obj) hiển thị:

    class Dog:
        def __init__(self, name):
            self.name = name
        def __str__(self):
            return f"Dog named {self.name}"
    
    print(Dog("Rex"))    # Dog named Rex
    
    Một lớp là bản thiết kế; gọi nó tạo ra một đối tượng
    Một lớp là bản thiết kế; gọi nó tạo ra một đối tượng
    14.2

    Kế thừa, đóng gói & Đa hình

    Kế thừa cho phép subclass tái sử dụng superclass. Dùng super() để gọi parent; ghi đè phương thức để thay đổi nó.

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

    Encapsulation gộp dữ liệu với các phương thức và cung cấp một giao diện dự định. Trong Python, dấu gạch dưới ở đầu chỉ ra tên không công khai (thường gọi là riêng tư) theo quy ước; nó không ngăn mã bên ngoài truy cập vào. Việc biến đổi tên bằng hai dấu gạch dưới giúp tránh xung đột tên khi kế thừa, chứ không phải để đảm bảo an toàn.

    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
    

    Đa hình nghĩa là một tên, nhiều hành vi — speak đúng sẽ chạy cho mỗi đối tượng.

    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

    Các mô hình lập trình

    Một paradigm là phong cách viết chương trình. Code thủ tục là chuỗi các bước và hàm. Code hướng đối tượng nhóm dữ liệu và phương thức vào các đối tượng. Code khai báo nói bạn muốn cái gì, không phải làm thế nào (list comprehension hoặc 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)
    

    Lỗi thường gặp

    • Mọi phương thức đều cần self là tham số đầu tiên.
    • __init__ thiết lập một đối tượng mới và chạy tự động khi bạn tạo nó.
    • Hai đối tượng của cùng một lớp có thuộc tính riêng biệt; thay đổi cái này không ảnh hưởng đến cái kia.
  • 15 Biểu diễn dữ liệu
    15.1

    Bit & Nhị phân

    Một bit là một 0 hoặc 1 đơn lẻ. Nhị phân là hệ đếm cơ số 2: mỗi vị trí có giá trị gấp đôi vị trí bên phải (1, 2, 4, 8, …). Thập phân (cơ số 10) là các số bình thường của chúng ta.

    Giá trị vị trí nhị phân: 1101 nghĩa là 8 + 4 + 1 = 13
    Giá trị vị trí nhị phân: 1101 nghĩa là 8 + 4 + 1 = 13
    print(bin(13))         # 0b1101
    print(int("1101", 2))  # 13
    
    • 8 bit tạo thành một byte. Độ rộng cố định có thể tràn (vòng lại) khi số quá lớn.
    x = 250
    x = (x + 10) % 256     # one byte wraps at 256
    print(x)               # 4
    

    Thập lục phân (cơ số 16) là cách gọn gàng để đọc nhị phân: một chữ số thập lục phân đại diện chính xác cho bốn bit. Python viết hex bằng 0x:

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

    Nén dữ liệu

    Nén làm dữ liệu nhỏ hơn. Nén không mất mát giữ lại mọi bit, nên bạn tái tạo lại bản gốc hoàn toàn chính xác. Nén có mất mát loại bỏ chi tiết — nhỏ hơn nhưng không chính xác — và dùng cho ảnh và âm nhạc.

    Mã hóa run-length là phương pháp nén không mất mát đơn giản: lưu một chuỗi (lặp lại) dưới dạng đếm cộng giá trị.

    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
    

    Lỗi thường gặp

    • n bits lưu trữ 2**n giá trị khác nhau, từ 0 đến 2**n - 1.
    • Nén có mất mát loại bỏ chi tiết và không thể đảo ngược; nén không mất mát có thể đảo ngược hoàn toàn chính xác.
  • 16 Khái niệm máy tính
    16.1

    Computing là gì & Chu kỳ thiết kế

    Computing nghĩa là giải quyết vấn đề bằng máy tính: đầu vào, xử lý, đầu ra. Phần mềm tốt được xây dựng theo chu kỳ thiết kế — lên kế hoạch, viết, kiểm thử, cải tiến — lặp lại nhiều lần.

    • Chia nhỏ vấn đề, xây dựng một phần nhỏ, kiểm thử nó, sau đó thêm phần khác.
    • Lập trình viên làm việc theo nhóm và tái sử dụng code của nhau.
    16.2

    Internet

    Internet là mạng của các mạng. Dữ liệu được chia thành các gói tin di chuyển riêng biệt và được ghép lại ở đầu kia. Các quy tắc chung gọi là giao thức (như TCP/IP) làm cho điều này hoạt động. Nếu một đường truyền bị hỏng, gói tin đi đường khác — đây là sự dư thừa, mang lại khả năng chịu lỗi.

    Bản đồ Internet: mỗi đường là một đường đi giữa hai mạng
    Bản đồ Internet: mỗi đường là một đường đi giữa hai mạng
    Lớp Nhiệm vụ
    HTTP yêu cầu và gửi trang web
    TCP giao đáng tin cậy, theo thứ tự
    IP địa chỉ và định tuyến
    16.3

    Tính toán song song & phân tán

    Code tuần tự thực hiện từng bước một. Tính toán song song thực hiện nhiều bước cùng lúc trên nhiều nhân, có thể tăng tốc độ. Tính toán phân tán chia sẻ công việc across nhiều máy tính, ví dụ như đám mây.

    • Không phải mọi thứ đều chạy song song: một số bước phải chờ kết quả từ bước trước đó.
    16.4

    Tác động của tính toán

    Tính toán mang lại cả lợi ích và tác hại. Khoảng cách số nghĩa là không ai cũng có quyền truy cập bình đẳng vào nó. Phần mềm có thể chứa thiên kiến từ dữ liệu mà nó học hỏi. Tôn trọng sở hữu trí tuệ (bản quyền), và bảo vệ dữ liệu cá nhân cũng như quyền riêng tư của con người.

    Lỗi thường gặp

    • Internet và World Wide Web không phải là cùng một thứ: Web là một dịch vụ chạy trên nền tảng của Internet.
    • Nhiều nhân xử lý hơn chỉ giúp ích nếu công việc có thể chia nhỏ thành các phần chạy cùng lúc.
  • 17 Kết hợp tất cả lại
    17.1

    Các mini-project cuối khóa

    Một mini-project kết hợp các ý tưởng đã học: dữ liệu trong danh sách, hàm có chọn lọc bên trong vòng lặp, và đầu ra được in ra. Đây cũng chính là cấu trúc của AP Create Performance Task.

    Project: điểm trung bình

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

    Project: đếm số lượng đạt

    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
    

    Project: lọc sang danh sách mới

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

    AP Create Task yêu cầu một danh sách, một thủ tục tham số hóa sử dụng chọn lọc và lặp, cùng với một số đầu vào/đầu ra. Mỗi project ở trên đều đúng cấu trúc đó — hãy xây dựng từng phần nhỏ, sau đó ghép chúng lại.

    Lỗi thường gặp

    • Xây dựng theo từng bước nhỏ và kiểm thử từng phần trước khi chuyển sang phần tiếp theo — đừng viết tất cả cùng một lúc.
    • Đọc hết bài tập trước, sau đó lập kế hoạch đầu vào → xử lý → đầu ra trước khi code.
    Mini-project: dữ liệu → hàm → kết quả in
    Mini-project: dữ liệu → hàm → kết quả in

Đăng nhập hoặc tạo tài khoản

IGCSE, A-Level & AP