Python – ¿Qué prioridad tiene global?

Estoy un poco confundido acerca de los globales cuando se trata de paquetes que usan otros paquetes. De una búsqueda rápida en google; No hay mucho que explique.

En pocas palabras: ¿a qué nivel se “globaliza” una variable cuando se usa global ? ¿Está en el nivel de módulo, nivel de paquete o nivel de intérprete? Es decir, en una configuración como esta:

  |- __init__.py |- Module.py |- Module2.py 

y hay una statement global utilizada en Module.py, es la variable globalizada solo para ese módulo, o el paquete completo (incluyendo Module2.py y __init__.py), o en el nivel de interperter (para cualquier cosa que se ejecute en el intérprete ).

Además, si en __init__.py I from .Module import * , ¿las funciones importadas que contienen una statement global “globalizarán correctamente” alguna de dichas variables para ese archivo?

    ¿Qué tan globales son las variables globales?

    Las llamadas variables “globales” en Python son realmente a nivel de módulo. En realidad, hay globales globales que viven en el módulo __builtin__ en Python 2 o builtins en Python 3, pero no debes tocarlos. (Además, tenga en cuenta que la presencia o la falta de un s . __builtins__ es su propia cosa rara.)

    ¿Qué hace la statement global ?

    La statement global significa que, solo para la función en la que aparece , el nombre o los nombres de las variables especificadas se refieren a la (s) variable (s) “global” (nivel de módulo), en lugar de a las variables locales.

    ¿Qué pasa con la import * ?

    Oh dios, no hagas eso. Los globales son lo suficientemente malos, pero importarlos es peor, y hacerlo con import * es casi la peor forma en que puedes hacerlo. Lo que hace el sistema de importación con variables globales es horriblemente sorprendente para los nuevos progtwigdores y casi nunca para lo que usted quiere.

    Cuando import * , eso no significa que su módulo comience a buscar en las variables globales del módulo importado para buscar variables. Significa que Python busca en el módulo importado, encuentra sus variables globales “públicas” *, y asigna sus valores actuales a nuevas variables globales con nombres idénticos en el módulo actual.

    Eso significa que cualquier asignación a sus nuevas variables globales no afectará a los originales, y cualquier asignación a los originales no afectará a sus nuevas variables. Todas las funciones que importó con import * siguen mirando las variables originales, por lo que no verán los cambios que realice en sus copias, y no verá los cambios que hagan en las suyas. Los resultados son un lío confuso.

    En serio, si es absolutamente necesario utilizar las variables globales de otro módulo, impórtelo con la syntax de import othermodule y acceda a las othermodule.whatever_global globales con othermodule.whatever_global .


    * Si el módulo define una lista __all__ , los globales “públicos” son las variables cuyos nombres aparecen en esa lista. De lo contrario, son las variables cuyos nombres no comienzan con un guión bajo. def funciones definidas se almacenan en variables ordinarias, por lo que se incluyen bajo los mismos criterios que otras variables.