O Python tem uma classe de string integrada chamada "str" com vários recursos úteis (há um módulo mais antigo chamado "string", que você não deve usar). Os literais de string podem ser delimitados por aspas duplas ou simples, embora as aspas simples sejam mais usadas. O escape de barra invertida funciona da maneira normal dentro de literais simples e duplos entre aspas. Por exemplo: \n \ \". Um literal de string entre aspas duplas pode conter aspas simples sem confusão (por exemplo, "Eu não fiz isso") e, da mesma forma, uma string entre aspas simples pode conter aspas duplas. Um literal de string pode abranger várias linhas, mas precisa haver uma barra invertida \ no final de cada linha para fazer o escape da nova linha. Literais de string entre aspas triplas, """ ou ''', podem abranger várias linhas de texto.
Strings do Python são "imutáveis" o que significa que eles não podem ser alterados depois de criados (strings Java também usam esse estilo imutável). Como as strings não podem ser alteradas, construímos strings *novas* para representar valores computados. Por exemplo, a expressão ("hello" + "there") aceita as duas strings "hello" e "há" e cria uma nova string "hellothere".
Os caracteres em uma string podem ser acessados usando a sintaxe padrão [ ] e, como Java e C++, Python usa indexação baseada em zero, portanto, se s for "hello" s[1] é "e". Se o índice estiver fora dos limites para a string, o Python vai gerar um erro. O estilo Python (ao contrário de Perl) deve ser interrompido se não puder dizer o que fazer, em vez de apenas criar um valor padrão. A "fatia" útil (abaixo) também funciona para extrair qualquer substring de uma string. A função len(string) retorna o comprimento de uma string. A sintaxe [ ] e a função len() realmente funcionam em qualquer tipo de sequência: strings, listas etc. O Python tenta fazer as operações funcionarem de forma consistente em diferentes tipos. Nova ideia sobre Python: não use "len" como um nome de variável para evitar o bloqueio da função len(). O sinal "+" pode concatenar duas strings. Observe no código abaixo que as variáveis não são pré-declaradas; apenas as atribua e prossiga.
s = 'hi' print(s[1]) ## i print(len(s)) ## 2 print(s + ' there') ## hi there
Ao contrário do Java, o sinal "+" não converte automaticamente números ou outros tipos para formato de string. A função str() converte valores em uma forma de string para que eles possam ser combinados com outras strings.
pi = 3.14 ##text = 'The value of pi is ' + pi ## NO, does not work text = 'The value of pi is ' + str(pi) ## yes
Para números, os operadores padrão +, /, * funcionam da maneira habitual. Não há operador ++, mas +=, -= etc. funcionam. Para dividir números inteiros, use duas barras. Por exemplo: 6 // 5 é 1
A "impressão" normalmente exibe um ou mais itens Python seguidos por uma nova linha. Um valor "bruto" o literal de string é prefixado por um "r" e passa todos os caracteres sem tratamento especial de barras invertidas, então r'x\nx' avalia como a string length-4 "x\nx". "imprimir" pode usar vários argumentos para mudar a forma como ela exibe as informações (consulte a definição da função de impressão em python.org), como: configuração "final" para "" para não imprimir uma nova linha depois de terminar de imprimir todos os itens.
raw = r'this\t\n and that' # this\t\n and that print(raw) multi = """It was the best of times. It was the worst of times.""" # It was the best of times. # It was the worst of times. print(multi)
Métodos de string
Aqui estão alguns dos métodos de string mais comuns. Um método é como uma função, mas é executado "em" um objeto. Se a variável s for uma string, o código s.lower() executará o método bottom() nesse objeto string e retornará o resultado (essa ideia de um método executado em um objeto é uma das ideias básicas que compõem a Programação Orientada a Objetos, OOP). Confira alguns dos métodos de string mais comuns:
- s.lower(), s.upper(): retorna a versão em letras minúsculas ou maiúsculas da string
- s.strip(): retorna uma string com o espaço em branco removido do início e do fim
- s.isalpha()/s.isdigit()/s.isspace()... -- testa se todos os caracteres de string estão nas várias classes de caracteres
- s.startswith('other'), s.endswith('other') -- testa se a string começa ou termina com determinada string
- s.find('other') -- procura a outra string fornecida (não uma expressão regular) em s e retorna o primeiro índice onde começa ou -1 se não for encontrado
- s.replace('old', 'new') -- retorna uma string em que todas as ocorrências de 'old' foram substituídos por "new"
- s.split('delim') -- retorna uma lista de substrings separadas pelo delimitador fornecido. O delimitador não é uma expressão regular, é apenas texto. 'aaa,bbb,bch, zzz'.split(',') -> ['aaa', 'bbb', 'cef']. Como um caso especial conveniente, s.split() (sem argumentos) é dividido em todos os caracteres de espaço em branco.
- s.join(list) - oposto de split(), une os elementos da lista indicada usando a string como delimitador. Por exemplo: '---'.join(['aaa', 'bbb', 'c/ch']) -> aaa---bbb---ccc
Uma pesquisa no Google por "python str" deve levar você aos métodos de string python.org oficiais, que listam todos os métodos str.
O Python não tem um tipo de caractere separado. Em vez disso, uma expressão como s[8] retorna um string-length-1 contendo o caractere. Com essa string-length-1, os operadores ==, <=, ... funcionam como o esperado, então, na maioria das vezes, você não precisa saber que o Python não tem um "char" escalar separado não é válido.
Fatias de string
A "fatia" é uma maneira prática de se referir a subpartes de sequências, normalmente strings e listas. A fração s[start:end] são os elementos que começam no início e se estendem até o final, mas sem incluí-lo. Suponha que temos s = "Olá"
- s[1:4] é "ell" -- caracteres começando no índice 1 e se estendendo até o índice 4, mas não incluindo ele
- s[1:] é "ello" -- a omissão de um dos índices tem como padrão o início ou o fim da string
- s[:] é "Olá" -- a omissão de ambos sempre nos dá uma cópia do todo (essa é a maneira Python de copiar uma sequência como uma string ou lista)
- s[1:100] é "ello" -- um índice muito grande é truncado para o comprimento da string
Os números de índice padrão baseados em zero oferecem acesso fácil aos caracteres próximos ao início da string. Como alternativa, o Python usa números negativos para facilitar o acesso aos caracteres no fim da string: s[-1] é o último caractere 'o', s[-2] é 'l' penúltimo caractere e assim por diante. Os números de índice negativos são contabilizados a partir do fim da string:
- s[-1] é 'o' -- último caractere (1o a partir do final)
- s[-4] é "e" -- 4o a partir do final
- s[:-3] é 'Ele' - até os últimos 3 caracteres, mas sem incluí-los.
- s[-3:] é "llo" -- começando pelo 3o caractere do final e se estendendo até o fim da string.
É um fato puro de frações que para qualquer índice n, s[:n] + s[n:] == s. Isso funciona até mesmo para n negativos ou fora do limite. Ou, de outra forma, s[:n] e s[n:] sempre particionam a string em duas partes, conservando todos os caracteres. Como veremos na seção de lista mais tarde, as frações também funcionam com listas.
Formatação de strings
Uma coisa legal que a Python pode fazer é converter automaticamente objetos em uma string adequada para impressão. Duas maneiras integradas de fazer isso são strings formatadas literais, também chamados de "f-strings", e invocar str.format().
Literais de string formatados
Muitas vezes, literais de string formatados são usados em situações como:
value = 2.791514 print(f'approximate value = {value:.2f}') # approximate value = 2.79 car = {'tires':4, 'doors':2} print(f'car = {car}') # car = {'tires': 4, 'doors': 2}
Uma string literal formatada é prefixada com "f" (como o prefixo 'r' usado para strings brutas). Qualquer texto fora de chaves '{}' é impresso diretamente. Expressões contidas em '{}' são são impressos usando a especificação de formato descrita em a especificação de formato. Há muitas coisas legais que podem ser feitas com a formatação, incluindo truncamento e conversão para notação científica e alinhamento à esquerda/direita/centro.
As f-strings são muito úteis quando você deseja imprimir uma tabela de objetos e gostaria colunas representando diferentes atributos de objetos a serem alinhadas como
address_book = [{'name':'N.X.', 'addr':'15 Jones St', 'bonus': 70}, {'name':'J.P.', 'addr':'1005 5th St', 'bonus': 400}, {'name':'A.A.', 'addr':'200001 Bdwy', 'bonus': 5},] for person in address_book: print(f'{person["name"]:8} || {person["addr"]:20} || {person["bonus"]:>5}') # N.X. || 15 Jones St || 70 # J.P. || 1005 5th St || 400 # A.A. || 200001 Bdwy || 5
% de string
O Python também tem um recurso parecido com printf() mais antigo para criar uma string. O operador % usa uma string de formato do tipo printf à esquerda (%d int, %s string, ponto flutuante %f/%g) e os valores correspondentes em uma tupla à direita (tupla é composta de valores separados por vírgulas, normalmente agrupados entre parênteses):
# % operator text = "%d little pigs come out, or I'll %s, and I'll %s, and I'll blow your %s down." % (3, 'huff', 'puff', 'house')
A linha acima é meio longa. Vamos supor que você queira dividi-la em linhas separadas. Não é possível simplesmente dividir a linha após "%" como você faria em outras linguagens, já que, por padrão, o Python trata cada linha como uma instrução separada (do lado positivo, é por isso que não precisamos digitar ponto e vírgula em cada linha). Para corrigir isso, coloque toda a expressão entre parênteses externos. Assim, a expressão poderá abranger várias linhas. Essa técnica de código entre linhas funciona com as várias construções de agrupamento detalhadas abaixo: ( ), [ ] e { }.
# Add parentheses to make the long line work: text = ( "%d little pigs come out, or I'll %s, and I'll %s, and I'll blow your %s down." % (3, 'huff', 'puff', 'house'))
Melhorou, mas a linha ainda está um pouco longa. O Python permite recortar uma linha em pedaços, que serão concatenados automaticamente. Então, para tornar essa linha ainda mais curta, podemos fazer o seguinte:
# Split the line into chunks, which are concatenated automatically by Python text = ( "%d little pigs come out, " "or I'll %s, and I'll %s, " "and I'll blow your %s down." % (3, 'huff', 'puff', 'house'))
Strings (Unicode x bytes)
As strings Python regulares são Unicode.
O Python também suporta strings compostas por bytes simples (indicados pelo prefixo "b" na frente de um literal de string) como:
> byte_string = b'A byte string' > byte_string b'A byte string'
Uma string unicode é um tipo diferente de objeto de uma string de bytes, mas várias bibliotecas, como as expressões regulares funcionam corretamente se receberem qualquer tipo de string.
Para converter uma string Python comum em bytes, chame o método encode() na string. Indo na outra direção, o método decode() da string de bytes converte bytes simples codificados em uma string unicode:
> ustring = 'A unicode \u018e string \xf1' > b = ustring.encode('utf-8') > b b'A unicode \xc6\x8e string \xc3\xb1' ## bytes of utf-8 encoding. Note the b-prefix. > t = b.decode('utf-8') ## Convert bytes back to a unicode string > t == ustring ## It's the same as the original, yay!True
Na seção de leitura de arquivos, há um exemplo que mostra como abrir um arquivo de texto com codificação e ler strings Unicode.
Instrução If
O Python não usa { } para incluir blocos de código para if/loops/function etc.. Em vez disso, o Python usa dois-pontos (:) e recuo/espaço em branco para agrupar instruções. O teste booleano de "if" não precisa estar entre parênteses (grande diferença de C++/Java) e pode ter cláusulas *elif* e *else* (mnemônica: a palavra "elif" tem o mesmo tamanho que a palavra "else").
Qualquer valor pode ser usado como um teste if. O "zero" todos os valores contam como falsos: nenhum, 0, string vazia, lista vazia, dicionário vazio. Há também um tipo booleano com dois valores: True e False (convertidos em int, são 1 e 0). O Python tem as operações de comparação usuais: ==, !=, <, <=, >, >=. Ao contrário de Java e C, == é sobrecarregado para funcionar corretamente com strings. Os operadores booleanos são as palavras *e*, *ou*, *não* (o Python não usa o estilo C && || !). O código de um app de saúde que fornece recomendações de bebidas ao longo do dia pode ser assim. Observe como cada bloco de instruções "then/else" começa com : e as instruções são agrupadas pelo recuo:
if time_hour >= 0 and time_hour <= 24: print('Suggesting a drink option...') if mood == 'sleepy' and time_hour < 10: print('coffee') elif mood == 'thirsty' or time_hour < 2: print('lemonade') else: print('water')
Acho que omitir ":" é meu erro de sintaxe mais comum ao digitar no tipo de código acima, provavelmente porque é uma coisa adicional a ser digitada em comparação com meus hábitos C++/Java. Além disso, não coloque o teste booleano em parênteses, pois isso é um hábito do C/Java. Se o código for curto, você poderá colocá-lo na mesma linha depois de ":". Isso também se aplica a funções, repetições etc., embora algumas pessoas acham mais legível espaçar as coisas em linhas separadas.
if time_hour < 10: print('coffee') else: print('water')
Exercício: string1.py
Para praticar o material desta seção, experimente o exercício string1.py nos Exercícios básicos.