在python程序编写过程中，如何解决模块名称冲突？

Posted 2023-03-15

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了在python程序编写过程中，如何解决模块名称冲突？相关的知识，希望对你有一定的参考价值。

如果你有两个同名的模块，那么你只能导人它们中的一个——默认情况下，Python总是会选择在模块搜索路径sys.path中最左边的那一项。如果你偏爱的模块和顶层脚本在同一目录下，那就不成问题;由于顶层脚本的主目录总是模块搜索路径中的第一项，因此它的内容总是会首先被自动定位。然而对于跨目录的导入，模块搜索路径的线性本质意味着同名的文件会产生冲突。
要修复这一冲突，要么避免同名文件。如果你需要同时访问两个同名的文件，那么就要把两个源文件分别放入子目录中，这样包导入目录名称将使得模块引用唯一。只要外围的包目录名称是唯一的，你就能访问同名模块中的任意一个，或是全部的两个。注意，如果你不小心为自己的模块使用了一个名称，而它碰巧和你需要使用的标准库模块的名称相同，那么也会出现这一问题。这是因为程序主目录（或是模块路径中靠前的另一个目录)下的本地模块会隐藏和替换标准库模块。要修复这种覆盖，要么避免使用和你需要的另一模块相同的名称，要么把模块放到一个包目录下然后使用Python 3.X的包相对导入模型（包相对导入在2.X版本中是一个可选的功能)。在包相对导入模型下，普通导入会跳过包目录，因此你可以获取标准库版本，但在必要时特殊的点号开头导入语句仍然可以选取同名模块的本地版本。参考技术A 如果两个包中定义的函数，类，或者子模块互相重名，那么就可能会导致名称冲突，例如:
from analysis.utils import inspect
from frontend.utils import inspect # 覆盖前一句导入的inspect
解决方法1
在import语句中，通过as语句，给引入当前作用域中的属性重新起名，例如：
from analysis.utils import inspect as analysis_inspect
from frontend.utils import inspect as frontend_inspect
凡是通过import语句引入的内容，都可以通过as子句来改名，及时引入整个模块，也依然能用as为其改名。
解决方法2
每次使用模块时都从最高层的路径来时，完整地写出各模块的名称。例如：
import analysis.utils
import frontend.utils
然后通过analysis.utils.inspect和frontend.utils.inspect这样完整的路径来访问这两个模块中的函数。参考技术B 个人觉得最好的办法就是在提前准备好各个模块的名称，而不要临时性的给模块起名

Python 包管理

1. 模块

一个模块就是一个包含python代码的文件，后缀名称是.py就可以，模块就是个python文件
为什么我们用模块
- 程序太大，编写维护非常不方便，需要拆分
- 模块可以增加代码重复利用的方法
- 当作命名空间使用，避免命名冲突
如何定义模块
- 模块就是一个普通文件，所以任何代码可以直接书写
- 不过根据模块的规范，最好在本块中编写以下内容
```
- 函数（单一功能）
- 类（相似功能的组合，或者类似业务模块）
- 测试代码
```

如何使用模块

模块直接导入

- 模块名称直接以数字开头，需要借助importlib帮助

语法

import module_name
module_name.function_name
module_name.class_name

案例 01.py，02.py，p01.py，p02.py

    # 案例 01.py
    # 包含一个学生类
    # 一个sayHello函数
    # 一个打印语句

    class Student():
        def __init__(self, name = "NoName", age = 18):
            self.name = name
            self.age = age
    
        def say(self):
                print("My name is {0}".format(self.name))
    
    def sayHello():
        print("Hi, ")
    
    print("我是模块p0")

    # 案例 02.py
    # 借助于importlib包可以实现导入以数字开头的模块名称
    import importlib
    
    # 相当于导入了一个叫01的模块并把导入模块赋值给了a
    
    a = importlib.import_module("01")
    stu = a.Student()
    stu.say()

    # 案例 p01.py
    # 包含一个学生类
    # 一个sayHello函数
    # 一个打印语句
    
    class Student():
        def __init__(self, name = "NoName", age = 18):
            self.name = name
            self.age = age
    
        def say(self):
                print("My name is {0}".format(self.name))
    
    def sayHello():
        print("Hi, ")
    
    # 此判断语句建议一直作为程序的入口
    if __name__ == \'__main__\':
        print("我是模块p01")

    # 案例 p02.py
    import p01
    
    stu = p01.Student("xiaojing", 19)
    
    stu.say()
    
    p01.sayHello()

    My name is xiaojing
    Hi,

import 模块 as 别名

- 导入的同时给模块起一个别名
- 其余用法跟第一种相同
- 案例 p03.py

    # 案例 p03.py
    import p01 as p
    
    stu = p.Student("yueyue", 18)
    stu.say()

    My name is yueyue

from module_name import func_name, class_name

- 按上述方法有选择性的导入
- 使用的时候可以直接使用导入的内容，不需要前缀
- 案例 p04

    # 案例 p04.py
    from p01 import Student, sayHello
    
    stu = Student()
    
    stu.say()
    
    sayHello()

  My name is NoName
  Hi,

from module_name import *

- 导入模块所有内容
- 案例 p05.py

       # 案例 p05.py
    from p01 import *
    
    sayHello()
    
    stu = Student("yaona", 20)
    stu.say()

    Hi, 
    My name is yaona

if __name__ == `__main__` 的使用
- 可以有效的避免模块代码被导入的时候被动执行的问题
- 建议所有程序的入口都以此代码为入口

2. 模块的搜索路径和存储

什么是模块的搜索路径
- 加载模块的时候，系统会在哪些地方寻找此模块

系统默认的模块搜索路径

import sys
sys.path  属性可以获取路径列表
# 案例 p06.py

    # 案例 p06.py
    import sys
    
    print(type(sys.path))
    print(sys.path)
    
    for p in sys.path:
        print(p)

        <class \'list\'>
    [\'D:\\\\python\\\\project\\\\包管理\', \'D:\\\\PyCharm Community Edition 2019.1.1\\\\helpers\\\\pydev\', \'D:\\\\python\\\\project\', \'D:\\\\PyCharm Community Edition 2019.1.1\\\\helpers\\\\third_party\\\\thriftpy\', \'D:\\\\PyCharm Community Edition 2019.1.1\\\\helpers\\\\pydev\', \'C:\\\\Users\\\\user\\\\.PyCharmCE2019.1\\\\system\\\\cythonExtensions\', \'D:\\\\python\\\\project\\\\包管理\', \'D:\\\\Anaconda3\\\\envs\\\\opp\\\\python37.zip\', \'D:\\\\Anaconda3\\\\envs\\\\opp\\\\DLLs\', \'D:\\\\Anaconda3\\\\envs\\\\opp\\\\lib\', \'D:\\\\Anaconda3\\\\envs\\\\opp\', \'D:\\\\Anaconda3\\\\envs\\\\opp\\\\lib\\\\site-packages\']
    D:\\python\\project\\包管理
    D:\\PyCharm Community Edition 2019.1.1\\helpers\\pydev
    D:\\python\\project
    D:\\PyCharm Community Edition 2019.1.1\\helpers\\third_party\\thriftpy
    D:\\PyCharm Community Edition 2019.1.1\\helpers\\pydev
    C:\\Users\\user\\.PyCharmCE2019.1\\system\\cythonExtensions
    D:\\python\\project\\包管理
    D:\\Anaconda3\\envs\\opp\\python37.zip
    D:\\Anaconda3\\envs\\opp\\DLLs    
    D:\\Anaconda3\\envs\\opp\\lib
    D:\\Anaconda3\\envs\\opp
    D:\\Anaconda3\\envs\\opp\\lib\\site-packages

添加搜索路径
```
sys.path.append(dir)
```
模块的加载顺序
1. 搜索内存中已经加载好的模块
2. 搜索python的内置模块
3. 搜索sys.path路径

包

包是一种组织管理代码的方式，包里面存放的是模块
用于将模块包含在一起的文件夹就是包
自定义包的结构

    |---包
    |---|---  __init__.py  包的标志文件
    |---|---  模块1
    |---|---  模块2
    |---|---  子包（子文件夹）
    |---|---|---  __init__.py
    |---|---|---  子包模块1
    |---|---|---  子包模块2

包的导入操作

import package_name
- 直接导入一个包，可以使用__init__.py中的内容
- 使用方式是：
  package_name.func_name
  package_name.class_name.func_name()
- 此种方式的访问内容是
- 案例 pkg01, p07.py

    # pkg01.__init__py
    def inInit():
        print("I am in init of package")

    # pkg01.p01.py
    class Student():
        def __init__(self, name = "NoName", age = 18):
            self.name = name
            self.age = age
    
        def say(self):
                print("My name is {0}".format(self.name))
    
        def sayHello():
            print("Hi, ")


    print("我是模块p01")

    # 案例 p07.py
    import pkg01
    
    pkg01.inInit()

    I am in init of package

import package_name as p
- 具体用法跟作用方式，跟上述简单导入一致
- 注意的是此种方法是默认对__init__.py内容的导入

import package.module

导入包中某一个具体的模块

使用方法

    package.module.func_name
    package.module.class.fun()
    package.module.class.var

案例 p08.py

    # 案例 p08.py
    import pkg01.p01
    
    stu = pkg01.p01.Student()
    stu.say()

    我是模块p01
    My name is NoName

import package.module as pm

from ... import 导入
- from package import module1, module2, module3, ... ...
- 此种导入方法不执行 __init__ 的内容
```
from pkg01 import p01
p01.sayHello()
```
- from package import *
  - 导入当前包 __init__.py 文件中所有的函数和类
  - 使用方法
    func_name()
    class_name.func_name()
    class_name.var
  - 案例 p09.py, 注意此种导入的具体内容
```
    # 案例 p09.py
    from pkg01 import *
    
    inInit()
    
    stu = Student() 
```
```
    I am in init of package
    
    NameError: name \'Student\' is not defined
```
from package.module import *
- 导入包中指定的模块的所有内容
- 使用方法
  func_name()
  class_name.func_name()
在开发环境中经常会引用其他模块，可以在当前包中直接导入其他模块中的内容
- import 完整的包或者模块的路径

__all__ 的用法

在使用from package import 的时候， 可以导入的内容
__init__.py 中如果文件为空，或者没有 __all__, 那么只可以把 __init__ 中的内容导入
__init__ 如果设置了 __all__ 的值，那么则按照 __all__ 指定的子包或者模块进行加载

如此则不会载入 __init__ 中的内容

__all__=[\'module1\', \'module2\', \'package1\'... ...]
案例 pkg02，p10.py

    # pkg02.__init__.py
    __all__=[\'p01\']
    
    def inInit():
        print("T am in init of package")

    # pkg02.p01.py
    class Student():
        def __init__(self, name = "NoName", age = 18):
            self.name = name
            self.age = age

        def say(self):
            print("My name is {0}".format(self.name))
    
        def sayHello():
            print("Hi, ")
    
    # 此判断语句建议一直作为程序的入口
    if __name__ == \'__main__\':
        print("我是模块p01")

    # 案例 p10.py
    from pkg02 import *
    
    stu = p01.Student()
    stu.say()

My name is NoName

命名空间

用于区分不同位置不同功能但相同名称的函数或者变量的一个特定前缀
作用是防止命名冲突
setName()
Student.setName()
Dog.setName()

以上是关于在python程序编写过程中，如何解决模块名称冲突？的主要内容，如果未能解决你的问题，请参考以下文章

解决python开发中模块冲突的具体方法？

盘点Python常用的模块和包

如何解决包冲突问题

解决 2 个 npm 模块具有相同名称的组件时的名称冲突

模块和包

如何解决包冲突问题