3.1.2 Strings

Além dos números, o Python também pode manipular strings, o que pode ser expresso de várias maneiras. Eles podem ser incluídos em aspas simples ou aspas duplas:

>>> 'spam eggs'
    'spam eggs'
>>> 'doesn\'t'
    "doesn't"
>>> "doesn't"
    "doesn't"
>>> '"Yes," he said.'
    '"Yes," he said.'
>>> "\"Yes,\" he said."
    '"Yes," he said.'
>>> '"Isn\'t," she said.'
    '"Isn\'t," she said.'

As strings podem abranger várias linhas de várias maneiras. As linhas de continuação podem ser usadas, com uma barra invertida como último caracter na linha indicando que a próxima linha é uma continuação lógica da linha:

hello = "This is a rather long string containing\n\
several lines of text just as you would do in C.\n\
   Note that leading whitespace is\
 significant."
    
print hello

Note que as novas linhas ainda precisam ser incorporadas na string usando \n; A nova linha que segue a barra invertida anterior é descartada. Este exemplo imprimiria o seguinte:

    This is a rather long string containing
    several lines of text just as you would do in C.
        Note that leading whitespace is significant.

Se formos fazer uma cadeia de string “bruta”, no entanto, ao precedê-lo com o prefixo r, as seqüências \n não são convertidas em linhas novas, mas a barra invertida no final da linha e o caractere da nova linha na fonte são ambos incluídos na string como dados. Assim, o exemplo:

    hello = r"This is a rather long string containing\n\
    several lines of text much as you would do in C."
    
    print hello

será impresso:

    This is a rather long string containing\n\
    several lines of text much as you would do in C.

Ou, as strings podem ser cercadas em um par de aspas triplas correspondentes: “”” ou ”’. O final das linhas não precisa ser escapado ao usar as aspas triplas, mas elas serão incluídas na string.

    print """
    Usage: thingy [OPTIONS] 
         -h                        Display this usage message
         -H hostname               Hostname to connect to
    """

Reproduz a seguinte saída:

 Usage: thingy [OPTIONS] 
         -h                        Display this usage message
         -H hostname               Hostname to connect to

O interpretador imprime o resultado das operações de seqüência de caracteres da mesma maneira que são digitadas para entrada: aspas internas e aspas com outros caracteres engraçados escapados por barras invertidas, para mostrar o valor preciso. A seqüência de caracteres é entre aspas duplas, se a seqüência de caracteres contiver uma única aspas e sem aspas duplas, senão ela é entre aspas simples. (A declaração de impressão, descrita mais tarde, pode ser usada para escrever strings sem aspas ou escapes.)

As strings podem ser concatenadas (coladas juntas) com o operador + e repetidas com *:

    >>> word = 'Help' + 'A'
    >>> word
    'HelpA'
    >>> ''
    ''

Dois literais de strings ao lado do outro são automaticamente concatenados; a primeira linha acima também poderia ter sido escrita ‘word =’ Help ” A ”; Isso só funciona com duas literais, não com expressões de string arbitrárias:

   >>> 'str' 'ing'             #  >> 'str'.strip() + 'ing'   #  >> 'str'.strip() 'ing'     #  <-  This is invalid
      File "", line 1, in ?
        'str'.strip() 'ing'
                          ^
    SyntaxError: invalid syntax

As strings podem ser subscritas (indexadas); Como em C, o primeiro caractere de uma seqüência tem subíndice (índice) 0. Não há nenhum tipo de caractere separador; um caracter é simplesmente uma seqüência de tamanho um. Como no ícone da linguagem, as substrings podem ser especificadas com a notação de partes: dois índices separados por dois pontos.

    >>> word[4]
    'A'
    >>> word[0:2]
    'He'
    >>> word[2:4]
    'lp'

As partes de índices têm padrões úteis; um primeiro índice omitido padrão é zero, um segundo índice omitido padrão para o tamanho da seqüência sendo cortada.

    >>> word[:2]    # The first two characters
    'He'
    >>> word[2:]    # All but the first two characters
    'lpA'

Ao contrário de uma string C, as seqüências de caracteres Python não podem ser alteradas. Atribuir a uma posição indexada na seqüência resulta em um erro:

    >>> word[0] = 'x'
    Traceback (most recent call last):
      File "", line 1, in ?
    TypeError: object doesn't support item assignment
    >>> word[:1] = 'Splat'
    Traceback (most recent call last):
      File "", line 1, in ?
    TypeError: object doesn't support slice assignment

No entanto, criar uma nova string com o conteúdo combinado é fácil e eficiente:

    >>> 'x' + word[1:]
    'xelpA'
    >>> 'Splat' + word[4]
    'SplatA'

Aqui está uma útil invariante de operações de subpartes: s [: i] + s [i:] é igual a s.

    >>> word[:2] + word[2:]
    'HelpA'
    >>> word[:3] + word[3:]
    'HelpA'

Os índices divididos corrompidos são tratados cuidadosamente: um índice que é muito grande é substituído pelo tamanho da string, um limite superior menor que o limite inferior retorna uma string vazia.

    >>> word[1:100]
    'elpA'
    >>> word[10:]
    "
    >>> word[2:1]
    "

Os índices podem ser números negativos, para começar a contar da direita. Por exemplo:

    >>> word[-1]     # The last character
    'A'
    >>> word[-2]     # The last-but-one character
    'p'
    >>> word[-2:]    # The last two characters
    'pA'
    >>> word[:-2]    # All but the last two characters
    'Hel'

Mas note que -0 é realmente o mesmo que 0, então não conta com a direita!

   >>> word[-0]     # (since -0 equals 0)
    'H'

As subpartes de índices negativos fora do intervalo são truncados, mas não tente isso para índices de um único elemento (não cortados):

    >>> word[-100:]
    'HelpA'
    >>> word[-10]    # error
    Traceback (most recent call last):
      File "", line 1, in ?
    IndexError: string index out of range

A melhor maneira de lembrar como subpartes funcionam é pensar nos índices como apontando entre caracteres, com a margem esquerda do primeiro caractere numerado 0. Então a borda direita do último caractere de uma seqüência de caracteres n possui índice n, por exemplo :

  +---+---+---+---+---+ 
  | H | e | l | p | A |
  +---+---+---+---+---+ 
  0   1   2   3   4   5 
 -5  -4  -3  -2  -1

A primeira linha de números dá a posição dos índices 0 … 5 na string; a segunda linha fornece os índices negativos correspondentes. A parte de i para j consiste de todos os caracteres entre as bordas identificadas i e j, respectivamente.

Para índices não negativos, o comprimento de uma suparte é a diferença dos índices, se ambos estiverem dentro dos limites. Por exemplo, o comprimento de word[1: 3] é 2.

A função incorporada len() retorna o comprimento de uma string:

    >>> s = 'supercalifragilisticexpialidocious'
    >>> len(s)
    34
Anúncios

Deixe um comentário

Preencha os seus dados abaixo ou clique em um ícone para log in:

Logotipo do WordPress.com

Você está comentando utilizando sua conta WordPress.com. Sair /  Alterar )

Foto do Google+

Você está comentando utilizando sua conta Google+. Sair /  Alterar )

Imagem do Twitter

Você está comentando utilizando sua conta Twitter. Sair /  Alterar )

Foto do Facebook

Você está comentando utilizando sua conta Facebook. Sair /  Alterar )

Conectando a %s