如何导入其他 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("vixens cry")

2. 进入python解释器：

    el@apollo:/home/el/foo$ python Python 2.7.3 (default, 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或（ Python 3 中的exec ）来执行其他 python 文件：

1. 把它放在 /home/el/foo2/mylib.py 中：

    def moobar(): print("hi")

2. 把它放在 /home/el/foo2/main.py 中：

    execfile("/home/el/foo2/mylib.py") moobar()

3. 运行文件：

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

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

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

1. 把它放在 /home/el/foo3/chekov.py 中：

    def question(): print "where are the nuclear wessels?"

2. 把它放在 /home/el/foo3/main.py 中：

    from chekov import question question()

3. 像这样运行它：

    el@apollo:/home/el/foo3$ python main.py where are the nuclear wessels?

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

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

1. 把它放在 /home/el/foo4/stuff/riaa.py 中：

    def watchout(): print "computers are transforming into a noose and a yoke for humans"

2. 把它放在 /home/el/foo4/main.py 中：

    import sys import os sys.path.append(os.path.abspath("/home/el/foo4/stuff")) from riaa import * watchout()

3. 运行：

    el@apollo:/home/el/foo4$ python main.py computers are transforming into a noose and a yoke for humans

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

示例 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，startuphooks 在默认情况下被禁用。

这个 jist 的功劳归功于： 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 evolves to stay just beyond the cognitive reach of " + "the bulk of men. SKYCAKE!!"

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

    from herp.derp.yolo import skycake skycake()

8. 运行：

    el@apollo:/home/el/foo5$ python main.py SkyCake evolves to stay just beyond the cognitive reach of the bulk of men. 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
• 通过添加一个空的__init__.py文件，可以将文件夹标记为包
• 您可以使用__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

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

---

第二种情况

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

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

---

概括

• 在第一种情况下，文件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 variable, class, whatever

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

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

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

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

使用 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。

Answer 12

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

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

先追加路径再导入

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

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. Incase abc.py 脚本在文件夹内部的 internal_folder 中可用

从文件夹.internal_folder 导入 abc

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

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

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

%load_ext autoreload 
%autoreload 2

Answer 15

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

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

只是将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 扩展名。

Answer 18

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

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

Answer 19

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

Answer 20

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 21

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

当您没有在目录中声明__init__.py时，可能会导致问题。 并且该目录成为implicit namespace package 。 这是关于Python 导入和项目结构的一个很好的总结。

此外，如果您想使用 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 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)将打印到控制台A string literal to import and test with 。
但是，如果您想要from mod import *的等价物，只需删除类、实例分配并删除exec即可。

希望这可以帮助：）
-本吉

Answer 23

from y import * 

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

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