Python import file with functions

Importing Function From a File in Python

The process of importing a function from a file in Python is similar to importing modules. You have to create two files. Next, insert the definition of the function in one file and call the function from another.

Create a file with a function

Name the new file myfile.py and insert a function.

Create the second file, in the same directory, let’s call it main.py, import the file and make a function call.

This code will generate the following message.

my_function works. Message: Hello World!

Another way to import

Let’s import a file and call a function a bit differently. Instead of using import myfile, we use from myfile import *.

Now, you can call a function, without using the file name at the beginning of it.

This way, the program will import all functions inside the file. In our case, there is only one function.

Import file from another location

Python 3.3+

If the file where you want to call a function is in a different location than the file you want to import, you have to use the SourceFileLoader class.

Читайте также:  Html div align center position

I have my second file called myfile2.py at this location: D:/myfile2.py.

The modified main.py file looks like this:

The class SourceFileLoader takes a path and loads a module using the load_module function. This module is assigned to the mymodule variable.

After you run the code, you will get this message.

my_function2 works. Message: Hello World!

Python 3.5+

You can also import a file using the util module.

Источник

Python 3: Import Another Python File as a Module

In Python, a module is a single unit of Python code that can be imported (loaded and used) by other Python code. A module can contain definitions (like functions and constants), as well as statements that initialize those definitions. Once the module code is written, it can be reused by any script that imports the module.

A common way to create a Python module is to create a file with a filename that ends in .py , and write the module code in there. If we use a different file extension in the filename, or no extension at all, the standard import statements shown below will not work, and we’ll have to use importlib instead, which requires more code (more info below).

To illustrate standard import usage, let’s say we create a file called mymodule.py with the following function definition:

def say_hello(): print( 'Hello, world!' )

Now every time we want to write «Hello, world!» to the screen from a Python script, we can simply import this module rather than having to write the message again. It also allows us to change one line of code inside mymodule.py rather than in many different scripts if we ever decide to change the message we want to show in all the scripts that use this function.

Import a File in the Same Directory

Let’s say we have two Python files in the same directory:

mymodule.py contains the say_hello() function we saw above.

To call say_hello() from inside script.py , we can write in script.py :

import mymodule mymodule.say_hello()

The name used in the import statement is simply the module’s filename without the .py extension at the end.

Import a File in a Subdirectory (Python 3.3 and Up)

Python versions 3.3 and higher allow easy imports of modules in subdirectories of the current script’s directory. If you’re using a Python version lower than 3.3, you can follow the steps in Import a File in a Different Directory instead.

Let’s say we move mymodule.py to a subdirectory called subdir :

Then if we’re using Python 3.3 or higher, we can write in script.py :

import subdir.mymodule subdir.mymodule.say_hello()

In a file system path, we would separate the components of a path using / (Linux, macOS, etc.) or \ (Windows). In a Python import statement, however, we separate the path components using a dot ( . ).

We can also assign a shorter name for the module using an import — as statement:

import subdir.mymodule as m m.say_hello()

where m is any name we choose. We can also import the function directly:

from subdir.mymodule import say_hello say_hello()

This works even if there are multiple levels of subdirectories. For example, if we had the following directory structure:

we could write in script.py :

import alpha.beta.mymodule as mymodule mymodule.say_hello()

Import a File in a Different Directory

Now let’s say that we move mymodule.py to a directory that is outside of the current directory tree:

By default, Python looks for files in the same directory (including subdirectories) as the current script file, as well as in other standard locations defined in sys.path . If you’re curious what these locations are, you can print out the sys.path variable like this:

import sys for p in sys.path: print( p )

However, if the file we want to import is somewhere else entirely, we’ll first have to tell Python where to look by adding search directories to sys.path . In our example, we can write in script.py :

import sys sys.path.append( '/alpha/beta' ) import mymodule mymodule.say_hello()

Note that the path appended to sys.path is an absolute path. If we used a relative path, the path would resolve differently based on the directory from which the user is running the script, not relative to script.py ‘s path.

To append a directory relative to this script file, you can use __file__ to get the current script’s full path and build a full path to the import from there. In script.py we can write:

import os import sys script_dir = os.path.dirname( __file__ ) mymodule_dir = os.path.join( script_dir, '..', 'alpha', 'beta' ) sys.path.append( mymodule_dir ) import mymodule mymodule.say_hello()

Import Any File, Including Non- .py File Extension (Python 3.4 and Up)

Absolute Path

Python versions 3.4 and higher provide functionality through the built-in importlib library that allows us to load any file anywhere as a Python module, even if the file’s filename does not end in .py (it can have a different file extension, or no file extension at all).

For example, let’s say we have the following directory structure:

Notice here that the mymodule filename does not have a file extension. In this case, we can’t use a simple import statement to import that file. Instead, we can write in script.py :

import importlib.machinery import importlib.util # Import mymodule loader = importlib.machinery.SourceFileLoader( 'mymodule', '/alpha/beta/mymodule' ) spec = importlib.util.spec_from_loader( 'mymodule', loader ) mymodule = importlib.util.module_from_spec( spec ) loader.exec_module( mymodule ) # Use mymodule mymodule.say_hello()

Note that the path passed into SourceFileLoader() is an absolute path. If we used a relative path like ../alpha/beta/mymodule , the path would resolve differently based on the directory from which the user is running the script, not relative to script.py ‘s path.

Relative Path

If we want to reference a file relative to our current script file’s path, we can use __file__ to first get our current script file’s path, and then build a full path from there:

import importlib.machinery import importlib.util from pathlib import Path # Get path to mymodule script_dir = Path( __file__ ).parent mymodule_path = str( script_dir.joinpath( '..', 'alpha', 'beta', 'mymodule' ) ) # Import mymodule loader = importlib.machinery.SourceFileLoader( 'mymodule', mymodule_path ) spec = importlib.util.spec_from_loader( 'mymodule', loader ) mymodule = importlib.util.module_from_spec( spec ) loader.exec_module( mymodule ) # Use mymodule mymodule.say_hello()

References

Источник

Руководство по импорту функций в Python: примеры и методы

Руководство по импорту функций в Python: примеры и методы

Импорт функций из другого файла является общей практикой в Python. Это позволяет разделить код на модули, что делает его более удобным для чтения и поддержки.

Структура проекта

Перед тем, как начать рассматривать импорт функций, давайте посмотрим на стандартную структуру проекта Python. Как правило, проект содержит различные файлы и папки. Например:

my_project/ │ ├── module1.py ├── module2.py ├── my_package/ │ ├── __init__.py │ ├── submodule1.py │ └── submodule2.py └── main.py

В данном случае, у нас есть два модуля на верхнем уровне ( module1.py и module2.py ), пакет my_package , содержащий два подмодуля ( submodule1.py и submodule2.py ), и главный скрипт main.py .

Импортирование функций

Допустим, у нас есть функция в module1.py , которую мы хотим использовать в main.py . Это можно сделать, импортировав эту функцию.

# module1.py def greet(name): print(f'Hello, !')
# main.py from module1 import greet greet('Alice')

Здесь мы используем ключевое слово import чтобы импортировать функцию greet() из module1.py в main.py . После импортирования функции, мы можем вызывать её как обычно.

Использование алиасов для функций

В некоторых случаях, может быть удобно использовать алиас (или «псевдоним») для импортированной функции. Это особенно полезно, когда функция имеет длинное или не очень понятное имя, или когда вы хотите избежать конфликтов имен.

# main.py from module1 import greet as g g('Alice')

Теперь функция greet() может быть вызвана как g() .

Импорт всех функций из модуля

Иногда может быть удобно импортировать все функции из модуля. Это можно сделать с использованием * .

# main.py from module1 import * greet('Alice')

Однако, следует быть осторожным при использовании * для импорта, поскольку это может привести к конфликтам имен, если разные модули содержат функции с одинаковыми именами.

Импортирование функций из пакетов и подмодулей

Импортирование функций из пакетов и подмодулей происходит аналогичным образом.

# my_package/submodule1.py def farewell(name): print(f'Goodbye, !')
# main.py from my_package.submodule1 import farewell farewell('Alice')

Обратите внимание, что при импортировании из пакета, вы должны указать полный путь к функции, начиная с имени пакета.

Использование __init__.py

__init__.py — это особый файл, который Python автоматически запускает при импортировании пакета. Этот файл обычно используется для выполнения кода инициализации пакета или для указания, какие модули должны быть импортированы, когда импортируется весь пакет.

# my_package/__init__.py from .submodule1 import farewell from .submodule2 import some_other_function
# main.py from my_package import farewell farewell('Alice')

Здесь farewell() доступен для импорта напрямую из my_package , благодаря импорту в __init__.py .

Относительный и абсолютный импорт

В Python существуют два типа импорта: относительный и абсолютный. Абсолютный импорт использует полный путь к импортируемому модулю от корня проекта. Относительный импорт, с другой стороны, использует путь от текущего модуля до модуля, который вы хотите импортировать.

Абсолютный импорт обычно предпочтительнее, поскольку он делает более ясной структуру проекта и избегает возможной путаницы и ошибок. Однако в некоторых случаях относительный импорт может быть удобен.

# main.py from my_package.submodule1 import farewell # Абсолютный импорт # my_package/submodule1.py from .submodule2 import some_other_function # Относительный импорт

Заключение

Импортирование функций из другого файла — это важная часть структурирования вашего кода в Python. Это позволяет разделить код на модули и пакеты, делая его более организованным и удобным для поддержки.

Учтите, что при работе с импортами следует избегать циклических импортов и необходимо быть осторожными с использованием импорта с * , чтобы избежать конфликтов имен. Будьте внимательны к структуре вашего проекта и используйте абсолютные импорты, когда это возможно, для большей ясности.

Источник

Оцените статью