Programação de Computadores

Aula 1: Algoritmos e Lógica de Programação

● Conceitos básicos de algoritmos e lógica de programação.
● Estrutura de um programa em Python.
● Introdução aos diagramas de bloco/fluxogramas.
● Testes de mesa.

Objetivo da Aula: Compreender os conceitos fundamentais de algoritmos e lógica de

programação, e como aplicá-los em Python.

Iniciando a programação em python

print("Olá, Mundo!")

Indentação em Python
A indentação se refere aos espaços no início de uma linha de código.

Enquanto em outras linguagens de programação a indentação é apenas para legibilidade,

em Python ela é muito importante.

Python usa a indentação para indicar um bloco de código.

if 5 > 2:
print("Cinco é maior que dois!")

Variáveis em Python
Em Python, variáveis são criadas quando você atribui um valor a elas:

x = 5
y = "Olá, Mundo!"

Comentários
Python permite comentários para documentação no código.

Comentários começam com #, e Python considera o resto da linha como um comentário:

#Este é um comentário.
print("Olá, Mundo!")

Variáveis
Variáveis são contêineres para armazenar valores de dados.

Criando Variáveis
Python não possui comando para declarar uma variável.

Uma variável é criada no momento em que você atribui um valor a ela.

x = 5
y = "João"
print(x)
print(y)

Variáveis não precisam ser declaradas com um tipo particular e podem mudar de tipo após
serem definidas.

x = 4 # x é do tipo int
x = "Sally" # x agora é do tipo str
print(x)

Casting
Se você deseja especificar o tipo de dados de uma variável, isso pode ser feito com casting.

x = str(3) # x será '3'

y = int(3) # y será 3
z = float(3) # z será 3.0

Obtendo o Tipo
Você pode obter o tipo de dados de uma variável com a função type().

x = 5
y = "João"
print(type(x))
print(type(y))

Aspas Simples ou Duplas?

Variáveis de string podem ser declaradas usando aspas simples ou duplas:

x = "João"
# é o mesmo que
x = 'João'

Diferenciação de Maiúsculas e Minúsculas

Nomes de variáveis diferenciam maiúsculas de minúsculas.
 a = 4
A = "Sally"
#A não sobrescreverá a

Nomes de Variáveis
Uma variável pode ter um nome curto (como x e y) ou um nome mais descritivo (idade,
nome_do_carro, volume_total). Regras para variáveis em Python:
- Um nome de variável deve começar com uma letra ou o caractere de sublinhado
- Um nome de variável não pode começar com um número
- Um nome de variável pode conter apenas caracteres alfanuméricos e sublinhados (A-z,
0-9 e _)
- Nomes de variáveis são sensíveis a maiúsculas e minúsculas (idade, Idade e IDADE são
três variáveis diferentes)
- Um nome de variável não pode ser uma palavra-chave do Python.

meu_var = "John"
minha_variavel = "John"
_minha_variavel = "John"
minhaVariavel = "John"
MINHAVAR = "John"
minhavar2 = "John"

Nomes de Variáveis com Múltiplas Palavras

Nomes de variáveis com mais de uma palavra podem ser difíceis de ler.

Existem várias técnicas que você pode usar para torná-los mais legíveis:

Camel Case
Cada palavra, exceto a primeira, começa com uma letra maiúscula:

minhaVariavelNome = "John"

Pascal Case
Cada palavra começa com uma letra maiúscula:

MinhaVariavelNome = "John"

Snake Case
Cada palavra é separada por um caractere de sublinhado:

minha_variavel_nome = "John"

Muitos Valores para Múltiplas Variáveis

Python permite que você atribua valores a várias variáveis em uma linha:
 x, y, z = "Laranja", "Banana", "Cereja"
print(x)
print(y)
print(z)

Um Valor para Múltiplas Variáveis

E você pode atribuir o mesmo valor a várias variáveis em uma linha:

x = y = z = "Laranja"
print(x)
print(y)
print(z)

Desempacotar uma Coleção

Se você tiver uma coleção de valores em uma lista, tupla etc., o Python permite que você
extraia os valores em variáveis. Isso é chamado de desempacotamento.

frutas = ["maçã", "banana", "cereja"]

x, y, z = frutas
print(x)
print(y)
print(z)

Variáveis Globais
Variáveis que são criadas fora de uma função (como em todos os exemplos acima) são
conhecidas como variáveis globais.

Variáveis globais podem ser usadas por todos, tanto dentro de funções quanto fora.

Crie uma variável fora de uma função e use-a dentro da função

x = "incrível"

def minha_funcao():
print("Python é " + x)

minha_funcao()

Se você criar uma variável com o mesmo nome dentro de uma função, essa variável será
local e só poderá ser usada dentro da função. A variável global com o mesmo nome
permanecerá como era, global e com o valor original.

Crie uma variável dentro de uma função, com o mesmo nome da variável global
 x = "incrível"

def minha_funcao():
x = "fantástico"
print("Python é " + x)

minha_funcao()

print("Python é " + x)

A Palavra-chave global
Normalmente, quando você cria uma variável dentro de uma função, essa variável é local e
só pode ser usada dentro dessa função.

Para criar uma variável global dentro de uma função, você pode usar a palavra-chave
global.

Se você usar a palavra-chave global, a variável pertence ao escopo global:

def minha_funcao():
global x
x = "fantástico"

minha_funcao()

print("Python é " + x)

Também use a palavra-chave global se você quiser alterar uma variável global dentro de
uma função.

Para alterar o valor de uma variável global dentro de uma função, faça referência à variável
usando a palavra-chave global:

x = "incrível"

def minha_funcao():
global x
x = "fantástico"

minha_funcao()

print("Python é " + x)

Teste de Mesa
Um teste de mesa em Python (ou em qualquer linguagem de programação) é uma técnica
utilizada para entender e verificar o funcionamento de um algoritmo ou código fonte. Nesse
teste, você executa o código manualmente, acompanhando o valor de cada variável ao
longo das linhas de execução, como se estivesse seguindo um mapa ou tabela (daí o nome
"teste de mesa").

Pseudocódigo

1. Defina três variáveis: num1, num2 e num3.

2. Atribua valores a essas variáveis.
3. Calcule a média dos três números.
4. Verifique se a média é maior que 10.
5. Imprima a média e uma mensagem indicando se é maior que 10 ou não.

Python

# Passo 1: Definindo as variáveis

num1 = 8
num2 = 12
num3 = 10

# Passo 2: Calculando a média

soma = num1 + num2 + num3
media = soma / 3

# Passo 3: Verificando se a média é maior que 10

resultado = "Maior que 10" if media > 10 else "Menor ou igual a 10"

# Passo 4: Imprimindo a média e o resultado da verificação

print("Número 1:", num1)
print("Número 2:", num2)
print("Número 3:", num3)
print("Média:", media)
print("Resultado:", resultado)

Resultado final

Número 1: 8
Número 2: 12
Número 3: 10
Média: 10.0
Resultado: Menor ou igual a 10

Praticando:
Pseudocódigo

1. Solicite ao usuário que insira seu peso em quilogramas.

2. Solicite ao usuário que insira sua altura em metros.
3. Calcule o IMC usando a fórmula: IMC = peso / (altura * altura).
4. Imprima o resultado do IMC.
5. Verifique em qual faixa de peso o usuário se encontra com base no IMC.

Python

# Solicita ao usuário que insira seu peso em quilogramas

peso = float(input("Digite seu peso em quilogramas: "))

# Solicita ao usuário que insira sua altura em metros

altura = float(input("Digite sua altura em metros: "))

# Calcula o IMC
imc = peso / (altura * altura)

# Imprime o resultado do IMC

print("Seu Índice de Massa Corporal (IMC) é:", imc)

# Verifica em qual faixa de peso o usuário se encontra com base no IMC

if imc < 18.5:
print("Você está abaixo do peso normal.")
elif imc < 25:
print("Você está dentro da faixa de peso normal.")
elif imc < 30:
print("Você está com sobrepeso.")
elif imc < 35:
print("Você está com obesidade grau 1.")
elif imc < 40:
print("Você está com obesidade grau 2.")
else:
print("Você está com obesidade grau 3.")

Pseudocódigo

1. Solicite ao usuário que insira a temperatura em graus Celsius.

2. Calcule a temperatura em graus Fahrenheit usando a fórmula: Fahrenheit = (Celsius *
9/5) + 32.
3. Imprima o resultado da temperatura em Fahrenheit.

Python

# Solicita ao usuário que insira a temperatura em graus Celsius

celsius = float(input("Digite a temperatura em graus Celsius: "))

# Calcula a temperatura em graus Fahrenheit

fahrenheit = (celsius * 9/5) + 32

# Imprime o resultado da temperatura em Fahrenheit

print("A temperatura em Fahrenheit é:", fahrenheit)
Aula 2: Dados, Variáveis e Constantes
● Tipos de dados em Python.
● Declaração de constantes e variáveis.
● Operações básicas de entrada e saída de dados.

Objetivo da Aula: Entender como manipular dados em Python e realizar operações básicas
de entrada e saída.

Tipos de Dados em Python

Em programação, o tipo de dado é um conceito importante.

As variáveis podem armazenar dados de tipos diferentes, e cada tipo pode fazer coisas
diferentes.

Python tem os seguintes tipos de dados incorporados por padrão, nessas categorias:

- Texto: str
- Numéricos: int, float, complex
- Sequências: list, tuple, range
- Mapeamento: dict
- Conjuntos: set, frozenset
- Booleano: bool
- Binários: bytes, bytearray, memoryview
- Tipo Nulo: NoneType

# Exemplo de variáveis em Python com diferentes tipos de dados

# Texto: str
nome = "João"

# Numéricos: int, float, complex

idade = 30
altura = 1.75
numero_complexo = 2 + 3j

# Sequências: list, tuple, range

lista_numeros = [1, 2, 3, 4, 5]
tupla_cores = ("vermelho", "azul", "verde")
intervalo = range(0, 10)

# Mapeamento: dict
dic_alunos = {"João": 18, "Maria": 20, "Pedro": 22}

# Conjuntos: set, frozenset

conjunto_vogais = {"a", "e", "i", "o", "u"}
conjunto_imutavel = frozenset({1, 2, 3})

# Booleano: bool
verdadeiro = True
falso = False

# Binários: bytes, bytearray, memoryview

dados_bytes = b"dados"
array_bytes = bytearray(b"array")
visualizacao_memoria = memoryview(b"visualizacao")

# Tipo Nulo: NoneType

variavel_nula = None

Número Aleatório

Python não possui uma função random() para gerar um número aleatório, mas Python tem
um módulo embutido chamado random que pode ser usado para gerar números aleatórios:

# Gerando um número aleatório em Python usando o módulo random

import random

# Gerando um número aleatório entre 0 e 1

numero_aleatorio = random.random()
print(numero_aleatorio)

# Gerando um número inteiro aleatório dentro de um intervalo específico

numero_inteiro_aleatorio = random.randint(1, 100)
print(numero_inteiro_aleatorio)

# Gerando um número flutuante aleatório dentro de um intervalo

específico
numero_flutuante_aleatorio = random.uniform(1.5, 3.5)
print(numero_flutuante_aleatorio)

# Gerando uma escolha aleatória de uma lista

lista_opcoes = ['a', 'b', 'c', 'd', 'e']
escolha_aleatoria = random.choice(lista_opcoes)
print(escolha_aleatoria)

# Embaralhando uma lista aleatoriamente

lista_numeros = [1, 2, 3, 4, 5]
random.shuffle(lista_numeros)
print(lista_numeros)
Especificar o Tipo de Variável

Às vezes, é necessário especificar um tipo para uma variável. Isso pode ser feito através de
conversão de tipos. Python é uma linguagem orientada a objetos e usa classes para definir
tipos de dados, incluindo os tipos primitivos.

A conversão de tipos em Python é feita usando funções construtoras:

- int() - converte um número inteiro de um literal inteiro, um literal flutuante (removendo

todas as casas decimais) ou um literal de string (desde que a string represente um número
inteiro)
- float() - converte um número flutuante de um literal inteiro, um literal flutuante ou um literal
de string (desde que a string represente um número flutuante ou inteiro)
- str() - converte uma string a partir de uma variedade de tipos de dados, incluindo strings,
literais inteiros e literais flutuantes

# Exemplo de especificação de tipo de variável em Python

# Convertendo para um número inteiro

numero_inteiro = int(5.8)
print(numero_inteiro) # Saída: 5

# Convertendo para um número flutuante

numero_flutuante = float("3.14")
print(numero_flutuante) # Saída: 3.14

# Convertendo para uma string

texto = str(123)
print(texto) # Saída: "123"

Strings

# Exemplo de manipulação de strings em Python

# Criando uma string

texto = "Olá, mundo!"

# Métodos de manipulação de strings

# 1. lower(): converte todos os caracteres da string para minúsculas

print(texto.lower()) # Saída: "olá, mundo!"

# 2. upper(): converte todos os caracteres da string para maiúsculas

print(texto.upper()) # Saída: "OLÁ, MUNDO!"
 # 3. capitalize(): converte o primeiro caractere da string para
maiúscula
print(texto.capitalize()) # Saída: "Olá, mundo!"

# 4. title(): converte o primeiro caractere de cada palavra para

maiúscula
print(texto.title()) # Saída: "Olá, Mundo!"

# 5. swapcase(): inverte o caso de cada caractere na string

print(texto.swapcase()) # Saída: "oLÁ, MUNDO!"

# 6. count(): conta o número de ocorrências de uma substring na string

print(texto.count("o")) # Saída: 1

# 7. find(): encontra a primeira ocorrência de uma substring na string

print(texto.find("mundo")) # Saída: 5

# 8. replace(): substitui uma substring por outra

print(texto.replace("mundo", "Python")) # Saída: "Olá, Python!"

# 9. split(): divide a string em substrings com base em um separador

print(texto.split(",")) # Saída: ['Olá', ' mundo!']

# 10. join(): junta elementos de uma lista em uma única string usando a
string como separador
lista_palavras = ["Olá", "mundo", "Python"]
print("-".join(lista_palavras)) # Saída: "Olá-mundo-Python"

Booleanos

Booleans representam um de dois valores: True ou False. Na programação, frequentemente

você precisa saber se uma expressão é Verdadeira ou Falsa. Você pode avaliar qualquer
expressão em Python e obter uma de duas respostas: Verdadeiro ou Falso.

Verificar se um número é maior que outro:

x = 5
y = 3
resultado = x > y
print(resultado) # Saída: True

Testar se uma lista está vazia:

lista = []
resultado = bool(lista)
 print(resultado) # Saída: False

Verificar se uma string contém determinado caractere:

texto = "Python é divertido"

resultado = 'y' in texto
print(resultado) # Saída: True

Verificar se uma variável é do tipo inteiro:

variavel = "Texto"
resultado = isinstance(variavel, int)
print(resultado) # Saída: False

Declaração de constantes e variáveis

Declaração de uma constante e uma variável:

# Declarando uma constante e uma variável

PI = 3.14159 # Definindo o valor de PI como uma constante

# Calculando a área de um círculo com base no raio

raio = 5 # Definindo o raio do círculo como uma variável
area = PI * (raio ** 2) # Calculando a área usando a fórmula PI *
raio^2

# Imprimindo a área do círculo

print("A área do círculo é:", area)

Declaração de variáveis para armazenar informações sobre uma pessoa:

# Variáveis para informações pessoais

nome = "João"
idade = 30
altura = 1.75
peso = 70

print("Nome:", nome)
print("Idade:", idade)
print("Altura:", altura)
print("Peso:", peso)

Exemplo:
# Constantes para as taxas de imposto sobre vendas em diferentes países
TAXA_IMPOSTO_EUA = 0.08
TAXA_IMPOSTO_REINO_UNIDO = 0.20
TAXA_IMPOSTO_ALEMANHA = 0.19
TAXA_IMPOSTO_JAPAO = 0.10

# Função para calcular o preço total com imposto

def calcular_preco_total(preco_produto, taxa_imposto):
return preco_produto * (1 + taxa_imposto)

# Preço do produto em dólares americanos

preco_produto = 50

# Calcular o preço total do produto com imposto nos EUA

preco_total_eua = calcular_preco_total(preco_produto, TAXA_IMPOSTO_EUA)
print("Preço total nos EUA: $", preco_total_eua)

# Calcular o preço total do produto com imposto no Reino Unido

preco_total_reino_unido = calcular_preco_total(preco_produto,
TAXA_IMPOSTO_REINO_UNIDO)
print("Preço total no Reino Unido: £", preco_total_reino_unido)

# Calcular o preço total do produto com imposto na Alemanha

preco_total_alemanha = calcular_preco_total(preco_produto,
TAXA_IMPOSTO_ALEMANHA)
print("Preço total na Alemanha: €", preco_total_alemanha)

# Calcular o preço total do produto com imposto no Japão

preco_total_japao = calcular_preco_total(preco_produto,
TAXA_IMPOSTO_JAPAO)
print("Preço total no Japão: ¥", preco_total_japao)

Desafio

# Constante para a idade mínima permitida

IDADE_MINIMA = 18

# Solicita ao usuário que digite seu nome

nome = input("Digite seu nome: ")

# Solicita ao usuário que digite sua idade

idade = int(input("Digite sua idade: ")) # Convertendo a entrada para
um número inteiro

# Solicita ao usuário que digite sua altura

altura = float(input("Digite sua altura em metros: ")) # Convertendo a
entrada para um número em ponto flutuante

# Solicita ao usuário que indique se gosta de Python (True ou False)

gosta_de_python = input("Você gosta de Python? (Sim ou Não): ").lower()
# Convertendo a entrada para minúsculas
gosta_de_python = gosta_de_python == "sim" # Convertendo para um valor
booleano

# Verifica se o usuário é maior de idade

maior_de_idade = idade >= IDADE_MINIMA

# Exibe uma mensagem personalizada com todas as informações fornecidas

print("Olá,", nome, "!")

if maior_de_idade:
print("Você tem", idade, "anos, o que significa que é maior de
idade.")
else:
print("Você tem", idade, "anos, o que significa que é menor de
idade.")

print("Sua altura é de", altura, "metros.")

if gosta_de_python:
print("É ótimo saber que você gosta de Python!")
else:
print("Tudo bem, Python pode não ser para todos, mas é uma ótima
linguagem!")
Aula 3: Operadores e Expressões
● Operadores aritméticos.
● Expressões aritméticas.
● Operadores relacionais.
● Expressões lógicas.

Objetivo da Aula: Familiarizar-se com os diversos operadores e expressões em Python.

Operadores aritméticos

# Variáveis em português
soma = 10 + 5 # Operador de soma
subtracao = 10 - 5 # Operador de subtração
multiplicacao = 10 * 5 # Operador de multiplicação
divisao = 10 / 5 # Operador de divisão
divisao_inteira = 10 // 3 # Divisão inteira (descarta a parte decimal)
resto_divisao = 10 % 3 # Resto da divisão
exponenciacao = 10 ** 2 # Operador de exponenciação

# Exibindo os resultados
print("Soma:", soma)
print("Subtração:", subtracao)
print("Multiplicação:", multiplicacao)
print("Divisão:", divisao)
print("Divisão inteira:", divisao_inteira)
print("Resto da divisão:", resto_divisao)
print("Exponenciação:", exponenciacao)

Expressões aritméticas

Exemplo 1

# Variáveis em português
comprimento = 10 # Comprimento do retângulo
largura = 5 # Largura do retângulo

# Expressões aritméticas para o perímetro e a área do retângulo

perimetro = 2 * (comprimento + largura) # Cálculo do perímetro
area = comprimento * largura # Cálculo da área

# Exibindo os resultados
print("Comprimento do retângulo:", comprimento)
print("Largura do retângulo:", largura)
print("Perímetro do retângulo:", perimetro)
print("Área do retângulo:", area)
Exemplo 2

# Solicita ao usuário que insira as notas e os pesos correspondentes

nota1 = float(input("Digite a primeira nota: "))
peso1 = float(input("Digite o peso da primeira nota: "))
nota2 = float(input("Digite a segunda nota: "))
peso2 = float(input("Digite o peso da segunda nota: "))
nota3 = float(input("Digite a terceira nota: "))
peso3 = float(input("Digite o peso da terceira nota: "))

# Calcula a média ponderada das notas

media_ponderada = (nota1 * peso1 + nota2 * peso2 + nota3 * peso3) /
(peso1 + peso2 + peso3)

# Exibe a média ponderada

print("A média ponderada das notas é:", media_ponderada)

Exemplo 3

# Solicita ao usuário que insira os dados do investimento

capital_inicial_str = input("Digite o capital inicial (R$): ")
capital_inicial = float(capital_inicial_str)

taxa_juros_anual_str = input("Digite a taxa de juros anual (%): ")

taxa_juros_anual = float(taxa_juros_anual_str)

periodo_investimento_str = input("Digite o período de investimento (em

anos): ")
periodo_investimento = int(periodo_investimento_str)

# Converte a taxa de juros anual para decimal

taxa_juros_decimal = taxa_juros_anual / 100

# Calcula o montante final usando juros compostos

montante_final = capital_inicial * (1 + taxa_juros_decimal) **
periodo_investimento

# Exibe o montante final

print("O montante final do investimento será de R$", montante_final)

Operadores Relacionais

# Exemplo demonstrando todos os operadores relacionais em Python

# Declaração de variáveis
numero_um = 10
numero_dois = 5

# Igualdade
if numero_um == numero_dois:
print("Os números são iguais")
else:
print("Os números são diferentes")

# Desigualdade
if numero_um != numero_dois:
print("Os números são diferentes")
else:
print("Os números são iguais")

# Maior que
if numero_um > numero_dois:
print("O primeiro número é maior que o segundo")
else:
print("O primeiro número não é maior que o segundo")

# Menor que
if numero_um < numero_dois:
print("O primeiro número é menor que o segundo")
else:
print("O primeiro número não é menor que o segundo")

# Maior ou igual a
if numero_um >= numero_dois:
print("O primeiro número é maior ou igual ao segundo")
else:
print("O primeiro número não é maior ou igual ao segundo")

# Menor ou igual a
if numero_um <= numero_dois:
print("O primeiro número é menor ou igual ao segundo")
else:
print("O primeiro número não é menor ou igual ao segundo")

Expressões Lógicas

# Exemplo demonstrando expressões lógicas em Python

# Declaração de variáveis
idade = 25
tem_cartao = True
renda_mensal = 3000

# Expressão lógica com 'and'

if idade >= 18 and tem_cartao:
print("Pode fazer compras com o cartão")

# Expressão lógica com 'or'

if idade < 18 or renda_mensal > 2000:
print("Você não é um adulto financeiramente independente")

# Expressão lógica com 'not'

if not tem_cartao:
print("Você não tem cartão")

# Combinação de expressões lógicas

if idade >= 18 and (renda_mensal > 2000 or tem_cartao):
print("Você é elegível para solicitar um empréstimo")
else:
print("Você não é elegível para solicitar um empréstimo")

Praticando

# Algoritmo para calcular o lucro líquido de uma empresa e verificar se

atingiu a meta de lucro

# Solicitação de entrada de dados do usuário

receita_total = float(input("Digite a receita total da empresa: "))
custos_fixos = float(input("Digite o total dos custos fixos da empresa:
"))
impostos = float(input("Digite o total dos impostos pagos pela empresa:
"))
despesas_operacionais = float(input("Digite o total das despesas
operacionais da empresa: "))
meta_lucro = float(input("Digite a meta de lucro da empresa: "))

# Cálculo do lucro líquido

lucro_bruto = receita_total - custos_fixos
lucro_operacional = lucro_bruto - despesas_operacionais
lucro_liquido = lucro_operacional - impostos

# Verificação se a meta de lucro foi atingida

atingiu_meta_lucro = lucro_liquido >= meta_lucro
# Exibição dos resultados
print("Lucro bruto: R$", lucro_bruto)
print("Lucro operacional: R$", lucro_operacional)
print("Lucro líquido: R$", lucro_liquido)

if atingiu_meta_lucro:
print("Parabéns! A empresa atingiu a meta de lucro.")
else:
print("A empresa não atingiu a meta de lucro. Mais esforços são
necessários para alcançá-la.")
Aula 4: Estrutura de Decisão - IF/ELSE
● Tomada de decisão simples com if.
● Tomada de decisão encadeada com if-elif-else.
● Tomada de decisão composta.

Objetivo da Aula: Compreender e aplicar estruturas de decisão em Python.

Condições em Python e Declarações If

Python suporta as condições lógicas usuais da matemática:

● Igual: a == b
● Diferente: a != b
● Menor que: a < b
● Menor ou igual a: a <= b
● Maior que: a > b
● Maior ou igual a: a >= b

Essas condições podem ser utilizadas de várias maneiras, mais comumente em

"declarações if" e loops.

Uma "declaração if" é escrita usando a palavra-chave if.

# Nota do estudante na disciplina de Matemática

nota_matematica = 7.5

# Verificando a nota e exibindo uma mensagem correspondente

if nota_matematica >= 9.0:
print("Parabéns! Você obteve uma nota excelente em Matemática.")
elif 7.0 <= nota_matematica < 9.0:
print("Você foi muito bem em Matemática.")
elif 5.0 <= nota_matematica < 7.0:
print("Você foi aprovado em Matemática, mas pode melhorar.")
else:
print("Infelizmente, você não atingiu a nota mínima em Matemática.
Estude mais para o próximo exame.")

Abreviação de if - Operadores Ternários

# Número para verificar se é par ou ímpar

numero = 10

# Verificando se o número é par ou ímpar usando Short Hand If

resultado = "par" if numero % 2 == 0 else "ímpar"
 # Exibindo o resultado
print(f"O número {numero} é {resultado}.")

Na forma convencional:

# Número para verificar se é par ou ímpar

numero = 10

# Verificando se o número é par ou ímpar

if numero % 2 == 0:
resultado = "par"
else:
resultado = "ímpar"

# Exibindo o resultado
print(f"O número {numero} é {resultado}.")

Instrução if else de uma linha, com 3 condições:

# Idades das pessoas

idade_pessoa1 = 25
idade_pessoa2 = 30

# Comparando as idades e imprimindo uma mensagem correspondente

print("Pessoa 1 é mais nova") if idade_pessoa1 < idade_pessoa2 else
print("As idades são iguais") if idade_pessoa1 == idade_pessoa2 else
print("Pessoa 1 é mais velha")

A palavra-chave and é um operador lógico e é usada para combinar instruções

condicionais:

a = 200
b = 33
c = 500

if a > b and c > a:

print("Ambas as condições são verdadeiras")

A palavra-chave or é um operador lógico e é usada para combinar instruções condicionais:

# Notas do estudante em duas disciplinas

nota_matematica = 7.5
nota_fisica = 5.8
 # Verificando se o estudante passou em pelo menos uma das disciplinas
if nota_matematica >= 6 or nota_fisica >= 6:
print("O estudante passou em pelo menos uma das disciplinas.")
else:
print("O estudante não passou em nenhuma das disciplinas.")

A palavra-chave not é um operador lógico e é usada para reverter o resultado da instrução

condicional:

# Estado do aplicativo
aplicativo_fora_do_ar = False

# Verificando se o aplicativo está online

if not aplicativo_fora_do_ar:
print("O aplicativo está online. Não é necessário tomar medidas
corretivas.")
else:
print("O aplicativo está fora do ar. Medidas corretivas estão sendo
tomadas.")

Você pode ter ifinstruções dentro ifde instruções, isso é chamado de instruções aninhadas .
if

x = 41

if x > 10:
print("Acima de dez,")

if x > 20:
print("e também acima de 20!")
else:
print("mas não acima de 20.")

As instruções if não podem estar vazias, mas se por algum motivo você tiver uma instrução
if sem conteúdo, coloque-a na instrução pass para evitar erros.

# Definindo os limites
limite_inferior = 10
limite_superior = 50

# Número a ser verificado

numero = 30
# Verificando se o número está dentro dos limites
if limite_inferior < numero < limite_superior:
pass

Exemplo prático

# Informações sobre o funcionário

experiencia_anos = 5
avaliacao_desempenho = 8.5
aviso_previo = False

# Critérios para elegibilidade da promoção

experiencia_minima = 3
desempenho_minimo = 8.0

# Verificando se o funcionário é elegível para a promoção

if (experiencia_anos >= experiencia_minima or avaliacao_desempenho >=
desempenho_minimo) and not aviso_previo:
print("Parabéns! Você é elegível para a promoção.")
elif experiencia_anos >= experiencia_minima:
if not aviso_previo:
print("Seu desempenho ainda não atingiu o nível mínimo para a
promoção.")
else:
print("Você está em aviso prévio. Não é elegível para a promoção
no momento.")
elif avaliacao_desempenho >= desempenho_minimo:
if not aviso_previo:
print("Você precisa de mais experiência para ser considerado
para a promoção.")
else:
print("Você está em aviso prévio. Não é elegível para a promoção
no momento.")
else:
print("Você não atende aos critérios mínimos para a promoção.")
Aula 5: Estrutura de Decisão - SWITCH/CASE
● Alternativas para simular switch/case em Python.

Objetivo da Aula: Explorar técnicas para implementar seleção múltipla em Python.

O SWITCH/CASE é uma estrutura de controle que permite selecionar uma entre várias
alternativas com base no valor de uma expressão. Ele simplifica o código, tornando-o mais
legível e eficiente, especialmente em situações onde há múltiplas opções de caminho a
serem seguidos.

Não existe uma estrutura de SWITCH/CASE direta em Python porque a filosofia da

linguagem Python favorece a simplicidade e a legibilidade do código. Em vez disso, Python
oferece alternativas, como o uso de dicionários, funções ou classes, que podem alcançar
resultados semelhantes ao SWITCH/CASE de outras linguagens. Essas abordagens
mantêm o código Python limpo e fácil de entender, sem a necessidade de adicionar uma
estrutura de controle adicional.

Utilizando dicionário

# Exemplo 1: Utilizando dicionário

def case_1(opcao):
switch = {
1: "Opção 1 selecionada",
2: "Opção 2 selecionada",
3: "Opção 3 selecionada"
}
return switch.get(opcao, "Opção inválida")

print(case_1(2)) # Saída: Opção 2 selecionada

`switch.get(opcao, "Opção inválida")` significa que o método `get` é chamado no dicionário

`switch` com a chave `opcao`. Se essa chave existir no dicionário, o método `get` retornará
o valor correspondente a essa chave. Se a chave não existir, o método `get` retornará o
valor padrão fornecido como segundo argumento, neste caso, "Opção inválida". Isso
permite lidar com o caso em que a opção fornecida não está presente no dicionário.

Utilizando funções

# Exemplo 2: Utilizando funções

def case_2(opcao):
def opcao_1():
return "Opção 1 selecionada"

def opcao_2():
return "Opção 2 selecionada"
 def opcao_3():
return "Opção 3 selecionada"

switch = {
1: opcao_1,
2: opcao_2,
3: opcao_3
}

func = switch.get(opcao, lambda: "Opção inválida")

return func()

print(case_2(3)) # Saída: Opção 3 selecionada

Utilizando classes

# Exemplo 3: Utilizando classes

class Switch:
def opcao_1(self):
return "Opção 1 selecionada"

def opcao_2(self):
return "Opção 2 selecionada"

def opcao_3(self):
return "Opção 3 selecionada"

def default(self):
return "Opção inválida"

def switch(self, opcao):

method_name = 'opcao_' + str(opcao)
method = getattr(self, method_name, self.default)
return method()

switch_instance = Switch()
print(switch_instance.switch(1)) # Saída: Opção 1 selecionada

`self`: é uma referência à própria instância da classe em métodos de instância, permitindo o

acesso aos atributos e métodos dessa instância.
`getattr`: é uma função embutida que retorna o valor de um atributo de um objeto,
especificado pelo seu nome, ou retorna um valor padrão se o atributo não existir.
`self.default`: chama o método `default` da própria instância da classe `Switch`.

Utilizando módulos
 # Exemplo 4: Utilizando módulos
def opcao_1():
return "Opção 1 selecionada"

def opcao_2():
return "Opção 2 selecionada"

def opcao_3():
return "Opção 3 selecionada"

def default():
return "Opção inválida"

def switch(opcao):
switcher = {
1: opcao_1,
2: opcao_2,
3: opcao_3
}
func = switcher.get(opcao, default)
return func()

print(switch(2)) # Saída: Opção 2 selecionada

Utilizando match

# Exemplo 5: uso do Match

def escolha(dia):
match dia:
case 1:
return "Número 1"
case 2:
return "Número 2"
case 3:
return "Número 3"
case _:
return "Valor inválido"

Lambda

Uma função lambda é uma pequena função anônima.

Ela pode receber qualquer número de argumentos, mas só pode conter uma expressão.

Sintaxe:
lambda argumentos: expressão

# Adiciona 5 ao argumento a e retorna o resultado:

x = lambda a: a + 5
print(x(8)) # Saída: 13

# Multiplica o argumento a pelo argumento b e retorna o resultado:

x = lambda a, b: a * b
print(x(5, 6)) # Saída: 30

# Soma os argumentos a, b e c e retorna o resultado:

x = lambda a, b, c: a + b + c
print(x(5, 6, 2)) # Saída: 13

Por que usar Funções Lambda?

O poder das lambdas é melhor demonstrado quando você as utiliza como uma função
anônima dentro de outra função.

Por exemplo, suponha que você tenha uma definição de função que recebe um argumento,
e esse argumento será multiplicado por um número desconhecido:

# Definindo a função myfunc que retorna uma função lambda para

multiplicar o argumento pelo valor n
def myfunc(n):
return lambda a: a * n

# Criando uma função que sempre dobra o número fornecido

meudobro = myfunc(2)

# Testando a função criada

print(meudobro(11)) # Saída: 22

# Definindo a função myfunc que retorna uma função lambda para

multiplicar o argumento pelo valor n
def myfunc(n):
return lambda a: a * n

# Criando uma função que dobra o número fornecido

meudobro = myfunc(2)
# Criando uma função que triplica o número fornecido
meutriplo = myfunc(3)
# Testando as funções criadas
print(meudobro(11)) # Saída: 22
print(meutriplo(11)) # Saída: 33

Praticando

# Função para calcular o lucro ou prejuízo

def calcular_lucro_prejuizo(preco_compra, preco_venda):
resultado = preco_venda - preco_compra
if resultado > 0:
return "Lucro de ${:.2f}".format(resultado)
elif resultado < 0:
return "Prejuízo de ${:.2f}".format(abs(resultado))
else:
return "Sem lucro nem prejuízo"

# Dicionário contendo os dados da transação

transacao = {
"preco_compra": float(input("Digite o preço de compra: ")),
"preco_venda": float(input("Digite o preço de venda: "))
}

# Função lambda para calcular a porcentagem de lucro ou prejuízo

calcular_porcentagem = lambda preco_compra, preco_venda: ((preco_venda -
preco_compra) / preco_compra) * 100

# Chamada da função para calcular lucro ou prejuízo

print(calcular_lucro_prejuizo(transacao["preco_compra"],
transacao["preco_venda"]))

# Chamada da expressão lambda para calcular a porcentagem de lucro ou

prejuízo
print("Porcentagem de lucro/prejuízo:
{:.2f}%".format(calcular_porcentagem(transacao["preco_compra"],
transacao["preco_venda"])))
Aula 6: Estrutura de Repetição - Acumuladores e Contadores
● Uso de acumuladores e contadores.

Objetivo da Aula: Aprender a utilizar acumuladores e contadores em estruturas de

repetição.

Loop For

O loop for em Python é usado para iterar sobre uma sequência, que pode ser uma lista,
uma tupla, um dicionário, um conjunto ou uma string. Ele funciona como um método de
iterador encontrado em outras linguagens de programação orientadas a objetos. Com o loop
for, podemos executar um conjunto de instruções uma vez para cada item em uma lista,
tupla, conjunto, etc.

Exemplo de loop for

# Lista de frutas
frutas = ["maçã", "banana", "cereja"]

# Iteração sobre cada fruta na lista

for fruta in frutas:
# Imprime o nome da fruta
print(fruta)

Iterando através de uma string

Até mesmo strings são objetos iteráveis, pois contêm uma sequência de caracteres:

Itere através das letras na palavra "banana":

# Iteração sobre cada letra na palavra "banana"

for letra in "banana":
# Imprime a letra
print(letra)

Acumuladores e Contadores

● Acumulador: Uma variável usada para somar valores ao longo de várias iterações
em uma estrutura de repetição.
● Contador: Uma variável usada para contar o número de vezes que uma condição é
atendida durante as iterações em uma estrutura de repetição.
Contador Simples

# Exemplo de contador simples

contador = 0

for i in range(1, 11): # Loop de 1 a 10

contador += 1

print("O contador é:", contador)

Acumulador Simples

# Exemplo de acumulador simples

soma = 0

for i in range(1, 6): # Loop de 1 a 5

soma += i # Acumula o valor de i na variável soma

print("A soma é:", soma)

Contador com Condição

# Exemplo de contador com condição

contador_pares = 0

for i in range(1, 11): # Loop de 1 a 10

if i % 2 == 0: # Verifica se o número é par
contador_pares += 1 # Incrementa o contador

print("O número de pares é:", contador_pares)

Acumulador com Condição

# Exemplo de acumulador com condição

soma_impares = 0

for i in range(1, 11): # Loop de 1 a 10

if i % 2 != 0: # Verifica se o número é ímpar
soma_impares += i # Acumula o valor de i na variável
soma_impares

print("A soma dos ímpares é:", soma_impares)

Contador com Entrada do Usuário

# Exemplo de contador com entrada do usuário

limite = int(input("Digite um número limite: "))
contador = 0

for i in range(1, limite + 1): # Loop até o número limite digitado pelo
usuário
contador += 1

print("O contador é:", contador)

Acumulador com Entrada do Usuário

# Exemplo de acumulador com entrada do usuário

limite = int(input("Digite um número limite: "))
soma = 0

for i in range(1, limite + 1): # Loop até o número limite digitado pelo
usuário
soma += i # Acumula o valor de i na variável soma

print("A soma é:", soma)

Exemplo prático

# Simulação de cálculo do número médio de consultas por paciente em um

período de tempo

# Pergunta ao usuário o número de pacientes

num_pacientes = int(input("Digite o número de pacientes: "))

# Inicializa o acumulador para o número total de consultas

total_consultas = 0

# Inicializa o contador para o número total de pacientes que realizaram

consultas
pacientes_com_consultas = 0

for paciente in range(1, num_pacientes + 1): # Loop de 1 até o número

de pacientes
# Pergunta ao usuário o número de consultas realizadas pelo paciente
consultas_paciente = int(input(f"Digite o número de consultas do
paciente {paciente}: "))
 # Verifica se o paciente realizou pelo menos uma consulta
if consultas_paciente > 0:
# Incrementa o contador de pacientes com consultas
pacientes_com_consultas += 1

# Acumula o número total de consultas

total_consultas += consultas_paciente

# Calcula o número médio de consultas por paciente

if pacientes_com_consultas > 0:
media_consultas_por_paciente = total_consultas /
pacientes_com_consultas
else:
media_consultas_por_paciente = 0

print("\nResumo:")
print("Número total de consultas:", total_consultas)
print("Número de pacientes com consultas:", pacientes_com_consultas)
print("Número médio de consultas por paciente:",
media_consultas_por_paciente)
Aula 7: Estrutura de Repetição - Contada
● Estrutura de repetição contada (for loop).

Objetivo da Aula: Dominar o uso do loop for para repetição em Python.

Uma estrutura de repetição contada em Python é um tipo de loop onde você especifica
um contador ou uma variável de controle para controlar o número de vezes que o loop é
executado. A estrutura de repetição mais comum para isso em Python é o loop for, embora
você também possa usar o loop while com uma variável de controle.

for i in range(5): # começa de 0 e vai até 4

print(i)

Estrutura de repetição com uma lista

# Lista de números
numeros = [1, 2, 3, 4, 5]

# Loop for para percorrer cada elemento da lista

for numero in numeros:
print(numero)

Estrutura de repetição com um dicionário:

# Dicionário de frutas e suas quantidades

frutas = {'maçã': 5, 'banana': 3, 'laranja': 4}

# Loop for para percorrer as chaves (frutas) do dicionário

for fruta in frutas:
print(fruta + ':', frutas[fruta])

Estrutura de repetição com uma tupla

# Tupla de cores
cores = ('vermelho', 'azul', 'verde', 'amarelo')

# Loop for para percorrer cada elemento da tupla

for cor in cores:
print(cor)

Explicando os tipos de dados apresentados:

Lista:
Uma lista em Python é uma estrutura de dados ordenada e mutável que permite armazenar
uma coleção de elementos. Os elementos em uma lista podem ser de diferentes tipos de
dados e são acessados por meio de índices inteiros. As listas são definidas usando
colchetes []. Além disso, as listas suportam uma variedade de métodos que podem ser
utilizados para adicionar, remover, ordenar e modificar elementos.

# Definição da lista
lista = [1, 2, 3, 4, 5]

# Adicionando um elemento ao final da lista

lista.append(6)

# Removendo o último elemento da lista

lista.pop()

# Ordenando a lista
lista.sort()

print(lista) # Saída: [1, 2, 3, 4, 5]

Tupla:

Uma tupla em Python é uma estrutura de dados ordenada e imutável que permite
armazenar uma coleção de elementos. Assim como as listas, os elementos em uma tupla
podem ser de diferentes tipos de dados e são acessados por meio de índices inteiros. As
tuplas são definidas usando parênteses (). Apesar de serem imutáveis, as tuplas ainda
oferecem métodos que permitem a manipulação de dados.

# Definição da tupla
tupla = (1, 2, 3, 4, 5)

# Encontrando o índice de um elemento

indice = tupla.index(3)

# Contando o número de ocorrências de um elemento

contagem = tupla.count(2)

print(indice, contagem) # Saída: 2 1

Dicionário:

Um dicionário em Python é uma estrutura de dados não ordenada que mapeia chaves
únicas para valores associados. Os elementos em um dicionário são acessados por suas
chaves e não por índices. Os dicionários são definidos usando chaves {} e têm a sintaxe
chave: valor. Os dicionários oferecem métodos para adicionar, remover e acessar
elementos, bem como para realizar operações de iteração sobre as chaves, valores ou
itens.

# Definição do dicionário
dicionario = {'nome': 'João', 'idade': 30, 'cidade': 'São Paulo'}

# Acessando o valor de uma chave

nome = dicionario['nome']

# Adicionando um novo par chave-valor

dicionario['email'] = '[email protected]'

# Removendo um par chave-valor

idade = dicionario.pop('idade')

print(nome, idade) # Saída: João 30

For aninhado

Um loop `for` aninhado em Python é quando um loop `for` é colocado dentro de outro. Isso
é útil para iterar sobre estruturas de dados bidimensionais, como matrizes, ou realizar
operações complexas em conjuntos de dados multidimensionais. Cada iteração do loop
externo dispara uma série de iterações do loop interno, permitindo acesso sistemático a
cada elemento da estrutura de dados em diferentes níveis de profundidade. Isso simplifica a
implementação de algoritmos complexos em Python.

Tabuleiro de xadrez:

# Tamanho do tabuleiro de xadrez

tamanho = 8

# Loop for para as linhas

for linha in range(tamanho):
# Loop for para as colunas
for coluna in range(tamanho):
# Se a soma dos índices da linha e da coluna for par, a casa é
preta, caso contrário, é branca
if (linha + coluna) % 2 == 0:
print("□", end=" ") # Casa branca
else:
print("■", end=" ") # Casa preta
print() # Nova linha após cada linha do tabuleiro

Produto de matriz:
# Duas matrizes
matriz1 = [[1, 2, 3],
[4, 5, 6],
[7, 8, 9]]

matriz2 = [[9, 8, 7],

[6, 5, 4],
[3, 2, 1]]

# Inicialização da matriz resultante

resultado = [[0, 0, 0],
[0, 0, 0],
[0, 0, 0]]

# Loop for para as linhas

for i in range(len(matriz1)):
# Loop for para as colunas
for j in range(len(matriz2[0])):
# Loop for para a multiplicação e soma dos elementos
for k in range(len(matriz2)):
resultado[i][j] += matriz1[i][k] * matriz2[k][j]

# Imprimindo o resultado
for linha in resultado:
print(linha)

Exemplos:

# Solicita ao usuário que insira um número inteiro

N = int(input("Insira um número inteiro positivo: "))

# Variável para armazenar a soma dos números naturais

soma = 0

# Loop for para iterar de 1 até N (inclusive)

for i in range(1, N + 1):
soma += i # Adiciona o número atual à soma

# Imprime a soma dos primeiros N números naturais

print("A soma dos primeiros", N, "números naturais é:", soma)

# Lista de dicionários representando informações de funcionários

funcionarios = [
{"nome": "João", "cargo": "Analista", "idade": 28},
{"nome": "Maria", "cargo": "Gerente", "idade": 35},
 {"nome": "Pedro", "cargo": "Analista", "idade": 30}
]

# Cargo que queremos verificar

cargo_desejado = "Analista"

# Loop for para iterar sobre a lista de funcionários

for funcionario in funcionarios:
# Itera sobre as chaves e valores de cada dicionário
for chave, valor in funcionario.items():
# Verifica se o cargo do funcionário é o desejado
if chave == "cargo" and valor == cargo_desejado:
print(f"{funcionario['nome']} é um {cargo_desejado}.")
break # Encerra o loop interno se o cargo for encontrado
else:
# Se o loop interno terminar sem encontrar o cargo desejado
print(f"{funcionario['nome']} não é um {cargo_desejado}.")
Aula 8: Estrutura de Repetição - Pré-condição
● Estrutura de repetição com pré-condição (while loop).

Objetivo da Aula: Utilizar o loop while para repetição com pré-condição.

Python possui dois comandos de laço primitivos:

● while loops (laços enquanto)

● for loops (laços para)

Vamos adicionar mais algumas informações sobre cada tipo de loop:

Laços while: Estes laços executam um bloco de código repetidamente enquanto uma
condição especificada for verdadeira. É importante garantir que a condição de parada seja
eventualmente alcançada para evitar loops infinitos.

Laços for: Estes laços iteram sobre uma sequência (como uma lista, tupla, conjunto ou
string) e executam um bloco de código para cada elemento da sequência. São
frequentemente utilizados quando se conhece antecipadamente a quantidade de iterações
necessárias.

Demonstração de um loop while simples

# Inicializando a variável de controle

contador = 1

# Definindo a condição de parada do loop

while contador < 6:
# Imprimindo o valor atual do contador
print("O valor atual do contador é:", contador)

# Atualizando o contador para a próxima iteração

contador += 1

# Após o loop, exibindo uma mensagem de conclusão

print("O loop while foi encerrado!")

A declaração `break`

Com a declaração `break`, podemos interromper o loop mesmo que a condição do while
seja verdadeira.

Vamos expandir um pouco mais sobre como usar o `break` em loops:

A declaração `break` é útil quando queremos sair de um loop antes que a condição de
parada normal seja alcançada. Isso pode ser útil quando, por exemplo, estamos procurando
por um certo valor em uma lista e queremos parar assim que o valor for encontrado, ou
quando estamos em um loop infinito e queremos sair dele com base em uma condição
específica.

Demonstração do uso da declaração 'break' em um loop while

# Inicializando a variável de controle

contador = 1

# Definindo a condição de parada do loop

while contador < 6:
# Imprimindo o valor atual do contador
print("O valor atual do contador é:", contador)

# Verificando se o contador atingiu o valor desejado para

interromper o loop
if contador == 3:
print("O loop foi interrompido porque o contador atingiu o valor
3!")
break

# Atualizando o contador para a próxima iteração

contador += 1

# Após o loop, exibindo uma mensagem de conclusão

print("O loop while foi encerrado!")

Verificação da hora:

import time
time.strftime('%X')

Interrupção de senhas pelo horário:

import time
senha = 1

while senha < 100000:

print("Senha:", senha)

if time.strftime('%X') >= "12:15:30":

print("Loop interrompido")
break
 senha = senha + 1 # senha += 1

print("Loop encerrado!")

A declaração `continue`

Com a declaração `continue`, podemos interromper a iteração atual e continuar com a

próxima:

Vamos expandir um pouco mais sobre como usar o `continue` em loops:

A declaração `continue` é útil quando queremos pular uma iteração específica do loop e
continuar com a próxima iteração. Isso pode ser útil, por exemplo, quando estamos
processando uma lista e queremos pular elementos que não atendem a certos critérios, ou
quando queremos ignorar certos valores em um loop.

Demonstração do uso da declaração 'continue' em um loop while

# Inicializando a variável de controle

contador = 0

# Definindo a condição de parada do loop

while contador < 6:
# Incrementando o contador para a próxima iteração
contador += 1

# Verificando se o contador é igual a 3

if contador == 3:
# Se o contador for igual a 3, continuamos para a próxima
iteração sem executar o restante do código dentro do loop
continue

# Se o contador não for igual a 3, imprimimos o valor atual do

contador
print("O valor atual do contador é:", contador)

# Após o loop, exibindo uma mensagem de conclusão

print("O loop while foi encerrado!")
A declaração `else`

Com a declaração `else`, podemos executar um bloco de código uma vez quando a
condição do loop não for mais verdadeira:

Vamos expandir um pouco mais sobre como usar o `else` em loops:

A declaração `else` em um loop é executada uma vez após a conclusão normal do loop, ou
seja, quando a condição do loop se torna falsa. Isso é útil quando queremos executar um
bloco de código após o loop ser concluído, mas apenas se o loop não for interrompido
prematuramente por uma declaração `break`.

Demonstração do uso da declaração 'else' em um loop while

# Inicializando a variável de controle

contador = 1

# Definindo a condição de parada do loop

while contador < 6:
# Imprimindo o valor atual do contador
print("O valor atual do contador é:", contador)

# Atualizando o contador para a próxima iteração

contador += 1
else:
# Quando a condição do loop não for mais verdadeira, este bloco de
código será executado uma vez
print("O contador não é mais menor que 6")

Exemplo Prático

# Simulação da venda de ingressos para um cinema

# Capacidade máxima do cinema

capacidade_maxima = 50

# Inicializando o contador de ingressos vendidos

ingressos_vendidos = 0

# Loop enquanto houver ingressos disponíveis

while ingressos_vendidos < capacidade_maxima:
# Verificando a disponibilidade de lugares
lugares_disponiveis = capacidade_maxima - ingressos_vendidos
print("Lugares disponíveis:", lugares_disponiveis)
 # Solicitando ao usuário a quantidade de ingressos desejados
quantidade_ingressos = int(input("Quantos ingressos você deseja
comprar? (Digite 0 para sair): "))

# Verificando se o usuário deseja sair

if quantidade_ingressos == 0:
print("Saindo...")
break

# Verificando se há ingressos suficientes disponíveis

if quantidade_ingressos > lugares_disponiveis:
print("Desculpe, não há ingressos suficientes disponíveis.")
continue

# Vendendo os ingressos
print("Vendendo", quantidade_ingressos, "ingressos...")
ingressos_vendidos += quantidade_ingressos

# Verificando se todos os ingressos foram vendidos

if ingressos_vendidos == capacidade_maxima:
print("Todos os ingressos foram vendidos!")
break
else:
# Se todos os ingressos foram vendidos, exibimos uma mensagem
print("Todos os ingressos foram vendidos!")

Contagem regressiva

# Contagem regressiva
numero = 5

print("Contagem regressiva iniciada:")

while numero >= 0:
print(numero)
numero -= 1
print("Fogo!")

Adivinhe o número

# Jogo de adivinhação
numero_secreto = 7
palpite = 0

print("Bem-vindo ao jogo de adivinhação!")

while palpite != numero_secreto:
 palpite = int(input("Adivinhe o número secreto (entre 1 e 10): "))
print("Parabéns! Você acertou o número secreto:", numero_secreto)

import random
numero_secreto = random.randint(1, 10)
palpite = 0

print("Bem-vindo ao jogo de adivinhação")

while palpite != numero_secreto:

palpite = int(input("Qual o seu palpite? (1 a 10):"))

print("Parabéns você acertou!")

Soma de números pares

soma = 0
numero = 1

while numero <= 10:

if numero % 2 == 0:
soma += numero
numero += 1

print("A soma dos números pares de 1 a 10 é:", soma)

soma = 0
numero = 1
maximo = int(input("Digite o número:"))

while numero <= maximo:

if numero % 2 == 0:
soma += numero
numero += 1

print(f"A soma dos numeros pares de 1 a {maximo} é: {soma}")

Lista de compras

lista_de_compras = []
print("Bem-vindo à lista de compras!")
while True:
item = input("Digite um item para adicionar à lista (ou digite 'fim'
para sair): ")
if item.lower() == 'fim':
break
lista_de_compras.append(item)

print("Sua lista de compras final é:")

for item in lista_de_compras:
print("- " + item)

Lista de compras em um dicionário

# Lista de compras em um dicionário de usuários

# Inicializando o dicionário de usuários

listas_de_compras = {}

while True:
# Solicitando ao usuário seu nome
nome_usuario = input("Digite seu nome (ou digite 'fim' para sair):
")

# Verificando se o usuário deseja sair

if nome_usuario.lower() == 'fim':
break

# Inicializando a lista de compras do usuário

lista_do_usuario = []

print(f"Bem-vindo(a) à lista de compras, {nome_usuario}!")

while True:
# Solicitando ao usuário que adicione um item à sua lista de
compras
item = input("Digite um item para adicionar à sua lista (ou
digite 'fim' para finalizar): ")

# Verificando se o usuário deseja finalizar sua lista de compras

if item.lower() == 'fim':
break
 # Adicionando o item à lista do usuário
lista_do_usuario.append(item)

# Adicionando a lista de compras do usuário ao dicionário de listas

de compras
listas_de_compras[nome_usuario] = lista_do_usuario

# Exibindo as listas de compras de todos os usuários

print("\nListas de compras dos usuários:")
for usuario, lista in listas_de_compras.items():
print(f"\nLista de compras de {usuario}:")
for item in lista:
print("- " + item)
Aula 9: Estrutura de Repetição - Pós-condição
● Estrutura de repetição com pós-condição (do-while loop).
● Técnicas para emular o do-while loop em Python.

Objetivo da Aula: Entender e implementar repetição com pós-condição em Python.

Estrutura de Repetição com Pós-condição (do-while loop):

Em muitas linguagens de programação, existe uma estrutura de repetição chamada

do-while, que executa um bloco de código pelo menos uma vez antes de verificar a
condição. Se a condição for verdadeira, o bloco de código é repetido. Essa estrutura é útil
quando queremos garantir que o bloco de código seja executado pelo menos uma vez.

Técnicas para Emular o do-while loop em Python:

O Python não possui uma estrutura de repetição do-while nativa. No entanto, podemos
emular esse comportamento usando um loop while junto com uma condição de controle. A
ideia básica é usar um while True com uma verificação de condição interna que, se não
satisfeita, usa um break para sair do loop.

Exemplo 1: Lendo um número positivo

# Inicializa a variável
numero = -1

# Emula do-while usando while True

while True:
numero = int(input("Digite um número positivo: "))
# Verifica se o número é positivo
if numero > 0:
break # Sai do loop se a condição for verdadeira

print(f"Você digitou o número positivo: {numero}")

Exemplo 2: Validação de entrada de usuário

# Inicializa a variável
senha = ""

# Emula do-while usando while True

while True:
senha = input("Digite sua senha (mínimo 8 caracteres): ")
# Verifica se a senha tem pelo menos 8 caracteres
if len(senha) >= 8:
break # Sai do loop se a condição for verdadeira

print("Senha válida!")
Exemplo 3: Calculando a soma de números até que o usuário digite zero

# Inicializa a variável
soma = 0

# Emula do-while usando while True

while True:
numero = int(input("Digite um número (0 para sair): "))
soma += numero
# Verifica se o número é zero
if numero == 0:
break # Sai do loop se a condição for verdadeira

print(f"A soma dos números digitados é: {soma}")

Exemplo 4: Contagem regressiva com validação

# Inicializa a variável
contador = 10

# Emula do-while usando while True

while True:
print(f"Contagem: {contador}")
contador -= 1
# Verifica se o contador chegou a zero
if contador <= 0:
break # Sai do loop se a condição for verdadeira

print("Contagem regressiva finalizada!")

Exemplo 5: Jogo de adivinhação

import random

# Inicializa a variável com um número aleatório

numero_secreto = random.randint(1, 10)
tentativa = -1

# Emula do-while usando while True

while True:
tentativa = int(input("Adivinhe o número entre 1 e 10: "))
# Verifica se a tentativa está correta
if tentativa == numero_secreto:
break # Sai do loop se a condição for verdadeira

print("Parabéns! Você adivinhou o número secreto.")

Exemplo 6: Calculando a média de notas

# Inicializa as variáveis
soma_notas = 0
quantidade_notas = 0

# Emula do-while usando while True

while True:
nota = float(input("Digite uma nota (-1 para sair): "))
# Verifica se o usuário quer sair
if nota == -1:
break # Sai do loop se a condição for verdadeira
soma_notas += nota
quantidade_notas += 1

# Verifica se alguma nota foi digitada

if quantidade_notas > 0:
media = soma_notas / quantidade_notas
print(f"A média das notas é: {media}")
else:
print("Nenhuma nota foi digitada.")

Algoritmo para cálculo de nota e construção de gráfico

import matplotlib.pyplot as plt

# Inicializa as variáveis
notas = []
soma_notas = 0
quantidade_notas = 0

# Emula do-while usando while True

while True:
try:
# Lê a nota do usuário
nota = float(input("Digite uma nota entre 0 e 10 (-1 para sair): "))

# Verifica se a nota está no intervalo permitido

if nota < 0 and nota != -1 or nota > 10:
print("Nota inválida. Por favor, digite uma nota entre 0 e 10.")
continue # Volta ao início do loop

# Verifica se o usuário quer sair

if nota == -1:
# Verifica se alguma nota foi digitada antes de sair
if quantidade_notas == 0:
print("Nenhuma nota foi digitada. O programa será encerrado.")
exit()
 break # Sai do loop se a condição for verdadeira

# Adiciona a nota à lista de notas

notas.append(nota)
soma_notas += nota
quantidade_notas += 1
except ValueError:
print("Entrada inválida. Por favor, digite um número válido.")

# Calcula a média das notas

media = soma_notas / quantidade_notas

# Exibe as notas e a média

print(f"As notas digitadas foram: {notas}")
print(f"A média das notas é: {media:.2f}")

# Visualização dos dados com matplotlib

plt.bar(range(1, quantidade_notas + 1), notas, color='blue', alpha=0.7)
plt.axhline(y=media, color='red', linestyle='--', label=f'Média: {media:.2f}')
plt.xlabel('Número da Nota')
plt.ylabel('Nota')
plt.title('Gráfico de Notas dos Alunos')
plt.legend()
plt.show()

Sistema de cálculo de salário

import matplotlib.pyplot as plt

# Inicializa as variáveis
funcionarios = []

# Emula do-while usando while True

while True:
try:
nome = input("Digite o nome do funcionário (ou 'sair' para encerrar): ")
if nome.lower() == 'sair':
if len(funcionarios) == 0:
print("Nenhum funcionário registrado. Encerrando o programa.")
exit()
break # Sai do loop se a condição for verdadeira

horas_trabalhadas = float(input(f"Digite as horas trabalhadas por {nome}: "))

taxa_por_hora = float(input(f"Digite a taxa por hora de {nome} (R$): "))

funcionario = {
'nome': nome,
'horas_trabalhadas': horas_trabalhadas,
 'taxa_por_hora': taxa_por_hora
}

funcionarios.append(funcionario)
except ValueError:
print("Entrada inválida. Por favor, insira valores numéricos válidos.")

# Imprime a folha de pagamento

print("\nFolha de Pagamento")
print("="*30)

# Lista para armazenar dados para o gráfico

nomes = []
salarios_liquidos = []

for func in funcionarios:

# Cálculo do salário bruto
salario_bruto = func['horas_trabalhadas'] * func['taxa_por_hora']

# Cálculo dos descontos (20% de imposto + 5% de contribuição previdenciária)

imposto = 0.20 * salario_bruto
contribuicao_previdenciaria = 0.05 * salario_bruto

# Salário líquido
salario_liquido = salario_bruto - imposto - contribuicao_previdenciaria

# Armazena dados para o gráfico

nomes.append(func['nome'])
salarios_liquidos.append(salario_liquido)

# Exibe os detalhes do funcionário

print(f"Nome: {func['nome']}")
print(f"Salário Bruto: R$ {salario_bruto:.2f}")
print(f"Imposto (20%): R$ {imposto:.2f}")
print(f"Contribuição Previdenciária (5%): R$ {contribuicao_previdenciaria:.2f}")
print(f"Salário Líquido: R$ {salario_liquido:.2f}")
print("="*30)

# Visualização dos dados com matplotlib

plt.bar(nomes, salarios_liquidos, color='blue', alpha=0.7)
plt.xlabel('Funcionários')
plt.ylabel('Salário Líquido (R$)')
plt.title('Salário Líquido dos Funcionários')
plt.xticks(rotation=45)
plt.tight_layout()
plt.show()
Aula 10: Vetores
● Declaração e manipulação de vetores (listas em Python).

Objetivo da Aula: Aprender a trabalhar com vetores em Python.

Aula 11: Leitura e Exibição de Matrizes de uma Dimensão

● Leitura e exibição de vetores em Python.

Objetivo da Aula: Praticar a manipulação de vetores de uma dimensão em Python.

Aula 12: Manipulação de Vetores

● Operações básicas de manipulação de vetores.

Objetivo da Aula: Dominar técnicas avançadas de manipulação de vetores em Python.

Aula 13: Matrizes

● Declaração e manipulação de matrizes (listas de listas) em Python.
Objetivo da Aula: Compreender como trabalhar com matrizes em Python.

Aula 14: Leitura e Exibição de Matrizes de Duas Dimensões

● Leitura e exibição de matrizes de duas dimensões em Python.

Objetivo da Aula: Praticar a manipulação de matrizes em Python.

Aula 15: Manipulação de Matrizes

● Operações básicas de manipulação de matrizes.

Objetivo da Aula: Dominar técnicas avançadas de manipulação de matrizes em Python.

Aula 16: Funções em Python

● Definição e uso de funções em Python.
● Parâmetros e argumentos de função.
● Retorno de valores em funções.
● Escopo de variáveis.

Objetivo da Aula: Compreender o conceito de funções em Python e sua aplicação na

resolução de problemas.