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 a ​ spas 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 i​ nt
%s ​é compatível com o tipo s ​ tr

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:

​ ​a quantidade de
Existem duas formas de percorrer os índices de uma string: (Considere n
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’

​ BS: ​Notou que o índice ​3​ é inválido? Se tentar acessar o programa vai voar! :(
O
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 como parâmetro a string que queremos buscar e retorna o índice
inicial que encontrar ou ​-1​ se ​não e
​ ncontrar.

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 l​ strip ​e pela direita use r​ strip​.
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):

​ enor​ << que

OBS:​ A condição if é True, pois o código de todo caracter maiúsculo é >> M
qualquer código de caracter minúsculo!
 ​ ue para cada
OBS:​ A codificação dos caracteres em Python segue a tabela​ UTF-8 q
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 c
​ hr​ é exatamente o oposto, recebe
como parâmetro o caracter e retorna o código da tabela.

------------------------------------------------------- // ------------------------------------------------------------