Файлы __init__.py пакетов

Если вы решили использовать импортирование пакетов, существует еще одно условие, которое необходимо будет соблюдать: каждый каталог в пути, указанном в инструкции импортирования пакета, должен содержать файл с именем __init__.py, в противном случае операция импорта пакета будет терпеть неудачу. То есть в примере выше каталоги dir1 и dir2 должны содержать файл с именем __init__.py каталог-контейнер dir0 может не содержать такой файл, потому что сам он не указан в инструкции импортирования пакета. Точнее говоря, для такой структуры каталогов:
dir0\dir1\dir2\mod.py
и инструкции импортирования, имеющей следующий вид:
import dir1.dir2.mod
применяются следующие правила:
•  dir1 и dir2 должны содержать файл __init__.py.
•  dir0, каталог-контейнер, может не содержать файл __init__.py – этот файл
будет проигнорирован, если он присутствует.
•  dir0, но не dir0\dir1, должен присутствовать в пути поиска модулей (то есть он  должен  быть  домашним  каталогом  или  присутствовать  в  переменной окружения PYTHONPATH и так далее).

Таким образом, структура каталогов в этом примере должна иметь следующий вид (здесь отступы указывают на вложенность каталогов):

Основы операции импортирования пакетов

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

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

Основы использования функции reload

В отличие от инструкций import и from:
•  reload – это не инструкция, а функция.
•  Функции reload передается существующий объект модуля, а не имя.
•  В Python 3.0 функции reload находится в модуле imp, который требуется импортировать, чтобы получить доступ к функции. Функция reload ожидает получить объект, поэтому к моменту ее вызова модуль уже должен быть успешно импортирован (если операция импорта оказалась неудачной из-за синтаксических или каких-либо других ошибок, вам может потребоваться повторить ее, прежде чем можно будет повторно загрузить модуль).

Повторная загрузка модулей

Как мы уже видели, программный код модуля по умолчанию запускается всего один раз за все время работы программы. Чтобы принудительно повторно загрузить модуль и запустить программный код в нем, необходимо явно вызвать встроенную функцию reload. В этом разделе мы исследуем, как использовать возможность повторной загрузки модулей, чтобы сделать систему более динамичной. В двух словах:
•  При  вызове  операции  импортирования  (с  помощью  инструкций  import и from) программный код модуля загружается и выполняется, только когда модуль импортируется в первый раз за время работы программы.
•  При последующих попытках импортировать модуль будет использоваться объект уже загруженного модуля. Повторная загрузка и запуск программного кода в этом случае не происходит.

Вложенные пространства имен

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

Импортирование и области видимости

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

Квалификация имен атрибутов

Здравствуйте посетители и читатели. Перед тем как начну, хочу поздравить всех с наступившим новым 2015 годом и с прошедшими праздниками. Ну и всем удачи и успехов в поисках работы или же просто в работе... так как от нее будет зависеть - то, на сколько Вам сладко придется жить :)

Немного напомню, что в моих постах информации из замечательной книги... Сам я в питоне пока не шарю, так как я веб программист который в основном сталкивается с РНР,НТМЛ и т.д. - но в последнее время ЯваСкрипт начинает нравиться... думаю скоро выложить на своем втором блоге - про рнр информацию о том, на сколько нужно шарить, чтоб пройти хотяб на джуниора и немножко выше, а так же я постараюсь создать блог на yii с небольшим обьяснением. Ну и собственно ссылка на мой второй блог - http://phpekurs.blogspot.com/ надеюсь я не буду затягивать со временем выпуска материалов как это бывает с этим блогом. Ну что ж, теперь приступим к теме....

После  ознакомления  с модулями  мы  должны  поближе  рассмотреть  понятие квалификации имен. В языке Pythonдля доступа к атрибутам любого объекта используется синтаксис квалификации имени object.attribute.

Пространства имен модулей

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

Равны ли import и from ?

В предыдущей записи после from потребовалось выполнить инструкцию import, чтобы получить доступ к имени модуля  small,  –  инструкция  from  копирует  только  имена  из одного  модуля в другой и ничего не присваивает самому имени модуля. Инструкция  from,
приведенная ниже:
from module import name1, name2    # Копировать только эти два имени
эквивалентна следующей последовательности, по крайней мере, концептуально:
import module          # Получить объект модуля
name1 = module.name1   # Скопировать имена с помощью присваивания
name2 = module.name2
del module             # Удалить имя модуля

Как и все операции присваивания, инструкция from создает новые переменные в импортирующем модуле, которые ссылаются на объекты с теми же именами в импортируемом файле. При этом копируются только имена, а не сам модуль. При использовании формы from * этой инструкции (from module import *) эквивалентная последовательность действий та же самая, только при этом копируются все имена, определенные на верхнем уровне импортируемого модуля.

Обратите внимание, что на первом шаге инструкция from выполняет обычную операцию import. Вследствие этого инструкция from всегда импортирует весь модуль целиком, если он еще не был импортирован, независимо от того, сколько  имен  копируется  из  файла.  Нет  никакой  возможности  загрузить  только часть модуля (например, только одну функцию), но так как модули – это байт-код, а не машинный код, влияние на производительность оказывается незначительным.

Не забываем ставить лайк и репосты, чем больше лайков тем больше тут будет постов )

Поменять значение имен в других файлах

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

Чтобы изменить глобально переменную в определенном файле, необходимо использовать инструкцию import:
% python
>>> from small import x, y     # Скопировать два имени
>>> x = 42                     # Изменить только локальное имя x

>>> import small               # Получить имя модуля
>>> small.x = 42               # Изменить x в другом модуле

Вот такой короткий пост, скоро будет еще один...

Операции присваивания в import и from

Так же, как и инструкция def, инструкции import и from являются выполняемыми  инструкциями,  а  не  объявлениями  времени  компиляции.  Они  могут вкладываться в условные инструкции if, присутствовать в объявлениях функций def и так далее, и они не имеют никакого эффекта, пока интерпретатор не достигнет их в ходе выполнения программы. Другими словами, импортируемые модули и имена в них не будут доступны, пока не будут выполнены соответствующие инструкции import или from. Кроме того, подобно инструкции def, import и from – это явные операции присваивания:

•  Инструкция import присваивает объект модуля единственному имени.
•  Инструкция from присваивает одно или более имен объектам с теми же именами в другом модуле.

Почему import перестает работать?

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

import и from - функции для использования модулей

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

Файл модуля с расширением .py можно подключить используя команды import или же from. Эти функции могут отыскать и загрузить файл модуля, если этого еще не было сделано.
Отличие у этих команд в том что:
import - загружает модуль целиком;
from - загружает или же копирует отдельные имена из модуля.

Теперь несколько примеров для каждой:

Основы программирования модулей

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

Чтобы определить модуль, достаточно воспользоваться текстовым редактором, я использую Sublime Text, с его помощью ввести некоторый программный код на языке Python в текстовый файл и сохранить его с расширением «.py» – любой такой файл автоматически
будет считаться модулем Python. Все имена, которым будет выполнено присваивание на верхнем уровне модуля, станут его атрибутами (именами, ассоциированными с объектом модуля) и будут доступны для использования клиентами.

Операции импорта, углубляемся

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

Что ж с наступившим вас 2014 годом и с продолжением темы)

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

Выбор файла модуля

Как говорится - от теории к практике...

Выбор Файла Модуля

Расширения .py преднамеренно опущены в инструкции import. Интерпретатор Python выбирает первый найденный в пути поиска файл который соответствует указанному имени. В таком случае инструкция import b могла бы загрузить:

Создание путей поиска модуля, углубление

От теории к практике
так сказать углубляемся...

Пути поиска модулей, углубляемся

Из  всего  предыдущего поста следует,  что  переменная  окружения  PYTHONPATH 

и файлы .pth позволяют вам определять каталоги, где интерпретатор будет искать  файлы при  выполнении  операции  импортирования.  Способ  настройки переменных окружения и имена каталогов, где могут храниться файлы .pth, зависит от типа платформы. Например, в Windows можно воспользоваться ярлыком Система (System) в панели управления, чтобы записать в переменную PYTHONPATH список каталогов, разделенных точкой с запятой, как показано ниже:

c:\pycode\utilities;d:\pycode\package1

Или создать текстовый файл с именем C:\Python30\pydirs.pth, который выглядит примерно так:

c:\pycode\utilities

d:\pycode\package1

Аналогичным образом выполняются настройки и на других платформах.

Автоматическое изменение пути поиска

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

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

импорта.

Чтобы увидеть, как интерпретатор настраивает путь поиска модулей на вашей платформе, вы можете проверить содержимое переменной sys.path, обсуждение которой является темой следующего поста.

Список sys.path

Если вам потребуется узнать, как выглядит путь поиска на вашей машине, вы всегда сможете сделать это, просмотрев содержимое встроенного списка sys.path. Этот список строк с именами каталогов представляет собой путь поиска, используемый интерпретатором, – при выполнении операций импорта Python просматривает каждый каталог из списка, слева направо.

Действительно, sys.path – это путь поиска модулей. Интерпретатор создает его во время запуска программы, автоматически объединяя в список домашний каталог все каталоги, перечисленные в переменной окружения PYTHONPATH и в файлах .pth,  и  каталоги стандартной  библиотеки.  В  результате  получается  список строк с именами каталогов, которые просматриваются интерпретатором при импортировании новых файлов.

Представление языком Python этого списка имеет два основных полезных результата. 

Во-первых, он обеспечивает возможность проверить настройки пути поиска, которые вы выполнили, – если вы не видите свои настройки в этом списке каталогов, вам следует проверить, насколько правильно вы все проделали. Например, ниже показано, как выглядит путь поиска модулей у меня, в операционной системе Windows в Python 3.0, с моими     настройками переменной окружения PYTHONPATH, куда записан каталог C:\users, и с моим файлом C:\Python30\mypath.pth, содержащим путь к каталогу C:\users\mark. Пустая строка в начале списка соответствует текущему рабочему каталогу, а мои настройки объединены с системными (остальные пути в списке – это каталоги 

стандартной библиотеки):

>>> import sys

>>> sys.path

[‘’, ‘C:\\users’, ‘C:\\Windows\\system32\\python30.zip’, ‘c:\\Python30\\DLLs’,

‘c:\\Python30\\lib’, ‘c:\\Python30\\lib\\plat-win’, ‘c:\\Python30’,

‘C:\\Users\\Mark’, ‘c:\\Python30\\lib\\site-packages’]

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

Разобравшись с настройкой путей для модулей, в следующем посте будет показано импортирование файлов модулей

Продолжаем про импорт

Первое из разъяснений про импорт:

Это будет...

Поиск Пути Модулей

Как известно программистам, или же начинающим программистам, что важным этапом является поиск импортируемого модуля. Но для того чтоб этот поиск сработал, вам необходимо будет указать интерпретатору, где его искать. Для того, чтоб это сделать, вам необходимо знать, как это сделать. Именно для этого и создаю этот пост.

Как работает импорт

В предыдущих постах говорилось об импортировании модулей, но никак не объяснялось, что происходит во время импорта.  Так как в языке Python  инструкции импортирования составляют основу структуры программы, в  этом разделе  более  подробно будет  рассмотрена  операция импорта, чтобы  сделать представление об этом процессе менее абстрактным.

Как организована программа

Как правило, программа на языке Python состоит из множества текстовых файлов, содержащих инструкции. Программа организована как один главный файл, к которому могут подключаться дополнительные файлы, известные как модули. Главный файл (или сценарий) определяет, как будет двигаться основной поток выполнения программы, – это тот файл, который необходимо запустить, чтобы начать работу приложения. Файлы модулей – это библиотеки инструментальных средств, где содержатся компоненты, используемые главным файлом (и,
возможно, где-то еще). Главный файл использует инструменты, определенные в файлах модулей, а модули используют инструменты, определенные в других модулях.

Обычно файлы  модулей ничего не делают, если попытаться запустить их отдельно – в них определяются инструментальные средства, используемые в других файлах. Чтобы получить доступ к определенным в модуле инструментам, именующимся атрибутами модуля (имена переменных, связанные с такими объектами, как  функции),  в  языке  Python  необходимо импортировать этот модуль. То есть мы импортируем модули и получаем доступ к их атрибутам, что дает нам возможность использовать их функциональные возможности.