Strings

Prof. Omero Francisco Bertol

(omero@utfpr.edu.br)

Outubro/ 2017
String (cadeia de caracteres)
• sequência de zero ou mais caracteres ASCII: letras,
números e símbolos especiais

• na linguagem Python denotadas entre aspas dupla ou aspas

simples, por exemplo:

• como nas listas os caracteres de uma cadeia podem ser

individualizados através de um índice, entre colchetes
([]), que indica a posição do caractere na cadeia:
– s[i], faz referência ao i-ésimo caractere da String “s”
A Tabela ASCII (American Standard Code for Information
Interchange) é usada pela maior parte da indústria de computadores
para a troca de informações.
Funções:
ord: retorna a ordem do

caractere indicado

chr: retorna o caractere

da ordem indicada

Cada caractere é representado por um código

de 8 bits, ou seja, um byte.

28 = 256 caracteres:
0 31 Caracteres de Controle
32 127 ASCII Normal
128 255 ASCII Estendida
Tabela ASCII
print("Maiúsculas:")
for i in range(65, 91):
print(chr(i), end="")

print("\n\nMinúsculas:")
for i in range(97, 123):
print(chr(i), end="")
65 90
print("\n\nNúmeros:")
for i in range(48, 58): Maiúsculas:
print(chr(i), end="") ABCDEFGHIJKLMNOPQRSTUVWXYZ

Minúsculas:
abcdefghijklmnopqrstuvwxyz
97
Números:
48 0123456789 57 122

>>>
Variáveis String (1/3)
Declarando uma String vazia:
>>> s = ""
>>> len(s) função "len" retorna o
tamanho da String
0

Atribuindo uma String: função "type" retorna o tipo

>>> nome = "Juca Bala" da variável:
>>> type(nome); print(nome) class 'str' String
<class 'str'> class 'int' inteiro
Juca Bala class 'float' ponto flutuante

Juntando uma lista de itens:

>>> s = "".join(['U', 'T', 'F', 'P', 'R'])
>>> type(s); print(s)
<class 'str'>
UTFPR
Variáveis String (2/3)
Atribuindo a entrada de dados (input):
>>> nome = input("Informe o seu nome: ")
Informe o seu nome: Juca Bala
>>> type(nome); print("Seja bem-vindo(a),", nome)
<class 'str'>
Seja bem-vindo(a), Juca Bala

>>> n = input("Informe um número inteiro: ")

Informe um número inteiro: 10
>>> type(n); n
<class 'str'>
'10'
função "int" converte um
valor para inteiro
>>> n = int(n)
>>> type(n); print(n)
<class 'int'>
10
Variáveis String (3/3)
Transformando valores para String:
>>> numero = 10
>>> type(numero); print(numero)
<class 'int'> função "str" converte um
10 valor para String
>>> strNumero = str(numero)
>>> type(strNumero); strNumero
<class 'str'>
'10'

>>> valor = 7.5

>>> type(valor); print(valor)
<class 'float'>
7.5
>>> strValor = str(valor)
>>> type(strValor); strValor
<class 'str'>
'7.5'
Representação interna de uma variável String
(operador de indexação)
>>> nome = "Juca Bala" nome
>>> print(nome) J u c a B a l a conteúdo
Juca Bala
0 1 2 3 4 5 6 7 8 índice
>>> len(nome)
9 -9 -8 -7 -6 -5 -4 -3 -2 -1 índice
0, posição do 1o caractere
8, posição do último caractere: len(nome)-1

nome[i], faz referência ao i-ésimo caractere da String "nome":

>>> nome[0], nome[1], nome[2], nome[3], nome[4]
('J', 'u', 'c', 'a', ' ')
>>> nome[5], nome[6], nome[7], nome[8], nome[-1], nome[-9]
('B', 'a', 'l', 'a', 'a', 'J')
>>> nome[9]
Traceback (most recent call last):
File "<pyshell#27>", line 1, in <module>
nome[9]
IndexError: string index out of range
Operações com Strings (1/5)
Comparação (==, !=, <, <=, >, >=):
os operadores relacionais também funcionam com valores
Strings.
>>> s1 = "AAA"
>>> s2 = "ZZZ"
>>> s3 = "AAA"

>>> (s1 == s2), (s1 != s2), (s1 == s3)

(False, True, True)

>>> (s1 < s2), (s1 > s2), (s1 <= s3), (s1 >= s3)
(True, False, True, True)
Operações com Strings (2/5)
Concatenação (+):
concatena (ou junta) o contéudo de variáveis ou valores
String.
>>> parte1 = "Omero"
>>> parte2 = "Francisco"
>>> parte3 = "Bertol"
>>> nome = parte1 + parte2 + parte3
>>> print(nome)
OmeroFranciscoBertol

>>> nome = parte1 + " " + parte2 + " " + parte3

>>> print(nome)
Omero Francisco Bertol

>>> salario = 950.75

>>> print("{ Salário = R$ " + str(salario) + " }")
{ Salário = R$ 950.75 }
Operações com Strings (3/5)
Repetição (*):
repete o contéudo de variáveis ou valores String.
>>> s = "{ UTFPR }"

>>> result = s * 3
>>> print(result)
{ UTFPR }{ UTFPR }{ UTFPR }
1o 2o 3o

>>> result = ((s + " => ") * 4) + s

>>> print(result)
{ UTFPR } => { UTFPR } => { UTFPR } => { UTFPR } => { UTFPR }
1o 2o 3o 4o

>>> print("=" * 30)

==============================
Operações com Strings (4/5)
Composição (%):
juntar valores a uma String através de especificadores de
formato.
>>> nome = "Juca Bala"
>>> idade = 33
>>> result = "%s, tem %d anos." % (nome, idade)
>>> print(result)
Juca Bala, tem 33 anos.

>>> salario = 950.75

>>> print("{ Salário = R$ %.2f }" % salario)
{ Salário = R$ 950.75 }

especificadores de formato:
%d para valores inteiros
%f para valores com ponto flutuante
%s para valores String
%c para valores caracteres
Exemplificando a composição (%) em
Strings (1/3)
• composição com números decimais:
>>> idade = 7
>>> print("Idade = [%d] anos." % idade)
Idade = [7] anos.

# alinhando (ou justificando) à direita

>>> print("Idade = [%2d] anos." % idade)
Idade = [ 7] anos.

# preenchendo com 0s (zero) à esquerda

>>> print("Idade = [%02d] anos." % idade)
Idade = [07] anos.

# alinhando (ou justificando) à esquerda

>>> print("Idade = [%-2d] anos." % idade)
Idade = [7 ] anos.
Exemplificando a composição (%) em
Strings (2/3)
• composição com números de ponto flutuante:
>>> salario = 980.75
>>> print("Salário = R$ %f" % salario)
Salário = R$ 980.750000

# apresentando o valor com 2 casas decimais

>>> print("Salário = R$ %.2f" % salario)
Salário = R$ 980.75

# apresentando o valor em 10 posições (justificado à

# direita), sendo 2 posições para o valor decimal
>>> print("Salário = R$ %10.2f" % salario)
Salário = R$ 980.75

1 2
1 2 3 4 5 6 7 8 9 10
Exemplificando a composição (%) em
Strings (3/3)
• composição com Strings:
>>> nome = "Juca Bala"
>>> salario = 980.75

>>> print("%s {R$ %.2f}" % (nome, salario))

Juca Bala {R$ 980.75}

# alinhando (ou justificando) à direita

>>> print("%20s {R$ %.2f}" % (nome, salario))
Juca Bala {R$ 980.75}

# alinhando (ou justificando) à esquerda

>>> print("%-20s {R$ %.2f}" % (nome, salario))
Juca Bala {R$ 980.75}
Operações com Strings (5/5)
Fatiamento (slicing):
obter fatias (partes) da String, por exemplo: nome[0:4], o
resultado será uma fatia, com 4 caracteres, da String “nome”
obtida a partir do primeiro caractere (posição 0) até o caractere
da posição 3 (4-1).
J u c a B a l a
nome
0 1 2 3 4 5 6 7 8

>>> nome = "Juca Bala" >>> print(nome[2:7])

>>> print(nome[0:4])
Juca # da posição 0 até a posição 3
>>> print(nome[:4])
Juca # a partir da posição 0 até a posição 3
>>> print(nome[5:9])
Bala # da posição 5 até a posição 8
>>> print(nome[5:])
Bala # da posição 5 até a última posição (8)
ca Ba # da posição 2 até a posição 6
>>> print(nome[::2])
Jc aa # somente as posições pares
>>> print(nome[1::2])
uaBl # somente as posições ímpares
# retornando um clone da String "nome"
>>> print(nome[:])
Juca Bala
Entrada de dados String
nome = input("Informe o seu nome: ")

print("\ntype(nome) =", type(nome))

print("\nSeja bem-vindo(a) %s." % nome)

Funções:
str: recebe um valor e o converte
para uma String
Acrescentando aspas em uma String
Para criar uma constante String, o programa deverá
colocar os caracteres desejados dentro de aspas:
>>> s1 = "Isto é uma constante de String"

Dependendo do programa, algumas vezes uma constante

String deverá conter um caractere aspas, por exemplo:
"Pare!", ele disse.

Como a linguagem Python usa as aspas para delimitar as

constantes String, é necessário ter uma forma de dizer
ao interpretador que deseja-se incluir aspas dentro da
string. Para fazer isso, deve-se usar a sequência de
escape (\"), como demonstrado a seguir:
>>> s2 = "\"Pare!\", ele disse."

>>> print(s1 + ". " + s2)

Isto é uma constante de String. "Pare!", ele disse.
>>>
Trabalhando com Strings (1/24)
Verificação parcial de Strings:
•<str>.starswith(<str1>, beg=0, end=len(<str>)): verifica se
a String “str1” existe no ínicio da String “str”.
•<str>.endswith(<str1>, beg=0, end=len(<str>)): verifica se
a String “str1” existe no final da String “str”.
Os parâmetros “beg” e “end” devem ser utilizados
>>> nome = "Juca Bala" para delimitar (“beg”=início e “end”=fim) a região da
verificação.
>>> nome.startswith("Juca")
True
combinando a utilização de métodos:
>>> nome.startswith("juca") >>> nome.lower().startswith("juca")
False True

>>> nome.endswith("Bala")
True
Trabalhando com Strings (2/24)
Conversão para maiúsculas e minúsculas:
•<str>.upper(): converte a String para maiúsculas.
•<str>.lower(): converte a String para minúsculas.
•<str>.title(): deixa somente as iniciais das partes da String em
maiúsculas.
•<str>.capitalize(): deixa somente o primeiro caractere da String em
maiúsculas.
•<str>.swapcase(): troca os caracteres maiúsculos pelos respectivos
minúsculos e os caracteres minúsculos pelos respectivos maiúsculos.
s = input("Informe uma String: ") Informe uma String: juca BALA

print("str.upper().....:", s.upper()) str.upper().....: JUCA BALA

print("str.lower().....:", s.lower()) str.lower().....: juca bala
print("str.title().....:", s.title()) str.title().....: Juca Bala
print("str.capitalize():", s.capitalize()) str.capitalize(): Juca bala
print("str.swapcase()..:", s.swapcase()) str.swapcase()..: JUCA bala
Trabalhando com Strings (3/24)
• len(<str>): retorna o tamanho da String “str” (quantidade
de caracteres).

Percorrendo os “n” caracteres da String:

s = input("Informe uma String: ")

print("\nCaracteres da String:")
# usando índice (s[i])
n = len(s)
s
for i in range(n):
print("{%d:%c}" % (i, s[i]), end=" ") S t r i n g
0 1 2 3 4 5
print("\n")
# os caracteres (c) como itens da String
for c in s:
Informe uma String: String
print("{%c}" % c, end=" ")
Caracteres da String:
{0:S} {1:t} {2:r} {3:i} {4:n} {5:g}

{S} {t} {r} {i} {n} {g}

Trabalhando com Strings (4/24)
Verificando se uma substring existe em uma String
usando o operador in:
>>> nomes = "Ana Chico Juca Maria Terezinha"
>>> print("Nomes: {" + nomes + "}")
Nomes: {Ana Chico Juca Maria Terezinha}
>>> "Terezinha" in nomes
True
>>> "terezinha" in nomes
False
>>> "Chico" in nomes
True
>>> "Luiz" in nomes a in b
False o operador in verifica se a String “a”
>>> "TEREZINHA" in nomes.upper() pertence (ou está contida) na String “b”
True
>>> "Luiz" not in nomes a not in b
True o operador in combinado com o operador de
>>> "Juca" not in nomes negação not verifica se a String “a” não
False pertence (ou não está contida) na String “b”
Trabalhando com Strings (5/24)
Contando letras e palavras:
•<str>.count(<str1>, beg=0, end=len(<str>)): conta quantas
vezes a String “str1” foi encontrada na String. “str”.
>>> s = "1 elefante incomoda muita gente. " + \
"2 elefantes incomodam, incomodam muito mais."
“\” possibilita a divisão da
>>> s.count("incomoda") linha de código em duas
3 Os parâmetros “beg” e “end” devem ser
>>> s.count("incomodam") utilizados para delimitar (“beg”=início e
“end”=fim) a região da contagem.
2
>>> s.count("UTFPR") # "UTFPR" não existe String "s"
0

>>> s.count("m") # existem 8 letras "m" na String "s"

8
>>> s.count("i", 33) # existem 4 letras "i" na String "s"
4 # a partir (beg) da posição 33
Trabalhando com Strings (6/24)
Pesquisa de String: (1/4)
•<str>.find(<str1>, beg=0, end=len(<str>)): pesquisa se a
String “str1” está contida na String “str” a partir do ínicio.
Retorna a posição inicial da primeira ocorrência, -1 em caso
contrário.
>>> s = "uma bola, duas bolas, três bolas"
0 4 15

>>> s.find("bola")
4 Os parâmetros “beg” e “end” devem ser
>>> s.find("bolas") utilizados para delimitar (“beg”=início e
“end”=fim) a região da pesquisa.
15
>>> s.find("BOLAS")
-1
>>> s.upper().find("BOLAS")
15
Trabalhando com Strings (7/24)
Pesquisa de String: (2/4)
•pesquisando todas as ocorrências com o método “find”.
str = input("Informe uma String: ")
str1 = input("O que procurar: ")

if (str.find(str1) == -1):
print("Não existe!!!")
else:
print("\nAchou na(s) posição(ões): ", end="")

pos = 0
while (pos != -1):
pos = str.find(str1, pos)
if (pos != -1):
print(pos, end=", ") 0
pos += 1
Informe uma String: uma bola, duas bolas, três bolas
O que procurar: bola
4 15 27
Achou na(s) posição(ões): 4, 15, 27,
Trabalhando com Strings (8/24)
Pesquisa de String: (3/4)
•<str>.rfind(<str1>, beg=0, end=len(<str>)): pesquisa se a
String “str1” está contida na String “str” a partir do final
(da direita para a esquerda). Retorna a posição inicial da
primeira ocorrência, -1 em caso contrário.

Os métodos “index” e “rindex” funcionam de forma

similar aos respectivos métodos “find” e “rfind” com a
diferença de que se a String “str1” não for encontrada,
“index” e “rindex” lançam uma exceção (try) do tipo
“ValueError”. Os parâmetros “beg” e “end” devem ser
utilizados para delimitar (“beg”=início e
“end”=fim) a região da pesquisa.
Trabalhando com Strings (9/24)
Pesquisa de String: (4/4)
•pesquisando todas as ocorrências com o método “rfind”.
str = input("Informe uma String: ")
str1 = input("O que procurar: ")

if (str.rfind(str1) == -1):
print("Não existe!!!")
else:
print("\nAchou na(s) posição(ões): ", end="")

pos = 0
while (pos != -1):
pos = str.rfind(str1, 0, pos)
if (pos != -1):
print(pos, end=", ") 0
pos -= 1
Informe uma String: uma bola, duas bolas, três bolas
O que procurar: bola
4 15 27
Achou na(s) posição(ões): 27, 15, 4,
Trabalhando com Strings (10/24)
Centralização de String:
•<str>.center(<tamanho>[, char]): centraliza a String “str”
em “tamanho” posições, preenchendo com espaços à direita e
à esquerda até que “str” fique centralizada. A String
centralizada definida como resultado pode ser preenchida
pelo caractere “char” indicado.
>>> s = "DAELN"

>>> result = "[" + s.center(20) + "]"

>>> print(result)
[ DAELN ]

>>> result = "[" + s.center(20, ".") + "]"

>>> print(result)
[.......DAELN........]
Trabalhando com Strings (11/24)
Justificando String:
•<str>.ljust(<tamanho>[, char]): justifica a String “str” à
esquerda preenchendo com espaços em branco (ou com
“char”) o final de “str” até completar o “tamanho”.
•<str>.rjust(<tamanho>, [char]): justifica a String “str” à
direita preenchendo com espaços em branco (ou com
“char”) o início de “str” até completar o “tamanho”.
>>> s = "UTFPR" >>> s = "UTFPR"

>>> print("["+s.ljust(15)+"]") >>> print("["+s.ljust(15,".")+"]")

[UTFPR ] [UTFPR..........]

>>> print("["+s.rjust(15)+"]") >>> print("["+s.rjust(15,"+")+"]")

[ UTFPR] [++++++++++UTFPR]
Trabalhando com Strings (12/24)
Zeros à esquerda:
•<str>.zfill(<tamanho>): preenche a String “str” com 0s à
esquerda até completar o “tamanho”.
>>> s = "1"
>>> binario = s.zfill(8)

>>> print(binario, "=", int(binario, 2), "(decimal)")

00000001 = 1 (decimal)

>>> s = "1101101"
>>> binario = s.zfill(8)

>>> print(binario, "=", int(binario, 2), "(decimal)")

01101101 = 109 (decimal)

Converte uma String que corresponde a

um valor binário para a base decimal.
Trabalhando com Strings (13/24)
Remoção de espaços em branco:
•<str>.strip([chars]): remove os espaços em branco (ou os
“chars”) do início e do final da String “str”.
•<str>.lstrip([chars]): remove os espaços em branco (ou os
“chars”) do início da String “str”.
•<str>.rstrip([chars]): remove os espaços em branco (ou os
“chars”) do final da String “str”.
>>> s = " UTFPR " >>> s = "...UTFPR..."
>>> print("["+s.strip()+"]") >>> print("["+s.strip(".")+"]")
[UTFPR] [UTFPR]
>>> print("["+s.lstrip()+"]") >>> print("["+s.lstrip(".")+"]")
[UTFPR ] [UTFPR...]
>>> print("["+s.rstrip()+"]") >>> print("["+s.rstrip(".")+"]")
[ UTFPR] [...UTFPR]
Trabalhando com Strings (14/24)
Separação de Strings: (1/2)
•<str>.split(str1=" ", num=str.count(str1)): retorna uma lista
com as partes separadas da String “str” usando “str1” como
separador. O parâmetro “num” delimita o número de partes.
>>> s = "3 5 7 9"
>>> x = s.split()
>>> print(x)
['3', '5', '7', '9']
>>> print("{%s} {%s} {%s} {%s}" % (x[0], x[1], x[2], x[3]))
{3} {5} {7} {9}

>>> s = "uva;banana;laranja"
>>> frutas = s.split(";")
>>> print(frutas)
['uva', 'banana', 'laranja']
>>> print("%s - %s - %s" % (frutas[0], frutas[1], frutas[2]))
uva - banana – laranja
Trabalhando com Strings (15/24)
Separação de Strings: (2/2)
•<str>.splitlines(num=str.count('\n')): retorna uma lista com as
partes separadas da String “str” usando a quebra de linha (\n)
como separador. O parâmetro “num” delimita o número de
partes.
s = "1a. linha\n2a. linha\n3a. linha\n4a. linha"

linhas = s.splitlines()

print("Linhas:")
for item in linhas:
print(item) Linhas:
1a. linha
2a. linha
3a. linha
4a. linha
Trabalhando com Strings (16/24)
Substituição de String:
•<str>.replace(<old>, <new>[, max]): substitui na String
“str” o valor “old” pelo valor “new”. O parâmetro “max”
limita o número máximo de substituições.
>>> s1 = "uma bola, duas bolas, três bolas"
>>> s2 = s1.replace("bola", "roda")
>>> print(s1); print(s2)
uma bola, duas bolas, três bolas
uma roda, duas rodas, três rodas

>>> s1 = "Linguagem de Programação Python"

>>> s2 = s1.replace("a", "@")
>>> print(s1); print(s2)
Linguagem de Programação Python
Lingu@gem de Progr@m@ção Python
Trabalhando com Strings (17/24)
Alteração de uma String: (1/2)
no Python as Strings são imutáveis:
>>> s = "UTFPR"
>>> print(s[0])
U
>>> s[0] = 'X'
Traceback (most recent call last):
File "<pyshell#2>", line 1, in <module>
s[0] = 'X'
TypeError: 'str' object does not support item assignment

Solução: para processar caractere a caractere em uma

String, alterando o seu valor, é necessário transformá-la em
uma lista: função list(<str>).
Trabalhando com Strings (18/24)
Alteração de uma String: (2/2)
•list(<str>): retorna uma lista com os caracteres da String
“str”.
•str.join(<lista>): retorna uma String com os itens da
“lista”.
s = input("Informe uma String:\n")
['L', 'i', 'n', 'g', 'u', 'a', 'g',
'e', 'm', ' ', 'd', 'e', ' ', 'P', 'r',
l = list(s)
'o', 'g', 'r', 'a', 'm', 'a', 'ç', 'ã',
'o', ' ', 'P', 'y', 't', 'h', 'o', 'n']
n = len(l)
for i in range(n): Informe uma String:
if ((l[i] == 'A') or (l[i] == 'a')): Linguagem de Programação Python
l[i] = '@'
Trocando 'A' ou 'a' por '@':
s = "".join(l) Lingu@gem de Progr@m@ção Python

print("\nTrocando 'A' ou 'a' por '@':")

print(s)
Trabalhando com Strings (19/24)
Menor e Maior Caractere de uma String:
•min(<str>): retorna o menor caractere da String “str”.
•max(<str>): retorna o maior caractere da String “str”.
>>> s = "ABCabc012"
>>> print(ord("A"), "A"); print(ord("a"), "a"); print(ord("0"), "0")
65 A
97 a
48 0
>>> print(ord(min(s)), min(s))
48 0

>>> print(ord("C"), "C"); print(ord("c"), "c"); print(ord("2"), "2")

67 C
99 c
50 2 Para definir o menor ou o maior caractere deve-se
levar em consideração a posição, ou ordem: ord(),
>>> print(ord(max(s)), max(s))
do caractere na tabela de códigos ASCII.
99 c
Trabalhando com Strings (20/24)
Substituindo Caracteres em uma String:
•str.maketrans(<intab>, <outtab>): define uma tabela de
substituição, na String “str”, dos caracteres da String “intab”
pelos respectivos caracteres da String “outtab”.
•str.translate(<tabelaTroca>): realiza as substituição dos
caracteres da String “str” de acordo com a tabela definida
através do método “maketrans”.
>>> s = "Terezinha Lurdes Bertol"
>>> intab = "aeiou"
>>> outtab = "12345"
>>> tabelaTroca = s.maketrans(intab, outtab)
>>> result = s.translate(tabelaTroca)
>>> print(s); print(result)
Terezinha Lurdes Bertol
T2r2z3nh1 L5rd2s B2rt4l
Trabalhando com Strings (21/24)
Validação do conteúdo de uma String: (1/4)
•<str>.isalnum(): retorna True se todos os caracteres da
String “str” forem caracteres alfabéticos ou numéricos,
False em caso contrário.
>>> s1 = "ABC12345"; s2 = "ABC = 12345"
>>> s1.isalnum(), s2.isalnum()
(True, False)

•<str>.isalpha(): retorna True se todos os caracteres da

String “str” forem caracteres alfabéticos, False em caso
contrário.
>>> s1 = "ABCDEFGH"; s2 = "ABCDEF123"
>>> s1.isalpha(), s2.isalpha()
(True, False)
Trabalhando com Strings (22/24)
Validação do conteúdo de uma String: (2/4)
•<str>.isdigit(): retorna True se todos os caracteres da
String “str” forem caracteres numéricos, False em caso
contrário.
>>> s1 = "12345"; s2 = "12345.67"
>>> s1.isdigit(), s2.isdigit()
(True, False)

•<str>.isspace(): retorna True se todos os caracteres da

String “str” forem caracteres de espaço, False em caso
contrário.
>>> s1 = " "; s2 = " x "
>>> s1.isspace(), s2.isspace()
(True, False)
Trabalhando com Strings (23/24)
Validação do conteúdo de uma String: (3/4)
•<str>.islower(): retorna True se existem caracteres
alfabéticos na String “str” e se todos eles forem minúsculos,
False em caso contrário.
>>> s1 = "abcdef"; s2 = "abcdEF"
>>> s1.islower(), s2.islower()
(True, False)

•<str>.isupper(): retorna True se existem caracteres

alfabéticos na String “str” e se todos eles forem caracteres
maiúsculos, False em caso contrário.
>>> s1 = "ABCDEF"; s2 = "ABCDef"
>>> s1.isupper(), s2.isupper()
(True, False)
Trabalhando com Strings (24/24)
Validação do conteúdo de uma String: (4/4)
•<str>.istitle(): retorna True se todas as iniciais alfabéticas
das partes da String “str” forem caracteres alfabéticos
maiúsculos, False em caso contrário.

>>> s = "Juca Bala"

>>> s.istitle()
True

>>> s = "Juca bala"

>>> s.istitle()
False
Processando os caracteres (1/4)
s = input("Informe uma String: ")
n = len(s)
for i in range(n):
… s[i], indica o i-ésimo caractere da cadeia "s"

ctmaius = ctminus = ctalfa = 0

1) verificando se é um caractere alfabético maiúsculo
if ((s[i] >= 'A') and (s[i] <= 'Z')):
ctmaius = ctmaius + 1

2) verificando se é um caractere alfabético minúsculo

if ((s[i] >= 'a') and (s[i] <= 'z')):
ctminus = ctminus + 1

3) verificando se é um caractere alfabético

if (((s[i] >= 'A') and (s[i] <= 'Z')) or \
((s[i] >= 'a') and (s[i] <= 'z'))):
ctalfa = ctalfa + 1
Processando os caracteres (2/4)
ctnum = cta = ctbit = ctespaco = 0

4) verificando se é um caractere numérico

if ((s[i] >= '0') and (s[i] <= '9')):
ctnum = ctnum + 1

5) verificando se é a vogal 'a'

if ((s[i] == 'A') or (s[i] == 'a')):
cta = cta + 1

6) verificando se é um bit ('0' ou '1')

if ((s[i] == '0') or (s[i] == '1')):
ctbit = ctbit + 1

7) verificando se é o espaço em branco

if (s[i] == ' '):
ctespaco = ctespaco + 1
Processando os caracteres (3/4)
cta = cte = cti = cto = ctu = 0

8) verificando as vogais separadamente

if ((s[i] == 'A') or (s[i] == 'a')):
cta = cta + 1
elif ((s[i] == 'E') or (s[i] == 'e')):
cte = cte + 1
elif ((s[i] == 'I') or (s[i] == 'i')):
cti = cti + 1
elif ((s[i] == 'O') or (s[i] == 'o')):
cto = cto + 1
elif ((s[i] == 'U') or (s[i] == 'u')):
ctu = ctu + 1
Processando os caracteres (4/4)
ctcons = 0

9) verificando se é uma consoante: todo caractere

alfabético que não é vogal
if (((s[i] >= 'A') and (s[i] <= 'Z')) or \
((s[i] >= 'a') and (s[i] <= 'z'))):

if ((s[i] != 'A') and (s[i] != 'a') and \

(s[i] != 'E') and (s[i] != 'e') and \
(s[i] != 'I') and (s[i] != 'i') and \
(s[i] != 'O') and (s[i] != 'o') and \
(s[i] != 'U') and (s[i] != 'u')):
ctcons = ctcons + 1