O str é um tipo de dado um pouco diferente dos demais tipos nativos de Python (que são int, float e bool) porque valores do tipo str, diferentemente do que ocorre com os valores dos demais tipos nativos, são formados a partir da composicação de valores "menores" - os caracteres. Nesse sentido, strings têm muitas semelhanças com listas, já que uma string pode ser vista como uma lista onde cada posição contém um caracter.
Assim como fazemos com listas, nós podemos:
usar a função len() para saber qual é o tamanho de uma string
acessar uma posição específica de uma string usando o operador de indexação []
usar o operador de "fatiar" : para obter trechos de uma string
Veja os exemplos a seguir:
texto = "A minha matéria favorita é MAC2166"
print("Texto completo: %s" %(texto))
print("O texto possui %d caracteres" %len(texto))
print("O caracter na posição 3 do texto é:", texto[2])
print("O trecho de texto entre as posições 7 e 15 é:", texto[6:15])
Embora possamos acessar o seu valor, não podemos modificar uma posição específica de uma string usando indexação. Strings em Python são imutáveis. Essa é uma diferença importante entre strings e listas. Veja o exemplo abaixo:
poeminha = "Betatinha quando dorme, espalha a rama pelo chão"
poeminha[1] = "a"
Há diferentes formas de se converter valores numéricos em strings. A mais direta delas é por meio da função str(), como mostrado nos exemplos a seguir:
num_dois = 2
print(num_dois, "-->", type(num_dois))
str_dois = str(num_dois) # converte o valor em num_dois para string e armazena-o em str_dois
print(str_dois, "-->", type(str_dois))
str_real = str(3.33333333333)
print(str_real, "-->", type(str_real))
Uma outra forma de converter números em strings é por meio de strings de formatação, como as que frequentemente usamos nos comandos print e input, nos exercícios que fazemos em aula. Veja exemplos a seguir:
num_real1 = 13.2278430
num_real2 = 4.9
num_int1 = 121
num_int2 = 6
str_reais_formatados = "Números reais formatados: |%6.3f|, |%6.3f|" %(num_real1, num_real2)
print(str_reais_formatados)
str_ints_formatados = "Números inteiros formatados: |%4d|, |%4d|" %(num_int1, num_int2)
print(str_ints_formatados)
str_num_simples = "%d" %(num_int1)
print(str_num_simples, "-->", type(str_num_simples))
O operador + (de concatenação) pode ser aplicado tanto a listas quanto a strings. O primeiro exemplo a seguir mostra um caso de uso envolvendo listas, enquanto o segundo exemplo se refere à concatenação de strings:
lista1 = [1,2,3]
lista2 = [9,8,7,6,5]
lista3 = lista1 + lista2 # cria uma nova lista contendo os elementos de lista1 e lista2
print(lista3)
verso1 = "Como diria o Cebolinha: "
verso2 = "- Keep calm and make an infallible plan!"
citacao = verso1 + verso2 # cria uma nova string com a junção de verso1 e verso2
print(citacao)
"Um caractere pode ser uma letra (maiúscula ou minúscula, um ponto final, ponto de interrogação, colchetes, enfim, símbolos que normalmente encontramos num teclado de um computador".
Em Python, um caractere é uma string de comprimento 1.
Como vimos na primeira aula deste curso, tudo o que computador armazena e processa são números. Por outro lado, durante este curso também já escrevemos programas que leem e manipulam textos (strings). Então, como será que o computador lida com os caracteres?
Para que possam ser processados pelo computador, precisamos representar os caracteres por meio de números.
Existem diferentes codificações (= representações numéricas) que podem ser usadas para caracteres. Algumas codificações são específicas para uma língua (como Chinês, Russo, etc.), enquanto outras podem ser usadas para múltiplas línguas. Um mesmo caracter pode aparecer em diferentes codificações; entretanto, duas codificações diferentes podem usar códigos numéricos diferentes para representar um mesmo caracter.
Uma das codificações mais conhecida (e antiga!) é a ASCII (American Standard Code for Information Interchange), que foi definida como um padrão em 1968. A ASCII foi criada para representar caracteres da língua inglesa e, para isso, usa os números entre 0 e 127. Como um código ASCII é um número entre 0 e 127, ele pode ser armazenado usando-se apenas 7 bits, ou seja, menos de 1 byte (= 8 bits). Você pode ver a tabela da codificação ASCII na Wikipédia.
A codificação ASCII define códigos apenas para caracteres não acentuados, portanto ela não representa completamente os caracteres de outras línguas que possuem o mesmo alfabeto do inglês, como o português, o francês e o espanhol. Para lidar com esse problema, nos anos 80 várias extensões do ASCII foram criadas usando os valores entre 128 e 255 como códigos para caracteres acentuados, resultando em códigos de 1 byte. Um exemplo de uma dessas extensões, usada para a língua portuguesa, é a codificação ISO-8859-1, também chamada de Latin1.
Problema das extensões do ASCII: 128 caracteres adicionais ainda não eram suficientes para representar ao mesmo tempo, por exemplo, os caracteres "especiais" existentes no português e no alfabeto russo.
A criação e uso de codificações específicas para um língua resolve uma parte desse problema. Um arquivo contendo um texto em português pode ter uma determinada codificação, enquanto um outro arquivo contendo um texto em russo pode ter uma codificação diferente. Mas o que fazer quando um texto em português precisava conter uma citação a um trecho em russo?
Para solucionar esse problema e prover uma representação unificada dos alfabetos de todas as línguas da humanidade (objetivo bastante ambicioso!), o padrão Unicode foi desenvolvido. Em sua proposta inicial, o Unicode usava códigos de até 16 bits (2 bytes), sendo capaz de codificar 2^16 = 65536 caracteres diferentes. Mas essa quantidade de caracteres logo mostrou-se insuficiente; atualmente, um código Unicode pode ocupar até 4 bytes (= 32 bits). O Unicode possui diferentes "implementações": UTF-8, UTF-16 e UTF-32. Para todos os caracteres que estão na tabela ASCII, o código Unicode (UTF-8) e o código ASCII são iguais.
O Python 3.x usa codificação UTF-8 como padrão. Já o Python 2.x usa a codificação ASCII como padrão.
ord() e chr()A função ord() devolve o código numérico do caractere passado como parâmetro. Veja os exemplos a seguir:
print(ord("8"))
print(ord("?"))
print(ord("A"))
print(ord("C"))
print(ord("^"))
print(ord("a"))
A função ord() gerará um erro se passarmos como parâmetro uma string contendo mais de um caracter:
ord("olá!")
A função chr() devolve o caracter corresponde ao código numérico passado como parâmetro. Veja os exemplos abaixo:
print(chr(43))
print(chr(54))
print(chr(65))
print(chr(472))
Importante: Em todos os exercícios a seguir, por simplicidade, trabalharemos apenas com strings com codificação ASCII, ou seja, strings que não contêm caracteres com acentos.
Escreva um programa que imprima todos os caracteres ASCII de 32 a 127.
def main():
for i in range(32,128):
print("Caracter '%c' tem código ASCII %d"%(chr(i), i))
#################
main()
Dada uma sequência de caracteres representando um texto, determinar a frequência relativa de vogais no texto.
Por exemplo, no texto:
"Em terra de cego quem tem um olho e caolho"
essa frequência é 16/42.
for elemento in ...)def main():
texto = input("Digite um texto: ")
n = len(texto)
nv = 0
vogais = ['a', 'e', 'i', 'o', 'u', 'A', 'E', 'I', 'O', 'U']
for letra in texto:
if letra in vogais:
nv += 1
print ("Frequencia relativa = %d/%d = %f" %(nv, n, nv/n))
#-------------------------------------------
main()
for para varrer a lista de vogais)def main():
texto = input("Digite um texto: ")
n = len(texto)
nv = 0
vogais = "aeiouAEIOU"
for i in range(n):
for j in range(len(vogais)):
if texto[i] == vogais[j]:
nv += 1
print ("Frequencia relativa = %d/%d = %f" %(nv, n, nv/n))
#-------------------------------------------
main()
a) Escreva uma função que recebe um caractere e, caso o caractere seja uma letra minúscula, retorna a letra maiúscula correspondente. Caso contrário, retorna o caractere.
b) Escreva uma função que recebe um caractere e, caso o caractere seja uma letra maiúscula, retorna a letra minúscula correspondente. Caso contrário, retorna o caractere.
c) Escreva um programa que leia uma frase e imprima:
def main():
texto = input("digite um texto: ")
textoMaiusculo = ''
textoMinusculo = ''
for l in texto:
textoMaiusculo += maiuscula(l)
textoMinusculo += minuscula(l)
print("Em maiúsculas: ")
print (textoMaiusculo)
print("Em minúsculas: ")
print(textoMinusculo)
def maiuscula(c):
if c >= 'a' and c <= 'z':
return chr(ord('A') + ord(c) - ord('a'))
else:
return c
def minuscula(c):
if c >= 'A' and c <= 'Z':
return chr(ord('a') + ord(c) - ord('A'))
else:
return c
#------------------------------
main()
Obs.: O tipo string em Python já possui funções para converter uma string para letras maiúsculas ou minúsculas - são as funções upper() e lower(). Veja um exemplo do uso delas a seguir:
texto = "PeQuEno TesTE"
textoMaiusculo = texto.upper() # cria uma string com o texto em letras maiúsculas
textoMinusculo = texto.lower() # cria uma string com o texto em letras minúsculas
print(textoMaiusculo)
print(textoMinusculo)
Faça um programa que, dada uma frase, imprima o comprimento da palavra mais longa nela.
def main():
frase = input("Digite uma frase: ")
n = len(frase)
tam = 0
max = 0
for ch in frase:
if 'a' <= ch <= 'z' or 'A' <= ch <= 'Z':
tam = tam + 1
else:
tam = 0
if tam > max:
max = tam
print("\nMaior comprimento de uma palavra = %d\n" %(max)
# início da execução do programa
main()
(a) Escreva uma função separa(texto, sep) que recebe como parâmetro um texto (= uma string) e um caractere separador sep e retorna uma lista contendo as "palavras" do texto usando o caractere sep como delimitador:
Por exemplo, para:
texto = "Como é bom estudar MAC2166!"
sep = " "
a função deve retornar
['Como', 'é', 'bom', 'estudar', 'MAC2166!']
A função deve "cortar" o texto nos separadores.
(b) Escreva um programa que leia uma linha com palavras separadas por espaços e determina o maior comprimento de uma palavra do texto. Utilize a função separa() do item anterior.
def main():
frase = input("Digite palavras separadas por espacos: ")
palavras = separa(frase, ' ')
print (palavras)
if len(palavras) > 0:
maxp = palavras[0]
for p in palavras:
print ("A palavra '%s' tem %d caracteres."%(p, len(p)))
if len(p) > len(maxp):
maxp = p
print("A maior palavra e '%s', que tem %d caracteres." %(maxp, len(maxp)))
else:
print("Nao achei nenhuma palavra em sua frase!")
#---------------------------------------------------------
def separa(texto, sep = ' '):
''' (str, chr) -> list
Recebe um string texto e um caractere separador sep e
retorna uma lista contendo as 'palavras' do texto usando
o caractere sep como delimitador:
Por exemplo para:
texto = "Como e bom estudar MAC2166!"
sep = " "
a funcao retorna
['Como', 'e', 'bom', 'estudar', 'MAC2166']
A funcao 'corta' o texto nos separadores.
'''
lista = []
palavra = ''
for car in texto:
if car != sep:
palavra += car
elif palavra != '':
lista.append(palavra)
palavra = ''
# coloca a ultima palavra na lista
if palavra != '':
lista.append(palavra)
return lista
#------------------------------------------------------
main()
A linguagem Python já tem uma função equivalente à separa() implementada no Problema 14.5: é função split(), que cria uma lista de strings a partir de uma só string. Essa função pode ser chamada por meio da notação de ponto, a partir de um objeto do tipo str. A função recebe como parâmetro o caractere (ou a string) que será usada como separador de substrings dentro da string a ser "desmembrada". Veja os exemplos de uso dela a seguir:
texto = "Passarim quis pousar, não deu, voou"
palavras = texto.split(" ") # usa o caracter de espaço como separador de substrings
print(palavras)
outro_texto = "Este é um string"
pedacos = outro_texto.split("t") # usa "t" como caracter separador
print(pedacos)
ord() e chr