Краткое описание правил определения объема?

, Где x найден?

x не найден, поскольку Вы не определили его.:-) можно было найти в (глобальном) code1 или code3 (локальный) при помещении его там.

code2 (участники класса) не видимы для кодирования внутренних методов того же class —  you, обычно получал бы доступ к ним использование сам. code4/code5 (циклы) живут в том же объеме как code3, поэтому если бы Вы записали в x там, то Вы изменили бы x экземпляр, определенный в code3, не делая новое x.

, Python статически ограничен по объему, поэтому при передаче ‘spam’ другому функциональному спаму, будет все еще иметь доступ к globals в модуле, это прибыло из (определенный в code1), и любой другой содержащий объемы (см. ниже). к участникам code2 снова получили бы доступ через сам.

лямбда не отличается от определения, Если Вам использовали лямбду в функции, это совпадает с определением вложенной функции. В Python 2.2 вперед, вложенные объемы доступны. В этом случае можно связать x на любом уровне функционального вложения, и Python возьмет самый внутренний экземпляр:

x= 0
def fun1():
    x= 1
    def fun2():
        x= 2
        def fun3():
            return x
        return fun3()
    return fun2()
print fun1(), x

2 0

fun3 видит экземпляр x от самого близкого, содержащего объем, который является функциональным объемом, связанным с fun2. Но другие x экземпляры, определенные в fun1 и глобально, не затронуты.

Прежде nested_scopes —  in Python пред2.1, и в 2,1, если Вы конкретно не просите функцию с помощью from-future-import —  fun1 и объемы fun2, не видимы к fun3, таким образом, ответ S.Lott содержит, и Вы получили бы глобальный x:

0 0

Правила обзора для Python 2.x уже были обрисованы в общих чертах в других ответах. Единственная вещь, которую я добавил бы, состоит в том, что в Python 3.0, существует также понятие нелокального объема (обозначено 'нелокальным' ключевым словом). Это позволяет Вам получать доступ к внешним объемам непосредственно и открывает способность сделать некоторые аккуратные приемы, включая лексические закрытия (без ужасных взломов, включающих изменяемые объекты).

РЕДАКТИРОВАНИЕ: вот PEP с большей информацией об этом.

Python разрешает Ваши переменные с - обычно - три доступные пространства имен.

В любое время во время выполнения, существует по крайней мере три вложенных объема, пространства имен которых непосредственно доступны: самый внутренний объем, который ищется сначала, содержит локальные имена; пространства имен любых функций включения, которые ищутся, начиная с самого близкого объема включения; средний объем, искавший затем, содержит глобальные имена текущего модуля; и наиболее удаленным объемом (искавший в последний раз) является пространство имен, содержащее встроенные имена.

существует две функции: globals и locals, которые показывают Вам содержание два из этих пространств имен.

Пространства имен создаются пакетами, модулями, классами, объектной конструкцией и функциями. Нет никаких других разновидностей пространств имен.

В этом случае, вызов к функции, названной x, должен быть разрешен в локальном пространстве имен или глобальном пространстве имен.

Локальный в этом случае, тело функции метода Foo.spam.

Глобальный - хорошо - глобален.

правило состоит в том, чтобы искать вложенные локальные пространства, созданные функциями метода (и определения вложенной функции), затем искать глобальный. Вот именно.

нет никаких других объемов. for оператор (и другие составные операторы как if и try) не создают новые вложенные объемы. Только определения (пакеты, модули, функции, классы и экземпляры объектов.)

Внутренняя часть определение класса, имена являются частью пространства имен класса. code2, например, должен быть квалифицирован именем класса. Обычно Foo.code2. Однако self.code2 будет также работать, потому что объекты Python смотрят на содержание класса как нейтрализация.

объект (экземпляр класса) имеет переменные экземпляра. Эти имена находятся в пространстве имен объекта. Они должны быть квалифицированы объектом. (variable.instance.)

Из метода класса, у Вас есть местные жители и globals. Вы говорите self.variable для выбора экземпляра как пространства имен. Вы отметите, что self аргумент каждой функции членства класса, делая его частью локального пространства имен.

См. Правила , Объема Python Объем Python , Переменный Объем .

По существу единственной вещью в Python, который представляет новый объем, является функциональное определение. Классы являются чем-то вроде особого случая, в котором что-либо определенное непосредственно в теле помещается в пространство имен класса, но они не непосредственно доступны из методов (или вложенные классы), они содержат.

В Вашем примере существует только 3 объема, где x будет искаться в:

• объем спама - содержащий все определенное в code3 и code5 (а также code4, Ваша переменная цикла)

• глобальная область видимости - содержащий все определенное в code1, а также Foo (и безотносительно изменений после него)

• builtins пространство имен. Что-то вроде особого случая - это содержит различный Python встроенные функции и типы, такие как len () и str (). Обычно это не должно быть изменено никаким пользовательским кодом, поэтому ожидать, что он будет содержать стандартные функции и ничто иное.

[еще 1113] объемы только появляются при представлении вложенной функции (или лямбда) в изображение. Они будут вести себя в значительной степени, как Вы ожидали бы как бы то ни было. Вложенная функция может получить доступ ко всему в локальном объеме, а также чему-либо в объеме функции включения. например,

def foo():
    x=4
    def bar():
        print x  # Accesses x from foo's scope
    bar()  # Prints 4
    x=5
    bar()  # Prints 5

Ограничения:

к Переменным в объемах кроме переменных локальной функции можно получить доступ, но не могут быть восстановлением к новым параметрам без дальнейшего синтаксиса. Вместо этого присвоение создаст новое локальный переменная вместо того, чтобы влиять на переменную в родительском объеме. Например:

global_var1 = []
global_var2 = 1

def func():
    # This is OK: It's just accessing, not rebinding
    global_var1.append(4) 

    # This won't affect global_var2. Instead it creates a new variable
    global_var2 = 2 

    local1 = 4
    def embedded_func():
        # Again, this doen't affect func's local1 variable.  It creates a 
        # new local variable also called local1 instead.
        local1 = 5
        print local1

    embedded_func() # Prints 5
    print local1    # Prints 4

для фактического изменения привязки глобальных переменных из функционального объема, необходимо определить, что переменная глобальна с глобальным ключевым словом. Например:

global_var = 4
def change_global():
    global global_var
    global_var = global_var + 1

В настоящее время нет никакого способа сделать то же для переменных во включении функция , объемы, но Python 3 представляет новое ключевое слово, "nonlocal", который будет действовать похожим способом к глобальному, но для объемов вложенной функции.