Pular para o conteúdo principal

04 Aula: estruturas de dados (2) e strings

Comentários

Código

Estrutura de dados (2) e strings

Na aula passada aprendemos a mexer com listas, uma das estruturas de dados mais importantes e flexíveis que existe.

Nesta aula veremos outras estruturas de dados importantes como os dicionários, os conjuntos e as tuplas.

Antes disso vamos rever o que aprendemos com as listas.

Também vamos ver mais funcionalidades de strings.

Revisão de listas

In [1]:
L = [1,2,3,4] # Como criar uma lista
L
Out[1]:
[1, 2, 3, 4]
In [2]:
len(L) # Comprimento de uma lista
Out[2]:
4
In [3]:
L[0] # Acessar os elementos da lista
Out[3]:
1
In [4]:
L[1:3] # Fatiamento das listas
Out[4]:
[2, 3]
In [5]:
L.append(5) # Adicionar um elemento ao final da lista
L
Out[5]:
[1, 2, 3, 4, 5]
In [6]:
M = [1,2,3,] + [4,5,6,7,8] # Concatenar listas
In [7]:
L.extend([6,7,8]) # Extender lista
L
Out[7]:
[1, 2, 3, 4, 5, 6, 7, 8]
In [8]:
del L[5:] # Remover elementos da lista
L
Out[8]:
[1, 2, 3, 4, 5]
In [9]:
L.pop(-1)  # Retirar o último elemento da lista e retornar seu valor
Out[9]:
5
In [10]:
L
Out[10]:
[1, 2, 3, 4]
In [11]:
L.pop(0) # Retirar o primeiro elemento da lista e retornar seu valor
Out[11]:
1
In [12]:
L
Out[12]:
[2, 3, 4]
In [13]:
# Algo que não vimos!
L*3
Out[13]:
[2, 3, 4, 2, 3, 4, 2, 3, 4]

Vimos que existem vários métodos

Estes métodos podem ser bastante úteis

In [14]:
L = [32,3456,124,687,523,456,23,634,576]
M = L[:]  # Cuidado ao copiar a lista!!!
In [15]:
L.index(124) # Buscar índice de elemento da lista
Out[15]:
2
In [16]:
[2,34,3,2,3,6,6,6,6,32,4,4,3,2].count(6)
Out[16]:
4
In [17]:
L.sort() # Reordenar
In [18]:
L
Out[18]:
[23, 32, 124, 456, 523, 576, 634, 687, 3456]

Vimos o algorítimo de Bubble Sort para reordenar listas

Dicionários

Estrutura de dados semelhante à lista mas com acesso diferente.

Os dicionários em Python são compostos por

  • Chaves
  • Valores

O dicionário relaciona uma chava a um valor. A cada chave, existe um valor associado.

De certo modo a lista pode ser vista como um dicionário: as chaves são números inteiros ordenados.

Para se criar um dicionário, utilizam-se chaves ({})

Imagine como exemplo, uma lista de preços de um supermercado:

Produto Preço
Alface R\$ 0,45
Batata R\$ 1,20
Tomate R\$ 2,30
Feijão R\$ 1,50
In [19]:
tabela = {"Alface": 0.45, 
         "Batata": 1.20, 
         "Tomate": 2.30, 
         "Feijão": 1.50}
In [20]:
tabela
Out[20]:
{'Alface': 0.45, 'Batata': 1.2, 'Tomate': 2.3, 'Feijão': 1.5}

Em um dicionário, para se acessar um valor, usa-se a chave:

In [21]:
tabela["Alface"]
Out[21]:
0.45

Também podemos atribuir um valor à chave:

In [22]:
tabela["Alface"] = 0.55  # Aumentamos o preço
In [23]:
tabela
Out[23]:
{'Alface': 0.55, 'Batata': 1.2, 'Tomate': 2.3, 'Feijão': 1.5}

Se atribuirmos um valor a uma chave que não existe, essa nova chave com este valor será adicionada ao dicionário:

In [24]:
tabela["Cebola"] = 1.35
tabela
Out[24]:
{'Alface': 0.55, 'Batata': 1.2, 'Tomate': 2.3, 'Feijão': 1.5, 'Cebola': 1.35}

Se a chave não existir, ocorrerá um erro:

In [25]:
tabela["Picanha"]

---------------------------------------------------------------------------
KeyError                                  Traceback (most recent call last)
/tmp/ipykernel_19331/2276766913.py in <module>
----> 1 tabela["Picanha"]

KeyError: 'Picanha'

Para se verificar se um chave faz parte do dicionário, use o operador in:

In [26]:
"Feijão" in tabela
Out[26]:
True
In [27]:
"Manga" in tabela
Out[27]:
False

O método .keys() retorna uma lista (algo parecido) com as chaves:

In [28]:
tabela.keys()
Out[28]:
dict_keys(['Alface', 'Batata', 'Tomate', 'Feijão', 'Cebola'])
In [29]:
# Programa para obter o preço da tabela:
tabela = {"Alface": 0.45, 
         "Batata": 1.20, 
         "Tomate": 2.30, 
         "Feijão": 1.50}

while True:
    produto = input("Entre com o nome do produto, fim para terminar: ")
    if produto == 'fim':
        break
    if produto in tabela:
        print(f"Preço {tabela[produto]:5.2f}")
    else:
        print("Produto não encontrado!")
        

Entre com o nome do produto, fim para terminar: Alface
Preço  0.45
Entre com o nome do produto, fim para terminar: Feijão
Preço  1.50
Entre com o nome do produto, fim para terminar: fim

Assim como nas listas, podemos apagar uma chave com a instrução del:

In [30]:
tabela = {"Alface": 0.45, 
         "Batata": 1.20, 
         "Tomate": 2.30, 
         "Feijão": 1.50}

del tabela["Tomate"]
tabela
Out[30]:
{'Alface': 0.45, 'Batata': 1.2, 'Feijão': 1.5}

Quando usar listas ou dicionários?

Quando você quer acessar os dados pela chave. Observe que nas versões mais antigas de Python (antes da versão 3.7) a ordem de inserção não era preservada!

O acesso de elementos de listas pode ser mais rápido.

Cuidado ao usar os f-strings com dicionários:

In [31]:
d = {"banana": 2.00, "maçã": 5.00}
f"Banana: R${d['banana']:5.2f} Maçã: R${d['maçã']:5.2f}"
Out[31]:
'Banana: R$ 2.00 Maçã: R$ 5.00'

O que pode ser usado como chave em um dicionário?

  • Strings
  • Números
  • Tuplas (veremos mais tarde)

Os elementos de um dicionário podem ser qualquer coisa...

In [32]:
estoque = {"tomate": [1000, 2.30],
           "alface": [500, 0.45],
           "batata": [2001, 1.20], 
           "feijão": [100, 1.5]}
In [33]:
# Programa para atualizar estoque após venda
venda = [["tomate", 5], ["batata",10], ["alface",5]]
total = 0
print("Vendas:\n")
for operação in venda:
    produto, quantidade = operação
    preço = estoque[produto][1]
    custo = preço * quantidade
    print(f"{produto:12s}: {quantidade:3d} x {preço:6.2f} = {custo:6.2f}")
    estoque[produto][0] -= quantidade
    total += custo
print(f" Custo total: {total:21.2f}\n")
print("Estoque:\n")
for chave, dados in estoque.items():
    print("Descrição: ", chave)
    print("Quantidade: ", dados[0])
    print(f"Preço: {dados[1]:6.2f}\n")

Vendas:

tomate      :   5 x   2.30 =  11.50
batata      :  10 x   1.20 =  12.00
alface      :   5 x   0.45 =   2.25
 Custo total:                 25.75

Estoque:

Descrição:  tomate
Quantidade:  995
Preço:   2.30

Descrição:  alface
Quantidade:  495
Preço:   0.45

Descrição:  batata
Quantidade:  1991
Preço:   1.20

Descrição:  feijão
Quantidade:  100
Preço:   1.50

Exercício 1

Altere o programa anterior de modo que o produto e a quantidade vendida seja solicitada ao usuário. Verifique se o produto digitado existe e só então efetue a baixa no estoque. Também verifique se o estoque é o suficiente para atender ao pedido.

Exercício 2

Escreva um programa que que gere um dicionário a partir de uma string onde a chave seja um caracter e o valor o número de vezes que este caracter aparece no dicionário

o rolo -> {'o': 3, ' ': 1, 'l': 1}

Dicionário com valores padrão

Algo comum é que ao se recuperar o valor de uma chave, se essa chave não existir, utilizar um valor padrão

In [34]:
d = {}
d["A"] = 1
d["B"] = 2
d
Out[34]:
{'A': 1, 'B': 2}
In [35]:
d["C"]

---------------------------------------------------------------------------
KeyError                                  Traceback (most recent call last)
/tmp/ipykernel_19331/852664300.py in <module>
----> 1 d["C"]

KeyError: 'C'
In [36]:
x = d.get("C")
In [37]:
x is None
Out[37]:
True
In [38]:
x = d.get("C", 999)
x
Out[38]:
999

Iterando um dicionário com for

Também dá usar for em um dicionário.

In [39]:
estoque = {"tomate": [1000, 2.30],
           "alface": [500, 0.45],
           "batata": [2001, 1.20], 
           "feijão": [100, 1.5]}
In [40]:
for x in estoque:
    print(x)

tomate
alface
batata
feijão

E se você precisa da chave e do valor? Use o método .items()

In [41]:
for c,v in estoque.items():
    print("------------")
    print(f"Chave: {c}")
    print(f"Valor: {v}")
    

------------
Chave: tomate
Valor: [1000, 2.3]
------------
Chave: alface
Valor: [500, 0.45]
------------
Chave: batata
Valor: [2001, 1.2]
------------
Chave: feijão
Valor: [100, 1.5]
In [42]:
estoque.items()
Out[42]:
dict_items([('tomate', [1000, 2.3]), ('alface', [500, 0.45]), ('batata', [2001, 1.2]), ('feijão', [100, 1.5])])

Tuplas

Muito parecida com a lista mas com uma diferença: são imutáveis!

Tem alguma semelhança com as strings. Strings se parecem com listas que não podem ser modificadas. Mas as strings são otimizadas para caracteres.

Apesar de imutáveis, os elementos da tupla podem ter tipos distintos.

Tuplas são parecidas com listas!

In [43]:
tupla = ("a", "b", "c")
In [44]:
tupla
Out[44]:
('a', 'b', 'c')
In [45]:
tupla[0]
Out[45]:
'a'
In [46]:
tupla[1]
Out[46]:
'b'
In [47]:
[1,2,3]*2 # repetição
Out[47]:
[1, 2, 3, 1, 2, 3]
In [48]:
tupla[1:]
Out[48]:
('b', 'c')
In [49]:
len(tupla)
Out[49]:
3
In [50]:
for e in tupla:
    print(e)
    

a
b
c
In [51]:
# Lembre-se as tuplas são imutáveis!
tupla[1] = 'd'

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
/tmp/ipykernel_19331/2537307119.py in <module>
      1 # Lembre-se as tuplas são imutáveis!
----> 2 tupla[1] = 'd'

TypeError: 'tuple' object does not support item assignment

Tuplas como múltiplos valores, empacotamento e desempacotamento

In [52]:
tupla = 100,200,300
tupla
Out[52]:
(100, 200, 300)
In [53]:
a, b, c = tupla
In [54]:
print(f"a = {a}, b = {b}, c = {c}")

a = 100, b = 200, c = 300
In [55]:
a, b = 10, 20
a,b
Out[55]:
(10, 20)
In [56]:
# Operação realizada de maneira 'paralela'
a, b = b, a
a,b
Out[56]:
(20, 10)

Se lembram do bubble sort?

In [57]:
L = [9, 2, 4, 3, 8, 6]
N = len(L)
for i in range(N):
    trocou = False
    for k in range(N-i-1):
        if L[k] > L[k+1]: # Inverter a posição
            trocou = True
            # Como era antes
            # tmp = L[k]
            # L[k] = L[k+1]
            #L[k+1] = tmp
            L[k], L[k+1] = L[k+1], L[k] # Olha só que simples!
    if not trocou:
        break

L
Out[57]:
[2, 3, 4, 6, 8, 9]

Tuplas com um elemento

In [58]:
t1 = (1)
t1
Out[58]:
1
In [59]:
t2 = (1,)
t2
Out[59]:
(1,)
In [60]:
# Tupla vazia
t3 = ()
t3
Out[60]:
()

Tuplas a partir de listas (e vice e versa):

In [61]:
L = [1,2,3]
T = tuple(L)
T
Out[61]:
(1, 2, 3)
In [62]:
T = (1,2,3)
L = list(T)
L
Out[62]:
[1, 2, 3]

Concatenação

In [63]:
(1,2,3) + (4,5,6)
Out[63]:
(1, 2, 3, 4, 5, 6)

A tupla é imutável, não seus elementos (pode ou não ser!)

In [64]:
T = (1,[2,3,4])
T
Out[64]:
(1, [2, 3, 4])
In [65]:
T[1].append(5)
In [66]:
T
Out[66]:
(1, [2, 3, 4, 5])

Exercício 3

Explore os métodos disponíveis aos dicionários. Brinque com eles

Mais empacotamento e desempacotamento (listas também podem)

In [67]:
tupla = 1,2
a,b = tupla
In [68]:
a,b = 1,2
In [69]:
c,d = [3,4]
print(f"c = {c}, d = {d}")

c = 3, d = 4
In [70]:
*a, b = [1,2,3,4,5]
b
Out[70]:
5
In [71]:
a
Out[71]:
[1, 2, 3, 4]
In [72]:
*a,b = (1,2,3,4,5)
In [73]:
a
Out[73]:
[1, 2, 3, 4]
In [74]:
b
Out[74]:
5
In [75]:
a,*b = [1,2,3,4,5]
a
Out[75]:
1
In [76]:
b
Out[76]:
[2, 3, 4, 5]
In [77]:
a,*b,c = [1,2,3,4,5]
a
Out[77]:
1
In [78]:
b
Out[78]:
[2, 3, 4]
In [79]:
c
Out[79]:
5
In [80]:
*a,b,c = [1,2,3,4,5]
a
Out[80]:
[1, 2, 3]
In [81]:
b
Out[81]:
4
In [82]:
c
Out[82]:
5
In [83]:
a,b,*c = [1,2,3,4,5]
a
Out[83]:
1
In [84]:
b
Out[84]:
2
In [85]:
c
Out[85]:
[3, 4, 5]

Conjuntos (set)

Os conjuntos em Python são uma estrutura de dados que funcionam como conjuntos que aprendemos na escola.

Um conjunto é uma coleção de elementos que não são repetidos.

Ah, podemos fazer as operações união e intersecção!

In [86]:
a = {1,2,3} # Notação para conjuntos
a
Out[86]:
{1, 2, 3}
In [87]:
a.add(4)
a.add(5)
a.add(6)
a
Out[87]:
{1, 2, 3, 4, 5, 6}
In [88]:
a.add(1)
a
Out[88]:
{1, 2, 3, 4, 5, 6}
In [89]:
a.add(-1)
a
Out[89]:
{-1, 1, 2, 3, 4, 5, 6}
In [90]:
len(a)
Out[90]:
7

Ver se um elemento pertence a um conjunto:

In [91]:
 2 in a
Out[91]:
True
In [92]:
123 in a
Out[92]:
False

Criando conjuntos a partir de listas

In [93]:
b = set([1,2,3,4,5])
b
Out[93]:
{1, 2, 3, 4, 5}
In [94]:
b = set([1,2,3,4,5,1,2,3,4,5])
b
Out[94]:
{1, 2, 3, 4, 5}

Operações com conjuntos

Diferença entre conjuntos:

a - b

O resultado é um conjunto com os elementos de a que não estão em b

In [95]:
a = {0, 1, 2, 3, -1}
b = {2, 3}
a-b
Out[95]:
{-1, 0, 1}
In [96]:
a = {0, 1, 2, 3, -1, 4, 5}
b = {2, 3}
a-b
Out[96]:
{-1, 0, 1, 4, 5}
In [97]:
a = {0, 1, 2, 3, -1}
b = {2, 3, 4}
a-b
Out[97]:
{-1, 0, 1}

União entre conjuntos:

a | b
In [98]:
a = {0,1,2,3,-1}
b = {2,3}
a | b
Out[98]:
{-1, 0, 1, 2, 3}
In [99]:
c = {4,5,6}
a | c
Out[99]:
{-1, 0, 1, 2, 3, 4, 5, 6}

Interseção de conjuntos

In [100]:
a & b
Out[100]:
{2, 3}
In [101]:
a & c
Out[101]:
set()

Exercício 4

Veja os métodos disponíveis aos conjuntos. Brinque com eles

Exercício 5

Escreva um programa que compare duas listas. Utilizando operações com conjuntos, imprima:

  • Os valores comuns às duas listas
  • Os valores que só existem na primeira
  • Os valores que existem apenas na segunda
  • Uma lista com os elementos não repetidos das duas listas
  • A primeira lista sem os elementos repetidos na segunda

Qual estrutura de dados utilizar?

Listas Tuplas Dicionários Conjuntos
Ordem dos elementos Fixa Fixa Fixa a partir da versão 3.7 Indeterminada
Tamanho Variável Fixo Variável Variável
Elementos repetidos Sim Sim Valores mas não chaves Não
Pesquisa Sequencial Sequencial Direto pela chave Direta pelo valor
Alterações Sim Não Sim Sim
Uso primário Sequências Sequências constantes Dados indexados por chave Verificação de unicidade

Trabalhando com strings

Temos usado strings desde a primeira aula. Strings são úteis e extremamente importantes. Vimos que existem algumas semelhanças entre strings e listas e entre strings e tuplas: strings são sequências imutáveis de caracteres.

In [102]:
s = "Alô mundo"
s[0]
Out[102]:
'A'
In [103]:
s[0] = 'X'

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
/tmp/ipykernel_19331/2311957138.py in <module>
----> 1 s[0] = 'X'

TypeError: 'str' object does not support item assignment
In [104]:
L = list(s)
L
Out[104]:
['A', 'l', 'ô', ' ', 'm', 'u', 'n', 'd', 'o']

Strings também têm métodos!

In [105]:
s1 = "".join(L)
s1
Out[105]:
'Alô mundo'
In [106]:
L = ['a','b','c']
print("".join(L))
print(" ".join(L))
print(".".join(L))
print("_|_".join(L))

abc
a b c
a.b.c
a_|_b_|_c
In [ ]:
s.

Verificação parcial de strings

In [108]:
nome = "Instituto de Pesquisas Tecnológicas"
nome.startswith("Inst")
Out[108]:
True
In [109]:
nome.startswith("inst")
Out[109]:
False

Maíusculas e minúsculas

In [110]:
nome.upper()
Out[110]:
'INSTITUTO DE PESQUISAS TECNOLÓGICAS'
In [111]:
nome.lower()
Out[111]:
'instituto de pesquisas tecnológicas'
In [112]:
nome.lower().startswith("inst")
Out[112]:
True
In [113]:
nome.upper().startswith("INST")
Out[113]:
True
In [114]:
"uma frase simples com letras minúsculas".capitalize()
Out[114]:
'Uma frase simples com letras minúsculas'

Pesquisando em strings

In [115]:
s = "o rato roeu a roupa do rei de roma"
In [116]:
"rato" in s
Out[116]:
True
In [117]:
"Rato" in s
Out[117]:
False
In [118]:
"u a r" in s
Out[118]:
True
In [119]:
"santos" not in s
Out[119]:
True
In [120]:
'roupa' not in s
Out[120]:
False

Cuidado com acentos!!!

In [121]:
s = "além da cúpula do trovão"
In [122]:
"além" in s
Out[122]:
True
In [123]:
"alem" in s
Out[123]:
False

Algumas vezes queremos saber onde se encontra uma substring

In [124]:
s = "o rato roeu a roupa do rei de roma"
In [125]:
i = s.find("roeu")
i
Out[125]:
7
In [126]:
s[i:i+4]
Out[126]:
'roeu'
In [127]:
s.find("gato")
Out[127]:
-1

Buscando pelo fim

In [128]:
s = "o rato roeu a roupa do rato de roma"
i = s.find("rato")
i
Out[128]:
2
In [129]:
s[i:i+4]
Out[129]:
'rato'
In [130]:
i = s.rfind("rato")
i
Out[130]:
23
In [131]:
s[i:i+4]
Out[131]:
'rato'

Dá para falar de onde queremos começar a procurar!

In [132]:
s.find("rato", 3)
Out[132]:
23
In [133]:
# Programa que pesquisa *todas* as ocorrênicas
s = "um tigre, dois tigres, três tigres"
ss = "tigre"
p = 0
while p > -1:
    p = s.find(ss, p)
    if p >= 0:
        print(f"Posição: {p}")
        p += 1

Posição: 3
Posição: 15
Posição: 28

Exercício 6

Teste a diferença entre os métodos .find e .rfind com .index e .rindex

Exercício 7

Escreva um programa que leia duas strings. Verifique se a segunda ocorre dentro da primeira e imprima sua posição de início

Exercício 8

Escreva um programa que leia duas strings e gere uma terceira string com todos os caracteres que aparecem nas duas strings. A ordem não interessa.

Exercício 9

Escreva um programa que leia uma string e imprima quantas vezes cada caracter aparece nessa string

Justificação de strings

In [134]:
s = 'bola'
s.center(20)
Out[134]:
'        bola        '
In [135]:
'X' + s.center(10) + 'X'
Out[135]:
'X   bola   X'
In [136]:
'X' + s.center(10, '.') + 'X'
Out[136]:
'X...bola...X'
In [137]:
s.ljust(10)
Out[137]:
'bola      '
In [138]:
s.ljust(10,'.')
Out[138]:
'bola......'
In [139]:
s.rjust(10)
Out[139]:
'      bola'
In [140]:
s.rjust(10,'.')
Out[140]:
'......bola'

Remoção de espaços em branco

In [141]:
s = "   IPT    "
s.strip()
Out[141]:
'IPT'
In [142]:
s.rstrip()
Out[142]:
'   IPT'
In [143]:
s.lstrip()
Out[143]:
'IPT    '
In [144]:
s.lstrip('.')
Out[144]:
'   IPT    '
In [145]:
s = '....  IPT   ...  .'
s.strip('.')
Out[145]:
'  IPT   ...  '
In [146]:
s.strip('. ')
Out[146]:
'IPT'
In [147]:
s.rstrip(' .')
Out[147]:
'....  IPT'
In [148]:
s.lstrip(' .')
Out[148]:
'IPT   ...  .'

Quebrando strings

In [149]:
s = "1,2,3,4,5,6"
s.split(",")
Out[149]:
['1', '2', '3', '4', '5', '6']
In [150]:
"1 2 3 4 5 6".split(" ")
Out[150]:
['1', '2', '3', '4', '5', '6']
In [151]:
"1 e 2 e 3 e 4 e 5 e 6".split(" e ")
Out[151]:
['1', '2', '3', '4', '5', '6']

Substituindo strings

In [152]:
s = "um tigre, dois tigres, três tigres"
s.replace("tigre", "gato")
Out[152]:
'um gato, dois gatos, três gatos'
In [153]:
s.replace("tigre", "gato", 1)
Out[153]:
'um gato, dois tigres, três tigres'
In [154]:
s.replace("tigre", "gato", 2)
Out[154]:
'um gato, dois gatos, três tigres'
In [155]:
s.replace("tigre", "")
Out[155]:
'um , dois s, três s'
In [156]:
s.replace("", "-")
Out[156]:
'-u-m- -t-i-g-r-e-,- -d-o-i-s- -t-i-g-r-e-s-,- -t-r-ê-s- -t-i-g-r-e-s-'
In [ ]:

Validação por tipo de conteúdo

In [157]:
s = "125"
p = "uma pequena frase"
In [158]:
s.isalnum()
Out[158]:
True
In [159]:
p.isalnum()
Out[159]:
False
In [160]:
"abc123".isalnum()
Out[160]:
True
In [161]:
"125".isalpha()
Out[161]:
False
In [162]:
"uma frase pequena".isalpha()
Out[162]:
False
In [163]:
"palavra".isalpha()
Out[163]:
True
In [164]:
"123".isdigit()
Out[164]:
True
In [165]:
"3.14".isdigit()
Out[165]:
False
In [166]:
"-123".isdigit()
Out[166]:
False
In [167]:
"123".isnumeric()
Out[167]:
True
In [168]:
"3.14".isnumeric()
Out[168]:
False
In [169]:
# .isdigit() -> caracteres numéricos em Unicode
In [170]:
s = "\u2153"
s
Out[170]:
'⅓'
In [171]:
s.isnumeric()
Out[171]:
True
In [172]:
s.isdigit()
Out[172]:
False

Como reconhecer se o número é ponto flutuante? Isso é mais chato do que parece. Mas temos aqui uma solução. Aqui introduzimos uma nova funcionalidade: exceções:

In [173]:
s = "123e23"

try:
    float(s)
    isfloat = True
except:
    isfloat = False
    
isfloat
Out[173]:
True
In [174]:
"  ".isspace()
Out[174]:
True
In [175]:
"\n\r\t ".isspace()
Out[175]:
True
In [176]:
"\n\t\r".isprintable()
Out[176]:
False
In [177]:
"um testo simples".isprintable()
Out[177]:
True
In [178]:
"ABC".isupper()
Out[178]:
True
In [179]:
"ABC".islower()
Out[179]:
False
In [180]:
"abc".isupper()
Out[180]:
False
In [181]:
"abc".islower()
Out[181]:
True
In [182]:
"Abc".istitle()
Out[182]:
True
In [183]:
"ABC".istitle()
Out[183]:
False
In [184]:
"abc".istitle()
Out[184]:
False

Formatação de strings

Já temos usado bastante isso.

In [185]:
"{0} {1}".format("Oi", "mundo")
Out[185]:
'Oi mundo'
In [186]:
"{} {} {}".format(1,2,3)
Out[186]:
'1 2 3'
In [187]:
"{2} {1} {0}".format(1,2,3)
Out[187]:
'3 2 1'
In [188]:
"X{0:<10}X".format("IPT")
Out[188]:
'XIPT       X'
In [189]:
"X{0:>10}X".format("IPT")
Out[189]:
'X       IPTX'
In [190]:
"X{0:^10}X".format("IPT")
Out[190]:
'X   IPT    X'
In [191]:
"X{0:.<10}X".format("IPT")
Out[191]:
'XIPT.......X'
In [192]:
"X{0:.^10}X".format("IPT")
Out[192]:
'X...IPT....X'

Os parâmetros de format podem ser uma lista:

In [193]:
"{0[0]} {0[1]} {1[0]} {1[1]}".format([1,2], [3,4])
Out[193]:
'1 2 3 4'

Até mesmo um dicionário:

In [194]:
"{0[nome]} {0[telefone]} {1[0]} {1[1]}".format({"telefone": "3767-0000", "nome": "João"}, [1,2])
Out[194]:
'João 3767-0000 1 2'

Tem como formatar números. Na verdade esta formatação é quase uma minilinguagem. Para maiores informações, veja a documentação oficial do Python:

Jogo da forca

In [195]:
palavra = input("Digite a plavra secreta: ").strip().lower()
for x in range(100): 
    print()

digitadas = []
acertos = []
erros = 0

while True:
    senha = ""
    for letra in palavra:
        senha += letra if letra in acertos else "."
    print(senha)
    if senha == palavra:
        print("Você acertou!")
        break
    tentativa = input("\nDigite uma letra: ").strip().lower()
    if tentativa in digitadas:
        print("Você já tentou esta letra!")
        continue
    else:
        digitadas += tentativa
        if tentativa in palavra:
            acertos += tentativa
        else:
            erros += 1
            print("Você errou!")
    print("||==:==\n||  :  ")
    print("||  O  " if erros >= 1 else "||")
    linha2 = ""
    if erros == 2:
        linha2 = "  |  "
    elif erros == 3:
        linha2 = " \|  " 
    elif erros >= 4:
        linha2 = " \|/ "
    print(f"||{linha2}")
    linha3 = ""
    if erros == 5:
        linha3 += " /  "
    elif erros >= 6:
        linha3 += " / \ "
    print(f"||{linha3}")
    print("||\n==========")
    if erros == 6:
        print("Enforcado!")
        break

Digite a plavra secreta: rato




































































































....

Digite uma letra: t
||==:==
||  :  
||
||
||
||
==========
..t.

Digite uma letra: a
||==:==
||  :  
||
||
||
||
==========
.at.

Digite uma letra: o
||==:==
||  :  
||
||
||
||
==========
.ato

Digite uma letra: r
||==:==
||  :  
||
||
||
||
==========
rato
Você acertou!

Escrevendo scripts

Scripts são pequenos programas que fazem alguma tarefa específica. Python surgiu como uma linguagem de script e é muito usada para isso.

Um exemplo comum é executar um programa repetidas vezes mudando algum dado de entrada.

Aqui, vamos fazer um script com o jogo de forca acima. Convenhamos, usar isso no notebook jupyter não é a melhor coisa do mundo...

Para se fazer o script, você vai precisar usar um editor de texto. Pode ser o spyder, notepad++, geany, visual studio code, emacs ou qualquer editor de texto. Não processador de texto. Não vai funcionar com o Word!!!

Crie um arquivo novo e copie e cole o programa acima. Chame o arquivo de forca.py

Agora basta você executar

python forca.py

Tem como tornar isso um pouco melhor.

No Linux ou Unix

Em linux (e mac OS?) é interessante adicionar a seguinte linha no topo:

#!/usr/bin/env python3

aí você torna o arquivo executável com a seguinte linha de comando

chmod +x forca.py

Agora o arquivo funciona como se fosse um executável!

No windows

Se você instalou o python, clique duplo no arquivo forca.py já deveria funcionar. Se a associação da extensão do arquivo estiver correta.

Na linha de comando você pode fazer algo parecido com o Linux. Na primeira linha, coloque o caminho para o executável do Python. No meu computador, esta primeira linha é:

#!"C:\ProgramData\Anaconda3\python.exe"

Aí você pode usar o programa como se fosse um executável.

Exercício 10

Modifique o jogo da forca de forma que a palavra secreta seja escrita caso o jpgador perca

Exercício 11

Modifique o jogo da forca de forma a utilizar uma lista de palavras. No início pergunte um número e calcule o índice da palavra a utilizar pela fórmula:

índice = (número * 776) % len(lista_de_palavras)
In [ ]:

Comentários

Comments powered by Disqus