Как вызвать функцию из другого файла Python

Обновлено: 21.11.2024

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

Для этого в Python есть способ поместить определения в файл и использовать их в сценарии или в интерактивном экземпляре интерпретатора. Такой файл называется модулем; определения из модуля можно импортировать в другие модули или в главный модуль (набор переменных, к которым у вас есть доступ в скрипте, выполняемом на верхнем уровне, и в калькуляторе). режим).

Модуль — это файл, содержащий определения и операторы Python. Имя файла — это имя модуля с добавленным суффиксом .py. Внутри модуля имя модуля (в виде строки) доступно как значение глобальной переменной __name__. Например, с помощью вашего любимого текстового редактора создайте файл fibo.py в текущем каталоге со следующим содержимым:

Теперь войдите в интерпретатор Python и импортируйте этот модуль с помощью следующей команды:

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

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

6.1. Подробнее о модулях¶

Модуль может содержать исполняемые операторы, а также определения функций. Эти операторы предназначены для инициализации модуля. Они выполняются только в первый раз, когда имя модуля встречается в операторе импорта. 1 (Они также запускаются, если файл выполняется как скрипт.)

Каждый модуль имеет свою собственную таблицу символов, которая используется в качестве глобальной таблицы символов всеми функциями, определенными в модуле. Таким образом, автор модуля может использовать глобальные переменные в модуле, не беспокоясь о случайных столкновениях с глобальными переменными пользователя. С другой стороны, если вы знаете, что делаете, вы можете обращаться к глобальным переменным модуля с той же нотацией, которая используется для обозначения его функций, modname.itemname .

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

Существует вариант оператора импорта, который импортирует имена из модуля непосредственно в таблицу символов импортирующего модуля. Например:

Это не вводит имя модуля, из которого берутся импорты, в локальную таблицу символов (поэтому в примере фибо не определено).

Существует даже вариант импорта всех имен, определенных модулем:

При этом импортируются все имена, кроме тех, которые начинаются с символа подчеркивания ( _ ). В большинстве случаев программисты на Python не используют эту возможность, поскольку она вводит в интерпретатор неизвестный набор имен, возможно, скрывая некоторые вещи, которые вы уже определили.

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

Если за именем модуля следует as , то имя после as напрямую связано с импортированным модулем.

Это фактически импортирует модуль так же, как это делает import fibo, с той лишь разницей, что он доступен как fib .

Его также можно использовать при использовании from с аналогичными эффектами:

Из соображений эффективности каждый модуль импортируется только один раз за сеанс интерпретатора. Поэтому, если вы меняете свои модули, вы должны перезапустить интерпретатор — или, если вы хотите протестировать только один модуль в интерактивном режиме, используйте importlib.reload() , например импортировать импортную библиотеку; importlib.reload(имя модуля) .

6.1.1. Выполнение модулей как скриптов¶

Когда вы запускаете модуль Python с

код в модуле будет выполнен так же, как если бы вы его импортировали, но с __name__, установленным на "__main__" . Это означает, что, добавив этот код в конец вашего модуля:

вы можете сделать файл пригодным для использования как скрипт, а также как импортируемый модуль, потому что код, анализирующий командную строку, запускается только в том случае, если модуль выполняется как «основной» файл:

Если модуль импортирован, код не запускается:

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

6.1.2. Путь поиска модуля¶

Когда импортируется модуль с именем spam, интерпретатор сначала ищет встроенный модуль с таким именем. Если он не найден, он ищет файл с именем spam.py в списке каталогов, заданном переменной sys.path. sys.path инициализируется из следующих мест:

Каталог, содержащий входной скрипт (или текущий каталог, если файл не указан).

PYTHONPATH (список имен каталогов с тем же синтаксисом, что и переменная оболочки PATH ).

Зависимое от установки значение по умолчанию (по соглашению включает каталог site-packages, обрабатываемый модулем site).

В файловых системах, поддерживающих символические ссылки, каталог, содержащий входной скрипт, вычисляется после перехода по символической ссылке. Другими словами, каталог, содержащий символическую ссылку, не добавляется в путь поиска модуля.

После инициализации программы Python могут изменять sys.path . Каталог, содержащий выполняемый скрипт, помещается в начало пути поиска перед стандартным путем библиотеки. Это означает, что скрипты в этом каталоге будут загружены вместо одноименных модулей в каталоге библиотеки. Это ошибка, если замена не предназначена. Дополнительную информацию см. в разделе Стандартные модули.

6.1.3. «Скомпилированные» файлы Python¶

Чтобы ускорить загрузку модулей, Python кэширует скомпилированную версию каждого модуля в каталоге __pycache__ под именем module. версия .pyc , где версия кодирует формат скомпилированного файла; обычно он содержит номер версии Python. Например, в выпуске CPython 3.3 скомпилированная версия spam.py будет кэшироваться как __pycache__/spam.cpython-33.pyc. Это соглашение об именах позволяет сосуществовать скомпилированным модулям из разных выпусков и разных версий Python.

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

Python не проверяет кэш в двух случаях. Во-первых, он всегда перекомпилирует и не сохраняет результат для модуля, загруженного непосредственно из командной строки. Во-вторых, он не проверяет кэш, если нет исходного модуля. Для поддержки не исходного (только скомпилированного) дистрибутива скомпилированный модуль должен находиться в исходном каталоге, и не должно быть исходного модуля.

Несколько советов для экспертов:

Вы можете использовать ключи -O или -OO в команде Python, чтобы уменьшить размер скомпилированного модуля. Переключатель -O удаляет утверждения утверждений, переключатель -OO удаляет как утверждения утверждений, так и строки __doc__. Поскольку некоторые программы могут полагаться на их доступность, вам следует использовать эту опцию только в том случае, если вы знаете, что делаете. «Оптимизированные» модули имеют тег opt-tag и обычно меньше по размеру. В будущих версиях результаты оптимизации могут быть изменены.

При чтении из файла .pyc программа работает не быстрее, чем при чтении из файла .py; единственное, что быстрее в файлах .pyc, — это скорость их загрузки.

Модуль compileall может создавать файлы .pyc для всех модулей в каталоге.

Подробнее об этом процессе, включая блок-схему решений, см. в PEP 3147.

6.2. Стандартные модули¶

Python поставляется с библиотекой стандартных модулей, описанных в отдельном документе — Справочнике по библиотеке Python (далее — «Справочник по библиотеке»). Некоторые модули встроены в интерпретатор; они обеспечивают доступ к операциям, которые не являются частью ядра языка, но, тем не менее, встроены либо для повышения эффективности, либо для предоставления доступа к примитивам операционной системы, таким как системные вызовы. Набор таких модулей является опцией конфигурации, которая также зависит от базовой платформы. Например, модуль winreg предоставляется только в системах Windows. Отдельного внимания заслуживает один конкретный модуль: sys, встроенный в каждый интерпретатор Python. Переменные sys.ps1 и sys.ps2 определяют строки, используемые в качестве основных и дополнительных подсказок:

Эти две переменные определяются только в том случае, если интерпретатор находится в интерактивном режиме.

Переменная sys.path представляет собой список строк, определяющих путь поиска модулей интерпретатором. Он инициализируется путем по умолчанию, взятым из переменной среды PYTHONPATH или из встроенного значения по умолчанию, если PYTHONPATH не задан. Вы можете изменить его, используя стандартные операции со списками:

6.3. Функция dir()¶

Встроенная функция dir() используется для определения имен, определяемых модулем. Он возвращает отсортированный список строк:

Без аргументов dir() перечисляет имена, которые вы определили в данный момент:

Обратите внимание, что в нем перечислены все типы имен: переменные, модули, функции и т. д.

dir() не перечисляет имена встроенных функций и переменных.Если вам нужен их список, они определены в стандартных встроенных модулях:

6.4. Пакеты¶

Пакеты — это способ структурирования пространства имен модулей Python с помощью «точечных имен модулей». Например, имя модуля A.B обозначает подмодуль с именем B в пакете с именем A. Точно так же, как использование модулей избавляет авторов разных модулей от необходимости беспокоиться об именах глобальных переменных друг друга, использование имен модулей с точками избавляет авторов многомодульных пакетов, таких как NumPy или Pillow, от необходимости беспокоиться об именах модулей друг друга. .

Предположим, вы хотите разработать набор модулей («пакет») для единообразной обработки звуковых файлов и звуковых данных. Существует множество различных форматов звуковых файлов (обычно распознаваемых по их расширениям, например: .wav, .aiff, .au), поэтому вам может потребоваться создать и поддерживать растущую коллекцию модулей для преобразования между различными форматами файлов. Существует также множество различных операций, которые вы, возможно, захотите выполнить со звуковыми данными (например, микширование, добавление эха, применение функции эквалайзера, создание искусственного стереоэффекта), так что, кроме того, вы будете писать нескончаемый поток модулей для выполнения. эти операции. Вот возможная структура вашего пакета (выраженная в терминах иерархической файловой системы):

При импорте пакета Python просматривает каталоги sys.path в поисках подкаталога пакета.

Файлы __init__.py необходимы для того, чтобы Python рассматривал каталоги, содержащие файл, как пакеты. Это предотвращает непреднамеренное сокрытие допустимых модулей каталогами с общим именем, таким как string , которые встречаются позже в пути поиска модулей. В простейшем случае __init__.py может быть просто пустым файлом, но он также может выполнять код инициализации пакета или устанавливать переменную __all__, описанную ниже.

Пользователи пакета могут импортировать отдельные модули из пакета, например:

Это загружает подмодуль sound.effects.echo. На него должно указываться его полное имя.

Альтернативный способ импорта подмодуля:

Это также загружает подмодуль echo и делает его доступным без префикса пакета, поэтому его можно использовать следующим образом:

Еще один вариант — импортировать нужную функцию или переменную напрямую:

Опять же, это загружает подмодуль echo , но делает его функцию echofilter() доступной напрямую:

Обратите внимание, что при использовании элемента импорта из пакета элемент может быть либо подмодулем (или подпакетом) пакета, либо каким-либо другим именем, определенным в пакете, например, функцией, классом или переменной. Оператор импорта сначала проверяет, определен ли элемент в пакете; если нет, он предполагает, что это модуль, и пытается загрузить его. Если его не удается найти, возникает исключение ImportError.

Наоборот, при использовании синтаксиса наподобие import item.subitem.subsubitem каждый элемент, кроме последнего, должен быть пакетом; последний элемент может быть модулем или пакетом, но не может быть классом, функцией или переменной, определенной в предыдущем элементе.

6.4.1. Импорт * из пакета¶

Что происходит, когда пользователь пишет из sound.effects import * ? В идеале можно было бы надеяться, что это каким-то образом выйдет в файловую систему, найдет, какие подмодули присутствуют в пакете, и импортирует их все. Это может занять много времени, а импорт подмодулей может привести к нежелательным побочным эффектам, которые должны иметь место только при явном импорте подмодуля.

Единственным решением для автора пакета является предоставление явного индекса пакета. В операторе импорта используется следующее соглашение: если код пакета __init__.py определяет список с именем __all__ , он считается списком имен модулей, которые следует импортировать, когда встречается from package import *. Автор пакета должен поддерживать этот список в актуальном состоянии при выпуске новой версии пакета. Авторы пакетов также могут принять решение не поддерживать его, если они не видят смысла в импорте * из своего пакета. Например, файл sound/effects/__init__.py может содержать следующий код:

Это будет означать, что из sound.effects import * будут импортированы три именованных подмодуля звукового пакета.

Если __all__ не определено, инструкция из sound.effects import * не импортирует все подмодули из пакета sound.effects в текущее пространство имен; это только гарантирует, что пакет sound.effects был импортирован (возможно, запуск любого кода инициализации в __init__.py ), а затем импортирует любые имена, определенные в пакете. Сюда входят любые имена, определенные (и явно загруженные подмодули) с помощью __init__.py. Он также включает любые подмодули пакета, которые были явно загружены предыдущими операторами импорта. Рассмотрим этот код:

В этом примере модули эха и объемного звучания импортируются в текущее пространство имен, так как они определены в пакете sound.effects, когда файл from. выполняется оператор импорта.(Это также работает, когда определено __all__.)

Несмотря на то, что некоторые модули предназначены для экспорта только тех имен, которые соответствуют определенным шаблонам при использовании import * , это по-прежнему считается плохой практикой в ​​производственном коде.

Помните, что нет ничего плохого в использовании from package importspecific_submodule ! На самом деле это рекомендуемая нотация, если импортирующему модулю не нужно использовать подмодули с одинаковыми именами из разных пакетов.

6.4.2. Внутрипакетные ссылки¶

Когда пакеты структурированы в подпакеты (как в случае со звуковым пакетом в примере), вы можете использовать абсолютный импорт для ссылки на подмодули одноуровневых пакетов. Например, если модулю sound.filters.vocoder необходимо использовать модуль echo в пакете sound.effects, он может использовать from sound.effects import echo .

Вы также можете написать относительный импорт с формой имени импорта из модуля в операторе импорта. Эти импорты используют начальные точки для обозначения текущего и родительского пакетов, участвующих в относительном импорте. Например, из модуля объемного звучания вы можете использовать:

Обратите внимание, что относительный импорт основан на имени текущего модуля. Поскольку имя основного модуля всегда "__main__" , модули, предназначенные для использования в качестве основного модуля приложения Python, всегда должны использовать абсолютный импорт.

6.4.3. Пакеты в нескольких каталогах¶

Пакеты поддерживают еще один специальный атрибут — __path__ . Он инициализируется как список, содержащий имя каталога, содержащего __init__.py пакета, до выполнения кода в этом файле. Эту переменную можно изменить; это повлияет на дальнейший поиск модулей и подпакетов, содержащихся в пакете.

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

Фактически определения функций также являются «операторами», которые «выполняются»; выполнение определения функции на уровне модуля вводит имя функции в глобальную таблицу символов модуля.

Set_up: у меня есть файл .py для каждой функции, которую мне нужно использовать в программе.

В этой программе мне нужно вызвать функцию из внешних файлов.

Но я получаю сообщение об ошибке:

ImportError: Нет модуля с именем 'file.py'; файл не является пакетом

Как решить эту проблему?

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

19 ответов 19

Нет необходимости добавлять file.py во время импорта. Просто напишите из функции импорта файла, а затем вызовите функцию, используя function(a, b) . Причина, по которой это может не работать, заключается в том, что файл является одним из основных модулей Python, поэтому я предлагаю вам изменить имя вашего файла.

Обратите внимание: если вы пытаетесь импортировать функции из a.py в файл с именем b.py , вам необходимо убедиться, что a.py и b.py находятся в одном каталоге.

"Файл" был просто заполнителем для вопроса, который я задаю, а не фактическим именем файла. Однако, спасибо. Я попробую это и вернусь к вам.

Я попробовал это, но ошибка все равно появляется: это как-то связано с Python 3 или это общая проблема?

@GamesBrainiac, что, если файл, из которого вы хотите импортировать функции, находится в другом каталоге? Могу ли я указать путь к файлу перед именем файла или есть что-то более сложное?

Во-первых, вам не нужен .py .

Если у вас есть файл a.py и внутри у вас есть какие-то функции:

И вы хотите импортировать их в z.py, вы должны написать

Это можно сделать двумя способами. Во-первых, просто импортируйте нужную функцию из file.py. Для этого используйте

Другой способ – импорт всего файла

Затем вы можете вызвать любую функцию внутри file.py с помощью

Если ваш файл находится в другой структуре пакета и вы хотите вызвать его из другого пакета, вы можете вызвать его следующим образом:

Допустим, у вас есть следующая структура пакета в вашем проекте Python:

в файле Python com.my.func.DifferentFunction у вас есть некоторая функция, например:

И вы хотите вызвать другие функции из Example3.py , тогда вы можете сделать это следующим образом:

Если вы новичок в Python и наткнулись на этот вопрос, я приглашаю вас продолжить чтение, пока я обсуждаю, как вызвать функцию из другого файла. Скорее всего, вы уже использовали некоторые встроенные функции Python, такие как print() и len(). Но что, если вы определили свою собственную функцию, сохранили ее в файле и хотите вызвать ее в другом файле?

Импортируйте!

Если вы когда-либо импортировали что-то вроде random, NumPy или math, то это действительно так просто! Если нет, то вот краткий обзор того, как это делается.

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

Сначала мы импортируем его.

Чтобы просмотреть доступные функции и атрибуты модуля, используйте встроенную функцию dir() :

Функция для вычисления квадратного корня называется sqrt. И мы будем использовать точечную нотацию для его вызова:

В качестве альтернативы вы можете использовать ключевое слово «из», за которым следует имя модуля, и «импорт», за которым следует атрибут или функция. Таким образом, нам больше не нужно использовать запись через точку при вызове функции извлечения квадратного корня.

И, как и ожидалось, для доступа к другим функциям или атрибутам по-прежнему требуется запись через точку:

Пользовательские функции

По мере того, как вы продвигаетесь в программировании на Python, вы в конечном итоге будете создавать свои собственные функции и реализовывать их в других программах. В качестве примера мы проиллюстрируем это на простом калькуляторе чаевых. Я приглашаю вас следовать за нами.

Откройте свой любимый редактор Python. В настоящее время я использую Linux, поэтому в этом примере я просто использую vi. Я назову свой файл «myfunctions.py».

Вот определение функции:

Теперь, чтобы вызвать функцию из другого файла в Python, мы просто используем «import», за которым следует имя вашего файла .py:

Если в вашем файле есть несколько функций и вы хотите их увидеть, не забудьте использовать функцию dir. В нашем случае отображается только функция calcTip:

Кроме того, не забывайте, что мы можем использовать альтернативный метод, если вы хотите пропустить запись через точку:

На что обратить внимание

Обратите внимание, что в моем примере, когда я запускал интерпретатор Python, он находился в том же рабочем каталоге, что и файл myfunctions.py. Если вы не знакомы с Linux, знак доллара — это командная строка.

  • pwd = печатать рабочий каталог
    • Текущий каталог — «/home/pete/Videos/Python»
    • Здесь находится файл myfunctions.py

    На приведенном ниже снимке экрана показано, как я изменил рабочий каталог на домашний (~) и запустил pwd, чтобы показать текущий путь к каталогу. Затем я запускаю интерпретатор Python и пытаюсь импортировать файл myfunctions. Теперь он показывает « ModuleNotFoundError », потому что файл находится не в текущем каталоге.

    Если вы используете IDE, убедитесь, что ваш файл находится в вашем проекте. На приведенном ниже снимке экрана показана среда разработки Spyder с проектом под названием «Пример функции». Снимок экрана: файл «myfunctions.py» с определением функции calcTip:

    Снимок экрана с файлом main.py. Эта конкретная IDE действительно хороша, потому что, поскольку файл «myfunctions.py» находится в нашем проекте, автозаполнение обнаруживает его, когда я его импортирую.

    Вот вывод консоли при запуске файла main.py с передачей переменной " bill " в функцию calcTip:

    Вот как вызвать функцию из другого файла в Python. Я надеюсь, что вы нашли эту статью полезной и с нетерпением ждем новых статей! До скорой встречи!

    Почему Finxter?

    "Дайте мне достаточно длинный рычаг [. ], и я переверну мир." 🌍 - Архимед

    Finxter стремится быть вашим рычагом! Наша единственная цель — увеличить коллективный интеллект человечества с помощью учебных пособий по программированию, чтобы вы могли использовать бесконечный вычислительный интеллект для своего успеха! 🧠

    Учебные ресурсы

    Присоединяйтесь к нашей бесплатной академии электронной почты с более чем 1000 руководств по Python, фрилансу, науке о данных и машинному обучению, а также технологии блокчейн!

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

    Если создается новый файл с именем myfunctions.py, содержащий два определения функций, plustwo() и falldist() , функции plustwo() и falldist() могут использоваться отдельным скриптом. если имена файлов и функций сначала импортируются в отдельный скрипт. Важно, чтобы файл, содержащий определения функций, заканчивался расширением .py. Без расширения .py файл, в котором определены функции, не может быть импортирован.

    В файле myfuctions.py определены две функции с помощью приведенного ниже кода.

    Этот файл myfunctions.py можно импортировать в другой скрипт (другой файл .py) или Jupyter Notebook.

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

    Чтобы использовать функции, записанные в одном файле, внутри другого файла, включите строку импорта from filename import имя_функции . Обратите внимание, что хотя имя файла должно содержать расширение .py, расширение .py не используется как часть имени файла во время импорта.

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

    Пример использования этого синтаксиса с файлом myfunctions.py и функцией plustwo() приведен ниже:

    Можно импортировать несколько функций из одного файла, разделив импортированные функции запятыми. Ниже приведен общий синтаксис для импорта и вызова нескольких функций из одного файла:

    Пример использования этого синтаксиса с файлом myfunctions.py и функциями plustwo() и falldist() приведен ниже:

    Еще один способ импортировать и использовать функции из myfunctions.py в другой скрипт или блокнот Jupyter — импортировать весь файл myfunctions.py с помощью import myfunctions , а затем вызвать функции с приведенным ниже синтаксисом.

    Пример использования этого синтаксиса с файлом myfunctions.py приведен ниже.

    Этот урок частично основан на уроках группы Software Carpentry по программированию на Python.

    Что такое функция?¶

    Функция – это блок организованного повторно используемого кода, который может сделать ваши сценарии более эффективными, более легкими для чтения и простыми в управлении. Вы можете думать о функциях как о маленьких автономных программах, которые могут выполнять определенную задачу, которую вы можете многократно использовать в своем коде. Один из основных принципов хорошего программирования — «не повторяйся». Другими словами, вам следует избегать повторяющихся строк кода в ваших скриптах. Функции — это хороший способ избежать таких ситуаций, и они могут сэкономить вам много времени и усилий, поскольку вам не нужно постоянно указывать компьютеру, что делать каждый раз, когда он выполняет стандартную задачу, такую ​​как преобразование температуры из градусов Фаренгейта в градусы Цельсия. . В ходе курса мы уже использовали некоторые функции, такие как команда print(), которая на самом деле является встроенной функцией Python.

    Структура функции¶

    Давайте рассмотрим задачу из первого урока, когда мы переводили температуры из градусов Цельсия в градусы Фаренгейта. Такая операция является довольно распространенной задачей при работе с температурными данными. Таким образом, нам может потребоваться довольно часто повторять такие расчеты, например, при анализе или сравнении данных о погоде или климате между США и Европой.

    Давайте определим нашу первую функцию с именем celsiusToFahr:

    Структура функции

    Определение функции открывается ключевым словом def, за которым следует имя функции и список имен параметров в скобках. Тело функции — операторы, которые выполняются при ее запуске, — располагается с отступом ниже строки определения.

    Когда мы вызываем функцию, значения, которые мы ей передаем, присваиваются соответствующим переменным параметров, чтобы мы могли использовать их внутри функции (например, переменная tempCelsius в этом примере функции). Внутри функции мы используем оператор return для определения значения, которое должно быть возвращено, когда функция используется или вызывается).

    Вызов функций¶

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

    Теперь, когда мы знаем, как создать функцию для преобразования градусов Цельсия в градусы Фаренгейта, давайте создадим еще одну функцию с именем kelvinsToCelsius :

    И давайте использовать его так же, как предыдущий:

    Как насчет преобразования градусов Кельвина в градусы Фаренгейта? Мы могли бы написать для него новую формулу, но нам это не нужно. Вместо этого мы можем выполнить преобразование, используя две уже созданные функции и вызывая их из функции, которую мы сейчас создаем:

    Теперь воспользуемся функцией:

    Сохранение и загрузка функций¶

    Функции, подобные только что созданным, также можно вызывать из другого скрипта. На самом деле, довольно часто бывает полезно создать специальную библиотеку функций для функций, которые вы часто используете, например, при анализе данных. В основном это делается путем перечисления полезных функций в одном файле .py, из которого затем вы можете импортировать и использовать их при необходимости.

    Сохранение функций в файле скрипта¶

    Прежде чем мы сможем импортировать наши функции, нам нужно создать новый файл сценария и сохранить только что созданные функции в файл Python с именем temp_converter.py .

    Мы могли бы снова записать функции в наш файл сценария, но мы также можем воспользоваться вкладкой журнала истории в Spyder, где мы должны найти все команды, которые мы ввели в консоли IPython [1]:

    Журнал истории в Spyder

    Скопируйте и вставьте (только) функции, которые мы написали ранее, с вкладки Журнал истории и сохраните их в скрипте temp_converter.py (при желании вы можете просто снова записать их в файл, если хотите попрактиковаться). Это должно выглядеть следующим образом:

    Сценарий temp_converter.py. Обратите внимание, что названия наших функций немного отличаются от названий на изображении.

    Вызов функций из другого файла скрипта¶

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

    Давайте создадим еще один файл сценария с именем calculate.py .

    Сохраните файл в той же папке, где вы сохранили файл temp_converter.py [2].

    Теперь давайте импортируем нашу функцию celsiusToFahr из другого скрипта, добавив специальный оператор импорта в начало нашего скрипта calculate.py. Давайте также воспользуемся функцией, чтобы убедиться, что она работает [3]:

    Запустите код, нажав клавишу F5 или нажав кнопку воспроизведения в Spyder. Теперь мы должны получить следующий вывод:

    Использование функции из другого скрипта

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

    Иногда бывает полезно импортировать сразу весь скрипт и все его функции. Давайте изменим оператор импорта в нашем скрипте и проверим, что все функции работают [4]:

    Калькулятор температуры (необязательно, дополнительная тема)¶

    До сих пор наши функции имели только один параметр, но также можно определить функцию с несколькими параметрами. Давайте теперь создадим простую функцию tempCalculator, которая принимает значения температуры в градусах Кельвина и возвращает значения в градусах Цельсия или Фаренгейта. Новая функция будет иметь два параметра:

    • tempK = Параметр для передачи температуры в Кельвинах.
    • convertTo = Параметр, определяющий, должен ли быть вывод в градусах Цельсия или Фаренгейта (с использованием букв C или F соответственно)

    Давайте начнем определение нашей функции, дав ей имя и задав параметры:

    Далее нам нужно добавить условные операторы, которые проверяют, нужна ли выходная температура в градусах Цельсия или Фаренгейта, а затем вызывают соответствующую функцию, импортированную из файла temp_converter.py.

    Далее нам нужно добавить оператор return, чтобы наша функция отправляла обратно интересующее нас значение:

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

    Вот оно! Теперь у нас есть калькулятор температуры с простым управлением для пользователя, где он/она может изменить вывод, используя параметр convertTo. Теперь, когда мы добавили короткую строку документации в начало функции, мы можем использовать функцию help() в Python, чтобы узнать, как следует использовать нашу функцию. Запустите скрипт и попробуйте следующее:

    [1]Вкладку журнала истории можно найти в том же панель, на которой мы выполнили наши коды (внизу справа, рядом с консолью IPython).
    [2]При обмене данными между файлами сценариев необходимо хранить их в одной папке, чтобы Python мог их найти (есть и другие способы, кроме этого проще всего).
    [3 ]Следуя принципам хорошего программирования, операторы импорта, которые вы используете, всегда должны быть написаны в верхней части файла сценария.

    Также можно импортировать функции, используя специальный символ *:

    Недостаток использования символа * для импорта всех функций заключается в том, что вы не увидите, какие функции импортируются, если только не проверите их из самого скрипта или не воспользуетесь функцией dir() для их вывода (см. урок о модулях).

    Мы не рекомендуем импортировать функции, используя этот подход, так как при этом существует риск конфликта имен функций. Пожалуйста, используйте с осторожностью

    © © Tenkanen & Whipp, Хельсинкский университет, 2017 г., редакция 2f9a568f.

    Последняя стабильная версия 2019 2017.1 development Загрузки в Read the Docs Домашняя страница проекта Сборки Бесплатный хостинг документов, предоставляемый Read the Docs.

    Читайте также:

    [4]