Analysieren des Variablenbereichs in Python anhand lokaler und globaler Variablen

Ob es sich um klassenbasierte objektorientierte Programmierung oder die Definition von Variablen innerhalb einer einfachen Funktion handelt, der Umfang von Variablen ist immer ein Zusammenhang, der beim Python-Lernen verstanden und beherrscht werden muss. Beginnen wir mit einer umfassenden Analyse von Python Informationen zum Umfang von Variablen finden Sie unter

Grundlegendes zu globalen Variablen und lokalen Variablen
1 Die Funktion erscheint zum ersten Mal und vor dem =-Symbol kann davon ausgegangen werden, dass sie als lokale Variable definiert ist. In diesem Fall wird die lokale Variable in der Funktion verwendet, unabhängig davon, ob der Variablenname in der globalen Variablen verwendet wird. Beispiel:

  num = 100
  def func():
    num = 123
    print num
  func()

Das Ausgabeergebnis ist 123. Erklären Sie, dass der in der Funktion definierte Variablenname num eine lokale Variable ist und die globale Variable abdeckt. Ein weiteres Beispiel:

  num = 100
  def func():
    num += 100
    print num
  func()

Das Ausgabeergebnis ist: UnboundLocalError: Lokale Variable „num“, auf die vor der Zuweisung verwiesen wurde. Fehlermeldung: Lokale Variable num wird vor der Zuweisung angewendet. Mit anderen Worten: Die Variable wird falsch verwendet, ohne definiert zu sein. Dies beweist einmal mehr, dass es sich hier um eine lokale Variable und nicht um eine globale Variable handelt.

2. Wenn der Variablenname innerhalb der Funktion zum ersten Mal erscheint, nach dem =-Symbol steht und zuvor als globale Variable definiert wurde, wird hier auf die globale Variable verwiesen. Beispiel:

  num = 100
  def func():
    x = num + 100
    print x
  func()

Das Ausgabeergebnis ist 200. Wenn der Variablenname num noch nicht als globale Variable definiert wurde, erscheint eine Fehlermeldung: Die Variable ist nicht definiert. Beispiel:

  def func():
    x = num + 100
    print x
  func()

Das Ausgabeergebnis ist: NameError: globaler Name 'num' ist nicht definiert.

3. Wenn eine Variable in einer Funktion verwendet wird und der Variablenname sowohl globale als auch lokale Variablen enthält, wird standardmäßig die lokale Variable verwendet. Beispiel:

  num = 100
  def func():
    num = 200
    x = num + 100
    prinx x
  func()

Das Ausgabeergebnis ist 300.

4. Wenn Sie eine Variable als globale Variable in einer Funktion definieren, müssen Sie das Schlüsselwort global verwenden. Beispiel:

  num = 100
  def func():
    global num
    num = 200
    print num
  func()
  print num

Die Ausgabeergebnisse sind 200 bzw. 200. Dies zeigt, dass der Variablenname num in der Funktion als globale Variable definiert ist und dem Wert 200 zugewiesen wird. Ein weiteres Beispiel:

  num = 100
  def func():
    global num
    num = 200
    num += 100
    print num
  func()
  print num

Die Ausgabeergebnisse sind 300 bzw. 300.

Basierend auf den obigen Ergebnissen der Anwendungsszenarien globaler Variablen und lokaler Variablen habe ich versucht, die erste Hälfte des Lehrcodes in den Eingabefeldern zu analysieren (Kommentare zum chinesischen Teil):

  # calculator with all buttons

  import simplegui

  # intialize globals
  store = 0
  operand = 0

Das simplegui-Modul wird hier aufgerufen und kann unter http://www.php.cn/ fehlerfrei betrieben werden. Dieses Modul kann jedoch nicht direkt in der Python-Umgebung verwendet werden und das SimpleGUICS2Pygame-Paket muss zuerst installiert werden.

  # event handlers for calculator with a store and operand

  def output():
  """prints contents of store and operand"""
    print "Store = ", store
    print "Operand = ", operand
    print ""

Die globalen Variablen „store“ und „operand“ werden direkt in der definierten Funktion „output()“ verwendet. Sie können auf Punkt 2 verweisen.

  def swap():
  """ swap contents of store and operand"""
    global store, operand
    store, operand = operand, store
    output()

In der definierten Funktion swap() werden zunächst die globalen Variablen von Store und Operand definiert. Wenn Sie dies nicht tun, erscheint eine Fehlermeldung, dass es ohne Zuweisung eines Werts verwendet wird. Sie können sich auf Punkt 1 beziehen. Kann es gleichzeitig so verstanden werden: Wenn in der Funktion swap () kein Schlüsselwort global vorhanden ist, sind Store und Operand lokale Standardvariablen, und es ist falsch, den Teil auf der rechten Seite von = zu verwenden ohne Auftrag. Sie können auf Punkt 3 verweisen.

  def add():
  """ add operand to store"""

    global store
    store = store + operand
    output()

Hier bin ich auf das erste Problem seit dem Studium des zweiwöchigen Kurses gestoßen: Aus diesem Grund definiert die Funktion add() den Speicher nur als globale Variablen. ohne den Operanden auf die gleiche Weise zu definieren. In Kombination mit Punkt 1 liegt dies daran, dass der Speicherung als lokale Variable im Voraus kein Wert zugewiesen wurde und sie nicht direkt verwendet werden kann, während der Operand durch direkten Aufruf der zuvor definierten globalen Variablen verwendet werden kann.

Variablenbereich
Variablenbereich ist ein einfacher Ort, um in Python in eine Falle zu tappen.
Python verfügt über insgesamt 4 Bereiche:

L (Lokaler) lokaler Bereich
E (Einschließend) in einer Funktion außerhalb der Abschlussfunktion
G (Global) globaler Bereich
B (Eingebaut) Der integrierte Bereich
wird gemäß den Regeln von L --> Es wird gesucht. Wenn Sie nach lokalen Teilen außerhalb des lokalen Bereichs suchen (z. B. Schließungen) und diese nicht wiederfinden können, gehen Sie zur globalen Suche und dann zu den integrierten.

Außer def/class/lambda in Python können andere wie: if/elif/else/ try/exclus for/while ihren Gültigkeitsbereich nicht ändern. Auf die darin definierten Variablen kann weiterhin von außen zugegriffen werden.

>>> if True:
...   a = 'I am A'
... 
>>> a
'I am A'

Auf die in der if-Sprache definierte Variable kann weiterhin von außen zugegriffen werden.
Bitte beachten Sie jedoch, dass wenn es von def/class/lambda umschlossen und intern zugewiesen wird, es zum lokalen Gültigkeitsbereich dieser Funktion/Klasse/Lambda wird.
Die Zuweisung innerhalb von def/class/lambda wird zu ihrem lokalen Geltungsbereich. Der lokale Geltungsbereich deckt den globalen Geltungsbereich ab, hat jedoch keinen Einfluss auf den globalen Geltungsbereich.

g = 1 #全局的
def fun():
  g = 2 #局部的
  return g

print fun()
# 结果为2
print g
# 结果为1

Beachten Sie jedoch, dass Sie manchmal innerhalb einer Funktion auf globale Variablen verweisen möchten und Fehler auftreten, wenn Sie dies nicht tun, z :

#file1.py
var = 1
def fun():
  print var
  var = 200
print fun()

#file2.py
var = 1
def fun():
  var = var + 1
  return var
print fun()

这两个函数都会报错UnboundLocalError: local variable 'var' referenced before assignment
在未被赋值之前引用的错误！为什么？因为在函数的内部，解释器探测到var被重新赋值了，所以var成为了局部变量，但是在没有被赋值之前就想使用var，便会出现这个错误。解决的方法是在函数内部添加 globals var 但运行函数后全局的var也会被修改。

闭包Closure
闭包的定义：如果在一个内部函数里，对在外部函数内（但不是在全局作用域）的变量进行引用，那么内部函数就被认为是闭包(closure)

函数嵌套/闭包中的作用域：

a = 1
def external():
  global a
  a = 200
  print a

  b = 100
  def internal():
    # nonlocal b
    print b
    b = 200
    return b

  internal()
  print b

print external()

一样会报错- 引用在赋值之前，Python3有个关键字nonlocal可以解决这个问题，但在Python2中还是不要尝试修改闭包中的变量。 关于闭包中还有一个坑：

from functools import wraps

def wrapper(log):
  def external(F):
    @wraps(F)
    def internal(**kw):
      if False:
        log = 'modified'
      print log
    return internal
  return external

@wrapper('first')
def abc():
  pass

print abc()

也会出现 引用在赋值之前 的错误，原因是解释器探测到了 if False 中的重新赋值，所以不会去闭包的外部函数（Enclosing）中找变量，但 if Flase 不成立没有执行，所以便会出现此错误。除非你还需要else: log='var' 或者 if True 但这样添加逻辑语句就没了意义，所以尽量不要修改闭包中的变量。

好像用常规的方法无法让闭包实现计数器的功能，因为在内部进行 count +=1 便会出现 引用在赋值之前 的错误，解决办法：（或Py3环境下的 nonlocal 关键字）

def counter(start):
    count =[start]
    def internal():
      count[0] += 1
      return count[0]
    return internal

count = counter(0)
for n in range(10):
  print count()
# 1,2,3,4,5,6,7,8,9,10

count = counter(0)
print count()
# 1

由于 list 具有可变性，而字符串是不可变类型。

locals() 和 globals()
globals()
global 和 globals() 是不同的，global 是关键字用来声明一个局部变量为全局变量。globals() 和 locals() 提供了基于字典的访问全局和局部变量的方式

比如：如果函数1内需要定义一个局部变量，名字另一个函数2相同，但又要在函数1内引用这个函数2。

def var():
  pass

def f2():
  var = 'Just a String'
  f1 = globals()['var']
  print var
  return type(f1)

print f2()
# Just a String
# <type &#39;function&#39;>

locals()
如果你使用过Python的Web框架，那么你一定经历过需要把一个视图函数内很多的局部变量传递给模板引擎，然后作用在HTML上。虽然你可以有一些更聪明的做法，还你是仍想一次传递很多变量。先不用了解这些语法是怎么来的，用做什么，只需要大致了解locals()是什么。
可以看到，locals()把局部变量都给打包一起扔去了。

@app.route('/')
def view():
  user = User.query.all()
  article = Article.query.all()
  ip = request.environ.get('HTTP_X_REAL_IP',     request.remote_addr)
  s = 'Just a String'
  return render_template('index.html', user=user,
      article = article, ip=ip, s=s)
  #或者 return render_template('index.html', **locals())

更多从局部变量和全局变量解析Python中变量的作用域相关文章请关注PHP中文网！