python学习笔记——命名空间、__all__变量与__init__.py文件

已于 2023-09-24 21:51:02 修改
阅读量975 收藏
点赞数
分类专栏： python学习笔记 文章标签： python pycharm 开发语言
于 2021-12-25 15:48:54 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/phily123/article/details/122144363
版权

一、命名空间

https://blog.csdn.net/yuelai_217/article/details/123110259
https://www.php.cn/faq/556852.html

1、概念

Python在代码执行时会维护一个常量、变量、函数等命名的环境。这个环境就是命名空间(Namespace)，也可以称作名称空间。命名空间是一个存储名称与对象对应关系的字典(dictionary)，是从名称到对象的映射，其中名称就是指标识符(identifier)，对象就是指一切对象，Python中的一切都是对象，包括整数、浮点数、字符串、函数、类等。。大部分的命名空间都是通过字典来实现的，它的键就是变量名，它的值就是那些变量的值。

命名空间提供了在项目中避免名字冲突的一种方法。各个命名空间是独立的，没有任何关系的，所以一个命名空间中不能有重名，但不同的命名空间是可以重名而没有任何影响。

2、命名空间分类

Python中的命名空间可以分为三种类型：
（1）内置命名空间(Built-in Namespace)
内置命名空间是Python 语言内置的名称，Python解释器启动时就加载了的命名空间。内置命名空间中默认包含了一些函数和变量，比如函数名 abs、char 、print()、type()、str()和BaseException、Exception 等，开发人员可以直接使用。内置命名空间也可以通过 builtins 模块来访问。

（2）全局命名空间(Global Namespace)
全局命名空间是指在模块中定义的名称，而不是在函数或类中定义的，记录了模块的变量，包括函数、类、其它导入的模块、模块级的变量和常量。在一个模块中定义的全局变量在其他模块中也可以被访问。一个模块只有一个全局命名空间，模块中的所有函数都可以访问这个命名空间。

（3）局部命名空间(Local Namespace)
局部命名空间是函数中定义的名称，在函数调用时创建的命名空间，记录了函数的变量，包括函数的参数和局部定义的变量。（类中定义的也是）。函数结束调用时，局部命名空间也会被销毁。

3、通过globals()和locals()函数获取命名空间

Python中可以使用globals()和locals()两个函数来获取对应的全局命名空间和局部命名空间。globals()函数返回全局命名空间的字典也可以通过当前模块中的任一模块的函数的__globals__访问，locals()函数返回局部命名空间的字典，内置命名空间可以通过全局命名空间中的键__bulitins__来访问。

4、命名空间查找规则

当使用一个变量时，Python会先在局部命名空间中查找对应的变量，如果查到，Python 将使用它，然后停止搜索。如果没有找到，就会到全局命名空间中查找，最后再到内置命名空间中查找。换句话说，Python查找变量时是按照局部、全局、内置的顺序进行的，这种查找变量的顺序被称为LEGB规则。如果这些名字空间找不到 x，它将放弃查找并引发一个 NameError 异常，如，NameError: name ‘aa’ is not defined。
对于闭包来说，这里有一点区别，如果在local namespace中找不到变量的话，还会去父函数的local namespace中找变量。

5、命名空间的作用域和生存周期

在Python中，每个函数、模块、类都有自己的命名空间。当一个名称被绑定到一个对象时，它只在该命名空间中有意义。如果名称被绑定到一个局部命名空间中，它就只在该函数中有意义；如果名称被绑定到全局命名空间中，它在该模块中就有意义；如果名称被绑定到内置命名空间中，它就在整个Python解释器中都有意义。
（1）

b = 3
def func():
    b = 2
    print(b)
func()
print(b)


2
3

（2）

b = 3
def func():
    global b
    b = 2
    print(b)
func()
print(b)


2
2

（3）

def func():
    b = 2
    print(b)
func()
print(b)

2
Traceback (most recent call last):
  File "D:/DL/yolov5/test/z.py", line 5, in <module>
    print(b)
NameError: name 'b' is not defined

（4）

def func():
    global b
    b = 2
    print(b)
func()
print(b)

2
2

（5）当前的函数用global之后，b变量就被加到了globals里面

def func():
    global b
    b = 2
    print(b)
    print(func.__globals__)
print(globals())
func()
print(b)
print(globals())

{'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x000001CC9627FCC8>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, '__file__': 'D:/DL/yolov5/test/z.py', '__cached__': None, 'func': <function func at 0x000001CC962D8168>}
2
{'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x000001CC9627FCC8>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, '__file__': 'D:/DL/yolov5/test/z.py', '__cached__': None, 'func': <function func at 0x000001CC962D8168>, 'b': 2}
2
{'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x000001CC9627FCC8>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, '__file__': 'D:/DL/yolov5/test/z.py', '__cached__': None, 'func': <function func at 0x000001CC962D8168>, 'b': 2}

(6)

def out():
    ## global关键字作用
    global en
    en = 1
    other()
    print(out.__globals__['en'])
    ## 调用other可以打印en

def other():
    print(en)
def b():
    ## globals里面没有en那个全局变量
    out()
    print(b.__globals__['en'])

b()


1
1
1

（7）

# a.py
def out():
    ## global关键字作用
    global en
    en = 1
    other()
    print(out.__globals__['en'])
    ## 调用other可以打印en

def other():
    print(en)

#############上面是a文件，下面是b文件#############

# b.py
from a import out

def b():
    ## globals里面没有en那个全局变量
    out()
    print(b.__globals__['en'])

b()

KeyError: 'en'
1
1

（8）

# a.py
def out():
    ## global关键字作用
    global en
    en = 1
    # other()
    # print(out.__globals__['en'])
    ## 调用other可以打印en
 
# def other():
#     print(en)
 
# b.py
from a import *
##  b 文件没执行过a文件的out函数，也就是global还没定义
# print('这个是out的：',out.__globals__['en'])    # KeyError: 'en'
def b():
    ## 执行out，global被定义
    out()
    ## 打印out函数的globals
    print('这个是out的：',out.__globals__['en'])
    ## 打印b函数的globals
    # print('这个是b的：',b.__globals__['en'])    # KeyError: 'en'
b()
print('这里是分割线'.center(150,'-'))
## out函数执行过后，global已经被定义
print('这个是out的：',out.__globals__['en'])
# print(b.__globals__['en'])        # KeyError: 'en'

这个是out的： 1
------------------------------------------------------------------------这里是分割线------------------------------------------------------------------------
这个是out的： 1

不同的命名空间在不同的时刻创建，有不同的生存期。
1、内置命名空间在 Python 解释器启动时创建，会一直保留，不被删除。
2、模块的全局命名空间在模块定义被读入时创建，通常模块命名空间也会一直保存到解释器退出。
3、当函数被调用时创建一个局部命名空间，当函数返回结果或抛出异常时被删除。每一个递归调用的函数都拥有自己的命名空间。

Python 的一个特别之处在于其赋值操作总是在最里层的作用域。赋值不会复制数据，只是将命名绑定到对象。删除也是如此：“del y” 只是从局部作用域的命名空间中删除命名 y 。事实上，所有引入新命名的操作都作用于局部作用域。

i=1
def func2():
    i=i+1
 
func2();
#错误：UnboundLocalError: local variable 'i' referenced before assignment

由于创建命名空间时，python会检查代码并填充局部命名空间。在python运行那行代码之前，就发现了对i的赋值，并把它添加到局部命名空间中。当函数执行时，python解释器认为i在局部命名空间中但没有值，所以会产生错误。

def func3():
　　y=123
　　del y
　　print(y)

func3()
#错误：UnboundLocalError: local variable 'y' referenced before assignment
#去掉"del y"语句后，运行正常

6、from module import 和 import module

（1）使用 import module时，module 本身被引入，但是保存它原有的命名空间，所以我们需要使用 module.name 这种方式访问它的函数和变量。from module import这种方式，是将其它模块的函数或者变量引到当前的命名空间中，所以就不需要使用 module.name 这种方式访问其它的模块的方法了。但是注意使用global命名的全局变量在导入其他模块时不会被导入当前模块的命名空间。

# c文件
f = 1
def out():
    ## global关键字作用
    global en
    en = 1
    other()
    print(out.__globals__['en'])


def other():
     print(en)

if __name__ == '__main__':
    out()

#d文件
import c
def b():

    c.out()
    aa = c.out.__globals__
    bb = b.__globals__
    print(aa)
    print(bb)

b()

在这里插入图片描述
在这里插入图片描述

# c文件
f = 1
def out():
    ## global关键字作用
    global en
    en = 1
    other()
    print(out.__globals__['en'])


def other():
     print(en)

if __name__ == '__main__':
    out()

# d文件
from c import out
#import c
def b():

    out()
    aa = out.__globals__
    bb = b.__globals__
    print(aa)
    print(bb)

b()

在这里插入图片描述

# d文件
from c import *
#import c
def b():

    out()
    aa = out.__globals__
    bb = b.__globals__
    print(aa)
    print(bb)

b()

在这里插入图片描述
（2）python中的module也是对象，所有的modules都有一个内置的属性__name__，模块的__name__属性的值取决于如何使用这个模块，如果import module，那么__name__属性的值是模块的名字。如果直接执行这个模块的话，那么__name__属性的值就是默认值__main__。
在这里插入图片描述
在这里插入图片描述

7、命名空间的注意点

（1）命名空间中的名称必须是合法的标识符。
（2）函数和类就是创建一个新的命名空间。
（3）变量名可以在命名空间中重新绑定到其他对象上。
（4）使用global语句可以让函数内部的变量引用全局变量。
（5）使用nonlocal语句可以让函数内部的变量引用外层函数的局部变量。
（6）Python中名称空间的查找是按照LEGB规则进行查找的。

二、all

当使用from module import *时，会将非下划线开头的成员都导入当前命名空间中，这样可能弄脏当前命名空间。如果显式声明了 all，import * 就只会导入 all 列出的成员。如果 all 定义有误，列出的成员不存在，还会抛出异常。当使用import module或者from module import 时与__all__变量无关。

三、init.py

导入模块就是在导入模块的位置将模块（.py)文件拷贝过去

python中的__init__.py文件用来区分一文件夹是包还是普通文件夹，所以导入一个包时，这个包内一定要有__init__.py文件（必须是其目录的子文件）。（新版本的python不管有没有_init__.py文件都是包）

当包有__init__.py文件时，不管用哪种导入模块的方式都会先执行__init__.py文件，我们可以借助__init__.py文件导入我们所需的其他模块（当其他模块也是其包的子文件时可以使用from .module import 实现自动子模块导入）。

# a文件夹下有a_a文件
def a_A():
    print('this is a_A')
print('this is a_a')
# a文件夹下有a_b文件
def a_B():
    print('this is a_B')
print('this is a_b')
# __init__文件
print('this is __init__')

# b文件
from a import a_a

执行b文件，结果：

this is __init__
this is a_a
# 可以看出先执行了__init__文件，然后再执行了a_a文件。

当没有__init__文件时，执行b文件，结果：

this is a_a
# 可以看出依然识别出a是一个模块

# b文件
import a
#当b文件使用import 导入时，有__init__文件

执行b文件，结果：

this is __init__
# 可以看出使用import导入模块时，只会执行__init__.py文件

# b文件
from a import *

执行b文件，结果：

this is __init__
# 可以看出这种导入方式依旧只会执行__init__文件

# __init__.py文件
print('this is __init__')
from .a_a import a_A
from .a_b import a_B

无论b.py文件以哪种方式导入包a，结果：

this is __init__
this is a_a
this is a_b
# 可以看出通过__init__文件实现了子模块的自动导入

# __init__.py文件
print('this is __init__')
from .a_a import a_A
from .a_b import a_B
__all__ = ['a_A']

# b文件
import a
a.a_A()
a.a_B()

执行b文件，结果：

this is __init__
this is a_a
this is a_b
this is a_A
this is a_B

# b文件
from a import  *
a_A()
a_B()

执行b文件，结果：

NameError: name 'a_B' is not defined
this is __init__
this is a_a
this is a_b
this is a_A

当__init__文件没有__all__时：

# __init__.py文件
print('this is __init__')
from .a_a import a_A
from .a_b import a_B
# b文件
from a import  *
a_A()
a_B()

执行b文件，结果：

this is __init__
this is a_a
this is a_b
this is a_A
this is a_B

得到结论，init.py的作用不再是标识文件夹是包，而是可以实现子模块的自动导入，变量__all__作用于from package import *，不管是py模块还是包都可以用all来实现模糊导入，注意如果__all__的变量里没有某个函数时通过 from package import *是导入不了这个函数的，但还是可以通过from package import 这个函数来实现精确导入，或者删除__all__变量。

可以被import导入的对象有：

模块文件（.py文件）
C或C++扩展（已编译为共享库或DLL文件）
包（包含多个模块）
内建模块（使用C编写并已链接到Python解释器中）

可以作为模块被导入的文件形式有：.py、.pyo、.pyc、.pyd、.so、.dll

参考：https://blog.csdn.net/m0_37607365/article/details/79889901?utm_medium=distribute.pc_relevant.none-task-blog-2defaultbaidujs_baidulandingword~default-1.pc_relevant_paycolumn&spm=1001.2101.3001.4242.2
https://blog.csdn.net/yucicheung/article/details/79445350

init.py文件：

from .builder import DATASETS, PIPELINES, build_dataloader, build_dataset
from .cityscapes import CityscapesDataset
from .coco import CocoDataset
from .custom import CustomDataset
from .dataset_wrappers import (ClassBalancedDataset, ConcatDataset,
                               RepeatDataset)
from .deepfashion import DeepFashionDataset
from .lvis import LVISDataset, LVISV1Dataset, LVISV05Dataset
from .nightowls import NightOwlsDataset
from .samplers import DistributedGroupSampler, DistributedSampler, GroupSampler
from .utils import replace_ImageToTensor
from .voc import VOCDataset
from .waymo_open import WaymoOpenDataset
from .wider_face import WIDERFaceDataset
from .xml_style import XMLDataset
from .underwater_optics import UnderwaterOpticsDataset

__all__ = [
    'CustomDataset', 'XMLDataset', 'CocoDataset', 'DeepFashionDataset',
    'VOCDataset', 'CityscapesDataset', 'LVISDataset', 'LVISV05Dataset',
    'LVISV1Dataset', 'GroupSampler', 'DistributedGroupSampler',
    'DistributedSampler', 'build_dataloader', 'ConcatDataset', 'RepeatDataset',
    'ClassBalancedDataset', 'WIDERFaceDataset', 'DATASETS', 'PIPELINES',
    'build_dataset', 'replace_ImageToTensor', 'UnderwaterOpticsDataset'
]

__all__ += ['WaymoOpenDataset', 'NightOwlsDataset']
phily123
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
python基础__init__.py，__all__ 介绍
nmxy_mmc的博客
02-18 461
__init__.py __all__
Python3中__init__.py文件介绍
网络资源是无限的
10-20 7240
Python中的模块是包含Python定义和语句的文件(A module is a file containing Python definitions and statements)，其文件名是模块名加后缀名.py。在模块内部，通过全局变量__name__可以获取模块名。 模块包含可执行语句及函数定义。这些语句用于初始化模块，且仅在import语句第一次遇到模块名时执行。 模块有自己的私有符号表，用作模块中所有函数的全局符号表。因此，在模块内使用全局变量时，不用担心...
python 中 __init__（）
qq_42467563的博客
10-09 109
class Student: score=100 #全局变量，所有对象共享 def __init__(self,name,age,num): #法__init__()方法是一种特殊的方法，被称为类的构造函数或初始化方法，传入对象后，初始化系统就会自动调用该方法 self.name=name self.age=age self.num=num #self 代表类的实例，当前对象：谁调用该...
理解python中__init__.py和__all__
qq_18824345的博客
03-15 1411
__ init __.py what is init.py? 通常在一个工程文件里面，我可能会发现在某个文件夹下面会有一个命名为__init__.py的py文件 why need init.py? 在一个工程文件下面，我们可能会有很多的py文件(模块)，文件太多，管理很不方便，这时候我们就可以创建一个包(package)对这些文件进行管理，把具有共同特征的文件放在同一个package里面，那该如何...
python中的 __init__.py文件及用途
最新发布
qq_43202117的博客
12-13 436
对于一个python项目，里面的每一个文件夹都可以认为是一个package，而每一个.py文件被认为是一个module。如果用的IDE是PyCharm，那么每新建一个Python Package，都会自动新建一个__init__.py文件。可以看作这个package的初始化文件。对于package里有多个module，调用多个module里几十上百个函数的时候，就可以把这些import语句统统放进__init__.py文件，极大简化代码。假设在tool.py文件中有一个函数function()如下。
python_workspace:python笔记
03-20
在"python_workspace-main"这个文件夹中，可能包含了Python学习过程中的笔记、练习代码和小项目，这些都是深化理解、巩固知识的好材料。持续实践和探索这些知识点，将有助于成为一个熟练的Python开发者。
Designer Sauce??_python_
10-02
_python_》是一个全面的Python学习资源，涵盖了从基础到高级的多个方面，对于想要深入Python编程的人来说，无疑是一份宝贵的资料。通过阅读和实践其中的内容，不仅可以掌握Python的核心技术，还能培养良好的编程习惯...
python_training
04-07
8. **模块和包**：Python通过导入机制来重用代码，模块是单个文件，而包是包含多个模块的文件夹结构，使用__init__.py文件标识。 9. **文件和I/O操作**：学习如何打开、读取、写入和关闭文件，以及更高级的文件操作...
Python学习笔记.pdf
08-24
init__.py`文件的作用（表示一个目录为Python包）、中文编码处理（如使用UTF-8编码）、注释（使用`#`进行单行注释，`"""`进行多行注释）、标识符（遵循命名规则，区分大小写）、保留字符（如`for`、`if`等关键字不能...
Python-LVIS数据集的PythonAPI
08-11
Python API for LVIS Dataset
python 模块化__init__.py-------__all__
RUN
09-26 1124
1.init.py的在文件夹中，可以使文件夹变为一个python模块，python的每个模块对应的包中都有一个__init__.py文件的存在 2.通常__init__.py文件为空，但是我们还可以为它增加其他的功能，我们在导入一个模块时候（也叫包），实际上导入的是这个模块的__init__.py文件。我们可以在__init__.py导入我们需要的模块，不需要一个个导入 3.init_.py 中还有一个重要的变量，叫做 all_。我们有时会使出一招“全部导入”，也就是这样：from PackageName
python init文件 all_python __init__.py和__all__
weixin_39804629的博客
12-10 190
__init__.py是创建python包时用的，详见文章：http://www.cnblogs.com/tqsummer/archive/2011/01/24/1943273.htmlpython中的Module是比较重要的概念。常见的情况是，事先写好一个.py文 件，在另一个文件中需要import时，将事先写好的.py文件拷贝 到当前目录，或者是在sys.path中增加事先写好的.py文件所在...
【Python】__init__.py文件的使用
黎明总是如期而至
12-13 984
在Python中，__init__.py是一个特殊的文件，它可以用来初始化Python包。是一个Python包的标识文件，它告诉Python这个目录应该被当做一个包对待，使得这个目录下的Python文件可以被其他文件导入。
python实现 全局变量的两种解决办法
热门推荐
kkwant的博客
07-13 2万+
python实现 全局变量的两种解决办法 两种解决办法：python实现 全局变量的两种解决办法
python的init方法在哪个模块_python模块中__init__.py的作用
weixin_39548733的博客
12-11 218
基本概念先上结论举例解释实验一：不包含__init__.py实验二：A中包含__init__.py实验三：A.A_A中也包含__init__.py进阶基本概念概念解释import即导入，方式就是在import位置将代码文件拷贝过去。模块python中一个.py文件就是一个模块包指软件包，举例import matplotlib.pyplot中(其中pyplot非函数，至少是一个模块或者包)，matp...
【无标题】在python中跨模块（py文件）使用全局变量的方法
zwy_0309的博客
09-05 1298
跨PY文件使用变量
【无标题】Cannot find reference ‘imread‘ in ‘__init__.py‘报错的解决方法
alpha567的博客
11-11 3628
Cannot find reference 'imread' in '__init__.py
python中__init__文件的作用
qm5132的博客
02-24 3627
目的：控制包的导入行为 简单来说：python程序运行时，__init__.py文件会将当前目录（文件夹）激活为module（模块包），其他模块引用此package模块时时会自动加载运行该__init__.py文件，这样开发人员可以在__init__.py中做一些初始化操作。 目录中的__init__.py文件作用：将当前整个文件夹当作一个包来管理，每当有外部import的时候，就会自动执行里面的函数。 （1）标识该目录是一个python的模块包 （2）简化模块导入操作 （3）功能的封装和细节隐藏 对
Python包中__init__.py文件__all__
06-10
在 Python 包中，__init__.py 文件可以包含 __all__ 变量，这个变量定义了当使用 from package import * 语句时，应该导入哪些模块或变量。__all__ 变量是一个列表，包含了需要导入的模块或变量名。例如： ```...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值