Главная страница
Навигация по странице:

  • Другие ограничения на запуск щелчком мыши

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

  • Важные сведения о модулях: атрибуты

  • Модули и пространства имен

  • Математический анализ. 3е издание


    Скачать 4.86 Mb.
    Название3е издание
    АнкорМатематический анализ
    Дата04.02.2022
    Размер4.86 Mb.
    Формат файлаpdf
    Имя файлаpython_01.pdf
    ТипДокументы
    #351981
    страница12 из 98
    1   ...   8   9   10   11   12   13   14   15   ...   98
    Рис. 3.2. При запуске программы в Windows щелчком мыши на ярлыке можно
    увидеть результаты ее работы, если добавить вызов функции raw_input()
    в самый конец сценария. Но делать это следует, только если это
    действительно необходимо!

    86
    Глава 3. Как пользователь запускает программы
    Следует отметить, что функция raw_input – это средство для ввода ин
    формации, дополняющая инструкцию print, которая является средст
    вом вывода. Она представляет собой простейший способ чтения вводи
    мых данных, и обладает более широкими возможностями, чем было продемонстрировано в этом примере. Например, функция raw_input:

    Может принимать строку в качестве аргумента, которая будет вы
    водиться как подсказка (например, raw_input('Press Enter to exit')).

    Возвращает сценарию текстовую строку (например, nextinput =
    raw_input()
    ).

    Поддерживает возможность перенаправления потока ввода на уровне командной оболочки системы (например, python spam.py < input.txt),
    точно так же, как инструкция print поддерживает возможность пе
    ренаправления вывода.
    Далее в этой книге мы найдем более интересное применение этой функции: например, в главе 10 эта функция будет использована для организации интерактивного цикла.
    Другие ограничения на запуск щелчком мыши
    Даже при использовании функции raw_input запуск файлов щелчком мыши имеет некоторые недостатки. Вы можете не заметить появление сообщений об ошибках. Если в ходе работы сценария возникает ошиб
    ка, текст сообщения о ней выводится в окно консоли, которое тут же закрывается. Хуже того, даже добавление вызова raw_input не поможет в такой ситуации, потому что работа сценария будет прервана еще до того, как будет выполнен этот вызов. Другими словами, вам будет сложно определить, что именно пошло не так.
    Изза этих ограничений способ запуска программы щелчком мыши на ярлыке лучше использовать уже после того, как сценарий будет пол
    ностью отлажен. Старайтесь использовать другие способы запуска программ, особенно в самом начале работы над ними, такие как запуск из командной строки системы и из интегрированной среды разработки
    IDLE (будет рассматриваться ниже, в этой же главе). Благодаря этому вы сможете увидеть сообщения об ошибках и обычный вывод от сцена
    рия, не прибегая к разного рода хитростям. Когда позднее в этой книге мы будем рассматривать исключения, вы узнаете, что существует воз
    можность перехватывать и обрабатывать ошибки так, чтобы они не приводили к аварийному завершению программы. Обратите внимание на приведенное ниже обсуждение инструкции try, которая предостав
    ляет альтернативный способ предотвратить преждевременное закры
    тие окна в случае возникновения ошибок.
    Импортирование и перезагрузка модулей
    Мы уже говорили об «импортировании модулей», но до сих пор я не давал никаких пояснений, что означает этот термин. Подробно о моду

    Импортирование и перезагрузка модулей
    87
    лях и об архитектуре крупных программ мы будем говорить в пятой части книги, но так как операция импорта модулей – это еще один из способов запуска программ, мы рассмотрим в этом разделе основы мо
    дулей, чтобы дать вам начальное представление о них.
    Проще говоря, каждый файл с исходным текстом на языке Python, имя которого оканчивается расширением .py, является модулем. Другие файлы могут обращаться к программным компонентам, объявляемым модулем, импортируя этот модуль. По сути, инструкция import выпол
    няет загрузку другого файла и обеспечивает доступ к его содержимому.
    Содержимое модуля становится доступным внешнему миру через его атрибуты (определение этого термина я дам в следующем разделе).
    Эта модульная модель является центральной идеей, лежащей в основе архитектуры программ на языке Python. Крупные программы обычно организованы в виде множества файлов модулей, которые импортиру
    ют и используют функциональные возможности из других модулей.
    Один из модулей определяется как основной файл верхнего уровня, ко
    торый запускает всю программу.
    Проблемы модульной архитектуры мы будем рассматривать подроб
    нее позже, в этой же книге, а в этой главе основное внимание уделяет
    ся тому факту, что операция импорта приводит к выполнению про
    граммного кода загружаемого файла на заключительном этапе. Как следствие, импорт файла является еще одним способом запустить его.
    Например, если запустить интерактивный сеанс работы с интерпрета
    тором (в IDLE, из командной строки или както иначе), можно будет запустить файл script4.py, созданный ранее, с помощью простой инст
    рукции import:
    D:\LP3E\Examples> c:\python25\python
    >>> import script4
    win32 1267650600228229401496703205376
    Такой способ пригоден только для однократного запуска модуля в тече
    ние сеанса. После первой операции импорта все последующие попытки импортировать модуль не приводят ни к каким результатам, даже если изменить и сохранить исходный текст модуля в другом окне:
    >>> import script4
    >>> import script4
    Так сделано преднамеренно – операция импорта требует слишком больших затрат вычислительных ресурсов, чтобы выполнять ее более одного раза в ходе выполнения программы. Как вы узнаете в главе 18,
    в ходе импорта производится поиск файлов, компиляция их в байт
    код и выполнение этого байткода.
    Если действительно возникает необходимость вынудить интерпрета
    тор многократно запускать файл в рамках одного и того же сеанса (без

    88
    Глава 3. Как пользователь запускает программы остановки и перезапуска сеанса), можно воспользоваться встроенной функцией reload:
    >>> reload(script4)
    win32 65536

    >>>
    Функция reload загружает и запускает текущую версию программного кода в файле, если он был изменен в другом окне. Это позволяет редак
    тировать и использовать новый программный код в ходе одного и того же интерактивного сеанса работы с интерпретатором Python. В этом сеансе, например, уже после того как модуль был импортирован, вто
    рая инструкция print в файле script4.py была изменена в другом окне так, чтобы она выводила результат выражения 2 ** 16, после чего была выполнена перезагрузка модуля с помощью функции reload.
    Функция reload ожидает получить имя уже загруженного модуля, по
    этому, прежде чем перезагрузка станет возможной, модуль должен быть импортирован. Примечательно также, что имя модуля при вызо
    ве функции reload должно быть заключено в круглые скобки, тогда как инструкция import не требует этого. Дело в том, что reload – это функция, которая вызывается, а import – это инструкция. Именно по
    этому имя модуля следует передавать функции reload как аргумент,
    в круглых скобках, и именно поэтому после перезагрузки модуля вы
    водится дополнительная строка. Последняя строка в выводе выше –
    это всего лишь представление результата, возвращаемого функцией reload после перезагрузки модуля.
    Более подробно функции будут обсуждаться в главе 15.
    Важные сведения о модулях: атрибуты
    Операции импортирования и перезагрузки модулей обеспечивают есте
    ственный способ запуска программы, так как на заключительном этапе этих операций производится исполнение файлов. При этом в более ши
    роком понимании модули играют роль библиотек инструментов, как вы узнаете в пятой части книги. Модуль – это, главным образом, всего лишь пакет имен переменных, известный как пространство имен.
    Имена внутри этого пакета называются атрибутами, то есть атрибут –
    это имя переменной, которая связана с определенным объектом.
    В самом типичном случае импортирующий программный код получа
    ет доступ ко всем именам верхнего уровня, определяемым в файле мо
    дуля. Эти имена обычно связаны с функциональными возможностя
    ми, экспортируемыми модулем, – функциями, классами, переменны
    ми и т. д., которые предназначены для использования в других фай
    лах и программах. Снаружи доступ к именам в файле модуля можно получить с помощью двух инструкций языка Python, import и from,
    а также с помощью вызова функции reload.

    Импортирование и перезагрузка модулей
    89
    Для иллюстрации вышесказанного с помощью текстового редактора создайте однострочный файл модуля Python с именем myfile.py со сле
    дующим содержимым:
    title = "The Meaning of Life"
    Это, пожалуй, один из самых простых модулей Python (он содержит единственную операцию присваивания), но его вполне достаточно для иллюстрации основных положений. При импортировании этого моду
    ля выполняется его программный код, который создает атрибут моду
    ля. Инструкция присваивания создает атрибут с именем title.
    Доступ к атрибуту title можно получить из других программных ком
    понентов двумя разными способами. Первый заключается в том, что
    бы загрузить модуль целиком с помощью инструкции import, а затем обратиться к атрибуту по его имени, уточнив его именем модуля:
    % python # Запуск интерпретатора Python
    >>> import myfile # Запуск файла; модуль загружается целиком
    >>> print myfile.title # Имя атрибута, уточненное именем модуля через '.'
    The Meaning of Life
    Вообще синтаксис точечной нотации, в виде object.attribute, позволя
    ет получить доступ к любому атрибуту в любом объекте, и этот прием широко используется в программном коде на языке Python. Здесь мы использовали его для обращения к строковой переменной title, опре
    деленной внутри модуля myfile, – то есть myfile.title.
    Кроме того, доступ к именам внутри модулей (фактически, копию имен) можно получать с помощью инструкции from:
    % python # Запуск интерпретатора Python
    >>> from myfile import title # Запуск файла; выполняется копирование имен
    >>> print title # Имя атрибута используется напрямую, уточнение не требуется
    The Meaning of Life
    Как будет говориться позднее, инструкция from во многом подобна ин
    струкции import, которая выполняет присваивание имен в импорти
    руемом компоненте. С технической точки зрения, инструкция from ко
    пирует атрибуты модуля так, что они становятся простыми перемен+
    ными
    в программном коде, выполняющем импорт, благодаря чему на этот раз он может обратиться к импортированной строке уже не по имени myfile.title (ссылка на атрибут), а просто – title (переменная).
    1
    Неважно, как выполняется импортирование модуля, с помощью инст
    рукции import или from, это приводит к выполнению инструкций в файле
    1
    Обратите внимание: в обеих инструкциях, import и from, имя модуля myfile
    указывается без расширения .py. Как вы узнаете в пятой части книги, ко
    гда интерпретатор Python выполняет поиск файлов модулей, он знает, что к имени модуля необходимо добавить расширение. Не забывайте, что рас
    ширение обязательно должно указываться при вызове файла в системной командной оболочке и опускаться в инструкциях import.

    90
    Глава 3. Как пользователь запускает программы
    myfile.py
    , а импортирующий компонент (в данном случае – интерак
    тивная оболочка интерпретатора) получает доступ к именам, опреде
    ленным в файле на верхнем уровне. В этом простом примере существу
    ет только одно такое имя – переменная title, которой присвоена строка, но сама концепция приобретает более важное значение, когда речь заходит об определении в модулях таких объектов, как функции и классы. Такие объекты становятся программными компонентами многократного использования, доступ к которым можно получить из одного или более клиентских модулей.
    На практике модули обычно определяют более чем одно имя, которые могут использоваться и внутри, и за пределами модуля. Ниже приво
    дится пример модуля, в котором определяются три имени:
    a = 'dead' # Определяются три атрибута,
    b = 'parrot' # Экспортируемые другим модулям
    c = 'sketch'
    print a, b, c # Кроме того, они используются и самим этим модулем
    В файле threenames.py создаются три переменные, которые становятся тремя атрибутами, доступными внешнему миру. Этот модуль сам так
    же использует эти переменные в инструкции print, в чем можно убе
    диться, если запустить этот модуль как файл верхнего уровня:
    % python threenames.py
    dead parrot sketch
    Как обычно, программный код этого модуля выполняется всего один раз, при импортировании (с помощью инструкции import или from).
    Клиенты, использующие инструкцию import, получают модуль со все
    ми его атрибутами, а клиенты, использующие инструкцию from, полу
    чают копии имен из этого модуля:
    % python
    >>> import threenames # Загрузить модуль целиком
    dead parrot sketch
    >>>
    >>> threenames.b, threenames.c
    ('parrot', 'sketch')
    >>>
    >>> from threenames import a, b, c # Скопировать несколько имен
    >>> b, c
    ('parrot', 'sketch')
    Результаты здесь выводятся в круглых скобках, потому что в действи
    тельности они являются кортежами (разновидность объектов, кото
    рая описывается в следующей части книги).
    Как только вы начнете создавать модули, содержащие несколько имен, как в данном случае, вам наверняка пригодится встроенная функция dir. Она может использоваться для получения списка имен,
    доступных внутри модуля:

    Импортирование и перезагрузка модулей
    91
    >>> dir(threenames)
    ['_ _builtins_ _', '_ _doc_ _', '_ _file_ _', '_ _name_ _', 'a', 'b', 'c']
    При вызове функции dir передается имя импортированного модуля в круглых скобках, как показано выше, а возвращает она список всех атрибутов, определенных внутри модуля. Некоторые возвращаемые имена, которые начинаются и завершаются двумя символами подчер
    кивания, присутствуют всегда; эти встроенные имена определяются са
    мим интерпретатором Python и имеют для него особый смысл. Имена переменных, которые определяются нашими инструкциями присваива
    ния, – a, b и c – выводятся в конце списка, получаемого от функции dir.
    Модули и пространства имен
    Импортирование модулей – это один из способов запуска программно
    го кода в файлах, но, помимо этого, и это будет рассмотрено в книге позже, модули являются также самой крупной структурной единицей в программах на языке Python. Вообще программы на языке Python состоят из множества файлов модулей, связанных между собой инст
    рукциями import. Каждый файл модуля – это самостоятельный пакет переменных, или пространство имен. Один модуль не сможет увидеть переменные, определенные в другом модуле, если явно не импортиру
    ет его. Модули позволяют уменьшить вероятность конфликтов имен в программном коде – т. к. каждый файл является самостоятельным пространством имен, имена в одном файле не вступают в конфликт с именами в другом файле, даже если они одинаковые.
    Как можно понять, модули – одно из ухищрений, которые использу
    ются в языке Python для упаковки переменных в категории, чтобы из
    бежать конфликтов имен. Далее мы еще будем обсуждать модули и другие конструкции образования пространств имен (включая клас
    сы и функции). А пока будем использовать модули в качестве средства многократного использования программного кода, позволяющего не вводить его повторно с клавиатуры.
    import и reload, примечания к использованию
    Зачастую, узнав о возможности запуска файлов с помощью import и re
    load
    , начинающие разработчики концентрируют все свое внимание на этом способе и забывают о других возможностях запуска, позволяю
    щих всегда запускать самую свежую версию программного кода (на
    пример, щелчок мышью на ярлыке, пункты меню интегрированной среды разработки IDLE и системная командная строка). Такой подход может быстро привести к появлению ошибок – вам придется запоми
    нать, импортировали ли вы тот или иной модуль, чтобы иметь возмож
    ность перезагрузить его; вам нужно будет помнить о необходимости использовать круглые скобки при вызове функции reload (только для нее) и не забывать использовать ее, чтобы запустить самую последнюю версию модуля.

    92
    Глава 3. Как пользователь запускает программы
    Изза этих сложностей (и некоторых других, с которыми мы еще столкнемся позднее) пока лучше избегать пользоваться операциями импорта и перезагрузки. Пункт меню
    Run
    →Run Module интегрирован
    ной среды IDLE, например, предоставляет более простой способ запус
    ка файлов, менее подверженный ошибкам. С другой стороны, импорт и перезагрузку оправданно использовать в процессе тестирования классов Python. В этом случае вы можете отдать предпочтение этому способу, но если начнут возникать сложности – остановитесь.
    Это еще не все сведения о модулях, на которых хотелось бы здесь оста
    новиться. Например, встроенная функция execfile('module.py’) – еще один способ запуска файлов из интерактивной командной строки, ко
    торый избавляет от необходимости импортировать и затем перезагру
    жать модули. Имея схожее действие, она технически не выполняет импорт модуля – по умолчанию всякий раз, когда вызывается функ
    ция execfile, она снова запускает файл, как если бы на место вызова функции было подставлено содержимое этого файла. Изза этого функция execfile, как и упоминавшаяся ранее инструкция from, мо
    жет попросту затереть значения переменных, которые уже использо
    вались. С другой стороны, инструкция import запускает файл всего один раз в течение сеанса работы и превращает файл в отдельное про
    странство имен, благодаря чему становится невозможным изменение переменных в текущей области видимости.
    Следует добавить, что в случае использования необычных способов применения модулей, отличных от тех, которые описываются в этой книге, вы можете столкнуться с некоторыми неприятностями. Напри
    мер, если вам необходимо импортировать файл модуля, который хра
    нится в каталоге, отличном от того, в котором вы работаете, дожди
    тесь, пока мы не подойдем к главе 18, где вы узнаете о пути поиска мо+
    дулей
    . А пока, чтобы избежать осложнений, храните все импортируе
    мые файлы модулей в рабочем каталоге.
    Для тех, кто не хочет ждать, пока повествование дойдет до гла
    вы 18, скажу, что интерпретатор Python выполняет поиск импор
    тируемых модулей во всех каталогах, перечисленных в перемен
    ной sys.path, – в списке имен каталогов, определенной в модуле
    sys
    , которая инициализируется значением переменной окруже
    ния PYTHONPATH, и в наборе стандартных имен каталогов. Если воз
    никает потребность импортировать модули из других каталогов,
    отличных от того, в котором вы работаете, они должны быть пере
    числены в переменной PYTHONPATH. За дополнительной информаци
    ей обращайтесь к главе 18.
    1   ...   8   9   10   11   12   13   14   15   ...   98


    написать администратору сайта