Python cheatsheet: Tổng hợp cú pháp và kiến thức cần nhớ
Kiến thức lập trình

Python cheatsheet: Tổng hợp cú pháp và kiến thức cần nhớ

TX
Trần Xuân Hiếu
Xuất bản 10/29/2026

Python được thiết kế để dễ đọc và dễ viết, nhưng ngay cả khi đã quen thuộc với ngôn ngữ này, vẫn có những lúc bạn cần tra lại cú pháp của một hàm, cách dùng của một cấu trúc dữ liệu hay cách xử lý một tình huống cụ thể. Đó là lý do cheatsheet tồn tại.

Bài viết dưới đây tổng hợp toàn bộ những kiến thức Python quan trọng nhất, từ cú pháp cơ bản đến lập trình hướng đối tượng, xử lý file và các thư viện phổ biến, trình bày theo dạng tra cứu nhanh kèm ví dụ code cụ thể. Dù bạn đang học Python lần đầu hay chỉ cần ôn lại một khái niệm nào đó, đây là tài liệu bạn có thể quay lại bất cứ lúc nào.

Python cheatsheet cấp độ: Cơ bản (Foundations & Syntax)

Nhóm kiến thức Cơ bản bao gồm những thứ bạn sẽ dùng trong mỗi dòng code, mỗi file và mỗi dự án bất kể sau này đi theo hướng nào: cách Python giao tiếp với người dùng, cách khai báo và làm việc với biến, cách xử lý các kiểu dữ liệu nguyên thủy và cách thực hiện các phép tính. Đây là nền tảng mà mọi thứ bên trên đều được xây dựng lên từ đó, và hiểu chắc phần này sẽ giúp bạn tránh được rất nhiều lỗi không đáng có trong các giai đoạn sau.

Cú pháp cơ bản trong Python

Trước khi đi vào bất kỳ khái niệm nào, bạn cần nắm được cách Python xử lý những thứ căn bản nhất: in dữ liệu ra màn hình, nhận dữ liệu từ người dùng, khai báo biến và làm việc với các kiểu dữ liệu nguyên thủy. Đây là nền tảng mà mọi đoạn code Python đều xây dựng trên đó, và hiểu rõ phần này sẽ giúp bạn tránh được nhiều lỗi không đáng có ở giai đoạn đầu.

image.png
Cú pháp Python cơ bản

In ra màn hình và nhận dữ liệu đầu vào

Hàm print() là cách đơn giản nhất để hiển thị kết quả ra màn hình, trong khi input() cho phép chương trình dừng lại và chờ người dùng nhập dữ liệu. Một điểm cần lưu ý là input() luôn trả về kiểu chuỗi, vì vậy nếu cần số bạn phải chuyển đổi thủ công.

# Print output to screen
print("Hello, Python!")
print("Sum:", 5 + 3)

# Get input from user (always returns string)
name = input("Enter your name: ")
print("Hello,", name)

Biến và kiểu dữ liệu

Python là ngôn ngữ kiểu động, nghĩa là bạn không cần khai báo kiểu dữ liệu trước khi dùng. Ngôn ngữ sẽ tự nhận diện kiểu dựa trên giá trị bạn gán vào. Python có bốn kiểu dữ liệu nguyên thủy cơ bản là số nguyên, số thực, chuỗi ký tự và boolean. Hàm type() giúp bạn kiểm tra kiểu của bất kỳ biến nào khi cần xác minh.

# Integer
age = 25

# Float
gpa = 3.75

# String
name = "Python"

# Boolean
is_active = True

# Check data type
print(type(age))        # <class 'int'>
print(type(gpa))        # <class 'float'>
print(type(name))       # <class 'str'>
print(type(is_active))  # <class 'bool'>

Chuyển đổi kiểu dữ liệu

Đôi khi bạn cần chuyển đổi dữ liệu từ kiểu này sang kiểu khác, ví dụ chuyển chuỗi từ input() thành số để tính toán, hoặc chuyển số thành chuỗi để ghép với văn bản. Python cung cấp các hàm chuyển đổi tường minh cho từng trường hợp. Cần lưu ý rằng int() sẽ bỏ phần thập phân khi chuyển từ float, không làm tròn.

# Convert to integer
x = int("10")       # String to int: 10
x = int(3.9)        # Float to int: 3 (truncates, not rounds)

# Convert to float
y = float("3.14")   # String to float: 3.14
y = float(5)        # Int to float: 5.0

# Convert to string
z = str(100)        # Int to string: "100"
z = str(3.14)       # Float to string: "3.14"

# Convert to boolean
b = bool(0)         # False (zero is falsy)
b = bool(1)         # True (non-zero is truthy)
b = bool("")        # False (empty string is falsy)
b = bool("hello")   # True (non-empty string is truthy)

Comment trong Python

Comment giúp code dễ đọc và dễ bảo trì hơn. Python hỗ trợ hai dạng comment: comment một dòng bắt đầu bằng dấu # và docstring nhiều dòng dùng ba dấu nháy kép. Docstring thường được dùng để mô tả module, class hoặc hàm và có thể được truy cập qua thuộc tính __doc__.

# This is a single-line comment

"""
This is a multi-line docstring.
Often used to describe functions, classes, or modules.
Can be accessed via the __doc__ attribute.
"""

def greet(name):
    """
    Returns a greeting message.
    
    Args:
        name (str): The name of the person to greet.
    
    Returns:
        str: A greeting message.
    """
    return f"Hello, {name}!"

Toán tử

Toán tử là các ký hiệu dùng để thực hiện phép tính hoặc so sánh giữa các giá trị và biến, đóng vai trò là nền tảng để xây dựng mọi biểu thức và logic trong một đoạn code. Python chia toán tử thành bốn nhóm chính theo mục đích sử dụng, và việc phân biệt rõ từng nhóm sẽ giúp tránh được không ít lỗi logic phổ biến khi mới học.

image.png
Cú pháp toán tử trong Python

Toán tử số học

Ngoài các phép tính quen thuộc, Python có thêm toán tử // cho phép chia lấy phần nguyên và % cho phép chia lấy phần dư, hai toán tử này rất thường gặp trong các bài toán về số học. Toán tử ** thực hiện phép lũy thừa mà không cần import thư viện bên ngoài.

a = 15
b = 4

print(a + b)    # Addition: 19
print(a - b)    # Subtraction: 11
print(a * b)    # Multiplication: 60
print(a / b)    # Division: 3.75 (always returns float)
print(a // b)   # Floor division: 3 (discards remainder)
print(a % b)    # Modulus: 3 (remainder only)
print(a ** b)   # Exponentiation: 50625

Toán tử so sánh

Toán tử so sánh luôn trả về giá trị boolean True hoặc False. Một lỗi phổ biến của người mới là nhầm lẫn giữa = (gán giá trị) và == (so sánh bằng). Python cũng cho phép so sánh dây chuỗi như 1 < x < 10 thay vì phải viết x > 1 and x < 10.

x = 10
y = 20

print(x == y)   # Equal to: False
print(x != y)   # Not equal to: True
print(x > y)    # Greater than: False
print(x < y)    # Less than: True
print(x >= y)   # Greater than or equal: False
print(x <= y)   # Less than or equal: True

# Chained comparison (Python-specific)
print(1 < x < 15)   # True

Toán tử logic

Toán tử logic dùng để kết hợp nhiều điều kiện lại với nhau. Python dùng từ khóa and, or, not thay vì ký hiệu &&, ||, ! như một số ngôn ngữ khác. Cần lưu ý thứ tự ưu tiên: not được xử lý trước, tiếp đến and và cuối cùng mới là or.

a = True
b = False

print(a and b)      # Logical AND: False (both must be True)
print(a or b)       # Logical OR: True (at least one must be True)
print(not a)        # Logical NOT: False

# Short-circuit evaluation
x = 5
print(x > 0 and x < 10)    # True
print(x < 0 or x > 3)      # True

Toán tử gán

Toán tử gán kết hợp cho phép viết các phép cập nhật biến ngắn gọn hơn. Thay vì x = x + 5, bạn có thể viết x += 5. Tất cả toán tử số học đều có phiên bản kết hợp tương ứng.

x = 10
x += 5      # x = x + 5 → 15
x -= 3      # x = x - 3 → 12
x *= 2      # x = x * 2 → 24
x /= 4      # x = x / 4 → 6.0
x //= 2     # x = x // 2 → 3.0
x %= 2      # x = x % 2 → 1.0
x **= 3     # x = x ** 3 → 1.0

Toán tử bitwise

Toán tử bitwise hoạt động trực tiếp trên các bit của số nguyên. Nhóm toán tử này ít xuất hiện trong code ứng dụng thông thường nhưng rất quan trọng trong lập trình hệ thống, xử lý ảnh và các bài toán tối ưu hiệu năng.

a = 0b1010  # 10 in binary
b = 0b1100  # 12 in binary

print(a & b)    # AND: 0b1000 = 8
print(a | b)    # OR: 0b1110 = 14
print(a ^ b)    # XOR: 0b0110 = 6
print(~a)       # NOT: -11
print(a << 1)   # Left shift: 20 (multiply by 2)
print(a >> 1)   # Right shift: 5 (divide by 2)

Python cheatsheet cấp độ: Sơ cấp (Data Structures & String Manipulation)

Khi đã nắm được cú pháp cơ bản, thách thức tiếp theo là học cách tổ chức và lưu trữ dữ liệu một cách có cấu trúc. Python cung cấp năm kiểu cấu trúc dữ liệu tích hợp sẵn cho nhóm này, mỗi kiểu phù hợp với một loại bài toán khác nhau. List khi bạn cần danh sách có thứ tự và linh hoạt, tuple khi dữ liệu cần cố định và không thay đổi, dictionary khi bạn cần tra cứu theo khóa, set khi cần loại bỏ trùng lặp hay thao tác tập hợp, và string với bộ công cụ xử lý văn bản phong phú. Biết chọn đúng cấu trúc dữ liệu cho từng bài toán là một trong những kỹ năng quan trọng nhất của lập trình viên Python.

image.png
Cú pháp sơ cấp trong Python - 1

Chuỗi ký tự (String)

String trong Python là kiểu dữ liệu bất biến, nghĩa là sau khi tạo ra bạn không thể thay đổi nội dung của nó mà chỉ có thể tạo ra string mới. Python cung cấp một bộ phương thức rất phong phú cho string, từ tìm kiếm, thay thế đến định dạng, đủ để xử lý hầu hết các tình huống làm việc với văn bản mà không cần thư viện bên ngoài.

Các thao tác cơ bản với chuỗi

Phần lớn các phương thức của string đều trả về string mới thay vì sửa string gốc. Điều quan trọng cần nhớ là string trong Python được index từ 0, và có thể dùng index âm để đếm từ cuối chuỗi về đầu.

s = "Hello, Python World"

print(len(s))               # Length: 19
print(s.upper())            # HELLO, PYTHON WORLD
print(s.lower())            # hello, python world
print(s.strip())            # Remove leading/trailing whitespace
print(s.replace("Python", "Beautiful"))     # Hello, Beautiful World
print(s.split(" "))         # ['Hello,', 'Python', 'World']
print(s.find("Python"))     # Index of first occurrence: 7
print(s.count("l"))         # Count occurrences: 3
print(s.startswith("Hello"))    # True
print(s.endswith("World"))      # True
print(s.isdigit())          # False
print("123".isdigit())      # True
print(",".join(["a", "b", "c"]))    # a,b,c

Định dạng chuỗi

Python có nhiều cách định dạng chuỗi, nhưng f-string (có từ Python 3.6) đang là lựa chọn được ưa chuộng nhất hiện nay vì cú pháp ngắn gọn và dễ đọc. Bên trong f-string bạn có thể đặt bất kỳ biểu thức Python nào trong cặp ngoặc nhọn, kể cả gọi hàm hay tính toán trực tiếp.

name = "Alice"
age = 22
score = 8.567

# f-string (recommended, Python 3.6+)
print(f"Name: {name}, Age: {age}")
print(f"Score: {score:.2f}")        # Format to 2 decimal places: 8.57
print(f"Uppercase: {name.upper()}")
print(f"2 + 2 = {2 + 2}")

# .format() method
print("Name: {}, Age: {}".format(name, age))
print("Name: {name}, Age: {age}".format(name=name, age=age))

# % operator (old-style, less recommended)
print("Name: %s, Age: %d" % (name, age))
print("Score: %.2f" % score)

Cắt chuỗi (Slicing)

Slicing cho phép trích xuất một phần của chuỗi theo cú pháp [start:end:step]. Khi bỏ qua start, Python lấy từ đầu chuỗi. Khi bỏ qua end, Python lấy đến hết chuỗi. Kỹ thuật [::-1] để đảo ngược chuỗi là một trong những trick Python được dùng phổ biến nhất.

s = "Python Programming"

print(s[0])         # First character: P
print(s[-1])        # Last character: g
print(s[0:6])       # Python
print(s[7:])        # Programming
print(s[:6])        # Python
print(s[::2])       # Every 2nd character: Pto rgamn
print(s[::-1])      # Reverse string: gnimmargorP nohtyP
print(s[7:18:2])    # Step through substring: Pormmn

Danh sách (List)

List là cấu trúc dữ liệu linh hoạt nhất trong Python, có thể chứa bất kỳ kiểu dữ liệu nào, kể cả list lồng trong list. Khác với tuple, list có thể thay đổi sau khi tạo, thêm xóa hoặc sửa phần tử tùy ý. List là lựa chọn mặc định khi bạn cần lưu một tập hợp các phần tử có thứ tự và cần thao tác thường xuyên.

Tạo và truy cập List

List trong Python hỗ trợ slicing giống string, có thể dùng index âm để truy cập từ cuối và có thể lồng list bên trong list để tạo ma trận hoặc cấu trúc dữ liệu nhiều chiều.

# Creating lists
fruits = ["apple", "banana", "orange", "mango"]
numbers = [1, 2, 3, 4, 5]
mixed = [1, "Python", True, 3.14, None]
nested = [[1, 2], [3, 4], [5, 6]]

# Accessing elements
print(fruits[0])        # apple
print(fruits[-1])       # mango
print(fruits[1:3])      # ['banana', 'orange']
print(fruits[:2])       # ['apple', 'banana']
print(nested[1][0])     # 3 (row 1, column 0)

Các phương thức của List

Python cung cấp nhiều phương thức built-in cho list. Điểm khác biệt quan trọng cần nhớ: hầu hết các phương thức thay đổi list trực tiếp (in-place) và trả về None, không trả về list mới. sorted() là ngoại lệ vì trả về list mới mà không thay đổi list gốc.

items = [3, 1, 4, 1, 5, 9, 2, 6]

items.append(7)             # Add to end: [..., 7]
items.insert(0, 0)          # Insert at position 0
items.extend([8, 9, 10])    # Add multiple items
items.remove(1)             # Remove first occurrence of 1
popped = items.pop()        # Remove and return last item
popped = items.pop(0)       # Remove and return item at index 0
items.sort()                # Sort in ascending order (in-place)
items.sort(reverse=True)    # Sort in descending order
items.reverse()             # Reverse the list (in-place)
items.clear()               # Remove all items

print(len(items))           # Number of items
print(items.count(1))       # Count occurrences of 1
print(items.index(5))       # Index of first occurrence of 5
print(5 in items)           # Check membership: True/False

# sorted() returns new list without modifying original
original = [3, 1, 4, 1, 5]
sorted_list = sorted(original)
print(original)             # [3, 1, 4, 1, 5] (unchanged)
print(sorted_list)          # [1, 1, 3, 4, 5]

List Comprehension

List comprehension là cú pháp đặc trưng của Python cho phép tạo list theo cách ngắn gọn và Pythonic hơn so với vòng lặp thông thường. Ngoài việc ngắn hơn, list comprehension thường chạy nhanh hơn vòng lặp for thông thường do được tối ưu ở tầng implementation.

# Basic list comprehension
squares = [x**2 for x in range(10)]
print(squares)  # [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

# With condition (filter)
even_squares = [x**2 for x in range(10) if x % 2 == 0]
print(even_squares)     # [0, 4, 16, 36, 64]

# Nested list comprehension
matrix = [[i * j for j in range(1, 4)] for i in range(1, 4)]
print(matrix)   # [[1, 2, 3], [2, 4, 6], [3, 6, 9]]

# Flatten a nested list
flat = [item for sublist in matrix for item in sublist]
print(flat)     # [1, 2, 3, 2, 4, 6, 3, 6, 9]

Tuple

Tuple giống list ở chỗ lưu trữ một dãy phần tử có thứ tự, nhưng khác ở chỗ không thể thay đổi sau khi tạo. Tính bất biến này có một số lợi ích thực tế: tuple nhanh hơn list trong các thao tác đọc, có thể dùng làm key trong dictionary và có thể giúp đảm bảo dữ liệu không bị sửa đổi ngoài ý muốn. Tuple thường dùng để lưu các tập hợp dữ liệu có ý nghĩa gắn liền nhau như tọa độ, RGB color hay các giá trị cấu hình.

# Creating tuples
coordinates = (10.5, 106.7)
colors = ("red", "green", "blue")
single = (42,)      # Single-element tuple MUST have trailing comma
empty = ()

# Accessing elements (same as list)
print(coordinates[0])       # 10.5
print(colors[-1])           # blue
print(colors[0:2])          # ('red', 'green')

# Tuple unpacking
x, y = coordinates
print(x, y)     # 10.5 106.7

# Extended unpacking
first, *middle, last = (1, 2, 3, 4, 5)
print(first)    # 1
print(middle)   # [2, 3, 4]
print(last)     # 5

# Tuple methods
print(len(colors))              # 3
print(colors.count("red"))      # 1
print(colors.index("green"))    # 1

# Convert between list and tuple
as_list = list(colors)
as_tuple = tuple(as_list)

Dictionary

Dictionary là cấu trúc dữ liệu lưu trữ dữ liệu theo cặp key-value, tương tự như một bảng tra cứu. Mỗi key phải là duy nhất và phải là kiểu bất biến như string, number hay tuple. Dictionary được tối ưu cho việc tìm kiếm theo key với độ phức tạp O(1), làm cho nó trở thành lựa chọn hoàn hảo khi bạn cần truy cập dữ liệu nhanh theo một định danh cụ thể.

image.png
Cú pháp sơ cấp trong Python - 2

Tạo và thao tác với Dictionary

Từ Python 3.7 trở đi, dictionary giữ nguyên thứ tự chèn, vì vậy bạn có thể tin tưởng vào thứ tự khi duyệt qua dictionary. Phương thức get() được ưu tiên hơn truy cập trực tiếp bằng [] khi key có thể không tồn tại vì không gây lỗi KeyError.

# Creating dictionary
student = {
    "name": "Alice Johnson",
    "age": 22,
    "gpa": 3.8,
    "major": "Computer Science"
}

# Accessing values
print(student["name"])                          # Alice Johnson
print(student.get("age"))                       # 22
print(student.get("phone", "Not provided"))     # Not provided (default value)

# Adding and updating
student["email"] = "alice@example.com"          # Add new key
student["age"] = 23                             # Update existing key
student.update({"gpa": 3.9, "year": 3})        # Update multiple keys

# Removing
del student["email"]                            # Delete key
removed = student.pop("year")                   # Remove and return value
student.clear()                                 # Remove all keys

# Iterating
for key in student.keys():
    print(key)

for value in student.values():
    print(value)

for key, value in student.items():
    print(f"{key}: {value}")

# Check membership
print("name" in student)        # True
print("phone" in student)       # False

# Merge dictionaries (Python 3.9+)
defaults = {"theme": "dark", "language": "en"}
user_prefs = {"language": "vi", "font_size": 14}
merged = defaults | user_prefs
print(merged)   # {'theme': 'dark', 'language': 'vi', 'font_size': 14}

Dictionary Comprehension

Tương tự list comprehension, dictionary comprehension cho phép tạo dictionary một cách ngắn gọn từ một iterable. Cú pháp có thêm : để phân tách key và value trong biểu thức.

# Create dictionary from list
numbers = [1, 2, 3, 4, 5]
squares = {x: x**2 for x in numbers}
print(squares)      # {1: 1, 2: 4, 3: 9, 4: 16, 5: 25}

# With condition
even_squares = {x: x**2 for x in numbers if x % 2 == 0}
print(even_squares) # {2: 4, 4: 16}

# Swap keys and values
original = {"a": 1, "b": 2, "c": 3}
swapped = {v: k for k, v in original.items()}
print(swapped)      # {1: 'a', 2: 'b', 3: 'c'}

Set

Set là tập hợp các phần tử không trùng lặp và không có thứ tự cố định. Set được tối ưu cho các thao tác kiểm tra thuộc về (membership testing) và các phép toán tập hợp như hợp, giao, hiệu. Khi cần loại bỏ giá trị trùng lặp từ một list hoặc thực hiện các phép so sánh tập hợp, set là công cụ phù hợp nhất.

# Creating sets
set_a = {1, 2, 3, 4, 5}
set_b = {4, 5, 6, 7, 8}
empty_set = set()       # Note: {} creates empty dict, not set

# Adding and removing
set_a.add(6)
set_a.remove(1)         # Raises KeyError if not found
set_a.discard(10)       # Safe remove, no error if not found

# Set operations
print(set_a | set_b)    # Union: {1, 2, 3, 4, 5, 6, 7, 8}
print(set_a & set_b)    # Intersection: {4, 5}
print(set_a - set_b)    # Difference: {1, 2, 3}
print(set_a ^ set_b)    # Symmetric difference: {1, 2, 3, 6, 7, 8}

# Checking relationships
print(set_a.issubset(set_b))        # False
print(set_a.issuperset({1, 2}))     # True
print(set_a.isdisjoint({10, 11}))   # True (no common elements)

# Practical use: remove duplicates from list
duplicates = [1, 2, 2, 3, 3, 3, 4, 5, 5]
unique = list(set(duplicates))
print(unique)   # [1, 2, 3, 4, 5] (order not guaranteed)

Python cheatsheet cấp độ: Trung cấp (Functions & Logic Control)

Ở cấp độ này, bạn bắt đầu học cách tổ chức code thành các đơn vị có thể tái sử dụng và kiểm soát luồng thực thi của chương trình theo nhiều cách khác nhau. Hàm giúp tránh lặp code và chia nhỏ bài toán phức tạp thành các phần dễ quản lý hơn. Cấu trúc điều kiện và vòng lặp cho phép chương trình đưa ra quyết định và xử lý dữ liệu lặp đi lặp lại. Xử lý ngoại lệ giúp chương trình phản ứng có kiểm soát trước các tình huống không mong muốn thay vì crash đột ngột. Làm việc với file và module mở ra khả năng đọc ghi dữ liệu thực tế và tái sử dụng code giữa các dự án. Đây là nhóm kỹ năng biến bạn từ người biết viết code thành người có thể xây dựng chương trình hoàn chỉnh.

image.png
Cú pháp Python trung cấp - 1

Cấu trúc điều kiện và vòng lặp

Cấu trúc điều kiện và vòng lặp là hai trụ cột điều khiển luồng thực thi của chương trình. Cấu trúc điều kiện cho phép chương trình đưa ra quyết định dựa trên dữ liệu, còn vòng lặp cho phép thực hiện một tác vụ nhiều lần mà không cần viết lại code. Nắm vững hai phần này giúp bạn giải quyết được phần lớn các bài toán lập trình từ cơ bản đến trung bình.

Câu lệnh if-elif-else

Python dùng thụt lề để phân cấp khối lệnh thay vì dấu ngoặc nhọn như các ngôn ngữ khác. Điều này buộc bạn phải giữ code gọn gàng ngay từ đầu. Một câu lệnh if có thể đứng một mình, kết hợp với else hoặc mở rộng với nhiều elif để xử lý nhiều trường hợp.

score = 75

if score >= 90:
    print("Excellent")
elif score >= 80:
    print("Good")
elif score >= 65:
    print("Average")
elif score >= 50:
    print("Below average")
else:
    print("Fail")

Toán tử ba ngôi (Ternary operator)

Đây là cách viết câu lệnh if-else đơn giản trên một dòng duy nhất, rất hữu ích khi bạn cần gán giá trị có điều kiện mà không muốn viết nhiều dòng. Tuy nhiên không nên lồng nhiều ternary operator vào nhau vì sẽ khiến code khó đọc.

age = 20
status = "Adult" if age >= 18 else "Minor"
print(status)   # Adult

# Useful for simple conditional assignment
price = 100
discount = 0.2 if price > 50 else 0
final_price = price * (1 - discount)
print(final_price)  # 80.0

Vòng lặp for

Vòng lặp for trong Python duyệt qua từng phần tử của một iterable, có thể là list, tuple, string, dictionary hay bất kỳ đối tượng nào hỗ trợ iteration. Hàm range() thường được dùng khi bạn cần lặp một số lần cố định hoặc tạo ra dãy số theo bước nhảy tùy chọn.

# Iterate over a list
fruits = ["apple", "banana", "orange"]
for fruit in fruits:
    print(fruit)

# Using range()
for i in range(5):          # 0 to 4
    print(i)

for i in range(2, 8):       # 2 to 7
    print(i)

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

# Enumerate: get both index and value
for index, fruit in enumerate(fruits):
    print(f"{index}: {fruit}")

# Iterate over dictionary
student = {"name": "Alice", "age": 22, "gpa": 3.8}
for key, value in student.items():
    print(f"{key}: {value}")

Vòng lặp while

Vòng lặp while tiếp tục thực thi khi điều kiện còn đúng. Đây là lựa chọn phù hợp khi bạn không biết trước số lần lặp và muốn kiểm tra điều kiện ở đầu mỗi vòng. Luôn đảm bảo có cơ chế để điều kiện trở thành False ở một thời điểm nào đó, nếu không vòng lặp sẽ chạy mãi.

count = 0
while count < 5:
    print(f"Count: {count}")
    count += 1

# While loop with user input
while True:
    user_input = input("Type 'quit' to exit: ")
    if user_input == "quit":
        break
    print(f"You typed: {user_input}")

Lệnh break, continue và pass

Ba lệnh này cho phép kiểm soát chi tiết hơn luồng thực thi bên trong vòng lặp. break thoát khỏi vòng lặp ngay lập tức, continue bỏ qua phần còn lại của lần lặp hiện tại và chuyển sang lần lặp tiếp theo, còn pass là lệnh không làm gì cả nhưng cần thiết về mặt cú pháp khi Python yêu cầu phải có ít nhất một lệnh trong khối.

# break: exit the loop immediately
for i in range(10):
    if i == 5:
        break
    print(i)    # Prints 0 to 4

# continue: skip current iteration
for i in range(10):
    if i % 2 == 0:
        continue
    print(i)    # Prints odd numbers: 1, 3, 5, 7, 9

# pass: placeholder, does nothing
for i in range(5):
    pass    # Will implement later

# else clause in loops (runs when loop completes normally)
for i in range(5):
    print(i)
else:
    print("Loop completed successfully")

Hàm

Hàm là đơn vị tổ chức code cơ bản nhất trong Python. Thay vì viết lặp đi lặp lại cùng một đoạn logic, bạn đặt nó vào một hàm và gọi lại khi cần. Python hỗ trợ nhiều tính năng mạnh mẽ liên quan đến hàm như tham số mặc định, tham số không giới hạn và hàm lambda, tất cả giúp code trở nên linh hoạt và tái sử dụng được tốt hơn.

image.png
Cú pháp Python trung cấp - 2

Khai báo và gọi hàm

Mọi hàm trong Python đều được khai báo bằng từ khóa def. Hàm có thể nhận tham số, thực hiện tính toán và trả về giá trị bằng return. Nếu không có return, hàm tự động trả về None. Python cũng cho phép hàm trả về nhiều giá trị cùng lúc dưới dạng tuple.

# Basic function
def greet(name):
    print(f"Hello, {name}!")

greet("Python")     # Hello, Python!

# Function with return value
def add(a, b):
    return a + b

result = add(3, 5)
print(result)       # 8

# Function returning multiple values
def get_min_max(numbers):
    return min(numbers), max(numbers)

minimum, maximum = get_min_max([3, 1, 4, 1, 5, 9, 2])
print(minimum, maximum)     # 1 9

Tham số mặc định và tham số từ khóa

Tham số mặc định cho phép bạn định nghĩa giá trị fallback khi người gọi không truyền vào. Tham số từ khóa cho phép truyền đối số theo tên thay vì theo vị trí, giúp code dễ đọc hơn đặc biệt khi hàm có nhiều tham số. Lưu ý quan trọng: tham số mặc định phải đặt sau tất cả tham số bắt buộc.

def create_profile(name, age=18, country="Vietnam"):
    print(f"{name}, {age} years old, from {country}")

create_profile("Alice")                         # Alice, 18 years old, from Vietnam
create_profile("Bob", 25)                       # Bob, 25 years old, from Vietnam
create_profile("Charlie", country="Japan")      # Charlie, 18 years old, from Japan
create_profile("Dave", 30, "Singapore")         # Dave, 30 years old, from Singapore

Tham số *args và **kwargs

*args cho phép hàm nhận số lượng đối số vị trí không giới hạn, tất cả được gom vào một tuple. **kwargs cho phép nhận số lượng đối số từ khóa không giới hạn, tất cả được gom vào một dictionary. Hai tính năng này rất hữu ích khi bạn muốn viết hàm linh hoạt mà không biết trước số lượng tham số.

# *args: variable positional arguments
def calculate_sum(*numbers):
    return sum(numbers)

print(calculate_sum(1, 2, 3))           # 6
print(calculate_sum(1, 2, 3, 4, 5))    # 15

# **kwargs: variable keyword arguments
def display_info(**info):
    for key, value in info.items():
        print(f"{key}: {value}")

display_info(name="Alice", age=22, role="Developer")

# Combining both
def mixed_function(required, *args, **kwargs):
    print(f"Required: {required}")
    print(f"Args: {args}")
    print(f"Kwargs: {kwargs}")

mixed_function("hello", 1, 2, 3, key1="a", key2="b")

Lambda (Hàm vô danh)

Lambda là hàm ẩn danh được định nghĩa trên một dòng duy nhất, thường dùng cho các tác vụ đơn giản mà bạn không muốn đặt tên hàm riêng. Lambda đặc biệt hữu ích khi dùng kết hợp với các hàm bậc cao như sorted(), map() hay filter().

# Basic lambda
square = lambda x: x ** 2
print(square(5))    # 25

# Lambda with multiple parameters
add = lambda x, y: x + y
print(add(3, 4))    # 7

# Common use with sorted()
students = [("Alice", 85), ("Bob", 92), ("Charlie", 78)]
sorted_students = sorted(students, key=lambda x: x[1], reverse=True)
print(sorted_students)  # [('Bob', 92), ('Alice', 85), ('Charlie', 78)]

Hàm map, filter và reduce

Đây là ba hàm bậc cao phổ biến nhất trong Python, cho phép xử lý collection theo cách khai báo thay vì dùng vòng lặp tường minh. map() áp dụng một hàm lên từng phần tử, filter() lọc phần tử theo điều kiện, còn reduce() gộp tất cả phần tử thành một giá trị duy nhất.

numbers = [1, 2, 3, 4, 5, 6, 7, 8]

# map(): apply function to each element
squares = list(map(lambda x: x ** 2, numbers))
print(squares)      # [1, 4, 9, 16, 25, 36, 49, 64]

# filter(): keep elements that satisfy condition
evens = list(filter(lambda x: x % 2 == 0, numbers))
print(evens)        # [2, 4, 6, 8]

# reduce(): accumulate elements into single value
from functools import reduce
total = reduce(lambda x, y: x + y, numbers)
print(total)        # 36

product = reduce(lambda x, y: x * y, numbers)
print(product)      # 40320

Xử lý ngoại lệ (Exception Handling)

Trong thực tế, chương trình luôn có thể gặp các tình huống không mong muốn như file không tồn tại, dữ liệu đầu vào sai định dạng hay kết nối mạng thất bại. Xử lý ngoại lệ là cách để chương trình phản ứng với những tình huống đó một cách có kiểm soát thay vì crash đột ngột. Python dùng cơ chế try-except cho mục đích này, với cú pháp rõ ràng và hỗ trợ nhiều loại exception khác nhau.

Try-Except cơ bản

Khối try chứa code có thể phát sinh lỗi. Nếu lỗi xảy ra, Python nhảy ngay đến khối except tương ứng. Khối else chỉ chạy khi không có lỗi nào xảy ra, còn finally luôn chạy dù có lỗi hay không, thường dùng để dọn dẹp tài nguyên như đóng file hay kết nối database.

try:
    number = int(input("Enter a number: "))
    result = 100 / number
    print(f"Result: {result}")
except ValueError:
    print("Error: Please enter a valid integer")
except ZeroDivisionError:
    print("Error: Cannot divide by zero")
except (TypeError, AttributeError) as e:
    print(f"Type error: {e}")
except Exception as e:
    print(f"Unexpected error: {type(e).__name__}: {e}")
else:
    print("Operation completed successfully")
finally:
    print("This always executes (cleanup code goes here)")

Raise và Exception tùy chỉnh

Bạn có thể tự tạo ra các exception riêng bằng cách kế thừa từ class Exception. Điều này giúp phân biệt rõ ràng các loại lỗi đặc thù của ứng dụng và cho phép xử lý chúng theo cách khác nhau ở tầng gọi hàm. Lệnh raise được dùng để ném ra exception, có thể là exception có sẵn hoặc exception tùy chỉnh.

class InvalidScoreError(Exception):
    def __init__(self, score, message=None):
        self.score = score
        self.message = message or f"Score {score} is invalid (must be 0-100)"
        super().__init__(self.message)

class NegativeAmountError(ValueError):
    pass

def validate_score(score):
    if not isinstance(score, (int, float)):
        raise TypeError(f"Score must be a number, got {type(score).__name__}")
    if not 0 <= score <= 100:
        raise InvalidScoreError(score)
    return score

try:
    validate_score(150)
except InvalidScoreError as e:
    print(f"Invalid score: {e.score} - {e.message}")
except TypeError as e:
    print(f"Type error: {e}")

Xử lý file

Làm việc với file là kỹ năng thiết yếu khi xây dựng bất kỳ ứng dụng thực tế nào. Python cung cấp cú pháp with rất tiện lợi để đảm bảo file luôn được đóng đúng cách ngay cả khi có lỗi xảy ra giữa chừng. Đây là cách được khuyến nghị sử dụng thay vì gọi open() và close() thủ công.

Đọc và ghi file văn bản

Khi làm việc với file chứa tiếng Việt hoặc ký tự đặc biệt, luôn chỉ định encoding="utf-8" để tránh các lỗi encoding khó debug. Python có ba chế độ mở file phổ biến: "r" để đọc, "w" để ghi mới (xóa nội dung cũ) và "a" để ghi thêm vào cuối file.

# Writing to file
with open("data.txt", "w", encoding="utf-8") as f:
    f.write("First line\n")
    f.write("Second line\n")
    f.writelines(["Line 3\n", "Line 4\n", "Line 5\n"])

# Reading entire file at once
with open("data.txt", "r", encoding="utf-8") as f:
    content = f.read()
    print(content)

# Reading line by line (memory efficient for large files)
with open("data.txt", "r", encoding="utf-8") as f:
    for line in f:
        print(line.strip())     # strip() removes the newline character

# Reading into list of lines
with open("data.txt", "r", encoding="utf-8") as f:
    lines = f.readlines()
    print(lines)    # List of strings, each ending with \n

# Appending to existing file
with open("data.txt", "a", encoding="utf-8") as f:
    f.write("Appended line\n")

Xử lý file JSON

JSON là định dạng trao đổi dữ liệu phổ biến nhất hiện nay, đặc biệt khi làm việc với API. Module json của Python cho phép chuyển đổi qua lại giữa Python object và JSON string hoặc file một cách dễ dàng. Khi ghi JSON có chứa ký tự Unicode như tiếng Việt, cần đặt ensure_ascii=False để giữ nguyên ký tự thay vì escape thành dạng \uXXXX.

import json

# Write JSON to file
data = {
    "name": "Alice Johnson",
    "age": 22,
    "skills": ["Python", "SQL", "Docker"],
    "is_active": True,
    "score": None
}

with open("data.json", "w", encoding="utf-8") as f:
    json.dump(data, f, ensure_ascii=False, indent=4)

# Read JSON from file
with open("data.json", "r", encoding="utf-8") as f:
    loaded_data = json.load(f)
    print(loaded_data["name"])      # Alice Johnson
    print(loaded_data["skills"])    # ['Python', 'SQL', 'Docker']

# Convert between Python object and JSON string
json_string = json.dumps(data, ensure_ascii=False)
python_object = json.loads(json_string)
print(type(python_object))  # <class 'dict'>

Modules và Packages

Module là file Python chứa code có thể tái sử dụng. Package là thư mục chứa nhiều module có liên quan nhau. Hệ sinh thái thư viện của Python là một trong những điểm mạnh lớn nhất của ngôn ngữ này, với hơn 500.000 package trên PyPI (Python Package Index) sẵn sàng để cài đặt và dùng ngay.

Import module

Python có nhiều cách import tùy theo nhu cầu. Import toàn bộ module giúp tránh xung đột tên nhưng phải gõ tên module mỗi lần dùng. Import hàm cụ thể giúp viết code ngắn hơn nhưng cần cẩn thận khi có nhiều module có hàm tên giống nhau.

# Import entire module
import math
print(math.pi)              # 3.141592653589793
print(math.sqrt(16))        # 4.0
print(math.ceil(4.2))       # 5
print(math.floor(4.9))      # 4
print(math.log(100, 10))    # 2.0

# Import with alias
import numpy as np
import pandas as pd

# Import specific functions
from math import sqrt, pi, factorial
print(sqrt(25))             # 5.0
print(factorial(5))         # 120

# Import all (not recommended in production)
from math import *

Một số module chuẩn hay dùng

Python Standard Library cung cấp sẵn rất nhiều module mà bạn không cần cài thêm. Nắm được các module này giúp bạn giải quyết nhiều bài toán thực tế mà không cần phụ thuộc vào thư viện bên ngoài.

import os
import sys
import datetime
import random
import re

# os: operating system interface
print(os.getcwd())                          # Current working directory
print(os.path.exists("data.txt"))           # Check if file exists
print(os.path.join("folder", "file.txt"))   # Build path correctly
os.makedirs("new_folder", exist_ok=True)    # Create directory
files = os.listdir(".")                     # List files in directory

# datetime: date and time
today = datetime.date.today()
now = datetime.datetime.now()
print(today)                                    # 2026-06-16
print(now.strftime("%d/%m/%Y %H:%M:%S"))        # 16/06/2026 10:30:00

delta = datetime.timedelta(days=7)
next_week = today + delta
print(next_week)

# random: random number generation
print(random.randint(1, 100))               # Random integer 1-100
print(random.choice(["a", "b", "c"]))      # Random choice from list
print(random.random())                      # Random float 0.0-1.0
print(random.uniform(1.5, 10.5))           # Random float in range

items = [1, 2, 3, 4, 5]
random.shuffle(items)
print(items)

sample = random.sample(range(100), 5)      # 5 unique random numbers
print(sample)

# re: regular expressions
pattern = r'\d+'
text = "There are 42 students and 15 teachers"
matches = re.findall(pattern, text)
print(matches)      # ['42', '15']

email_pattern = r'^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$'
print(bool(re.match(email_pattern, "user@example.com")))    # True

Python cheatsheet cấp độ: Cao cấp (Advanced OOP & Functional Programming)

Nhóm kiến thức này đánh dấu bước chuyển từ viết code chạy được sang viết code có cấu trúc tốt, dễ mở rộng và dễ bảo trì. Lập trình hướng đối tượng giúp tổ chức code xung quanh các đối tượng phản ánh thực thể trong bài toán thực tế, đặc biệt quan trọng khi ứng dụng tăng về quy mô và độ phức tạp. Generator và Iterator mang đến cách xử lý dữ liệu lớn mà không tiêu tốn bộ nhớ không cần thiết. Decorator là công cụ mạnh mẽ để mở rộng chức năng của hàm theo cách tái sử dụng được mà không cần sửa code gốc. Nắm vững nhóm này là điều kiện để bạn đọc hiểu và đóng góp vào các codebase chuyên nghiệp trong môi trường thực tế.

image.png
Cú pháp Python cao cấp - 1

Lập trình hướng đối tượng (OOP)

Lập trình hướng đối tượng là paradigm tổ chức code xung quanh các đối tượng, mỗi đối tượng kết hợp dữ liệu và hành vi liên quan vào một đơn vị. Python hỗ trợ đầy đủ bốn tính chất của OOP là đóng gói, kế thừa, đa hình và trừu tượng. Khi bạn bắt đầu xây dựng những ứng dụng có độ phức tạp nhất định, OOP giúp tổ chức code theo cách có cấu trúc hơn và dễ bảo trì hơn đáng kể.

Khai báo Class và tạo Object

Class là bản thiết kế, còn object là thực thể được tạo ra từ bản thiết kế đó. Phương thức __init__ là constructor, tự động chạy khi tạo object mới. Tham số self tham chiếu đến object hiện tại và phải là tham số đầu tiên của mọi phương thức instance. Các phương thức bắt đầu và kết thúc bằng hai dấu gạch dưới như __str__, __repr__ được gọi là dunder methods và được Python gọi tự động trong các tình huống cụ thể.

class Student:
    # Class variable (shared by all instances)
    school = "ABC University"
    student_count = 0

    def __init__(self, name, age, gpa):
        # Instance variables (unique to each object)
        self.name = name
        self.age = age
        self.gpa = gpa
        Student.student_count += 1

    def introduce(self):
        print(f"I'm {self.name}, {self.age} years old, GPA: {self.gpa}")

    def get_grade(self):
        if self.gpa >= 3.7:
            return "A"
        elif self.gpa >= 3.3:
            return "B"
        elif self.gpa >= 3.0:
            return "C"
        else:
            return "F"

    def __str__(self):
        return f"Student({self.name}, GPA: {self.gpa})"

    def __repr__(self):
        return f"Student(name={self.name!r}, age={self.age}, gpa={self.gpa})"

# Create objects
alice = Student("Alice", 22, 3.8)
bob = Student("Bob", 21, 3.5)

alice.introduce()
print(alice.get_grade())        # A
print(Student.school)           # ABC University
print(Student.student_count)    # 2
print(alice)                    # Student(Alice, GPA: 3.8)

Kế thừa (Inheritance)

Kế thừa cho phép một class mới (child) thừa hưởng thuộc tính và phương thức của class có sẵn (parent), sau đó mở rộng hoặc ghi đè theo nhu cầu. Hàm super() được dùng để gọi phương thức của class cha từ class con, thường thấy nhất trong __init__ để đảm bảo class cha được khởi tạo đúng cách.

class Person:
    def __init__(self, name, email):
        self.name = name
        self.email = email

    def introduce(self):
        print(f"Person: {self.name} ({self.email})")

class Developer(Person):
    def __init__(self, name, email, languages):
        super().__init__(name, email)   # Call parent's __init__
        self.languages = languages

    def introduce(self):                # Override parent method
        super().introduce()
        print(f"Languages: {', '.join(self.languages)}")

    def code(self):
        return f"{self.name} is coding in {self.languages[0]}"

dev = Developer("Alice", "alice@dev.com", ["Python", "JavaScript", "Go"])
dev.introduce()
print(dev.code())

# Check inheritance
print(isinstance(dev, Developer))   # True
print(isinstance(dev, Person))      # True
print(issubclass(Developer, Person))    # True

Encapsulation (Đóng gói)

Đóng gói là cơ chế ẩn chi tiết triển khai bên trong và chỉ expose những gì cần thiết ra bên ngoài. Trong Python, quy ước đặt tên dùng một dấu gạch dưới _ cho thuộc tính protected và hai dấu gạch dưới __ cho thuộc tính private, mặc dù Python không thực sự ngăn chặn truy cập từ bên ngoài mà chỉ là quy ước.

class BankAccount:
    def __init__(self, owner, balance):
        self.owner = owner
        self.__balance = balance    # Private attribute

    def deposit(self, amount):
        if amount > 0:
            self.__balance += amount
            return f"Deposited ${amount:,.2f}. New balance: ${self.__balance:,.2f}"
        raise ValueError("Deposit amount must be positive")

    def withdraw(self, amount):
        if amount <= 0:
            raise ValueError("Withdrawal amount must be positive")
        if amount > self.__balance:
            raise ValueError("Insufficient funds")
        self.__balance -= amount
        return f"Withdrawn ${amount:,.2f}. New balance: ${self.__balance:,.2f}"

    @property
    def balance(self):
        return self.__balance   # Controlled read access

account = BankAccount("Alice", 1000)
print(account.deposit(500))
print(account.withdraw(200))
print(account.balance)          # 1300
# print(account.__balance)      # AttributeError

Generators và Iterators

Generator và Iterator là hai khái niệm liên quan chặt chẽ đến cách Python xử lý dữ liệu theo kiểu "lazy evaluation", tức là chỉ tính toán và tạo ra giá trị khi thực sự cần. Thay vì tạo toàn bộ dữ liệu và lưu vào bộ nhớ ngay lập tức, generator tạo ra từng giá trị một theo yêu cầu. Điều này đặc biệt quan trọng khi làm việc với tập dữ liệu lớn mà nếu load hết vào RAM sẽ gây vấn đề.

image.png
Cú pháp Python cao cấp - 2

Generator

Generator function dùng từ khóa yield thay vì return. Mỗi lần gọi next() trên generator, function thực thi cho đến khi gặp yield, trả về giá trị đó rồi dừng lại. Lần tiếp theo sẽ tiếp tục từ chỗ dừng. Generator tự động là iterator, không cần implement thêm gì.

# Generator function using yield
def count_up(n):
    i = 0
    while i < n:
        yield i
        i += 1

counter = count_up(5)
print(next(counter))    # 0
print(next(counter))    # 1
print(next(counter))    # 2

# Use in for loop (most common usage)
for num in count_up(5):
    print(num)  # 0, 1, 2, 3, 4

# Infinite generator (memory-safe)
def fibonacci():
    a, b = 0, 1
    while True:
        yield a
        a, b = b, a + b

fib = fibonacci()
first_10 = [next(fib) for _ in range(10)]
print(first_10)     # [0, 1, 1, 2, 3, 5, 8, 13, 21, 34]

# Generator expression (lazy version of list comprehension)
squares_gen = (x**2 for x in range(1000000))   # Uses almost no memory
print(next(squares_gen))    # 0
print(next(squares_gen))    # 1

# Compare memory usage
import sys
list_comp = [x**2 for x in range(10000)]
gen_exp = (x**2 for x in range(10000))
print(sys.getsizeof(list_comp))     # ~85 KB
print(sys.getsizeof(gen_exp))       # ~200 bytes

Iterator tùy chỉnh

Để tạo iterator tùy chỉnh, class của bạn cần implement hai phương thức đặc biệt: __iter__() trả về chính object đó, và __next__() trả về giá trị tiếp theo hoặc raise StopIteration khi hết.

class CountDown:
    def __init__(self, start):
        self.start = start

    def __iter__(self):
        self.current = self.start
        return self

    def __next__(self):
        if self.current <= 0:
            raise StopIteration
        value = self.current
        self.current -= 1
        return value

for num in CountDown(5):
    print(num)      # 5, 4, 3, 2, 1

# Can also use next() manually
countdown = CountDown(3)
iterator = iter(countdown)
print(next(iterator))   # 3
print(next(iterator))   # 2

Decorators

Decorator là một pattern mạnh mẽ trong Python cho phép bạn thêm chức năng vào một hàm hoặc class mà không cần sửa code gốc của nó. Về bản chất, decorator là một hàm nhận hàm khác làm tham số, bọc thêm logic xung quanh và trả về hàm mới. Cú pháp @decorator_name là cách viết tắt của function = decorator(function). Decorator thường được dùng cho logging, authentication, caching, validation và đo thời gian thực thi.

import functools
import time

# Basic decorator structure
def my_decorator(func):
    @functools.wraps(func)      # Preserves original function's metadata
    def wrapper(*args, **kwargs):
        print(f"Before calling {func.__name__}")
        result = func(*args, **kwargs)
        print(f"After calling {func.__name__}")
        return result
    return wrapper

@my_decorator
def say_hello(name):
    print(f"Hello, {name}!")

say_hello("Alice")
# Before calling say_hello
# Hello, Alice!
# After calling say_hello

# Timing decorator
def timer(func):
    @functools.wraps(func)
    def wrapper(*args, **kwargs):
        start = time.perf_counter()
        result = func(*args, **kwargs)
        end = time.perf_counter()
        print(f"{func.__name__} took {end - start:.4f} seconds")
        return result
    return wrapper

@timer
def slow_function():
    time.sleep(0.1)
    return "Done"

slow_function()     # slow_function took 0.1003 seconds

# Decorator with parameters
def repeat(n):
    def decorator(func):
        @functools.wraps(func)
        def wrapper(*args, **kwargs):
            for _ in range(n):
                result = func(*args, **kwargs)
            return result
        return wrapper
    return decorator

@repeat(3)
def greet(name):
    print(f"Hello, {name}!")

greet("Alice")
# Hello, Alice!
# Hello, Alice!
# Hello, Alice!

# Stacking multiple decorators
@timer
@repeat(2)
def combined_example():
    print("Running...")

combined_example()

Python cheatsheet cấp độ: Ứng dụng & Kiểm thử (Applications & Testing)

Đây là nơi Python tỏa sáng nhất. Sau khi đã có nền tảng vững chắc, nhóm kiến thức này đưa bạn vào những lĩnh vực ứng dụng thực tế mà Python đang dẫn đầu thị trường. NumPy là nền tảng của mọi tính toán số học hiệu năng cao trong Python, Pandas là công cụ không thể thiếu cho phân tích và xử lý dữ liệu, còn Requests đơn giản hóa việc tích hợp với bất kỳ REST API nào chỉ trong vài dòng code. Đây là bộ ba thư viện mà bất kỳ lập trình viên Python nào làm việc trong mảng data, backend hay automation đều cần biết và sử dụng thành thục.

image.png
Cú pháp Python ứng dụng - 1

Thư viện phổ biến

Python có một hệ sinh thái thư viện bên ngoài cực kỳ phong phú, và có một số thư viện gần như là bắt buộc phải biết tùy vào lĩnh vực bạn làm việc. Ba thư viện dưới đây là những cái tên xuất hiện thường xuyên nhất trong môi trường làm việc thực tế và được cộng đồng developer Việt Nam sử dụng rộng rãi.

NumPy: Tính toán số học hiệu năng cao

NumPy cung cấp cấu trúc dữ liệu mảng đa chiều (ndarray) và hàng trăm hàm toán học được tối ưu cho tính toán số học. NumPy nhanh hơn list Python thông thường rất nhiều khi xử lý dữ liệu số vì các phép tính được thực hiện ở tầng C thay vì Python. NumPy là nền tảng của gần như toàn bộ hệ sinh thái data science Python bao gồm Pandas, Matplotlib và Scikit-learn.

import numpy as np

# Creating arrays
a = np.array([1, 2, 3, 4, 5])
b = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])

print(a.shape)      # (5,) - 1D array with 5 elements
print(b.shape)      # (3, 3) - 3x3 2D array
print(b.ndim)       # 2 dimensions
print(b.dtype)      # int64

# Special arrays
print(np.zeros((3, 3)))         # 3x3 matrix of zeros
print(np.ones((2, 4)))          # 2x4 matrix of ones
print(np.eye(3))                # 3x3 identity matrix
print(np.arange(0, 10, 2))     # [0 2 4 6 8]
print(np.linspace(0, 1, 5))    # [0. 0.25 0.5 0.75 1.]
print(np.random.rand(3, 3))    # 3x3 random matrix

# Element-wise operations (vectorized)
x = np.array([1, 2, 3, 4, 5])
print(x + 10)       # [11 12 13 14 15]
print(x * 2)        # [2 4 6 8 10]
print(x ** 2)       # [1 4 9 16 25]
print(np.sqrt(x))   # [1. 1.414 1.732 2. 2.236]

# Statistical functions
print(np.sum(x))    # 15
print(np.mean(x))   # 3.0
print(np.std(x))    # 1.414
print(np.max(x))    # 5
print(np.min(x))    # 1
print(np.argmax(x)) # 4 (index of max value)

# Array indexing and slicing
print(b[1, 2])          # 6 (row 1, col 2)
print(b[:, 1])          # [2 5 8] (all rows, col 1)
print(b[b > 5])         # [6 7 8 9] (boolean indexing)

Pandas: Phân tích và xử lý dữ liệu

Pandas cung cấp hai cấu trúc dữ liệu chính là Series (1 chiều) và DataFrame (2 chiều, giống bảng Excel). Pandas đặc biệt mạnh trong việc đọc dữ liệu từ nhiều định dạng khác nhau, làm sạch dữ liệu, phân tích thống kê và chuyển đổi dữ liệu. Đây là công cụ không thể thiếu trong workflow của Data Analyst và Data Scientist.

image.png
Cú pháp Python ứng dụng - 2
import pandas as pd

# Creating DataFrame
data = {
    "name": ["Alice", "Bob", "Charlie", "Diana", "Eve"],
    "age": [25, 30, 22, 28, 35],
    "score": [85, 92, 78, 88, 95],
    "department": ["IT", "IT", "Finance", "IT", "HR"]
}

df = pd.DataFrame(data)
print(df)
print(df.head(3))           # First 3 rows
print(df.tail(2))           # Last 2 rows
print(df.shape)             # (5, 4)
print(df.dtypes)            # Data types of each column
print(df.describe())        # Statistical summary
print(df.info())            # Overview with null counts

# Accessing data
print(df["name"])                   # Single column (Series)
print(df[["name", "score"]])        # Multiple columns (DataFrame)
print(df.iloc[0])                   # First row by position
print(df.loc[0, "name"])            # Specific cell by label
print(df.iloc[1:3, 0:2])           # Slice by position

# Filtering
it_staff = df[df["department"] == "IT"]
high_scorers = df[df["score"] >= 90]
print(it_staff)

# Multiple conditions
top_it = df[(df["department"] == "IT") & (df["score"] >= 85)]
print(top_it)

# Sorting
df_sorted = df.sort_values("score", ascending=False)
print(df_sorted)

# Grouping and aggregation
dept_stats = df.groupby("department")["score"].agg(["mean", "max", "count"])
print(dept_stats)

# Adding and modifying columns
df["grade"] = df["score"].apply(lambda x: "A" if x >= 90 else "B")
df["score_normalized"] = (df["score"] - df["score"].min()) / (df["score"].max() - df["score"].min())

# Handling missing values
df["phone"] = None
print(df.isnull().sum())                    # Count nulls per column
df["phone"].fillna("N/A", inplace=True)
df.dropna(inplace=True)

# Reading and writing files
# df.to_csv("output.csv", index=False, encoding="utf-8")
# df = pd.read_csv("data.csv", encoding="utf-8")
# df.to_excel("output.xlsx", index=False)
# df = pd.read_excel("data.xlsx")

Requests: Gọi HTTP API

Requests là thư viện HTTP phổ biến nhất trong Python, được thiết kế để làm cho việc gọi API trở nên đơn giản và tự nhiên nhất có thể. Từ REST API, web scraping cho đến tải file từ internet, Requests xử lý tất cả. Luôn xử lý lỗi khi làm việc với network vì kết nối mạng có thể fail vì nhiều lý do khác nhau.

import requests

# Simple GET request
response = requests.get("https://api.github.com/users/python")
print(response.status_code)     # 200
print(response.headers["Content-Type"])
data = response.json()
print(data["name"])

# GET with parameters
params = {"q": "python", "per_page": 5}
response = requests.get(
    "https://api.github.com/search/repositories",
    params=params
)
results = response.json()
print(f"Found: {results['total_count']} repositories")

# POST request
payload = {"title": "Test Post", "body": "Hello World", "userId": 1}
response = requests.post(
    "https://jsonplaceholder.typicode.com/posts",
    json=payload,
    headers={"Content-Type": "application/json"}
)
print(response.status_code)    # 201
print(response.json())

# PUT and DELETE
requests.put("https://api.example.com/items/1", json={"name": "Updated"})
requests.delete("https://api.example.com/items/1")

# Error handling (always do this in production)
try:
    response = requests.get(
        "https://api.example.com/data",
        timeout=10,
        headers={"Authorization": "Bearer your_token_here"}
    )
    response.raise_for_status()     # Raises HTTPError for 4xx/5xx
    data = response.json()
except requests.exceptions.Timeout:
    print("Request timed out")
except requests.exceptions.HTTPError as e:
    print(f"HTTP error {e.response.status_code}: {e}")
except requests.exceptions.ConnectionError:
    print("Network connection failed")
except requests.exceptions.RequestException as e:
    print(f"Request failed: {e}")

# Session for multiple requests to same host
with requests.Session() as session:
    session.headers.update({"Authorization": "Bearer token123"})
    r1 = session.get("https://api.example.com/profile")
    r2 = session.get("https://api.example.com/orders")

Bảng tổng hợp nhanh toàn bộ cheat sheet

Dưới đây là bảng rút gọn toàn bộ cú pháp quan trọng đã đề cập trong bài, dùng để nhìn lướt và tra cứu nhanh mà không cần đọc lại toàn bộ nội dung phía trên.

Chủ đề

Cú pháp mẫu

In ra màn hình

print("text", sep="-", end=" ")

Nhận input

val = input("Nhập: ")

Comment

# dòng đơn, """ nhiều dòng """

Khai báo biến

x = 5, a, b = 1, 2

Kiểm tra kiểu

type(x)

Ép kiểu

int(), float(), str(), bool()

Toán tử số học

+ - * / % ** //

Toán tử so sánh

== != > < >= <=

Toán tử logic

and or not

Toán tử gán

= += -= *= /=

Điều kiện

if / elif / else

Vòng lặp for

for i in range(n):

Vòng lặp while

while condition:

Ngắt/bỏ qua lặp

break, continue

Lấy index và value

enumerate(list)

Định nghĩa hàm

def func(a, b): return a + b

Tham số linh hoạt

*args, **kwargs

String slicing

text[0:5], text[-1]

List

my_list = [1, 2, 3]

Tuple

my_tuple = (1, 2, 3)

Dictionary

my_dict = {"key": "value"}

Set

my_set = {1, 2, 3}

Học Python đúng cách: Từ cheat sheet đến dự án thực tế

Cheat sheet là công cụ hỗ trợ trí nhớ rất hiệu quả trong giai đoạn đầu học Python, nhưng bản thân nó không tạo ra năng lực lập trình thực sự. Sự khác biệt giữa người chỉ biết tra cứu cú pháp và người thực sự thành thạo Python nằm ở số lượng bài toán thực tế đã từng giải quyết, số lỗi đã từng tự debug và số lần phải tự suy nghĩ cách áp dụng một cú pháp vào một tình huống cụ thể.

Tại Onschool Bootcamp toàn bộ kiến thức nền tảng như biến, kiểu dữ liệu, vòng lặp và hàm được đưa ngay vào thực hành qua các bài toán nhỏ trước khi mở rộng dần thành các dự án thực tế có độ phức tạp tăng lên theo thời gian theo phương pháp Learning by Doing trong 120 ngày. Việc có mentor đồng hành và review code trực tiếp giúp học viên không chỉ biết cú pháp đúng mà còn hiểu vì sao một cách viết lại tốt hơn cách khác trong một tình huống cụ thể, điều mà việc đọc cheat sheet một mình khó có thể mang lại.

Kết luận

Cheat sheet này tổng hợp những phần cú pháp và nền tảng cơ bản nhất của Python, từ biến, kiểu dữ liệu, toán tử cho đến các cấu trúc dữ liệu phổ biến. Đây là tài liệu nên được lưu lại để tra cứu trong suốt giai đoạn đầu học tập, nhưng năng lực thực sự với Python chỉ hình thành khi những cú pháp này được áp dụng lặp đi lặp lại vào các bài toán cụ thể. Khi cảm thấy đã quen với phần nền tảng này, bước tiếp theo hợp lý là tìm hiểu sâu hơn về lập trình hướng đối tượng, xử lý lỗi và làm việc với file, những chủ đề sẽ mở rộng đáng kể khả năng giải quyết vấn đề bằng Python.

Bạn đã sẵn sàng đổi thay sự nghiệp chưa?

Onschool Bootcamp tự hào chỉ trong 120 ngày, đào tạo thế hệ lập trình viên kiến tạo thế giới số - bắt đầu từ con số 0

Đừng quên chia sẻ bài viết này!

Sao chép link

Cùng Onschool Bootcamp chinh phục lộ trình 120 ngày đổi thay sự nghiệp

Fullstack java web developer
Fullstack javascript (Nodejs & reactjs web developer
Fullstack Python web developer
Fullstack PHP web developer
Cross-Platform Mobile App Development

Khóa học dành cho người từ 18 tuổi trở lên

zalomessenger