Python Handout · ⁨Tài liệu tham khảo Python⁩

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ộ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.

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.

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)

• 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).

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ố:

• / 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.

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).

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

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.

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).

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

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):

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

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ả.

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.

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.

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

Để 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

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

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.

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:

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

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

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]

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 không sao chép danh sách: cả hai tên đều trỏ đến cùng một danh sách, nên thay đổi cái này sẽ làm thay đổi cái kia. Hãy dùng a.copy() hoặc a[:].
• 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.

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.

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.

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.

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

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ã.

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ó.

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.

# 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ị nơi nó thất bại. Đọc từ dưới lên trên.

Bọc mã rủi ro trong try. Nếu thất bại, except bắt ngoại lệ và xử lý nó, thay vì bị sập.

def to_int(text):
    try:
        return int(text)
    except ValueError:
        return 0

print(to_int("42"))    # 42
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

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 không bị sập trước đầu vào kỳ lạ; nó xử lý nó một cách thanh lịch.

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ễ.

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

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.

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.

伪代码 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ự.

Đệ 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).

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.

Một kiểu dữ liệu trừ抽象化 (ADT) mô tả một số dữ liệu plus các thao tác trên đó, tách biệt khỏ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)

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.

stack = []
stack.append("a")
stack.append("b")
print(stack.pop())   # b
print(stack.pop())   # a

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

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.

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

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.

table = {}
table["Mei"] = 88
table["Sam"] = 71
print(table["Mei"])   # 88  (fast lookup by key)

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.

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]

Đồ 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ị.

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.

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

Sắp xếp là đặt các mục theo thứ tự. Sắp xếp bọt lặp lại hoán đổi các cặp邻居 bị 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]

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.

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)

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.

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

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

Đóng gói ẩn dữ liệu sau các phương thức; dấu gạch dưới đứng đầu đánh dấu nó là riêng tư.

class Account:
    def __init__(self):
        self._balance = 0           # private
    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

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.

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.

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

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.

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.

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.

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 đó.

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.

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.