Umfassende Analyse des Variablenumfangs in Python, beginnend mit lokalen Variablen und globalen 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. Zum 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 Variablen 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 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

Mit dem simplegui-Modul kann es unter http://www.codeskulptor.org/ 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 ""

verwendet direkt den globalen Variablenspeicher und Operanden in der definierten Funktion „output()“. 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: Deshalb definiert die Funktion add() nur den Speicher als globale Variable und definiert den Operanden nicht auf die gleiche Weise. 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'

Die in der if-Sprache definierte Variable a ist weiterhin von außen zugänglich.
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 auf globale Variablen innerhalb einer Funktion verweisen möchten und Fehler auftreten, wenn Sie dies nicht tun. Zum Beispiel:

#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()

Beide Funktionen melden den Fehler UnboundLocalError: Auf die lokale Variable „var“ wurde vor der Zuweisung verwiesen
Fehler beim Verweisen vor der Zuweisung! Warum? Denn innerhalb der Funktion erkennt der Interpreter, dass var neu zugewiesen wurde, sodass var zu einer lokalen Variablen wird. Wenn Sie var jedoch verwenden möchten, bevor es zugewiesen wurde, tritt dieser Fehler auf. Die Lösung besteht darin, eine globale Variable innerhalb der Funktion hinzuzufügen. Die globale Variable wird jedoch auch nach dem Ausführen der Funktion geändert.

闭包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())

Das obige ist der detaillierte Inhalt vonUmfassende Analyse des Variablenumfangs in Python, beginnend mit lokalen Variablen und globalen Variablen. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!