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

  • Смотрите также :Перечисляемые типы Строки — вид перечисляемых типов и они поддерживают привычные для этих типов операции.Строковые методы

  • Форматирование строк Здесь описано форматирование строк с применением функции str.format()Операции форматирования строк в старом стиле

  • Учебник 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
    страница2 из 13
    1   2   3   4   5   6   7   8   9   ...   13
    '
    Два строковых литерала, расположенные друг за другом, автоматически конкатенируются; первая строка в предыдущем примере также могла быть записана как word = 'Help' 'A'
    ; это работает только с двумя литералами — не с произвольными выражениями, содержащими строки.
    >>>
    'str'
    'ing'
    # <- Так — верно
    'string'
    >>>
    'str'
    .strip() +
    'ing'
    # <- Так — верно
    'string'
    >>>
    'str'
    .strip()
    'ing'
    # <- Так — не верно
    File
    ""
    ,
    line
    1
    ,
    in
    ?
    'str'
    .strip()
    'ing'
    ^
    15

    Учебник Python 3.1: Материал из Викиучебника.
    SyntaxError
    : invalid syntax
    Строки могут быть проиндексированы; также как и в C, первый символ строки имеет индекс 0. Отсутствует отдельный тип для символов; символ является строкой с единичной длиной. Как и в языке программирования Icon, подстроки могут определены через нотацию срезов (slice): два индекса, разделенных двоеточием.
    >>>
    word[
    4
    ]
    'A'
    >>>
    word[
    0
    :
    2
    ]
    'He'
    >>>
    word[
    2
    :
    4
    ]
    'lp'
    Индексы срезов имеют полезные значения по умолчанию; опущенный первый индекс заменяется нулём, опущенный второй индекс подменяется размером срезаемой строки.
    >>>
    word[:
    2
    ]
    # Первые два символа
    'He'
    >>>
    word[
    2
    :]
    # Всё, исключая первые два символа
    'lpA'
    В отличие от строк в C, строки Python не могут быть изменены. Присваивание по позиции индекса строки вызывает ошибку:
    >>>
    word[
    0
    ]
    =
    'x'
    Traceback (most recent call last):
    File
    ""
    ,
    line
    1
    ,
    in
    ?
    TypeError
    :
    'str'
    object doesn
    't support item assignment
    >>> word[:1] = '
    Splat
    '
    Traceback (most recent call last):
    File "", line 1, in ?
    TypeError: '
    str
    ' object doesn'
    t support slice assignment
    Тем не менее, создание новой строки со смешанным содержимым — процесс легкий и очевидный:
    >>>
    'x'
    + word[
    1
    :]
    'xelpA'
    >>>
    'Splat'
    + word[
    4
    ]
    'SplatA'
    Полезный инвариант операции среза: s[:i] + s[i:]
    эквивалентно s
    >>>
    word[:
    2
    ] + word[
    2
    :]
    'HelpA'
    >>>
    word[:
    3
    ] + word[
    3
    :]
    'HelpA'
    Вырождения индексов срезов обрабатываются элегантно: чересчур большой индекс заменяется на размер строки, а верхняя граница меньшая нижней возвращает пустую строку.
    >>>
    word[
    1
    :
    100
    ]
    'elpA'
    >>>
    word[
    10
    :]
    ''
    >>>
    word[
    2
    :
    1
    ]
    ''
    Индексы могут быть отрицательными числами, обозначая при этом отсчет справа налево.
    Например:
    >>>
    word[-
    1
    ]
    # Последний символ
    'A'
    16

    Учебник Python 3.1: Материал из Викиучебника.
    >>>
    word[-
    2
    ]
    # Предпоследний символ
    'p'
    >>>
    word[-
    2
    :]
    # Последние два символа
    'pA'
    >>>
    word[:-
    2
    ]
    # Всё, кроме последних двух символов
    'Hel'
    Но обратите внимание, что -0 действительно эквивалентен 0 - это не отсчет справа.
    >>>
    word[-
    0
    ]
    # (поскольку -0 равен 0)
    'H'
    Отрицательные индексы вне диапазона обрезаются, но не советуем делать это с одно- элементными индексами (не-срезами):
    >>>
    word[-
    100
    :]
    'HelpA'
    >>>
    word[-
    10
    ]
    # ошибка
    Traceback (most recent call last):
    File
    ""
    ,
    line
    1
    ,
    in
    ?
    IndexError
    : string index out of range
    Один из способов запомнить, как работают срезы - думать о них, как об указателях на места между символами, где левый край первого символа установлен в ноль, а правый край последнего символа строки из n
    символов имеет индекс n
    , например:
    +---+---+---+---+---+
    | H | e | l | p | A |
    +---+---+---+---+---+
    0 1 2 3 4 5
    -5 -4 -3 -2 -1
    Первый ряд чисел дает позицию индексов строки от 0 до 5; второй ряд описывает соответствующие отрицательные индексы. Срез от i до j состоит из всех символов между правым и левым краями, отмеченными, соответственно, через i
    и j
    Для всех индексов, больших или равных нулю, длина среза - разность между индексами, при условии что оба индекса находятся в диапазоне. Например, длина word[1:3]
    — 2.
    Встроенная функция len()
    возвращает длину строки
    [10]
    :
    >>>
    s
    =
    'supercalifragilisticexpialidocious'
    >>>
    len
    (s)
    34
    Смотрите также:
    Перечисляемые типы
    Строки — вид перечисляемых типов и они поддерживают привычные для этих типов операции.
    Строковые методы
    Строки поддерживают большое количество методов для поиска и простых трансформаций.
    Форматирование строк
    Здесь описано форматирование строк с применением функции str.format()
    Операции форматирования строк в старом стиле
    Операции форматирования, вызывающиеся тогда, когда обычные строки или строки в
    Unicode оказываются левым операндом относительно операции
    %
    , более детально рассмотрены здесь.
    [11]
    17

    Учебник Python 3.1: Материал из Викиучебника.
    О Unicode
    Начиная с Python версии 3.0, строковый тип поддерживает только Unicode
    (см. http://www.unicode.org/
    ).
    Преимущество набора Unicode состоит в том, что он предоставляет порядковый номер для любого символа из любой письменности, использовавшейся в современных или древнейших текстах. До этих пор для символов в сценарии было доступно лишь 256 номеров. Тексты обычно привязывались к кодовой странице, которая устанавливала в соответствие порядковые номера и символы сценария. Это приводило к серьезной путанице, особенно в том, что касалось интернационализации
    [12]
    программного продукта.
    Unicode решает эти проблемы, определяя единую кодовую страницу для всех письменностей.
    Для вставки в строку специального символа можно использовать Unicode-экранирование
    (Python Unicode-Escape encoding). Следующий пример всё пояснит:
    >>>
    'Hello
    \u
    0020World !'
    'Hello World !'
    Экранированная последовательность
    \u0020
    задаёт символ Unicode с порядковым номером 0x0020 (символ пробела).
    Другие символы интерпретируются с использованием соответствующих им порядковых значений тем же способом, что и порядковые номера Unicode. Первые 128 символов кодировки Unicode полностью совпадают с 128 символами кодировки Latin-1, использующейся во многих западных странах.
    Помимо стандартных способов кодирования, Python предоставляет целый набор различных способов создания Unicode-строк, основываясь на известной кодировке.
    Для конвертирования Unicode-строки в последовательность байтов с использованием желаемой кодировки, строковые объекты предоставляют метод encode()
    , принимающий единственный параметр — название кодировки. Предпочитаются названия кодировок, записанные в нижнем регистре.
    >>>
    "Äpfel"
    .encode(
    'utf-8'
    ) b
    '
    \x
    c3
    \x
    84pfel'
    Списки
    В языке Python доступно некоторое количество составных типов данных, использующихся для группировки прочих значений вместе. Наиболее гибкий из них — список (list). Его можно выразить в тексте программы через разделённые запятыми значения (элементы), заключённые в квадратные скобки. Элементы списка могут быть разных типов.
    >>>
    a
    =
    [
    'spam'
    ,
    'eggs'
    ,
    100
    ,
    1234
    ]
    >>>
    a
    [
    'spam'
    ,
    'eggs'
    ,
    100
    ,
    1234
    ]
    Подобно индексам в строках, индексы списков начинаются с нуля, списки могут быть срезаны, объединены (конкатенированы) и так далее:
    >>>
    a[
    0
    ]
    'spam'
    >>>
    a[
    3
    ]
    1234
    >>>
    a[-
    2
    ]
    100 18

    Учебник Python 3.1: Материал из Викиучебника.
    >>>
    a[
    1
    :-
    1
    ]
    [
    'eggs'
    ,
    100
    ]
    >>>
    a[:
    2
    ] + [
    'bacon'
    ,
    2
    *
    2
    ]
    [
    'spam'
    ,
    'eggs'
    ,
    'bacon'
    ,
    4
    ]
    >>>
    3
    *a[:
    3
    ] + [
    'Boo!'
    ]
    [
    'spam'
    ,
    'eggs'
    ,
    100
    ,
    'spam'
    ,
    'eggs'
    ,
    100
    ,
    'spam'
    ,
    'eggs'
    ,
    100
    ,
    'Boo!'
    ]
    В отличие от строк, являющихся неизменяемыми, изменить индивидуальные элементы списка вполне возможно:
    >>>
    a
    [
    'spam'
    ,
    'eggs'
    ,
    100
    ,
    1234
    ]
    >>>
    a[
    2
    ]
    =
    a[
    2
    ] +
    23
    >>>
    a
    [
    'spam'
    ,
    'eggs'
    ,
    123
    ,
    1234
    ]
    Присваивание срезу также возможно, и это действие может даже изменить размер списка или полностью его очистить:
    >>>
    # Заменим некоторые элементы:
    ... a[
    0
    :
    2
    ]
    =
    [
    1
    ,
    12
    ]
    >>>
    a
    [
    1
    ,
    12
    ,
    123
    ,
    1234
    ]
    >>>
    # Удалим немного:
    ... a[
    0
    :
    2
    ]
    =
    []
    >>>
    a
    [
    123
    ,
    1234
    ]
    >>>
    # Вставим пару:
    ... a[
    1
    :
    1
    ]
    =
    [
    'bletch'
    ,
    'xyzzy'
    ]
    >>>
    a
    [
    123
    ,
    'bletch'
    ,
    'xyzzy'
    ,
    1234
    ]
    >>>
    # Вставим (копию) самого себя в начало
    >>>
    a[:
    0
    ]
    =
    a
    >>>
    a
    [
    123
    ,
    'bletch'
    ,
    'xyzzy'
    ,
    1234
    ,
    123
    ,
    'bletch'
    ,
    'xyzzy'
    ,
    1234
    ]
    >>>
    # Очистка списка: замена всех значений пустым списком
    >>>
    a[:]
    =
    []
    >>>
    a
    []
    Встроенная функция len()
    также применима к спискам:
    >>>
    a
    =
    [
    'a'
    ,
    'b'
    ,
    'c'
    ,
    'd'
    ]
    >>>
    len
    (a)
    4
    Вы можете встраивать списки (создавать списки, содержащие другие списки), например так:
    >>>
    q
    =
    [
    2
    ,
    3
    ]
    >>>
    p
    =
    [
    1
    ,
    q
    ,
    4
    ]
    >>>
    len
    (p)
    3
    >>>
    p[
    1
    ]
    [
    2
    ,
    3
    ]
    >>>
    p[
    1
    ][
    0
    ]
    2
    Вы можете добавить что-нибудь в конец списка.
    >>>
    p[
    1
    ].append(
    'xtra'
    )
    >>>
    p
    [
    1
    ,
    [
    2
    ,
    3
    ,
    'xtra'
    ]
    ,
    4
    ]
    >>>
    q
    19

    Учебник Python 3.1: Материал из Викиучебника.
    [
    2
    ,
    3
    ,
    'xtra'
    ]
    Обратите внимание, что в последнем примере p[1]
    и q
    на самом деле ссылаются на один и тот же объект! Мы вернёмся к семантике объектов позже.
    Первые шаги к программированию
    Безусловно, Python можно использовать для более сложных задач, чем сложение двух чисел. Например, мы можем вывести начало последовательности чисел Фибоначчи таким образом:
    >>>
    # Ряд Фибоначчи:
    # сумма двух элементов определяет следущий элемент
    ... a
    ,
    b
    =
    0
    ,
    1
    >>>
    while
    b
    <
    10
    :
    print
    (b)
    ... a
    ,
    b
    =
    b
    ,
    a+b
    1 1
    2 3
    5 8
    Этот пример показывает нам некоторые новые возможности.

    Первая строка содержит множественное присваивание (multiple assignment): переменные a
    и b
    параллельно получают новые значения —
    0
    и
    1
    . В последней строке этот метод используется снова, демонстрируя тот факт, что выражения по правую сторону [от оператора присваивания] всегда вычисляются раньше каких бы то ни было присваиваний. Сами же разделённые запятыми выражения вычисляются слева направо.

    Цикл while
    (пока) исполняется до тех пор, пока условие (здесь: b < 10
    ) остается истиной. В Python, также как и в C, любое ненулевое значение является истиной
    (
    True
    ); ноль является ложью (
    False
    ). Условием может быть строка, список или вообще любая последовательность; все, что имеет ненулевую длину, играет роль истины, пустые последовательности — лжи. Использованная в примере проверка — простое условие. Стандартные операции сравнения записываются так же, как и в
    C:
    <
    (меньше чем),
    >
    (больше чем),
    ==
    (равно),
    <=
    (меньше или равно),
    >=
    (больше или равно) и
    !=
    (не равно).

    Тело цикла выделено отступом (indented). Отступы — это средство группировки операторов в Python. Интерактивный режим Python (пока!) не имеет какого-либо разумного и удобного средства для редактирования строк ввода, поэтому необходимо использовать табуляции или пробелы для отступа в каждой строке. На практике более сложный текст на Python готовится в текстовом редакторе, а большинство из них имеют функцию авто-отступа. По окончанию ввода составного выражения в интерактивном режиме, необходимо закончить его пустой строкой — признаком завершения (поскольку интерпретатор не может угадать, когда вами была введена последняя строка). Обратите внимание, что размер отступа в каждой строке основного блока должен быть одним и тем же
    [13]

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

    Учебник Python 3.1: Материал из Викиучебника.
    величины с плавающей точкой и строки. Строки выводятся без кавычек и между элементами вставляются пробелы, благодаря чему форматирование вывода улучшается — как, например, здесь:
    >>>
    i
    =
    256
    *
    256
    >>>
    print
    (
    'Значением i является'
    ,
    i)
    Значением i является
    65536
    Для отключения перевода строки после вывода или завершения вывода другой строкой используется именованный параметр end
    :
    >>>
    a
    ,
    b
    =
    0
    ,
    1
    >>>
    while
    b
    <
    1000
    :
    print
    (b
    ,
    end
    =
    ' '
    )
    ... a
    ,
    b
    =
    b
    ,
    a+b
    1 1
    2 3
    5 8
    13 21 34 55 89 144 233 377 610 987
    Больше средств для управления потоком команд
    [14]
    Помимо описанного выше оператора while
    , в Python доступны привычные операторы управления потоком из других языков, но с некоторыми особенностями.
    Оператор
    if
    Возможно, наиболее широко известный тип оператора — оператор if
    (если). Пример:
    >>>
    x
    =
    int
    (
    input
    (
    "Введите, пожалуйста, целое число: "
    ))
    Введите
    ,
    пожалуйста
    ,
    целое число:
    42
    >>>
    if
    x
    <
    0
    :
    ... x
    =
    0
    print
    (
    'Отрицательное значение, изменено на ноль'
    )
    elif
    x
    ==
    0
    :
    print
    (
    'Ноль'
    )
    elif
    x
    ==
    1
    :
    print
    (
    'Один'
    )
    else
    :
    print
    (
    'Больше'
    )
    Блока elif может не быть вообще, он может быть один или их может быть несколько, а блок else
    (иначе) необязателен. Ключевое слово elif — краткая запись else if (иначе если) — позволяет избавиться от чрезмерного количества отступов.
    Оператор if elif elif
    ... — аналог оператора выбора switch или case
    , которые можно встретить в других языках программирования.
    Оператор
    for
    Оператор for в Python немного отличается от того, какой вы, возможно, использовали в C или Pascal. Вместо неизменного прохождения по арифметической прогрессии из чисел (как в Pascal) или предоставления пользователю возможности указать шаг итерации и условие остановки (как в С), оператор for в Python проходит по всем элементам любой последовательности (списка или строки) в том порядке, в котором они в ней располагаются. Например (игра слов не подразумевалась):
    [15]
    >>>
    # Измерим несколько строк:
    ... a
    =
    [
    'cat'
    ,
    'window'
    ,
    'defenestrate'
    ]
    >>>
    for
    x
    in
    a:
    print
    (x
    ,
    len
    (x))
    21

    Учебник Python 3.1: Материал из Викиучебника.
    cat
    3
    window
    6
    defenestrate
    12
    Изменять содержимое последовательности, по которой проходит цикл, небезопасно (это в принципе-то возможно только для изменяемых типов, таких как списки). Если необходимо модифицировать список, использующийся для организации цикла, (например, для того чтобы продублировать отдельные элементы) нужно передать циклу его копию. Нотация срезов делает это практически безболезненным:
    >>>
    for
    x
    in
    a[:]:
    # создать срез-копию всего списка
    if
    len
    (x)
    >
    6
    : a.insert(
    0
    ,
    x)
    >>>
    a
    [
    'defenestrate'
    ,
    'cat'
    ,
    'window'
    ,
    'defenestrate'
    ]
    Функция
    range()
    Если вам нужно перебрать последовательность чисел, встроенная функция range()
    придёт на помощь. Она генерирует арифметические прогрессии:
    >>>
    for
    i
    in
    range
    (
    5
    ):
    print
    (i)
    0 1
    2 3
    4
    Указанный конец интервала никогда не включается в сгенерированный список; вызов range(10)
    генерирует десять значений, которые являются подходящими индексами для элементов последовательности длины 10. Можно указать другое начало интервала и другую, даже отрицательную, величину шага.
    range
    (
    5
    ,
    10
    )
    от
    5
    до
    9
    range
    (
    0
    ,
    10
    ,
    3
    )
    0
    ,
    3
    ,
    6
    ,
    9
    range
    (-
    10
    ,
    -
    100
    ,
    -
    30
    )
    -
    10
    ,
    -
    40
    ,
    -
    70
    Чтобы пройти по всем индексам какой-либо последовательности, скомбинируйте вызовы range()
    и len()
    следующим образом:
    >>>
    a
    =
    [
    'Mary'
    ,
    'had'
    ,
    'a'
    ,
    'little'
    ,
    'lamb'
    ]
    >>>
    for
    i
    in
    range
    (
    len
    (a)):
    print
    (i
    ,
    a[i])
    0
    Mary
    1
    had
    2
    a
    3
    little
    4
    lamb
    В большинстве таких случаев удобно использовать функцию enumerate()
    , обратитесь к
    Организация циклов
    Странные вещи начинают происходить при попытке вывода последовательности:
    >>>
    print
    (
    range
    (
    10
    ))
    22

    Учебник Python 3.1: Материал из Викиучебника.
    range
    (
    0
    ,
    10
    )
    Во многих случаях объект, возвращаемый функцией range()
    , ведёт себя как список, но фактически им не является. Этот объект возвращает по очереди элементы желаемой последовательности, когда вы проходите по нему в цикле, но на самом деле не создаёт списка, сохраняя таким образом пространство в памяти.
    Мы называем такие объекты итерируемыми (iterable), и это все объекты, которые предназначаются для функций и конструкций, ожидающих от них поочерёдного предоставления элементов до тех пор, пока источник не иссякнет. Мы видели, что оператор for является таким итератором iterator. Функция list()
    тоже из их числа — она создаёт списки изитерируемых объектов:
    >>>
    list
    (
    range
    (
    5
    ))
    [
    0
    ,
    1
    ,
    2
    ,
    3
    ,
    4
    ]
    Позже мы познакомимся и с другими функциями, которые возвращают и принимают итерируемые объекты в качестве параметров.
    1   2   3   4   5   6   7   8   9   ...   13


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