如何导入其他 Python 文件？

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

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

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

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

把它放在 /home/el/foo/fox.py 中： def what_does_the_fox_say(): print("vixens cry") 进入 python 解释器： el@apollo:/home/el/foo$ python Python 2.7.3（默认, Sep 26 2013, 20:03:06) >>> import fox >>> fox.what_does_the_fox_say() vixens cry >>> 你通过 python 解释器导入了 fox，从 fox.py 中调用了 python 函数 what_does_the_fox_say()。

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

把它放在 /home/el/foo2/mylib.py: def moobar(): print("hi") 把它放在 /home/el/foo2/main.py: execfile("/home/el/foo2/mylib .py") moobar() 运行文件： el@apollo:/home/el/foo$ python main.py hi 函数 moobar 是从 mylib.py 导入并在 main.py 中可用

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

把它放在 /home/el/foo3/chekov.py 中： def question(): print "where are the nucleus wessels?"把它放在 /home/el/foo3/main.py 中： from chekov import question question() 像这样运行它： el@apollo:/home/el/foo3$ python main.py 核容器在哪里？如果您在 chekov.py 中定义了其他函数，除非您导入 *，否则它们将不可用

示例 4，如果 riaa.py 与导入位置不同，则导入 riaa.py

把它放在 /home/el/foo4/stuff/riaa.py: def watchout(): print "计算机正在变成人类的绞索和枷锁" 把它放在 /home/el/foo4/main.py: import sys import os sys.path.append(os.path.abspath("/home/el/foo4/stuff")) from riaa import * watchout() 运行：el@apollo:/home/el/foo4$ python main .py 计算机正在转变为人类的绞索和枷锁，它从不同的目录导入外部文件中的所有内容。

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

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

示例 6，通过搭载 python startuphook 导入文件：

更新：这个例子曾经适用于 python2 和 3，但现在只适用于 python2。 python3 摆脱了这个用户启动钩子功能集，因为它被低技能的 Python 库编写者滥用，在所有用户定义的程序之前使用它来不礼貌地将他们的代码注入全局命名空间。如果你想让它适用于 python3，你将不得不变得更有创意。如果我告诉你怎么做，python 开发人员也会禁用该功能集，所以你只能靠自己了。

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

将此代码放入 ~/.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，默认情况下启动挂钩在此处禁用。

此 jist 的功劳归功于：https://github.com/docwhat/homedir-examples/blob/master/python-commandline/.pythonrc.py 发送您的上船。

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

创建一个新目录 /home/el/foo5/ 创建一个新目录 /home/el/foo5/herp 在 herp 下创建一个名为 __init__.py 的空文件：el@apollo:/home/el/foo5/herp$ touch __init__。 py el@apollo:/home/el/foo5/herp$ ls __init__.py 新建目录 /home/el/foo5/herp/derp 在derp下，再新建一个__init__.py文件： el@apollo:/home/el /foo5/herp/derp$ touch __init__.py el@apollo:/home/el/foo5/herp/derp$ ls __init__.py 在 /home/el/foo5/herp/derp 下新建一个文件 yolo.py 放里面的这个： def skycake(): print "SkyCake 进化到刚刚超出了" + "大部分人的认知范围。SKYCAKE!!"关键时刻，制作新文件/home/el/foo5/main.py，把它放在那里； from herp.derp.yolo import skycake skycake() 运行它：el@apollo:/home/el/foo5$ python main.py SkyCake 进化到超出大多数人的认知范围。天饼！！空的 __init__.py 文件与 Python 解释器通信，开发人员希望该目录成为可导入的包。

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

---

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

import importlib

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

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

在 python 2.x 中：

只需导入不带 .py 扩展名的文件

通过添加一个空的 __init__.py 文件，可以将文件夹标记为包

您可以使用 __import__ 函数，它将模块名称（不带扩展名）作为字符串扩展名

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

输入 help(__import__) 了解更多详情。

---

第一种情况

你要在文件 B.py 中导入文件 A.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

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

import folder.A

或者

from folder.A import *

或者

from folder.A import THINGS_YOU_WANT_TO_IMPORT_IN_A

然后您将能够在文件 B.py 中使用文件 A.py 的所有功能

概括

在第一种情况下，文件 A.py 是您在文件 B.py 中导入的模块，您使用了语法 import module_name。

在第二种情况下，文件夹是包含模块 A.py 的包，您使用了语法 import package_name.module_name。

有关包和模块的详细信息，请参阅此link。

---

要在“运行时”导入具有已知名称的特定 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

---

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

from root.parent.folder.file import variable, class, whatever

---

Import doc .. -- 参考链接

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

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

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

---

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”文件仅存在于当前目录中。

---

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

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

在要导入函数的文件中，写下：

from x import greet

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

---

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

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

---

我想在别处添加我不太清楚的注释；在模块/包中，从文件加载时，模块/包名称必须以 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

---

使用 Python 3.5 或更高版本，您可以使用 importlib.util 直接将任意位置的 .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"{__name__} imported (file.py)")
# =========

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

# two.py ==
print(f"{__name__} imported (two.py)")
import mymod
# =========

鉴于上述文件，您可以运行以下命令来查看 file.py 是如何变得可导入的。

$ python3 -m one
__main__ imported (one.py)
two imported (two.py)
mymod imported (file.py)

此答案基于官方 Python 文档：importlib: Importing a source file directly.

---

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

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

先追加路径再导入

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

---

我如何导入是导入文件并使用它的名称的简写。

import DoStuff.py as DS
DS.main()

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

---

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

例如，如果您的文件被称为 abc.py (import abc) 限制是您的文件应该出现在您的调用 python 脚本所在的同一位置。

导入 abc

例如，如果您的 python 文件位于 Windows 文件夹中。 Windows 文件夹位于调用 python 脚本的同一位置。

从文件夹导入 abc

Incase abc.py 脚本在文件夹内部的 internal_folder 中可用

从文件夹.internal_folder 导入 abc

正如上面詹姆斯所回答的那样，如果您的文件位于某个固定位置

导入 os 导入 sys scriptpath = "../Test/MyModule.py" sys.path.append(os.path.abspath(scriptpath)) 导入 MyModule

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

%load_ext autoreload 
%autoreload 2

---

如果您要导入的模块不在子目录中，请尝试以下操作并从最深的公共父目录运行 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 中都适用于我。

---

这就是我从 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)

---

只是将python文件导入另一个python文件

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

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

现在在app.py中，可以使用显示功能了，

import helper
helper.display()

输出，

I'm working sundar gsv

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

---

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

---

您也可以这样做：from filename import something

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

---

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()

---

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

当您没有在目录中声明 __init__.py 时，可能会导致该问题。目录变为 implicit namespace package。这是关于 Python imports and project structure 的一个很好的总结。

https://i.stack.imgur.com/F045Y.png

例如，您想从测试包中执行一个打开的 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

其他系统的更全面的答案也在 this question 中。

---

方法有很多，如上所列，但我发现我只想导入文件的内容，不想写一行又一行又要导入其他 模块。因此，我想出了一种获取文件内容的方法，即使使用点语法 (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) 将打印到控制台 A string literal to import and test with。
但是，如果您想要 from mod import * 的等价物，只需删除类、实例分配并删除 exec。

希望这会有所帮助:) -Benji

---

from y import * 

假设您有一个文件 x 和 y。

您想将 y 文件导入 x。

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

---