PA: PROGRAMAÇÃO ESTRUTURADA

PROF. OSMAR VENTURA GOMES

Apresentando o ambiente de desenvolvimento VSCode:
Apresentando a arquitetura do Notebook:
- Visão Geral

No Visual Studio Code podemos criar diversos notebooks. A estrutura geral

pode ser identificada pela figura abaixo:

Notebook Célula de código

Célula 1

Célula 2 Célula texto

..
..

Célula N
Apresentando a arquitetura do Notebook:
- Visão Geral

No Visual Studio Code podemos criar diversos notebooks. A estrutura geral

pode ser identificada pela figura abaixo:

Notebook Célula de código

Célula 1

Célula 2 Célula texto

..
..

Célula N

Executar um programa!
Apresentando a arquitetura do Notebook:
- Visão Geral

Caixa de entrada de dados.

Primeiro Programa
Python
Roteiro

1. Dominando variável

2. Entrada de dados

3. Saída de dados

4. Exercícios
1. Dominando variável

Uma variável é um elemento da linguagem usado para armazenar

valores (dados) de entrada ou de processamento. Possui um tipo
específico para cada tipo de dado.

É identificada por um nome ou identificador.

Ex: variável chamada “mensagem”

mensagem = "Olá Mundo!“

print(mensagem)
1. Dominando variável
Tipos de valores
• Inteiros (int): -22, 0, 44
– A aritmética é exata

• Números Reais (float): 2.718, 3.1415

– float, para “ponto flutuante”
– A aritmética é aproximada

• Strings (str): "I love Python", ""

• Valores lógicos (bool): True, False

– bool, para “Booleano”
1. Dominando variável
Nomenclatura
• Case sensitive: Aluno != (diferente) aluno
• Nomes compostos não podem possuir espaçamento
Exemplos:
nome do aluno (3 variáveis: nome, do, aluno)
nomeDoAluno (1 variável),
nome_do_aluno (1 variável)
• Não é permitido o uso de caracteres especiais, salvo "_"
• Variáveis não podem ter o seu nome inicializado com
números.
Exemplos:
1aluno → (errado)
aluno1 → (correto)
2. Entrada de dados
Entrada interna (valores são definidos pelo programador e/ou processamento)

• nome_da_variável = valor
• Outros tipos de entrada de dados interna (atribuição):
Caso 1: atribuição múltipla → A = B = C = 1
Caso 2: atribuição posicional → A, B, C = 1, 2, 3
Caso 3: inversão de objetos → X, Y = Y, X
• Exemplo:
X, Y = 0, -10
print(X, Y)
0 -10
X, Y = Y, X
print(X, Y)
-10 0
2. Entrada de dados
Entrada externa (valores são definidos pelo usuário do programa)

• nome_da_variável = tipoVariável(input("texto"))

• Exemplo

valor1 = int(input("Digite um número inteiro"))

3. Saída de dados
Impressão na tela do simulador/computador

• Valor de uma variável → print(nome da variável)

print(ap1)
print (ap1, ap2 ..., apn)
“

• Texto
print("texto para print")
print("Aluno aprovado!")

• Valor de uma variável + texto

print("Texto", nome da variável)
print("Sua nota foi:", nota)
 EXERCÍCIOS

CRIE PROGRAMAS EM PYTHON CORRESPON-

DENTES A LISTA DE EXERCÍCIOS 1, DISPO-
NIBILIZADA NA SALA DE AULA VIRTUAL.
Operadores matemáticos
 Manipulando números

Em Python existem três funções empregadas para efetuar o

arredondamento de números de ponto flutuante:

• Função built-in round(): Arredonda para cima ou para baixo

• Método math.floor(): Arredonda para baixo, até o inteiro mais

próximo

• Método math.ceil(): Arredonda para cima, até o inteiro mais

próximo
Manipulando números – round exemplos
Manipulando números – round exemplos
 Segundo passo:
Estrutura Condicional
Estrutura Condicional
O Python suporta as condições lógicas usuais da matemática, retornando um valor lógico
booleano (Falso | Verdadeiro):

Igual a: a == b

Não é igual: a! = b

Menor que: a <b

Menor ou igual a: a <= b

Maior que: a > b

Maior ou igual a: a >= b

Ainda podemos formar expressões mais complexas usando os operadores lógicos:

and → Define uma conjunção lógica entre os termos

or → Define uma disjunção lógica

Not → Negação lógica

Estrutura Condicional
Aplicando os operadores lógicos:

1) Not a = 33
b = 200
if not a > b:
print("a não é maior que b")

2) or a = 200
b = 33
c = 500
if a > b or a > c:
print(“Pelo menos uma das condições é verdadeira")

3) and a = 200
b = 33
c = 500
if a > b and c > a:
print(“As duas condições são verdadeiras")
Estrutura Condicional

Em programação, é comum que diante de determinadas situações, é necessário fazermos

escolhas quanto ao fluxo normal de execução do programa. Como por exemplo:

Considere que no de cálculo da folha de pagamento de funcionários de uma empresa,

deseja-se pagar uma gratificação. A condições para este pagamento, é que se o salário do

funcionário for menor que R$ 3.500,00 deverá ser adicionado ao vencimento uma

gratificação de R$ 300,00, valores iguais ou acima a gratificação será de R$ 100,00.

O Python tem suporte para este tipo de mecanismo de processamento, chamamos de estrutura

condicional.
Estrutura Condicional
A principal e mais usada estrutura condicional do Python é a construção if/else.

Podemos usar também uma variação conhecida como if/elif/else.

O Python suporta as condições lógicas usuais da matemática, retornando um valor lógico booleano
(Falso | Verdadeiro) – Atente pela indentação. Formatos:

if condição1:
Bloco de execução da condição verdadeira
else:
Bloco de execução na condição de falha na condicional

if condição1:
Bloco de execução da condição verdadeira
elif condição2:
Bloco de execução da condição verdadeira
else:
Bloco de execução na condição de falha na condicional
Estrutura Condicional - variações
If condicional:

If condicional:
else:
Estrutura Condicional - variações

If condicional:
elif:
else:
Estrutura Condicional - composta
If
condicional
:
elif:
else:
Estrutura Condicional - aninhada
Estrutura de dados
Estrutura de Dados
 Processamento de strings
• Sequências imutáveis de códigos Unicode: dados textuais
em Python são manipulados com objetos str ou strings.

• Como escrevê-las (mantenha o padrão escolhido em todo

código):
➢ Aspas simples: ‘Podemos usar “aspas" quotes’
➢ Aspas dupla: “Podemos usar ‘aspas’ simples".

• Strings são arrays: As strings no Python são matrizes de bytes

que representam caracteres unicode. No entanto, Python não
possui um tipo de dados de caractere, um único caractere é
simplesmente uma sequência com comprimento 1.
Processando Strings Exemplos:
• isdigit(): retorna True se a string for formada apenas por dígitos.
'306090'.isdigit() #True
telefone = '55 31 68711272'
telefone.isdigit() # False

• len(): mostrar o tamanho da string

opcao = “abc"
len(opcao) # 3

• split(): separa uma string conforme um delimitador

s = 'n o m e'
s.split() # ['n', 'o', 'm', 'e']
s.split(" ") # ['n', 'o', 'm', 'e']
s.split("") # ValueError: empty separator
Processando Strings Exemplos:
▪ isalpha(): retorna False se a string contiver algum caractere
que não seja letras
"abc".isalpha() # True
"1fg".isalpha() # False
"123".isalpha() # False
"/+)".isalpha() # False

▪ upper(): caixa alta

“Osmar".upper() # OSMAR

▪ lower(): caixa baixa

"Osmar".lower() # osmar
 Processando Strings Exemplos:
• join(): une cada item da string com um delimitador especificado. É o
inverso do split()
",".join("abc") # 'a,b,c'

Também aceita listas.

"-".join([‘Osmar’, ‘Ventura', ‘Gomes’]) # ‘Osmar-Ventura-Gomes'

• strip(): retira espaços em branco no começo e no fim

" sobrando espaços ".strip() # 'sobrando espaços’

▪ replace(): Substitui uma sequência de caracteres dentro de uma

string
“n o m e“.replace(" ", "") # nome
Processando Strings Exemplos:
▪ find(): localiza uma sub-string em uma string. Retorna o índice e não a
posição.
test = 'Eu sou apenas uma string.'
test.find(‘a’) #7

▪ str(): converte em string

num = 123
type(num) # <class 'int'>
type(str(num)) # <class 'str’>

▪ Fragmentar strings:
s = 'ola mundo!'
s[3:8] #' mund'
 Conhecendo Listas
• O Python inclui diversas estruturas de dados compostas, usadas para
agrupar outros valores.

• A mais versátil é list (lista), que pode ser escrita como uma lista de
valores (itens) separados por vírgula, entre colchetes.

• Os valores contidos na lista não precisam ser todos do mesmo tipo.

Exemplos:

num = [1, 8, 16, 25, 14, 66]

letra = [‘g’, ’w’, ’p’, ’1’, ’b’, ’y’]

 Listas
• Indexação e Fatiamento:

num = [1, 8, 16, 25, 14, 66]

print (num) # [1, 8, 16, 25, 14, 66]

print (num[3]) # 25

letra = ['g', 'w', 'p', '1', 'b', 'y']

print (letra) # ['g', 'w', 'p', '1', 'b', 'y’]

print (letra[0]) # g

print (letra[-1]) # y

print (letra[-3]) # 1

print (letra[-3]:) # ['1', 'b', 'y']

 Listas
• Indexação e Fatiamento:

letra = ['g', 'w', 'p', '1', 'b', 'y’]

print (letra[:]) # ['g', 'w', 'p', '1', 'b', 'y’]

print (letra+[1, 2, 3, 4]) # ['g', 'w', 'p', '1', 'b', ‘y’, 1, 2, 3, 4]

letra[2] = ‘x'

print (letra) # ['g', 'w', ‘x', '1', 'b', ‘y’]

print (letra[-3]:) # ['1', 'b', 'y']

 Listas – Métodos associados
• Considere:
letra = ['g', 'w', 'p', '1', 'b', 'y']
complemento = [1, 2, 3, 4]
• lista.append(x)
Adiciona um item ao fim da lista. Equivalente a:
letra[len(letra):] = ['x']
['g', 'w', 'p', '1', 'b', 'y', 'x’]

• lista.extend(iterable)
Prolonga a lista, adicionando no fim todos os elementos do argumento
iterable passado como parâmetro. Equivalente a:
letra[len(letra):] = complemento
['g', 'w', 'p', '1', 'b', ‘y’, 1, 2, 3, 4]
 Listas – Métodos associados
• Considere:
letra = ['g', 'w', 'p', '1', 'b', 'y']
complemento = [1, 2, 3, 4]

• lista.insert(i, x)
Insere um item em uma dada posição. O primeiro argumento é o índice
do elemento antes do qual será feita a inserção, assim a.insert(0, x) insere
um elemento na frente da lista, por outro lado, a.insert(len(a), x) é equivale
a lista.append(x).

Exemplo: letra.insert(1, ‘_’) # ['g', ‘_’, 'w', 'p', '1', 'b', 'y']
 Listas – Métodos associados
• Considere:
letra = ['g', ‘g', 'p', '1', 'b', ‘g’]

• lista.remove(x)
Remove o primeiro item encontrado na lista cujo valor é igual a x. Se
não existir valor igual, uma exceção ValueError é levantada. Exemplos:
letra.remove(‘g’)
['g', 'p', '1', 'b', 'g’]

try:
letra.remove('x')
except ValueError:
print('Valor não encontrado!')
print(letra) #['g', 'g', 'p', '1', 'b', 'g']
 Listas – Usando a instrução del
• Remove um item de uma lista usando seu índice no lugar do seu valor.
• Ele difere do método pop() que devolve um valor.
• Exemplos:

lista = [-1, 1, 66.25, 333, 333, 1234.5]

del lista[0]
print(lista) # [1, 66.25, 333, 333, 1234.5]
del lista[2:4]
print(lista) # [1, 66.25, 1234.5]
del lista[:]
print(lista) # []
# del também pode ser usado para remover totalmente uma variável:
del lista
print (lista) # NameError
 Listas – Métodos associados
• Considere:
letra = ['g', ‘g', 'p', '1', 'b', ‘g']
• lista.count(x)
Devolve o número de vezes em que x aparece na lista.
letra.count('g') # 3
• list.sort(reverse=False)
Ordena os itens na lista.
letra = ['g', 'g', 'p', '1', 'b','g']
letra.sort(reverse=False)
print(letra) #['1', 'b', 'g', 'g', 'g', 'p']
• list.reverse()
Inverte a ordem dos elementos na lista.
letra.reverse() #['g', 'b', '1', 'p', 'g', 'g']
 Listas – Métodos associados
• list.copy()

Devolve uma cópia da lista. Equivalente a copia = letra[:]

letra = ['g', 'g', 'p', '1', 'b’, 'g']

copia = letra.copy()

copia[0] = 'z'

print(letra) #['g', 'g', 'p', '1', 'b', 'g’]

print(copia) #[‘z', 'g', 'p', '1', 'b', 'g']

 Dicionários: Conceitos
▪ Dicionários em Python são conjuntos de chave-valor.

▪ São chamados de “memória associativa” ou “vetor associativo”.

▪ Diferente de sequências que são indexadas por inteiros, dicionários são

indexados por chaves (keys), que podem ser de qualquer tipo imutável
(como strings e inteiros).

▪ Tuplas também podem ser chaves se contiverem apenas strings, inteiros

ou outras tuplas.

▪ Se a tupla contiver, direta ou indiretamente, qualquer valor mutável, não

poderá ser chave.

▪ Listas não podem ser usadas como chaves porque podem ser
modificadas.
 Dicionários: Conceitos
▪ Um bom modelo mental é imaginar um dicionário como um conjunto não-
ordenado de pares chave:valor, onde as chaves são únicas em uma dada
instância do dicionário.

▪ Dicionários são delimitados por chaves: {}, e contém uma lista de pares
chave:valor separada por vírgulas.

▪ O dicionário vazio é {}.

▪ As principais operações em um dicionário são armazenar e recuperar

valores a partir de chaves, também é possível remover um par chave:valor
com o comando del.

▪ Se você armazenar um valor utilizando uma chave já presente, o antigo

valor será substituído pelo novo.

▪ Se tentar recuperar um valor usando uma chave inexistente, será gerado

um erro.
 Dicionários: Exemplos
tel = {'Osmar': 4098, 'Pedro': 4139}

tel['Arnaldo'] = 4127

print(tel) # {'Osmar': 4098, 'Pedro': 4139, 'Arnaldo': 4127}

print(tel['Osmar']) # 4098

del tel['Pedro']

tel['Marcos'] = 4127

print(tel) #{'Osmar': 4098, 'Arnaldo': 4127, 'Marcos': 4127}

print(tel['Emerson']) # KeyError: 'Emerson'

 Dicionários: Criando
A função dict() gera dicionários diretamente de sequências de pares
chave-valor:

agenda = dict([(‘Pedro', 4139), (‘Arnaldo', 4127), (‘Osmar', 4098)])

print(agenda) # {‘Pedro': 4139, ‘Arnaldo': 4127, ‘Osmar': 4098}

Quando chaves são strings simples, é mais fácil especificar os pares

usando argumentos nomeados no construtor:

Agenda = dict(Pedro=4139, Arnaldo=4127, Osmar=4098)

print(agenda) # {‘Pedro': 4139, ‘Arnaldo: 4127, ‘Osmar': 4098}

 Dicionários: Operações
▪ Executar list(dic) em um dicionário devolve a lista de todas as chaves
presentes no dicionário, na ordem de inserção.

▪ Para ordenar dicionários basta usar a função sorted(dic)

▪ Para verificar a existência de uma chave, use o operador in.

Exemplos de uso do dicionário:

tel = {'Osmar': 4098, 'Arnaldo': 4127, 'Marcos': 4127}

Nomes = list(tel)

Nomes_ord = sorted(tel)

print(Nomes) # ['Osmar', 'Arnaldo', 'Marcos']

print(Nomes_ord) # ['Arnaldo', 'Marcos', 'Osmar']

'Elias' in tel # False

'Osmar' not in tel # False

Dicionários: Técnicas de iteração
Ao iterar sobre dicionários, a chave e o valor correspondente podem ser
obtidos simultaneamente usando o método items().

agenda = {'Osmar': 4098, 'Arnaldo': 4127, 'Marcos': 4127}

for nome, tel in agenda.items():

print(nome, tel)

Saída do programa:

Osmar 4098

Arnaldo 4127

Marcos 4127
 Dicionários: Métodos Associados
dic.clear()

Remove todos os elementos do dicionário.

frutas = {1: 'Maçã', 2: 'Pera', 3: 'Uva’}

print(frutas) # {1: 'Maçã', 2: 'Pera', 3: 'Uva’}

frutas.clear()

print(frutas) # {}
 Dicionários: Métodos Associados

dic.get(key)

Retorna o valor da referida chave.

frutas = {1: 'Maçã', 2: 'Pera', 3: 'Uva'}

print(frutas.get(1)) # Maçã
 Dicionários: Métodos Associados
dic.update(dict)

Atualiza os pares chave-valor de um dicionário usando elementos de

outro dicionário ou um iterável de pares chave-valor. Com esse método,
você pode incluir novos dados ou mesclá-los com entradas de dicionário
existentes.

frutas = {1: 'Maçã', 2: 'Pera', 3: 'Uva’}

frutas_tmp = {1: ‘Banana’}

frutas.update(frutas_tmp);

frutas_tmp = {5: ‘Manga’}

frutas.update(frutas_tmp);

print(frutas) # {1: ‘Banana', 2: 'Pera', 3: 'Uva’, 5:’Manga’}

 Dicionários: Métodos Associados
Atualizações em dicionários 1

frutas = {1: 'Maçã', 2: 'Pera', 3: 'Uva'}

print(list(frutas)) # [1, 2, 3]

for i, v in enumerate(['tic', 'tac', 'toe']):

print(i, v)

frutas[i]= v

print(frutas) #{1: 'tac', 2: 'toe', 3: 'Uva', 0: 'tic'}

 Dicionários: Métodos Associados
Atualizações em dicionários 2

frutas = {1: 'Maçã', 2: 'Pera', 3: 'Uva'}

print(list(frutas)) # [1, 2, 3]

L = ['Laranja','Abacaxi','Abacate','Limão']

for i, v in enumerate(L):

print(i, v)

frutas[i]= v

print(frutas) #{1: 'Abacaxi', 2: 'Abacate', 3: 'Limão', 0: 'Laranja'}

 Dicionários: Métodos Associados
dic.pop()

É um método de dicionário preexistente que remove e recupera o valor

vinculado a uma determinada chave de um dicionário.

frutas = {1: 'Maçã', 2: 'Pera', 3: 'Uva’}

frutas.pop(2)

print(frutas) # {1: 'Maçã', 3: 'Uva’}

Controle de fluxo:
loop
 Exercício: Conversão de
temperatura
• Faça um programa que efetue a conversão de medidas de temperature de Fahrenheit
para Celsius, usando os seguintes valores: 30, 40, 50, 60, 70

• Exemplo da tela de saída do programa:

30 -1.11
40 4.44
50 10.0
60 15.56
70 21.11

• Obs.: celsius = (fahr - 32) * 0.5555

 Exercício: Conversão de
temperatura
fahr = 30
celsius = (fahr - 32) * 0.5555
print(fahr, celsius)
fahr = 40
celsius = (fahr - 32) * 0.5555
print(fahr, celsius)
fahr = 50
celsius = (fahr - 32) * 0.5555
print(fahr, celsius)
fahr = 60
celsius = (fahr - 32) * 0.5555
Saída:
print(fahr, celsius)
30 -1.11
fahr = 70
40 4.44
celsius = (fahr - 32) * 0.5555
50 10.0
print(fahr, celsius)
60 15.56
print("Fim")
70 21.11
Fim
 Estrutura de repetição
(loop): for
for fahr in [30, 40, 50, 60, 70]:
celsius = (fahr - 32) * 0.5555
print(fahr, celsius)
 Explicando o loop for

Variável de Uma lista Obrigatório

loop for iteração :
(Coleção de valores)

Corpo de for fahr in [30, 40, 50, 60, 70]:

repetição
celsius = (fahr - 32)* 0.5555
print(fahr, celsius)
print(“Fim") Saída:
30 -1.11
Observe a indentação!!! Executa o corpo de repetição 5 vezes: 40 4.44
50 10.0
• Uma vez com ahr = 30 60 15.56
• Outra vez com fahr = 40 70 21.11
• … Fim
 Exemplos:
Imprime a sequência de
valores
for num in [2, 4, 6]:
print(num)
Não imprime a
sequência de valores.
for i in [2, 4, 6]: Imprime a frase 3
vezes.
print(“Teste de
impressão!")

for char in “Feliz": A sequência de valores

é uma string
print(char)
Imprime cada caracter
em uma linha
 Como o loop é executado?
- Usando uma abordagem sequential.
i = 1 Tela de saída
print(i)
i = 4 1
for i in [1,4,9]:
print(i) print(i) 4
i = 9 9
print(i)

Converta o loop em uma sequência de instruções simples!

 O corpo de repetição pode ter vários comandos

for i in [3, 4, 5]:

print(“Osmar")
print(i) Corpo de repetição:
3 comandos
print(i * i)
Saída: Não:
Osmar Osmar
3 Osmar
9 Osmar
Osmar 3
4 4
16 5
Osmar 9
5 16
25 25
 A indentação é importante

• Cada comando deve ter exatamente a mesma indentação

for i in [3, 4, 5]:

print(“Início do corpo”)
Erro! print(i)
print(i*i)

• Avalie os resultados dos loops:

for f in [30, 40, 50, 60, 70]:

print(f, (f - 32) * 0.555)
print("Fim!")

for f in [30, 40, 50, 60, 70]:

print(f, (f - 32) * 0.555)
print("Fim!")
A função range()

Um loop típico não usa uma lista explícita:

for i in range(5):
Produz a lista de
… Corpo de repetição … valores

Limite superior

range(5): [0, 1, 2, 3, 4]
Limites inferior e superior

range(1, 5): [1, 2, 3, 4]

range(1, 10, 2): cycles through [1, 3, 5, 7, 9]

Incremento entre os
elementos
 Avalie a execução:
# Exemplo 1
result = 0
for element in range(5):
result = result + element
print("A soma é: " + str(result))

# Exemplo 2
result = 0
for element in range(5, 1, -1):
result = result + element
print("A soma é:", result)

# Exemplo 3
result = 0
for element in range(0, 8, 2):
result = result + element
print(“A soma é:", result)
 Avalie a execução:

# Exemplo 4
result = 0
tam = 5
for element in range(tam):
result = result + element
print(“Quando tam = " + str(tam) + " o
resultado é " + str(result))

# Exemplo 5
mylist = [35, 123, 81, 14, 66, 2, 21, 8]
curr_max = mylist[0]
for element in mylist:
curr_max = max(curr_max, element)
print(curr_max)
 Avalie a execução:
# Exemplo 6
Aproximação de 3 pela fórmula: 1 + 2/3 + 4/9 + 8/27 + 16/81 + …
= (2/3)0 + (2/3)1 + (2/3)2 + (2/3)3 + … + (2/3)10

result = 0
for element in range(11):
result = result + (2.0/3.0)**element
print (result)

# Exemplo 7 - Loops aninhados

for i in [1, 2, 3]:

print("Antes do loop j, i =", i)
for j in [50, 100]:
print("j é", j)
Mais sobre loops aninhados
O que será impresso?

for i in [0, 1]:

print("Externo", i)
for j in [2, 3]:
print(" Interno", j)
print(" Soma", i + j)
print("Externo", i)
 Mais sobre loops aninhados
Quantos comandos o loop possui?

for i in [0, 1]: Corpo de commandos

do loop externo:
print("Externo", i) 3 comandos
for j in [2, 3]: saída:
Externo 0
Corpo de comandos
do loop aninhado:
print(" Interno", j) Interno 2
2 comandos
print(" Soma", i + j) Soma 2
Interno 3
print("Externo", i) Soma 3
Externo 0
Externo 1
Interno 2
Soma 3
O que será impresso? Interno 3
Soma 4
Externo 1
 Entendendo o aninhamento por
transformação

for i in [0, 1]: i = 0 i = 0

print("Externo", i) print("Externo", i) print(" Externo ", i)
for j in [2, 3]: for j in [2, 3]: j = 2
print(" Interno", j) print(" Interno", j) print(" Interno", j)
i = 1 j = 3
print("Externo", i) print(" Interno ", j)
for j in [2, 3]: i = 1
print(" Interno", j) print(" Externo ", i)
j = 2
print(" Interno ", j)
j = 3
print(" Interno ", j)
Exercícios de fixação – O que será impresso?

1)
for i in [0, 1]:
print(i)
print(i)

2)
i = 5
for i in []:
print(i)
Exercícios de fixação – O que será impresso?

3)
for i in [0, 1]:
print("Externo", i)
for i in [2, 3]:
print(" Interno", i)
print("Externo", i)

4)
for tam in [1, 2, 3, 4]:
print(" tam é " + str(tam))
for elemento in range(tam):
print("O element é " + str(elemento))
Exercícios de fixação – O que será impresso?

for tam in [1, 2, 3, 4]:

result = 0
for elemento in range(tam):
result = result + elemento
print(“tam=" + str(tam) + "
result=" + str(result))
print("Pronto!")
print("O result é", result)
 Exercícios de fixação
6) Analise o programa abaixo e faça o ajuste necessário para
imprimir a sequência: 1, 2, 3, 4, …, 48, 49 , 50

# Objetivo: Imprimir 1, 2, 3, …, 48, 49, 50

for dezena in [0, 1, 2, 3, 4]:
for unidade in [1, 2, 3, 4, 5, 6, 7, 8, 9]:
print(dezena * 10 + unidade)
Exercícios de fixação – Proposta de solução
6) Analise o programa abaixo e faça o ajuste necessário para imprimir a
sequência: 1, 2, 3, 4, …, 48, 49 , 50

a) for dezena in [0, 1, 2, 3, 4]:

for unidade in [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]:
print(dezena * 10 + unidade + 1)

b) for dezena in [0, 1, 2, 3, 4]:

for unidade in [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]:
print(dezena * 10 + unidade)

c) for unidade in [1, 2, 3, 4, 5, 6, 7, 8, 9]:

print(unidade)
for dezena in [1, 2, 3, 4]:
for unidade in [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]:
print(dezena * 10 + unidade)
print(50)
 Loops com Strings
for letra in "Osmar Ventura":
print(letra)

my_string = "Osmar Ventura"

for letra in my_string:
print(letra)

my_string = "Osmar Ventura"

cont = 0
for letra in my_string:
cont = cont + 1
print(cont)

77
 Loops: continue
O comando break interrompe o looping e
continue passa para a próxima iteração.

nome = "Osmar Ventura Gomes"

for letra in nome:
continue
print(letra, end="")

nome = "Osmar Ventura Gomes"

for letra in nome:
print(letra, end="")
continue

78
 Loops: break
nome = "Osmar Ventura Gomes"
for letra in nome:
print(letra, end="")
break

nome = "Osmar Ventura Gomes"

for letra in nome:
print(letra, end="")
if letra == " ":
break

79
 Loops: while
x = 0

print('antes do while’)

while(x<10):
print(x)
x+=1
else:
print('fim do while')

print('fim’)

80
 Loops: while - continue
x = 0
print('antes do while’)
while(x<10):
print(x)
x+=1
continue
else:
print('fim do while')
print('fim’)

81
 Loops: while - continue
x = 0
print('antes do while’)
while(x<10):
continue
print(x)
x+=1
else:
print('fim do while')
print('fim’)

82
 Loops: while - break
x = 0
print('antes do while’)
while(x<10):
break
print(x)
x+=1
else:
print('fim do while')
print('fim’)

83
 Loop infinito
x = 0
print('antes do while’)
while(True):
print(x)
x+=1
#break
else:
print('fim do while')
print('fim’)

84
 Funções: definição
• Uma das principais formas de se criar componentes reusáveis em
Python são as chamadas funções.
• Uma função é basicamente um trecho de código (um procedimento,
um algoritmo) que pode ser usado várias vezes.

• A palavra reservada def inicia a definição de uma função.

• Ela deve ser seguida do nome da função e da lista de parâmetros
formais entre parênteses.
• Os comandos que formam o corpo da função começam na linha
seguinte e devem ser indentados.
 Funções: exemplo
• Escrever uma função que retorna uma lista de números da
série de Fibonacci:
def fibo(n):
#Retorna uma lista contendo elementos da sequência de Fibonacci até n.
resultado = []
a, b = 0, 1
while a <= n:
resultado.append(a)
a=b
b = a+b
return resultado

sequencia = fibo(100)
print(sequencia) # [0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89]
 Formatando de strings

O método format() permite formatar partes selecionadas de uma

string.

Às vezes há partes de um texto que você não controla, talvez

elas venham de um banco de dados ou de entrada do usuário.

Para controlar tais valores, adicione espaços reservados

(colchetes {}) no texto e execute os valores através do método
format().
 Formatando de strings

Exemplos:
1) Posicionar o valor de uma variável em um texto, adicione um
espaço reservado onde deseja exibir o preço:

preco = 49
txt = "O preço é {} reais"
print(txt.format(preco))
 Formatando de strings

Exemplos:
2) Exibir um valor com um número específico de casas decimais:

preco = 49
#txt = "O preço é {} reais"
txt = "O preço é {:.2f} reais"
print(txt.format(preco))
 Formatando de strings

Exemplos:
3) Se você quiser usar mais valores, basta adicionar mais
valores ao método format():

quantidade = 3
itemno = 567
preco = 49
pedido = "Eu quero {} unidades do item {} a {:.2f} reais
cada."
print(pedido.format(quantidade, itemno, preco))
 Formatando de strings

Exemplos:
4) Podemos usar números de índice (um número entre chaves
{0}) para garantir que os valores sejam colocados nos espaços
reservados corretos:
quantidade = 3
itemno = 567
preco = 49
pedido = "Eu quero {0} unidades do item {1} a {2:.2f}
reais cada."
print(pedido.format(quantidade, itemno, preco))
 Formatando de strings

Exemplos:
5) Podemos usar números de índice (um número entre chaves
{0}) para garantir que os valores sejam colocados nos espaços
reservados corretos: ** Observem a ordem dos parâmetros do método format()

quantidade = 3
itemno = 567
preco = 49
pedido = "Eu quero {1} unidades do item {0} a {2:.2f}
reais cada."
print(pedido.format(itemno, quantidade, preco))
 Formatando de strings

Exemplos:
6) É possível referenciar a um mesmo índice mais de uma vez:

quantidade = 3
itemno = 567
preco = 49
pedido = "Eu quero {1} unidades do item {0} a {2:.2f}
reais cada. O valor total será {1} vezes o valor do preço
unitário!"
print(pedido.format(itemno, quantidade, preco))
 Formatando de strings

Exemplos:
7) Podemos usar índices nomeados, inserindo um nome entre
chaves {nome}. Ao chamar o método, devemos passar os nomes
como parâmetros do método format() :

pedido = "Eu vou comprar um {nomecarro}, modelo {modelo}."

print(pedido.format(nomecarro = "Ford", modelo = "Mustang"))

OBRIGADO!!!