Bỏ qua đến nội dung chính
Mục lục

Phạm vi biến trong Python (scope): cục bộ, toàn cục, global

AIDev Team · duyệt: Nguyễn Việt Chung

Bài 10/17 · Chương 8

Hàm

  • 8 phút
  • Cơ bản
  • Python 3.14
  • Cập nhật

Phạm vi biến trong Python (scope) cho biết một cái tên dùng được ở đâu. Biến tạo trong hàm là biến cục bộ, chỉ sống trong lần gọi hàm đó, còn biến tạo ngoài các hàm là biến toàn cục mà cả chương trình đọc được. Bạn cần nắm phạm vi khi một hàm phải đọc hay sửa số dư, doanh thu nằm ngoài nó.

Cần biết trước: biến, toán tử gán và lệnh return.

Biến tạo trong hàm là biến cục bộ

Hàm tính giá khuyến mãi dưới đây cần một biến phụ để giữ số tiền được giảm. Biến đó được tạo bên trong thân hàm:

python
def gia_khuyen_mai(gia):
    tien_giam = gia * 10 // 100
    return gia - tien_giam

print(gia_khuyen_mai(35000))
print(gia_khuyen_mai(45000))

KẾT QUẢ

31500
40500

tien_giam là biến cục bộ (local variable): nó được tạo khi hàm chạy tới dòng gán, và mất đi khi hàm trả về. Lời gọi thứ hai có một tien_giam mới, không dính gì tới lần gọi trước. Tham số gia cũng là biến cục bộ, mang giá trị của đối số trong lần gọi đó. Mỗi lần gọi hàm giống một tờ nháp mới: tính xong thì chỉ giữ lại kết quả trả về, tờ nháp bị bỏ.

Hàm đọc được biến toàn cục

Biến gán ở cấp ngoài cùng của file, không nằm trong hàm nào, là biến toàn cục. Hàm đọc nó được mà không cần làm gì thêm:

python
PHI_GIAO = 30000

def thanh_toan(tong_don):
    if tong_don >= 300000:
        return tong_don
    return tong_don + PHI_GIAO

print(thanh_toan(250000), thanh_toan(320000))

KẾT QUẢ

280000 320000

Khi gặp một cái tên, Python tìm trong phạm vi cục bộ của hàm trước. Không thấy thì tìm sang phạm vi toàn cục của file, rồi tới các tên dựng sẵn như print, len. PHI_GIAO không được gán trong hàm nên Python tìm thấy nó ở phạm vi toàn cục. Biến toàn cục mà chỉ để đọc, như một mức phí cố định, thường viết chữ hoa để người đọc biết không ai đổi nó lúc chạy.

Gán trong hàm tạo ra biến cục bộ mới

Đọc thì được, nhưng gán là chuyện khác. Dòng gán nào trong thân hàm cũng tạo biến cục bộ, kể cả khi bên ngoài đã có biến toàn cục cùng tên:

python
so_ly = 0

def dat_mon():
    so_ly = 3
    print("Trong hàm:", so_ly)

dat_mon()
print("Ngoài hàm:", so_ly)

KẾT QUẢ

Trong hàm: 3
Ngoài hàm: 0

Hai biến so_ly là hai biến khác nhau ở hai phạm vi. Biến trong hàm che biến ngoài hàm trong lúc hàm chạy, rồi mất đi, và biến toàn cục vẫn là 0. Đổi so_ly = 0 thành so_ly = 7 rồi chạy lại: dòng cuối in Ngoài hàm: 7, vì hàm không hề đụng tới biến toàn cục.

Quy tắc này áp cho cả thân hàm: Python đọc hết thân hàm trước khi chạy, thấy tên nào bị gán ở bất kỳ dòng nào thì coi tên đó là cục bộ từ dòng đầu tiên. Đó là nguồn gốc của lỗi dưới đây.

Từ khóa global

Dòng global ten_bien ở đầu thân hàm nói với Python: tên này trong hàm là biến toàn cục, gán vào nó là gán vào biến bên ngoài:

python
so_luot_mua = 0

def ghi_luot_mua():
    global so_luot_mua
    so_luot_mua += 1

ghi_luot_mua()
ghi_luot_mua()
ghi_luot_mua()
print(so_luot_mua)

KẾT QUẢ

3

Không có dòng global, ba lời gọi trên báo UnboundLocalError như khung bẫy ở trên. Dòng global phải đứng trước các chỗ dùng tên đó trong thân hàm; đặt nó sau một dòng gán là lỗi cú pháp.

Hàm lồng trong một hàm khác có thêm một tầng phạm vi nữa. Từ khóa nonlocal làm với tầng đó điều global làm với phạm vi toàn cục: cho phép gán vào tên ở đó. Bài closure và nonlocal dạy cách dùng nó.

Vì sao nên hạn chế global

Hàm dùng global cho kết quả phụ thuộc vào những gì đã chạy trước nó: gọi ghi_luot_mua() ba lần hay năm lần cho ra số khác nhau, và muốn thử hàm thì phải đặt lại biến toàn cục trước. Chương trình càng dài, càng khó biết ai đã đổi biến đó. Cách thay thế là truyền giá trị vào bằng tham số và lấy giá trị mới ra bằng return:

python
def rut_tien(so_du, so_tien):
    return so_du - so_tien

so_du = 500000
so_du = rut_tien(so_du, 200000)
so_du = rut_tien(so_du, 50000)
print(f"Còn lại: {so_du:,} đ")

KẾT QUẢ

Còn lại: 250,000 đ

Hàm này chỉ phụ thuộc vào hai tham số: cùng đối số thì cùng kết quả, đọc được mà không cần biết phần còn lại của chương trình. Việc đổi số dư nằm ngay ở nơi gọi, nhìn là thấy. global hợp với vài việc nhỏ như đếm lượt trong một chương trình ngắn, còn tiền, điểm hay trạng thái quan trọng thì nên truyền vào, trả ra.

Kiểm tra nhanh

  1. Trong ví dụ hàm dat_mon, gọi thêm dat_mon() hai lần nữa trước dòng in cuối. Dòng cuối in gì?

    • Ngoài hàm: 9
    • Ngoài hàm: 0
    • Ngoài hàm: 3
  2. Trong ví dụ hàm ghi_luot_mua, nếu xóa dòng global so_luot_mua thì lời gọi đầu tiên làm gì?

    • Báo lỗi UnboundLocalError
    • Báo lỗi NameError
    • Chạy bình thường, dòng cuối vẫn in 3
  3. Những cách nào cho hàm rut_tien đổi được số dư mà chương trình đang giữ trong biến toàn cục so_du?

    • Viết global so_du ở dòng đầu thân hàm, trước phép trừ
    • Viết so_du = so_du - so_tien trong thân hàm, không khai báo gì
    • Nhận so_du làm tham số, trả về số dư mới, và nơi gọi gán lại so_du
    • Viết global so_du ở dòng cuối thân hàm, sau phép trừ
  4. Biến tien_giam được tạo trong thân hàm gia_khuyen_mai. Sau khi hàm chạy xong, dòng print(tien_giam) ở ngoài hàm làm gì?

    • In số tiền giảm của lần gọi cuối
    • In 0, giá trị ban đầu của mọi biến
    • Báo lỗi NameError, vì biến cục bộ đã mất khi hàm trả về
Đúng hết lần đầu +15 XP

Bài tập

Viết hàm cộng doanh thu bằng global

Quán ghi doanh thu cả ngày vào biến toàn cục doanh_thu. Viết thân hàm ban_ly(gia, so_ly): tính tiền của lượt bán bằng giá nhân số ly, cộng tiền đó vào doanh_thu, rồi trả về tiền của lượt bán. Dùng từ khóa global để hàm gán được vào doanh_thu.

Ví dụ: khi doanh_thu là 0, ban_ly(29000, 2) trả về 58000 và doanh_thu thành 58000.

Trả về: tiền của lượt bán, một int.

python
doanh_thu = 0

def ban_ly(gia, so_ly):
    pass  # Viết thân hàm thay cho dòng này

Tóm tắt

  • Biến tạo trong hàm, kể cả tham số, là biến cục bộ; nó mất đi khi hàm trả về.

  • Biến gán ở cấp ngoài cùng của file là biến toàn cục; hàm đọc nó được mà không cần khai báo.

  • Một phép gán ở bất kỳ dòng nào trong thân hàm làm tên đó thành cục bộ cho cả hàm.

  • so_du -= tien trong hàm, không khai báo global, gây UnboundLocalError.

  • global ten ở đầu thân hàm cho phép gán vào biến toàn cục; tiền và trạng thái quan trọng thì nên truyền vào, trả ra.

Câu hỏi thường gặp

Biến toàn cục trong Python có nên dùng nhiều không?

Không nên. Đọc một hằng số toàn cục như PHI_GIAO thì không sao. Gán vào biến toàn cục từ nhiều hàm thì kết quả của mỗi hàm phụ thuộc vào thứ tự gọi, và khi số sai bạn phải dò từng hàm có global. Truyền giá trị vào bằng tham số, trả kết quả ra bằng return giữ mỗi hàm đọc được riêng.

Biến cục bộ (local variable) trong Python sống tới khi nào?

Biến cục bộ được tạo khi hàm chạy tới dòng gán nó, và mất đi khi hàm trả về hoặc chạy hết thân. Lần gọi sau bắt đầu với một bộ biến cục bộ mới. Muốn giữ một giá trị qua các lần gọi thì trả nó về cho nơi gọi cất giữ, hoặc dùng biến toàn cục với global.

Thân if và for có tạo phạm vi (scope) riêng trong Python không?

Không. Gọi một hàm thì có phạm vi mới, còn thân if hay thân vòng lặp for thì không. Biến gán trong thân for vẫn dùng được sau vòng lặp, kể cả biến lặp: sau for gia in [29000, 35000]:, gia còn giữ 35000.

Vì sao có code dùng global mà vẫn chạy đúng?

Vì global không sai, chỉ khó kiểm soát khi chương trình lớn lên. Một script ngắn đếm số lượt hay bật tắt một chế độ dùng global vẫn rõ ràng. Khi thấy một hàm cần global cho nhiều biến, đó là dấu hiệu nên tách lại chương trình thành hàm nhận tham số và trả về kết quả.

Chủ đề

global python

Bài này có hữu ích?

Hỏi đáp

Đang tải câu hỏi…

Tham vấn chuyên môn

Nguyễn Việt Chung

Nhà sáng lập AIDev và VietPlatform · Thạc sĩ AI MSE

  • Tốt nghiệp thủ khoa xuất sắc Thạc sĩ AI MSE.
  • Đồng sáng lập, CTO E-University, SVOnline: số hóa 10+ đại học, 40.000+ sinh viên.
  • Xây hệ thống AI cho doanh nghiệp tại VietPlatform.
Biên soạn: AIDev Team · Rà soát · Quy trình biên tập