如何导入其他 Python 文件？

Question

如何在 Python 中导入文件？我想导入：

1. 一个文件（例如 file.py）
2. 一个文件夹
3. 一个文件 在运行时根据用户输入动态地
4. 导入 文件的一个特定部分（例如单个函数）

Answer 1

导入 python 文件的方法有很多种，各有优缺点。

不要匆忙选择第一个适合您的导入策略，否则当您发现它不能满足您的需求时，您将不得不重写代码库。

我将首先解释最简单的示例 #1，然后我将转向最专业和最强大的示例 #7

示例 1，使用 python 解释器导入 python 模块：

1. 将其放入/home/el/foo/fox.py:

   def What_does_the_fox_say():
     print("泼妇哭了")
   

2. 进入 python 解释器：

   el@apollo:/home/el/foo$ python
   Python 2.7.3（默认，2013 年 9 月 26 日，20:03:06） 
   >>>>>进口狐狸
   >>>>>狐狸.what_does_the_fox_say()
   狐狸精哭泣
   >>>>> 
   

   您通过Python解释器导入了fox，并从fox.py中调用了python函数what_does_the_fox_say()。

示例 2，在 Python 3 中使用 execfile 或 (exec) 在脚本中执行其他 python 文件：

1. 将其放入 /home/el/foo2/mylib.py：

   def moobar():
     打印（“嗨”）
   

2. 将其放入 /home/el/foo2/main.py：

   execfile("/home/el/foo2/mylib.py")
   穆巴（）
   

3. 运行文件：

   el@apollo:/home/el/foo$ python main.py
   你好
   

   函数 moobar 是从 mylib.py 导入的，并在 main.py 中可用

示例 3，使用 from ... import ... 功能：

1. 将其放入 /home/ el/foo3/chekov.py：

   def 问题():
     print("核威斯尔在哪里？")
   

2. 将其放入 /home/el/foo3/main.py：

   来自 chekov 导入问题
   问题（）
   

3. 像这样运行：

   el@apollo:/home/el/foo3$ python main.py 
   核潜艇在哪里？
   

   如果您在 chekov.py 中定义了其他函数，除非您import *，否则它们将不可用

如果您在 chekov.py 中定义了其他函数，除非您 import * 示例 4，导入 riaa.py（如果它位于不同的文件位置），否则 它已导入

1. 将其放入 /home/el/foo4/stuff/riaa.py：

   def watchout():
     print("计算机正在变成人类的绞索和枷锁")
   

2. 将其放入 /home/el/foo4/main.py：

   导入系统 
   导入操作系统
   sys.path.append(os.path.abspath("/home/el/foo4/stuff"))
   从 riaa 进口 *
   小心（）
   

3. 运行它：

   el@apollo:/home/el/foo4$ python main.py 
   计算机正在变成人类的绞索和枷锁
   

   从不同的目录导入外部文件中的所有内容。

示例 5，使用 os.system("python yourfile.py")

import os
os.system("python yourfile.py")

示例 6，通过搭载 python 启动钩子导入文件：

更新：此示例曾经适用于 python2 和 3，但现在仅适用于 python2。 python3 摆脱了这个用户startuphook 功能集，因为它被低技能的Python 库编写者滥用，使用它不礼貌地将代码注入到所有用户定义程序之前的全局命名空间中。如果您希望它适用于 python3，您必须发挥更多创意。如果我告诉你如何做，Python 开发人员也会禁用该功能集，所以你只能靠自己了。

请参阅：https://docs.python.org/2/library/user.html< /a>

将此代码放入 ~/.pythonrc.py 中的主目录

class secretclass:
    def secretmessage(cls, myarg):
        return myarg + " is if.. up in the sky, the sky"
    secretmessage = classmethod( secretmessage )

    def skycake(cls):
        return "cookie and sky pie people can't go up and "
    skycake = classmethod( skycake )

将此代码放入 main.py（可以在任何地方）：

import user
msg = "The only way skycake tates good" 
msg = user.secretclass.secretmessage(msg)
msg += user.secretclass.skycake()
print(msg + " have the sky pie! SKYCAKE!")

运行它，您应该得到以下结果：

$ python main.py
The only way skycake tates good is if.. up in the sky, 
the skycookie and sky pie people can't go up and  have the sky pie! 
SKYCAKE!

如果您得到这里出现错误： ModuleNotFoundError: No module named 'user' 那么这意味着您正在使用 python3，默认情况下启动钩子在那里被禁用。

此要点的功劳在于： https:// github.com/docwhat/homedir-examples/blob/master/python-commandline/.pythonrc.py 发送你的上船。

示例 7，最强大：使用裸导入命令在 python 中导入文件：

1. 创建一个新目录 /home/el/foo5/

2. 创建一个新目录 /home/el/foo5/herp

3. 在herp下创建一个名为__init__.py的空文件：

   el@apollo:/home/el/foo5/herp$ touch __init__.py
   el@apollo:/home/el/foo5/herp$ ls
   __init__.py
   

4. 创建一个新目录/home/el/foo5/herp/derp

5. 在 derp 下，创建另一个 __init__.py 文件：

   el@apollo:/home/el/foo5/herp/derp$ touch __init__.py
   el@apollo:/home/el/foo5/herp/derp$ ls
   __init__.py
   

6. 在 /home/el/foo5/herp/derp 下创建一个名为 yolo.py 的新文件，将其放入其中：

   def skycake():
     print("SkyCake 的发展超出了人类的认知范围" +
     “大部分男人。天空蛋糕！！”）
   

7. 关键时刻，创建新文件 /home/el /foo5/main.py，把它放在那里；

   从herp.derp.yolo导入skycake
   天空蛋糕()
   

8. 运行它：

   el@apollo:/home/el/foo5$ python main.py
   SkyCake 的发展超出了大多数人的认知范围 
   男人。天空蛋糕！！
   

   空的 __init__.py 文件向 python 解释器传达开发人员希望此目录成为可导入包的信息。

如果您想查看我关于如何在目录下包含所有 .py 文件的帖子，请参阅此处：https://stackoverflow.com/a /20753073/445131

Answer 2

importlib 已添加到 Python 3以编程方式导入模块。

import importlib

moduleName = input('Enter module name:')
importlib.import_module(moduleName)

应从 moduleName 中删除 .py 扩展名。该函数还为相对导入定义了一个package 参数。

在 python 2.x 中：

• 只需 import file 而不带 .py 扩展名
• 通过添加空的 __init__.py 文件，可以将文件夹标记为包
• 您可以使用 < code>__import__ 函数，它将模块名称（不带扩展名）作为字符串扩展

pmName = input('Enter module name:')
pm = __import__(pmName)
print(dir(pm))

名键入 help(__import__) 了解更多详细信息。

Answer 3

第一种情况

您想要将文件 A.py 导入到文件 B.py 中，这两个文件位于同一文件夹中，如下所示：

. 
├── A.py 
└── B.py

您可以在文件 B 中执行此操作.py:

import A

或者

from A import *

或者

from A import THINGS_YOU_WANT_TO_IMPORT_IN_A

然后你就可以在B.py>文件中使用A.py文件的所有功能

---

第二案例

您想在文件B.py中导入文件folder/A.py，这两个文件不在同一个文件夹中，如下所示：

.
├── B.py
└── folder
     └── A.py

您可以在文件<中执行此操作code>B.py:

import folder.A

或者

from folder.A import *

或者

from folder.A import THINGS_YOU_WANT_TO_IMPORT_IN_A

然后你就可以在B.py文件中使用A.py文件的所有功能

---

< strong>摘要

• 在第一种情况中，文件A.py是您在文件B中导入的模块。 py，您使用了语法import module_name。
• 在第二种情况中，folder是包含模块A.py的包，您使用了语法import package_name.module_name< /代码>。

有关包和模块的更多信息，请参阅此链接。

Answer 4

要在“运行时”导入已知名称的特定 Python 文件：

import os
import sys

...

scriptpath = "../Test/"

# Add the directory containing your module to the Python path (wants absolute paths)
sys.path.append(os.path.abspath(scriptpath))

# Do the import
import MyModule

Answer 5

将 python 文件从一个文件夹导入到另一个文件夹的复杂方法并不多。只需创建一个 __init__.py 文件来声明此文件夹是一个 python 包，然后转到要导入的主机文件，只需键入

from root.parent.folder.file import 变量，类，无论什么

Answer 6

导入文档.. -- 参考链接

__init__.py 文件是使 Python 将目录视为包含包所必需的，这样做是为了防止具有通用名称（例如字符串）的目录无意中隐藏稍后出现在模块搜索路径上的有效模块。

__init__.py 可以只是一个空文件，但它也可以执行包的初始化代码或设置 __all__ 变量。

mydir/spam/__init__.py
mydir/spam/module.py
import spam.module
or
from spam import module

Answer 7

from file import function_name  ######## Importing specific function
function_name()                 ######## Calling function

这

import file              ######## Importing whole package
file.function1_name()    ######## Calling function
file.function2_name()    ######## Calling function

是我现在已经理解的两种简单方法，并确保要作为库导入的“file.py”文件仅存在于当前目录中。

Answer 8

如果定义的函数位于文件 x.py 中：

def greet():
    print('Hello! How are you?')

在要导入该函数的文件中，写入以下内容：

from x import greet

如果您不希望导入文件中的所有函数，这很有用。

Answer 9

使用 Python 3.5 或更高版本，您可以使用 importlib.util< /a> 直接将任意位置的 .py 文件作为模块导入，无需修改 sys.path 。

import importlib.util
import sys

def load_module(file_name, module_name)
    spec = importlib.util.spec_from_file_location(module_name, file_name)
    module = importlib.util.module_from_spec(spec)
    sys.modules[module_name] = module
    spec.loader.exec_module(module)
    return module

file_name 参数必须是字符串或类似路径的对象。 module_name 参数是必需的，因为所有加载的 Python 模块都必须有一个（点）模块名称（例如 sys、importlib 或 importlib .util），但您可以为这个新模块选择任何可用的名称。

您可以这样使用此函数：

my_module = load_module("file.py", "mymod")

使用 load_module() 函数将其导入到 Python 进程后，该模块将可以使用为其指定的模块名称进行导入。

file.py:

print(f"file.py was imported as {__name__}")

one.py:

print(f"one.py was imported as {__name__}")
load_module("file.py", "mymod")
import two

two.py:

print(f"two.py was imported as {__name__})")
import mymod

给定上面的文件，您可以运行以下命令来查看file.py 变得可导入。

$ python3 -m one
one.py was imported as __main__
two.py was imported as two
file.py was imported as mymod

这个答案基于官方Python文档： importlib：直接导入源文件。

Answer 10

我想添加这个注释，但我在其他地方不太清楚；在模块/包内，从文件加载时，模块/包名称必须以 mymodule 为前缀。想象一下 mymodule 的布局如下：

/main.py
/mymodule
    /__init__.py
    /somefile.py
    /otherstuff.py

当从 __init__.py 加载 somefile.py/otherstuff.py 时，内容应该看起来像：

from mymodule.somefile import somefunc
from mymodule.otherstuff import otherfunc

Answer 11

import sys
#print(sys.path)
sys.path.append('../input/tokenization')
import tokenization

要导入任何 .py 文件，您可以使用上面的代码。

首先附加路径，然后导入

注意：'../input/tokenization'目录包含tokenization.py文件

Answer 12

导入 .py 文件的最佳方法是通过 __init__.py。最简单的方法是在 .py 文件所在的同一目录中创建一个名为 __init__.py 的空文件。

Mike Grouchy 的这篇 帖子 很好地解释了 __init__.py 及其用于制作、导入和设置 python 包的用途。

Answer 13

我的导入方式是导入文件并使用其名称的简写。

import DoStuff.py as DS
DS.main()

不要忘记您的导入文件必须以 .py 扩展名命名

Answer 14

有几种方法可以包含名称为 abc.py 的 python 脚本，

1. 例如：如果你的文件名为 abc.py (import abc)
   限制是您的文件应该与调用 python 脚本位于同一位置。

导入abc

2. 例如如果你的 python 文件位于 Windows 文件夹内。 Windows 文件夹与调用 python 脚本的位置相同。

从文件夹导入 abc

3. 如果 abc.py 脚本可在文件夹内部的 inside_folder 中使用

从folder.internal_folder导入abc

4. 正如上面 James 的回答，如果您的文件位于某个固定位置

导入操作系统
导入系统
脚本路径 =“../Test/MyModule.py”
sys.path.append(os.path.abspath(scriptpath))
导入我的模块

如果您的 python 脚本已更新并且您不想上传 - 使用这些语句进行自动刷新。奖金 ：）

%load_ext autoreload 
%autoreload 2

Answer 15

这帮助我使用 Visual Studio Code 构建我的 Python 项目。

当您未在目录中声明 __init__.py 时，可能会导致此问题。并且该目录成为隐式命名空间包。这是关于 Python 导入和项目结构< /a>.

另外，如果您想使用 Visual Studio Code 运行按钮 在顶部栏中，其脚本不在主包内，您可以尝试从实际目录运行控制台。

例如，您想要执行测试包中打开的 test_game_item.py，并且您在 omission （主包）目录中打开了 Visual Studio Code：

├── omission
│   ├── app.py
│   ├── common
│   │   ├── classproperty.py
│   │   ├── constants.py
│   │   ├── game_enums.py
│   │   └── __init__.py
│   ├── game
│   │   ├── content_loader.py
│   │   ├── game_item.py
│   │   ├── game_round.py
│   │   ├── __init__.py
│   │   └── timer.py
│   ├── __init__.py
│   ├── __main__.py
│   ├── resources
│   └── tests
│       ├── __init__.py
│       ├── test_game_item.py
│       ├── test_game_round_settings.py
│       ├── test_scoreboard.py
│       ├── test_settings.py
│       ├── test_test.py
│       └── test_timer.py
├── pylintrc
├── README.md
└── .gitignore

目录结构来自[2]。

您可以尝试设置：

(Windows) Ctrl + Shift + P → 首选项：打开设置 (JSON) 。

将此行添加到您的用户设置中：

"python.terminal.executeInFileDir": true

此问题。

Answer 16

如果您要导入的模块不在子目录中，请尝试以下操作并从最深的公共目录运行app.py父目录：

目录结构：

/path/to/common_dir/module/file.py
/path/to/common_dir/application/app.py
/path/to/common_dir/application/subpath/config.json

在app.py中，将客户端路径附加到sys.path：

import os, sys, inspect

sys.path.append(os.getcwd())
from module.file import MyClass
instance = MyClass()

可选（如果加载例如配置）（检查似乎是我的用例中最强大的一个）

# Get dirname from inspect module
filename = inspect.getframeinfo(inspect.currentframe()).filename
dirname = os.path.dirname(os.path.abspath(filename))
MY_CONFIG = os.path.join(dirname, "subpath/config.json")

运行

user@host:/path/to/common_dir$ python3 application/app.py

这个解决方案适用于 cli 和 PyCharm。

Answer 17

这就是我从 python 文件调用函数的方法，这对我来说可以灵活地调用任何函数。

import os, importlib, sys

def callfunc(myfile, myfunc, *args):
    pathname, filename = os.path.split(myfile)
    sys.path.append(os.path.abspath(pathname))
    modname = os.path.splitext(filename)[0]
    mymod = importlib.import_module(modname)
    result = getattr(mymod, myfunc)(*args)
    return result

result = callfunc("pathto/myfile.py", "myfunc", arg1, arg2)

Answer 18

只是为了在另一个 python 文件中导入 python 文件

，假设我有 helper.py python 文件，它具有显示功能，例如，

def display():
    print("I'm working sundar gsv")

现在在 app.py 中，您可以使用显示函数，

import helper
helper.display()

输出，

I'mworking sundar gsv

注意： 无需指定 .py 扩展名。

Answer 19

Python 的一个非常不为人知的功能是能够导入 zip 文件：

library.zip
|-library
|--__init__.py

包的文件 __init__.py 包含以下内容：

def dummy():
    print 'Testing things out...'

我们可以编写另一个可以导入包的脚本来自 zip 存档。只需将 zip 文件添加到 sys.path 即可。

import sys
sys.path.append(r'library.zip')

import library

def run():
    library.dummy()

run()

Answer 20

这可能听起来很疯狂，但如果您只是为其创建包装脚本，则可以创建指向要导入的文件的符号链接。

Answer 21

您还可以执行以下操作：from filename import Something

示例：from client import Client
请注意，您不需要 .py .pyw .pyui 扩展名。

Answer 22

如上所述，有很多方法，但我发现我只想导入文件的内容，并且不想必须编写行和行并且必须导入其他模块。因此，我想出了一种获取文件内容的方法，即使使用点语法 (file.property)，而不是将导入的文件与您的文件合并。

首先，这是我要导入的文件，data.py

    testString= "A string literal to import and test with"

注意：您可以使用 .txt 扩展名反而。

在 mainfile.py 中，首先打开并获取内容。

    #!usr/bin/env python3
    Data=open('data.txt','r+').read()

现在您已将内容作为字符串，但尝试访问 data.testString 将导致错误，因为 data 是 str 的实例类，即使它确实有一个属性 testString ，它也不会执行您期望的操作。
接下来，创建一个类。例如（双关语），ImportedFile

    class ImportedFile:

并将其放入其中（使用适当的缩进）：

    exec(data)

最后，像这样重新分配data：

    data=ImportedFile()

就是这样！只需像访问任何其他模块一样进行访问，输入 print(data.testString) 将在控制台上打印用于导入和测试的字符串文字。

但是，如果您想要 from mod import * 的等价物，只需删除类、实例分配，然后取消 exec 的缩进即可。

希望这有帮助:)
-本吉

Answer 23

from y import * 

• 假设您有文件 x 和 y。
• 您想将 y 文件导入到 x。

然后转到您的 x 文件并放置上述命令。要测试这一点，只需在 y 文件中添加一个打印函数，当导入成功后，它应该在 x 文件中打印它。