как это изменить.

очтения документации я понимаю, что в Python есть отдельное пространство имен для функций, и если я хочу использовать глобальную переменную в этой функции, мне нужно использоватьglobal.

Я использую Python 2.7, и я попробовал этот маленький тест

>>> sub = ['0', '0', '0', '0']
>>> def getJoin():
...     return '.'.join(sub)
...
>>> getJoin()
'0.0.0.0'

Кажется, все работает нормально, даже безglobal, Я смог получить доступ к глобальной переменной без каких-либо проблем.

Я что-то пропустил? Кроме того, следующее из документации по Python:

Имена, перечисленные в глобальном операторе, не должны быть определены как формальные параметры или как цель управления циклом for, определение класса, определение функции или оператор импорта.

В то время как формальные параметры и определение класса имеют смысл для меня, я не могу понять ограничение для цели управления цикла и определения функции.

 user39576014 янв. 2011 г., 18:00
Будьте осторожны с формулировкой: у Python нет отдельного пространства имен для функций (это может означать, что вы могли бы иметьdef foo(): ... а такжеfoo = ... в то же время). Это создает новую область для каждого вызова функции. (Но как это отличается от любого другого языка высокого уровня в мире?)
 tobyodavies14 янв. 2011 г., 17:15
Я думаю, что вы перепутали с php, который требует использования глобального ключевого слова - документы Python подтверждают это - в основном, если оно не определено в локальном контексте, оно рассматривается как глобальное

Ответы на вопрос(10)

которую нужно знать об именах в Python, это то, что они являются локальными или глобальными для каждой области действия.

Рассмотрим это, например:

value = 42

def doit():
    print value
    value = 0

doit()
print value

Вы можете догадаться, чтоvalue = 0 оператор будет присваивать локальной переменной и не повлияет на значение той же переменной, объявленной внеdoit() функция. Вы можете быть более удивлены, обнаружив, чтокод выше не будет работать. Заявлениеprint value внутри функции производитUnboundLocalError.

Причина в том, что Python заметил, что в другом месте функции вы назначаете имяvalue, а такжеvalue нигде не заявленоglobal, Это делает его локальной переменной. Но когда вы пытаетесь распечатать его, локальное имя еще не определено. Python в этом случаене отступает искать имя как глобальную переменную, как это делают некоторые другие языки. По сути, вы не можете получить доступ к глобальной переменной, если вы определили локальную переменную с тем же именемв любом месте в функции.

 Dmitry Minkovsky18 мар. 2013 г., 17:49
В других языках это называется «подъем», например, так:github.com/shichuan/javascript-patterns/blob/master/...
 kindall21 февр. 2013 г., 21:31
Точно, у вас есть это.global (или жеnonlocal в Python 3.x) переопределяет это поведение и позволяет переназначить внешнее имя.
 Dmitry Minkovsky21 февр. 2013 г., 18:54
Спасибо за указание на это. Таким образом, до тех пор, пока ваша локальная область не присваивает имя, существующее вне ее, ссылки в локальной области будут использовать внешнее имя. Однако, если где-либо в вашей функции вы назначаете это имя, ссылки в этой локальной области, даже до локального назначения, не выглядят снаружи.
 kindall21 нояб. 2017 г., 18:10
Чтобы добавить оскорбление травме, переменные объявлены с более новым ключевым словом JavaScriptlet находятсяне водрузили.

переплет это в рамках.

Если вы просто ищете переменную, чтобы прочитать ее значение, у вас есть доступ к глобальной и локальной области видимости.

Однако, если вы назначите переменной, имя которой не входит в локальную область, выпереплет это имя в этой области (и если это имя также существует как глобальное, вы будете скрывать это).

Если вы хотите иметь возможность присваивать глобальное имя, вам нужно указать парсеру использовать глобальное имя, а не связывать новое локальное имя - это то, что делает ключевое слово «global».

Привязка в любом месте блока приводит к тому, что имя в этом блоке становится связанным, что может привести к некоторым довольно странным последствиям (например, UnboundLocalError, внезапно появляющаяся в ранее работающем коде).

>>> a = 1
>>> def p():
    print(a) # accessing global scope, no binding going on
>>> def q():
    a = 3 # binding a name in local scope - hiding global
    print(a)
>>> def r():
    print(a) # fail - a is bound to local scope, but not assigned yet
    a = 4
>>> p()
1
>>> q()
3
>>> r()
Traceback (most recent call last):
  File "<pyshell#35>", line 1, in <module>
    r()
  File "<pyshell#32>", line 2, in r
    print(a) # fail - a is bound to local scope, but not assigned yet
UnboundLocalError: local variable 'a' referenced before assignment
>>> 
Решение Вопроса

Ключевое словоglobal полезно только для изменения или создания глобальных переменных в локальном контексте, хотя создание глобальных переменных редко считается хорошим решением.

def bob():
    me = "locally defined"    # Defined only in local context
    print me

bob()
print me     # Asking for a global variable

Вышеуказанное даст вам:

locally defined
Traceback (most recent call last):
  File "file.py", line 9, in <module>
    print me
NameError: name 'me' is not defined

Хотя, если вы используетеglobal Скажем, переменная станет доступной «вне» области действия функции, фактически превратившись в глобальную переменную.

def bob():
    global me
    me = "locally defined"   # Defined locally but declared as global
    print me

bob()
print me     # Asking for a global variable

Таким образом, приведенный выше код даст вам:

locally defined
locally defined

Кроме того, из-за природы Python, вы также можете использоватьglobal объявлять функции, классы или другие объекты в локальном контексте. Хотя я бы посоветовал против этого, так как это вызывает кошмары, если что-то идет не так или требуется отладка.

 Robin Newhouse18 окт. 2013 г., 15:05
Не могли бы вы объяснить, почему глобальные переменные не являются хорошим решением? Я часто слышу это, но в моем текущем проекте они, кажется, делают именно то, что мне нужно. Есть ли что-то более зловещее, о чем я не думал?
 juice16 окт. 2013 г., 07:30
«Глобальный» в этом контексте отличается от других языков, которые считают «глобальными». В Python «глобальная» ссылка все еще находится в пределах модуля и должна ссылаться извне этого модуля как «module.global_var», а не просто как «global_var», как можно было бы ожидать.
 unode18 окт. 2013 г., 18:52
@RobinNewhouse Есть несколько вопросов по SO, уже охватывающихэто тема и другие не SOстатьи.
 unode16 окт. 2013 г., 19:07
@juice - в Python нет такого понятия, как абсолютglobals автоматически определяется во всех пространствах имен (к счастью). Как вы правильно указали, глобал связан с пространством имен внутри модуля, однако он может быть импортирован в другой модуль какfrom module import variable или жеimport module.variable, В первом случае импорт сделает переменную доступной какvariable не требуя ссылки какmodule., Если он считается глобальным в объеме модуля будет зависеть от того, где он импортируется. Смотрите такжеnonlocal в качестве нового ключевого слова, связанного с областью действия в Python 3.

получаете доступ к имени.

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

>>> x = 1         # global 
>>> def foo():
        print x       # accessing it, it is global

>>> foo()
1
>>> def foo():   
        x = 2        # local x
        print x 

>>> x            # global x
1
>>> foo()        # prints local x
2

Я приведу простой пример: подумайте об этом коде:

myVar = 0 
print (myVar )      # 01 line: returns 0

def func():
    myVar  = "def"
    print (myVar )

func()              # 02 line: returns def
print (myVar )      # 03 line: returns 0

как вы можете видеть, последняя строка кода вернет 0, потому что внутри функцииMYVAR переменная не была переназначена, она только что была изменена, и она изменитсятолько когда функция вызывается без влияния на основную переменную myVar, потому что она определена внутри функции our (означает, что это локальная переменная), но с использованием глобального ключевого слова как такового:

 myVar  = 0 
print (myVar )       # 01 Line : returns 0

def func():
    global myVar 
    myVar  = "def"
    print (myVar )

func()               # 02 Line : returns def
print (myVar )       # 03 Line : returns def

мы фактически заказываем python, что эта переменная внутри def не является локальной, используем глобальную переменную с именем asMYVAR как это изменить.

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

foo = 1
def test():
    foo = 2 # new local foo

def blub():
    global foo
    foo = 3 # changes the value of the global foo

В вашем случае вы просто получаете доступ к спискуsub.

 chhantyal19 февр. 2018 г., 15:40
С одной оговоркой:foo = 3 без глобальных работ, но foo снова определяется локально вblub Область действия функции & не изменяет исходную переменную foo. Это было довольно запутанным для меня.
 democidist12 апр. 2018 г., 00:31
@chhantyal Если под «работами» вы подразумеваете, что это не выдает ошибку, вы правы, но в контексте Иво Ветцеля это не будет работать так, как задумано. Есть способы использования такого поведения, но часто это не то, что хочет программист.

Это означает, что вы не должны делать следующее:

x = 1

def myfunc():
  global x

  # formal parameter
  def localfunction(x):
    return x+1

  # import statement
  import os.path as x

  # for loop control target
  for x in range(10):
    print x

  # class definition
  class x(object):
    def __init__(self):
      pass

  #function definition
  def x():
    print "I'm bad"
 pycruft14 янв. 2011 г., 17:43
ikostia перечисляет все то, что вы не можете использовать 'x' для использования global -docs.python.org/reference/...
 ikostia14 янв. 2011 г., 17:48
@Unode: Я просто демонстрирую все случаи, которые NikhilRathod привел в своей цитате.

Глобал делает переменную "Глобал"

def out():
    global x
    x = 1
    print(x)
    return


out()

print (x)

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

def out():
     # Taking out the global will give you an error since the variable x is no longer 'global' or in other words: accessible for other commands
    x = 1
    print(x)
    return


out()

print (x)

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

Вы можете получить доступ к глобальным ключевым словам без ключевого словаglobalЧтобы иметь возможность их изменять, вам необходимо явно указать, что ключевое слово является глобальным. В противном случае ключевое слово будет объявлено в локальной области.

Пример:

words = [...] 

def contains (word): 
    global words             # <- not really needed
    return (word in words) 

def add (word): 
    global words             # must specify that we're working with a global keyword
    if word not in words: 
        words += [word]

Ваш ответ на вопрос