Usar variables globales en una función

3443

¿Cómo puedo crear o usar una variable global en una función?

Si creo una variable global en una función, ¿cómo puedo usar esa variable global en otra función? ¿Necesito almacenar la variable global en una variable local de la función que necesita su acceso?

0
4620

Puede usar una variable global dentro de otras funciones declarándola como globaldentro de cada función que le asigna un valor:

globvar = 0

def set_globvar_to_one():
    global globvar    # Needed to modify global copy of globvar
    globvar = 1

def print_globvar():
    print(globvar)     # No need for global declaration to read value of globvar

set_globvar_to_one()
print_globvar()       # Prints 1

Me imagino que la razón de esto es que, dado que las variables globales son tan peligrosas, Python quiere asegurarse de que realmente sepa que es con lo que está jugando al requerir explícitamente la globalpalabra clave.

Vea otras respuestas si desea compartir una variable global entre módulos.

2
  • 935
    Es una exageración extrema referirse a los globales como "tan peligrosos". Los globales están perfectamente bien en todos los idiomas que han existido y existirán. Tienen su lugar. Lo que debería haber dicho es que pueden causar problemas si no tiene idea de cómo programar. Anthony 22/12/12 a las 23:22
  • 231
    Creo que son bastante peligrosos. Sin embargo, en Python, las variables "globales" son en realidad a nivel de módulo, lo que resuelve muchos problemas. Fábio Santos 22/01/2013 a las 15:41
818

Si entiendo su situación correctamente, lo que está viendo es el resultado de cómo Python maneja los espacios de nombres locales (funciones) y globales (módulos).

Digamos que tienes un módulo como este:

# sample.py
myGlobal = 5

def func1():
    myGlobal = 42

def func2():
    print myGlobal

func1()
func2()

Es posible que espere que imprima 42, pero en su lugar imprime 5. Como ya se ha mencionado, si agrega una globaldeclaración ' ' a func1(), func2()imprimirá 42.

def func1():
    global myGlobal
    myGlobal = 42

Lo que sucede aquí es que Python asume que cualquier nombre asignado , en cualquier lugar dentro de una función, es local a esa función a menos que se indique explícitamente lo contrario. Si solo está leyendo un nombre, y el nombre no existe localmente, intentará buscar el nombre en cualquier ámbito que lo contenga (por ejemplo, el ámbito global del módulo).

Cuando asigna 42 al nombre myGlobal, por lo tanto, Python crea una variable local que sombrea la variable global del mismo nombre. Ese local sale del alcance y se recolecta como basura cuando func1()regresa; mientras tanto, func2()nunca puede ver nada más que el nombre global (sin modificar). Tenga en cuenta que esta decisión de espacio de nombres ocurre en tiempo de compilación, no en tiempo de ejecución; si tuviera que leer el valor de myGlobalinside func1()antes de asignarlo, obtendría un UnboundLocalError, porque Python ya ha decidido que debe ser una variable local, pero todavía no ha tenido ningún valor asociado. Pero al usar la globaldeclaración ' ', le dice a Python que debe buscar el nombre en otro lugar en lugar de asignárselo localmente.

(Creo que este comportamiento se originó en gran parte a través de una optimización de los espacios de nombres locales; sin este comportamiento, la máquina virtual de Python necesitaría realizar al menos tres búsquedas de nombres cada vez que se asigna un nuevo nombre dentro de una función (para asegurarse de que el nombre no t ya existe a nivel de módulo / incorporado), lo que ralentizaría significativamente una operación muy común).

4
  • 1
    Mencionaste que la decisión del espacio de nombres ocurre en tiempo de compilación , no creo que sea cierto. por lo que aprendí, la compilación de Python solo verifica el error de sintaxis, no el error de nombre, pruebe este ejemplo def A (): x + = 1 , si no lo ejecuta, no dará UnboundLocalError , verifique graciaswatashiSHUN 12/10/2015 a las 22:36
  • 1
    Es común usar una letra mayúscula para variables globales comoMyGlobal = 5Vassilis 24 de enero de 2018 a las 11:55
  • 3
    @watashiSHUN: La decisión espacio de nombres no sucederá en tiempo de compilación. Decidir que xes local es diferente a verificar en tiempo de ejecución si el nombre local estaba vinculado a un valor antes de que se usara por primera vez. BlackJack 25 de enero de 2018 a las 17:43
  • 12
    @Vassilis: Es común a mayúsculas todas las letras: MY_GLOBAL = 5. Consulte la Guía de estilo para código Python . BlackJack 25 de enero de 2018 a las 17:46
242

Es posible que desee explorar la noción de espacios de nombres . En Python, el módulo es el lugar natural para los datos globales :

Each module has its own private symbol table, which is used as the global symbol table by all functions defined in the module. Thus, the author of a module can use global variables in the module without worrying about accidental clashes with a user’s global variables. On the other hand, if you know what you are doing you can touch a module’s global variables with the same notation used to refer to its functions, modname.itemname.

Aquí se describe un uso específico de global-in-a-module: ¿Cómo comparto variables globales entre módulos? , y para completar los contenidos se comparten aquí:

The canonical way to share information across modules within a single program is to create a special configuration module (often called config or cfg). Just import the configuration module in all modules of your application; the module then becomes available as a global name. Because there is only one instance of each module, any changes made to the module object get reflected everywhere. For example:

File: config.py

x = 0   # Default value of the 'x' configuration setting

File: mod.py

import config
config.x = 1

File: main.py

import config
import mod
print config.x
3
  • 1
    por una razón que no me gusta, config.x ¿puedo deshacerme de él? Vine con x = lambda: config.xy luego tengo el nuevo valor x(). por alguna razón, tener a = config.xno me sirve. vladosaurus 2 de enero de 2018 a las 14:56
  • 4
    ¿@vladosaurus from config import xresuelve eso? jhylands 7 dic 2018 a las 12:15
  • @vladosaurus usofrom config import xPsychzander 7 ago.20 a las 11:03
101

Python usa una heurística simple para decidir desde qué ámbito debe cargar una variable, entre local y global. Si el nombre de una variable aparece en el lado izquierdo de una asignación, pero no se declara global, se asume que es local. Si no aparece en el lado izquierdo de una asignación, se supone que es global.

>>> import dis
>>> def foo():
...     global bar
...     baz = 5
...     print bar
...     print baz
...     print quux
... 
>>> dis.disassemble(foo.func_code)
  3           0 LOAD_CONST               1 (5)
              3 STORE_FAST               0 (baz)

  4           6 LOAD_GLOBAL              0 (bar)
              9 PRINT_ITEM          
             10 PRINT_NEWLINE       

  5          11 LOAD_FAST                0 (baz)
             14 PRINT_ITEM          
             15 PRINT_NEWLINE       

  6          16 LOAD_GLOBAL              1 (quux)
             19 PRINT_ITEM          
             20 PRINT_NEWLINE       
             21 LOAD_CONST               0 (None)
             24 RETURN_VALUE        
>>> 

Vea cómo baz, que aparece en el lado izquierdo de una asignación en foo(), es la única LOAD_FASTvariable.

3
  • 12
    La heurística busca operaciones vinculantes . La asignación es una de esas operaciones, la importación de otra. Pero el destino de un forbucle y el nombre después de asin withy excepttambién están vinculados a. Martijn Pieters 8 de agosto de 2015 a las 23:56
  • @MartijnPieters Para el nombre after asen una exceptcláusula, esto no fue obvio para mí. Pero se borra automáticamente para ahorrar memoria. Robert 7 feb.20 a las 11:17
  • 2
    @Robert: no para ahorrar memoria, sino para evitar crear una referencia circular, que puede provocar pérdidas de memoria. Esto se debe a que una excepción hace referencia a un rastreo, y el rastreo hace referencia a cada espacio de nombres local y global a lo largo de toda la pila de llamadas, incluido el as ...destino en el controlador de excepciones. Martijn Pieters 7 feb.20 a las 11:27
67

Si desea hacer referencia a una variable global en una función, puede utilizar la palabra clave global para declarar qué variables son globales. No tiene que usarlo en todos los casos (como alguien aquí afirma incorrectamente): si el nombre al que se hace referencia en una expresión no se puede encontrar en el alcance local o en los alcances en las funciones en las que se define esta función, se busca entre globales variables.

Sin embargo, si asigna a una nueva variable no declarada como global en la función, se declara implícitamente como local y puede eclipsar cualquier variable global existente con el mismo nombre.

Además, las variables globales son útiles, al contrario de algunos fanáticos de la programación orientada a objetos que afirman lo contrario, especialmente para scripts más pequeños, donde la programación orientada a objetos es excesiva.

1
  • Absolutamente re. fanáticos. La mayoría de los usuarios de Python lo utilizan para la creación de scripts y crean pequeñas funciones para separar pequeños fragmentos de código. Paul Uszak 22/09/19 a las 22:57
60

If I create a global variable in one function, how can I use that variable in another function?

Podemos crear un global con la siguiente función:

def create_global_variable():
    global global_variable # must declare it to be a global first
    # modifications are thus reflected on the module's global scope
    global_variable = 'Foo' 

Escribir una función en realidad no ejecuta su código. Entonces llamamos a la create_global_variablefunción:

>>> create_global_variable()

Usar globales sin modificación

Puede usarlo, siempre que no espere cambiar a qué objeto apunta:

Por ejemplo,

def use_global_variable():
    return global_variable + '!!!'

y ahora podemos usar la variable global:

>>> use_global_variable()
'Foo!!!'

Modificación de la variable global desde dentro de una función

Para apuntar la variable global a un objeto diferente, debe usar la palabra clave global nuevamente:

def change_global_variable():
    global global_variable
    global_variable = 'Bar'

Tenga en cuenta que después de escribir esta función, el código que realmente lo cambia aún no se ha ejecutado:

>>> use_global_variable()
'Foo!!!'

Entonces, después de llamar a la función:

>>> change_global_variable()

podemos ver que se ha cambiado la variable global. El global_variablenombre ahora apunta a 'Bar':

>>> use_global_variable()
'Bar!!!'

Tenga en cuenta que "global" en Python no es verdaderamente global, solo es global a nivel de módulo. Por lo tanto, solo está disponible para funciones escritas en los módulos en los que es global. Las funciones recuerdan el módulo en el que están escritas, por lo que cuando se exportan a otros módulos, aún buscan en el módulo en el que fueron creadas para encontrar variables globales.

Variables locales con el mismo nombre

Si crea una variable local con el mismo nombre, eclipsará una variable global:

def use_local_with_same_name_as_global():
    # bad name for a local variable, though.
    global_variable = 'Baz' 
    return global_variable + '!!!'

>>> use_local_with_same_name_as_global()
'Baz!!!'

Pero el uso de esa variable local mal nombrada no cambia la variable global:

>>> use_global_variable()
'Bar!!!'

Tenga en cuenta que debe evitar el uso de variables locales con los mismos nombres que globales a menos que sepa exactamente lo que está haciendo y tenga una muy buena razón para hacerlo. Todavía no he encontrado tal razón.

Obtenemos el mismo comportamiento en las clases.

Un comentario de seguimiento pregunta:

what to do if I want to create a global variable inside a function inside a class and want to use that variable inside another function inside another class?

Aquí demuestro que obtenemos el mismo comportamiento en los métodos que en las funciones regulares:

class Foo:
    def foo(self):
        global global_variable
        global_variable = 'Foo'

class Bar:
    def bar(self):
        return global_variable + '!!!'

Foo().foo()

Y ahora:

>>> Bar().bar()
'Foo!!!'

Pero sugeriría que en lugar de usar variables globales, use atributos de clase, para evitar abarrotar el espacio de nombres del módulo. También tenga en cuenta que no usamos selfargumentos aquí; estos podrían ser métodos de clase (útiles si se muda el atributo de clase del clsargumento habitual ) o métodos estáticos (no selfo cls).

3
  • Genial, pero ¿qué hacer si quiero crear una variable global dentro de una función dentro de una clase y quiero usar esa variable dentro de otra función dentro de otra clase? Un poco atrapado aquífpaekoaij 19/01/20 a las 14:29
  • 2
    @anonmanx No sé por qué estás atascado, es el mismo comportamiento en un método que en una función normal. Pero actualizaré mi respuesta con su comentario y algún código de demostración, ¿de acuerdo? Aaron Hall 19/01/20 a las 14:33
  • Ok, lo tengo. Entonces tendré que llamar explícitamente a esa función para usar esa variable global. fpaekoaij 19/01/20 a las 14:44
52

Además de las respuestas ya existentes y para hacer esto más confuso:

In Python, variables that are only referenced inside a function are implicitly global. If a variable is assigned a new value anywhere within the function’s body, it’s assumed to be a local. If a variable is ever assigned a new value inside the function, the variable is implicitly local, and you need to explicitly declare it as ‘global’.

Though a bit surprising at first, a moment’s consideration explains this. On one hand, requiring global for assigned variables provides a bar against unintended side-effects. On the other hand, if global was required for all global references, you’d be using global all the time. You’d have to declare as global every reference to a built-in function or to a component of an imported module. This clutter would defeat the usefulness of the global declaration for identifying side-effects.

Fuente: ¿Cuáles son las reglas para las variables locales y globales en Python? .

38

Con la ejecución en paralelo, las variables globales pueden causar resultados inesperados si no comprende lo que está sucediendo. A continuación, se muestra un ejemplo del uso de una variable global dentro del multiprocesamiento. Podemos ver claramente que cada proceso trabaja con su propia copia de la variable:

import multiprocessing
import os
import random
import sys
import time

def worker(new_value):
    old_value = get_value()
    set_value(random.randint(1, 99))
    print('pid=[{pid}] '
          'old_value=[{old_value:2}] '
          'new_value=[{new_value:2}] '
          'get_value=[{get_value:2}]'.format(
          pid=str(os.getpid()),
          old_value=old_value,
          new_value=new_value,
          get_value=get_value()))

def get_value():
    global global_variable
    return global_variable

def set_value(new_value):
    global global_variable
    global_variable = new_value

global_variable = -1

print('before set_value(), get_value() = [%s]' % get_value())
set_value(new_value=-2)
print('after  set_value(), get_value() = [%s]' % get_value())

processPool = multiprocessing.Pool(processes=5)
processPool.map(func=worker, iterable=range(15))

Producción:

before set_value(), get_value() = [-1]
after  set_value(), get_value() = [-2]
pid=[53970] old_value=[-2] new_value=[ 0] get_value=[23]
pid=[53971] old_value=[-2] new_value=[ 1] get_value=[42]
pid=[53970] old_value=[23] new_value=[ 4] get_value=[50]
pid=[53970] old_value=[50] new_value=[ 6] get_value=[14]
pid=[53971] old_value=[42] new_value=[ 5] get_value=[31]
pid=[53972] old_value=[-2] new_value=[ 2] get_value=[44]
pid=[53973] old_value=[-2] new_value=[ 3] get_value=[94]
pid=[53970] old_value=[14] new_value=[ 7] get_value=[21]
pid=[53971] old_value=[31] new_value=[ 8] get_value=[34]
pid=[53972] old_value=[44] new_value=[ 9] get_value=[59]
pid=[53973] old_value=[94] new_value=[10] get_value=[87]
pid=[53970] old_value=[21] new_value=[11] get_value=[21]
pid=[53971] old_value=[34] new_value=[12] get_value=[82]
pid=[53972] old_value=[59] new_value=[13] get_value=[ 4]
pid=[53973] old_value=[87] new_value=[14] get_value=[70]
30

Resulta que la respuesta es siempre simple.

Aquí hay un pequeño módulo de muestra con una forma sencilla de mostrarlo en una maindefinición:

def five(enterAnumber,sumation):
    global helper
    helper  = enterAnumber + sumation

def isTheNumber():
    return helper

A continuación se explica cómo mostrarlo en una maindefinición:

import TestPy

def main():
    atest  = TestPy
    atest.five(5,8)
    print(atest.isTheNumber())

if __name__ == '__main__':
    main()

Este código simple funciona así y se ejecutará. Espero que ayude.

3
  • 1
    gracias, soy nuevo en Python, pero sé un poco de Java. lo que dijiste funcionó para mí. y escribir global a <ENTER> dentro de la clase ... parece tener más sentido para mí que escribir 'global a' dentro de una función ... Me doy cuenta de que no se puede decir global a = 4barlop 19/10/2013 a las 18:55
  • 2
    Este es probablemente el truco de Python más simple pero muy útil para mí. Pongo nombre a este módulo global_varse inicializo los datos init_global_varsque se llaman en el script de inicio. Luego, simplemente creo un método de acceso para cada var global definida. ¡Espero poder votar a favor de esto varias veces! ¡Gracias Peter! swdev 18 de septiembre de 2014 a las 2:32
  • 1
    ¿Qué pasa si hay muchas variables globales y no quiero tener que listarlas una por una después de una declaración global? jtlz2 10/04/2015 a las 10:36
30

Lo que está diciendo es usar el método de esta manera:

globvar = 5

def f():
    var = globvar
    print(var)

f()  # Prints 5

Pero la mejor manera es usar la variable global de esta manera:

globvar = 5
def f():
    global globvar
    print(globvar)
f()   #prints 5

Ambos dan el mismo resultado.

2
  • Este segundo ejemplo me da "NameError: el nombre 'globvar' no está definido" en Python3.7Pim Heijden 28 sep.20 a las 17:45
  • Pim: debería funcionar ahora, error tipográfico fijo: s / globavar / globvar /D McKeon 30 nov.20 a las 21:56
27

Debe hacer referencia a la variable global en cada función que desee utilizar.

Como sigue:

var = "test"

def printGlobalText():
    global var #wWe are telling to explicitly use the global version
    var = "global from printGlobalText fun."
    print "var from printGlobalText: " + var

def printLocalText():
    #We are NOT telling to explicitly use the global version, so we are creating a local variable
    var = "local version from printLocalText fun"
    print "var from printLocalText: " + var

printGlobalText()
printLocalText()
"""
Output Result:
var from printGlobalText: global from printGlobalText fun.
var from printLocalText: local version from printLocalText
[Finished in 0.1s]
"""
1
  • 4
    'en cada función que desea usar' es sutilmente incorrecto, debería estar más cerca de: 'en cada función donde desea actualizar 'spazm 19 de marzo de 2015 a las 23:43
24

En realidad, no está almacenando el global en una variable local, solo está creando una referencia local al mismo objeto al que se refiere su referencia global original. Recuerde que prácticamente todo en Python es un nombre que se refiere a un objeto, y nada se copia en la operación habitual.

Si no tuviera que especificar explícitamente cuándo un identificador debía hacer referencia a un global predefinido, entonces presumiblemente tendría que especificar explícitamente cuándo un identificador es una nueva variable local en su lugar (por ejemplo, con algo como el comando 'var' visto en JavaScript). Dado que las variables locales son más comunes que las variables globales en cualquier sistema serio y no trivial, el sistema de Python tiene más sentido en la mayoría de los casos.

Usted podría tener un lenguaje que trataba de adivinar, utilizando una variable global si existía o crear una variable local si no lo hizo. Sin embargo, eso sería muy propenso a errores. Por ejemplo, importar otro módulo podría introducir inadvertidamente una variable global con ese nombre, cambiando el comportamiento de su programa.

24

Prueba esto:

def x1():
    global x
    x += 1
    print('x1: ', x)

def x2():
    global x
    x = x+1
    print('x2: ', x)

x = 5
print('x:  ', x)
x1()
x2()

# Output:
# x:   5
# x1:  6
# x2:  7
1
  • ¡Felicidades! Finalmente alguien que obtuvo el punto más importante de usar global. Es decir, usar una variable en una función que se definió después de la función en sí. not2qubit 27 nov.20 a las 17:36
19

En caso de que tenga una variable local con el mismo nombre, es posible que desee utilizar la globals()función .

globals()['your_global_var'] = 42
17

A continuación y como complemento, use un archivo para contener todas las variables globales, todas declaradas localmente y luego import as:

Archivo initval.py :

Stocksin = 300
Prices = []

Archivo getstocks.py :

import initval as iv

def getmystocks(): 
    iv.Stocksin = getstockcount()


def getmycharts():
    for ic in range(iv.Stocksin):
2
  • 1
    ¿Cuál es la ventaja de mover las variables globales a otro archivo? ¿Es solo para agrupar las variables globales en un archivo pequeño? ¿Y por qué usar la declaración import ... as ...? ¿Por qué no solo import ...? oHo 23 de mayo de 2017 a las 20:21
  • 1
    Ah ... finalmente he entendido la ventaja: No es necesario usar la palabra clave global:-) => +1 :-) Edite su respuesta para aclarar estos interrogatorios que otras personas también pueden tener. SaludosoHo 23 de mayo de 2017 a las 20:31
15

Escribir en elementos explícitos de una matriz global aparentemente no necesita la declaración global, aunque escribir en ella "al por mayor" sí tiene ese requisito:

import numpy as np

hostValue = 3.14159
hostArray = np.array([2., 3.])
hostMatrix = np.array([[1.0, 0.0],[ 0.0, 1.0]])

def func1():
    global hostValue    # mandatory, else local.
    hostValue = 2.0

def func2():
    global hostValue    # mandatory, else UnboundLocalError.
    hostValue += 1.0

def func3():
    global hostArray    # mandatory, else local.
    hostArray = np.array([14., 15.])

def func4():            # no need for globals
    hostArray[0] = 123.4

def func5():            # no need for globals
    hostArray[1] += 1.0

def func6():            # no need for globals
    hostMatrix[1][1] = 12.

def func7():            # no need for globals
    hostMatrix[0][0] += 0.33

func1()
print "After func1(), hostValue = ", hostValue
func2()
print "After func2(), hostValue = ", hostValue
func3()
print "After func3(), hostArray = ", hostArray
func4()
print "After func4(), hostArray = ", hostArray
func5()
print "After func5(), hostArray = ", hostArray
func6()
print "After func6(), hostMatrix = \n", hostMatrix
func7()
print "After func7(), hostMatrix = \n", hostMatrix
8

Haga referencia al espacio de nombres de la clase donde desea que aparezca el cambio.

En este ejemplo, el corredor está usando max del archivo config. Quiero que mi prueba cambie el valor de max cuando el corredor lo esté usando.

main / config.py

max = 15000

main / runner.py

from main import config
def check_threads():
    return max < thread_count 

tests / runner_test.py

from main import runner                # <----- 1. add file
from main.runner import check_threads
class RunnerTest(unittest):
   def test_threads(self):
       runner.max = 0                  # <----- 2. set global 
       check_threads()
8

Estoy agregando esto porque no lo he visto en ninguna de las otras respuestas y podría ser útil para alguien que tenga problemas con algo similar. La globals()función devuelve un diccionario de símbolos global mutable donde puede "mágicamente" hacer que los datos estén disponibles para el resto de su código. Por ejemplo:

from pickle import load
def loaditem(name):
    with open(r"C:\pickle\file\location"+"\{}.dat".format(name), "rb") as openfile:
        globals()[name] = load(openfile)
    return True

y

from pickle import dump
def dumpfile(name):
    with open(name+".dat", "wb") as outfile:
        dump(globals()[name], outfile)
    return True

Le permitirá volcar / cargar variables fuera y dentro del espacio de nombres global. Súper conveniente, sin despeinarse, sin problemas. Estoy bastante seguro de que es solo Python 3.

1
  • 3
    globals()siempre devuelve globales disponibles en el contexto local, por lo que una mutación aquí puede no reflejarse en otro módulo. Kiran Jonnalagadda 8 de mayo de 2019 a las 4:53
5

Los globales están bien, excepto con multiprocesamiento

Los aspectos globales relacionados con el multiprocesamiento en diferentes plataformas / entornos como Windows / Mac OS por un lado y Linux por el otro son problemáticos.

Les mostraré esto con un ejemplo simple que señala un problema con el que me encontré hace algún tiempo.

Si desea comprender por qué las cosas son diferentes en Windows / MacOs y Linux, debe saber eso, el mecanismo predeterminado para iniciar un nuevo proceso en ...

  • Windows / MacOs es 'spawn'
  • Linux es 'bifurcación'

Son diferentes en la asignación de memoria y la inicialización ... (pero no entro en esto aquí).

Echemos un vistazo al problema / ejemplo ...

import multiprocessing

counter = 0

def do(task_id):
    global counter
    counter +=1
    print(f'task {task_id}: counter = {counter}')

if __name__ == '__main__':

    pool = multiprocessing.Pool(processes=4)
    task_ids = list(range(4))
    pool.map(do, task_ids)

Ventanas

Si ejecuta esto en Windows (y supongo que también en MacOS), obtendrá el siguiente resultado ...

task 0: counter = 1
task 1: counter = 2
task 2: counter = 3
task 3: counter = 4

Linux

Si ejecuta esto en Linux, obtendrá lo siguiente.

task 0: counter = 1
task 1: counter = 1
task 2: counter = 1
task 3: counter = 1
3

Hay 2 formas de declarar una variable como global:

1. Asignar variables dentro de funciones y usar línea global

def declare_a_global_variable():
    global global_variable_1
    global_variable_1 = 1

# Note to use the function to global variables
declare_a_global_variable() 

2. Asignar funciones externas variables:

global_variable_2 = 2

Ahora podemos usar estas variables globales declaradas en las otras funciones:

def declare_a_global_variable():
    global global_variable_1
    global_variable_1 = 1

# Note to use the function to global variables
declare_a_global_variable() 
global_variable_2 = 2

def print_variables():
    print(global_variable_1)
    print(global_variable_2)
print_variables() # prints 1 & 2

Nota 1:

Si desea cambiar una variable global dentro de otra función update_variables(), debe usar la línea global en esa función antes de asignar la variable:

global_variable_1 = 1
global_variable_2 = 2

def update_variables():
    global global_variable_1
    global_variable_1 = 11
    global_variable_2 = 12 # will update just locally for this function

update_variables()
print(global_variable_1) # prints 11
print(global_variable_2) # prints 2

Nota 2:

Hay una excepción para la nota 1 para las variables de lista y diccionario cuando no se usa una línea global dentro de una función:

# declaring some global variables
variable = 'peter'
list_variable_1 = ['a','b']
list_variable_2 = ['c','d']

def update_global_variables():
    """without using global line"""
    variable = 'PETER' # won't update in global scope
    list_variable_1 = ['A','B'] # won't update in global scope
    list_variable_2[0] = 'C' # updated in global scope surprisingly this way
    list_variable_2[1] = 'D' # updated in global scope surprisingly this way

update_global_variables()

print('variable is: %s'%variable) # prints peter
print('list_variable_1 is: %s'%list_variable_1) # prints ['a', 'b']
print('list_variable_2 is: %s'%list_variable_2) # prints ['C', 'D']
2

Aunque esto ha sido respondido, estoy dando una solución nuevamente ya que prefiero una sola línea Esto es si desea crear una variable global dentro de la función

def someFunc():
    x=20
    globals()['y']=50
someFunc() # invoking function so that variable Y is created globally 
print(y) # output 50
print(x) #NameError: name 'x' is not defined as x was defined locally within function