Luồng điều khiển và hàm

def classify(score: int) -> str:
    if score >= 90:
        return 'A'
    elif score >= 80:
        return 'B'
    elif score >= 70:
        return 'C'
    else:
        return 'F'

# Lưu ý: `elif` viết liền — KHÔNG có `else if` như JS/C.
# Đây là từ khóa riêng, tiết kiệm 1 cấp indent.

age = 20
status = 'adult' if age >= 18 else 'minor'
# status == 'adult'

# Nested (đọc khó — nên tránh):
grade = 'A' if score >= 90 else 'B' if score >= 80 else 'C'

# Khi tránh: chuyển sang if/elif/else 4 dòng cho dễ đọc.

# Anti-pattern (Java-ish):
if len(items) > 0 and items != None:
    ...

# Pythonic:
if items:
    ...

# Cảnh báo: đừng dùng truthy khi cần phân biệt None với 0/rỗng!
def connect(timeout=None):
    if timeout:           # BUG: timeout=0 cũng bị bỏ qua
        ...
    if timeout is not None:   # ĐÚNG: chỉ check None
        ...

def http_status(code: int) -> str:
    match code:
        case 200:
            return 'OK'
        case 301 | 302:           # OR pattern
            return 'Redirect'
        case 404:
            return 'Not Found'
        case _:                  # wildcard — như `default`
            return 'Unknown'

def describe_list(lst: list) -> str:
    match lst:
        case []:
            return 'rỗng'
        case [x]:
            return f'một phần tử: {x}'
        case [x, y]:
            return f'hai phần tử: {x}, {y}'
        case [1, 2, *rest]:        # bắt đầu bằng 1, 2 — phần dư vào rest
            return f'bắt đầu 1,2 — rest = {rest}'
        case [first, *_, last]:    # _ = bỏ qua
            return f'đầu = {first}, cuối = {last}'

describe_list([])              # 'rỗng'
describe_list([1, 2, 3, 4])     # 'bắt đầu 1,2 — rest = [3, 4]'
describe_list([5, 6, 7, 8])     # 'đầu = 5, cuối = 8'

def handle_event(event: dict) -> str:
    match event:
        case {'type': 'click', 'x': x, 'y': y}:
            return f'click tại ({x}, {y})'
        case {'type': 'keypress', 'key': key}:
            return f'phím {key}'
        case {'type': t}:
            return f'event chưa xử lý: {t}'
        case _:
            return 'không phải event dict'

handle_event({'type': 'click', 'x': 10, 'y': 20, 'meta': True})
# 'click tại (10, 20)' — pattern match dù dict có thêm key 'meta'

from dataclasses import dataclass

@dataclass
class Point:
    x: int
    y: int

def where(p: Point) -> str:
    match p:
        case Point(x=0, y=0):
            return 'gốc tọa độ'
        case Point(x=0, y=y_val):     # bind y vào y_val
            return f'trục Y, y={y_val}'
        case Point(x=x_val, y=0):
            return f'trục X, x={x_val}'
        case Point():
            return f'điểm thường: ({p.x}, {p.y})'

where(Point(0, 5))     # 'trục Y, y=5'

match point:
    case Point(x=x, y=y) if x == y:
        print('trên đường y=x')
    case Point(x=x, y=y) if x > 0 and y > 0:
        print('góc phần tư I')
    case _:
        print('khác')

# Duyệt list
for name in ['An', 'Bình', 'Cường']:
    print(name)

# Duyệt string — từng ký tự
for ch in 'python':
    print(ch)

# Duyệt range — tương đương for(i=0; i<5; i++)
for i in range(5):           # 0, 1, 2, 3, 4
    print(i)

for i in range(1, 10, 2):     # start=1, stop=10, step=2 → 1, 3, 5, 7, 9
    print(i)

# Duyệt dict — KEY (mặc định)
prices = {'apple': 10, 'banana': 5}
for k in prices:           # 'apple', 'banana'
    print(k)

for k, v in prices.items():   # key + value
    print(k, v)

# Duyệt file — từng dòng (không cần load toàn bộ file)
with open('data.txt') as f:
    for line in f:
        print(line.strip())

# Anti-pattern (C-style):
names = ['An', 'Bình', 'Cường']
for i in range(len(names)):
    print(i, names[i])

# Pythonic:
for i, name in enumerate(names):
    print(i, name)
# 0 An
# 1 Bình
# 2 Cường

# enumerate có start tùy chỉnh:
for i, name in enumerate(names, start=1):
    print(i, name)
# 1 An
# 2 Bình
# 3 Cường

# zip — duyệt song song
ages = [22, 25, 28]
for name, age in zip(names, ages):
    print(name, age)
# An 22
# Bình 25
# Cường 28

# zip dừng ở iterable ngắn nhất.
# Python 3.10+ thêm zip(..., strict=True) — raise nếu độ dài khác nhau.
for a, b in zip([1,2,3], ['a','b'], strict=True):
    print(a, b)
# ValueError: zip() argument 2 is shorter than argument 1

# Đọc input đến khi nhập 'quit'
while True:
    cmd = input('> ')
    if cmd == 'quit':
        break
    process(cmd)

# Newton-Raphson — lặp đến khi hội tụ
def sqrt(n: float, eps: float=1e-10) -> float:
    x = n
    while abs(x*x - n) > eps:
        x = (x + n/x) / 2
    return x

# Walrus := (3.8+) cho while-loop với phép gán inline
while (line := f.readline()):
    print(line)
# Đọc đến khi readline() trả chuỗi rỗng (EOF) — falsy → dừng.

# Anti-pattern — nested sâu
for user in users:
    if user.is_active:
        if user.age >= 18:
            if user.country == 'VN':
                send_email(user)

# Pythonic — early continue (flat is better than nested):
for user in users:
    if not user.is_active:
        continue
    if user.age < 18:
        continue
    if user.country != 'VN':
        continue
    send_email(user)

# Tìm số nguyên tố
def is_prime(n: int) -> bool:
    if n < 2:
        return False
    for i in range(2, int(n**0.5) + 1):
        if n % i == 0:
            return False
    return True

# Viết lại dùng for-else:
def find_divisor(n: int) -> int | None:
    for i in range(2, n):
        if n % i == 0:
            print(f'tìm thấy {i}')
            return i
    else:
        print('không có divisor (prime)')
        return None

# Quan sát hành vi:
for x in []:
    print(x)
else:
    print('done')
# In: 'done' — loop xong (không vào lần nào), không break.

for x in [1, 2, 3]:
    if x == 2:
        break
else:
    print('done')
# KHÔNG in gì — loop bị break.

def add(a: int, b: int) -> int:
    """Trả về tổng của hai số nguyên.

    Args:
        a: số hạng thứ nhất.
        b: số hạng thứ hai.

    Returns:
        Tổng a + b.

    Examples:
        >>> add(2, 3)
        5
    """
    return a + b

# Truy cập docstring qua thuộc tính __doc__
print(add.__doc__)
# help(add) cũng in ra docstring

def greet(name: str, greeting: str = 'Hi') -> str:
    return f'{greeting}, {name}!'

greet('An')                  # 'Hi, An!'
greet('An', 'Hello')         # 'Hello, An!'
greet(name='An')             # 'Hi, An!' — keyword
greet(greeting='Hi', name='An') # 'Hi, An!' — keyword đảo thứ tự OK

def append_to(item, lst=[]):     # ⚠️ default = list rỗng dùng chung!
    lst.append(item)
    return lst

append_to(1)   # [1]
append_to(2)   # [1, 2]    ← tích lũy giữa các lần gọi!
append_to(3)   # [1, 2, 3]

# Sửa: dùng None làm sentinel, khởi tạo bên trong function.
def append_to(item, lst=None):
    if lst is None:
        lst = []
    lst.append(item)
    return lst

append_to(1)   # [1]
append_to(2)   # [2]    ← OK, mỗi lần gọi là list mới

def log(*args, **kwargs):
    print('positional:', args)    # tuple
    print('keyword:', kwargs)     # dict

log(1, 2, 3, name='An', age=22)
# positional: (1, 2, 3)
# keyword: {'name': 'An', 'age': 22}

# Kết hợp với normal args:
def make_request(method, url, *headers, **params):
    ...
make_request('GET', '/api/users', 'X-Auth', 'X-Trace', page=1, limit=10)
# method='GET', url='/api/users'
# headers=('X-Auth', 'X-Trace')
# params={'page': 1, 'limit': 10}

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

nums = [1, 2, 3]
add(*nums)                  # 6 — unpack list thành 3 positional

opts = {'a': 1, 'b': 2, 'c': 3}
add(**opts)                 # 6 — unpack dict thành keyword

# Pattern phổ biến: forward args qua wrapper
def debug_call(fn, *args, **kwargs):
    print(f'calling {fn.__name__}({args}, {kwargs})')
    return fn(*args, **kwargs)

def f(pos_only, /, both, *, kw_only):
    ...

f(1, 2, kw_only=3)        # OK
f(1, both=2, kw_only=3)   # OK
f(pos_only=1, both=2, kw_only=3)
# TypeError: f() got some positional-only arguments passed as keyword
f(1, 2, 3)
# TypeError: f() takes 2 positional arguments but 3 were given

def connect(host, port, /, *, timeout=30, retries=3):
    """host, port phải positional. timeout, retries phải keyword."""
    ...

connect('localhost', 5432, timeout=60)   # OK
connect('localhost', 5432, 60, 5)
# TypeError: connect() takes 2 positional arguments

x = 'global'             # G

def outer():
    x = 'enclosing'       # E (đối với inner)

    def inner():
        x = 'local'        # L
        print(x)
    inner()
    print(x)

outer()
# local
# enclosing
print(x)
# global

count = 0

def increment_local():
    count = count + 1      # UnboundLocalError
    # count xuất hiện ở vế trái → Python coi là local; nhưng vế phải đọc count chưa khởi tạo.

def increment_global():
    global count
    count += 1
increment_global()
print(count)                # 1

def outer():
    x = 10
    def inner():
        nonlocal x             # bind biến của outer, KHÔNG phải global
        x += 1
    inner()
    print(x)                # 11

def make_counter():
    count = 0
    def inc():
        nonlocal count        # cần để có thể GÁN lại count (binding outer)
        count += 1
        return count
    return inc

c1 = make_counter()
c1()                       # 1
c1()                       # 2
c1()                       # 3

c2 = make_counter()        # instance độc lập
c2()                       # 1, không chia sẻ với c1

funcs = []
for i in range(3):
    funcs.append(lambda: i)

[f() for f in funcs]
# [2, 2, 2]   ← tất cả thấy `i` cuối loop

# Fix 1: capture qua default argument (eager)
funcs = []
for i in range(3):
    funcs.append(lambda i=i: i)

[f() for f in funcs]
# [0, 1, 2]

# Fix 2: dùng factory function (mỗi iteration tạo binding mới)
def make(x):
    return lambda: x
funcs = [make(i) for i in range(3)]
[f() for f in funcs]
# [0, 1, 2]

# lambda params: expression
square = lambda x: x * x
square(5)                   # 25

# Tương đương:
def square(x):
    return x * x

# Có thể có if/else expression (conditional expression):
abs_val = lambda x: -x if x < 0 else x

# Use case: callback ngắn cho sorted/filter/map
users = [{'name': 'An', 'age': 22}, {'name': 'Bình', 'age': 19}]
sorted(users, key=lambda u: u['age'])
# [{'name': 'Bình', 'age': 19}, {'name': 'An', 'age': 22}]

list(filter(lambda x: x % 2 == 0, range(10)))
# [0, 2, 4, 6, 8]

from operator import itemgetter, attrgetter

# Thay vì:
sorted(users, key=lambda u: u['age'])
# Dùng:
sorted(users, key=itemgetter('age'))

# itemgetter còn lấy nhiều field (trả tuple — sort theo nhiều khóa)
sorted(users, key=itemgetter('age', 'name'))

def mutate(lst):
    lst.append(99)             # mutate IN-PLACE → caller thấy thay đổi

a = [1, 2, 3]
mutate(a)
print(a)                    # [1, 2, 3, 99]

def reassign(lst):
    lst = [9, 9, 9]            # gán lại biến LOCAL → caller KHÔNG thấy

b = [1, 2, 3]
reassign(b)
print(b)                    # [1, 2, 3]

def try_modify_int(n):
    n += 1                  # int immutable → tạo object mới, gán biến local

x = 10
try_modify_int(x)
print(x)                    # 10 — không đổi