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

  • Пакеты в нескольких каталогах

  • Удобное форматирование вывода

  • Учебник Python 3.1

  • Форматирование строк в старом стиле

  • Учебник Python 3.1. Учебник Python 3. Учебник Python 1 Материал из Викиучебника. Оглавление


    Скачать 1.85 Mb.
    НазваниеУчебник Python 1 Материал из Викиучебника. Оглавление
    АнкорУчебник Python 3.1.pdf
    Дата05.04.2017
    Размер1.85 Mb.
    Формат файлаpdf
    Имя файлаУчебник Python 3.1.pdf
    ТипУчебник
    #4516
    страница7 из 13
    1   2   3   4   5   6   7   8   9   10   ...   13
    import
    sound.effects.echo
    import
    sound.effects.surround
    from
    sound.effects
    import
    *
    В этом примере модули echo и surround импортируются в текущее пространство имён, поскольку они определены в пакете sound.effects на тот момент, когда исполняется оператор from ... import
    . (И это также работает если определён
    __all__
    .)
    Обратите внимание, что в общем случае импортирование
    *
    из модуля не приветствуется, поскольку в результате часто получается плохо-читаемый код. Однако, вполне нормально использовать его в интерактивных сессиях, чтобы меньше печатать, а определённые модули разработаны для экспорта только тех имён, которые следуют определённым шаблонам.
    Помните: в использовании from пакет import определённый_подмодуль
    нет ничего плохого. На самом деле — это рекомендованная запись, до тех пор пока при импортировании модуля не нужно использовать подмодули с одинаковым именем из разных пакетов.
    Ссылки внутри пакета
    Когда пакеты структурированы в подпакеты (например, в случае пакета sound
    ), для того, чтобы сослаться на пакеты-потомки вы можете использовать абсолютное импортирование
    (absolute imports). Например, если модуль sound.filters.vocoder нуждается в модуле echo из пакета sound.effects
    , он должен использовать from sound.effects import echo
    Вы можете также использовать относительное импортирование (relative imports), применяя следующую форму оператора import
    : from модуль import имя
    . При таком способе импортирования для описания текущего и родительского пакетов используется символ точки. Например, для модуля surround вы можете написать:
    from
    import
    echo
    from
    import
    formats
    from
    ..filters
    import
    equalizer
    Обратите внимание, что относительное импортирование основано на имени текущего модуля. Поскольку имя главного модуля всегда „
    __main__
    “, модули, предназначенные для использования в качестве главных модулей приложения на Python, должны всегда использовать абсолютное импортирование (absolute imports).
    Пакеты в нескольких каталогах
    Пакеты поддерживают ещё один специальный аттрибут:
    __path__
    . Перед исполнением файла __init__.py этого пакета, он инициализируется списком, содержащим имя каталога, в котором этот файл находится. Изменив переменную, можно повлиять на ход поиска модулей и подпакетов, содержащихся в пакете.
    Хотя эта возможность нужна не так часто, она может быть использована для расширения набора модулей, находящихся в пакете.
    49

    Учебник Python 3.1: Материал из Викиучебника.
    Ввод и вывод
    Ознакомить пользователя с выводом программы можно различными способами — данные могут быть выведены в читаемом виде или записаны в файл для последующего использования. Часть возможностей будет обсуждена в этой главе.
    Удобное форматирование вывода
    На данный момент мы выяснили два способа вывода значений: операторные
    выражения (expression statements) и функция print()
    . (Третий способ — использование метода write()
    объектов файлов; на файл стандартного вывода можно сослаться как на sys.stdout
    . Более подробную информацию по этому пункту смотрите в
    Справочнике по библиотеке
    .)
    Часто возникает желание иметь больший контроль над форматированием вывода, чем обычная печать значений разделённых пробелами. Есть два способа форматирования вашего вывода. Первый способ — выполнять самостоятельно всю работу над строками: используя срезы строк и конкатенацию вы можете создать любой шаблон, какой пожелаете. Стандартный модуль string содержит много полезных операций для выравнивания строк по определённой ширине колонки (скоро мы их кратко рассмотрим).
    Второй способ — использование метода str.format()
    Модуль string содержит класс
    Template
    , который предоставляет ещё один способ подстановки значений в строки.
    Остаётся, конечно, один вопрос: каким образом конвертировать значения в строки? К счастью, в Python есть два способа для преобразования любого значения в строку — это функции repr()
    и str()
    Предназначение функции str()
    — возврат значений в довольно-таки читабельной форме; в отличие от repr()
    , чьё назначение — генерирование форм
    [40]
    , которые могут быть прочитаны интерпретатором (или вызовут ошибку
    SyntaxError
    , если эквивалентного синтаксиса не существует). Для тех объектов, у которых нет формы для человеческого прочтения функция str()
    возвратит такое же значение, как и repr()
    . У многих значений, таких как числа или структуры, вроде списков и словарей, одинаковая форма для обеих функций. Строки и числа с плавающей точкой, в частности, имеют по две разных формы.
    Несколько примеров:
    >>>
    s
    =
    'Привет, мир.'
    >>>
    str
    (s)
    'Привет, мир.'
    >>>
    repr
    (s)
    "'Привет, мир.'"
    >>>
    str
    (
    0.1
    )
    '0.1'
    >>>
    repr
    (
    0.1
    )
    '0.10000000000000001'
    >>>
    x
    =
    10
    *
    3.25
    >>>
    y
    =
    200
    *
    200
    >>>
    s
    =
    'Значение x - '
    + repr
    (x) +
    ', а y - '
    + repr
    (y) +
    '...'
    >>>
    print
    (s)
    Значение x -
    32.5
    ,
    а y -
    40000
    >>>
    # Фунция repr(), применённая к строке, добавляет кавычки и обратные слэши:
    ... hello
    =
    'привет, мир
    \n
    '
    50

    Учебник Python 3.1: Материал из Викиучебника.
    >>>
    hellos
    =
    repr
    (hello)
    >>>
    print
    (hellos)
    'привет, мир
    \n
    '
    >>>
    # Параметром функции repr() может быть объект Python:
    repr
    ((x
    ,
    y
    ,
    (
    'фарш'
    ,
    'яйца'
    )))
    "(32.5, 40000, ('фарш', 'яйца'))"
    Вот два способа вывести таблицу квадратов и кубов:
    >>>
    for
    x
    in
    range
    (
    1
    ,
    11
    ):
    print
    (
    repr
    (x).rjust(
    2
    )
    ,
    repr
    (x*x).rjust(
    3
    )
    ,
    end
    =
    ' '
    )
    # Обратите внимание на использование end в предыдущей строке
    print
    (
    repr
    (x*x*x).rjust(
    4
    ))
    1 1
    1 2
    4 8
    3 9
    27 4
    16 64 5
    25 125 6
    36 216 7
    49 343 8
    64 512 9
    81 729 10 100 1000
    >>>
    for
    x
    in
    range
    (
    1
    ,
    11
    ):
    print
    (
    '{0:2d} {1:3d} {2:4d}'
    .format(x
    ,
    x*x
    ,
    x*x*x))
    1 1
    1 2
    4 8
    3 9
    27 4
    16 64 5
    25 125 6
    36 216 7
    49 343 8
    64 512 9
    81 729 10 100 1000
    (Обратите внимание, что в первом примере единичные пробелы между колонками добавлены функцией print()
    : она всегда вставляет пробелы между своими параметрами)
    Этот пример демонстрирует работу метода строковых объектов rjust()
    , выравнивающего строку по правому краю в поле переданной ширины, отступая пробелами слева. Имеются также похожие методы ljust()
    и center()
    . Эти методы не выводят ничего, они лишь возвращают новую строку. Если строка на входе чересчур длинная, то они не усекают её, что обычно является меньшим из зол. (Для усечения можно добавить операцию среза, например: x.ljust(n)[:n]
    .)
    Есть другой метод — zfill()
    , который заполняет нулями пространство слева от числовой строки. Он распознаёт знаки плюс и минус:
    >>>
    '12'
    .zfill(
    5
    )
    '00012'
    >>>
    '-3.14'
    .zfill(
    7
    )
    '-003.14'
    >>>
    '3.14159265359'
    .zfill(
    5
    )
    '3.14159265359'
    Основной способ применения метода str.format()
    выглядит так
    [41]
    :
    51

    Учебник Python 3.1: Материал из Викиучебника.
    >>>
    print
    (
    'Мы — те {0}, что говорят "{1}!"'
    .format(
    'рыцари'
    ,
    'Ни'
    ))
    Мы — те рыцари
    ,
    что говорят "Ни!"
    Скобки с символами внутри (их называют полями форматирования (format fields)) заменяются на объекты, переданные методу format
    . Номер в скобках обозначает позицию объекта в списке параметров, переданных методу format
    >>>
    print
    (
    '{0} и {1}'
    .format(
    'фарш'
    ,
    'яйца'
    ))
    фарш и яйца
    >>>
    print
    (
    '{1} и {0}'
    .format(
    'фарш'
    ,
    'яйца'
    ))
    яйца и фарш
    Если в методе format используются именованные параметры, можно ссылаться на их значения, используя имя соответствующего аргумента
    [42]
    >>>
    print
    (
    'Этот {food} — {adjective}.'
    .format(
    ... food
    =
    'фарш'
    ,
    adjective
    =
    'непередаваемо ужасен'
    ))
    Этот фарш — непередаваемо ужасен.
    Позиционные и именованные параметры можно произвольно совмещать
    [43]
    :
    >>>
    print
    (
    'История о {0}е, {1}е, и {other}е.'
    .format(
    'Билл'
    ,
    'Манфред'
    ,
    other
    =
    'Георг'
    ))
    История о Билле
    ,
    Манфреде
    ,
    и Георге.
    После имени поля может следовать необязательный спецификатор формата ‘
    :
    ’. С его помощью можно управлять форматированием значения. Следующий пример оставляет у числа Пи только три цифры после десятичного разделителя
    [44]
    >>>
    import
    math
    >>>
    print
    (
    'Значение ПИ — примерно {0:.3f}.'
    .format(
    math
    .pi))
    Значение ПИ — примерно
    3.142
    После спецификатора ‘
    :
    ’ можно указать число — минимальную ширину поля, выраженную в количестве символов. Это удобно использовать для создания красивых таблиц:
    >>>
    table
    =
    {
    'Sjoerd'
    :
    4127
    ,
    'Jack'
    :
    4098
    ,
    'Dcab'
    :
    7678
    }
    >>>
    for
    name
    ,
    phone
    in
    table.items():
    print
    (
    '{0:10} ==> {1:10d}'
    .format(name
    ,
    phone))
    Jack
    ==>
    4098
    Dcab
    ==>
    7678
    Sjoerd
    ==>
    4127
    Если ваша строка с форматами очень длинна, а вы не хотите разбивать её на подстроки, было бы неплохо если бы вы могли ссылаться на переменные, предназначенные для форматирования, не по позиции, а по имени. Это можно сделать, просто передав словарь и используя квадратные скобки ‘[]’ для доступа к ключам.
    >>>
    table
    =
    {
    'Sjoerd'
    :
    4127
    ,
    'Jack'
    :
    4098
    ,
    'Dcab'
    :
    8637678
    }
    >>>
    print
    (
    'Jack: {0[Jack]:d}; Sjoerd: {0[Sjoerd]:d}; '
    'Dcab: {0[Dcab]:d}'
    .format(table))
    Jack:
    4098
    ;
    Sjoerd:
    4127
    ;
    Dcab:
    8637678
    Тоже самое можно сделать, передав словарь именованных параметров, используя нотацию

    **
    “:
    >>>
    table
    =
    {
    'Sjoerd'
    :
    4127
    ,
    'Jack'
    :
    4098
    ,
    'Dcab'
    :
    8637678
    }
    >>>
    print
    (
    'Jack: {Jack:d}; Sjoerd: {Sjoerd:d}; Dcab: {Dcab:d}'
    .format(**table))
    Jack:
    4098
    ;
    Sjoerd:
    4127
    ;
    Dcab:
    8637678
    В частности, такой приём удобно использовать в сочетании со встроенной функцией vars()
    , которая возвращает словарь с локальными переменными.
    52

    Учебник Python 3.1: Материал из Викиучебника.
    Подробное описание форматирования строк с применением метода str.format()
    описано в разделе
    Синтаксис строк форматирования
    Форматирование строк в старом стиле
    Для форматирования строк можно использовать и операцию
    %
    . Она интерпретирует левый операнд как строку форматирования в стиле sprintf
    , которую следует применить к правому операнду, и возвращает строку, получившуюся в результате этого преобразования. Например:
    >>>
    import
    math
    >>>
    print
    'Значение ПИ — примерно %5.3f.'
    % math
    .pi
    Значение ПИ — примерно
    3.142
    Поскольку метод str.format()
    довольно нов, большая часть исходных кодов Python всё ещё использует операцию
    %
    . Однако, со временем, форматирование строк будет удалено из языка, поэтому в большинстве случаев следует использовать str.format()
    Больше информации можно найти в разделе
    Операции форматирования строк в старом стиле
    Запись и чтение файлов
    Функция open()
    возвращает объект файла и в большинстве случаев используется с двумя аргументами: open(имя_файла, режим)
    >>>
    f
    =
    open
    (
    '/tmp/workfile'
    ,
    'w'
    )
    Первый параметр — строка, содержащая имя файла. Второй — другая строка, содержащая несколько символов, описывающих способ использования файла. Значение параметрарежим может быть символом 'r'
    , если файл будет открыт только для чтения,
    'w'
    — открыт только для записи (существующий файл с таким же именем будет стёрт) и 'a'
    — файл открыт для добавления: любые данные, записанные в файл автоматически добавляются в конец.
    'r+'
    открывает файл и для чтения, и для записи.
    Параметр режим необязателен: если он опущен — предполагается, что он равен 'r'
    В обычном случае файлы открываются в текстовом режиме (text mode) — это значит что вы читаете из файла и записываете в файл строки в определённой кодировке (по умолчанию используется UTF-8). Если добавить к режиму файла символ ‘
    b
    ’, файл открывается в двоичном режиме (binary mode): теперь данные считываются и записываются в виде двоичных объектов. Этот режим следует использовать для всех файлов, которые не содержат текст.
    При использовании текстового режима, все окончания строк, по умолчанию, специфичные для платформы (
    \n в Unix,
    \r\n в Windows) усекаются до символа
    \n
    , при чтении из файла, и конвертируются обратно из
    \n в вид, специфичный для платформы, при записи в файл.
    Эти закулисные изменения в файловых данных корректно работают в случае текстовых файлов, но испортят двоичные данные в файлах вроде
    JPEG
    или
    EXE
    . Внимательно следите за тем, чтобы использовать двоичный режим при чтении и записи таких файлов.
    Методы объектов-файлов
    В примерах ниже подразумевается, что заранее создан файловый объект с именем f
    Чтобы прочитать содержимое файла, вызовите f.read(размер)
    — функция читает некоторое количество данных и возвращает их в виде строки или байтового
    53

    Учебник Python 3.1: Материал из Викиучебника.
    объекта.
    размер
    — необязательный числовой параметр. Если
    размер
    опущен или отрицателен, будет прочитано и возвращено всё содержимое файла; если файл по величине в два раза больше оперативной памяти вашего компьютера, то решение этой проблемы остаётся на вашей совести. В противном случае, будет прочитано и возвращено максимум
    размер
    байт. Если был достигнут конец файла, f.read()
    вернёт пустую строку ().
    >>>
    f.read()
    'Это всё содержимое файла.
    \n
    '
    >>>
    f.read()
    ''
    f.readline()
    читает одну строку из файла; символ новой строки (
    \n
    ) остаётся в конце прочитанной строки и отсутствует при чтении последней строки файла только если файл не оканчивается пустой строкой. За счёт этого возращаемое значение становится недвусмысленным: если f.readline()
    возвращает пустую строку — достигнут конец файла, в то же время незаполненная строка, представленная посредством '\n'
    , содержит лишь символ новой строки.
    [45]
    >>>
    f.
    readline
    ()
    'Это первая строка файла.
    \n
    '
    >>>
    f.
    readline
    ()
    'Вторая строка файла
    \n
    '
    >>>
    f.
    readline
    ()
    ''
    f.readlines()
    возвращает список, содержащий все строки с данными, обнаруженные в файле. Если передан необязательный параметр подсказка_размера
    , функция читает из файла указанное количество байт, плюс некоторое количество байт сверх того, достаточное для завершения строки, и формирует список строк из результата. Функция часто используется для более эффективного (файл не загружается в память полностью) построчного чтения больших файлов. Возвращены будут только полные (завершённые) строки.
    >>>
    f.readlines()
    [
    'Это первая строка файла.
    \n
    '
    ,
    'Вторая строка файла
    \n
    '
    ]
    Альтернативный способ построчного чтения - организация цикла по файловому объекту.
    Он быстр, рационально использует память и имеет простой код в результате:
    >>>
    for
    line
    in
    f:
    print
    (line
    ,
    end
    =
    ''
    )
    Это первая строка файла.
    Вторая строка файла
    Альтернативный способ проще, но не предоставляет тонкого контроля над происходящим.
    Поскольку оба этих способа работают с буферизацией строк по-разному, их не следует смешивать.
    f.write(строка)
    записывает содержимое строки в файл и возвращает количество записанных байтов.
    >>>
    f.write(
    'This is a test
    \n
    '
    )
    15
    Чтобы записать в файл нечто отличное от строки, предварительно это нечто нужно в строку сконвертировать
    [46]
    :
    >>>
    value
    =
    (
    'ответ'
    ,
    42
    )
    >>>
    s
    =
    str
    (value)
    54

    Учебник Python 3.1: Материал из Викиучебника.
    >>>
    f.write(s)
    18
    f.tell()
    возвращает целое, представляющее собой текущую позицию в файле f
    , измеренную в байтах от начала файла. Чтобы изменить позицию объекта-файла, используйте f.seek(смещение, откуда)
    . Позиция вычисляется прибавлением смещения к точке отсчёта; точка отсчёта выбирается из параметра
    откуда
    Значение
    0
    параметра
    откуда
    отмеряет смещение от начала файла, значение
    1
    применяет текущую позицию в файле, а значение
    2
    в качестве точки отсчёта использует конец файла.
    Параметр
    откуда
    может быть опущен и по умолчанию устанавливается в
    0
    , используя начало файла в качестве точки отсчёта.
    >>>
    f
    =
    open
    (
    '/tmp/workfile'
    ,
    'rb+'
    )
    >>>
    f.write(b
    '0123456789abcdef'
    )
    16
    >>>
    f.seek(
    5
    )
    # Перейти к шестому байту в файле
    5
    >>>
    f.read(
    1
    ) b
    '5'
    >>>
    f.seek(-
    3
    ,
    2
    )
    # Перейти к третьему байту с конца
    13
    >>>
    f.read(
    1
    )
    b
    'd'
    При работе с текстовыми файлами (открытыми без символа b
    в строке режима), выполнять позиционирование (
    seek
    ) позволяется только от начала файла (за исключением прокрутки в конец файла с использованием seek(0, 2)
    ).
    Когда вы закончили все действия над файлом, вызовите f.close()
    чтобы закрыть его и освободить все системные ресурсы, использованные при открытии этого файла. Все попытки использовать объект-файл после вызова f.close()
    приведут к возникновению исключения.
    >>>
    f.close()
    >>>
    f.read()
    Traceback (most recent call last):
    File
    ""
    ,
    line
    1
    ,
    1   2   3   4   5   6   7   8   9   10   ...   13


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