Hướng dẫn biến toàn cục python

Trong bài này chúng ta sẽ tìm hiểu về biến cục bộ và biến toàn cục trong Python. Đây là hai phạm vi hoạt động chủ yếu của một biến trong Python, vì vậy bạn phải hiểu để sủ dụng cho đúng.

Bài viết này được đăng tại freetuts.net, không được copy dưới mọi hình thức.

Đọc đến bài này thì chắc chắn bạn đã hiểu cách tạo hàm trong Python rồi nhỉ? Bạn cũng biết việc sử dụng biến trong một hàm là quá bình thường. Nhưng chuyện gì xảy ra nếu bạn khai báo tên biến trong hàm trùng với tên của một biến nằm bên ngoài hàm?

Rất đơn giản, chỉ cần biết phạm vi hoạt động của biến là bạn sẽ hiểu được cách hoạt động của Python.

1. Biến toàn cục trong Python là gì?

Trong Python, một biến được khai báo bên ngoài hàm hoặc trong phạm vi toàn cục được gọi là biến toàn cục. Điều này có nghĩa, biến toàn cục có thể được truy cập bên trong hoặc bên ngoài hàm.

Bài viết này được đăng tại [free tuts .net]

Biến toàn cục có tên gọi là Global Variable.

Hãy xem một ví dụ về cách tạo một biến toàn cục trong Python.

Global Variable

x = "Học Python tại Freetuts.net"

def foo[]:
    print["Trong hàm:", x]
foo[]
print["Ngoài hàm:", x]

Khi chạy chương trình này thì kết quả sẽ như sau:

Trong hàm : Học Python tại Freetuts.net
Ngoài hàm: Học Python tại Freetuts.net

Trong đoạn code trên thì biến x là biến toàn cục bởi nó được khai báo bên ngoài hàm, nằm tại vị trí cấp cao nhất của ứng dụng. Giống như Javascript, trong hàm có thể sử dụng biến cục bộ mà không cần phải thông qua việc truyền tham số.

Khi sử dụng biến toàn cục bên trong một hàm thì bạn không được thay đổi giá trị cho biến. Như ví dụ dưới đây là sai, bởi vì mình đã thay đổi giá trị cho biến x.

x = 10

def foo[]:
    x = x * 2
    print[x]
foo[]

Khi chạy chương trình thì sẽ bị lỗi như sau:

UnboundLocalError: local variable 'x' referenced before assignment

Lý do là đây: Vì bên trong hàm foo[] bạn đã thay đổi giá trị cho biến x nên mặc nhiên nó sẽ hiểu biến x là biệc cục bộ, mà biến cục bộ thì đoạn code x = x * 2 sẽ sai vì biến x chưa được khai báo.

Để giải quyết vấn đề này thì bạn sử dụng từ khóa global nhé.

x = 10

def foo[]:
    global x
    x = x * 2
    print[x]

# In giá trị 20
foo[]

# In giá trị 20 vì x = 20
print[x]

Như bạn thấy, biến cục bộ x đã bị thay đổi bên trong hàm foo.

2. Biến cục bộ trong Python là gì?

Trong Python, biến cục bộ được hiểu là biến được khai báo bên trong hàm hoặc phạm vi cục bộ, những biến này gọi là biến cục bộ.

Biến cục bộ có tên gọi là Local Variable.

Hãy xem ví dụ dưới đây:

def foo[]:
    y = "local"

foo[]

# Lệnh này sai vì biến y không tồn tại
print[y]

Do biến y là biến cục bộ nằm bên trong hàm foo[] nên đoạn code print[y] là sai, bạn không thể sử dụng biến cục bộ ở bên ngoài hàm được.

Chạy lên kết quả sẽ như sau:

NameError: name 'y' is not defined

3. Từ khóa global trong Python

Mình đã lấy một ví dụ về từ khóa Global ở phần 1 rồi, tuy nhiên mình sẽ giải thích nó kỹ hơn một chút qua phần này nhé.

Để tường minh trong việc sử dụng biến cục bộ trong hàm thì Python cung cấp từ khóa global, khi khai báo từ khóa này cho một biến bất kì thì trình biên dịch sẽ tự hiểu biến đó sẽ trỏ tới một biến cục bộ nằm bên ngoài hàm.

Ví dụ: Sử dụng từ khóa global

x = "global"

def foo[]:
    global x
    y = "local"
    x = x * 2
    print[x]
    print[y]
    
foo[]

Chạy lên kết quả sẽ như sau:

Khi chúng ta thay đổi giá trị cho biến được khai báo global nằm ở trong hàm thì giá trị của biến đó sẽ thay đổi theo. Xem ví dụ dưới đây để hiểu hơn.

x = 5

def plusNum[]:
    global x
    x = x * 2

plusNum[]
print[x] # kết quả là 10

plusNum[]
print[x] # kết quả là 20

plusNum[]
print[x] # kết quả là 40

Xem hình:

4. Lời kết

Khó khăn nhất là việc khai báo trùng tên ở biến toàn cục và biến cục bộ, vì vậy lời khuyên bạn nên sử dụng biến một cách khoa học, khai báo bằng tham số truyền vào nếu muốn sử dụng biến toàn cục ở bên trong hàm.

Như vậy là mình đã giới thiệu xong khái niệm về biến cục bộ và biến toàn cục trong Python, hy vọng bạn sẽ hiểu ý nghĩa của từng loại biến để sử dụng cho đúng mục đích.

Biến toàn cục là biến được định nghĩa và khai báo bên ngoài hàm và chúng ta cần sử dụng chúng trong hàm.

# -----------------------------------------------------------
#Cafedev.vn - Kênh thông tin IT hàng đầu Việt Nam
#@author cafedevn
#Contact: 
#Fanpage: //www.facebook.com/cafedevn
#Group: //www.facebook.com/groups/cafedev.vn/
#Instagram: //instagram.com/cafedevn
#Twitter: //twitter.com/CafedeVn
#Linkedin: //www.linkedin.com/in/cafe-dev-407054199/
#Pinterest: //www.pinterest.com/cafedevvn/
#YouTube: //www.youtube.com/channel/UCE7zpY_SlHGEgo67pHxqIoA/
# -----------------------------------------------------------

# This function uses global variable s 
def f[]:  
    print s  
  
# Global scope 
s = "I love Cafedev.vn"
f[] 

Kết quả:

I love Cafedev.vn

Biến s được định nghĩa là chuỗi “I love Cafedev.vn”, trước khi chúng ta gọi hàm f[]. Lệnh duy nhất trong hàm f[] là câu lệnh “print s”. Vì không có biến s cục bộ, giá trị từ biến s toàn cục sẽ được sử dụng.

# -----------------------------------------------------------
#Cafedev.vn - Kênh thông tin IT hàng đầu Việt Nam
#@author cafedevn
#Contact: 
#Fanpage: //www.facebook.com/cafedevn
#Group: //www.facebook.com/groups/cafedev.vn/
#Instagram: //instagram.com/cafedevn
#Twitter: //twitter.com/CafedeVn
#Linkedin: //www.linkedin.com/in/cafe-dev-407054199/
#Pinterest: //www.pinterest.com/cafedevvn/
#YouTube: //www.youtube.com/channel/UCE7zpY_SlHGEgo67pHxqIoA/
# -----------------------------------------------------------


# This function has a variable with 
# name same as s. 
def f[]:  
    s = "Me too."
    print s  
  
# Global scope 
s = "I love Cafedev.vn" 
f[] 
print s 

Kết quả:

Me too.
I love Cafedev.vn

Nếu một biến có cùng tên cũng được định nghĩa bên trong phạm vi của hàm thì nó sẽ chỉ in giá trị được cung cấp bên trong hàm chứ không phải giá trị toàn cục.

Câu hỏi là: điều gì sẽ xảy ra nếu chúng ta thay đổi giá trị của biến s bên trong hàm f[]? Nó cũng sẽ ảnh hưởng đến biến toàn cục chứ? Chúng ta kiểm tra nó trong đoạn code sau:

# -----------------------------------------------------------
#Cafedev.vn - Kênh thông tin IT hàng đầu Việt Nam
#@author cafedevn
#Contact: 
#Fanpage: //www.facebook.com/cafedevn
#Group: //www.facebook.com/groups/cafedev.vn/
#Instagram: //instagram.com/cafedevn
#Twitter: //twitter.com/CafedeVn
#Linkedin: //www.linkedin.com/in/cafe-dev-407054199/
#Pinterest: //www.pinterest.com/cafedevvn/
#YouTube: //www.youtube.com/channel/UCE7zpY_SlHGEgo67pHxqIoA/
# -----------------------------------------------------------


def f[]:  
    print s 
  
    # This program will NOT show error 
    # if we comment below line.  
    s = "Me too."
  
    print s 
  
# Global scope 
s = "I love cafedev" 
f[] 
print s 

Kết quả:

Line 2: undefined: Error: local variable 's' referenced before assignment

Để chương trình trên hoạt động, chúng ta cần sử dụng từ khóa “global”. Chúng ta chỉ cần sử dụng từ khóa toàn cục trong một hàm nếu chúng ta muốn thực hiện các tác vụ/thay đổi chúng. Toàn cục là không cần thiết để in và truy cập. Tại sao vậy? Python có giả định rằng chúng ta muốn một biến cục bộ do các tác vụ cho biến s nằm bên bên trong hàm f[], vì vậy câu lệnh in đầu tiên hiện thông báo lỗi này. Bất kỳ biến nào được thay đổi hoặc tạo bên trong hàm là cục bộ nếu nó chưa được khai báo là biến toàn cục. Để nói với Python rằng chúng ta muốn sử dụng biến toàn cục, chúng ta phải sử dụng từ khóa toàn cục [global], có thể thấy trong ví dụ sau:

# -----------------------------------------------------------
#Cafedev.vn - Kênh thông tin IT hàng đầu Việt Nam
#@author cafedevn
#Contact: 
#Fanpage: //www.facebook.com/cafedevn
#Group: //www.facebook.com/groups/cafedev.vn/
#Instagram: //instagram.com/cafedevn
#Twitter: //twitter.com/CafedeVn
#Linkedin: //www.linkedin.com/in/cafe-dev-407054199/
#Pinterest: //www.pinterest.com/cafedevvn/
#YouTube: //www.youtube.com/channel/UCE7zpY_SlHGEgo67pHxqIoA/
# -----------------------------------------------------------


# This function modifies the global variable 's' 
def f[]: 
    global s 
    print s 
    s = "Look for cafedev Python Section"
    print s  
  
# Global Scope 
s = "Python is great!" 
f[] 
print s 

Kết quả:

Python is great!
Look for Geeksforgeeks Python Section.
Look for Geeksforgeeks Python Section.

Một ví dụ hay khác:

a = 1
  
# Uses global because there is no local 'a' 
def f[]: 
    print 'Inside f[] : ', a 
  
# Variable 'a' is redefined as a local 
def g[]:     
    a = 2
    print 'Inside g[] : ',a 
  
# Uses global keyword to modify global 'a' 
def h[]:     
    global a 
    a = 3
    print 'Inside h[] : ',a 
  
# Global scope 
print 'global : ',a 
f[] 
print 'global : ',a 
g[] 
print 'global : ',a 
h[] 
print 'global : ',a 

Kết quả:

global :  1
Inside f[] :  1
global :  1
Inside g[] :  2
global :  1
Inside h[] :  3
global :  3

Nguồn và Tài liệu tiếng anh tham khảo:

• w3school
• python.org
• geeksforgeeks

Tài liệu từ cafedev:

• Full series tự học Python từ cơ bản tới nâng cao tại đây nha.
• Ebook về python tại đây.
• Các series tự học lập trình khác

Nếu bạn thấy hay và hữu ích, bạn có thể tham gia các kênh sau của cafedev để nhận được nhiều hơn nữa:

• Group Facebook
• Fanpage
• Youtube
• Instagram
• Twitter
• Linkedin
• Pinterest
• Trang chủ

Chào thân ái và quyết thắng!

Đăng ký kênh youtube để ủng hộ Cafedev nha các bạn, Thanks you!