[INF1025] Resumo String

Prévia do material em texto

INF1025: Introdução à Programação 
Monitor: André Vicente Pessanha 
Resumo String: 
 
*************************************************************************************************** 
 
OBS:​ Essa matéria "Só" é cobrada na P1, P2 e P3! :D 
 
*************************************************************************************************** 
 
Definição: 
 
String é simplesmente um conjunto de caracteres. Lembrando que caracteres podem ser 
letras, números e símbolos. Toda string deve ser colocada entre aspas simples ou aspas 
duplas. Ambas estão corretas! 
 
pet = “cat” ​OU​ pet = ‘cat’ 
 
OBS:​ Recomendo ir acostumando usar sempre ​aspas duplas​ para >> ​string ​<< e ​aspas 
simples​ para >> ​caracter​ << pois em C (Prog 2) será obrigatório seguir esse critério. 
 
OBS: ​Observe que em Python (E em qualquer linguagem de script) >> Não << existe o tipo 
char para caracteres, somente o tipo >> ​str ​<< para strings. Então em Python, um caracter 
é representado como uma string de tamanho 1! 
 
------------------------------------------------------- // ------------------------------------------------------------ 
 
Caracteres especiais na função print: 
 
1) Use >> \n << para pular uma linha: 
 
print(“Isso é uma string\n”) 
 
OBS: ​Recomendo sempre usar \n no final das mensagens do print pra deixar o resultado na 
tela mais organizado. (Principalmente se tiver outros prints no resto do programa) 
 
2) Formatos de Impressão e limitar casas decimais: 
 
%f​ é compatível com o tipo ​float ​(Único tipo com casas decimais) 
%d ​é compatível com o tipo ​int 
%s ​é compatível com o tipo ​str 
 
 
n1 = 7.56 
n2 = 8.57 
 
print("Nota1: %.1f Nota2: %.1f\n" ​%​(n1,n2)) 
 
Notou que quando usamos esses formatos precisamos colocar uma >>​ %​ << após a última 
aspas? :) 
 
E além disso, é obrigatório colocar os parênteses (n1, n2) quando são duas variáveis ou 
mais! 
 
OBS: ​Lembrando que​ ​se colocar >>​ %f​ << vai exibir sempre 6 casas decimais! (Default) 
 
------------------------------------------------------- // ------------------------------------------------------------ 
 
Índices: 
 
Como uma string é um conjunto de caracteres, podemos acessar individualmente cada 
caracter através de seu índice. 
 
EX​: pet = “cat” 
 print( pet[0] ) #Exibe o caracter ‘c’ 
 
Regra Importante: 
 
Existem duas formas de percorrer os índices de uma string: (Considere ​n ​a quantidade de 
caracteres da string) 
 
- Da esquerda para a direita: Começa no índice zero até o índice n-1 
- Da direita para a esquerda: Começa do índice -1 (Último caracter) 
 
pet = “cat” (Aqui​ n vale 3 ​pois “cat” possui 3 caracteres) 
 
pet[0] armazena o caracter ‘c’ pet[-1] armazena o caracter ‘t’ 
pet[1] armazena o caracter ‘a’ pet[-2] armazena o caracter ‘a’ 
pet[2] armazena o caracter ‘t’ pet[-3] armazena o caracter ‘c’ 
 
 ​OBS: ​Notou que o índice ​3​ é inválido? Se tentar acessar o programa vai voar! :( 
A string “cat” possui 3 caracteres, mas a contagem do índice começa sempre em ​Zero​! (De 
0 até 2) 
 
OBS: ​Essa notação de índice negativo é exclusivo de Python e na maioria das linguagens 
só existe a notação com números positivos. Use somente nos casos em que o enunciado 
pedir pra inverter uma string ou se precisar acessar somente o último caracter (índice -1 ) 
 
 
 
 
------------------------------------------------------- // ------------------------------------------------------------ 
 
 
Operações Principais​: 
 
1) Concatenar: 
 
Podemos concatenar strings com o símbolo >>​ +​ << 
 
s1 = "Primeira e " 
s2 = "segunda mensagem :D" 
print( s1 + s2) 
 
OBS: ​Será exibido na tela >> “Primeira e segunda mensagem :D” << 
 
n1 = 7.5 
n2 = 8.5 
print("Nota1:", n1, "Nota2:", n2) 
 
 
OBS: ​Podemos concatenar strings com variáveis nas mensagens do print usando a vírgula 
>> ​,​ << Essa forma funciona independente do tipo da variável, pois é feito automaticamente 
a conversão de tipo para string. A única desvantagem é que essa forma não permite limitar 
a quantidade de casas decimais. 
 
mat = input("Digite a matrícula:") 
media = 8.5 
print("O aluno de Matrícula: " + mat + " Obteve média: " + str(media)) 
 
OBS: ​Essa é uma forma alternativa de concatenar strings com variáveis. Mas observe que 
usando essa notação precisamos sempre ​converter​ para string variáveis do tipo int e float, 
pois a função print só existe strings! 
 
2) Comparações entre strings: 
 
Todos os operadores que são usados em comparações entre números também são válidos 
em strings. ( != , == , >= , <= , etc) 
 
3) Duplicar String: 
 
Podemos duplicar uma string usando o operador >> ​*​ << 
 
OBS:​ Sim! É exatamente o mesmo da multiplicação! :O 
 
Teste esses exemplos no IDLE e observe atentamente o que acontece: 
 
nome = input("Digite seu nome:") 
print( 5 * '.' + nome + 5 * '.') 
 
print( 10 * "O_O ") 
 
OBS:​ Por mais inútil que isso pareça, na verdade uma das principais vantagens é criar uma 
lista (Conjunto de elementos) já inicializados com zero (Matéria da P2) 
 
 
4) Separar ou Fatiar uma String: 
 
Podemos especificar exatamente o pedaço que queremos da string através de um intervalo 
de índices. 
 
frase = "Isso é uma string" 
novaFrase = ​frase[11:] 
print(novaFrase) # Exibe “string” 
print(​ frase[7:10] ​) # Exibe “uma” 
 
 
 
OBS: ​A Fatia de uma string também é uma string! No exemplo acima a variável novaFrase 
é uma nova string! 
 
OBS: ​Exibe na tela >> ​uma​ << pois especificamos um intervalo que começa no​ índice 7 
(caracter ‘​u​’) e vai até o​ índice 9​ (Pois não inclui o 10) e como não especificamos o valor do 
passo, será sempre 1 em 1 caracter. 
 
Para separar a string >> “Isso” << podemos usar: 
 
print (frase[ :4] ) 
 
OBS​: Quando omitimos o intervalo inicial, o padrão é começar do índice zero! E da mesma 
forma, se omitir o intervalo final, é considerado percorrer do intervalo inicial até o final da 
string! 
 
print (frase[ : : 2] ) 
 
OBS:​ Exibe a string toda pulando os índices dos caracteres de 2 em 2. 
 
 
 ​5) Alterar uma String: (Criando uma nova através do Fatiamento!) 
 
Como não é possível alterar strings através do seu índice! Precisamos criar uma nova string 
que será uma cópia da string antiga concatenada com a alteração desejada. 
 
EX: Criamos uma string chamada “pombo” e queremos alterar para “Pombo” 
 
pet = "pombo" 
 
novoPet = 'P' + pet[1:] 
print(novoPet) 
 
 
OBS:​ Em Python strings são >> ​Imutáveis​ <<! Então fazer isso daqui pet[0] = ‘a’ é 
completamente errado​! :( 
 
 
------------------------------------------------------- // ------------------------------------------------------------ 
 
Principais Métodos de string​: 
 
 
1)​ A função ​len​ retorna a quantidade de caracteres que uma string possui. 
 
print( len (“Fritas”) ) #Quantidade de caracteres: 6 
 
2)​ O método ​split ​separa a string lida de acordo com um critério recebido como parâmetro. 
 
dia, mes, ano = input("Data de Nascimento: ").split(' ') 
print(dia + '/' + mes + '/' + ano) 
 
Ela recebe como parâmetro um caracter que representa o critério de separação usado na 
leitura. Recomendo sempre usar o caracter espaço como parâmetro da split, pois dessa 
forma o usuário vai digitar primeiro o dia, apertar espaço, digitar o mês, apertar espaço, 
digitar o ano e apertar enter somente no final. 
 
OBS:​ O nome disso é atribuição multivalorada (Semelhante em outras linguagens, como 
Lua) 
e funciona da seguinte forma, o primeiro valor digitado pelo usuário é armazenado na 
primeira variável (A que está mais na esquerda, a variável dia no exemplo acima) e assim 
por diante. :) 
 
OBS​: O método split só será ensinado na P3! Confirme com o seu professor se pode usar 
esse atalho em prova desde a P1! 
 
3) ​O método ​find ​recebe comoparâmetro a string que queremos buscar e retorna o índice 
inicial que encontrar ou ​-1​ se ​não ​encontrar. 
 
s1 = "Isso é uma string!!!" 
s2 = "uma" 
 
print (s1.find(s2)) # Achou no índice 7! 
 
print (s1.find(s2, 8)) # Não encontrou! Retorna -1 
 
OBS:​ O segundo parâmetro da find é opcional! Podemos especificar a partir de qual índice 
queremos buscar. E como o caracter ‘u’ está no índice 7 e queremos começar a buscar pelo 
índice 8 em diante. Então nesse caso a find retorna ​- 1​! (Não achou!) 
 
 
4) ​O método ​Join ​recebe uma lista (Conjunto de elementos) como parâmetro e concatena 
cada um dos elementos (Exceto o último!) com a primeira string. 
 
s1 = "_" 
s2 = ["Isso", "é", "uma", "string"] 
 
print(s1.join(s2)) # Exibe >> “Isso​_​é​_​uma​_​string” << 
 
5)​ O método​ replace ​recebe duas strings como parâmetro e substitui >> TODAS << 
ocorrências da primeira string pela segunda. 
 
s1 = "Pombo nadador nada longe" 
print(s1) 
s1 = s1.replace("nada", "voa") 
print(s1) # Exibe “Pombo voador voa longe” 
 
Podemos limitar a quantidade de substituições no terceiro parâmetro: 
 
s1 = "Pombo nadador nada longe" 
print(s1) 
s1 = s1.replace("nada", "voa", 1) 
print(s1) 
 
OBS: ​Dessa forma só será substituída a primeira ocorrência da primeira string! E nesse 
exemplo será exibido “Pombo voador nada longe” :D 
 
 
6)​ O método​ strip ​remove caracteres especiais (​‘\n’​) e brancos (Espaços) em ambos os 
lados da string. 
 
s1 = " Pombo Voador " 
s2 = "Voa longe" 
print(s1+s2) 
s1 = s1.strip() 
print(s1+s2) 
 
OBS: ​Para remover somente os brancos da esquerda, use ​lstrip ​e pela direita use ​rstrip​. 
 
 
 
 
7) ​A função ​lower​ converte todas as letras maiúsculas da string em minúsculas. 
 
pet = "PoMbo" 
print( lower(pet)) #Exibe pombo (Com todas as letras minúsculas!) 
 
Uma forma alternativa é usar print( pet.lower() ) pois lower é um método de string. 
OBS:​ A função ​upper​ é exatamente o oposto da lower! (Minúsculo para Maiúsculo) 
 
7)​ A função ​str​ converte o conteúdo de uma variável para string. 
 
valor = 2 
valor = str(valor) 
 
OBS:​ A variável valor é do tipo int e convertemos 2 para string “2” 
 
8) ​A função ​isalpha​ retorna True se a string >> só << contém letras. 
 
pet = "Cat" 
novo = "Pombo1" 
print( pet.isalpha() ) 
print(novo.isalpha()) 
 
OBS:​ Como a string pet só contém letras, pet.isalpha() é True. 
E como a string novo >> não << contém somente letras, então novo.isalpha() é False! ( Isso 
vale pra números ou símbolos) 
 
 
 
------------------------------------------------------- // ------------------------------------------------------------ 
 
 
- Codificação de caracteres: (Tabela UTF-8) 
 
Assim como números, caracteres (Minúsculos e Maiúsculos) também possuem uma >> 
Sequência Natural​ << que é justamente a ordem do alfabeto. 
 
pet = “Pombo” 
pet2 = “pombo” 
 
if (pet < pet2): 
 
OBS:​ A condição if é True, pois o código de todo caracter maiúsculo é >> ​Menor​ << que 
qualquer código de caracter minúsculo! 
 
OBS:​ A codificação dos caracteres em Python segue a tabela​ UTF-8 ​que para cada 
caracter existe um código correspondente em decimal e em hexadecimal. Coloque no 
google “Tabela UTF-8” e dê uma olhada por alto. É só pra conhecer, não precisa decorar 
nada :) 
 
OBS: ​A função ​ord(x) ​recebe um código como parâmetro e retorna o caracter 
correspondente da tabela ​UTF-8​. Enquanto a função ​chr​ é exatamente o oposto, recebe 
como parâmetro o caracter e retorna o código da tabela. 
 
 
------------------------------------------------------- // ------------------------------------------------------------