Tên bóng từ Python phạm vi bên ngoài

cơ sở lý luận

Trước phiên bản 2. 1, Cách xử lý phạm vi của Python giống với cách xử lý của tiêu chuẩn C. trong một tệp chỉ có hai mức phạm vi, toàn cầu và cục bộ. Trong C, đây là hệ quả tự nhiên của thực tế là các định nghĩa hàm không thể được lồng vào nhau. Nhưng trong Python, mặc dù các hàm thường được định nghĩa ở mức cao nhất, nhưng một định nghĩa hàm có thể được thực thi ở bất cứ đâu. Điều này mang lại cho Python hình thức cú pháp của phạm vi lồng nhau mà không có ngữ nghĩa, và tạo ra sự không nhất quán khiến một số lập trình viên ngạc nhiên – ví dụ: một hàm đệ quy hoạt động ở mức cao nhất sẽ ngừng hoạt động khi được di chuyển bên trong một hàm khác, bởi vì hàm đệ quy của riêng nó. . Điều này vi phạm trực giác rằng một hàm sẽ hoạt động nhất quán khi được đặt trong các ngữ cảnh khác nhau. Đây là một ví dụ

def enclosing_function():
    def factorial(n):
        if n < 2:
            return 1
        return n * factorial(n - 1)  # fails with NameError
    print factorial(5)

Trăn 2. 1 tiến gần hơn đến phạm vi lồng nhau tĩnh bằng cách hiển thị các tên bị ràng buộc trong tất cả các phạm vi kèm theo (xem PEP 227). Thay đổi này làm cho ví dụ mã trên hoạt động như mong đợi. Tuy nhiên, vì bất kỳ phép gán nào cho một tên đều ngầm khai báo tên đó là cục bộ, nên không thể ràng buộc lại một tên trong phạm vi bên ngoài (ngoại trừ khi khai báo

def make_scoreboard(frame, score=0):
    label = Label(frame)
    label.pack()
    for i in [-10, -1, 1, 10]:
        def increment(step=i):
            score = score + step  # fails with UnboundLocalError
            label['text'] = score
        button = Button(frame, text='%+d' % i, command=increment)
        button.pack()
    return label

def make_scoreboard(frame, score=0):
    label = Label(frame)
    label.pack()
    for i in [-10, -1, 1, 10]:
        def increment(step=i):
            score = score + step  # fails with UnboundLocalError
            label['text'] = score
        button = Button(frame, text='%+d' % i, command=increment)
        button.pack()
    return label

Cú pháp Python không cung cấp cách để chỉ ra rằng tên

def make_scoreboard(frame, score=0):
    label = Label(frame)
    label.pack()
    for i in [-10, -1, 1, 10]:
        def increment(step=i):
            score = score + step  # fails with UnboundLocalError
            label['text'] = score
        button = Button(frame, text='%+d' % i, command=increment)
        button.pack()
    return label

def make_scoreboard(frame, score=0):
    label = Label(frame)
    label.pack()
    for i in [-10, -1, 1, 10]:
        def increment(step=i):
            score = score + step  # fails with UnboundLocalError
            label['text'] = score
        button = Button(frame, text='%+d' % i, command=increment)
        button.pack()
    return label

def make_scoreboard(frame, score=0):
    label = Label(frame)
    label.pack()
    for i in [-10, -1, 1, 10]:
        def increment(step=i):
            score = score + step  # fails with UnboundLocalError
            label['text'] = score
        button = Button(frame, text='%+d' % i, command=increment)
        button.pack()
    return label

def make_scoreboard(frame, score=0):
    label = Label(frame)
    label.pack()
    for i in [-10, -1, 1, 10]:
        def increment(step=i):
            score = score + step  # fails with UnboundLocalError
            label['text'] = score
        button = Button(frame, text='%+d' % i, command=increment)
        button.pack()
    return label

def make_scoreboard(frame, score=0):
    label = Label(frame)
    label.pack()
    for i in [-10, -1, 1, 10]:
        def increment(step=i):
            score = score + step  # fails with UnboundLocalError
            label['text'] = score
        button = Button(frame, text='%+d' % i, command=increment)
        button.pack()
    return label

Người ta đã lập luận rằng một tính năng như vậy là không cần thiết, bởi vì một biến bên ngoài có thể rebindable có thể được mô phỏng bằng cách gói nó trong một đối tượng có thể thay đổi

def get_integer_input(prompt_text):
    user_input = input(prompt_text)
    return int(user_input)

print(user_input)

Tuy nhiên, cách giải quyết này chỉ làm nổi bật những thiếu sót của phạm vi hiện có. mục đích của một chức năng là đóng gói mã trong không gian tên riêng của nó, do đó, có vẻ như không may là lập trình viên phải tạo các không gian tên bổ sung để bù cho chức năng bị thiếu trong các phạm vi cục bộ hiện có và sau đó phải quyết định xem mỗi tên có nên nằm trong đó hay không.

Một phản đối phổ biến khác là thay vào đó, chức năng mong muốn có thể được viết dưới dạng một lớp, mặc dù hơi dài dòng hơn. Một phản bác đối với sự phản đối này là sự tồn tại của một kiểu triển khai khác không phải là lý do để cấu trúc lập trình được hỗ trợ (phạm vi lồng nhau) không hoàn thiện về mặt chức năng. Python đôi khi được gọi là “ngôn ngữ đa mô hình” vì nó có được rất nhiều sức mạnh, tính linh hoạt thực tế và khả năng sư phạm từ sự hỗ trợ và tích hợp duyên dáng của nhiều mô hình lập trình

Một đề xuất về cú pháp xác định phạm vi đã xuất hiện trên Python-Dev từ năm 1994 [1], rất lâu trước khi PEP 227 hỗ trợ cho các phạm vi lồng nhau được thông qua. Vào thời điểm đó, phản ứng của Guido là

Điều này rất nguy hiểm khi giới thiệu CSNS [phạm vi lồng nhau tĩnh cổ điển]. Nếu bạn làm như vậy, ngữ nghĩa được đề xuất của bạn về phạm vi có vẻ ổn. Tôi vẫn nghĩ rằng CSNS không đủ nhu cầu để đảm bảo loại công trình này…

Sau PEP 227, “cuộc thảo luận về việc hủy bỏ tên bên ngoài” đã xuất hiện lại trên Python-Dev đủ số lần để nó trở thành một sự kiện quen thuộc, đã tái diễn ở dạng hiện tại ít nhất là từ năm 2003 [2]. Mặc dù chưa có thay đổi ngôn ngữ nào được đề xuất trong các cuộc thảo luận này được thông qua, Guido đã thừa nhận rằng thay đổi ngôn ngữ đáng được xem xét [12]

Những ngôn ngữ khác

Để cung cấp một số thông tin cơ bản, phần này mô tả cách một số ngôn ngữ khác xử lý các phạm vi lồng nhau và liên kết lại

def make_scoreboard(frame, score=0):
    label = Label(frame)
    label.pack()
    for i in [-10, -1, 1, 10]:
        def increment(step=i):
            score = score + step  # fails with UnboundLocalError
            label['text'] = score
        button = Button(frame, text='%+d' % i, command=increment)
        button.pack()
    return label

def make_scoreboard(frame, score=0):
    label = Label(frame)
    label.pack()
    for i in [-10, -1, 1, 10]:
        def increment(step=i):
            score = score + step  # fails with UnboundLocalError
            label['text'] = score
        button = Button(frame, text='%+d' % i, command=increment)
        button.pack()
    return label

def make_scoreboard(frame, score=0):
    label = Label(frame)
    label.pack()
    for i in [-10, -1, 1, 10]:
        def increment(step=i):
            score = score + step  # fails with UnboundLocalError
            label['text'] = score
        button = Button(frame, text='%+d' % i, command=increment)
        button.pack()
    return label

def get_integer_input(prompt_text):
    user_input = input(prompt_text)
    return int(user_input)

print(user_input)

Tổng quan về đề xuất

Đã có nhiều đề xuất khác nhau trên Python-Dev về cách liên kết lại tên trong phạm vi bên ngoài. Tất cả đều rơi vào hai loại. cú pháp mới trong phạm vi nơi tên bị ràng buộc hoặc cú pháp mới trong phạm vi nơi tên được sử dụng

def make_scoreboard(frame, score=0):
    label = Label(frame)
    label.pack()
    for i in [-10, -1, 1, 10]:
        def increment(step=i):
            score = score + step  # fails with UnboundLocalError
            label['text'] = score
        button = Button(frame, text='%+d' % i, command=increment)
        button.pack()
    return label

def get_integer_input(prompt_text):
    user_input = input(prompt_text)
    return int(user_input)

print(user_input)

def get_integer_input(prompt_text):
    user_input = input(prompt_text)
    return int(user_input)

print(user_input)

def get_integer_input(prompt_text):
    user_input = input(prompt_text)
    return int(user_input)

print(user_input)

user_input = 10

def get_integer_input(prompt_text):
    user_input = input(prompt_text)
    return int(user_input)

print(user_input)

def get_integer_input(prompt_text):
    user_input = input(prompt_text)
    return int(user_input)

print(user_input)

def get_integer_input(prompt_text):
    user_input = input(prompt_text)
    return int(user_input)

print(user_input)

user_input = 10

def get_integer_input(prompt_text):
    user_input = input(prompt_text)
    return int(user_input)

print(user_input)

def get_integer_input(prompt_text):
    user_input = input(prompt_text)
    return int(user_input)

print(user_input)

def get_integer_input(prompt_text):
    user_input = input(prompt_text)
    return int(user_input)

print(user_input)

user_input = 10

def get_integer_input(prompt_text):
    user_input = input(prompt_text)
    return int(user_input)

print(user_input)

user_input = 10

def get_integer_input(prompt_text):
    user_input = input(prompt_text)
    return int(user_input)

print(user_input)

def get_integer_input(prompt_text):
    user_input = input(prompt_text)
    return int(user_input)

print(user_input)

def get_integer_input(prompt_text):
    user_input = input(prompt_text)
    return int(user_input)

print(user_input)

user_input = 10

def get_integer_input(prompt_text):
    user_input = input(prompt_text)
    return int(user_input)

print(user_input)

user_input = 10

def get_integer_input(prompt_text):
    user_input = input(prompt_text)
    return int(user_input)

print(user_input)

def get_integer_input(prompt_text):
    user_input = input(prompt_text)
    return int(user_input)

print(user_input)

user_input = input(prompt_text)

def get_integer_input(prompt_text):
    user_input = input(prompt_text)
    return int(user_input)

print(user_input)

user_input = input(prompt_text)

def make_scoreboard(frame, score=0):
    label = Label(frame)
    label.pack()
    for i in [-10, -1, 1, 10]:
        def increment(step=i):
            score = score + step  # fails with UnboundLocalError
            label['text'] = score
        button = Button(frame, text='%+d' % i, command=increment)
        button.pack()
    return label

def make_scoreboard(frame, score=0):
    label = Label(frame)
    label.pack()
    for i in [-10, -1, 1, 10]:
        def increment(step=i):
            score = score + step  # fails with UnboundLocalError
            label['text'] = score
        button = Button(frame, text='%+d' % i, command=increment)
        button.pack()
    return label

def make_scoreboard(frame, score=0):
    label = Label(frame)
    label.pack()
    for i in [-10, -1, 1, 10]:
        def increment(step=i):
            score = score + step  # fails with UnboundLocalError
            label['text'] = score
        button = Button(frame, text='%+d' % i, command=increment)
        button.pack()
    return label

def make_scoreboard(frame, score=0):
    label = Label(frame)
    label.pack()
    for i in [-10, -1, 1, 10]:
        def increment(step=i):
            score = score + step  # fails with UnboundLocalError
            label['text'] = score
        button = Button(frame, text='%+d' % i, command=increment)
        button.pack()
    return label

def make_scoreboard(frame, score=0):
    label = Label(frame)
    label.pack()
    for i in [-10, -1, 1, 10]:
        def increment(step=i):
            score = score + step  # fails with UnboundLocalError
            label['text'] = score
        button = Button(frame, text='%+d' % i, command=increment)
        button.pack()
    return label

def make_scoreboard(frame, score=0):
    label = Label(frame)
    label.pack()
    for i in [-10, -1, 1, 10]:
        def increment(step=i):
            score = score + step  # fails with UnboundLocalError
            label['text'] = score
        button = Button(frame, text='%+d' % i, command=increment)
        button.pack()
    return label

def enclosing_function():
    def factorial(n):
        if n < 2:
            return 1
        return n * factorial(n - 1)  # fails with NameError
    print factorial(5)

def make_scoreboard(frame, score=0):
    label = Label(frame)
    label.pack()
    for i in [-10, -1, 1, 10]:
        def increment(step=i):
            score = score + step  # fails with UnboundLocalError
            label['text'] = score
        button = Button(frame, text='%+d' % i, command=increment)
        button.pack()
    return label

giải pháp đề xuất

Giải pháp được đề xuất bởi PEP này là thêm một khai báo ghi đè phạm vi trong phạm vi giới thiệu (bên trong). Guido đã bày tỏ sự ưu tiên đối với danh mục giải pháp này trên Python-Dev [14] và đã thể hiện sự chấp thuận cho

def make_scoreboard(frame, score=0):
    label = Label(frame)
    label.pack()
    for i in [-10, -1, 1, 10]:
        def increment(step=i):
            score = score + step  # fails with UnboundLocalError
            label['text'] = score
        button = Button(frame, text='%+d' % i, command=increment)
        button.pack()
    return label

Tuyên bố đề xuất

user_input = input(prompt_text)

ngăn

def get_integer_input(prompt_text):
    user_input = input(prompt_text)
    return int(user_input)

print(user_input)

def get_integer_input(prompt_text):
    user_input = input(prompt_text)
    return int(user_input)

print(user_input)

def get_integer_input(prompt_text):
    user_input = input(prompt_text)
    return int(user_input)

print(user_input)

def make_scoreboard(frame, score=0):
    label = Label(frame)
    label.pack()
    for i in [-10, -1, 1, 10]:
        def increment(step=i):
            score = score + step  # fails with UnboundLocalError
            label['text'] = score
        button = Button(frame, text='%+d' % i, command=increment)
        button.pack()
    return label

user_input = 10

def get_integer_input(prompt_text):
    global user_input
    user_input = input(prompt_text)
    print(user_input)
    return int(user_input)

int_input = get_integer_input("Provide a number: ")
print(user_input)

Nếu không có ràng buộc tồn tại trước trong phạm vi kèm theo, trình biên dịch sẽ phát sinh Lỗi Cú pháp. (Có thể hơi dài dòng khi gọi đây là lỗi cú pháp, nhưng cho đến nay SyntaxError được sử dụng cho tất cả các lỗi thời gian biên dịch, bao gồm, ví dụ: __future__ nhập với tên tính năng không xác định. ) Guido đã nói rằng loại khai báo này khi không có ràng buộc bên ngoài nên được coi là một lỗi [16]

Nếu một khai báo

def make_scoreboard(frame, score=0):
    label = Label(frame)
    label.pack()
    for i in [-10, -1, 1, 10]:
        def increment(step=i):
            score = score + step  # fails with UnboundLocalError
            label['text'] = score
        button = Button(frame, text='%+d' % i, command=increment)
        button.pack()
    return label

Một hình thức tốc ký cũng được cho phép, trong đó

def make_scoreboard(frame, score=0):
    label = Label(frame)
    label.pack()
    for i in [-10, -1, 1, 10]:
        def increment(step=i):
            score = score + step  # fails with UnboundLocalError
            label['text'] = score
        button = Button(frame, text='%+d' % i, command=increment)
        button.pack()
    return label

def make_scoreboard(frame, score=0):
    label = Label(frame)
    label.pack()
    for i in [-10, -1, 1, 10]:
        def increment(step=i):
            score = score + step  # fails with UnboundLocalError
            label['text'] = score
        button = Button(frame, text='%+d' % i, command=increment)
        button.pack()
    return label

Ở trên có ý nghĩa chính xác giống như

def enclosing_function():
    def factorial(n):
        if n < 2:
            return 1
        return n * factorial(n - 1)  # fails with NameError
    print factorial(5)

def make_scoreboard(frame, score=0):
    label = Label(frame)
    label.pack()
    for i in [-10, -1, 1, 10]:
        def increment(step=i):
            score = score + step  # fails with UnboundLocalError
            label['text'] = score
        button = Button(frame, text='%+d' % i, command=increment)
        button.pack()
    return label

Ở phía bên trái của biểu mẫu tốc ký, chỉ các mã định danh mới được phép, không phải các biểu thức đích như

def make_scoreboard(frame, score=0):
    label = Label(frame)
    label.pack()
    for i in [-10, -1, 1, 10]:
        def increment(step=i):
            score = score + step  # fails with UnboundLocalError
            label['text'] = score
        button = Button(frame, text='%+d' % i, command=increment)
        button.pack()
    return label

def make_scoreboard(frame, score=0):
    label = Label(frame)
    label.pack()
    for i in [-10, -1, 1, 10]:
        def increment(step=i):
            score = score + step  # fails with UnboundLocalError
            label['text'] = score
        button = Button(frame, text='%+d' % i, command=increment)
        button.pack()
    return label

def enclosing_function():
    def factorial(n):
        if n < 2:
            return 1
        return n * factorial(n - 1)  # fails with NameError
    print factorial(5)

Lý do cho phép tất cả các hình thức chuyển nhượng này là nó đơn giản hóa việc hiểu câu lệnh

def make_scoreboard(frame, score=0):
    label = Label(frame)
    label.pack()
    for i in [-10, -1, 1, 10]:
        def increment(step=i):
            score = score + step  # fails with UnboundLocalError
            label['text'] = score
        button = Button(frame, text='%+d' % i, command=increment)
        button.pack()
    return label

Ghi chú

Cú pháp tốc ký không được thêm vào trong triển khai ban đầu của PEP. Các cuộc thảo luận sau đó [29] [30] đã kết luận rằng cú pháp này không nên được thực hiện

Khả năng tương thích ngược

PEP này nhắm mục tiêu Python 3000, theo đề xuất của Guido [19]. Tuy nhiên, những người khác đã lưu ý rằng một số tùy chọn được xem xét trong PEP này có thể là những thay đổi đủ nhỏ để khả thi trong Python 2. x [26], trong trường hợp này PEP này có thể được chuyển thành 2. dòng x PEP

Là thước đo (rất sơ bộ) về tác động của việc giới thiệu một từ khóa mới, đây là số lần mà một số từ khóa được đề xuất xuất hiện dưới dạng số nhận dạng trong thư viện chuẩn, theo bản quét kho lưu trữ Python SVN vào ngày 5 tháng 11 năm 2006

def make_scoreboard(frame, score=0):
    label = Label(frame)
    label.pack()
    for i in [-10, -1, 1, 10]:
        def increment(step=i):
            score = score + step  # fails with UnboundLocalError
            label['text'] = score
        button = Button(frame, text='%+d' % i, command=increment)
        button.pack()
    return label

def make_scoreboard(frame, score=0):
    label = Label(frame)
    label.pack()
    for i in [-10, -1, 1, 10]:
        def increment(step=i):
            score = score + step  # fails with UnboundLocalError
            label['text'] = score
        button = Button(frame, text='%+d' % i, command=increment)
        button.pack()
    return label

def make_scoreboard(frame, score=0):
    label = Label(frame)
    label.pack()
    for i in [-10, -1, 1, 10]:
        def increment(step=i):
            score = score + step  # fails with UnboundLocalError
            label['text'] = score
        button = Button(frame, text='%+d' % i, command=increment)
        button.pack()
    return label

def make_scoreboard(frame, score=0):
    label = Label(frame)
    label.pack()
    for i in [-10, -1, 1, 10]:
        def increment(step=i):
            score = score + step  # fails with UnboundLocalError
            label['text'] = score
        button = Button(frame, text='%+d' % i, command=increment)
        button.pack()
    return label

def make_scoreboard(frame, score=0):
    label = Label(frame)
    label.pack()
    for i in [-10, -1, 1, 10]:
        def increment(step=i):
            score = score + step  # fails with UnboundLocalError
            label['text'] = score
        button = Button(frame, text='%+d' % i, command=increment)
        button.pack()
    return label

Người giới thiệu

Sự nhìn nhận

Các ý tưởng và đề xuất được đề cập trong PEP này được thu thập từ vô số bài đăng Python-Dev. Cảm ơn Jim Jewett, Mike Orr, Jason Orendorff và Christian Tanzer đã đề xuất các chỉnh sửa cụ thể cho PEP này

Tên bóng có nghĩa là gì trong Python?

Làm thế nào một biến toàn cầu có thể được che khuất?

phạm vi biến bối cảnh biến đổ bóng là gì?