Lý do cho globals() bằng Python?

Question

Lý do có hàm globals() trong Python là gì? Nó chỉ trả về từ điển của các biến toàn cầu, mà đã được toàn cầu, vì vậy chúng có thể được sử dụng ở bất cứ đâu ... Tôi chỉ hỏi tò mò, cố gắng tìm hiểu python.

def F(): 
    global x 
    x = 1 

def G(): 
    print(globals()["x"]) #will return value of global 'x', which is 1 

def H(): 
    print(x) #will also return value of global 'x', which, also, is 1 

F() 
G() 
H() 

Tôi thực sự không thể thấy điểm ở đây? Chỉ có thời gian tôi sẽ cần đến nó, là nếu tôi đã biến địa phương và toàn cầu, với cùng một tên cho cả hai

def F(): 
    global x 
    x = 1 

def G(): 
    x = 5 
    print(x) #5 
    print(globals()["x"]) #1 

F() 
G() 

Nhưng bạn không bao giờ nên chạy vào một vấn đề của việc có hai biến với cùng một tên, và cần phải sử dụng cả hai đều trong phạm vi tương tự.

Answer 1

Python cung cấp cho trình lập trình một số lượng lớn các công cụ để tìm hiểu môi trường đang chạy. globals() chỉ là một trong số đó, và nó có thể rất hữu ích trong một phiên gỡ lỗi để xem những đối tượng phạm vi toàn cầu thực sự chứa.

Lý do đằng sau nó, tôi chắc chắn, giống như sử dụng locals() để xem các biến được xác định trong hàm hoặc sử dụng dir để xem nội dung của mô-đun hoặc thuộc tính của đối tượng.

Đến từ nền C++, tôi có thể hiểu rằng những thứ này có vẻ không cần thiết. Trong môi trường tĩnh được liên kết tĩnh, chúng hoàn toàn sẽ là. Trong trường hợp đó, nó được biết tại thời gian biên dịch chính xác những biến nào là toàn cầu, và các thành viên nào một đối tượng sẽ có, và thậm chí cả những tên được xuất khẩu bởi một đơn vị biên dịch khác.

Tuy nhiên, bằng ngôn ngữ động, những thứ này không cố định; chúng có thể thay đổi tùy thuộc vào cách mã được nhập hoặc thậm chí trong thời gian chạy. Vì lý do đó ít nhất, việc truy cập vào loại thông tin này trong trình gỡ lỗi có thể là vô giá.

Answer 2

globals() hữu ích cho eval() - nếu bạn muốn đánh giá một số mã đề cập đến các biến trong phạm vi, các biến đó sẽ nằm trong các hình ảnh tổng quát hoặc địa phương.

---

Để mở rộng một chút, hàm dựng sẵn eval() sẽ diễn giải một chuỗi mã Python được cung cấp cho nó. Chữ ký là: eval(codeString, globals, locals), và bạn sẽ sử dụng nó như vậy:

def foo(): 
    x = 2 
    y = eval("x + 1", globals(), locals()) 
    print("y=" + y) # should be 3 

này hoạt động, bởi vì người phiên dịch được giá trị của x từ locals() dict của các biến. Tất nhiên bạn có thể cung cấp dict của riêng bạn của các biến để eval.

Answer 3

Bạn có thể chuyển kết quả của globals() và locals() tới các lệnh eval, execfile và __import__. Làm như vậy tạo ra một môi trường hạn chế cho các lệnh đó hoạt động.

Do đó, các chức năng này tồn tại để hỗ trợ các chức năng khác được hưởng lợi từ môi trường có khả năng khác với ngữ cảnh hiện tại. Ví dụ: bạn có thể gọi globals() rồi xóa hoặc thêm một số biến trước khi gọi một trong các hàm đó.

Answer 4

Nó cũng hữu ích khi bạn cần gọi hàm bằng cách sử dụng tên chuỗi của hàm. Ví dụ:

def foo(): 
    pass 

function_name_as_string = 'foo' 

globals()[function_name_as_string]() # foo(). 

Answer 5

Nó có thể hữu ích trong 'python khai báo'.Ví dụ, ở bên dưới FooDef và BarDef là các lớp được sử dụng để xác định một loạt các cấu trúc dữ liệu mà sau đó được sử dụng bởi một số gói làm đầu vào của nó hoặc cấu hình của nó. Điều này cho phép bạn rất linh hoạt trong những gì đầu vào của bạn, và bạn không cần phải viết một trình phân tích cú pháp.

# FooDef, BarDef are classes 

Foo_one = FooDef("This one", opt1 = False, valence = 3) 
Foo_two = FooDef("The other one", valence = 6, parent = Foo_one) 

namelist = [] 
for i in range(6): 
    namelist.append("nm%03d"%i) 

Foo_other = FooDef("a third one", string_list = namelist) 

Bar_thing = BarDef((Foo_one, Foo_two), method = 'depth-first') 

Lưu ý rằng tệp cấu hình này sử dụng vòng lặp để tạo danh sách tên là một phần của cấu hình Foo_other. Vì vậy, ngôn ngữ cấu hình này đi kèm với một 'preprocessor' rất mạnh, với một thư viện thời gian chạy có sẵn. Trong trường hợp bạn muốn tìm kiếm một bản ghi phức tạp hoặc trích xuất mọi thứ từ một tệp zip và giải mã base64, như là một phần của việc tạo cấu hình của bạn (tất nhiên, phương pháp này không được khuyến nghị trong trường hợp đầu vào có thể từ nguồn không tin cậy ...)

các gói phần mềm đọc cấu hình sử dụng giống như sau:

conf_globals = {} # make a namespace 
# Give the config file the classes it needs 
conf_globals['FooDef']= mypkgconfig.FooDef # both of these are based ... 
conf_globals['BarDef']= mypkgconfig.BarDef # ... on .DefBase 

fname = "user.conf" 
try: 
    exec open(fname) in conf_globals 
except Exception: 
    ...as needed... 
# now find all the definitions in there 
# (I'm assuming the names they are defined with are 
# significant to interpreting the data; so they 
# are stored under those keys here). 

defs = {} 
for nm,val in conf_globals.items(): 
    if isinstance(val,mypkgconfig.DefBase): 
     defs[nm] = val 

Vì vậy, cuối cùng nhận được đến điểm, globals() là hữu ích, khi sử dụng một gói phần mềm như vậy, nếu bạn muốn đúc một loạt các định nghĩa theo thủ tục:

for idx in range(20): 
    varname = "Foo_%02d" % i 
    globals()[varname]= FooDef("one of several", id_code = i+1, scale_ratio = 2**i) 

này tương đương với viết ra

Foo_00 = FooDef("one of several", id_code = 1, scale_ratio=1) 
Foo_01 = FooDef("one of several", id_code = 2, scale_ratio=2) 
Foo_02 = FooDef("one of several", id_code = 3, scale_ratio=4) 
... 17 more ... 

Một ví dụ về một gói mà có được đầu vào của nó bằng cách thu thập một loạt các định nghĩa từ một mô-đun python là PLY (Python-lex-yacc) http://www.dabeaz.com/ply/ - trong trường hợp đó các đối tượng chủ yếu là các đối tượng hàm, nhưng siêu dữ liệu từ các đối tượng hàm (tên của chúng, các docstrings và thứ tự của định nghĩa) cũng là một phần của đầu vào. Nó không phải là một ví dụ tốt cho việc sử dụng globals(). Ngoài ra, nó được nhập khẩu bởi 'cấu hình' - sau này là một tập lệnh python bình thường - chứ không phải là cách khác xung quanh.

Tôi đã sử dụng 'python khai báo' trên một số dự án mà tôi đã làm việc và đã có dịp sử dụng globals() khi viết cấu hình cho những người đó. Bạn chắc chắn có thể tranh luận rằng điều này là do một điểm yếu trong cách cấu hình 'ngôn ngữ' được thiết kế. Sử dụng globals() theo cách này không tạo ra kết quả rất rõ ràng; chỉ các kết quả có thể dễ duy trì hơn là viết ra hàng tá câu lệnh gần như giống hệt nhau.

Bạn cũng có thể sử dụng nó để cung cấp cho các biến có ý nghĩa trong tập tin cấu hình, theo tên của họ:

# All variables above here starting with Foo_k_ are collected 
# in Bar_klist 
# 
foo_k = [ v for k,v in globals().items() if k.startswith('Foo_k_')] 
Bar_klist = BarDef(foo_k , method = "kset") 

Phương pháp này có thể hữu ích cho bất kỳ mô-đun python định nghĩa rất nhiều bảng và các cấu trúc, để làm cho việc thêm các mục vào dữ liệu dễ dàng hơn, mà không phải duy trì các tham chiếu.