Resumo das Aulas Livres de Algoritmos e Lógica de Programação Básica em Python com Reforço em Matemática

Introdução

Este é um projeto de iniciativa voluntária, sem fins lucrativos, oferecido pelo prof. Daniel, em parceria com uma escola de educação básica pública do estado de Santa Catarina.

O objetivo é o ensino e aprendizado da Linguagem de Programação Python, de modo interdisciplinar, abordando o reforço de Matemática e Língua Portuguesa, conforme demandas expostas pelos alunos. Além disso, serão abordados temas diversos de segurança da informação, mercado de trabalho, inteligência artificial, machine learning, jogos digitais, ciência e filosofia.

As aulas ocorrem no contraturno, uma vez por semana, com duração de até 4 horas, conforme disponibilidade do laboratório de informática.

Neste ano de 2025, sendo a primeira edição do projeto, as aulas tiveram início já no terceiro trimestre, em 5 de setembro. Para 2026, espero poder iniciar o projeto já a partir do primeiro trimestre, dependendo da demanda, disponibilidade de recursos e tempo, bem como parceria com a escola.

Atenção! Este material é um resumo do conteúdo das aulas, portanto, não está completo. Além disso, dado o tempo curto disponível até o término do ano letivo de 2025, não conterá tudo o que se pretende abordar. Meu desejo é que seja aprimorado para o próximo ano, abarcando muito mais assuntos.

Fique à vontade para criticar, elogiar ou sugerir mudanças, correções e novos conteúdos.

Respeite o trabalho intelectual e direitos autorais. Este conteúdo não pode ser distribuído ou compartilhado, em parte ou no todo, sem a devida autorização expressa e por escrito.

Resumo das aulas até 30/10/2025

Versão 1.1-30102025

Capítulo 1 – Introdução à Lógica e ao Pensamento Computacional

Lógica

A lógica pode ser entendida de diferentes formas, dependendo do contexto em que é estudada. De maneira geral, ela é o campo que investiga os princípios e critérios que distinguem um raciocínio correto de um incorreto, ou um argumento válido de um inválido.

A lógica ajuda a analisar e compreender se as ideias estão sendo expressas de forma coerente, clara e fundamentada.

Quando alguém escreve um texto, por exemplo, não está apenas organizando palavras, mas colocando em frases e parágrafos um raciocínio que deverá ser interpretado por um leitor.

Vejamos o exemplo da mensagem abaixo, enviada por alguém querendo transmitir uma informação:

“Percebi um homem filmando a parte da frente da loja com um drone.”

O que a mensagem quer dizer realmente?

Fica difícil ter certeza, pois trata-se de uma frase ambígua, ou seja, pode ser interpretada de duas formas:

1ª. Quem enviou a mensagem estava filmando a parte da frente da loja, com um drone, e percebeu um homem.

2ª. Quem enviou a mensagem está avisando que havia um homem filmando a parte da frente da loja com um drone.

Agora, vamos reescrever a mensagem dessa forma:

“Saí para ir ao mercado e, ao passar pela loja, percebi um homem que estava filmando a parte da frente da loja com um drone.”

Desse novo modo a mensagem é clara e não deixa margens para interpretações equivocadas.

No exemplo anterior, portanto, os princípios e critérios aplicados foram os das regras gramaticais de escrita da Língua Portuguesa.

No estudo da lógica, é importante observar a relação entre causas e efeitos, a estrutura gramatical, a coerência e a precisão das informações transmitidas.

A lógica é a base para a construção de algoritmos e programas de computador. Ela fornece as regras que permitem organizar passos de forma clara e sequencial, estruturar condições de decisão e criar repetições.

A lógica é fundamental para aprender a programar. É a verdadeira habilidade de quem programa bem.

Pensamento Computacional

O pensamento computacional é uma abordagem que busca resolver problemas utilizando ideias, técnicas e conceitos da ciência da computação.

O pensamento computacional é, antes de tudo, um tipo de pensamento humano.

É uma forma de pensar que foi “incorporada” no campo da programação de maneira que máquinas também possam resolver problemas.

Ele envolve o desenvolvimento e gerenciamento de habilidades mentais que permitem “quebrar” ou decompor um problema em partes menores, identificar padrões e abstrair características importantes, removendo o que é desnecessário. Desse modo, cria-se algoritmos com estratégias de solução (ex.: condições e repetições), e, ainda, automatizar ou expressar essas soluções em passos que possam ser executados por um computador.

A figura acima ilustra os quatro pilares do pensamento computacional.

Decomposição: é quebrar um problema em partes menores.

Identificação de padrões: é perceber situações que se repetem, como por exemplo na tabuada de 2, onde o padrão é um incremento de 2 em 2.

Abstração e simplificação: selecionar o que é essencial, ignorar ou simplificar o que não contribui para a solução; a máquina exige precisão.

Algoritmo: é colocar em passos ou etapas a sequência de tarefas para solucionar o problema. A elaboração do algoritmo envolve.

O pensamento sequencial é algo importante mencionar, pois envolve a organização dos passos que devem ser seguidos em uma ordem lógica para atingir um objetivo. Por exemplo, preparar um café:
1) colocar a água para aquecer;
2) pegar o filtro e colocar no suporte;
3) pôr o suporte sobre um bule ou a garrafa;
4) adicionar o pó no filtro;
5) despejar a água quente sobre o pó; etc.

Causa e efeito: é um comportamento do pensamento sequencial, pois cada ação produz uma consequência, que pode gerar um resultado esperado ou inesperado. Ao despejar a água quente sobre o pó, por exemplo, tem como consequência o café.

Laços de Repetição e Automatização: são características importantes do pensamento computacional. Por exemplo, em um algoritmo pode-se definir instruções para que a máquina execute comandos, verificando condições (ex.: se/senão; if/else), repetindo tarefas (ex.: para/faça; repita; for; while), e reagindo a dados de entrada.

Análise, avaliação e testes: precisamos testar a solução elaborada, verificar se funciona, se é eficiente e, se necessário, aplicar ajustes.

Algoritmos e programação

O pensamento humano se transforma em programação quando as ideias, planejamentos e decisões são expressas em forma de algoritmos/códigos (ou pseudocódigos).

Algoritmo pode ser definido como uma sequência finita de passos sequenciais e bem definidos que, se bem executados, atingem um objetivo (realização de tarefas e resolução de problemas). (FORBELLONE, 2022, p. 3).

A lógica humana munida das condições de verificação (“se… então/senão”), comparações, sequência de etapas, repetições (“para… faça, enquanto condição… repita”), é formalizada para que computadores entendam. Ou seja, para programar bem é necessário pensar bem, de modo crítico e lógico para entender o problema, definir quantos e quais passos são necessários, prever exceções e traduzir esse pensamento em uma linguagem que as máquinas entendam.

Representação de Algoritmos

Diagrama de Blocos e Pseudocódigo (Portugol)

Para facilitar o entendimento e a aplicação de algoritmos, existem formas de representá-los de maneira mais visual ou simplificada.

Diagrama de Blocos

Diagrama de blocos (ou fluxograma) é um recurso gráfico que mostra o fluxo de um algoritmo, permitindo visualizar de forma clara cada etapa do processo. Utilizaremos aqui, para simplificar, apenas duas figuras geométricas, o retânculo e o losango.

O retângulo é a figura para comandos simples.

Exemplo de algoritmo somente com comandos simples, onde tem como entrada o valor para dois números, soma os dois números e mostra o resultado no final:

O losango é utilizado para condição de verificação (tomada de decisão) e para instruções de repetição (loops).

Exemplo incluindo a instrução de verificação (se… então/senão):

Agora, as instruções de repetição (“loops” Para… Faça; Enquanto… Faça; Repita… Até; etc):

Exemplos incluindo a condição de repetição (Para… Faça; Enquanto… Faça; Repita… Até; etc):

Pseudocódigo e Portugol

Pseudocódigo é uma forma de simular uma linguagem de programação, utilizando palavras comuns, da língua falada/escrita das pessoas, para estruturar o algoritmo de maneira simplificada e compreensível.
Portugol é uma pseudolinguagem que utiliza palavras da língua portuguesa para criar pseudocódigos, sendo amplamente usada no ensino de lógica de programação.

Palavras (mais comuns) do portugol vistas em aula:

Exemplos de algoritmos com o Portugol.

# Algoritmo soma dois números e exibe o resultado
Var
    numero_1, numero_2, resultado
inicio
    resultado <- numero_1 + numero_2
    escreva “O resultado é: {resultado}”
fim

# Algoritmo soma dois números e exibe o resultado
Var
    numero_1, numero_2, resultado
inicio
    resultado <- numero_1 + numero_2
    escreva “O resultado é: {resultado}”
fim

# Algoritmo para verificar e exibir se um número
# digitado por um usuário é par ou ímpar
Var
    numero
Inicio
    escreva “Digite um número: “
    leia numero
    se numero % 2 == 0 então
        escreva “O número digitado é par.”
    senao
        escreva “O número digitado é ímpar.”
    fimse
fim

# Algoritmo para verificar e exibir se um número
# digitado por um usuário é par ou ímpar
Var
    numero
Inicio
    escreva “Digite um número: “
    leia numero
    se numero % 2 == 0 então
        escreva “O número digitado é par.”
    senao
        escreva “O número digitado é ímpar.”
    fimse
fim

# Algoritmo para criar uma lista com cinco nomes
# de pets e exibir a lista
Var
    nome_pet, lista_nomes
Inicio
    para i de 1 até 5 faca
        escreva “Digite um nome de pet: ”
        leia nome_pet
        insira o nome na lista de nomes {lista_nomes}
    fimpara
    escreva “A lista de nomes é {lista_nomes}”
fim

# Algoritmo para criar uma lista com cinco nomes
# de pets e exibir a lista
Var
    nome_pet, lista_nomes
Inicio
    para i de 1 até 5 faca
        escreva “Digite um nome de pet: ”
        leia nome_pet
        insira o nome na lista de nomes {lista_nomes}
    fimpara
    escreva “A lista de nomes é {lista_nomes}”
fim

# Algoritmo para aquecer a água para fazer o café
Var
    temp_atual_agua, temp_final_agua
inicio
    leia temp_atual_agua
    temp_final_agua <- temp_atual_agua
    enquanto temp_final_agua < 70 faca
        escreva “Aquecendo a água.”
        leia temp_atual_agua
        temp_final_agua <- temp_atual_agua
    fimenquanto
    escreva “A água atingiu os 70ºC. Pode fazer o café.”
Fim

# Algoritmo para aquecer a água para fazer o café
Var
    temp_atual_agua, temp_final_agua
inicio
    leia temp_atual_agua
    temp_final_agua <- temp_atual_agua
    enquanto temp_final_agua < 70 faca
        escreva “Aquecendo a água.”
        leia temp_atual_agua
        temp_final_agua <- temp_atual_agua
    fimenquanto
    escreva “A água atingiu os 70ºC. Pode fazer o café.”
Fim

Capítulo 2 – Programação Básica em Python

Variável

Uma variável aponta para um espaço na memória do computador, onde se guarda um dado que será manipulado ou utilizado durante o processamento do código.

O nome da variável é um rótulo que é “chamado” ou referenciado no código e, assim, o dado da variável, em um endereço específico da memória do computador, poderá ser aplicado.

Os nomes de variáveis só podem conter caracteres alfanuméricos (letras e números), não podem iniciar com um número, não podem conter caracteres especiais, mas podem conter o “_” (underscore).

Variáveis em Python, são de tipagem dinâmica, ou seja, o tipo é caracterizado em tempo real, na medida em que forem criadas.

Em Python, as variáveis são objetos que podem ser do tipo simples ou do tipo estruturado.

Veremos exemplos de variáveis do tipo simples quando abordarmos os tipos de dados, e variáveis do tipo estruturado quando chegarmos em listas, tuplas, conjuntos e dicionários.

Dado e Informação

Dado é um conteúdo bruto ou “solto”, sem sentido. Um elemento que precisa de um contexto para ter significado. Exemplos: ml; 21; 6; “livro”; “água”; 8; “tempo”; etc.

Informação é quando junta-se dados em contexto, adquirindo significado. Exemplo: “Levantar às 6 horas da manhã, depois de 8 horas de sono, e tomar 600ml de água, é excelente para a saúde humana.”

Atribuição

Atribuímos um dado a uma variável utilizando o sinal de igual (=). Ou seja, com o = colocamos um dado “dentro” de uma variável. Para x = 2, o correto é dizer x recebe 2. Não é correto dizer x é igual a 2. Outros exemplos:

medida_L = 'ml'
medida_T = 'hora'

medida_L = 'ml'
medida_T = 'hora'

Tipos de dados

Inteiro (int): -45; -2; -1; 0; 1; 2; 2324; 10; etc. São os números inteiros negativos, zero e positivos.

Exemplos de variáveis do tipo int():

a = 1
b = 0
c = -10
temperatura = -45
idade = 10

a = 1
b = 0
c = -10
temperatura = -45
idade = 10

int()

A função int() também pode ser usada para converter outros tipos de valores ou objetos (variáveis) em inteiros.

Exemplos

a = '22'
b = 1.83
c = True
d = False
print(type(a))  # <class 'str'>
print(type(b))  # <class 'float'>
print(type(c))  # <class 'bool'>
print(type(d))  # <class 'bool'>
a = int(a)
b = int(b)
c = int(c)
d = int(d)
print(type(a)) # <class 'int'>
print(type(b)) # <class 'int'>
print(type(c)) # <class 'int'>
print(type(d)) # <class 'int'>

a = '22'
b = 1.83
c = True
d = False
print(type(a))  # <class 'str'>
print(type(b))  # <class 'float'>
print(type(c))  # <class 'bool'>
print(type(d))  # <class 'bool'>
a = int(a)
b = int(b)
c = int(c)
d = int(d)
print(type(a)) # <class 'int'>
print(type(b)) # <class 'int'>
print(type(c)) # <class 'int'>
print(type(d)) # <class 'int'>

Real ou Decimal (float): -2.73, -0.5, 0.0, 1.1; 3.14; 1.80; 3.666; etc. São os números com ponto flutuante.

Exemplos de variáveis do tipo float():

x = 7.72
numero_pi = 3.14
altura = 1.68

x = 7.72
numero_pi = 3.14
altura = 1.68

float()

A função float() também pode ser usada para converter outros tipos de valores em reais (ou decimais, ou números de ponto flutuante).

Exemplos:

a = '22'
b = 34
c = True
d = False
print(type(a))  # <class 'str'>
print(type(b))  # <class 'int'>
print(type(c))  # <class 'bool'>
print(type(d))  # <class 'bool'>
a = float(a)
b = float(b)
c = float(c)
d = float(d)
print(type(a)) # <class 'float'>
print(type(b)) # <class 'float'>
print(type(c)) # <class 'float'>
print(type(d)) # <class 'float'>

a = '22'
b = 34
c = True
d = False
print(type(a))  # <class 'str'>
print(type(b))  # <class 'int'>
print(type(c))  # <class 'bool'>
print(type(d))  # <class 'bool'>
a = float(a)
b = float(b)
c = float(c)
d = float(d)
print(type(a)) # <class 'float'>
print(type(b)) # <class 'float'>
print(type(c)) # <class 'float'>
print(type(d)) # <class 'float'>

Caractere ou string (str): “689”; “ml”; “hora”; “livro”; “João”; etc. São cadeias de caracteres, palavras, textos que SEMPRE estarão entre áspas. Um número entre áspas também é uma string.

Exemplos de variáveis do tipo str():

peso = "70kg"
idade = “33”
altura = "centímetros"
nome = "Elon"
linguagem = "Python"

peso = "70kg"
idade = “33”
altura = "centímetros"
nome = "Elon"
linguagem = "Python"

str()

A função str() também pode ser usada para converter outros tipos de valores em strings.

Exemplos:

a = 22
b = 34.83
c = True
d = False
print(type(a))  # <class 'int'>
print(type(b))  # <class 'float'>
print(type(c))  # <class 'bool'>
print(type(d))  # <class 'bool'>
a = str(a)
b = str(b)
c = str(c)
d = str(d)
print(type(a)) # <class 'str'>
print(type(b)) # <class 'str'>
print(type(c)) # <class 'str'>
print(type(d)) # <class 'str'>

a = 22
b = 34.83
c = True
d = False
print(type(a))  # <class 'int'>
print(type(b))  # <class 'float'>
print(type(c))  # <class 'bool'>
print(type(d))  # <class 'bool'>
a = str(a)
b = str(b)
c = str(c)
d = str(d)
print(type(a)) # <class 'str'>
print(type(b)) # <class 'str'>
print(type(c)) # <class 'str'>
print(type(d)) # <class 'str'>

Lógico boolean ou booleano (bool): True; False.

O tipo bool() representa valores lógicos: verdadeiro (True) ou falso (False).

Esses valores são muito usados em condições, comparações e estruturas de decisão, como o if, elif e else.

# Tipo bool pode assumir dois valores:
verdadeiro = True
falso = False

# Tipo bool pode assumir dois valores:
verdadeiro = True
falso = False

bool()

A função bool() também pode ser usada para converter outros tipos de valores em booleanos.

Exemplos:

a = 0
b = 34.83
c = ""
d = "False"
print(type(a))  # <class 'int'>
print(type(b))  # <class 'float'>
print(type(c))  # <class 'str'>
print(type(d))  # <class 'str'>
a = bool(a)
b = bool(b)
c = bool(c)
d = bool(d)
print(type(a)) # <class 'bool'>
print(type(b)) # <class 'bool'>
print(type(c)) # <class 'bool'>
print(type(d)) # <class 'bool'>

a = 0
b = 34.83
c = ""
d = "False"
print(type(a))  # <class 'int'>
print(type(b))  # <class 'float'>
print(type(c))  # <class 'str'>
print(type(d))  # <class 'str'>
a = bool(a)
b = bool(b)
c = bool(c)
d = bool(d)
print(type(a)) # <class 'bool'>
print(type(b)) # <class 'bool'>
print(type(c)) # <class 'bool'>
print(type(d)) # <class 'bool'>

Comandos ou funções vistas

print()

Permite escrever algo na tela.

Exemplos:

print("Olá, mundo")
print("Programar em Python é muito legal!")

print("Olá, mundo")
print("Programar em Python é muito legal!")

Output:
Olá, mundo
Programar em Python é muito legal!

type()

Verificar o tipo de um dado ou uma variável ou objeto.

Exemplos:

print(type(10))
print(type(3.14))
print(type("a"))
print(type(True))
A = 2; B = 3.14; profissao = "rogramador"
print(type(A))
print(type(B))
print(type(profissao))

print(type(10))
print(type(3.14))
print(type("a"))
print(type(True))
A = 2; B = 3.14; profissao = "rogramador"
print(type(A))
print(type(B))
print(type(profissao))

Output:
<class ‘int’>
<class ‘float’>
<class ‘str’>
<class ‘bool’>
<class ‘int’>
<class ‘float’>
<class ‘str’>

input()

Utilizada para a entrada de dados de forma dinâmica por um usuário.

Exemplo 1:

nome = input('Digite um nome: ')
a = int(input('Digite um o valor de a: '))
x = float(input('Digite um valor para x: '))

nome = input('Digite um nome: ')
a = int(input('Digite um o valor de a: '))
x = float(input('Digite um valor para x: '))

Exemplo 2:

# Função do 2º grau ou função quadrática
# Solicitando o valor de x
a = 1
b = -2
c = -3
x = float(input("Digite o valor de x: "))
y = a * x**2 + b * x + c
print(f"x = {x}, f(x) ou y = {y}")

# Função do 2º grau ou função quadrática
# Solicitando o valor de x
a = 1
b = -2
c = -3
x = float(input("Digite o valor de x: "))
y = a * x**2 + b * x + c
print(f"x = {x}, f(x) ou y = {y}")

Output
x = 2.0, f(x) ou y = -3.0

Operadores aritméticos vistos até o momento

Subtração (-); adição (+); multiplicação (*); divisão (/); exponenciação (**)

Fizemos exemplos e práticas similares às abaixo:

# Minha primeira calculadora de somar
a = 2
b = 3
soma = a + b
print("O valor da soma é: ", soma)

# Calculando um número inteiro com um real
a = int(input("Digite um número inteiro: "))
pi = 3.14
resultado = a * pi
print("O resultado é: ", resultado)

# Equações básicas de matemática para ver a precedência de cálculo com parênteses
a = -2
b = 5
c = 2
x = 2
resultado = (a + b) * ((x / c) + a) ** a
mensagem = "O resultado da equação é: "
print(mensagem, resultado)

# Outro cálculo de equação e vefificando a precedência com os parênteses
valor_A = float(input("Por favor, digite o valor para A: "))
valor_B = float(input("Por favor, digite o valor para B: "))
valor_C = float(input("Por favor, digite o valor para C: "))
x = float(input("Por favor, digite o valor para x: "))
mensagem = "O resultado da equação é: "
resultado = (((2 * valor_A + (valor_B - valor_C)) * x) / 3) ** 2
print(mensagem, resultado)

# Minha primeira calculadora de somar
a = 2
b = 3
soma = a + b
print("O valor da soma é: ", soma)

# Calculando um número inteiro com um real
a = int(input("Digite um número inteiro: "))
pi = 3.14
resultado = a * pi
print("O resultado é: ", resultado)

# Equações básicas de matemática para ver a precedência de cálculo com parênteses
a = -2
b = 5
c = 2
x = 2
resultado = (a + b) * ((x / c) + a) ** a
mensagem = "O resultado da equação é: "
print(mensagem, resultado)

# Outro cálculo de equação e vefificando a precedência com os parênteses
valor_A = float(input("Por favor, digite o valor para A: "))
valor_B = float(input("Por favor, digite o valor para B: "))
valor_C = float(input("Por favor, digite o valor para C: "))
x = float(input("Por favor, digite o valor para x: "))
mensagem = "O resultado da equação é: "
resultado = (((2 * valor_A + (valor_B - valor_C)) * x) / 3) ** 2
print(mensagem, resultado)

A instrução ou estrutura de verificação ou decisão if/else

O if (se) é utilizado para fazer algo quando uma condição for verdadeira.

O else (senão) é utilizado para fazer algo quando uma condição for falsa.

Vimos o pseudocódigo para o algoritmo de verificar se um número é par ou ímpar. Foi mostrado o sinal de igualdade em Python, que é ==. Além disso, vimos que quando o resto da divisão de um número por 2 for zero (% 2 == 0), esse número é par. Com isso, foi feita uma pequena revisão de divisão de números em matemática.

Exemplo em pseudocódigo:

# Pseudocódigo para ver se o número é par ou ímpar
var
    numero
Inicio
    escreva “Digite um número: “
    leia numero
    se numero % 2 == 0 então
        escreva “O número digitado é par.”
    senao
        escreva “O número digitado é ímpar.”
    fimse
fim

# Pseudocódigo para ver se o número é par ou ímpar
var
    numero
Inicio
    escreva “Digite um número: “
    leia numero
    se numero % 2 == 0 então
        escreva “O número digitado é par.”
    senao
        escreva “O número digitado é ímpar.”
    fimse
fim

Exemplo em Python:

# Algoritmo para ver se o número é par ou ímpar
num = int(input("Digite um número: "))
if num % 2 == 0:
    print(f"O número digitado foi {num} e ele é par.")
else:
    print(f"O númerodigitado foi {num} e ele é ímpar.")

# Algoritmo para ver se o número é par ou ímpar
num = int(input("Digite um número: "))
if num % 2 == 0:
    print(f"O número digitado foi {num} e ele é par.")
else:
    print(f"O númerodigitado foi {num} e ele é ímpar.")

A instrução ou estrutura de repetição for

O for é usado quando queremos repetir uma ação várias vezes.

Exemplo em Portugol:

var
   numero
inicio
   para numero de 1 ate 5 faca
      escreva("Número: ", numero)
   fimpara
fim

var
   numero
inicio
   para numero de 1 ate 5 faca
      escreva("Número: ", numero)
   fimpara
fim

Exemplos em Python:

Exemplo 1:

# O exemplo acima convertido para Python
for numero in range(1, 6):  # começa em 1 e vai até 5
    print("Número:", numero)

# O exemplo acima convertido para Python
for numero in range(1, 6):  # começa em 1 e vai até 5
    print("Número:", numero)

Output:

Número: 1
Número: 2
Número: 3
Número: 4
Número: 5

Exemplo 2:

# O exemplo acima convertido para Python
for numero in range(1, 6):  # começa em 1 e vai até 5
    print("Número:", numero)

Exemplo 2:
# Função do 2º grau ou função quadrática.
# Calculando os valores de x com for e range().
a = 1
b = -2
c = -3
# x = float(input("Digite o valor de x: "))
for x in range(-5, 6):
    y = a * x**2 + b * x + c
    print(f"x = {x}, f(x) ou y = {y}")

# O exemplo acima convertido para Python
for numero in range(1, 6):  # começa em 1 e vai até 5
    print("Número:", numero)

Exemplo 2:
# Função do 2º grau ou função quadrática.
# Calculando os valores de x com for e range().
a = 1
b = -2
c = -3
# x = float(input("Digite o valor de x: "))
for x in range(-5, 6):
    y = a * x**2 + b * x + c
    print(f"x = {x}, f(x) ou y = {y}")

Output:

x = -5, f(x) ou y = 32
x = -4, f(x) ou y = 21
x = -3, f(x) ou y = 12
x = -2, f(x) ou y = 5
x = -1, f(x) ou y = 0
x = 0, f(x) ou y = -3
x = 1, f(x) ou y = -4
x = 2, f(x) ou y = -3
x = 3, f(x) ou y = 0
x = 4, f(x) ou y = 5
x = 5, f(x) ou y = 12

Instrução de verificação ou decisão if/elif/else

É parecido com a estrutura if/else. A diferenção é que contém a palavra “elif”, que é a junção do “else” com o “if”. Serve para tomar decisões no código, ou seja, fazer com que o programa siga caminhos diferentes dependendo de uma condição ser verdadeira ou falsa.

if (se)→ É a primeira condição.

elif (senão se)→ É a condição alternativa, podendo ter várias.

else (senão) →É a condição última, aquela que deve ser satisfeita caso nenhuma das acima seja verdadeira.

Exemplo 1:

# Algoritmo para ver se é uma cor primária e traduzi-la
# para o inglês.
cor = input("Digite uma cor primária: ")
if cor == "vermelho":
    print(f"{cor} em inglês é red.")
elif cor == "verde":
    print(f"{cor} em inglês é green.")
elif cor == "azul":
    print(f"{cor} em inglês é blue.")
else:
    print(f"Você digitou {cor} e isso não é uma cor primária.")

# Algoritmo para ver se é uma cor primária e traduzi-la
# para o inglês.
cor = input("Digite uma cor primária: ")
if cor == "vermelho":
    print(f"{cor} em inglês é red.")
elif cor == "verde":
    print(f"{cor} em inglês é green.")
elif cor == "azul":
    print(f"{cor} em inglês é blue.")
else:
    print(f"Você digitou {cor} e isso não é uma cor primária.")

Exemplo 2:

# Calular Bhaskara para encontrar as raízes da função.
# Se delta < 0 → não há raízes reais.
# Se delta == 0 → existe uma raiz real.
# Se delta > 0 → existem duas raízes reais distintas.
import math
#a, b, c = 1, -6, 8
delta = b ** 2 - 4 * a * c
print(f"O valor do delta é: {delta}")
if delta < 0:
    print('Não há raízes reais')
elif delta == 0:
    x = -b / 2 * a
    print(f"Apenas uma raiz: x = {x}")
else:
    x1 = -b + math.sqrt(delta) / 2 * a
    x2 = -b - math.sqrt(delta) / 2 * a
    print(f"x1 = {x1}")
    print(f"x2 = {x2}")

# Calular Bhaskara para encontrar as raízes da função.
# Se delta < 0 → não há raízes reais.
# Se delta == 0 → existe uma raiz real.
# Se delta > 0 → existem duas raízes reais distintas.
import math
#a, b, c = 1, -6, 8
delta = b ** 2 - 4 * a * c
print(f"O valor do delta é: {delta}")
if delta < 0:
    print('Não há raízes reais')
elif delta == 0:
    x = -b / 2 * a
    print(f"Apenas uma raiz: x = {x}")
else:
    x1 = -b + math.sqrt(delta) / 2 * a
    x2 = -b - math.sqrt(delta) / 2 * a
    print(f"x1 = {x1}")
    print(f"x2 = {x2}")

Output:

O valor do delta é: 40
x1 = -1.675444679663241
x2 = -14.32455532033676

Objetos (variáveis) do tipo estruturado

Lista –> list() –> um objeto iterável e uma coleção ordenada e mutável de elementos.

Tupla –> tuple() –> um objeto iterável e uma coleção ordenada e imutável de elementos.

Conjunto –> set() –> um objeto iterável e uma coleção desordenada e mutável de elementos únicos.

Dicionário –> dict() –> um objeto iterável e uma coleção ordenada e mutável de elementos.

Obs.: Iterável vem do verbo iterar, que quer dizer reiterar ou repetir. Objeto iterável, então, é um objeto com o qual pode-se ter várias relações. Por exemplo, no caso de strings, listas, tuplas, conjuntos e dicionários, pode-se ter sucessivas relações com os itens contidos nesses objetos.

Listas

Lista –> list() –> um objeto iterável e uma coleção ordenada e mutável de elementos.

Listas são objetos que são estruturas de dados, porque possuem dados estruturados ou organizados dentro delas. Ou seja, os dados ou elementos de uma lista, são indexados e ordenados, embora possam ser de tipos diferentes e mutáveis.

Listas são criadas com o uso de colchetes [].

Exemplos:

# Criar uma lista vazia
lista = []
#ou
#lista = list()

# Listas diversas
alfabeto = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'h', 'i', 'j', 'k']
listaNumerosInteiros = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 100, 1000, 10000]
listaNuemrosReais = [1.83, 2.45, 3.14, 235.45]
listaMista = [1, 'abelha', 4.28, True, '689']

# Criar uma lista vazia
lista = []
#ou
#lista = list()

# Listas diversas
alfabeto = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'h', 'i', 'j', 'k']
listaNumerosInteiros = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 100, 1000, 10000]
listaNuemrosReais = [1.83, 2.45, 3.14, 235.45]
listaMista = [1, 'abelha', 4.28, True, '689']

list()

list() é uma função Python que está integrada ao interpretador (Built-in).
Também serve para converter outros objetos iteráveis em listas.

Exemplos:

peso = "kg"
tupla = ('E', 'l', 'o', 'n')
conjunto = {1, 2, 3, 4, 5}
dicionario = {'nome': 'Daniel', 'linguagem': 'Python'}
print(type(peso))           # <class 'str'>
print(type(tupla))          # <class 'tuple'>
print(type(conjunto))       # <class 'set'>
print(type(dicionario))     # <class 'dict'>
peso = list(peso)
tupla = list(tupla)
conjunto = list(conjunto)
dicionario = list(dicionario)
print(type(peso))           # <class 'list'>
print(type(tupla))          # <class 'list'>
print(type(conjunto))       # <class 'list'>
print(type(dicionario))     # <class 'list'>

peso = "kg"
tupla = ('E', 'l', 'o', 'n')
conjunto = {1, 2, 3, 4, 5}
dicionario = {'nome': 'Daniel', 'linguagem': 'Python'}
print(type(peso))           # <class 'str'>
print(type(tupla))          # <class 'tuple'>
print(type(conjunto))       # <class 'set'>
print(type(dicionario))     # <class 'dict'>
peso = list(peso)
tupla = list(tupla)
conjunto = list(conjunto)
dicionario = list(dicionario)
print(type(peso))           # <class 'list'>
print(type(tupla))          # <class 'list'>
print(type(conjunto))       # <class 'list'>
print(type(dicionario))     # <class 'list'>

Os métodos do objeto lista

Podemos acessar os métodos possíveis digitando o nome da lista, seguido do ponto e depois teclando a tecla “tab”. Aparecerá um menu com todos os métodos possíveis.

append()
insert()
remove()
pop()
clear()
index()
count()
sort()
reverse()

Algumas práticas realizadas com listas

# Listas em Python
alfabeto = ['a', 'b', 'c', 'd', 'e']
print(alfabeto)
alfabeto.append('f')
alfabeto.pop()
print(alfabeto)
palavra = 'polipropileno'
lista_2 = palavra.split()
print(lista_2)
frase = "O rato roeu a roda do carro do rei de roma"
print(frase)
listaFrase = frase.split()
print(listaFrase)

# Imprimindo os itens da lista “alfabeto” um por um
alfabeto = ['a', 'b', 'c', 'd', 'e']
for i in alfabeto:
    print(i)

# O método .append() junto do comando for para calcular
# os valores de y para uma função do 1º grau.
x_valores = [-2, -1, 0, 1, 2]
y_valores = []
a = 2
b = -3
for x in x_valores:
    y_valores.append(a * x + b)
print(x_valores)
print(y_valores)

# Criar uma lista de pets conforme quantidade
# de pets que um usuário tenha
meusPets = []
qtdPets = int(input("Quantos pets você tem? "))
for i in range(qtdPets):
    nomePet = input("Digite o nome do pet: ")
    meusPets.append(nomePet)
print(meusPets)

# Listas em Python
alfabeto = ['a', 'b', 'c', 'd', 'e']
print(alfabeto)
alfabeto.append('f')
alfabeto.pop()
print(alfabeto)
palavra = 'polipropileno'
lista_2 = palavra.split()
print(lista_2)
frase = "O rato roeu a roda do carro do rei de roma"
print(frase)
listaFrase = frase.split()
print(listaFrase)

# Imprimindo os itens da lista “alfabeto” um por um
alfabeto = ['a', 'b', 'c', 'd', 'e']
for i in alfabeto:
    print(i)

# O método .append() junto do comando for para calcular
# os valores de y para uma função do 1º grau.
x_valores = [-2, -1, 0, 1, 2]
y_valores = []
a = 2
b = -3
for x in x_valores:
    y_valores.append(a * x + b)
print(x_valores)
print(y_valores)

# Criar uma lista de pets conforme quantidade
# de pets que um usuário tenha
meusPets = []
qtdPets = int(input("Quantos pets você tem? "))
for i in range(qtdPets):
    nomePet = input("Digite o nome do pet: ")
    meusPets.append(nomePet)
print(meusPets)

Indexação em Listas (index)

Os itens ou elementos contidos em uma lista, são organizados ou estruturados com um endereçamento que inicia em zero. Ou seja, o primeiro item está indexado em zero, o segundo em um, o terceiro em dois, e assim por diante.

Exemplo:

nort_BR = ['Acre', 'Amapá', 'Amazonas', 'Pará', 'Rondônia', 'Roraima', 'Tocantins']
        		  0	      1		      2	        3         4            5		      6

nort_BR = ['Acre', 'Amapá', 'Amazonas', 'Pará', 'Rondônia', 'Roraima', 'Tocantins']
        		  0	      1		      2	        3         4            5		      6

É possível, também, utilizar o endereçamento invertido, a indexação inversa, para acessar itens do último para o primeiro. Nesse caso, para acessar o último item, usa-se o -1, o penúltimo o -2, o antipenúltimo o -3, e assim por diante.

Exemplo:

nort_BR = ['Acre', 'Amapá', 'Amazonas', 'Pará', 'Rondônia', 'Roraima', 'Tocantins']
		         -7	     -6		      -5	      -4        -3         -2		       -1

nort_BR = ['Acre', 'Amapá', 'Amazonas', 'Pará', 'Rondônia', 'Roraima', 'Tocantins']
		         -7	     -6		      -5	      -4        -3         -2		       -1

Acessando itens de listas por indexação

Com o comando print():

print(nort_BR[2]) # Exibe o item no index 2.
print(nort_BR[-1]) # Exibe o item no último index.

print(nort_BR[2]) # Exibe o item no index 2.
print(nort_BR[-1]) # Exibe o item no último index.

Slicing (fatiamento) com listas

O slicing é utilizado para pegar partes ou “pedaços” de uma sequência.

sequencia[inicio:fim:passo]

estados = ["SC", "SP", "PR", "BA", "AC", "MG"]
# ['SP', 'PR', 'BA'] → do índice 1 até antes do 4
print(estados[1:4])
# ['SC', 'SP', 'PR'] → do início até antes do 3
print(estados[:3])
# ['PR', 'BA', 'AC', 'MG'] → do índice 2 até o fim
print(estados[2:])
# ['SC', 'PR', 'AC'] → de 2 em 2
print(estados[::2])
# ['MG', 'AC', 'BA', 'PR', 'SP', 'SC'] → lista invertida
print(estados[::-1])

estados = ["SC", "SP", "PR", "BA", "AC", "MG"]
# ['SP', 'PR', 'BA'] → do índice 1 até antes do 4
print(estados[1:4])
# ['SC', 'SP', 'PR'] → do início até antes do 3
print(estados[:3])
# ['PR', 'BA', 'AC', 'MG'] → do índice 2 até o fim
print(estados[2:])
# ['SC', 'PR', 'AC'] → de 2 em 2
print(estados[::2])
# ['MG', 'AC', 'BA', 'PR', 'SP', 'SC'] → lista invertida
print(estados[::-1])

Resumo:

Slicing é como “cortar pedaços” de listas, strings e tuplas.
Sintaxe: objeto[inicio:fim:passo].
Pode ser usado para pegar trechos, pular elementos ou inverter a ordem.

Tuplas

Tupla –> tuple() –> um objeto iterável e uma coleção ordenada e imutável de elementos.

São objetos similares às listas. São estruturas de dados porque possuem dados estruturados ou organizados dentro delas. Ou seja, os dados ou elementos de uma tupla são indexados e ordenados. Assim como nas listas, os dados podem ser de tipos diferentes, porém, são imutáveis.

Tuplas são criadas com o uso ou não de parênteses ().

Exemplos de tuplas:

# Criando tuplas vazias
tupla_vazia1 = ()
tupla_vazia2 = tuple()

# Tuplas diversas
tupla = (1, "olá", 3.3333)
outra_tupla = ('polipropileno', )
tupla_nums = (1, 2, 3, 6, 12, 24)
coord_chiesetta_alpina = (-26.515707985357345, -49.06232139272939)
outro_modo = "a", "b", 1, 1.7

# Criando tuplas vazias
tupla_vazia1 = ()
tupla_vazia2 = tuple()

# Tuplas diversas
tupla = (1, "olá", 3.3333)
outra_tupla = ('polipropileno', )
tupla_nums = (1, 2, 3, 6, 12, 24)
coord_chiesetta_alpina = (-26.515707985357345, -49.06232139272939)
outro_modo = "a", "b", 1, 1.7

Os métodos do objeto tupla

Podemos acessar os métodos possíveis digitando o nome da tupla seguido do ponto e, depois, teclando a tecla “tab”. Aparecerá um menu com os métodos possíveis.

No caso de tuplas, são apenas dois métodos.

count()
index()

Exemplos:

# Os métodos de tuplas
numeros = (1, 2, 1, 2, 3, 1, 2, 3, 1, 2, 3, 4)
print(numeros.count(2))  # 4 vezes o número 4
print(numeros.index(4))  # 4 é o endereço do número 5

# Os métodos de tuplas
numeros = (1, 2, 1, 2, 3, 1, 2, 3, 1, 2, 3, 4)
print(numeros.count(2))  # 4 vezes o número 4
print(numeros.index(4))  # 4 é o endereço do número 5

tuple()

tuple() é uma função Python e está integrada ao interpretador (Built-in).
Também serve para converter outros objetos iteráveis em tuplas.

Exemplos:

peso = "kg"
lista =['E', 'l', 'o', 'n']
conjunto = {1, 2, 3, 4, 5}
dicionario = {'nome': 'Daniel', 'linguagem': 'Python'}
print(type(peso))           	# <class 'str'>
print(type(lista))          	# <class 'list'>
print(type(conjunto))       	# <class 'set'>
print(type(dicionario))     	# <class 'dict'>
peso = tuple(peso)
lista = tuple(lista)
conjunto = tuple(conjunto)
dicionario = tuple(dicionario)
print(type(peso))           	# <class 'tuple'>
print(type(lista))          	# <class 'tuple'>
print(type(conjunto))       	# <class 'tuple'>
print(type(dicionario))     	# <class 'tuple'>

peso = "kg"
lista =['E', 'l', 'o', 'n']
conjunto = {1, 2, 3, 4, 5}
dicionario = {'nome': 'Daniel', 'linguagem': 'Python'}
print(type(peso))           	# <class 'str'>
print(type(lista))          	# <class 'list'>
print(type(conjunto))       	# <class 'set'>
print(type(dicionario))     	# <class 'dict'>
peso = tuple(peso)
lista = tuple(lista)
conjunto = tuple(conjunto)
dicionario = tuple(dicionario)
print(type(peso))           	# <class 'tuple'>
print(type(lista))          	# <class 'tuple'>
print(type(conjunto))       	# <class 'tuple'>
print(type(dicionario))     	# <class 'tuple'>

Conjuntos

Conjunto –> set() –> um objeto iterável e uma coleção desordenada e mutável de elementos únicos.

São objetos similares às listas. São estruturas de dados, porque possuem dados estruturados ou organizados dentro delas. Porém, os dados ou elementos de um conjunto, não são indexados e ordenados. Assim como nas listas, os dados podem ser de tipos diferentes e são mutáveis.

São objetos com dados estruturados ou organizados na memória por tabelas hash. Através desses valores hash, os dados são “espalhados” na memória, de modo que não é uma organização sequencial.

Conjuntos são criadas com o uso de chaves {}.

Exemplos de conjuntos:

conj_vazio = set()
conjunto = {1, 'olá', 3.3333}
conj_A = {1, 2, 3, 6, 12, 24}
conj_B = {1, 3, 4, 5, 9, 12, 13}

conj_vazio = set()
conjunto = {1, 'olá', 3.3333}
conj_A = {1, 2, 3, 6, 12, 24}
conj_B = {1, 3, 4, 5, 9, 12, 13}

Os métodos do objeto conjunto

Add()
clear()
copy()
difference()
difference_update()
discard()
intersection()
intersection_update()
isdisjoint()
issubset()
issuperset()
pop()
remove()
symmetric_difference()
symmetric_difference_update()
union()
update()

Exemplos:

# União entre os conjuntos A e B
A = {1, 2, 'x', 'y'}
B = {2, 3, 'y', 'z'}
C = A.union(B)		# Ou C = A | B
print(C)			# {1, 2, 'y', 3, 'z', 'x'}

# Intersecção entre os conjuntos A e B
A = {1, 2, 'x', 'y'}
B = {2, 3, 'y', 'z'}
C = A.intersection(B)	# Ou C = A & B
print(C)			# {'y', 2} 

# Diferença entre os conjuntos A e B
A = {1, 2, 'x', 'y'}
B = {2, 3, 'y', 'z'}
C = A.difference(B)	# Ou C = A - B
print(C)			# {1, 'x'} 

# Diferença simétrica entre os conjuntos A e B
A = {1, 2, 'x', 'y'}
B = {2, 3, 'y', 'z'}
C = A.symmetric_difference(B)	# Ou C = A ^ B
print(C)				# {3, 1, 'z', 'x'} 

# Verificar se A e B são subconjunto de C.
A = {1, 2, 'x', 'y'}
B = {2, 3, 'y', 'z'}
C = {1, 2, 'y', 3, 'z', 'x'}
print(A.issubset(C))	# Ou print(A <= C)		# True
print(B.issubset(C))	# Ou print(B <= C)		# True

# Verificar se A é superconjunto de B, ou se A contém B.
A = {1, 2, 'x', 'y'}
B = {2, 3, 'y', 'z'}
print(A.issuperset(B))	# Ou print(A >= C)		# False

# Verificar se C é superconjunto de A, ou se C contém A.
A = {1, 2, 'x', 'y'}
B = {2, 3, 'y', 'z'}
C = {1, 2, 'y', 3, 'z', 'x'}
print(C.issuperset(A))	# Ou print(C >= A)		# True

# União entre os conjuntos A e B
A = {1, 2, 'x', 'y'}
B = {2, 3, 'y', 'z'}
C = A.union(B)		# Ou C = A | B
print(C)			# {1, 2, 'y', 3, 'z', 'x'}

# Intersecção entre os conjuntos A e B
A = {1, 2, 'x', 'y'}
B = {2, 3, 'y', 'z'}
C = A.intersection(B)	# Ou C = A & B
print(C)			# {'y', 2} 

# Diferença entre os conjuntos A e B
A = {1, 2, 'x', 'y'}
B = {2, 3, 'y', 'z'}
C = A.difference(B)	# Ou C = A - B
print(C)			# {1, 'x'} 

# Diferença simétrica entre os conjuntos A e B
A = {1, 2, 'x', 'y'}
B = {2, 3, 'y', 'z'}
C = A.symmetric_difference(B)	# Ou C = A ^ B
print(C)				# {3, 1, 'z', 'x'} 

# Verificar se A e B são subconjunto de C.
A = {1, 2, 'x', 'y'}
B = {2, 3, 'y', 'z'}
C = {1, 2, 'y', 3, 'z', 'x'}
print(A.issubset(C))	# Ou print(A <= C)		# True
print(B.issubset(C))	# Ou print(B <= C)		# True

# Verificar se A é superconjunto de B, ou se A contém B.
A = {1, 2, 'x', 'y'}
B = {2, 3, 'y', 'z'}
print(A.issuperset(B))	# Ou print(A >= C)		# False

# Verificar se C é superconjunto de A, ou se C contém A.
A = {1, 2, 'x', 'y'}
B = {2, 3, 'y', 'z'}
C = {1, 2, 'y', 3, 'z', 'x'}
print(C.issuperset(A))	# Ou print(C >= A)		# True

set()

set() é uma função Python e está integrada ao interpretador (Built-in).
Também serve para converter outros objetos iteráveis em conjuntos.

Exemplos:

peso = 'kg'
tupla = ('E', 'l', 'o', 'n')
lista = [1, 2, 3, 4, 5, -5, 4, -3, 2]
dicionario = {'nome': 'Daniel', 'linguagem': 'Python'}
print(type(peso))			# <class 'str'> 
print(type(tupla))			# <class 'tuple'> 
print(type(lista))			# <class 'list'> 
print(type(dicionario))		# <class 'dict'> 
peso = set(peso)
tupla = set(tupla)
lista = set(lista)
dicionario = set(dicionario)
print(type(peso))			# <class 'set'>
print(type(tupla))			# <class 'set'>
print(type(lista))			# <class 'set'>
print(type(dicionario))		# <class 'set'>

peso = 'kg'
tupla = ('E', 'l', 'o', 'n')
lista = [1, 2, 3, 4, 5, -5, 4, -3, 2]
dicionario = {'nome': 'Daniel', 'linguagem': 'Python'}
print(type(peso))			# <class 'str'> 
print(type(tupla))			# <class 'tuple'> 
print(type(lista))			# <class 'list'> 
print(type(dicionario))		# <class 'dict'> 
peso = set(peso)
tupla = set(tupla)
lista = set(lista)
dicionario = set(dicionario)
print(type(peso))			# <class 'set'>
print(type(tupla))			# <class 'set'>
print(type(lista))			# <class 'set'>
print(type(dicionario))		# <class 'set'>

Lista de exercícios do pseudocódigo até decisões, laços etc.

Dicionários

Dicionário –> dict() –> um objeto iterável e uma coleção ordenada e mutável de dados.

São estruturas de dados porque possuem dados estruturados ou organizados dentro delas. Podem armazenar diferentes tipos de dados. Porém, os dados de um dicionário não são indexados e ordenados como nas listas e tuplas, mas possuem a organização na forma:
chave: valor

Dicionários, assim como conjuntos, são criadas com o uso de chaves {}, mas seguindo a organização de chave (key e valor (value).

Um dicionário pode ser comparado a um dicionário comum de Inglês / Português, onde a chave é a palavra a ser traduzida e o valor é a tradução. Abaixo um exemplo com a sintaxe básica:

cores = {'Blue': 'azul', 'Green': 'verde', 'Red': 'vermelho'}

cores = {'Blue': 'azul', 'Green': 'verde', 'Red': 'vermelho'}

“Blue”, “Green” e “Red” são as chaves (keys).
“azul”, “verde” e “vermelho” são os valores (values).

Outros exemplos de dicionários:

dicionario_vazio1 = {}
dicionario_vazio2 = dict()
color_cor = {
    'Blue': 'azul',
    'Green': 'verde',
    'Red': 'vermelho'
    }

dicionario_vazio1 = {}
dicionario_vazio2 = dict()
color_cor = {
    'Blue': 'azul',
    'Green': 'verde',
    'Red': 'vermelho'
    }

Os métodos do objeto dicionário

clear()
copy()
fromkeys()
get()
items()
keys()
pop()
popitem()
setdefault()
update()
values()

Exemplos:

# Utilizando o método get() para pegar
# os valores das chaves escolhidas.
print(color_cor.get("Blue"))		# azul
print(color_cor.get("Green"))		# verde
print(color_cor.get("Red"))		# vermelho

# Se a chave não existir, a saída é None.
print(color_cor.get("Pink"))		# None

# Pode-se colocar uma mensagem como segundo argumento para o caso da
# chave não existir.
print(color_cor.get("Grey", "Chave não encontrada.")) # Chave não encontrada.

# Utilizando o método get() para pegar
# os valores das chaves escolhidas.
print(color_cor.get("Blue"))		# azul
print(color_cor.get("Green"))		# verde
print(color_cor.get("Red"))		# vermelho

# Se a chave não existir, a saída é None.
print(color_cor.get("Pink"))		# None

# Pode-se colocar uma mensagem como segundo argumento para o caso da
# chave não existir.
print(color_cor.get("Grey", "Chave não encontrada.")) # Chave não encontrada.

# Utilizando o método update() para adicionar novos pares de chave: valor, ou
# modificar o valor de uma chave já existente.
color_cor.update({"Yellow": "amarelo", "Purple": "roxo"})
color_cor.update({'Red': 'VERMELHO', 'Gray': 'cinza'})
for chave, valor in color_cor.items():
    print(chave, valor)

# O método .items() facilita a iteração com o dicionário.
print(color_cor.items())
for chave, valor in color_cor.items():
    print(f" para a chave {chave}, temos: {valor}")

# Utilizando o método update() para adicionar novos pares de chave: valor, ou
# modificar o valor de uma chave já existente.
color_cor.update({"Yellow": "amarelo", "Purple": "roxo"})
color_cor.update({'Red': 'VERMELHO', 'Gray': 'cinza'})
for chave, valor in color_cor.items():
    print(chave, valor)

# O método .items() facilita a iteração com o dicionário.
print(color_cor.items())
for chave, valor in color_cor.items():
    print(f" para a chave {chave}, temos: {valor}")

Output:

dict_items([(‘Blue’, ‘azul’), (‘Green’, ‘verde’), (‘Red’, ‘VERMELHO’), (‘Yellow’, ‘amarelo’), (‘Purple’, ‘roxo’), (‘Gray’, ‘cinza’)])
para a chave Blue, temos: azul
para a chave Green, temos: verde
para a chave Red, temos: VERMELHO
para a chave Yellow, temos: amarelo
para a chave Purple, temos: roxo
para a chave Gray, temos: cinza

# Utilizando o método pop() para remover um par chave: valor indicando a chave
print(color_cor.pop("Red"))
print(color_cor)

# Utilizando o método pop() para remover um par chave: valor indicando a chave
print(color_cor.pop("Red"))
print(color_cor)

Output:

VERMELHO
{‘Blue’: ‘azul’, ‘Green’: ‘verde’, ‘Yellow’: ‘amarelo’, ‘Purple’: ‘roxo’, ‘Gray’: ‘cinza’}

# Utilizando o método pop() para remover um par chave: valor
# indicando a chave. Incluindo uma mensagem de aviso de chave
# inexistente, caso a chave não esteja na lista.
print(color_cor.pop("Red", "Chave inexistente."))
print(color_cor)

# Utilizando o método pop() para remover um par chave: valor
# indicando a chave. Incluindo uma mensagem de aviso de chave
# inexistente, caso a chave não esteja na lista.
print(color_cor.pop("Red", "Chave inexistente."))
print(color_cor)

Output:

Chave inexistente.
{‘Blue’: ‘azul’, ‘Green’: ‘verde’, ‘Yellow’: ‘amarelo’, ‘Purple’: ‘roxo’, ‘Gray’: ‘cinza’}

# Utilizando o método popitem() para remover o último par chave: valor.
color_cor.popitem()
print(color_cor)

# Utilizando o método popitem() para remover o último par chave: valor.
color_cor.popitem()
print(color_cor)

Output:

{‘Blue’: ‘azul’, ‘Green’: ‘verde’, ‘Yellow’: ‘amarelo’, ‘Purple’: ‘roxo’}

dict()

Dict() é uma função Python e está integrada ao interpretador (Built-in).
Também serve para converter outros objetos iteráveis em dicionários.

Exemplos:

tupla = (('E', 'l'), ('o', 'n'))
lista = [[1, 2], [3, 4], [5, -5], [4, -3]]
conjunto = {(1, 2), (3, 4), (5, 6)}
print(type(tupla))          # <class 'tuple'> 
print(type(lista))          # <class 'list'> 
print(type(conjunto))       # <class 'set'> 
tupla = dict(tupla)
lista = dict(lista)
conjunto = dict(conjunto)
print(type(tupla))          # <class 'dict'>
print(type(lista))          # <class 'dict'>
print(type(conjunto))       # <class 'dict'>

tupla = (('E', 'l'), ('o', 'n'))
lista = [[1, 2], [3, 4], [5, -5], [4, -3]]
conjunto = {(1, 2), (3, 4), (5, 6)}
print(type(tupla))          # <class 'tuple'> 
print(type(lista))          # <class 'list'> 
print(type(conjunto))       # <class 'set'> 
tupla = dict(tupla)
lista = dict(lista)
conjunto = dict(conjunto)
print(type(tupla))          # <class 'dict'>
print(type(lista))          # <class 'dict'>
print(type(conjunto))       # <class 'dict'>

Operadores Aritméticos, Comparativos e Lógicos em Python

Aritméticos → Servem para realizar operações matemáticas.

Exemplos:

# Treinando operadores aritméticos
a = 3.14
b = 3
soma = a + b
print(f"A soma é: {a} + {b} = {soma}")
subtracao = a - b
print(f"A subtracao é: {a} - {b} = {subtracao}")
multiplica = a * b
print(f"A multiplicação é: {a} * {b} = {multiplica}")
divisao = a / b
print(f"A divião com uma barra é: {a} / {b} = {divisao}")
divide_por_2_barras = a // b
print(f"A divisão com duas barras é: {a} // {b} = {divide_por_2_barras}")
expoente = a ** b
print(f"A exponenciação é: {a} ** {b} = {expoente}")

# Treinando operadores aritméticos
a = 3.14
b = 3
soma = a + b
print(f"A soma é: {a} + {b} = {soma}")
subtracao = a - b
print(f"A subtracao é: {a} - {b} = {subtracao}")
multiplica = a * b
print(f"A multiplicação é: {a} * {b} = {multiplica}")
divisao = a / b
print(f"A divião com uma barra é: {a} / {b} = {divisao}")
divide_por_2_barras = a // b
print(f"A divisão com duas barras é: {a} // {b} = {divide_por_2_barras}")
expoente = a ** b
print(f"A exponenciação é: {a} ** {b} = {expoente}")

Output:

A soma é: 3.14 + 3 = 6.140000000000001
A subtracao é: 3.14 – 3 = 0.14000000000000012
A multiplicação é: 3.14 * 3 = 9.42
A divião com uma barra é: 3.14 / 3 = 1.0466666666666666
A divisão com duas barras é: 3.14 // 3 = 1.0
A exponenciação é: 3.14 ** 3 = 30.959144000000002

Comparativos → Servem para comparar valores e o resultado será True ou False

Exemplos:

# Treinando operadores de comparação
print(a == b) # False
print(a != b) # True
print(a <= b) # False
print(a >= b) # True
print(a > b) # True
print(a < b) # False

# Treinando operadores de comparação
print(a == b) # False
print(a != b) # True
print(a <= b) # False
print(a >= b) # True
print(a > b) # True
print(a < b) # False

Lógicos → Utilizados para combinar condições. O resultado será True ou False.

Exemplos:

# Treinando operadores lógicos
# O operador and
# True and True --> True
# True and False --> False
# False and True --> False
# False and False --> False
print(a != b and a > b) # True
print(a != b and a < b) # False
print(a < b and a != b) # False
print(a < b and a == b) # False

# O operador or
# True or True --> True
# True or False --> True
# False or True --> True
# False or False --> False
print(a != b or a > b) # True
print(a != b or a < b) # True
print(a < b or a != b) # True
print(a < b or a == b) # False

# O operador not
print(not a == b) # True
print(not a != b) # False

# Treinando operadores lógicos
# O operador and
# True and True --> True
# True and False --> False
# False and True --> False
# False and False --> False
print(a != b and a > b) # True
print(a != b and a < b) # False
print(a < b and a != b) # False
print(a < b and a == b) # False

# O operador or
# True or True --> True
# True or False --> True
# False or True --> True
# False or False --> False
print(a != b or a > b) # True
print(a != b or a < b) # True
print(a < b or a != b) # True
print(a < b or a == b) # False

# O operador not
print(not a == b) # True
print(not a != b) # False

# Comer pizza ou ir à academia
chove = True
frio = False

if chove and not frio:
    print("Você pode comer pizza!")
else:
    print("Vá para a academia!")

# Enaquanto frio e com chuva, assistir um filme
frio = 1
chove = 1
while chove:
    print("Assista a um filme.")
    chove = int(input("Ainda chove? 0 para não, 1 para sim."))
    print(bool(chove))
print("Vá para a academia.")

# Comer pizza ou ir à academia
chove = True
frio = False

if chove and not frio:
    print("Você pode comer pizza!")
else:
    print("Vá para a academia!")

# Enaquanto frio e com chuva, assistir um filme
frio = 1
chove = 1
while chove:
    print("Assista a um filme.")
    chove = int(input("Ainda chove? 0 para não, 1 para sim."))
    print(bool(chove))
print("Vá para a academia.")

A instrução ou estrutura de repetição while

O comando while executa um bloco de código enquanto uma condição for verdadeira.

Sintaxe:

while condicao:
        # bloco de comandos

while condicao:
        # bloco de comandos

Exemplo em pseudocódigo:

// Pseudocódigo de um contador
var
   contador
Inicio
   contador <- 0
   enquanto contador <= 5 faca
      escreva("Número: ", contador)
      contador <- contador + 1
   fimenquanto
fim

// Pseudocódigo de um contador
var
   contador
Inicio
   contador <- 0
   enquanto contador <= 5 faca
      escreva("Número: ", contador)
      contador <- contador + 1
   fimenquanto
fim

Exemplo em Python:

# Contagem simples
contador = 0
while contador <= 10:
    print("Número: ", contador)
    contador = contador + 1

# Contagem simples
contador = 0
while contador <= 10:
    print("Número: ", contador)
    contador = contador + 1

Output

Número: 0
Número: 1
Número: 2
Número: 3
Número: 4
Número: 5
Número: 6
Número: 7
Número: 8
Número: 9
Número: 10

# Imprimindo item por item de uma lista
meus_pets = ['gato', 'cachorro', 'galinha', 'hamster']
i = 0
while i < len(meus_pets):
  print(meus_pets[i])
  i += 1

# Imprimindo item por item de uma lista
meus_pets = ['gato', 'cachorro', 'galinha', 'hamster']
i = 0
while i < len(meus_pets):
  print(meus_pets[i])
  i += 1

Output:

gato
cachorro
galinha
hamster

# Solicitando a senha até acertar
senha = ""
while senha != "Python":
    senha = input("Qual a senha? ")
print("Acertou, miseravi!")

# Loop infinito. CUIDADO!
x = 1
while x > 0:  # essa condição sempre é verdadeira e x sempre será exibido
    print(x)

# Solicitando a senha até acertar
senha = ""
while senha != "Python":
    senha = input("Qual a senha? ")
print("Acertou, miseravi!")

# Loop infinito. CUIDADO!
x = 1
while x > 0:  # essa condição sempre é verdadeira e x sempre será exibido
    print(x)

A instrução break

Se a instrução break for encontrada, o código será interrompido imediatamente.

Exemplo 1:

# Loop infinito, mas que é interrompido com o “break”
x = 1
while x > 0:  # essa condição sempre é verdadeira
    print(x)
    break

# Loop infinito, mas que é interrompido com o “break”
x = 1
while x > 0:  # essa condição sempre é verdadeira
    print(x)
    break

Output

1

Exemplo 2:

while True:
    print('Loop infinito, mas que é interrompido com "break"')
    break

while True:
    print('Loop infinito, mas que é interrompido com "break"')
    break

Output:

Loop infinito, mas que é interrompido com “break”

A instrução continue

Se a instrução continue for encontrada, o código dentro do loop pulará imediatamente voltando para o início.

Exemplo 1:

# No algoritmo abaixo, o loop será de 0 até 10. Se n for
# múltiplo de 3, executará o "continue" fazendo pular para
# o início do bloco dentro do "while". Se não for múltiplo
# de 3, vai imprimir na tela.
n = 0
while n < 10:
    n += 1              # ATUALIZA antes de testar o continue!
    if n % 3 == 0:
        continue        # pula o print dos múltiplos de 3
    print(n)

# No algoritmo abaixo, o loop será de 0 até 10. Se n for
# múltiplo de 3, executará o "continue" fazendo pular para
# o início do bloco dentro do "while". Se não for múltiplo
# de 3, vai imprimir na tela.
n = 0
while n < 10:
    n += 1              # ATUALIZA antes de testar o continue!
    if n % 3 == 0:
        continue        # pula o print dos múltiplos de 3
    print(n)

Output

1
2
4
5
7
8
10

Capítulo 3 – Programação intermediária em Python

Importação de bibliotecas ou módulos

Bibliotecas ou módulos são conjuntos ou pacotes de códigos prontos. Eles foram desenvolvidos por outros programadores e ficam disponíveis para facilitar a programação, de modo que não precisamos escrever tudo do zero. Portanto, caso haja uma ferramenta ou funcionalidade disponível em uma biblioteca, basta importá-la em vez de escrever o código.

Para ilustrar, imagine que o Python seja uma grande caixa de ferramentas para a construção e manutenção de bicicletas comuns. No entanto, em um determinado momento, você decide incrementar ou expandir seus serviços e decide consertar bicicletas elétricas. Você vai construir as ferramentas para bicicletas elétricas ou as buscará prontas para utilizar?

Há uma grande chance de haver alguma biblioteca já desenvolvida com as funções que alguém possa precisar para um determinado problema.
Exemplo: calcular a raiz quadrada de um número é facilitado com o uso da função .sqrt() da biblioteca math.

import math
print(math.sqrt(4)) # 2.0 

import math
print(math.sqrt(4)) # 2.0 

import

A palavra reservada import é utilizada para fazer a importação de módulos ou bibliotecas.

Abaixo alguns exemplos da utilização de algumas funções da biblioteca math que foi criada para trabalhar cálculos matemáticos.

Exemplos dos modos de importação:

# Importação completa:
import math
raiz_cub = math.cbrt(27)
print(raiz_cub)		# 3.0

# Importação com aliás (apelido):
import math as m
print(m.cbrt(64))		# 4.0

# Importação de pacotes específicos:
from math import sqrt, pi
print(sqrt(144))
print(pi)			# 3.141592653589793

# Importação total (cuidado!):
from math import *
print(sin(0))		# 0.0

# Importação completa:
import math
raiz_cub = math.cbrt(27)
print(raiz_cub)		# 3.0

# Importação com aliás (apelido):
import math as m
print(m.cbrt(64))		# 4.0

# Importação de pacotes específicos:
from math import sqrt, pi
print(sqrt(144))
print(pi)			# 3.141592653589793

# Importação total (cuidado!):
from math import *
print(sin(0))		# 0.0

Exemplos práticos

Exemplo 1: uso do math para calcular a área e a circunferência de um círculo.

import math
raio = float(input("Digite o raio do círculo: "))
area = math.pi * raio ** 2
circunferencia = 2 * math.pi * raio
print(f"A área do círculo com raio {raio} é: {area}.")
print(f"A circunferência do círculo com raio {raio} é: {circunferencia}.")

import math
raio = float(input("Digite o raio do círculo: "))
area = math.pi * raio ** 2
circunferencia = 2 * math.pi * raio
print(f"A área do círculo com raio {raio} é: {area}.")
print(f"A circunferência do círculo com raio {raio} é: {circunferencia}.")

Output

A área do círculo com raio 4.0 é: 50.26548245743669.
A circunferência do círculo com raio 4.0 é: 25.132741228718345.

Exemplo 2: uso do math para calcular a área e a circunferência de um círculo e arredondando para duas casas decimais com a função round().

# Cálculo da área e da circunferência de um círculo
# Arredondando as casas decimais com a função round().
import math
raio = float(input("Digite o raio do círculo: "))
area = round(math.pi * raio ** 2, 2)
circunferencia = round(2 * math.pi * raio, 2)
print(f"A área do círculo com raio {raio} é: {area}.")
print(f"A circunferência do círculo com raio {raio} é: {circunferencia}.")

# Cálculo da área e da circunferência de um círculo
# Arredondando as casas decimais com a função round().
import math
raio = float(input("Digite o raio do círculo: "))
area = round(math.pi * raio ** 2, 2)
circunferencia = round(2 * math.pi * raio, 2)
print(f"A área do círculo com raio {raio} é: {area}.")
print(f"A circunferência do círculo com raio {raio} é: {circunferencia}.")

Output

A área do círculo com raio 4.32 é: 58.63.
A circunferência do círculo com raio 4.32 é: 27.14.

Exemplo 3: uso do math para calcular a área e a circunferência de um círculo e arredondando para duas casas decimais com f-strings.

# Cálculo da área e da circunferência de um círculo
# Arredondando as casas decimais com f-strings.
import math
raio = float(input("Digite o raio do círculo: "))
area = math.pi * raio ** 2
circunferencia = 2 * math.pi * raio
print(f"A área do círculo com raio {raio} é: {area:.2f}.")
print(f"A circunferência do círculo com raio {raio} é: {circunferencia:.2f}.")

# Cálculo da área e da circunferência de um círculo
# Arredondando as casas decimais com f-strings.
import math
raio = float(input("Digite o raio do círculo: "))
area = math.pi * raio ** 2
circunferencia = 2 * math.pi * raio
print(f"A área do círculo com raio {raio} é: {area:.2f}.")
print(f"A circunferência do círculo com raio {raio} é: {circunferencia:.2f}.")

Output

A área do círculo com raio 4.93 é: 76.36.
A circunferência do círculo com raio 4.93 é: 30.98.

Exemplo 4: uso do math para calcular a área e a circunferência de um círculo e arredondando para duas casas decimais com .format().

# Cálculo da área e da circunferência de um círculo
# Arredondando as casas decimais com .format().
import math
raio = float(input("Digite o raio do círculo: "))
area = math.pi * raio ** 2
circ = 2 * math.pi * raio
print("A área do círculo com raio {}".format(raio), "é: {:.2f}.".format(area))
print("A circ. do círculo com raio {}".format(raio), "é: {:.2f}.".format(circ))

# Cálculo da área e da circunferência de um círculo
# Arredondando as casas decimais com .format().
import math
raio = float(input("Digite o raio do círculo: "))
area = math.pi * raio ** 2
circ = 2 * math.pi * raio
print("A área do círculo com raio {}".format(raio), "é: {:.2f}.".format(area))
print("A circ. do círculo com raio {}".format(raio), "é: {:.2f}.".format(circ))

Output

A área do círculo com raio 7.27 é: 166.04.
A circ. do círculo com raio 7.27 é: 45.68.

Abaixo, alguns exemplos da utilização de algumas funções da biblioteca matplotlib <https://matplotlib.org/stable/>.

Em suma, a biblioteca matplotlib foi criada para:

• Visualização de dados (ciência de dados, estatística, pesquisa acadêmica, engenharia).
• Gráficos (2D e 3D) e visualizações como de linha, barras, pizza, histograma, dispersão etc.

Exemplo 1:

# O código abaixo gera um gráfico de duas coleções de dados:
# os dados em "momentos" são as horas de um dia; os dados em
# "umid_rel_ar" são os valores da umidade relativa do ar em
# cada momento.
import matplotlib.pyplot as plt
momentos = [0, 3, 6, 9, 12, 15, 18, 21]
umid_rel_ar = [95, 100, 80, 65, 59, 68, 85, 75]
plt.plot(momentos, umid_rel_ar)
plt.show()

# O código abaixo gera um gráfico de duas coleções de dados:
# os dados em "momentos" são as horas de um dia; os dados em
# "umid_rel_ar" são os valores da umidade relativa do ar em
# cada momento.
import matplotlib.pyplot as plt
momentos = [0, 3, 6, 9, 12, 15, 18, 21]
umid_rel_ar = [95, 100, 80, 65, 59, 68, 85, 75]
plt.plot(momentos, umid_rel_ar)
plt.show()

Output

Exemplo 2:

# Calculando a função do 1º grau e gerando o gráfico
import matplotlib.pyplot as plt
x_valores = [-2, -1, 0, 1, 2]
y_valores = []
a = 2
b = -3
for x in x_valores:
    y_valores.append(a * x + b)
print(x_valores)
print(y_valores)
plt.plot(x_valores, y_valores, marker = 'd')
plt.title(f"Gráfico da função f(x) = {a}x + {b}")
plt.grid(color = 'k')
plt.xlabel("Eixo x")
plt.ylabel("Eixo y")
plt.show()

# Calculando a função do 1º grau e gerando o gráfico
import matplotlib.pyplot as plt
x_valores = [-2, -1, 0, 1, 2]
y_valores = []
a = 2
b = -3
for x in x_valores:
    y_valores.append(a * x + b)
print(x_valores)
print(y_valores)
plt.plot(x_valores, y_valores, marker = 'd')
plt.title(f"Gráfico da função f(x) = {a}x + {b}")
plt.grid(color = 'k')
plt.xlabel("Eixo x")
plt.ylabel("Eixo y")
plt.show()

Output:

[-2, -1, 0, 1, 2]
[-7, -5, -3, -1, 1]

Exemplo 3:

# Algoritmo para calcular a medida da área e a medida
# da circunferência de um círculo com o módulo math.
# Além disso, gera o gráfico com a circunferência e as
# informações dos cálculos.
import math
import matplotlib.pyplot as plt
raio = float(input("Digite o raio do círculo: "))
area = math.pi * raio ** 2
circ = 2 * math.pi * raio
print(f"Para um raio de {raio}cm:")
print(f"A medida da área é: {area:.2f}cm²")
print(f"A medida da circunferência é: {circ:.2f}cm")
x = []
y = []
for grau in range(0, 361):
    graus_to_rad = math.radians(grau)
    pontos_de_x = raio * math.cos(graus_to_rad)
    pontos_de_y = raio * math.sin(graus_to_rad)
    x.append(pontos_de_x)
    y.append(pontos_de_y)
plt.figure(figsize=(8, 8))
plt.plot(x, y, color="blue", alpha=1, label='Circunferência')
plt.fill(x, y, color="blue", alpha=0.4, label='Área do Círculo')
plt.title("Cálculo da Área e da Circunferência de um Círculo")
plt.xlabel("Eixo X")
plt.ylabel("Eixo Y")
plt.grid(True)
plt.legend()
plt.show()

# Algoritmo para calcular a medida da área e a medida
# da circunferência de um círculo com o módulo math.
# Além disso, gera o gráfico com a circunferência e as
# informações dos cálculos.
import math
import matplotlib.pyplot as plt
raio = float(input("Digite o raio do círculo: "))
area = math.pi * raio ** 2
circ = 2 * math.pi * raio
print(f"Para um raio de {raio}cm:")
print(f"A medida da área é: {area:.2f}cm²")
print(f"A medida da circunferência é: {circ:.2f}cm")
x = []
y = []
for grau in range(0, 361):
    graus_to_rad = math.radians(grau)
    pontos_de_x = raio * math.cos(graus_to_rad)
    pontos_de_y = raio * math.sin(graus_to_rad)
    x.append(pontos_de_x)
    y.append(pontos_de_y)
plt.figure(figsize=(8, 8))
plt.plot(x, y, color="blue", alpha=1, label='Circunferência')
plt.fill(x, y, color="blue", alpha=0.4, label='Área do Círculo')
plt.title("Cálculo da Área e da Circunferência de um Círculo")
plt.xlabel("Eixo X")
plt.ylabel("Eixo Y")
plt.grid(True)
plt.legend()
plt.show()

Output

Para um raio de 6.75cm:
A medida da área é: 143.14cm²
A medida da circunferência é: 42.41cm

Exemplos 4:

# Função do 2º grau ou função quadrática.
# Calculando os valores de x com for e range().
# Mostrando o gráfico com matplotlib.pyplot
import matplotlib.pyplot as plt
a = 1
b = -2
c = 3
xvalores = []
yvalores = []
# x = float(input("Digite o valor de x: "))
for x in range(-5, 6):
    xvalores.append(x)
    yvalores.append(a * x**2 + b * x + c)
    print(f"x = {x}, f(x) ou y = {y}")
plt.plot(
    xvalores,
    yvalores,
    label=(
        "Arco da função (coeficiente quadrático):\n"
        "a = 0 --> Função do 1º grau.\n"
        "a < 0 --> Concavidade para baixo.\n"
        "a > 0 --> Concavidade para cima."
    ),
)
plt.title(f"Gráfico da função f(x) = {a}x² + {b}x + {c}")
plt.xlabel("Valores de x")
plt.ylabel("Valores de f(x) ou y")
plt.legend()
plt.grid(True)
plt.show()

# Função do 2º grau ou função quadrática.
# Calculando os valores de x com for e range().
# Mostrando o gráfico com matplotlib.pyplot
import matplotlib.pyplot as plt
a = 1
b = -2
c = 3
xvalores = []
yvalores = []
# x = float(input("Digite o valor de x: "))
for x in range(-5, 6):
    xvalores.append(x)
    yvalores.append(a * x**2 + b * x + c)
    print(f"x = {x}, f(x) ou y = {y}")
plt.plot(
    xvalores,
    yvalores,
    label=(
        "Arco da função (coeficiente quadrático):\n"
        "a = 0 --> Função do 1º grau.\n"
        "a < 0 --> Concavidade para baixo.\n"
        "a > 0 --> Concavidade para cima."
    ),
)
plt.title(f"Gráfico da função f(x) = {a}x² + {b}x + {c}")
plt.xlabel("Valores de x")
plt.ylabel("Valores de f(x) ou y")
plt.legend()
plt.grid(True)
plt.show()

Output:

x = -5, f(x) ou y = 12
x = -4, f(x) ou y = 12
x = -3, f(x) ou y = 12
x = -2, f(x) ou y = 12
x = -1, f(x) ou y = 12
x = 0, f(x) ou y = 12
x = 1, f(x) ou y = 12
x = 2, f(x) ou y = 12
x = 3, f(x) ou y = 12
x = 4, f(x) ou y = 12
x = 5, f(x) ou y = 12

Exercícios básicos em Python com matemática, trigonometria, gráficos etc.

Definição de funções em Python

Uma função é algo que executa uma tarefa específica. É como uma máquina de café, por exemplo:
entramos com a água e o pó de café;
a máquina processa e prepara o café; e
no fim, ela entrega o café.
Portanto, em suma, uma função:
recebe dados de entrada, os parâmetros;
realiza um processamento; e
pode devolver um resultado.

def

Utilizamos a palavra-chave def para definir uma função. Abaixo podemos ver um modelo de função:

# def --> é a palavra reservada que define uma função
# nome_da_funcao --> nome que você escolhe para a função
# (parâmetros) --> valores que você envia para a função (opcional)
# : --> indica onde iniciar o bloco de código da função
# return --> indica o valor que a função devolverá (opcional)
def nome_da_funcao(parâmetros):
    # bloco de código
    return resultado

# def --> é a palavra reservada que define uma função
# nome_da_funcao --> nome que você escolhe para a função
# (parâmetros) --> valores que você envia para a função (opcional)
# : --> indica onde iniciar o bloco de código da função
# return --> indica o valor que a função devolverá (opcional)
def nome_da_funcao(parâmetros):
    # bloco de código
    return resultado

Exemplo 1:

# Função simples que mostra uma mensagem
# Note que é um caso sem parâmetros
def msn():
    return "Olá, mundo!"

# Função simples que mostra uma mensagem
# Note que é um caso sem parâmetros
def msn():
    return "Olá, mundo!"

Depois de definida a função, apenas precisamos chamá-la para ususá-la:

msn()

msn()

Output:

‘Olá, mundo!’

Exemplo 2:

# Função simples para multiplicar dois números
# Utilizando parâmetros a e b
def multiplica(a, b):
    valor = a * b
    return valor

# Função simples para multiplicar dois números
# Utilizando parâmetros a e b
def multiplica(a, b):
    valor = a * b
    return valor

Chamando a função:

# Utilizando a função para multiplicar 2 * 3
# 2 é o parâmetro a, 3 é o parâmetro b
multiplica(2, 3)

# Utilizando a função para multiplicar 2 * 3
# 2 é o parâmetro a, 3 é o parâmetro b
multiplica(2, 3)

Output:

6

Exemplo 3:

# Definindo uma função para dar boas vindas a novos alunos
def bemVindo(aluno):
    print(f"Olá, {aluno}! Seja bem-vindo ao mundo do Python.")

# Chamando a função bemVindo com o nome do aluno novo
bemVindo('Valdir')

# Definindo uma função para dar boas vindas a novos alunos
def bemVindo(aluno):
    print(f"Olá, {aluno}! Seja bem-vindo ao mundo do Python.")

# Chamando a função bemVindo com o nome do aluno novo
bemVindo('Valdir')

Output:

Olá, Valdir! Seja bem-vindo ao mundo do Python.

Exemplo 4:

# Definindo uma função com definição de valor padrão
# para o parâmetro. Neste caso é uma função para dar
# boas vindas a novos alunos. Ela retornará um padrão
# caso o nome do aluno não seja mencionado.
def bemVindo(aluno="Estudante"):
    print(f"Olá, {aluno}! Seja bem-vindo ao mundo do Python.")

# Chamando a função bemVindo, mas sem o nome do aluno.
bemVindo()

# Definindo uma função com definição de valor padrão
# para o parâmetro. Neste caso é uma função para dar
# boas vindas a novos alunos. Ela retornará um padrão
# caso o nome do aluno não seja mencionado.
def bemVindo(aluno="Estudante"):
    print(f"Olá, {aluno}! Seja bem-vindo ao mundo do Python.")

# Chamando a função bemVindo, mas sem o nome do aluno.
bemVindo()

Output:

Olá, Estudante! Seja bem-vindo ao mundo do Python.

Exemplo 5:

# Função para pegar o nome do estudante, a disciplina
# e mostrar as notas passadas como parâmetros no
# programa principal. Depois, calcular a média
# aritmética das notas e mostrar a mensagem com o
# nome do aluno, da disciplina, a nota final e se
# foi aprovado ou não.
def mediaResultFinal(aluno, mat, npt, nst, ntt):
    print(f"Olá, {aluno}! Vamos calcular sua nota final.")
    print(f"A disciplina escolhida é {mat}.")
    print(f"Suas notas são:\n1º Trim. {npt}\n2º Trim. {nst}\n3º Trim. {ntt}")
    n_final = round((npt + nst + ntt) / 3, 2)
    if n_final >= 6:
        print(f"{aluno}, sua nota final de {mat} é {n_final} e você foi aprovado(a).")
    else:
        print(f"{aluno}, sua nota final de {mat} é {n_final} e você foi reprovado(a).")

# Programa principal que solicita os dados e, depois,
# chama a função passando os dados como os parâmetros
# que a função exige.
nome = input("Qual o seu nome?")
materia = input("De qual matéria você quer calcular a nota final?: ")
n1 = float(input("Digite a nota do primeiro trimestre: "))
n2 = float(input("Digite a nota do segundo trimestre: "))
n3 = float(input("Digite a nota do terceiro trimestre: "))
mediaResultFinal(nome, materia, n1, n2, n3)

# Função para pegar o nome do estudante, a disciplina
# e mostrar as notas passadas como parâmetros no
# programa principal. Depois, calcular a média
# aritmética das notas e mostrar a mensagem com o
# nome do aluno, da disciplina, a nota final e se
# foi aprovado ou não.
def mediaResultFinal(aluno, mat, npt, nst, ntt):
    print(f"Olá, {aluno}! Vamos calcular sua nota final.")
    print(f"A disciplina escolhida é {mat}.")
    print(f"Suas notas são:\n1º Trim. {npt}\n2º Trim. {nst}\n3º Trim. {ntt}")
    n_final = round((npt + nst + ntt) / 3, 2)
    if n_final >= 6:
        print(f"{aluno}, sua nota final de {mat} é {n_final} e você foi aprovado(a).")
    else:
        print(f"{aluno}, sua nota final de {mat} é {n_final} e você foi reprovado(a).")

# Programa principal que solicita os dados e, depois,
# chama a função passando os dados como os parâmetros
# que a função exige.
nome = input("Qual o seu nome?")
materia = input("De qual matéria você quer calcular a nota final?: ")
n1 = float(input("Digite a nota do primeiro trimestre: "))
n2 = float(input("Digite a nota do segundo trimestre: "))
n3 = float(input("Digite a nota do terceiro trimestre: "))
mediaResultFinal(nome, materia, n1, n2, n3)