Đã đăng vào Chủ Nhật, 9:34 SA 7 phút đọc

Python từ Cơ bản đến Nâng cao: Tổng hợp kiến thức cần biết

Bài viết tổng hợp lại toàn bộ kiến thức Python theo lộ trình từ những khái niệm cơ bản nhất cho đến các chủ đề nâng cao, phù hợp cho người mới bắt đầu lẫn người muốn hệ thống hóa lại kiến thức.

Mục lục

Giới thiệu chung về Python
Cú pháp cơ bản
Kiểu dữ liệu
Cấu trúc điều khiển
Hàm (Functions)
Cấu trúc dữ liệu nâng cao
Lập trình hướng đối tượng (OOP)
Xử lý ngoại lệ (Exception Handling)
Module và Package
Làm việc với File
Comprehension và biểu thức Lambda
Iterator và Generator
Decorator
Context Manager
Lập trình bất đồng bộ (Async/Await)
Đa luồng và đa tiến trình
Type Hinting
Testing trong Python
Quản lý môi trường và package
Design Pattern phổ biến trong Python
Tối ưu hiệu năng
Best Practice và phong cách viết code
Tài liệu tham khảo

1. Giới thiệu chung về Python

Python là ngôn ngữ lập trình bậc cao, thông dịch (interpreted), đa mục đích, được Guido van Rossum tạo ra và phát hành lần đầu năm 1991. Python nổi bật với:

Cú pháp rõ ràng, dễ đọc: gần với ngôn ngữ tự nhiên, sử dụng thụt lề (indentation) để phân định khối lệnh thay vì dấu ngoặc nhọn.
Đa hình (multi-paradigm): hỗ trợ lập trình hướng đối tượng, lập trình hàm, lập trình thủ tục.
Hệ sinh thái thư viện khổng lồ: từ xử lý dữ liệu (pandas, numpy), machine learning (scikit-learn, TensorFlow, PyTorch), web (Django, Flask, FastAPI) đến tự động hóa (Selenium, requests).
Interpreted & Dynamically typed: không cần biên dịch trước khi chạy, kiểu dữ liệu được xác định lúc runtime.

Các bản phân phối phổ biến hiện nay là CPython (mặc định), PyPy (tối ưu tốc độ), Jython (chạy trên JVM).

2. Cú pháp cơ bản

Biến và gán giá trị

name = "Nguyen Van A"
age = 22
is_student = True

Python không yêu cầu khai báo kiểu dữ liệu tường minh, kiểu dữ liệu được suy luận tự động.

Thụt lề (Indentation)

Python dùng thụt lề để xác định khối lệnh (thường 4 khoảng trắng), thay vì {} như C/Java/JS:

if age >= 18:
    print("Đã trưởng thành")
else:
    print("Chưa trưởng thành")

Comment

# Đây là comment một dòng

"""
Đây là comment/nhiều dòng,
thường dùng làm docstring
"""

Quy ước đặt tên (PEP 8)

Biến, hàm: snake_case
Class: PascalCase
Hằng số: UPPER_CASE

3. Kiểu dữ liệu

Kiểu dữ liệu cơ bản

Kiểu	Ví dụ	Mô tả
`int`	`10`	Số nguyên
`float`	`3.14`	Số thực
`bool`	`True/False`	Boolean
`str`	`"hello"`	Chuỗi ký tự
`NoneType`	`None`	Giá trị rỗng

Ép kiểu (Type casting)

x = int("10")     # 10
y = str(10)        # "10"
z = float("3.14")  # 3.14

Chuỗi (String)

s = "Xin chào, Việt Nam"
print(s.upper())        # XIN CHÀO, VIỆT NAM
print(s.split(","))     # ['Xin chào', ' Việt Nam']
print(f"Tên: {name}")   # f-string, cách format hiện đại và hiệu quả nhất

4. Cấu trúc điều khiển

if / elif / else

score = 8
if score >= 8:
    print("Giỏi")
elif score >= 6.5:
    print("Khá")
else:
    print("Cần cố gắng thêm")

Vòng lặp for / while

for i in range(5):
    print(i)

n = 0
while n < 5:
    n += 1

match-case (Python 3.10+)

def check_status(code):
    match code:
        case 200:
            return "OK"
        case 404:
            return "Not Found"
        case _:
            return "Unknown"

5. Hàm (Functions)

def tinh_tong(a, b=0):
    """Tính tổng hai số, b mặc định = 0"""
    return a + b

# Tham số biến đổi
def tong_nhieu_so(*args, **kwargs):
    print(args)    # tuple
    print(kwargs)  # dict

Hàm lồng nhau và closure

def outer(x):
    def inner(y):
        return x + y
    return inner

add_5 = outer(5)
print(add_5(3))  # 8

6. Cấu trúc dữ liệu nâng cao

Cấu trúc	Đặc điểm	Ví dụ
`list`	Có thứ tự, thay đổi được (mutable)	`[1, 2, 3]`
`tuple`	Có thứ tự, không thay đổi được (immutable)	`(1, 2, 3)`
`set`	Không thứ tự, không trùng lặp	`{1, 2, 3}`
`dict`	Cặp key-value	`{"a": 1, "b": 2}`

Các thao tác thường dùng

lst = [3, 1, 2]
lst.sort()                  # sắp xếp tại chỗ
sorted_lst = sorted(lst)    # trả về list mới

d = {"a": 1, "b": 2}
for key, value in d.items():
    print(key, value)

`collections` module

from collections import Counter, defaultdict, namedtuple, deque

c = Counter("mississippi")          # đếm tần suất
dd = defaultdict(list)              # dict với giá trị mặc định
Point = namedtuple("Point", "x y")  # tuple có tên trường
q = deque([1, 2, 3])                 # hàng đợi 2 đầu hiệu năng cao

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

Class và Object

class SinhVien:
    truong = "Đại học Đà Nẵng"  # thuộc tính lớp (class attribute)

    def __init__(self, ten, mssv):
        self.ten = ten      # thuộc tính instance
        self.mssv = mssv

    def gioi_thieu(self):
        return f"Tôi tên {self.ten}, MSSV {self.mssv}"

sv = SinhVien("An", "SV001")
print(sv.gioi_thieu())

Tứ trụ OOP

Đóng gói (Encapsulation): dùng _bien (protected, quy ước) hoặc __bien (private, name mangling).
Kế thừa (Inheritance):

class SinhVienNangKhieu(SinhVien):
    def __init__(self, ten, mssv, nang_khieu):
        super().__init__(ten, mssv)
        self.nang_khieu = nang_khieu

Đa hình (Polymorphism): các lớp con override phương thức của lớp cha.
Trừu tượng (Abstraction): dùng abc.ABC để định nghĩa lớp trừu tượng.

from abc import ABC, abstractmethod

class HinhHoc(ABC):
    @abstractmethod
    def dien_tich(self):
        pass

class HinhTron(HinhHoc):
    def __init__(self, r):
        self.r = r

    def dien_tich(self):
        return 3.14 * self.r ** 2

Magic methods (Dunder methods)

class Vector:
    def __init__(self, x, y):
        self.x, self.y = x, y

    def __add__(self, other):
        return Vector(self.x + other.x, self.y + other.y)

    def __repr__(self):
        return f"Vector({self.x}, {self.y})"

`@property`, `@staticmethod`, `@classmethod`

class NhietDo:
    def __init__(self, celsius):
        self._celsius = celsius

    @property
    def fahrenheit(self):
        return self._celsius * 9/5 + 32

    @staticmethod
    def la_am(nhiet_do):
        return nhiet_do < 0

    @classmethod
    def tu_fahrenheit(cls, f):
        return cls((f - 32) * 5/9)

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

try:
    ket_qua = 10 / 0
except ZeroDivisionError as e:
    print(f"Lỗi chia cho 0: {e}")
except Exception as e:
    print(f"Lỗi khác: {e}")
else:
    print("Không có lỗi xảy ra")
finally:
    print("Luôn thực thi dù có lỗi hay không")

Custom Exception

class SoDuKhongDuException(Exception):
    def __init__(self, message="Số dư không đủ để thực hiện giao dịch"):
        self.message = message
        super().__init__(self.message)

9. Module và Package

# file: toan_hoc.py
def cong(a, b):
    return a + b

# file: main.py
import toan_hoc
from toan_hoc import cong

Một package là thư mục chứa file __init__.py (từ Python 3.3+ không bắt buộc nhưng vẫn nên có để tường minh).

my_package/
├── __init__.py
├── module_a.py
└── module_b.py

10. Làm việc với File

# Đọc file
with open("data.txt", "r", encoding="utf-8") as f:
    content = f.read()

# Ghi file
with open("output.txt", "w", encoding="utf-8") as f:
    f.write("Xin chào")

# Làm việc với JSON
import json
with open("data.json", "r") as f:
    data = json.load(f)

Nên luôn dùng with để đảm bảo file được đóng tự động, ngay cả khi có lỗi xảy ra.

11. Comprehension và biểu thức Lambda

# List comprehension
squares = [x**2 for x in range(10) if x % 2 == 0]

# Dict comprehension
square_dict = {x: x**2 for x in range(5)}

# Set comprehension
unique_lengths = {len(word) for word in ["a", "ab", "abc"]}

# Lambda
binh_phuong = lambda x: x ** 2
sorted_list = sorted([(1, 'b'), (2, 'a')], key=lambda item: item[1])

12. Iterator và Generator

Iterator Protocol

class DemSo:
    def __init__(self, gioi_han):
        self.gioi_han = gioi_han
        self.hien_tai = 0

    def __iter__(self):
        return self

    def __next__(self):
        if self.hien_tai >= self.gioi_han:
            raise StopIteration
        self.hien_tai += 1
        return self.hien_tai

Generator (dùng `yield`)

def dem_so(gioi_han):
    n = 0
    while n < gioi_han:
        yield n
        n += 1

# Generator expression - tiết kiệm bộ nhớ hơn list comprehension
gen = (x**2 for x in range(1000000))

Generator chỉ tính toán giá trị khi cần (lazy evaluation), rất hữu ích khi xử lý dữ liệu lớn.

13. Decorator

import functools
import time

def do_thoi_gian(func):
    @functools.wraps(func)
    def wrapper(*args, **kwargs):
        start = time.time()
        result = func(*args, **kwargs)
        print(f"{func.__name__} chạy trong {time.time() - start:.4f}s")
        return result
    return wrapper

@do_thoi_gian
def xu_ly_du_lieu():
    time.sleep(1)

xu_ly_du_lieu()

Decorator có tham số

def repeat(so_lan):
    def decorator(func):
        @functools.wraps(func)
        def wrapper(*args, **kwargs):
            for _ in range(so_lan):
                func(*args, **kwargs)
        return wrapper
    return decorator

@repeat(3)
def xin_chao():
    print("Xin chào!")

14. Context Manager

class KetNoiDB:
    def __enter__(self):
        print("Mở kết nối")
        return self

    def __exit__(self, exc_type, exc_value, traceback):
        print("Đóng kết nối")

with KetNoiDB() as db:
    print("Đang thao tác với database")

Hoặc dùng contextlib:

from contextlib import contextmanager

@contextmanager
def ket_noi_db():
    print("Mở kết nối")
    try:
        yield "connection_object"
    finally:
        print("Đóng kết nối")

15. Lập trình bất đồng bộ (Async/Await)

import asyncio

async def goi_api(ten):
    print(f"Bắt đầu gọi {ten}")
    await asyncio.sleep(2)
    print(f"Hoàn thành {ten}")
    return f"Kết quả từ {ten}"

async def main():
    ket_qua = await asyncio.gather(
        goi_api("API 1"),
        goi_api("API 2"),
        goi_api("API 3"),
    )
    print(ket_qua)

asyncio.run(main())

asyncio phù hợp cho các tác vụ I/O-bound (gọi API, đọc/ghi file, truy vấn DB) chạy đồng thời mà không cần nhiều luồng thật.

16. Đa luồng và đa tiến trình

Kỹ thuật	Phù hợp cho	Module
Threading	I/O-bound (bị giới hạn bởi GIL với CPU-bound)	`threading`
Multiprocessing	CPU-bound (tính toán nặng)	`multiprocessing`
Asyncio	I/O-bound, quy mô lớn, single-thread	`asyncio`

from concurrent.futures import ThreadPoolExecutor, ProcessPoolExecutor

with ThreadPoolExecutor(max_workers=4) as executor:
    results = executor.map(tai_du_lieu, danh_sach_url)

with ProcessPoolExecutor(max_workers=4) as executor:
    results = executor.map(tinh_toan_nang, danh_sach_so)

GIL (Global Interpreter Lock): CPython chỉ cho phép một luồng thực thi bytecode Python tại một thời điểm, vì vậy threading không tăng tốc các tác vụ CPU-bound thuần túy — cần dùng multiprocessing cho trường hợp này.

17. Type Hinting

from typing import List, Dict, Optional, Union, Callable

def tinh_trung_binh(diem: List[float]) -> float:
    return sum(diem) / len(diem)

def tim_sinh_vien(mssv: str) -> Optional[Dict[str, str]]:
    ...

BienDoi = Callable[[int], int]

# Python 3.10+ có thể dùng cú pháp union mới
def xu_ly(gia_tri: int | str) -> None:
    ...

Type hint không được kiểm tra lúc chạy mặc định, nhưng có thể dùng công cụ như mypy để kiểm tra tĩnh, giúp phát hiện lỗi sớm và code dễ bảo trì hơn.

18. Testing trong Python

import unittest

class TestToanHoc(unittest.TestCase):
    def test_cong(self):
        self.assertEqual(cong(2, 3), 5)

    def test_chia_cho_khong(self):
        with self.assertRaises(ZeroDivisionError):
            10 / 0

if __name__ == "__main__":
    unittest.main()

Hoặc dùng pytest (phổ biến hơn trong thực tế nhờ cú pháp gọn và hệ sinh thái plugin phong phú):

def test_cong():
    assert cong(2, 3) == 5

def test_chia_cho_khong():
    import pytest
    with pytest.raises(ZeroDivisionError):
        10 / 0

19. Quản lý môi trường và package

# Tạo môi trường ảo
python -m venv venv
source venv/bin/activate      # Linux/Mac
venv\Scripts\activate         # Windows

# Cài đặt package
pip install requests pandas

# Lưu danh sách package
pip freeze > requirements.txt
pip install -r requirements.txt

Các công cụ hiện đại hơn: poetry, pipenv, uv giúp quản lý dependency và môi trường ảo tốt hơn pip + venv truyền thống.

20. Design Pattern phổ biến trong Python

Singleton: đảm bảo một class chỉ có duy nhất một instance.
Factory: tạo object thông qua một interface chung thay vì gọi constructor trực tiếp.
Observer: một đối tượng thông báo thay đổi trạng thái cho nhiều đối tượng khác theo dõi.
Decorator pattern: mở rộng hành vi của object mà không sửa class gốc (khác với decorator function ở mục 13, nhưng cùng ý tưởng).

class Singleton:
    _instance = None

    def __new__(cls, *args, **kwargs):
        if cls._instance is None:
            cls._instance = super().__new__(cls)
        return cls._instance

21. Tối ưu hiệu năng

Dùng generator thay vì list khi không cần lưu toàn bộ dữ liệu trong bộ nhớ.
Dùng list comprehension thay vì vòng lặp for truyền thống khi có thể (nhanh hơn do tối ưu ở tầng C).
Dùng __slots__ trong class để giảm bộ nhớ khi có nhiều instance.
Profile code bằng cProfile, timeit trước khi tối ưu để xác định đúng điểm nghẽn (bottleneck).
Cân nhắc dùng NumPy cho các phép tính số học trên mảng lớn thay vì list thuần Python.

import timeit
print(timeit.timeit("[x**2 for x in range(1000)]", number=1000))

22. Best Practice và phong cách viết code

Tuân thủ PEP 8 — chuẩn phong cách code chính thức của Python.
Viết docstring rõ ràng cho module, class, function.
Dùng type hint để tăng khả năng đọc hiểu và bảo trì.
Áp dụng nguyên tắc DRY (Don't Repeat Yourself) và SOLID khi thiết kế class.
Sử dụng công cụ linter/formatter: black, flake8, pylint, ruff.
Viết unit test song song với việc phát triển tính năng, không để dồn về cuối dự án.
Quản lý logging thay vì dùng print() cho ứng dụng thực tế:

import logging

logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)
logger.info("Ứng dụng đã khởi động")

23. Tài liệu tham khảo

Bài viết được tổng hợp nhằm mục đích chia sẻ kiến thức, phù hợp làm tài liệu ôn tập hoặc tra cứu nhanh khi làm việc với Python.

Python từ Cơ bản đến Nâng cao: Tổng hợp kiến thức cần biết

Mục lục

1. Giới thiệu chung về Python

2. Cú pháp cơ bản

Biến và gán giá trị

Thụt lề (Indentation)

Comment

Quy ước đặt tên (PEP 8)

3. Kiểu dữ liệu

Kiểu dữ liệu cơ bản

Ép kiểu (Type casting)

Chuỗi (String)

4. Cấu trúc điều khiển

if / elif / else

Vòng lặp for / while

match-case (Python 3.10+)

5. Hàm (Functions)

Hàm lồng nhau và closure

6. Cấu trúc dữ liệu nâng cao

Các thao tác thường dùng

collections module

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

Class và Object

Tứ trụ OOP

Magic methods (Dunder methods)

@property, @staticmethod, @classmethod

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

Custom Exception

9. Module và Package

10. Làm việc với File

11. Comprehension và biểu thức Lambda

12. Iterator và Generator

Iterator Protocol

Generator (dùng yield)

13. Decorator

Decorator có tham số

14. Context Manager

15. Lập trình bất đồng bộ (Async/Await)

16. Đa luồng và đa tiến trình

17. Type Hinting

18. Testing trong Python

19. Quản lý môi trường và package

20. Design Pattern phổ biến trong Python

21. Tối ưu hiệu năng

22. Best Practice và phong cách viết code

23. Tài liệu tham khảo

Mục lục

`collections` module

`@property`, `@staticmethod`, `@classmethod`

Generator (dùng `yield`)