Pular para o conteúdo principal
InicioTutoriaisPython

Tutorial de strings em Python

Neste tutorial, você aprenderá tudo sobre as cadeias de caracteres do Python: fatiamento e encadeamento, manipulação e formatação com a classe Formatter, cadeias de caracteres f, modelos e muito mais!
abr. de 2024  · 16 min leer

String é um conjunto de alfabetos, palavras ou outros caracteres. É uma das estruturas de dados primitivas e é o bloco de construção para a manipulação de dados. O Python tem uma classe de string incorporada chamada str. As cadeias de caracteres Python são "imutáveis", o que significa que não podem ser alteradas depois de criadas. Para a manipulação de strings, criamos novas strings à medida que avançamos para representar os valores computados devido à sua propriedade imutável.

Neste tutorial, você verá as cadeias de caracteres em profundidade e abordará os seguintes tópicos:

tutorial de python sobre strings

Se você estiver interessado em aprender mais sobre estruturas de dados em Python, não deixe de conferir a caixa de ferramentas de ciência de dados em Python do DataCamp, composta de duas partes. Este curso se aprofunda em funções, iteradores, listas, etc.

Cordas

Você pode manipular dados textuais no Python usando o objeto str. As cadeias de caracteres são sequências imutáveis de unicode. O Unicode é um sistema projetado para representar todos os caracteres dos idiomas. No unicode, cada letra ou caractere é representado como um número de 4 bytes. Cada número representa um caractere exclusivo.

Para representar uma string, você a coloca entre aspas. Pode haver várias maneiras de fazer isso:

  • Aspas simples, como neste exemplo: As aspas simples permitem que você incorpore aspas "duplas" em sua string.
  • Aspas duplas. Por exemplo: "As aspas duplas permitem que você incorpore aspas 'simples' em sua string."
  • Aspas triplas, como neste exemplo: """Triple quotes using double quotes"""", '''Triple quotes using single quotes.'''

A string entre aspas triplas permite que você trabalhe com strings de várias linhas, e todos os espaços em branco associados serão incluídos na string.

single_quote = 'Single quote allow you to embed "double" quotes in your string.'
double_quote = "Double quote allow you to embed 'single' quotes in your string."
triple_quote = """Triple quotes allows to embed "double quotes" as well as 'single quotes' in your string. 
And can also span across multiple lines."""

As cadeias de caracteres são imutáveis, o que significa que, se você tentar alterar qualquer valor em uma cadeia de caracteres, ocorrerá um erro. Você deve criar uma nova string para incorporar as alterações.

triple_quote = '''This is triple quoted string using "single" quotes.'''
triple_quote[35] = "'"
---------------------------------------------------------------------------

TypeError                                 Traceback (most recent call last)

<ipython-input-207-62d335428dcf> in <module>()
      1 triple_quote = '''This is triple quoted string using "single" quotes.'''
----> 2 triple_quote[35] = "'"


TypeError: 'str' object does not support item assignment
triple_quote_new = triple_quote[0:35] + "'single'" + triple_quote[43:]
print(triple_quote_new)
This is triple quoted string using 'single' quotes.

Você pode encontrar o comprimento de uma cadeia de caracteres usando a função integrada len():

len(triple_quote_new)
51

Comece a aprender Python de graça

Introduction to Python

BeginnerSkill Level
4 hr
5.5M learners
Master the basics of data analysis with Python in just four hours. This online course will introduce the Python interface and explore popular packages.

Fatiamento de strings em Python

Como as cadeias de caracteres são uma sequência de caracteres, você pode acessá-las por meio de fatiamento e indexação da mesma forma que faria com as listas ou tuplas do Python. As cadeias de caracteres são indexadas em relação a cada caractere da cadeia e a indexação começa em 0:

tutorial de string em python

Na cadeia de caracteres acima, o primeiro índice é C e está indexado em 0. O último caractere é um ponto final ., que é o 16º caractere da cadeia. Também é possível acessar os caracteres na direção oposta a partir de -1, o que significa que você também pode usar -1 como valor de índice para acessar . na cadeia de caracteres. Há também um espaço em branco entre Chocolate e cookie, que também faz parte da cadeia de caracteres e tem seu próprio índice, 9 nesse caso. Você pode verificar isso usando o fatiamento.

Como cada caractere em uma string Python tem um número de índice correspondente, você pode acessar e manipular strings da mesma forma que outros tipos de dados sequenciais. O fatiamento é uma técnica em Python que permite que você use um elemento específico ou um subconjunto de elementos de um objeto contêiner usando seus valores de índice. O fatiamento evita que você tenha que escrever instruções de loop para percorrer os índices da cadeia de caracteres para localizar ou acessar determinadas subcadeias.

snack = "Chocolate cookie."
print(snack[0])
print(snack[9])
print(snack[-1])
C

.

Vamos supor que você queira extrair a substring "cookie" da string abaixo. Como você faria isso?

Nesses casos, você usa o fatiamento de intervalo.

A sintaxe para o corte de intervalo é a seguinte: [Start index (included): Stop index (excluded)]

snack = "Chocolate cookie."
print(snack[10:16])
cookie

Você também pode fazer isso usando um valor negativo para o índice de parada:

print(snack[10:-1]) # -1: since the stop index is excluded in slicing.
cookie

O fatiamento sem especificar o índice de parada significa que você captura os caracteres do índice inicial até o último índice da frase. Da mesma forma, o fatiamento com o índice inicial ausente significa que você começa do primeiro índice da cadeia de caracteres até o índice final:

# Stop value not provided
print(snack[0:]) 

# Start value not provided (Stop value excluded according to syntax)
print(snack[:-1])

# This is also allowed
print(snack[:])
Chocolate cookie.
Chocolate cookie
Chocolate cookie.

O fatiamento de strings também pode aceitar um terceiro parâmetro, o stride, que se refere a quantos caracteres você deseja avançar depois que o primeiro caractere for recuperado da string. O valor de stride é definido como 1 por padrão.

Vamos ver o site stride em ação para entendê-lo melhor:

number_string = "1020304050"
print(number_string[0:-1:2])
12345

Dica: Algo muito legal que você pode fazer com o striding é inverter uma corda:

print(number_string[::-1]) #
0504030201

O valor de -1 para o stride permite que você inicie a partir do caractere final e, em seguida, mova um caractere de cada vez.

Como alternativa, se você fornecer -2 como um valor, começará a partir do caractere final e moverá dois caracteres de cada vez:

print(number_string[::-2]) #
00000

Operações comuns com strings

O fatiamento e o fatiamento de intervalo são as operações comuns que você precisaria executar em strings. Há também a concatenação de strings, que é tão simples quanto a adição:

string1 = 'Chocolate'
string2 = 'cookie'

snack = string1 + " " + string2
print(snack)
Chocolate cookie

No entanto, isso não funcionará se você tentar concatenar uma cadeia de caracteres com algum outro tipo de dados.

cost = 15
string1 = "The total in Euro is: "

bill = string1 + cost
print(bill)
---------------------------------------------------------------------------

TypeError                                 Traceback (most recent call last)

<ipython-input-218-7d5c5248b927> in <module>()
      2 string1 = "The total in Euro is: "
      3 
----> 4 bill = string1 + cost
      5 print(bill)


TypeError: Can't convert 'int' object to str implicitly

Aqui, você tentou concatenar uma string com um valor inteiro, o que não é permitido. O interpretador não pode entender implicitamente se você está tentando realizar uma simples adição de números inteiros ou uma concatenação de strings. No entanto, tente isso agora:

bill = string1 + str(cost)
print(bill)
The total in Euro is: 15

Isso ocorre porque você converteu explicitamente um número inteiro em um valor de cadeia de caracteres e, em seguida, aplicou a concatenação. Para saber mais sobre conversões de tipos de dados, consulte este tutorial.

Para repetir uma cadeia de caracteres, use a operação *.

single_word = 'hip '
line1 = single_word * 2 + 'hurray! '
print(line1 * 3)
hip hip hurray! hip hip hurray! hip hip hurray! 

Você também pode verificar a propriedade de associação em uma string usando in e not in:

sub_string1 = 'ice'
sub_string2 = 'glue'
string1 = 'ice cream'
if sub_string in string1:
    print("There is " + sub_string + " in " + string1)
if sub_string2 not in string1:
    print("Phew! No " + sub_string2 + " in " + string1)
There is ice in ice cream
Phew! No glue in ice cream

O Python fornece muitos métodos internos ou funções auxiliares para manipular strings. Substituir uma substring, colocar determinadas palavras em maiúsculas em um parágrafo, encontrar a posição de uma string dentro de outra string são algumas das operações que você pode fazer com esses métodos internos.

Dê uma olhada em alguns deles em detalhes:

  • str.capitalize()Retorna uma cópia da cadeia de caracteres com o primeiro caractere em maiúscula.
str.capitalize('cookie')
'Cookie'
  • str.islower()Retorna true se todos os caracteres da cadeia de caracteres forem minúsculos e false caso contrário.
snack = 'cookie'
snack.islower()
True
  • str.find(substring)Retorna o índice mais baixo da cadeia de caracteres em que a substring é encontrada. Você também pode especificar o índice inicial e final dentro da string onde deseja que a substring seja pesquisada. Retorna -1 se a substring não for encontrada.
str1 = 'I got you a cookie'
str2 = 'cook'
str1.find(str2)
12
  • str.count(substring)Conta quantas vezes uma substring ocorre na string. Você também pode especificar o índice de início e de parada da string.
str1 = 'I got you a cookie, do you like cookies?'
str2 = 'cookie'
str1.count(str2)
2
  • str.isspace()Retorna True se houver apenas caracteres de espaço em branco na cadeia de caracteres e, caso contrário, falso. Caracteres de espaço em branco são os caracteres como espaço, tabulação, próxima linha, etc.

Isso pode ser útil ao trabalhar com conjuntos de dados da vida real, que nem sempre codificam o espaçamento adequado durante a conversão de um formato para outro.

str_space = '   '
str_space.isspace()
True
str_tab = '\t'
str_tab.isspace()
True
str_nextline = '''\n'''
str_nextline.isspace()
True

Observação: Você notou o \t, \n acima? Eles são chamados de caracteres de escape. Eles começam com um \ (barra invertida). Internamente, eles não são interpretados como cadeias de caracteres normais, mas sim como caracteres especiais que representam outra coisa. Por exemplo, \t representa uma guia. Há muitos outros personagens de fuga e você pode ler mais sobre eles aqui.

  • str.lstrip()Remove todos os espaços em branco à esquerda na string. Essa é outra função que pode ser útil quando se está trabalhando com conjuntos de dados reais.
str1 = " I can't hear you. Are you alright? "
str2 = " Yes, all is good."
str3 = str1.lstrip() + str2.lstrip()
print(str3)
I can't hear you. Are you alright? Yes, all is good.
  • str.isdigit()Retorna True se a cadeia de caracteres contiver apenas dígitos e False caso contrário.
number_string = "1020304050"
number_string.isdigit()
True
  • str.replace(substring, new)substitui todas as ocorrências da substring na string por new. Você também pode definir um terceiro argumento max, que substitui no máximo max ocorrências de substring na cadeia de caracteres. Lembre-se de que essa não é uma substituição inplace, o que significa que a propriedade imutável ainda se mantém e uma nova cadeia de caracteres é de fato formada.
string1 = 'hip hip hurray! hip hip hurray! hip hip hurray!'
string2 = string1.replace('hip', 'Hip')
print(string1)
print(string2)
hip hip hurray! hip hip hurray! hip hip hurray!
Hip Hip hurray! Hip Hip hurray! Hip Hip hurray!
string1.replace('hip', 'Hip', 2)
'Hip Hip hurray! hip hip hurray! hip hip hurray!'
  • str.split(delimiter="")divide a cadeia de caracteres de acordo com o delimitador (espaço, se não for fornecido) e retorna uma lista de subcadeias.
dessert = 'Cake, Cookie, Icecream'
list_dessert = string1.split(',')

Você pode encontrar uma lista exaustiva de métodos de string em Python aqui.

Formatação de strings

O Python oferece suporte a várias maneiras de formatar uma string. Nesta seção, você aprenderá mais sobre essas strings de formatação!

% Formatação

O módulo % é uma operação integrada no Python. Ele é conhecido como o operador de interpolação. Você precisará fornecer % seguido do tipo de dado que precisa ser formatado ou convertido. A operação % substitui a frase '%datatype' por zero ou mais elementos do tipo de dados especificado:

print("I bought %d Euro worth of %s!" %(200, 'cookies'))
I bought 200 Euro worth of cookies!

Você já viu %d ser usado para inteiros e %s para cadeias de caracteres. Alguns dos outros tipos de conversão disponíveis são: o para valores octal, x para hexadecimal, f para formato decimal de ponto flutuante, c para caractere único (aceita inteiro ou cadeia de caracteres única).

A classe do formatador

A classe formatter é uma das classes de string incorporadas. Ele oferece a capacidade de fazer substituições complexas de variáveis e formatação de valores usando o método format(). Ele permite que você crie e personalize seus próprios comportamentos de formatação de cadeia de caracteres reescrevendo os métodos públicos que ele contém: format(), vformat(). Ele tem alguns métodos que devem ser substituídos por subclasses: parse(), get_field(), get_value(), check_unused_args(), format_field() e convert_field(). No entanto, para simplificar, você verá apenas a funçãoformat() mais comumente usada em ação...

print("I bought {0} Euro worth of {1}!".format(200,'cookies')) #Accessing values by position
I bought 200 Euro worth of cookies!
print("I bought {total} Euro worth of {item}!".format(total = 200, item = 'cookies')) #Accessing values by name
I bought 200 Euro worth of cookies!
'{:#<10}'.format('Cake') #Left aligment for word 'Cake' according to right alignment, gaps filled with '#'
'Cake######'
'{:#^10}'.format('Cake') #Centre aligment for word 'Cake' according to right alignment, gaps filled with '#'
'###Cake###'
'{:#>10}'.format('Cake') #Right aligment for word 'Cake' according to right alignment, gaps filled with '#'
'######Cake'
for num in range(1,10): 
        print('{0:{width}}'.format(num, width=5), end=' ')
    1     2     3     4     5     6     7     8     9 

Strings de modelo

Em vez das substituições normais baseadas em %, os modelos suportam substituições baseadas em $. A lógica por trás da introdução do modelo na versão 2.4 do Python foi o fato de que, embora a formatação de strings do % seja poderosa e rica, ela é propensa a erros e também bastante rigorosa em termos dos formatos que seguem '%', o que a torna complexa. Um erro comum na formatação de % é esquecer o caractere de formato final, por exemplo: o e em %(variabl)e.

Os modelos têm alguns métodos definidos em: substitute() e safe_substitute(). Veja como você pode usá-los:

from string import Template #First you will need to import 'Tempalte' class

money = dict(who = 'You', to_whom = 'baker')
Template('$who owe the $to_whom a total of $$100').substitute(money)
'You owe the baker a total of $100'

Percebeu o $$ no exemplo acima?

Isso ocorre porque no modelo $$ há um caractere de escape que é substituído por um único $. Essa é uma das regras do modelo. Outra regra para o modelo é a forma como você define o identificador em seu modelo; há a sintaxe usual: $identifier, mas você também tem ${identifier}.

Isso significa que ${identifier}é o mesmo que $identifier, mas pode ser usado para cenários como:

word = dict(noun = 'feed')
Template('Please don\'t stop ${noun}ing me').substitute(word)
"Please don't stop feeding me"

Vamos ver como você pode usar substitute() e safe_substitute().

fact = Template('$alter_ego is weak but wait till he transforms to $superhero!')
fact.substitute(alter_ego='Bruce Banner', superhero='Hulk')
'Bruce Banner is weak but wait till he transforms to Hulk!'
hero = dict(alter_ego='Peter Parker')
fact.substitute(hero)
---------------------------------------------------------------------------

KeyError                                  Traceback (most recent call last)

<ipython-input-244-c82f6a2ebc02> in <module>()
      1 hero = dict(alter_ego='Peter Parker')
----> 2 fact.substitute(hero)


~/anaconda3/envs/tensorflow/lib/python3.5/string.py in substitute(*args, **kws)
    127             raise ValueError('Unrecognized named group in pattern',
    128                              self.pattern)
--> 129         return self.pattern.sub(convert, self.template)
    130 
    131     def safe_substitute(*args, **kws):


~/anaconda3/envs/tensorflow/lib/python3.5/string.py in convert(mo)
    117             named = mo.group('named') or mo.group('braced')
    118             if named is not None:
--> 119                 val = mapping[named]
    120                 # We use this idiom instead of str() because the latter will
    121                 # fail if val is a Unicode containing non-ASCII characters.


KeyError: 'superhero'

O exemplo acima gera um erro, pois o endereço superhero não está definido. No entanto, tente isso...

fact.safe_substitute(hero)
'Peter Parker is weak but wait till he transforms to $superhero!'

O site safe_substitute() é uma das vantagens do uso de modelos.

Por que tantas opções de formatação de strings, você pergunta?

Bem, isso é principalmente uma questão de preferências de sintaxe. Isso geralmente se resume a uma troca entre simplicidade e verbosidade e também depende de sua familiaridade com as sintaxes existentes. Por exemplo, o uso do % para formatação de strings parecerá natural para pessoas com experiência em programação em C. Os modelos em Python são simples de escrever, enquanto o uso do format() pode ser mais detalhado, mas tem mais recursos.

Literal de string formatada (f-string)

Esse é outro método de formatação de string adicionado na versão 3.6 do Python. Um literal de cadeia de caracteres formatado ou cadeia de caracteres f é um literal de cadeia de caracteres prefixado com "f" ou "F". Você pode definir identificadores a serem usados em sua cadeia de caracteres entre chaves { }.

Por que mais uma opção de formatação de string? A praticidade e a simplicidade são lindas e é por isso!

Confira os exemplos abaixo para ver por que as f-strings são realmente a maneira mais simples e prática de formatar strings em Python.

alter_ego = 'Peter Parker' superhero = 'spiderman' f'{alter_ego} is weak but wait till he transforms to {superhero}!'

Observação: O código acima só funcionará com o Python versão 3.6 e superior. Para verificar a versão do Python que você instalou, digite: python -V no terminal. Caso contrário, você também pode usar o módulo sys no Python. Para usar isso, basta fazer o seguinte:

import sys
sys.version

As strings formatadas são, na verdade, expressões avaliadas em tempo de execução, o que significa que você pode usar qualquer expressão Python dentro das chaves de f-strings, o que é outra grande vantagem do uso de f-string.

f'{alter_ego} is weak but wait till he transforms to {superhero.capitalize()}!'

O f-string já é ótimo! Mas, espere, isso fica ainda melhor... as f-strings também são mais rápidas em comparação com os outros três métodos que você viu anteriormente. Isso ocorre porque eles são pré-analisados e armazenados em um bytecode eficiente para uma execução mais rápida.

Puxe as cordas certas!

Você chegou até o final do tutorial, parabéns! Você já viu o que são strings, aprendeu sobre o fatiamento de strings e viu algumas operações que podem ser realizadas em strings. Você também viu várias maneiras de formatar cadeias de caracteres. Mas lembre-se, o segredo para dominar qualquer técnica é a prática!

Strings é um dos vários tipos de dados do Python. Confira o curso Data Types for Data Science do DataCamp para saber mais sobre listas, dicionários, tuplas e conjuntos. Neste curso, você pode usar seu conhecimento sobre tipos de dados para usar. Você trabalhará com dados de trânsito da área metropolitana de Chicago para fins de ciência de dados. Vá até lá para ver com seus próprios olhos...

Temas

Cursos de Python na DataCamp

Course

Data Types for Data Science in Python

4 hr
65.5K
Consolidate and extend your knowledge of Python data types such as lists, dictionaries, and tuples, leveraging them to solve Data Science problems.
See DetailsRight Arrow
Start Course
Veja MaisRight Arrow
Relacionado

tutorial

Formatação de f-string em Python

Saiba mais sobre a técnica de formatação f-string no Python 3.6. Neste tutorial, você verá as vantagens que ele oferece e verá alguns exemplos de casos de uso.
Hafeezul Kareem Shaik's photo

Hafeezul Kareem Shaik

5 min

tutorial

Tutorial de Python

Em Python, tudo é objeto. Números, cadeias de caracteres (strings), DataFrames, e até mesmo funções são objetos. Especificamente, qualquer coisa que você usa no Python tem uma classe, um modelo associado por trás.
DataCamp Team's photo

DataCamp Team

3 min

tutorial

Como aparar uma cadeia de caracteres em Python: Três métodos diferentes

Aprenda os fundamentos do corte de caracteres à esquerda e à direita de uma string em Python.
Adel Nehme's photo

Adel Nehme

5 min

tutorial

Função do sublinhado (_) no tutorial de Python

Neste tutorial, você aprenderá sobre os usos do sublinhado (_) em python.
Hafeezul Kareem Shaik's photo

Hafeezul Kareem Shaik

8 min

tutorial

Operadores em Python

Este tutorial aborda os diferentes tipos de operadores em Python, sobrecarga de operadores, precedência e associatividade.
Théo Vanderheyden's photo

Théo Vanderheyden

9 min

tutorial

Tutorial de manipulação de dados categóricos de aprendizado de máquina com Python

Aprenda os truques comuns para lidar com dados categóricos e pré-processá-los para criar modelos de aprendizado de máquina!
Moez Ali's photo

Moez Ali

28 min

See MoreSee More