# Cheat sheet Python: cú pháp, lệnh và hàm tích hợp trong các bảng

URL: https://skillaria.top/vi/guides/python/cheat-sheet-cu-phap-python

Cú pháp Python dựa trên thụt lề thay cho dấu ngoặc nhọn: khối lệnh sau dấu hai chấm được lùi vào 4 khoảng trắng. Nền tảng gồm biến không cần khai báo kiểu, điều kiện if/elif/else, vòng lặp for và while, hàm def, cùng các hàm tích hợp print, len, range, input, type và phương thức của chuỗi, danh sách và từ điển.

Cheat sheet Python này tập hợp trên một trang mọi thứ bạn cần giữ trong tầm tay những tháng đầu: cú pháp Python, vòng lặp, hàm tích hợp, phương thức của chuỗi, danh sách và từ điển, cùng các lệnh terminal. Mỗi bảng là một tài liệu tham khảo ngắn kèm ví dụ chạy được, có thể dán ngay vào REPL.

## Cơ bản về cú pháp Python

Đặc điểm chính của ngôn ngữ là khối lệnh được xác định bằng thụt lề, không phải dấu ngoặc. Sau dòng có dấu hai chấm (`if`, `for`, `def`, `class`), các dòng tiếp theo được lùi vào 4 khoảng trắng. Không được trộn tab và khoảng trắng — sẽ gặp `IndentationError`.

| Cấu trúc | Ví dụ | Giải thích |
| --- | --- | --- |

| Chú thích | `# văn bản` | mọi thứ sau # đến hết dòng bị bỏ qua |

| Biến | `age = 25` | kiểu không cần khai báo, giá trị quyết định kiểu |

| Gán nhiều biến | `a, b = 1, 2` | giải nén; hoán đổi giá trị: `a, b = b, a` |

| In ra | `print("Xin chào", name)` | các đối số được ngăn cách bằng dấu cách |

| Nhập liệu | `s = input("Tên: ")` | luôn trả về chuỗi |

| f-string | `f"{name}: {price:.2f}"` | chèn biểu thức và định dạng |

| Chú thích kiểu | `count: int = 0` | gợi ý cho IDE và công cụ kiểm tra, không được kiểm tra khi chạy |

| Khối rỗng | `pass` | chỗ giữ chỗ, nơi cú pháp đòi hỏi có thân |

| Import | `from math import sqrt` | nạp module hoặc tên từ module |

### Kiểu dữ liệu

| Kiểu | Literal | Có thể thay đổi |
| --- | --- | --- |

| `int` | `42`, `1_000_000` | không |

| `float` | `3.14`, `1e-3` | không |

| `bool` | `True`, `False` | không |

| `str` | `"văn bản"`, `'văn bản'`, `"""nhiều dòng"""` | không |

| `list` | `[1, 2, 3]` | có |

| `tuple` | `(1, 2)`, `(1,)` | không |

| `dict` | `{"a": 1}` | có |

| `set` | `{1, 2}`, rỗng — `set()` | có |

| `NoneType` | `None` | — |

### Toán tử

| Nhóm | Toán tử | Ví dụ → kết quả |
| --- | --- | --- |

| Số học | `+ - * / // % **` | `7 // 2` → 3, `7 % 2` → 1, `2 ** 10` → 1024 |

| So sánh | `== != < > <= >=` | `1 < x < 10` — chuỗi so sánh |

| Logic | `and or not` | `x or "mặc định"` |

| Thành viên | `in`, `not in` | `"a" in "abc"` → True |

| Đồng nhất | `is`, `is not` | `x is None` |

| Gán | `+= -= *= /=`, `:=` | `if (n := len(s)) > 10: ...` |

## Điều kiện và so khớp mẫu

```
if score >= 90:
    grade = "A"
elif score >= 70:
    grade = "B"
else:
    grade = "C"

status = "người lớn" if age >= 18 else "trẻ em"   # toán tử ba ngôi

match command:
    case "start":
        print("Bắt đầu")
    case "stop" | "exit":
        print("Dừng lại")
    case _:
        print("Lệnh không xác định")
```

Các giá trị sai gồm `False`, `None`, `0`, chuỗi rỗng và các tập hợp rỗng, nên thay vì `if len(items) > 0` người ta viết đơn giản là `if items`.

## Vòng lặp trong Python: cú pháp for và while

### Vòng lặp for

Cú pháp vòng lặp for trong Python: `for biến in dãy:` và thân lệnh có thụt lề. Vòng lặp duyệt qua bất kỳ đối tượng lặp nào — chuỗi, danh sách, từ điển, tệp, `range`.

```
for i in range(5):              # 0 1 2 3 4
    print(i)

for i in range(10, 0, -2):      # 10 8 6 4 2
    print(i)

for i, fruit in enumerate(["táo", "lê"], start=1):
    print(i, fruit)

for name, score in zip(names, scores):
    print(name, score)

for key, value in prices.items():
    print(key, value)
```

### Vòng lặp while

```
attempts = 3
while attempts > 0:
    password = input("Mật khẩu: ")
    if password == "secret":
        print("Đăng nhập thành công")
        break
    attempts -= 1
else:
    print("Hết số lần thử")   # chạy nếu không có break
```

| Lệnh | Tác dụng |
| --- | --- |

| `break` | thoát khỏi vòng lặp sớm |

| `continue` | chuyển sang lần lặp tiếp theo |

| `else` của vòng lặp | chạy nếu vòng lặp kết thúc mà không có `break` |

| `range(stop)`, `range(start, stop, step)` | dãy số, `stop` không được bao gồm |

### Comprehension (danh sách rút gọn)

```
squares = [x ** 2 for x in range(10)]
evens = [x for x in numbers if x % 2 == 0]
lengths = {word: len(word) for word in words}
unique = {c.lower() for c in text}
total = sum(x * x for x in range(100))   # biểu thức sinh (generator)
```

## Hàm

```
def greet(name: str, greeting: str = "Xin chào") -> str:
    """Trả về lời chào."""
    return f"{greeting}, {name}!"

def total(*args, **kwargs):
    return sum(args), kwargs

square = lambda x: x * x
print(greet("Anna"))                   # Xin chào, Anna!
print(greet("Anna", greeting="Chào"))  # Chào, Anna!
```

| Thành phần | Ý nghĩa |
| --- | --- |

| `def f(a, b=1)` | tham số có giá trị mặc định |

| `*args` | số lượng đối số vị trí tùy ý (tuple) |

| `**kwargs` | số lượng đối số có tên tùy ý (dict) |

| `return` | trả về giá trị; nếu không có thì hàm trả về `None` |

| `lambda x: ...` | hàm ẩn danh ngắn gọn chỉ gồm một biểu thức |

| `global`, `nonlocal` | thay đổi biến từ phạm vi bên ngoài |

Đừng dùng giá trị mặc định là đối tượng có thể thay đổi, ví dụ `def f(items=[])`: danh sách được tạo một lần và tích lũy qua các lần gọi. Cách đúng là `items=None` và bên trong `if items is None: items = []`.

## Hàm tích hợp của Python

Các hàm tích hợp của Python dùng được mà không cần import. Đây là những hàm xuất hiện gần như trong mọi script.

| Hàm | Làm gì | Ví dụ → kết quả |
| --- | --- | --- |

| `print()` | in các giá trị | `print(1, 2, sep="-")` → 1-2 |

| `input()` | đọc một chuỗi từ bàn phím | `int(input())` |

| `len()` | độ dài tập hợp hoặc chuỗi | `len("abc")` → 3 |

| `type()` | kiểu của đối tượng | `type(3.0)` → <class 'float'> |

| `isinstance()` | kiểm tra kiểu | `isinstance(5, int)` → True |

| `int() float() str() bool()` | chuyển đổi kiểu | `int("42")` → 42 |

| `list() tuple() set() dict()` | tạo tập hợp | `list("ab")` → ['a', 'b'] |

| `range()` | dãy số | `list(range(3))` → [0, 1, 2] |

| `enumerate()` | cặp (chỉ số, phần tử) | `list(enumerate("ab"))` → [(0, 'a'), (1, 'b')] |

| `zip()` | ghép các dãy theo cặp | `list(zip([1, 2], "ab"))` → [(1, 'a'), (2, 'b')] |

| `sum() min() max()` | tổng, nhỏ nhất, lớn nhất | `max([3, 7, 1])` → 7 |

| `abs() round()` | trị tuyệt đối và làm tròn | `round(3.14159, 2)` → 3.14 |

| `sorted()` | danh sách mới đã sắp xếp | `sorted(words, key=len, reverse=True)` |

| `reversed()` | iterator theo thứ tự ngược | `list(reversed([1, 2]))` → [2, 1] |

| `map() filter()` | áp dụng hàm / lọc | `list(map(str, [1, 2]))` → ['1', '2'] |

| `any() all()` | có ít nhất một / tất cả đều đúng | `all(x > 0 for x in nums)` |

| `open()` | mở tệp | `open("a.txt", encoding="utf-8")` |

| `help() dir()` | trợ giúp và danh sách thuộc tính | `help(str.split)`, `dir(list)` |

| `id() hash()` | định danh và hash của đối tượng | `hash("a")` |

Tài liệu tham khảo Python luôn có sẵn là hàm `help()` trong REPL: `help(dict)` hiển thị mọi phương thức của từ điển kèm mô tả, còn `dir(obj)` — danh sách các tên có sẵn.

## Phương thức của chuỗi

Chuỗi trong Python: chuỗi không thể thay đổi, mỗi phương thức trả về một chuỗi mới. Cắt lát hoạt động giống như với danh sách: `s[1:4]`, `s[::-1]` — đảo ngược.

| Phương thức | Ví dụ → kết quả |
| --- | --- |

| `upper() lower()` | `"Py".upper()` → 'PY' |

| `capitalize() title()` | `"hello world".title()` → 'Hello World' |

| `strip() lstrip() rstrip()` | `" hi \n".strip()` → 'hi' |

| `split(sep)` | `"a,b,c".split(",")` → ['a', 'b', 'c'] |

| `join(iterable)` | `"-".join(["a", "b"])` → 'a-b' |

| `replace(old, new)` | `"cá".replace("á", "à")` → 'cà' |

| `find() index()` | `"hello".find("l")` → 2; nếu không có — -1 (với `index` — lỗi) |

| `count()` | `"banana".count("a")` → 3 |

| `startswith() endswith()` | `"file.py".endswith(".py")` → True |

| `isdigit() isalpha() isspace()` | `"123".isdigit()` → True |

| `removeprefix() removesuffix()` | `"test_a".removeprefix("test_")` → 'a' |

| `zfill() center() ljust()` | `"7".zfill(3)` → '007' |

| `format()` | `"{} + {}".format(1, 2)` → '1 + 2' |

## Lệnh cho danh sách Python

Danh sách là tập hợp có thứ tự và có thể thay đổi. Phần lớn phương thức thay đổi danh sách ngay tại chỗ và trả về `None`, nên `a = a.sort()` là lỗi thường gặp.

| Thao tác | Làm gì | Ví dụ |
| --- | --- | --- |

| `append(x)` | thêm vào cuối | `a.append(4)` |

| `extend(iter)` | thêm tất cả phần tử | `a.extend([5, 6])` |

| `insert(i, x)` | chèn theo chỉ số | `a.insert(0, "đầu")` |

| `remove(x)` | xóa lần xuất hiện đầu tiên của giá trị | `a.remove(3)` |

| `pop(i)` | xóa và trả về phần tử (mặc định là phần tử cuối) | `last = a.pop()` |

| `clear()` | xóa sạch danh sách | `a.clear()` |

| `index(x)` | chỉ số của lần xuất hiện đầu tiên | `a.index("b")` |

| `count(x)` | số lần xuất hiện | `a.count(1)` |

| `sort()` | sắp xếp tại chỗ | `a.sort(key=str.lower)` |

| `reverse()` | đảo ngược tại chỗ | `a.reverse()` |

| `copy()` | bản sao nông | `b = a.copy()` |

| `del a[i]` | xóa theo chỉ số hoặc lát cắt | `del a[1:3]` |

| Cắt lát | `a[start:stop:step]` | `a[-1]` — phần tử cuối, `a[:3]` — ba phần tử đầu |

## Lệnh cho từ điển Python

| Thao tác | Làm gì | Ví dụ |
| --- | --- | --- |

| `d[key]` | giá trị theo khóa, không có khóa — `KeyError` | `d["name"]` |

| `get(key, default)` | giá trị hoặc giá trị dự phòng | `d.get("age", 0)` |

| `d[key] = value` | thêm hoặc thay đổi | `d["city"] = "Hà Nội"` |

| `keys() values() items()` | khóa, giá trị, cặp | `for k, v in d.items():` |

| `update()` | gộp với từ điển khác | `d.update({"a": 1})` |

| `d1 | d2` | từ điển mới đã gộp | `merged = defaults | user` |

| `pop(key, default)` | xóa và trả về giá trị | `d.pop("tmp", None)` |

| `popitem()` | xóa cặp được thêm vào gần nhất | `d.popitem()` |

| `setdefault(key, value)` | trả về giá trị, nếu chưa có khóa thì tạo | `d.setdefault("tags", []).append("py")` |

| `key in d` | kiểm tra sự có mặt của khóa | `if "name" in d:` |

| `dict.fromkeys()` | từ điển từ các khóa với một giá trị chung | `dict.fromkeys("abc", 0)` |

| `len(d)`, `del d[key]` | kích thước và xóa | `del d["old"]` |

### Tuple và tập hợp

| Thao tác | Ví dụ → kết quả |
| --- | --- |

| Giải nén tuple | `x, y = (3, 4)` |

| Thêm vào tập hợp | `s.add(5)`, xóa — `s.discard(5)` |

| Hợp / giao | `{1, 2} | {2, 3}` → {1, 2, 3}; `{1, 2} & {2, 3}` → {2} |

| Hiệu | `{1, 2} - {2}` → {1} |

| Bỏ trùng lặp trong danh sách | `list(dict.fromkeys(items))` — giữ nguyên thứ tự |

## Ngoại lệ và tệp

```
try:
    number = int(input("Số: "))
except ValueError as err:
    print("Đây không phải là số:", err)
else:
    print("Thành công")
finally:
    print("Luôn được thực hiện")

with open("data.txt", "w", encoding="utf-8") as f:
    f.write("dòng\n")

with open("data.txt", encoding="utf-8") as f:
    for line in f:
        print(line.rstrip())
```

| Ngoại lệ | Khi nào xảy ra |
| --- | --- |

| `SyntaxError`, `IndentationError` | lỗi cú pháp hoặc thụt lề |

| `NameError` | tên chưa được định nghĩa (gõ sai) |

| `TypeError` | thao tác với kiểu không phù hợp: `"1" + 1` |

| `ValueError` | đúng kiểu nhưng giá trị sai: `int("abc")` |

| `IndexError`, `KeyError` | không có chỉ số hoặc khóa như vậy |

| `FileNotFoundError` | không tìm thấy tệp |

| `ZeroDivisionError` | chia cho 0 |

## Lớp

```
from dataclasses import dataclass

class Dog:
    def __init__(self, name: str):
        self.name = name

    def bark(self) -> str:
        return f"{self.name}: Gâu!"

@dataclass
class Point:
    x: float
    y: float

print(Dog("Mực").bark())    # Mực: Gâu!
print(Point(1, 2))          # Point(x=1, y=2)
```

## Module tích hợp của Python

Thư viện chuẩn được cài cùng trình thông dịch — chỉ cần `import`.

| Module | Dùng để | Ví dụ |
| --- | --- | --- |

| `math` | toán học | `math.sqrt(16)` → 4.0 |

| `random` | số ngẫu nhiên | `random.randint(1, 6)`, `random.choice(items)` |

| `datetime` | ngày và giờ | `datetime.date.today()` |

| `pathlib` | đường dẫn và tệp | `Path("data").glob("*.csv")` |

| `os`, `sys` | hệ thống, biến môi trường, đối số | `os.environ.get("HOME")`, `sys.argv` |

| `json` | đọc và ghi JSON | `json.loads(text)`, `json.dumps(obj, ensure_ascii=False)` |

| `csv` | bảng CSV | `csv.DictReader(f)` |

| `collections` | Counter, defaultdict, deque | `Counter("banana").most_common(1)` → [('a', 3)] |

| `itertools` | tổ hợp và nối các iterator | `itertools.chain(a, b)` |

| `re` | biểu thức chính quy | `re.findall(r"\d+", s)` |

| `time` | tạm dừng và đo thời gian | `time.sleep(1)`, `time.perf_counter()` |

| `asyncio` | mã bất đồng bộ | `asyncio.run(main())` |

Trong Python 3.15 có import lười (PEP 810): `lazy import pandas as pd` trì hoãn việc nạp module đến lần đầu truy cập, và script với các phụ thuộc nặng khởi động nhanh hơn rõ rệt.

## Lệnh Python trong terminal

Nhóm truy vấn «lệnh python» riêng biệt là các lệnh để chạy trình thông dịch và cài thư viện. Trên Windows người ta thường viết `python` hoặc `py` thay cho `python3`.

| Lệnh | Làm gì |
| --- | --- |

| `python3 --version` | hiển thị phiên bản |

| `python3` | mở console tương tác REPL (thoát bằng `exit()`) |

| `python3 script.py` | chạy tệp |

| `python3 -c "print(2 + 2)"` | chạy một dòng lệnh |

| `python3 -m venv .venv` | tạo môi trường ảo |

| `source .venv/bin/activate` / `.venv\Scripts\activate` | kích hoạt môi trường (Linux, macOS / Windows) |

| `python3 -m pip install requests` | cài gói |

| `pip list`, `pip freeze > requirements.txt` | danh sách gói và lưu lại |

| `pip install -r requirements.txt` | cài các phụ thuộc từ tệp |

| `python3 -m http.server 8000` | máy chủ web đơn giản trong thư mục hiện tại |

| `uv init`, `uv add requests`, `uv run main.py` | dự án, phụ thuộc và chạy qua trình quản lý uv |

## Lỗi thường gặp của người mới

- **So sánh bằng `=`** — trong điều kiện cần `==`; dấu `=` đơn là phép gán.
- **Quên dấu hai chấm** sau `if`, `for`, `def` gây `SyntaxError`.
- **Cộng chuỗi với số**: `"Tuổi: " + 25` là lỗi, hãy viết `f"Tuổi: {25}"`.
- **Thay đổi danh sách khi đang duyệt** — hãy duyệt bản sao `for x in a[:]` hoặc tạo danh sách mới.
- **`input()` trả về chuỗi** — để tính toán hãy bọc trong `int()` hoặc `float()`.

## Kết luận

Cú pháp Python dựa trên thụt lề, dấu hai chấm và một bộ cấu trúc nhỏ: điều kiện, vòng lặp for và while, hàm, lớp. Thêm vào đó hai chục hàm tích hợp và các phương thức của chuỗi, danh sách, từ điển — và bạn đã bao quát phần lớn công việc hằng ngày. Hãy lưu lại cheat sheet này; khi các bảng đã quen thuộc, hãy chuyển sang module và bất đồng bộ. Tất cả những điều đó được hướng dẫn từng bước với thực hành trong khóa học «Python 3.15: từ người mới đến chuyên nghiệp».

## FAQ

**Nên dùng bao nhiêu khoảng trắng để thụt lề trong Python?**

Theo chuẩn PEP 8 — 4 khoảng trắng mỗi cấp. Quan trọng là nhất quán trong toàn khối và không trộn với tab.

**List khác tuple như thế nào?**

List có thể thay đổi, có thể bổ sung và sắp xếp tại chỗ; tuple không thể thay đổi, nên dùng được làm khóa của từ điển và cho các tập giá trị cố định.

**Làm sao xem tất cả phương thức của một đối tượng ngay trong Python?**

Gọi dir(obj) để có danh sách tên và help(obj) để có mô tả — ví dụ help(str) hiển thị mọi phương thức của chuỗi.

**sort() khác sorted() ở điểm nào?**

Phương thức list.sort() sắp xếp chính danh sách và trả về None, còn hàm sorted() trả về danh sách mới và làm việc với mọi tập hợp có thể lặp.

**Có cần dấu chấm phẩy ở cuối dòng không?**

Không. Dấu chấm phẩy được phép dùng để ngăn nhiều lệnh trên cùng một dòng, nhưng trong code bình thường mỗi lệnh được viết trên một dòng riêng.


---
Source: Skillaria.Top (https://skillaria.top)