Python Descomplicado

1° edição

Iniciantes

Introdução

Python é uma linguagem de programação de alto nível, interpretada, orientada a objetos e de

propósito geral. Foi criada em 1991 por Guido van Rossum e desde então tem se tornado cada
vez mais popular, sendo atualmente uma das linguagens mais utilizadas no mundo da
computação.

O grande sucesso de Python se deve a sua simplicidade e facilidade de aprendizado, além da

sua versatilidade e eficiência em diversos tipos de aplicações, como desenvolvimento web,
científico, análise de dados, inteligência artificial e muitas outras.

Neste livro, você aprenderá os conceitos fundamentais de Python e como aplicá-los na prática
para desenvolver programas eficientes e funcionais. A partir de exemplos simples e intuitivos,
você irá adquirir as habilidades necessárias para criar suas próprias soluções em Python e se
tornar um programador de sucesso.

Ao longo dos capítulos, você será guiado desde a instalação e configuração do ambiente de
desenvolvimento, passando por temas como tipos de dados, estruturas de controle de fluxo,
funções, classes e objetos, até chegar em assuntos mais avançados como manipulação de
arquivos, acesso a banco de dados, desenvolvimento web e introdução à inteligência artificial.

Este livro é voltado para iniciantes em programação, mas também pode ser uma referência útil
para programadores experientes que desejam aprimorar suas habilidades em Python.
Esperamos que você aproveite bem essa jornada e se divirta programando em Python!
 Sumário

Resumo do que esse livro vai entrega a você :

 Instalação e configuração do ambiente de desenvolvimento:

 Classes e objetos

 Funções

 Estruturas de controle de fluxo:

 Sintaxe básica:

 SQLite ou SQLAlchemy

 Criar interfaces gráficas de usuário em Python, usando bibliotecas como tkinter,

PyQt ou wxPython.

 Trabalhar com XML e JSON em Python, usando as bibliotecas xml e json

 Escrever testes de unidade em Python, usando a biblioteca unittest.

• Crie uma janela simples usando a biblioteca Tkin...

• Booleans estendidos (bool):

• Contagem de letras
Vamos começa nossa aula de python!

Bora pra primeira aula

python :

Python é uma linguagem de programação de alto nível, interpretada, orientada a objetos e de

propósito geral. Ela foi criada por Guido van Rossum em 1991 e desde então tem se tornado
cada vez mais popular, sendo atualmente uma das linguagens mais utilizadas no mundo da
computação.

Uma das principais características de Python é a sua simplicidade e facilidade de aprendizado.

Ela possui uma sintaxe clara e intuitiva, o que a torna muito amigável para iniciantes em
programação, mas também é poderosa e versátil o suficiente para ser utilizada em projetos
complexos e de grande escala.

Python pode ser usada em diversas áreas, como desenvolvimento web, científico, análise de
dados, inteligência artificial e muitas outras. Ela possui uma grande comunidade de
desenvolvedores que contribuem para o seu crescimento e evolução constante, além de uma
vasta biblioteca de módulos e ferramentas que facilitam o desenvolvimento de programas em
Python.

Em resumo, Python é uma linguagem de programação de fácil aprendizado e grande poder,

utilizada em diversas áreas da computação e com uma comunidade ativa e engajada.

Porque é uma das mais usadas no mundo?

Python é uma das linguagens de programação mais utilizadas no mundo por diversas razões.
Algumas delas são:

1. Simplicidade: Python tem uma sintaxe clara e intuitiva, o que a torna fácil de aprender
e usar. Isso faz com que seja uma das linguagens mais populares para iniciantes em
programação.

2. Versatilidade: Python pode ser usada em diversas áreas, como desenvolvimento web,
científico, análise de dados, inteligência artificial e muitas outras. Ela possui uma
grande variedade de bibliotecas e frameworks que permitem o desenvolvimento de
projetos de diferentes tipos e tamanhos.
 3. Comunidade ativa: Python tem uma grande comunidade de desenvolvedores em todo
o mundo, que contribuem constantemente para o seu desenvolvimento e evolução.
Isso significa que há muitos recursos disponíveis online para ajudar programadores a
aprender e resolver problemas em Python.

4. Código aberto: Python é uma linguagem de programação de código aberto, o que

significa que é livre para uso e distribuição. Isso torna Python uma opção econômica
para projetos de desenvolvimento de software, pois não há custos de licenciamento
envolvidos.

5. Empresas utilizam Python: Grandes empresas, como Google, Facebook, Instagram,

Spotify, Netflix e muitas outras, usam Python em seus sistemas e serviços. Isso
aumenta a demanda por programadores Python qualificados e torna a linguagem
ainda mais popular.

Esses fatores contribuem para que Python seja uma das linguagens de programação mais
utilizadas no mundo atualmente.

Vamos começa nossa aula de python

Com :

Instalação e configuração do ambiente de desenvolvimento:

1. Baixe e instale a versão mais recente do Python em

https://www.python.org/downloads/. Certifique-se de escolher a versão apropriada
para o seu sistema operacional (Windows 32 bits ou 64 bits).

2. Abra o prompt de comando do Windows digitando “cmd” na barra de pesquisa do

menu Iniciar.

3. Digite “python” no prompt de comando e pressione Enter. Se o Python foi instalado

corretamente, você deve ver a versão do Python instalada e o prompt do
interpretador do Python (>>>) deve aparecer.

4. Instale um editor de código. Existem muitos editores de código gratuitos disponíveis

para Python, como o Visual Studio Code, PyCharm, Sublime Text, Notepad++ e muitos
outros. Baixe e instale o editor de sua preferência.
Estarei deixando uns links pra facilitar pra você usuário:

Visual Studio Code: https://code.visualstudio.com/download

PyCharm: https://www.jetbrains.com/pycharm/download/

Sublime Text: https://www.sublimetext.com/3

Notepad++: https://notepad-plus-plus.org/downloads/

Esses são apenas alguns dos editores de código disponíveis para Python. Há muitos outros
disponíveis gratuitamente na internet, por isso, você pode experimentar vários e escolher o
que mais lhe agrada.

5. Abra o editor de código e crie um novo arquivo com a extensão “.py”. Este será o
arquivo onde você escreverá seu código Python.

6. Depois de baixar e instalar um editor de código, você pode criar um novo arquivo com
a extensão “.py” e começar a escrever seu código Python. Em seguida, você pode
salvar o arquivo no seu computador e executá-lo a partir do prompt de comando do
Windows digitando “python nome_do_arquivo.py”.

O editor de código não é uma parte integrante do Python, mas é uma ferramenta importante
para tornar a escrita e o gerenciamento de programas Python mais fáceis e eficientes.

Agora, você está pronto para começar a escrever código Python em seu ambiente de
desenvolvimento! Lembre-se de salvar seus arquivos com frequência e executá-los no prompt
de comando do Windows digitando “python nome_do_arquivo.py”.

Agora iremos pra Sintaxe básica :

A sintaxe básica em Python se refere às regras e convenções que devem ser seguidas ao
escrever um código em Python. É importante seguir as regras de sintaxe para que o código seja
legível e possa ser entendido por outras pessoas.
Algumas das principais regras de sintaxe em Python incluem:

1. Indentação:

Python usa a indentação para delimitar blocos de código. É importante manter a mesma
quantidade de espaço em branco no início de cada linha dentro do mesmo bloco.
Normalmente, é recomendável usar quatro espaços para cada nível de indentação.

Exemplo :

# Exemplo de indentação correta

def somar(a, b):

Resultado = a + b

Return resultado

# Exemplo de indentação incorreta

def somar(a, b):

Resultado = a + b

Return resultado

2. Comentários:

Os comentários são usados para explicar o código e torná-lo mais legível. Em Python, os
comentários começam com o símbolo “#” e vão até o final da linha.

Exemplo :

# Este é um comentário em Python

# que se estende por várias linhas

# e é usado para explicar o código

3. Variáveis:

As variáveis em Python devem começar com uma letra e podem conter letras, números e
underscores. Os nomes das variáveis são case-sensitive, ou seja, “nome” e “Nome” são duas
variáveis diferentes.

Exemplo :

Python

# Exemplos de variáveis em Python

Nome = “Maria”
Idade = 25

Altura = 1.75

4. Funções:

As funções em Python são definidas usando a palavra-chave “def” seguida pelo nome da
função e pelos parâmetros entre parênteses. A função é finalizada com dois pontos e o bloco
de código correspondente é indentado.

Exemplo :

# Exemplo de função em Python

def dobrar(numero):

Resultado = numero * 2

Return resultado

5. Condicionais:

As condicionais em Python são criadas com as palavras-chave “if”, “elif” e “else”. O bloco de
código correspondente deve ser indentado corretamente.

Exemplo :

# Exemplo de condicional em Python

Idade = 18

If idade < 18:

Print(“Você é menor de idade.”)

Elif idade >= 18 and idade < 60:

Print(“Você é adulto.”)

Else:

Print(“Você é idoso.”)

6. Loops:

Python suporta dois tipos de loops: “for” e “while”. O bloco de código correspondente
também deve ser indentado corretamente.

Exemplo :

# Exemplo de loop for em Python

For i in range(10):
 Print(i)

Python

# Exemplo de loop while em Python

I=0

While i < 10:

Print(i)

I += 1

Esses são apenas alguns exemplos de código em Python que mostram algumas das regras de
sintaxe básica da linguagem.

Essas são apenas algumas das regras básicas de sintaxe em Python. É importante aprender e
seguir essas regras para escrever um código Python correto e legível.

Sintaxes básicas em Python:

Imprimir na tela:

Para imprimir algo na tela, use a função “print()”. Por exemplo, para imprimir a mensagem
“Olá, mundo!”, digite:

Print( “Olá, mundo!” )

Variáveis:

As variáveis são usadas para armazenar dados em um programa Python. Para criar uma
variável, escolha um nome para ela e atribua um valor a ela usando o operador “=””. Por
exemplo:

Nome = “Maria”

Idade = 25

Tipos de dados:

Python suporta diferentes tipos de dados, incluindo:

 Strings (cadeias de caracteres): representam sequências de caracteres, como nomes e

mensagens.
  Números inteiros (int): representam números inteiros, como idades e quantidades.

 Números de ponto flutuante (float): representam números decimais, como preços e

taxas.

 Booleanos (bool): representam valores verdadeiro (True) e falso (False).

Operadores aritméticos:

Python suporta vários operadores aritméticos para realizar operações matemáticas, como
adição (+), subtração (-), multiplicação (*), divisão (/) e exponenciação (**).

A = 10

B=5

Soma = a + b # soma = 15

Subtracao = a – b # subtracao = 5

Multiplicacao = a * b # multiplicacao = 50

Divisao = a / b # divisao = 2.0

Exponenciacao = a ** b # exponenciacao = 100000

Essas são apenas algumas das sintaxes básicas em Python. À medida que você progride no
aprendizado de Python, irá explorar muitos outros recursos e sintaxes que a linguagem
oferece.

 Listas:

Python

# Exemplo de lista em Python

Numeros = [1, 2, 3, 4, 5]

Python

# Acessando elementos de uma lista

Numeros = [1, 2, 3, 4, 5]

Primeiro_numero = numeros[0]

Ultimo_numero = numeros[-1]
Python

# Iterando sobre os elementos de uma lista

Numeros = [1, 2, 3, 4, 5]

For numero in numeros:

Print(numero)

 Dicionários:

Python

# Exemplo de dicionário em Python

Pessoa = {“nome”: “João”, “idade”: 25, “altura”: 1.75}

Python

# Acessando valores de um dicionário

Pessoa = {“nome”: “João”, “idade”: 25, “altura”: 1.75}

Nome_da_pessoa = pessoa[“nome”]

Python

# Iterando sobre os valores de um dicionário

Pessoa = {“nome”: “João”, “idade”: 25, “altura”: 1.75}

For chave, valor in pessoa.items():

Print(chave, valor)

 Strings:

Python

# Exemplo de string em Python

Mensagem = “Olá, mundo!”

Python

# Concatenando strings

Nome = “Maria”

Mensagem = “Olá, “ + nome + “!”

Python
# Formatando strings

Nome = “Maria”

Idade = 25

Mensagem = “Olá, {}! Você tem {} anos.”.format(nome, idade)

 Funções lambda:

Python

# Exemplo de função lambda em Python

Dobro = lambda x: x * 2

 Importando módulos:

Python

# Exemplo de importação de módulo em Python

Import math

# Usando funções do módulo math

Raiz_quadrada = math.sqrt(25)

Esses são apenas alguns exemplos adicionais de código Python que mostram diferentes
aspectos da sintaxe da linguagem

Agora que você já entendeu como funciona

É deu uma treinada

Vamos pro exercício :

Exercício :

Aqui estão cinco exercícios em Sintaxe básica do Python com explicações:

 Exibindo uma mensagem

Escreva um programa que exiba uma mensagem na tela.

Print(“Olá, mundo!”)

 Operações aritméticas

Escreva um programa que realize operações aritméticas básicas (adição, subtração,

multiplicação e divisão) com dois números.

A = 10

B=5

Soma = a + b

Subtracao = a – b

Multiplicacao = a * b

Divisao = a / b

Print(“Soma:”, soma)

Print(“Subtração:”, subtracao)

Print(“Multiplicação:”, multiplicacao)

Print(“Divisão:”, divisao)

 Controle de fluxo com if

Escreva um programa que verifique se um número é positivo, negativo ou zero.

Numero = 10

If numero > 0:

Print(“Número positivo”)

Elif numero < 0:

Print(“Número negativo”)
Else:

Print(“Zero”)

 Controle de fluxo com while

Escreva um programa que imprima os números de 1 a 10 usando um loop while.

I=1

While i <= 10:

Print(i)

I += 1

 Controle de fluxo com for

Escreva um programa que calcule a soma dos números de 1 a 10 usando um loop for.

Soma = 0

For i in range(1, 11):

Soma += i

Print(“Soma:”, soma)

Esses exercícios cobrem os conceitos básicos de sintaxe em Python, incluindo a utilização de

funções, variáveis, condicionais e loops.

 Conversão de tipos

Escreva um programa que leia um número inteiro digitado pelo usuário e exiba uma
mensagem informando se o número é par ou ímpar.

Numero = int(input(“Digite um número inteiro: “))

If numero % 2 == 0:

Print(“O número é par.”)

Else:

Print(“O número é ímpar.”)

 Listas

Escreva um programa que crie uma lista com os números de 1 a 10 e exiba a lista na tela.

Numeros = list(range(1, 11))

Print(numeros)

 Loops com break

Escreva um programa que peça ao usuário para digitar uma senha. Se a senha digitada for
“abc123”, exiba uma mensagem de sucesso e encerre o programa. Se o usuário digitar a senha
incorreta três vezes, exiba uma mensagem de erro e encerre o programa.

Senha_correta = “abc123”

Tentativas = 0

While True:

Senha = input(“Digite a senha: “)

If senha == senha_correta:

Print(“Senha correta!”)

Break

Else:

Tentativas += 1

If tentativas == 3:

Print(“Senha incorreta! O programa será encerrado.”)

 Break

 Funções

Escreva uma função que receba dois números como argumentos e exiba o resultado da divisão
do primeiro pelo segundo. Se o segundo número for zero, a função deve exibir uma mensagem
de erro.

Def divisao(num1, num2):

If num2 == 0:

Print(“Erro: divisão por zero.”)

Else:

Resultado = num1 / num2

Print(“Resultado:”, resultado)

Divisao(10, 2)

Divisao(10, 0)

 List comprehension

Escreva um programa que crie uma lista com os quadrados dos números de 1 a 10.

Quadrados = [x ** 2 for x in range

Contagem de letras

Escreva um programa que receba uma string e conte quantas vezes cada letra aparece na
string. O resultado deve ser exibido em ordem alfabética.

Exemplo:

Digite uma string: abracadabra

A: 5

B: 2

C: 1

D: 1

R: 2

Números primos

Escreva uma função que receba um número inteiro e verifique se ele é primo ou não. O
resultado deve ser exibido na tela.

FizzBuzz

Escreva um programa que imprima os números de 1 a 100. Para múltiplos de 3, em vez do

número, imprima “Fizz”. Para múltiplos de 5, imprima “Buzz”. Para números que são múltiplos
de 3 e 5, imprima “FizzBuzz”.

Análise de dados

Escreva um programa que receba uma lista de números e exiba a soma, média, valor mínimo e
valor máximo da lista.

Adivinhe o número

Escreva um programa que gere um número aleatório entre 1 e 100 e peça para o usuário
adivinhar o número. O programa deve informar se o número digitado é maior ou menor do
que o número gerado, até que o usuário acerte o número. O programa deve informar também
quantas tentativas foram necessárias para acertar o número.

 Contagem de letras

Nesse exercício, você precisa receber uma string do usuário e contar quantas vezes cada letra
aparece nessa string. Para isso, você pode utilizar um dicionário para armazenar a contagem
de cada letra. Percorra cada letra da string e atualize o valor correspondente no dicionário.
Depois, basta percorrer o dicionário em ordem alfabética e exibir o resultado.

 Números primos
Para verificar se um número é primo ou não, você pode percorrer os números de 2 até a raiz
quadrada do número em questão e verificar se há algum divisor inteiro. Se não houver, o
número é primo. Caso contrário, não é.

 FizzBuzz

Esse exercício é bastante comum em processos seletivos de empresas que usam Python. Você
precisa percorrer os números de 1 a 100 e verificar se são múltiplos de 3, 5 ou ambos. Para
isso, você pode utilizar o operador %, que retorna o resto da divisão. Se o resto for zero, o
número é múltiplo. Basta então imprimir “Fizz”, “Buzz” ou “FizzBuzz” de acordo com as regras.

 Análise de dados

Nesse exercício, você precisa receber uma lista de números e calcular a soma, média, valor
mínimo e valor máximo. Para calcular a soma, basta percorrer a lista e ir somando os valores.
Para calcular a média, divida a soma pelo tamanho da lista. Para encontrar o valor mínimo e
máximo, utilize as funções min e max do Python.

 Adivinhe o número

Nesse exercício, você precisa gerar um número aleatório entre 1 e 100 e pedir para o usuário
adivinhar o número. Para gerar o número aleatório, você pode utilizar a função randint do
módulo random. Depois, basta pedir para o usuário digitar um número e verificar se é igual ao
número gerado. Se não for, informe se o número é maior ou menor e continue pedindo para o
usuário tentar novamente. Quando o usuário acertar o número, exiba quantas tentativas
foram necessárias.

Exemplo
Nesse código, a função “ count_letters “ “recebe uma string “ s “como parâmetro. Em
seguida, é criado um dicionário ” letter_count “ para armazenar a contagem de cada letra. O
laço “ for “ percorre cada letra da string e verifica se ela é uma letra do alfabeto. Se for,
converte a letra para minúsculo e atualiza o valor correspondente no dicionário.

Depois, o dicionário é percorrido em ordem alfabética e os valores são exibidos na tela. A

função sorted é usada para ordenar as chaves do dicionário em ordem alfabética.

Mais Exercícios :

Sintaxe básica

 Cálculo de fatorial:

Crie uma função que receba um número inteiro e retorne o fatorial desse número. O fatorial
de um número é dado pela multiplicação de todos os números inteiros positivos menores ou
iguais a ele. Por exemplo, o fatorial de 5 é 5 x 4 x 3 x 2 x 1 = 120.

 Verificação de palíndromo:

Crie uma função que receba uma string e verifique se ela é um palíndromo, ou seja, se pode
ser lida da mesma forma de trás para frente. Por exemplo, a string “arara” é um palíndromo.

 Cálculo de média aritmética:

Crie uma função que receba uma lista de números e retorne a média aritmética desses
números.
  Ordenação de lista:

Crie uma função que receba uma lista de números e retorne uma nova lista com os mesmos
números ordenados em ordem crescente.

 Cálculo de área de um círculo:

Crie uma função que receba o raio de um círculo e retorne a área desse círculo. A fórmula para
o cálculo da área de um círculo é A = pi x r^2, onde pi é uma constante aproximadamente igual
a 3.14159 e r é o raio do círculo.

 Cálculo de fatorial:

Def fatorial(n):

If n == 0:

Return 1

Else:

Return n * fatorial(n-1)

Numero = int(input(“Digite um número inteiro: “))

Resultado = fatorial(numero)

Print(f”O fatorial de {numero} é {resultado}”)

 Verificação de palíndromo:

Def palindromo(palavra):

Palavra = palavra.lower()

Inverso = palavra[::-1]

If palavra == inverso:

Return True
 Else:

Return False

Texto = input(“Digite uma palavra ou frase: “)

If palindromo(texto):

Print(f”{texto} é um palíndromo!”)

Else:

Print(f”{texto} não é um palíndromo.”)

 Cálculo de média aritmética:

Def media(numeros):

Soma = sum(numeros)

N = len(numeros)

Media = soma / n

Return media

Lista = [2, 4, 6, 8, 10]

Resultado = media(lista)

Print(f”A média dos números {lista} é {resultado}”)

 Ordenação de lista:

Def ordena_lista(numeros):

Numeros_ordenados = sorted(numeros)

Return numeros_ordenados

Lista = [3, 7, 1, 9, 4]

Lista_ordenada = ordena_lista(lista)
Print(f”A lista {lista} ordenada fica assim: {lista_ordenada}”)

 Cálculo de área de um círculo:

Def area_circulo(raio):

Pi = 3.14159

Area = pi * (raio ** 2)

Return area

Raio = float(input(“Digite o raio do círculo: “))

Resultado = area_circulo(raio)

Print(f”A área do círculo de raio {raio} é {resultado}”)

Agora que você Já aprendeu a Instalação, Sintaxe básica

Agora vamos pra Tipos de dados

Tipos de dados:

Tipos de dados em programação referem-se às diferentes categorias de informações que

podem ser armazenadas e manipuladas por um programa. Em Python, existem vários tipos de
dados, incluindo:

 Números:

números inteiros, números de ponto flutuante e números complexos.

# Números inteiros

Num_int = 10

# Números de ponto flutuante

Num_float = 3.14
# Números complexos

Num_complex = 2 + 3j

 Strings:

sequências de caracteres, como palavras, frases ou parágrafos.

# Strings simples

String1 = “Olá, mundo!”

# Strings com aspas simples

String2 = ‘Eu amo Python.’

# Strings multilinhas

String3 = “””Este é um exemplo

De uma string

Multilinha.”””

 Booleanos:

valores True ou False, usados para expressar lógica e condições.

# Valores booleanos

Verdadeiro = True

Falso = False

 Listas:

coleções ordenadas de valores, que podem ser de diferentes tipos de dados.

# Lista de números inteiros

Lista1 = [1, 2, 3, 4, 5]

# Lista de strings
Lista2 = [“maçã”, “banana”, “laranja”]

# Lista de valores mistos

Lista3 = [1, “dois”, 3.0, True]

 Tuplas:

semelhante a listas, mas são imutáveis, ou seja, não podem ser modificadas após a criação.

# Tupla de números inteiros

Tupla1 = (1, 2, 3, 4, 5)

# Tupla de strings

Tupla2 = (“maçã”, “banana”, “laranja”)

# Tupla de valores mistos

Tupla3 = (1, “dois”, 3.0, True)

 Conjuntos:

coleções não ordenadas de valores únicos.

# Conjunto de números inteiros

Conjunto1 = {1, 2, 3, 4, 5}

# Conjunto de strings

Conjunto2 = {“maçã”, “banana”, “laranja”}

# Conjunto de valores mistos

Conjunto3 = {1, “dois”, 3.0, True}

 Dicionários:

coleções de pares chave-valor, onde cada valor é acessado por uma chave única.
# Dicionário com pares chave-valor de string

Dicionario1 = {“nome”: “Maria”, “idade”: 30, “cidade”: “São Paulo”}

# Dicionário com pares chave-valor de número inteiro

Dicionario2 = {1: “maçã”, 2: “banana”, 3: “laranja”}

# Dicionário com valores mistos

Dicionario3 = {“nome”: “João”, “idade”: 25, “cidade”: “Rio de Janeiro”, 4: True}

 Bytes e bytearray:

são usados para representar sequências de bytes. Bytes são imutáveis, enquanto bytearray
pode ser modificado. Eles são criados usando a letra ‘b’ antes de aspas simples ou duplas. Por
exemplo, b’hello’, bytearray(b’world’).

# Bytes

Bytes1 = b’abc’

# bytearray

Bytearray1 = bytearray(b’abc’)

 Range:

é uma sequência imutável de números usada para iterar em um loop for. É criado usando a
função range(), que pode receber um, dois ou três argumentos. Por exemplo, range(10) gera
uma sequência de números de 0 a 9.

# Range com um argumento

Range1 = range(10)

# Range com dois argumentos

Range2 = range(1, 10)

# Range com três argumentos

Range3 = range(1, 10, 2)

 None:

é usado para representar a ausência de valor. É comumente usado para inicializar variáveis ou
retornar valores de função que não retornam nenhum valor.

# Valor nulo

Nulo = None

Em Python, o tipo de dados de uma variável é determinado dinamicamente pelo valor que ela
contém. Isso significa que não é necessário declarar explicitamente o tipo de dados de uma
variável ao criá-la, como em algumas outras linguagens de programação. Em vez disso, o tipo
de dados é atribuído automaticamente quando um valor é atribuído à variável. Por exemplo,
se você atribuir um número inteiro a uma variável, o Python reconhecerá que o tipo de dados
é um número inteiro.

 Conjuntos (set):

são coleções não ordenadas e sem elementos duplicados. Eles são criados usando chaves {} ou
a função set(). Por exemplo, {1, 2, 3} ou set([4, 5, 6]).

# criando um conjunto

Set1 = {1, 2, 3, 4, 5}

# criando um conjunto usando a função set()

Set2 = set([4, 5, 6, 7])

# imprimindo os conjuntos

Print(set1)

Print(set2)
Saída

{1, 2, 3, 4, 5}

{4, 5, 6, 7}

 Frozensets:

são conjuntos imutáveis, criados usando a função frozenset(). Eles são úteis quando você
precisa de um conjunto como chave em um dicionário.

# criando um frozenset

Frozen_set = frozenset([1, 2, 3, 4, 5])

# imprimindo o frozenset

Print(frozen_set)

Saída:

Frozenset({1, 2, 3, 4, 5})

 Números complexos (complex):

são usados para representar números complexos, com uma parte real e uma parte imaginária.
Eles são criados usando a letra ‘j’ para representar a parte imaginária. Por exemplo, 3 + 2j.

# criando um número complexo

Num_complexo = 3 + 2j

# imprimindo o número complexo

Print(num_complexo)

Saída

(3+2j)
  Booleans estendidos (bool):

embora Python tenha apenas os valores True e False para o tipo bool, você pode usar esses
valores em operações aritméticas e de comparação. True é considerado como 1 e False é
considerado como 0.

# operações aritméticas com booleanos

Print(True + True) # saída: 2

Print(True + False) # saída: 1

Print(False + False) # saída: 0

# operações de comparação com booleanos

Print(True == 1) # saída: True

Print(False == 0) # saída: True

 Matriz

é um tipo de dado utilizado na matemática e na ciência da computação para representar uma

coleção de valores dispostos em linhas e colunas. Na programação, uma matriz é uma
estrutura de dados bidimensional, onde cada elemento é acessado por um par de índices
(linha e coluna).

# Criando uma matriz 3x3

Matriz = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]

# Imprimindo a matriz

For linha in matriz:

Print(linha)

Neste exemplo, criamos uma matriz 3x3 com valores inteiros. Cada linha da matriz é
representada por uma lista, e as três listas são agrupadas em outra lista, formando assim a
matriz. Depois, imprimimos a matriz percorrendo cada linha e imprimindo seus valores. O
resultado seria:

[1, 2, 3]

[4, 5, 6]
[7, 8, 9]

 Números hexadecimais (hex):

são usados para representar números em notação hexadecimal. Eles são criados usando a
função hex(), que retorna uma string com o valor hexadecimal. Por exemplo, hex(10) retorna
‘0xa’.

# convertendo um número para hexadecimal

Num_hex = hex(255)

# imprimindo o número hexadecimal

Print(num_hex)

Saída:

0xff

Obs: o número hexadecimal é retornado como uma string

Mas tem maridos tipo de dados não existe só ele

Vou coloca 40 tipo de dado aqui e você verá :

Estão 40 tipos de dados:

 Inteiro (int)
 Flutuante (float)
 Booleano (bool)
 Complexo (complex)
 String (str)
 Lista (list)
 Tupla (tuple)
 Dicionário (dict)
 Conjunto (set)
 Nenhum (NoneType)
 Objeto (object)
 Função (function)
 Gerador (generator)
 Classe (class)
 Módulo (module)
 Arquivo (file)
  Bytes (bytes)
 ByteArray (bytearray)
 Range (range)
 Enum (enum)
 Decimal (decimal)
 Fração (fraction)
 Data (date)
 Hora (time)
 Tempo (datetime)
 Timestamp (timestamp)
 Intervalo de tempo (timedelta)
 Vetor (array)
 Matriz (matrix)
 Conjunto de bits (bitset)
 Registro (record)
 Ponteiro (pointer)
 Endereço (address)
 Tipagem dinâmica (dynamic typing)
 Tipagem estática (static typing)
 Tipos personalizados (user-defined types)
 JSON (JavaScript Object Notation)
 XML (Extensible Markup Language)
 YAML (YAML Ain’t Markup Language)
 BSON (Binary JSON)

 Inteiro (int):

X = 10

Y = -5

 Float:

X = 3.14

Y = -2.5

 String (str):

X = “Olá, mundo!”

Y = ‘Python é incrível’
  Boolean (bool):

X = True

Y = False

 Lista (list):

X = [1, 2, 3, 4, 5]

Y = [‘maçã’, ‘banana’, ‘laranja’]

 Tupla (tuple):

X = (1, 2, 3, 4, 5)

Y = (‘maçã’, ‘banana’, ‘laranja’)

 Dicionário (dict):

X = {‘nome’: ‘João’, ‘idade’: 25, ‘cidade’: ‘São Paulo’}

Y = {‘marca’: ‘Apple’, ‘modelo’: ‘iPhone 12’, ‘ano’: 2021}

 Conjunto (set):

X = {1, 2, 3, 4, 5}

Y = {‘maçã’, ‘banana’, ‘laranja’}

 Frozenset:

X = frozenset([1, 2, 3, 4, 5])

Y = frozenset((‘maçã’, ‘banana’, ‘laranja’))

  Número complexo (complex):

X = 3 + 2j

Y = -1j

 Boolean estendido (bool):

X = True + True

Y = False * 10

 Número hexadecimal (hex):

X = hex(10)

Y = hex(255)

Bora pra o exercício :

 Crie uma lista de números inteiros e use um loop para somar todos os números e
imprimir o resultado.
 Crie um dicionário que represente um livro, com as chaves “título”, “autor” e “ano de
publicação”. Em seguida, imprima o título do livro.
 Crie um conjunto de cores e adicione algumas cores diferentes. Em seguida, use a
função len() para imprimir quantas cores há no conjunto.
 Crie uma string com o valor “1234” e converta-a em um número inteiro.
 Crie um número complexo com a parte real igual a 3 e a parte imaginária igual a 4. Em
seguida, imprima o módulo do número complexo (ou seja, sua distância até a origem
do plano cartesiano).

Crie uma lista com os números pares de 2 a 10 e imprima na tela:

Numeros_pares = [2, 4, 6, 8, 10]

Print(numeros_pares)

Crie um dicionário com 3 chaves e seus respectivos valores e imprima na tela:

Dicionario = {“chave1”: “valor1”, “chave2”: “valor2”, “chave3”: “valor3”}

Print(dicionario)

 Crie um conjunto com os números de 1 a 5 e um conjunto com os números de 4 a 8, e

faça a interseção entre eles:

Conjunto1 = {1, 2, 3, 4, 5}

Conjunto2 = {4, 5, 6, 7, 8}

Intersecao = conjunto1.intersection(conjunto2)

Print(intersecao)

 Crie uma tupla com 3 elementos e tente alterar o valor do primeiro elemento:

Tupla = (1, 2, 3)

Tupla[0] = 4

# Erro: tuplas são imutáveis e não podem ser alteradas

 Crie uma variável do tipo booleano e use operadores lógicos para verificar se ela é
verdadeira ou falsa:

Var_booleana = True

Print(var_booleana and False)

Print(var_booleana or False)

Print(not var_booleana)

1. Crie uma matriz 3x3 e exiba a soma de todos os seus elementos.

2. Crie duas matrizes 2x2 e exiba o resultado da multiplicação entre elas.

3. Crie uma matriz 4x4 e exiba todos os seus elementos que são divisíveis por 3.

4. Crie uma matriz 5x5 com valores aleatórios entre 0 e 9 e exiba a soma dos elementos
da diagonal principal.
 5. Crie uma matriz 3x3 e verifique se ela é simétrica (ou seja, se a matriz transposta é
igual à matriz original).

Segue o código para resolver os exercícios:

1)

Matriz = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]

Soma = 0

For linha in matriz:

For elemento in linha:

Soma += elemento

Print(soma)

2)

Matriz1 = [[1, 2], [3, 4]]

Matriz2 = [[5, 6], [7, 8]]

Resultado = [[0, 0], [0, 0]]

For i in range(len(matriz1)):

For j in range(len(matriz2[0])):

For k in range(len(matriz2)):

Resultado[i][j] += matriz1[i][k] * matriz2[k][j]

For linha in resultado:

Print(linha)

3)
Matriz = [[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12], [13, 14, 15, 16]]

Divisiveis_por_3 = []

For linha in matriz:

For elemento in linha:

If elemento % 3 == 0:

Divisiveis_por_3.append(elemento)

Print(divisiveis_por_3)

4)

Import random

Matriz = [[random.randint(0, 9) for i in range(5)] for j in range(5)]

Soma_diagonal = 0

For i in range(len(matriz)):

Soma_diagonal += matriz[i][i]

Print(soma_diagonal)

5)

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

Simetrica = True

For i in range(len(matriz)):

For j in range(len(matriz)):

If matriz[i][j] != matriz[j][i]:

Simetrica = False
If simetrica:

Print(“A matriz é simétrica!”)

Else:

Print(“A matriz não é simétrica.”)

Código para o tipo de dados Tempo (datetime):

1. Crie um objeto de data para representar a data atual e imprima-o no formato

AAAA-MM-DD.

Import datetime

Agora = datetime.date.today()

Print(agora.strftime(‘%Y-%m-%d’))

2. Crie um objeto de tempo para representar a hora atual e imprima-o no

formato HH:MM:SS.

Import datetime

Agora = datetime.datetime.now()

Hora_atual = agora.time()

Print(hora_atual.strftime(‘%H:%M:%S’))

3. Crie um objeto de data e hora para representar a data e hora atuais e

imprima-o no formato AAAA-MM-DD HH:MM:SS.

Import datetime

Agora = datetime.datetime.now()
Print(agora.strftime(‘%Y-%m-%d %H:%M:%S’))

4. Crie um objeto de data e hora para representar a data e hora de 1 de janeiro

de 2022 às 12h30min.

Import datetime

Data_hora = datetime.datetime(2022, 1, 1, 12, 30, 0)

Print(data_hora)

5. Crie um objeto de data e hora para representar a data e hora atual em UTC
(tempo universal coordenado).

Import datetime

Agora = datetime.datetime.utcnow()

Print(agora.strftime(‘%Y-%m-%d %H:%M:%S UTC’))

Agora que você já visualizou e viu como aprende faze dados em seu python

Vamos pra nossa aula aula sobre

Sobre :

Estruturas de controle de fluxo:

Estruturas de controle de fluxo são instruções que permitem que um programa tome decisões
ou execute repetições com base em certas condições. Essas estruturas são importantes porque
permitem que o programa seja mais dinâmico e flexível, permitindo que ele ajuste seu
comportamento de acordo com diferentes cenários.

 As principais estruturas de controle de fluxo em Python são:

1. If/elif/else: Essa estrutura permite que o programa execute um bloco de

código se uma determinada condição for verdadeira. Se a condição não for
 verdadeira, é possível definir outros blocos de código para executar. A
palavra-chave “elif” significa “else if” e permite que você especifique uma
nova condição para verificar se a condição anterior falhou.

2. For/else: Essa estrutura permite que o programa execute um bloco de

código um número definido de vezes, geralmente com base em uma
sequência de valores. É possível definir um bloco de código para executar
quando o loop terminar normalmente ou quando for interrompido usando
a palavra-chave “break”.

3. While/else: Essa estrutura permite que o programa execute um bloco de

código enquanto uma determinada condição for verdadeira. É possível
definir um bloco de código para executar quando o loop terminar
normalmente ou quando for interrompido usando a palavra-chave
“break”.

4. Try/except/else/finally: Essa estrutura permite que o programa tente

executar um bloco de código, mas capture e lide com quaisquer erros que
possam ocorrer. É possível definir blocos de código para executar quando
o bloco try terminar normalmente, quando ocorrer um erro específico ou
quando o bloco finally for executado, independentemente de ocorrer um
erro ou não.

5. Switch/case: Embora Python não tenha uma estrutura de controle de fluxo

switch/case nativa, é possível emular essa funcionalidade usando um
dicionário. Nesse caso, a chave do dicionário representa o valor a ser
testado e o valor associado à chave representa o bloco de código a ser
executado se a chave corresponder ao valor de teste.

6. Compreensão de lista (list comprehension): uma forma concisa e poderosa

de criar listas com base em uma outra lista ou iterável.

7. Compreensão de dicionário (dictionary comprehension): semelhante à

compreensão de lista, mas para a criação de dicionários.

8. Compreensão de conjunto (set comprehension): semelhante à

compreensão de lista, mas para a criação de conjuntos.
 9. Expressões lambda (lambda expressions): funções anônimas e de uma
única linha que podem ser usadas em situações em que uma função
completa seria excessiva.

10. Try/except/finally: uma estrutura de controle de fluxo usada para tratar

exceções e erros em tempo de execução.

11. Decoradores (decorators): uma técnica avançada que permite adicionar

comportamento a uma função ou classe existente sem modificá-los
diretamente.

12. Geradores (generators): uma forma eficiente de criar sequências iteráveis

em Python, usando a palavra-chave yield em vez de return.

13. Context managers: uma técnica para garantir que um recurso seja alocado
e desalocado corretamente em um bloco de código, usando a sintaxe with.

14. Expressões condicionais (ternary expressions): uma forma concisa de

escrever uma expressão condicional de uma única linha

Essas são apenas algumas das estruturas de controle de fluxo disponíveis em Python, mas elas
cobrem a maioria dos casos de uso comuns. Combinando essas estruturas com operadores
lógicos e comparativos, é possível criar fluxos de controle sofisticados e dinâmicos em seus
programas.

Irei explicar cada uma a você( 1 ) au ( 14 )

2. If/elif/else
A estrutura de controle if/elif/else é usada para executar diferentes blocos de código
dependendo das condições definidas.

O código abaixo é um exemplo simples que usa a estrutura if/else para imprimir uma
mensagem dependendo se a idade de uma pessoa é maior ou menor que 18 anos:

Idade = 20

If idade >= 18:

 Print(“Você é maior de idade.”)
Else:
Print(“Você é menor de idade.”)

Se a variável idade for maior ou igual a 18, a mensagem “Você é maior de idade” será
impressa. Caso contrário, a mensagem “Você é menor de idade” será impressa.

Podemos adicionar condições adicionais usando a estrutura elif (uma abreviação para
“else if”). O código abaixo adiciona uma condição para imprimir uma mensagem
personalizada para pessoas com idade entre 13 e 17 anos:

Idade = 15

If idade >= 18:

Print(“Você é maior de idade.”)
Elif idade >= 13:
Print(“Você é um adolescente.”)
Else:
Print(“Você é uma criança.”)

Se a idade for maior ou igual a 18, a mensagem “Você é maior de idade” será
impressa. Se a idade for menor que 18, a próxima condição será testada. Se a idade for
maior ou igual a 13, a mensagem “Você é um adolescente” será impressa. Caso
contrário, a mensagem “Você é uma criança” será impressa.

A estrutura if/elif/else pode ser usada com qualquer tipo de condição, não apenas com
comparações numéricas. Por exemplo, o código abaixo usa a estrutura para verificar se
uma string contém uma determinada palavra:

Frase = “O gato comeu meu queijo”

If “gato” in frase:
Print(“A frase contém a palavra ‘gato’.”)
Else:
Print(“A frase não contém a palavra ‘gato’.”)

Se a string frase contiver a palavra “gato”, a mensagem “A frase contém a palavra

‘gato’” será impressa. Caso contrário, a mensagem “A frase não contém a palavra
‘gato’” será impressa.

3. For/else:

A estrutura for/else em Python é usada para executar uma sequência de comandos em um

loop for e, opcionalmente, executar um bloco de código adicional se o loop for concluído com
êxito. O bloco de código adicional é executado somente se o loop for concluído sem ser
interrompido por uma instrução break.

A sintaxe do for/else é a seguinte:

For item in lista:

# comandos a serem executados para cada item na lista

Else:

# comandos a serem executados após o término do loop for

Se o loop for concluído com êxito (ou seja, sem uma instrução break), o bloco de código na
cláusula else será executado.

Aqui está um exemplo:

Numeros = [1, 2, 3, 4, 5]

For numero in numeros:

If numero == 3:

Print(“Pulei o número 3!”)

Continue

Print(numero)

Else:

Print(“Cheguei ao fim da lista!”)

Neste exemplo, o loop for itera sobre a lista numeros. Se o número atual for igual a 3, o loop
continua sem imprimir o número atual. Se o número atual não for igual a 3, o loop imprime o
número atual. Quando o loop for concluído com êxito, a mensagem “Cheguei ao fim da lista!”
será impressa. Se houver uma instrução break dentro do loop, o bloco else não será
executado.

Além disso, o for/else pode ser usado para verificar se um item está presente em uma lista:

Alunos = [“João”, “Maria”, “Pedro”, “Lucas”]

For aluno in alunos:

 If aluno == “Fernanda”:

Print(“Fernanda está na lista!”)

Break

Else:

Print(“Fernanda não está na lista!”)

Neste exemplo, o loop for itera sobre a lista alunos e verifica se o item “Fernanda” está
presente. Se “Fernanda” estiver presente, o loop é interrompido e a mensagem “Fernanda
está na lista!” é impressa. Se “Fernanda” não estiver presente, o loop é concluído com êxito e
a mensagem “Fernanda não está na lista!” é impressa.

4. While/else

A estrutura de controle de fluxo while é usada para repetir um bloco de código enquanto uma
determinada condição for verdadeira. O bloco de código dentro do while será executado
repetidamente até que a condição se torne falsa.

O bloco de código dentro do while pode ser interrompido por uma instrução break se uma
determinada condição for atendida. Além disso, podemos usar a instrução continue para pular
uma iteração e continuar com a próxima.

A cláusula else pode ser usada juntamente com a estrutura while para executar um bloco de
código quando a condição se torna falsa. O bloco de código dentro do else só será executado
se a cláusula while terminar normalmente, sem ser interrompido por uma instrução break.

Aqui está um exemplo de como usar a estrutura while/else em Python:

I=1

While i < 10:

Print(i)

I += 1

Else:

Print(“Loop concluído com sucesso”)

Neste exemplo, o loop while imprimirá os números de 1 a 9 e, em seguida, o bloco de código

dentro da cláusula else será executado, imprimindo a mensagem “Loop concluído com
sucesso”. Se usássemos uma instrução break para interromper o loop, o bloco de código
dentro do else não seria executado.

5. Try/except/else/finally

A estrutura try/except/else/finally é usada para lidar com exceções em Python. Ela permite
que você execute um bloco de código e capture exceções que possam ocorrer durante a sua
execução. O bloco de código dentro do try é executado primeiro, e se não houver exceções, o
bloco dentro do else é executado. O bloco dentro do finally é executado sempre,
independentemente de haver exceções ou não.

A sintaxe é a seguinte:

Try:

# bloco de código que pode gerar exceções

Except Excecao1:

# bloco de código para tratar a exceção Excecao1

Except Excecao2:

# bloco de código para tratar a exceção Excecao2

Else:

# bloco de código que é executado se não houver exceções

Finally:

# bloco de código que é executado sempre

Aqui está um exemplo de código que mostra como usar essa estrutura:

Def dividir(a, b):

Try:

Resultado = a / b

Except ZeroDivisionError:

Print(“Não é possível dividir por zero”)

Else:

Print(“O resultado é:”, resultado)

Finally:
 Print(“Operação concluída”)

Dividir(4, 2)

Dividir(4, 0)

Neste exemplo, a função dividir() recebe dois argumentos e tenta dividir o primeiro pelo
segundo. Se o segundo argumento for zero, uma exceção ZeroDivisionError será gerada. O
bloco except trata essa exceção e imprime uma mensagem de erro. Se não houver exceções, o
bloco else é executado e imprime o resultado da divisão. Em ambos os casos, o bloco finally é
executado e imprime a mensagem “Operação concluída”.

Output:

O resultado é: 2.0

Não é possível dividir por zero

Operação concluída

Operação concluída

6. Try/except/finally

A estrutura try/except/finally é usada para lidar com exceções em Python. É usada para tentar
executar um bloco de código e, se ocorrer uma exceção, lidar com ela de uma maneira
apropriada. Aqui está um exemplo de código:

Try:

X=5/0

Except ZeroDivisionError:

Print(“Erro: divisão por zero”)

Finally:

Print(“Este bloco será sempre executado”)

Neste exemplo, estamos tentando dividir o número 5 por zero, o que resulta em uma exceção
ZeroDivisionError. Usamos a estrutura try/except para lidar com essa exceção e imprimir uma
mensagem de erro apropriada. Também usamos o bloco finally para garantir que uma
mensagem seja sempre exibida, independentemente de haver uma exceção ou não.
A estrutura try/except também pode ser usada com vários tipos de exceção. Por exemplo:

Try:

X = int(input(“Digite um número: “))

Y = 10 / x

Except ValueError:

Print(“Erro: o valor digitado não é um número”)

Except ZeroDivisionError:

Print(“Erro: divisão por zero”)

Else:

Print(“O resultado é:”, y)

Finally:

Print(“Este bloco será sempre executado”)

Neste exemplo, estamos solicitando ao usuário que digite um número. Se o usuário inserir algo
que não seja um número, uma exceção ValueError será gerada e uma mensagem de erro será
exibida. Se o usuário inserir zero, uma exceção ZeroDivisionError será gerada e outra
mensagem de erro será exibida. Se o usuário inserir um número válido, a divisão será realizada
e o resultado será exibido. O bloco finally será sempre executado, independentemente de
haver uma exceção ou não.

7. Compreensão de lista (list comprehension):

Compreensão de lista (list comprehension) é uma forma concisa de criar listas em Python. Em
vez de escrever um loop for tradicional para adicionar elementos a uma lista, você pode usar a
sintaxe da compreensão de lista para criar a lista diretamente. A sintaxe básica é a seguinte:

New_list = [expression for item in iterable if condition]

Isso significa que para cada item em um iterável, a expressão é avaliada e o resultado é
adicionado à nova lista se a condição for verdadeira.

Aqui estão alguns exemplos de compreensão de lista:

Exemplo 1: criar uma lista de números pares de 0 a 10

Even_numbers = [x for x in range(11) if x % 2 == 0]

Print(even_numbers)

# saída: [0, 2, 4, 6, 8, 10]

Neste exemplo, usamos a função range() para criar um iterável com os números de 0 a 10. Em
seguida, usamos a compreensão de lista para criar uma nova lista contendo apenas os
números pares.

Exemplo 2: criar uma lista de quadrados de números de 1 a 5

Squares = [x**2 for x in range(1, 6)]

Print(squares)

# saída: [1, 4, 9, 16, 25]

Neste exemplo, usamos a função range() novamente para criar um iterável com os números de
1 a 5. Em seguida, usamos a compreensão de lista para criar uma nova lista contendo os
quadrados de cada número.

Exemplo 3: criar uma lista de palavras que começam com a letra “a” de uma lista de palavras

Words = [“apple”, “banana”, “orange”, “avocado”, “grape”]

A_words = [word for word in words if word.startswith(“a”)]

Print(a_words)

# saída: [“apple”, “avocado”]

Neste exemplo, usamos a compreensão de lista para criar uma nova lista contendo apenas as
palavras que começam com a letra “a” da lista original de palavras.

A compreensão de lista também pode incluir várias expressões e loops for aninhados,
permitindo a criação de listas mais complexas.

8. Compreensão de dicionário (dictionary comprehension):

Compreensão de dicionário (dictionary comprehension) é uma maneira concisa de criar um
dicionário usando uma única linha de código. A sintaxe é semelhante à compreensão de lista,
mas em vez de criar uma lista, cria-se um dicionário.

A sintaxe básica é a seguinte:

{chave: valor for item in iterável}

Onde chave e valor são as chaves e valores que você deseja inserir no dicionário, item é cada
elemento no iterável (como uma lista ou um conjunto), e iterável é a lista ou conjunto de
elementos.

Aqui está um exemplo de como usar a compreensão de dicionário para criar um dicionário a
partir de uma lista:

Lista = [1, 2, 3, 4, 5]

Dicionario = {numero: numero ** 2 for numero in lista}

Print(dicionario)

Saída:

{1: 1, 2: 4, 3: 9, 4: 16, 5: 25}

Neste exemplo, a compreensão de dicionário cria um novo dicionário, onde cada chave é um
número da lista e o valor é o quadrado desse número.

Também é possível adicionar uma condição para filtrar os elementos que são incluídos no
dicionário:

Lista = [1, 2, 3, 4, 5]

Dicionario = {numero: numero ** 2 for numero in lista if numero % 2 == 0}

Print(dicionario)
Saída:

{2: 4, 4: 16}

Neste exemplo, apenas os números pares são incluídos no dicionário, pois a condição if
numero % 2 == 0 filtra os elementos ímpares.

9. Compreensão de conjunto (set comprehension):

A compreensão de conjunto (set comprehension) é uma técnica utilizada em linguagens de

programação para criar conjuntos de elementos a partir de uma expressão ou condição. Ela
permite criar conjuntos de forma mais concisa e legível do que utilizando loops e condicionais.

Em Python, a compreensão de conjunto é escrita entre chaves ({}) e consiste em uma

expressão seguida de um loop e/ou uma condição. Veja alguns exemplos:

Criando um conjunto com os quadrados dos números de 1 a 10:

Squares = {x*x for x in range(1, 11)}

Print(squares) # {1, 4, 9, 16, 25, 36, 49, 64, 81, 100}

Criando um conjunto com as letras únicas de uma string:

Word = “hello”

Unique_letters = {letter for letter in word}

Print(unique_letters) # {‘e’, ‘o’, ‘l’, ‘h’}

Criando um conjunto com os números pares de uma lista:

Numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

Even_numbers = {num for num in numbers if num % 2 == 0}

Print(even_numbers) # {2, 4, 6, 8, 10}

Em outras linguagens de programação, como JavaScript e Ruby, a sintaxe para a compreensão
de conjunto pode variar, mas o conceito é o mesmo: criar um conjunto a partir de uma
expressão ou condição de forma concisa e legível

10. Expressões lambda (lambda expressions):

Expressões lambda, também conhecidas como funções anônimas, são funções sem nome que
podem ser definidas em uma única linha de código. Elas são muito úteis em situações em que
você precisa de uma função simples que é usada apenas uma vez, e não quer criar uma função
completa para isso.

Em Python, as expressões lambda são definidas usando a palavra-chave “lambda”, seguida

pelos argumentos da função separados por vírgulas, seguidos por dois pontos e a expressão
que a função deve retornar. Veja alguns exemplos:

Criando uma função lambda que retorna o dobro de um número:

Double = lambda x: x * 2

Print(double(5)) # 10

Criando uma função lambda que retorna a soma de dois números:

Add = lambda x, y: x + y

Print(add(2, 3)) # 5

Criando uma função lambda que retorna a primeira letra de uma string:

First_letter = lambda s: s[0]

Print(first_letter(“hello”)) # ‘h’

As expressões lambda também podem ser usadas em conjunto com outras funções de Python,
como “map”, “filter” e “reduce”, para realizar operações em listas de forma mais concisa. Veja
alguns exemplos:
Usando a função map com uma expressão lambda para criar uma nova lista com os quadrados
dos números de uma lista:

Numbers = [1, 2, 3, 4, 5]

Squares = list(map(lambda x: x * x, numbers))

Print(squares) # [1, 4, 9, 16, 25]

Usando a função filter com uma expressão lambda para criar uma nova lista com os números
pares de uma lista:

Numbers = [1, 2, 3, 4, 5]

Even_numbers = list(filter(lambda x: x % 2 == 0, numbers))

Print(even_numbers) # [2, 4]

Usando a função reduce com uma expressão lambda para calcular o produto dos números de
uma lista:

From functools import reduce

Numbers = [1, 2, 3, 4, 5]

Product = reduce(lambda x, y: x * y, numbers)

Print(product) # 120

Note que as expressões lambda são úteis em situações em que você precisa de uma função
simples e concisa, mas para funções mais complexas, é geralmente melhor usar uma função
nomeada completa para tornar o código mais legível

11. Try/except/finally

“Try/except/finally” é uma construção em Python usada para manipular exceções. Ela permite
que você escreva um código que pode gerar exceções, mas também oferece uma maneira de
lidar com essas exceções e executar ações de limpeza mesmo que ocorra uma exceção. A
sintaxe básica é a seguinte:
Try:

# código que pode gerar exceções

Except TipoDeExcecao1:

# código para lidar com a exceção TipoDeExcecao1

Except TipoDeExcecao2:

# código para lidar com a exceção TipoDeExcecao2

...

Except:

# código para lidar com qualquer outra exceção

Finally:

# código a ser executado, independentemente de ter ocorrido exceção ou não

O bloco “try” contém o código que pode gerar exceções. Se uma exceção ocorrer, o Python
pula o restante do bloco “try” e tenta encontrar um bloco “except” que corresponda ao tipo
de exceção gerada. Se uma correspondência for encontrada, o bloco “except” correspondente
é executado. Se nenhum bloco “except” corresponder à exceção gerada, ela é propagada para
o código externo.

O bloco “finally” é opcional e é sempre executado, independentemente de ter ocorrido

exceção ou não. Ele é usado para executar ações de limpeza, como fechar arquivos ou
conexões de banco de dados, e é garantido que será executado, mesmo que ocorra uma
exceção no bloco “try”.

Aqui estão alguns exemplos de como usar “try/except/finally” em Python:

Manipulando uma exceção “ZeroDivisionError” gerada ao tentar dividir um número por zero:

Try:

Result = 5 / 0

Except ZeroDivisionError:

Print(“Não é possível dividir por zero!”)

Finally:

Print(“Finalizando o programa...”)
Manipulando uma exceção “ValueError” gerada ao tentar converter uma string em um número
inteiro:

Try:

Number = int(“abc”)

Except ValueError:

Print(“Não é possível converter ‘abc’ em um número inteiro!”)

Finally:

Print(“Finalizando o programa...”)

Manipulando qualquer exceção e imprimindo a mensagem de erro:

Try:

# código que pode gerar exceções

Except Exception as e:

Print(f”Ocorreu uma exceção: {e}”)

Finally:

Print(“Finalizando o programa...”)

É importante lembrar que o uso excessivo de blocos “try/except” pode tornar o código confuso
e dificultar a depuração de erros. Portanto, é uma boa prática usar blocos “try/except”
somente quando necessário e lidar com exceções de maneira apropriada.

12. Decoradores (decorators):

Decoradores (decorators) são uma maneira elegante de modificar ou estender o

comportamento de funções ou classes em Python, sem precisar modificar diretamente o
código dessas funções ou classes. Eles são usados para adicionar funcionalidades a uma função
ou classe existente sem alterar seu código original.

Um decorador é uma função que recebe outra função como argumento e retorna uma nova
função que acrescenta ou modifica o comportamento da função original. O decorador é
aplicado usando a sintaxe “@decorador” acima da definição da função a ser decorada.
Aqui está um exemplo simples de um decorador em Python:

Def meu_decorador(funcao):

Def funcao_decorada():

Print(“Antes de executar a função”)

Funcao()

Print(“Depois de executar a função”)

Return funcao_decorada

@meu_decorador

Def minha_funcao():

Print(“Minha função sendo executada”)

Neste exemplo, a função meu_decorador é um decorador que adiciona uma mensagem de

texto antes e depois da execução da função decorada. A função decorada funcao_decorada é
definida dentro da função decoradora meu_decorador, e chama a função original funcao. O
decorador retorna a função decorada funcao_decorada, que substitui a função original
minha_funcao após a sua aplicação com a sintaxe “@meu_decorador”.

Ao chamar a função decorada minha_funcao, a mensagem “Antes de executar a função” é

exibida, seguida pela mensagem “Minha função sendo executada”, e finalmente a mensagem
“Depois de executar a função”.

>>> minha_funcao()

Antes de executar a função

Minha função sendo executada

Depois de executar a função

Decoradores também podem receber argumentos. Aqui está um exemplo de um decorador

que recebe um argumento:

Def decorador_com_argumento(nome):

Def meu_decorador(funcao):

Def funcao_decorada():

Print(“Antes de executar a função”, nome)

Funcao()
 Print(“Depois de executar a função”, nome)

Return funcao_decorada

Return meu_decorador

@decorador_com_argumento(“minha função”)

Def minha_funcao():

Print(“Minha função sendo executada”)

Neste exemplo, o decorador decorador_com_argumento recebe um argumento nome, que é

usado para personalizar a mensagem de texto. O decorador meu_decorador é definido dentro
da função decorador_com_argumento, que recebe a função original funcao como argumento
e retorna a função decorada funcao_decorada. A função decorada chama a função original e
exibe as mensagens de texto personalizadas.

>>> minha_funcao()

Antes de executar a função minha função

Minha função sendo executada

Depois de executar a função minha função

Decoradores podem ser usados para uma variedade de tarefas, como adicionar autenticação
ou log de chamadas de função. Eles são uma das ferramentas mais poderosas do Python para a
criação de códigos mais elegantes e reutilizáveis

13. Geradores (generators)

Geradores (generators) são funções especiais em Python que podem gerar uma sequência de
valores sob demanda, em vez de gerá-los todos de uma vez e armazená-los em memória. Eles
são úteis para trabalhar com grandes quantidades de dados ou para gerar valores em um loop
infinito.

Um gerador é criado usando a palavra-chave yield em vez de return. Quando uma função com
yield é chamada, ela retorna um objeto de gerador, que pode ser iterado usando um loop for
ou chamado manualmente usando a função next().

Aqui está um exemplo simples de um gerador em Python:

Def meu_gerador():

Yield 1

Yield 2

Yield 3

Gerador = meu_gerador()

Print(next(gerador)) # imprime 1

Print(next(gerador)) # imprime 2

Print(next(gerador)) # imprime 3

Neste exemplo, a função meu_gerador é um gerador que gera uma sequência de valores 1, 2 e
3 usando yield. A função next() é usada para obter cada valor sequencialmente a partir do
objeto de gerador retornado pela função meu_gerador.

Geradores podem ser usados para gerar uma sequência de valores infinita, como neste
exemplo:

Def gerador_infinito():

I=0

While True:

Yield i

I += 1

Gerador = gerador_infinito()

Print(next(gerador)) # imprime 0

Print(next(gerador)) # imprime 1

Print(next(gerador)) # imprime 2
Neste exemplo, a função gerador_infinito é um gerador que gera uma sequência infinita de
números inteiros. O loop while True garante que a função continue gerando valores
indefinidamente, enquanto o yield gera cada valor sequencialmente.

Geradores também podem ser usados em conjunto com a sintaxe for para iterar sobre uma
sequência de valores. Aqui está um exemplo:

Def meu_gerador():

Yield “primeiro”

Yield “segundo”

Yield “terceiro”

For valor in meu_gerador():

Print(valor)

Neste exemplo, a função meu_gerador é um gerador que gera uma sequência de três strings.
A sintaxe for valor in meu_gerador(): é usada para iterar sobre cada valor gerado pela função,
imprimindo cada valor na tela.

Geradores são uma maneira poderosa de trabalhar com grandes quantidades de dados em
Python, especialmente quando a memória é limitada. Eles permitem a geração de valores sob
demanda, em vez de gerá-los todos de uma vez, economizando espaço e tempo de
processamento.

14. Context managers:

Context managers são objetos que definem ações a serem executadas antes e depois de um
bloco de código. Eles são usados para gerenciar recursos que precisam ser inicializados e
finalizados corretamente, como arquivos, conexões de banco de dados, sockets, entre outros.

O gerenciamento de contexto é implementado em Python usando os métodos especiais

__enter__() e __exit__(). O método __enter__() é chamado no início do bloco de código, e o
método __exit__() é chamado no final, independentemente de ter ocorrido uma exceção ou
não.
Os context managers podem ser usados com a sintaxe with, que garante que o contexto será
gerenciado corretamente, mesmo que ocorra uma exceção.

Aqui está um exemplo de um contexto manager simples que abre e fecha um arquivo:

Class File:

Def __init__(self, filename, mode):

Self.filename = filename

Self.mode = mode

Self.file = None

Def __enter__(self):

Self.file = open(self.filename, self.mode)

Return self.file

Def __exit__(self, exc_type, exc_value, traceback):

If self.file:

Self.file.close( )

Neste exemplo, a classe File é um contexto manager que abre e fecha um arquivo. O método
__enter__() abre o arquivo e retorna o objeto do arquivo para ser usado dentro do bloco with.
O método __exit__() fecha o arquivo no final do bloco, independentemente de ter ocorrido
uma exceção ou não.

Aqui está um exemplo de como usar o contexto manager File com a sintaxe with:

With File(‘file.txt’, ‘r’) as f:

Print(f.read())

Neste exemplo, o arquivo “file.txt” é aberto para leitura e o objeto do arquivo é atribuído à
variável f. O conteúdo do arquivo é lido e impresso no console. Quando o bloco with é
encerrado, o contexto manager File fecha o arquivo.
Context managers são uma maneira elegante e eficiente de gerenciar recursos em Python,
garantindo que eles sejam inicializados e finalizados corretamente.

15. Expressões condicionais (ternary expressions):

As Expressões Condicionais, também conhecidas como Ternary Expressions, são uma forma
compacta de escrever declarações condicionais em uma única linha.

A sintaxe geral é a seguinte:

Valor_se_verdadeiro if condicao else valor_se_falso

Onde condicao é a expressão que será avaliada como verdadeira ou falsa, valor_se_verdadeiro
é o valor retornado caso a condição seja verdadeira e valor_se_falso é o valor retornado caso a
condição seja falsa.

Aqui está um exemplo simples que utiliza uma Expressão Condicional para determinar se um
número é par ou ímpar:

Numero = 5

Paridade = “par” if numero % 2 == 0 else “impar”

Print(f”O número {numero} é {paridade}.”)

Neste exemplo, a Expressão Condicional avalia se numero % 2 == 0 é verdadeira ou falsa. Se

for verdadeira, “par” é atribuído a paridade; se for falsa, “impar” é atribuído.

Você também pode usar Expressões Condicionais para simplificar declarações if/else mais
longas. Por exemplo:

Idade = 25

Preco = 10 if idade < 18 else 20 if idade < 30 else 30

Print(f”O preço do ingresso é {preco} reais.”)

Neste exemplo, a primeira Expressão Condicional avalia se idade < 18 é verdadeira ou falsa. Se
for verdadeira, 10 é atribuído a preco. Se for falsa, a segunda Expressão Condicional é avaliada,
verificando se idade < 30 é verdadeira ou falsa. Se for verdadeira, 20 é atribuído a preco. Se for
falsa, 30 é atribuído a preco.

Agora que você já realizou algum Estruturas de controle de fluxo

Vamos pro exercício :

Exercício de Estruturas de controle de fluxo

Estruturas de Controle de Fluxo em Python com códigos:

Exercício 1:

Escreva um programa que solicita ao usuário que digite um número inteiro positivo e imprima
se esse número é par ou ímpar.

Numero = int(input(“Digite um número inteiro: “))

If numero % 2 == 0:

Print(“O número é par”)

Else:

Print(“O número é ímpar”)

Exercício 2:

Escreva um programa que solicita ao usuário que digite uma string e imprima se essa string é
um palíndromo (ou seja, se pode ser lida da mesma forma da esquerda para a direita e da
direita para a esquerda).

String = input(“Digite uma string: “)

If string == string[::-1]:

Print(“A string é um palíndromo”)

Else:

Print(“A string não é um palíndromo”)

Exercício 3:

Escreva um programa que solicita ao usuário que digite dois números e imprima o maior
número.

Numero1 = float(input(“Digite o primeiro número: “))

Numero2 = float(input(“Digite o segundo número: “))

If numero1 > numero2:

Print(numero1, “é o maior número”)

Else:

Print(numero2, “é o maior número”)

Exercício 4:

Escreva um programa que solicita ao usuário que digite um número e imprima se esse número
é primo ou não.

Numero = int(input(“Digite um número inteiro: “))

Primo = True

If numero <= 1:

Primo = False

For i in range(2, numero):

If numero % i == 0:

Primo = False

Break

If primo:

Print(numero, “é um número primo”)

Else:

Print(numero, “não é um número primo”)

Exercício 5:

Escreva um programa que solicita ao usuário que digite uma lista de números e imprima a
soma desses números.

Numeros = input(“Digite uma lista de números separados por vírgulas: “)

Numeros = numeros.split(“,”)

Soma = 0

For numero in numeros:

Soma += float(numero)

Print(“A soma dos números é:”, soma)

Exercício 6:

Escreva um programa que solicita ao usuário que digite um número inteiro positivo e imprima
os primeiros n números da sequência de Fibonacci.

N = int(input(“Digite um número inteiro positivo: “))

A, b = 0, 1

Print(“Os primeiros”, n, “números da sequência de Fibonacci são:”)

For i in range(n):

Print(a, end=” “)

A, b = b, a+b

Exercício 7:

Escreva um programa que solicita ao usuário que digite uma string e conte o número de vogais
nessa string.
String = input(“Digite uma string: “)

Vogais = “aeiouAEIOU”

Num_vogais = 0

For letra in string:

If letra in vogais:

Num_vogais += 1

Print(“A string possui”, num_vogais, “vogais”)

Exercício 8:

Escreva um programa que solicita ao usuário que digite uma lista de números e imprima
apenas os números pares.

Numeros = input(“Digite uma lista de números separados por vírgulas: “)

Numeros = numeros.split(“,”)

Print(“Os números pares são:”)

For numero in numeros:

If int(numero) % 2 == 0:

Print(numero, end=” “)

Exercício 9:

Escreva um programa que solicita ao usuário que digite um número inteiro e imprima uma
tabela de multiplicação para esse número até o 10.

Numero = int(input(“Digite um número inteiro: “))

Print(“Tabela de multiplicação para”, numero)

For i in range(1, 11):

Print(numero, “x”, i, “=”, numero*i)

Exercício 10:

Escreva um programa que solicita ao usuário que digite uma lista de números e encontre o
segundo maior número na lista.

Numeros = input(“Digite uma lista de números separados por vírgulas: “)

Numeros = numeros.split(“,”)

Numeros = [int(numero) for numero in numeros]

Maior = max(numeros)

Numeros.remove(maior)

Segundo_maior = max(numeros)

Print(“O segundo maior número é:”, segundo_maior)

Estes são apenas mais alguns exemplos de exercícios de estruturas de controle de fluxo em
Python. Espero que ajude a praticar suas habilidades em Python

Agora você já aprendeu Estruturas de controle de fluxo

Iremos pra próxima aula de Funções

O quie funções em Python?

Funções são blocos de código reutilizáveis que realizam uma tarefa específica. No Python, as
funções são definidas usando a palavra-chave “def”, seguida pelo nome da função e seus
parâmetros entre parênteses.

As funções em Python podem ter ou não um valor de retorno. Se a função tiver um valor de
retorno, você pode armazenar esse valor em uma variável ou usá-lo imediatamente em uma
expressão. Se a função não tiver um valor de retorno, ela pode simplesmente realizar uma
tarefa e não retornar nenhum valor.
Aqui está um exemplo simples de uma função em Python que adiciona dois números:

Def soma(a, b):

Return a + b

Neste exemplo, a função é definida com o nome “soma” e dois parâmetros, “a” e “b”. Dentro
da função, é realizado o cálculo da soma dos parâmetros e o resultado é retornado usando a
palavra-chave “return”.

Você pode chamar a função passando os argumentos como este exemplo:

Resultado = soma(2, 3)

Print(resultado)

Este código irá chamar a função “soma” com os argumentos 2 e 3 e armazenar o resultado
retornado na variável “resultado”. Em seguida, ele imprime o valor da variável “resultado”,
que deve ser 5.

Funções em Python e alguns conceitos importantes relacionados a elas.

1.Definindo funções:

Em Python, as funções são definidas com a palavra-chave def, seguida do nome da função,
parênteses contendo os parâmetros e dois-pontos. O código que será executado quando a
função é chamada é colocado em um bloco de código indentado abaixo da linha de definição
da função.

Aqui está um exemplo de uma função simples que calcula a área de um círculo:

Def calcular_area_circulo(raio):

Pi = 3.14

Area = pi * (raio ** 2)

Return area

2.Chamando funções:

Para chamar uma função, você simplesmente precisa digitar o nome da função, seguido dos
parênteses contendo os argumentos (se houver) que você deseja passar para a função.
Area_do_circulo = calcular_area_circulo(5)

Neste exemplo, estamos chamando a função calcular_area_circulo com um argumento de 5. O

valor retornado pela função é armazenado na variável area_do_circulo.

3.Parâmetros de função:

Os parâmetros de função permitem que você passe informações para a função. Você pode
definir quantos parâmetros forem necessários e dar a eles nomes significativos. Quando a
função é chamada, você passa argumentos que correspondem aos parâmetros na ordem em
que eles foram definidos.

Def exibir_nome_completo(primeiro_nome, sobrenome):

Print(f”Nome completo: {primeiro_nome} {sobrenome}”)

Neste exemplo, a função exibir_nome_completo recebe dois parâmetros: primeiro_nome e

sobrenome. Quando a função é chamada, você deve passar dois argumentos, um para cada
parâmetro.

Exibir_nome_completo(“João”, “Silva”)

4. Valor de retorno:

Uma função pode ou não retornar um valor. Se uma função retornar um valor, você pode
armazená-lo em uma variável ou usá-lo imediatamente em uma expressão.

Def calcular_soma(a, b):

Return a + b

Resultado = calcular_soma(2, 3)

Neste exemplo, a função calcular_soma retorna a soma dos dois parâmetros. O resultado da
função é armazenado na variável resultado.

5.Argumentos padrão:
Os argumentos padrão permitem que você especifique um valor padrão para um parâmetro
de função. Se o argumento não for passado quando a função é chamada, o valor padrão será
usado.

Def exibir_informacao_pessoa(nome, idade=18):

Print(f”{nome} tem {idade} anos.”)

Exibir_informacao_pessoa(“João”) # Output: João tem 18 anos.

Exibir_informacao_pessoa(“Maria”, 25) # Output: Maria tem 25 anos.

Neste exemplo, o segundo parâmetro idade tem um valor padrão de 18. Se não for passado
nenhum valor para idade quando a função é chamada, ele usará o valor padrão. Se você
fornecer um valor para idade, ele

Def verificar_maioridade(idade):

“””

Verifica se a idade é maior ou igual a 18 anos.

Retorna uma mensagem de acordo com o resultado da verificação.

“””

If idade >= 18:

Return “Maior de idade.”

Else:

Return “Menor de idade.”

# Chamando a função e armazenando o resultado em uma variável

Resultado = verificar_maioridade(20)

# Imprimindo o resultado

Print(resultado)
Neste exemplo, temos uma função chamada verificar_maioridade, que recebe um parâmetro
chamado idade. A função verifica se a idade é maior ou igual a 18 anos e retorna uma
mensagem correspondente ao resultado da verificação.

Ao chamar a função com um argumento de 20, por exemplo, a função retornará a mensagem
“Maior de idade”. O resultado é armazenado na variável resultado e, em seguida, é impresso
na tela.

Observe que a função também tem um comentário de documentação (docstring) que descreve
o que a função faz e como ela funciona. Esse tipo de comentário é útil para ajudar outros
programadores a entender como usar a função e qual é o seu propósito.

 Função que converte Celsius para Fahrenheit:

Def celsius_para_fahrenheit(celsius):

“””

Converte uma temperatura em graus Celsius para Fahrenheit.

Retorna o valor em Fahrenheit.

“””

Fahrenheit = (celsius * 1.8) + 32

Return fahrenheit

# Chamando a função com um argumento de 25 graus Celsius

Resultado = celsius_para_fahrenheit(25)

# Imprimindo o resultado

Print(resultado)

 Função que verifica se um número é par:

Def verificar_par(numero):

“””

Verifica se um número é par.

Retorna True se o número for par, ou False se for ímpar.

“””

If numero % 2 == 0:

Return True

Else:

Return False

# Chamando a função com um argumento de 7

Resultado = verificar_par(7)

# Imprimindo o resultado

Print(resultado)

 Função que soma os valores de uma lista:

Def somar_lista(lista):

“””

Soma os valores de uma lista.

Retorna o resultado da soma.

“””

Soma = 0

For valor in lista:

Soma += valor

Return soma

# Chamando a função com uma lista de valores

Lista_de_valores = [1, 2, 3, 4, 5]

Resultado = somar_lista(lista_de_valores)
# Imprimindo o resultado

Print(resultado)

 Função que encontra o maior valor de uma lista:

Def encontrar_maior_valor(lista):

“””

Encontra o maior valor em uma lista.

Retorna o valor encontrado.

“””

Maior_valor = lista[0]

For valor in lista:

If valor > maior_valor:

Maior_valor = valor

Return maior_valor

# Chamando a função com uma lista de valores

Lista_de_valores = [10, 5, 20, 8, 15]

Resultado = encontrar_maior_valor(lista_de_valores)

# Imprimindo o resultado

Print(resultado)

 Função que gera um dicionário a partir de duas listas:

Def gerar_dicionario(chaves, valores):

“””

Gera um dicionário a partir de duas listas.

A primeira lista é usada como as chaves do dicionário.

 A segunda lista é usada como os valores do dicionário.

Retorna o dicionário gerado.

“””

Dicionario = {}

For i in range(len(chaves)):

Dicionario[chaves[i]] = valores[i]

Return dicionario

# Chamando a função com duas listas

Chaves = [“nome”, “idade”, “cidade”]

Valores = [“João”, 25, “São Paulo”]

Resultado = gerar_dicionario(chaves, valores)

# Imprimindo o resultado

Print(resultado)

Exercício de funções :

 Escreva uma função que calcule a área de um triângulo, a partir da base e altura
fornecidas pelo usuário:

Def calcular_area_triangulo(base, altura):

“””

Calcula a área de um triângulo a partir da base e altura fornecidas.

Retorna o valor da área calculada.

“””

Area = (base * altura) / 2

Return area

# Exemplo de uso da função

Base = 6
Altura = 4

Area = calcular_area_triangulo(base, altura)

Print(“A área do triângulo é:”, area)

 Escreva uma função que verifique se uma palavra é um palíndromo (ou seja, se pode
ser lida da mesma forma de trás para frente):

Def verificar_palindromo(palavra):

“””

Verifica se uma palavra é um palíndromo.

Retorna True se for um palíndromo, ou False caso contrário.

“””

Palavra_invertida = palavra[::-1]

If palavra == palavra_invertida:

Return True

Else:

Return False

# Exemplo de uso da função

Palavra = “arara”

If verificar_palindromo(palavra):

Print(“A palavra”, palavra, “é um palíndromo.”)

Else:

Print(“A palavra”, palavra, “não é um palíndromo.”)

 Escreva uma função que converta uma lista de temperaturas em graus Celsius para
Fahrenheit:

Def converter_temperaturas(lista_celsius):

“””

Converte uma lista de temperaturas em graus Celsius para Fahrenheit.

Retorna uma nova lista com as temperaturas convertidas.

 “””

Lista_fahrenheit = []

For celsius in lista_celsius:

Fahrenheit = (celsius * 1.8) + 32

Lista_fahrenheit.append(fahrenheit)

Return lista_fahrenheit

# Exemplo de uso da função

Temperaturas_celsius = [0, 10, 20, 30, 40]

Temperaturas_fahrenheit = converter_temperaturas(temperaturas_celsius)

Print(“Temperaturas em Celsius:”, temperaturas_celsius)

Print(“Temperaturas em Fahrenheit:”, temperaturas_fahrenheit)

 Escreva uma função que encontre o valor médio de uma lista de números:

Def calcular_media(lista):

“””

Calcula o valor médio de uma lista de números.

Retorna o valor da média calculada.

“””

Soma = 0

For valor in lista:

Soma += valor

Media = soma / len(lista)

Return media

# Exemplo de uso da função

Numeros = [10, 20, 30, 40, 50]

Media = calcular_media(numeros)

Print(“A média dos números é:”, media)

  Escreva uma função que ordene uma lista de números em ordem crescente:

Def ordenar_lista(lista):

“””

Ordena uma lista de números em ordem crescente.

Retorna a lista ordenada.

“””

Lista_ordenada = sorted(lista)

Return lista_ordenada

# Exemplo de uso da função

Numeros = [50, 10, 30, 40, 20]

Numeros_ordenados = ordenar_lista(numeros)

Print(“

 Escreva uma função que calcule o fatorial de um número:

Def calcular_fatorial(numero):

“””

Calcula o fatorial de um número.

Retorna o resultado do fatorial.

“””

Fatorial = 1

For i in range(1, numero+1):

Fatorial *= i

Return fatorial

# Exemplo de uso da função

Numero = 5

Fatorial = calcular_fatorial(numero)

Print(“O fatorial de”, numero, “é:”, fatorial)

  Escreva uma função que verifique se um número é primo:

Def verificar_primo(numero):

“””

Verifica se um número é primo.

Retorna True se for primo, ou False caso contrário.

“””

If numero <= 1:

Return False

For i in range(2, int(numero/2)+1):

If (numero % i) == 0:

Return False

Return True

# Exemplo de uso da função

Numero = 17

If verificar_primo(numero):

Print(numero, “é um número primo.”)

Else:

Print(numero, “não é um número primo.”)

 Escreva uma função que calcule a soma dos elementos de uma matriz:

Def somar_matriz(matriz):

“””

Calcula a soma dos elementos de uma matriz.

Retorna o valor da soma calculada.

“””

Soma = 0

For linha in matriz:

 For elemento in linha:

Soma += elemento

Return soma

# Exemplo de uso da função

Matriz = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]

Soma = somar_matriz(matriz)

Print(“A soma dos elementos da matriz é:”, soma)

 Escreva uma função que verifique se uma lista contém apenas números pares:

Def verificar_pares(lista):

“””

Verifica se uma lista contém apenas números pares.

Retorna True se todos os elementos forem pares, ou False caso contrário.

“””

For elemento in lista:

If (elemento % 2) != 0:

Return False

Return True

# Exemplo de uso da função

Numeros = [2, 4, 6, 8, 10]

If verificar_pares(numeros):

Print(“A lista contém apenas números pares.”)

Else:

Print(“A lista contém números ímpares ou mistos.”)

 Escreva uma função que receba uma lista de strings e retorne a lista ordenada em
ordem crescente de tamanho de string:
Def ordenar_por_tamanho(lista):

“””

Ordena uma lista de strings em ordem crescente de tamanho de string.

Retorna a lista ordenada.

“””

Lista_ordenada = sorted(lista, key=len)

Return lista_ordenada

# Exemplo de uso da função

Palavras = [“abacaxi”, “maçã”, “banana”, “pera”, “uva”]

Palavras_ordenadas = ordenar_por_tamanho(palavras)

Print(“Lista ordenada por tamanho:”, palavras_ordenadas)

Agora que você já terminou de aprender

A função no python

Vamos agora pra nossa aula de

Classes e objetos :

Classes e objetos são recursos fundamentais da programação orientada a objetos, e o Python é

uma linguagem que oferece suporte completo a esse paradigma.

Uma classe é uma estrutura que define um tipo de dado, com um conjunto de atributos e
métodos que podem ser associados a esse tipo. A classe é como um modelo ou uma planta
para criar objetos.

Um objeto, por sua vez, é uma instância da classe, uma representação concreta desse tipo de
dado com seus atributos e métodos. O objeto é como um exemplar ou uma cópia criada a
partir da classe.

Em outras palavras, uma classe define uma estrutura e comportamentos que os objetos que a
representam podem ter. Quando criamos um objeto a partir de uma classe, estamos criando
uma variável que contém as informações e ações definidas na classe.

Para definir uma classe em Python, usamos a palavra-chave class, seguida do nome da classe e
os seus atributos e métodos:
Class Carro:

Def __init__(self, marca, modelo, ano, cor):

Self.marca = marca

Self.modelo = modelo

Self.ano = ano

Self.cor = cor

Def ligar(self):

Print(“O carro está ligado!”)

Def desligar(self):

Print(“O carro está desligado!”)

Nesse exemplo, criamos uma classe chamada Carro com os atributos marca, modelo, ano e
cor, e os métodos ligar e desligar. O método __init__ é um método especial chamado
construtor, que é executado quando um objeto é criado a partir da classe.

Para criar um objeto a partir dessa classe, usamos o nome da classe seguido de parênteses,
com os argumentos necessários para o construtor:

Meu_carro = Carro(“Chevrolet”, “Onix”, 2022, “branco”)

Nesse exemplo, criamos um objeto chamado meu_carro a partir da classe Carro, passando os
argumentos para o construtor. Agora, podemos acessar os atributos e métodos desse objeto
usando a sintaxe de ponto:

Print(meu_carro.marca)

# Output: Chevrolet

Meu_carro.ligar()

# Output: O carro está ligado!

Essa é apenas uma introdução à programação orientada a objetos em Python, e há muito mais
a aprender sobre o assunto. Com o tempo e a prática, você poderá explorar todas as
possibilidades que essa abordagem oferece para criar soluções mais robustas e flexíveis em
seus projetos de programação.

Pra você entender melhor

Vamos fala de classes depois de objetos blz

Pra você usuário entende melhor :

Classes

Uma classe é uma estrutura de dados que representa um tipo de objeto ou entidade em um
programa. Em Python, as classes podem ter atributos e métodos que permitem representar e
manipular dados de uma forma mais organizada e modular.

Os atributos são variáveis que pertencem à classe e são usados para armazenar dados
específicos de cada objeto criado a partir da classe. Os métodos, por outro lado, são funções
que pertencem à classe e podem ser chamados para executar ações específicas ou manipular
os atributos.

A sintaxe para definir uma classe em Python é a seguinte:

Class NomeDaClasse:

Def __init__(self, arg1, arg2, ...):

Self.atributo1 = arg1

Self.atributo2 = arg2

...

Def metodo1(self, arg1, arg2, ...):

# código do método

...

Def metodo2(self, arg1, arg2, ...):

 # código do método

...

Aqui, NomeDaClasse é o nome da classe que está sendo definida. __init__ é um método
especial chamado construtor que é executado quando um objeto é criado a partir da classe.
Arg1, arg2, etc. são os argumentos que são passados para o construtor. Self é uma referência
ao objeto atual que está sendo criado.

Os métodos da classe podem ser chamados usando a sintaxe nome_do_objeto.metodo1(arg1,

arg2, ...). Isso executará o código no método e pode retornar um valor ou modificar os
atributos do objeto.

Para criar um objeto a partir de uma classe, usamos a seguinte sintaxe:

Nome_do_objeto = NomeDaClasse(arg1, arg2, ...)

Isso criará um objeto chamado nome_do_objeto a partir da classe NomeDaClasse, passando os

argumentos especificados para o construtor.

Por exemplo, suponha que queremos criar uma classe chamada Pessoa que tenha os atributos
nome, idade e altura, e os métodos falar e caminhar. Podemos definir a classe da seguinte
forma:

Class Pessoa:

Def __init__(self, nome, idade, altura):

Self.nome = nome

Self.idade = idade

Self.altura = altura

Def falar(self, mensagem):

Print(self.nome + “ diz: “ + mensagem)

Def caminhar(self, distancia):

 Print(self.nome + “ caminhou “ + str(distancia) + “ metros”)

Aqui, Pessoa é o nome da classe, que tem três atributos (nome, idade e altura) e dois métodos
(falar e caminhar). O construtor __init__ é usado para inicializar os atributos da classe com os
valores passados como argumentos.

Para criar um objeto a partir dessa classe, podemos fazer o seguinte:

Pessoa1 = Pessoa(“João”, 30, 1.75)

Pessoa2 = Pessoa(“Maria”, 25, 1.65)

Isso criará dois objetos da classe Pessoa, com os nomes pessoa1 e pessoa2. Podemos chamar
os métodos desses objetos usando a sintaxe `nome_do_objeto.metodo(arg1, arg2,

Em Python, a definição de uma classe é feita usando a palavra-chave “ class.”

A seguir, estão alguns exemplos de classes em Python:

Classe Retângulo

Class Retangulo:

Def __init__(self, largura, altura):

Self.largura = largura

Self.altura = altura

Def area(self):

Return self.largura * self.altura

Def perimetro(self):
 Return 2 * (self.largura + self.altura)

Nesse exemplo, temos uma classe Retangulo com dois atributos: largura e altura. O método
__init__ é o construtor da classe e é usado para inicializar os atributos. A classe também tem
dois métodos: area e perimetro, que calculam a área e o perímetro do retângulo,
respectivamente.

Classe Pessoa

Class Pessoa:

Def __init__(self, nome, idade):

Self.nome = nome

Self.idade = idade

Def falar(self, mensagem):

Print(f”{self.nome}: {mensagem}”)

Nesse exemplo, temos uma classe Pessoa com dois atributos: nome e idade. O método
__init__ é o construtor da classe e é usado para inicializar os atributos. A classe também tem
um método falar, que recebe uma mensagem e imprime na tela junto com o nome da pessoa.

Classe Conta Bancária

Class ContaBancaria:

Def __init__(self, saldo_inicial):

Self.saldo = saldo_inicial

Def depositar(self, valor):

Self.saldo += valor

Def sacar(self, valor):

 If valor <= self.saldo:

Self.saldo -= valor

Else:

Print(“Saldo insuficiente”)

Def consultar_saldo(self):

Return self.saldo

Nesse exemplo, temos uma classe ContaBancaria com um atributo saldo e três métodos:
depositar, sacar e consultar_saldo. O método __init__ é o construtor da classe e é usado para
inicializar o atributo saldo. O método depositar adiciona um valor ao saldo da conta, o método
sacar retira um valor do saldo da conta, desde que haja saldo suficiente, e o método
consultar_saldo retorna o saldo atual da conta.

Classe Cachorro

Class Cachorro:

Def __init__(self, nome, raca):

Self.nome = nome

Self.raca = raca

Def latir(self):

Print(“Au au!”)

Nesse exemplo, temos uma classe Cachorro com dois atributos: nome e raca. O método
__init__ é o construtor da classe e é usado para inicializar os atributos. A classe também tem
um método latir, que imprime na tela o som que um cachorro faz.

Classe Livro

Class Livro:

Def __init__(self, titulo, autor, ano):

Self.titulo = titulo
 Self.autor = autor

Self.ano = ano

Def mostrar_dados(self):

Print(f”{self.titulo}, escrito por {

Classe Carro

Class Carro:

Def __init__(self, marca, modelo, ano):

Self.marca = marca

Self.modelo = modelo

Self.ano = ano

Self.velocidade = 0

Def acelerar(self, incremento):

Self.velocidade += incremento

Def frear(self, decremento):

If self.velocidade > decremento:

Self.velocidade -= decremento

Else:

Self.velocidade = 0

Def mostrar_velocidade(self):

Print(f”Velocidade atual: {self.velocidade} km/h”)

Def mostrar_dados(self):

Print(f”{self.marca} {self.modelo} ({self.ano})”)

Nesse exemplo, temos uma classe Carro com quatro atributos: marca, modelo, ano e
velocidade. O método __init__ é o construtor da classe e é usado para inicializar os atributos,
incluindo o atributo velocidade, que começa com valor 0. A classe também tem três métodos:
acelerar, frear e mostrar_velocidade, que aumentam a velocidade do carro, diminuem a
velocidade do carro e mostram a velocidade atual do carro, respectivamente. O método
mostrar_dados mostra a marca, modelo e ano do carro.

Classe Conta Corrente

Class ContaCorrente:

Def __init__(self, numero, titular, saldo=0):

Self.numero = numero

Self.titular = titular

Self.saldo = saldo

Def depositar(self, valor):

Self.saldo += valor

Def sacar(self, valor):

If valor <= self.saldo:

Self.saldo -= valor

Else:

Print(“Saldo insuficiente”)

Def mostrar_saldo(self):

Print(f”Saldo atual: R$ {self.saldo:.2f}”)

Def mostrar_dados(self):

Print(f”Conta nº {self.numero} – Titular: {self.titular}”)

Nesse exemplo, temos uma classe ContaCorrente com três atributos: numero, titular e saldo.
O método __init__ é o construtor da classe e é usado para inicializar os atributos, incluindo o
atributo saldo, que começa com valor 0, a menos que seja especificado um valor diferente na
criação do objeto. A classe também tem três métodos: depositar, sacar e mostrar_saldo, que
adicionam dinheiro à conta, retiram dinheiro da conta e mostram o saldo atual da conta,
respectivamente. O método mostrar_dados mostra o número da conta e o nome do titular.
Classe Triângulo

Class Triangulo:

Def __init__(self, lado1, lado2, lado3):

Self.lado1 = lado1

Self.lado2 = lado2

Self.lado3 = lado3

Def perimetro(self):

Return self.lado1 + self.lado2 + self.lado3

Def tipo(self):

If self.lado1 == self.lado2 == self.lado3:

Return “equilátero”

Elif self.lado1 == self.lado2 or self.lado1 == self.lado3

Exercício de classes :

1. Crie uma classe Pessoa que tenha os atributos nome e idade, e um método
dizer_nome que imprime o nome da pessoa. Crie uma instância dessa classe e chame
o método dizer_nome.

2. Crie uma classe ContaBancaria que tenha os atributos saldo e titular, e métodos
depositar e sacar que atualizam o saldo da conta. Crie uma instância dessa classe,
deposite algum dinheiro e faça um saque.

3. Crie uma classe Carro que tenha os atributos marca, modelo e ano, e um método
imprimir_info que imprime as informações do carro. Crie uma lista de instâncias dessa
classe e chame o método imprimir_info em cada uma delas.

4. Crie uma classe Retangulo que tenha os atributos largura e altura, e métodos area e
perimetro que calculam a área e o perímetro do retângulo. Crie uma instância dessa
 classe com largura 5 e altura 10, e chame seus métodos para calcular a área e o
perímetro.

5. Crie uma classe Animal que tenha os atributos nome e especie, e um método
fazer_som que imprime um som característico do animal. Crie subclasses dessa classe
para diferentes tipos de animais, como Cachorro e Gato, que substituam o método
fazer_som para imprimir sons diferentes. Crie instâncias dessas classes e chame o
método fazer_som em cada uma delas.

Exemplo de como você irá faze esse exercício que lhe passe logo acima :

 Classe Pessoa:

Class Pessoa:

Def __init__(self, nome, idade):

Self.nome = nome

Self.idade = idade

Def dizer_nome(self):

Print(f”Meu nome é {self.nome}”)

P = Pessoa(“João”, 30)

p.dizer_nome()

Este código define uma classe Pessoa com dois atributos nome e idade. O método __init__ é
um método especial que é chamado quando uma nova instância da classe é criada. O método
dizer_nome imprime o nome da pessoa. Uma instância da classe é criada com o nome “João” e
idade 30, e o método dizer_nome é chamado para imprimir o nome.

 Classe Conta Bancária:

Class ContaBancaria:

Def __init__(self, titular):

Self.titular = titular
 Self.saldo = 0

Def depositar(self, valor):

Self.saldo += valor

Def sacar(self, valor):

If valor > self.saldo:

Print(“Saldo insuficiente”)

Else:

Self.saldo -= valor

Conta = ContaBancaria(“João”)

Conta.depositar(1000)

Conta.sacar(500)

Este código define uma classe ContaBancaria com os atributos titular e saldo. O método
depositar adiciona um valor ao saldo e o método sacar subtrai um valor do saldo, mas verifica
se o saldo é suficiente antes de fazer a transação. Uma instância da classe é criada com o
titular “João”, e são feitas uma operação de depósito e uma de saque.

 Classe Carro:

Class Carro:

Def __init__(self, marca, modelo, ano):

Self.marca = marca

Self.modelo = modelo

Self.ano = ano

Def imprimir_info(self):

Print(f”{self.marca} {self.modelo} ({self.ano})”)

Carros = [
 Carro(“Ford”, “Fiesta”, 2010),

Carro(“Volkswagen”, “Gol”, 2015),

Carro(“Toyota”, “Corolla”, 2020)

For carro in carros:

Carro.imprimir_info()

Este código define uma classe Carro com os atributos marca, modelo e ano. O método
imprimir_info imprime as informações do carro. Uma lista de três instâncias da classe é criada
e o método imprimir_info é chamado para cada uma delas.

 Classe Retângulo:

Class Retangulo:

Def __init__(self, largura, altura):

Self.largura = largura

Self.altura = altura

Def area(self):

Return self.largura * self.altura

Def perimetro(self):

Return 2 * self.largura + 2 * self.altura

Ret = Retangulo(5, 10)

Print(“Área:”, ret.area())

Print(“Perímetro:”, ret.perimetro())

 Este código define uma classe Retangulo com os atributos largura e altura. Os métodos
area e perimetro calculam a área e o perímetro
  Crie uma classe chamada Pessoa que tenha os atributos nome, idade e profissao. A
classe deve ter um método chamado fazer_aniversario que incrementa a idade em 1
unidade.

 Crie uma classe chamada Produto que tenha os atributos nome, preco e quantidade. A
classe deve ter um método chamado comprar que aumenta a quantidade em 1
unidade e um método chamado vender que diminui a quantidade em 1 unidade.

 Crie uma classe chamada Circulo que tenha o atributo raio. A classe deve ter um
método chamado calcular_area que retorna a área do círculo e um método chamado
calcular_perimetro que retorna o perímetro do círculo.

 Crie uma classe chamada Retangulo que tenha os atributos largura e altura. A classe
deve ter um método chamado calcular_area que retorna a área do retângulo e um
método chamado calcular_perimetro que retorna o perímetro do retângulo.

 Crie uma classe chamada Contador que tenha o atributo valor. A classe deve ter um
método chamado incrementar que incrementa o valor em 1 unidade e um método
chamado zerar que zera o valor.

Exemplo dessas atividades que passe de classe em código

Classe Pessoa:

Class Pessoa:

Def __init__(self, nome, idade, profissao):

Self.nome = nome

Self.idade = idade

Self.profissao = profissao

Def fazer_aniversario(self):

Self.idade += 1

Classe Produto:
Class Produto:

Def __init__(self, nome, preco, quantidade):

Self.nome = nome

Self.preco = preco

Self.quantidade = quantidade

Def comprar(self):

Self.quantidade += 1

Def vender(self):

If self.quantidade > 0:

Self.quantidade -= 1

Classe Circulo:

Import math

Class Circulo:

Def __init__(self, raio):

Self.raio = raio

Def calcular_area(self):

Return math.pi * self.raio ** 2

Def calcular_perimetro(self):

Return 2 * math.pi * self.raio

Classe Retangulo:

Python

Copy code

Class Retangulo:
 Def __init__(self, largura, altura):

Self.largura = largura

Self.altura = altura

Def calcular_area(self):

Return self.largura * self.altura

Def calcular_perimetro(self):

Return 2 * (self.largura + self.altura)

 Classe Contador:

Class Contador:

Def __init__(self, valor):

Self.valor = valor

Def incrementar(self):

Self.valor += 1

Def zerar(self):

Self.valor = 0

Vamos agora pra o objetos :

Objetos são instâncias de uma classe em Python. Uma classe define um tipo de objeto com
propriedades (atributos) e comportamentos (métodos) que são específicos para aquele tipo.

Quando você cria um objeto, está criando uma instância dessa classe, que tem seus próprios
valores para cada um dos atributos da classe. Além disso, cada objeto pode chamar os
métodos da classe, que podem manipular seus próprios atributos ou realizar outras operações.
Por exemplo, se tivermos uma classe Carro, podemos criar vários objetos dessa classe, cada
um representando um carro diferente, com seus próprios valores para as propriedades marca,
modelo, ano e velocidade, bem como a capacidade de acelerar, frear e mostrar sua velocidade
atual.

Class Carro:

Def __init__(self, marca, modelo, ano):

Self.marca = marca

Self.modelo = modelo

Self.ano = ano

Self.velocidade = 0

Def acelerar(self, incremento):

Self.velocidade += incremento

Def frear(self, decremento):

If self.velocidade > decremento:

Self.velocidade -= decremento

Else:

Self.velocidade = 0

Def mostrar_velocidade(self):

Print(f”Velocidade atual: {self.velocidade} km/h”)

Def mostrar_dados(self):

Print(f”{self.marca} {self.modelo} ({self.ano})”)

Carro1 = Carro(“Toyota”, “Corolla”, 2020)

Carro2 = Carro(“Honda”, “Civic”, 2022)

Carro1.acelerar(50)

Carro2.acelerar(30)

Carro1.mostrar_velocidade() # Velocidade atual: 50 km/h

Carro2.mostrar_velocidade() # Velocidade atual: 30 km/h

Nesse exemplo, carro1 e carro2 são objetos diferentes da classe Carro, cada um com sua
própria marca, modelo e ano. Cada objeto também pode ter sua própria velocidade, que pode
ser alterada com os métodos acelerar e frear, e mostrada com o método mostrar_velocidade.
Cada objeto é independente do outro, então alterar a velocidade de carro1 não afetará a
velocidade de carro2.

Em Python, tudo é um objeto, ou seja, cada valor que você trabalha em Python é um objeto
com seu próprio tipo e comportamento. Até mesmo os tipos básicos, como números, strings e
listas, são objetos em Python.

Quando você cria um objeto em Python, é criada uma instância desse objeto, que possui seus
próprios valores para seus atributos e métodos. Por exemplo, ao criar uma lista, você está
criando uma instância do tipo list em Python.

Aqui está um exemplo simples que cria uma lista, adiciona elementos a ela e chama alguns dos
seus métodos:

Minha_lista = [1, 2, 3, 4, 5]

Minha_lista.append(6)

Print(minha_lista) # [1, 2, 3, 4, 5, 6]

Print(len(minha_lista)) # 6

Neste exemplo, minha_lista é uma instância do objeto list em Python. A lista tem seu próprio
conjunto de valores, neste caso, [1, 2, 3, 4, 5]. Em seguida, o método append é chamado na
lista para adicionar o número 6. Finalmente, o método len é chamado para retornar o
comprimento da lista, que é 6.
Você também pode criar seus próprios objetos em Python, usando classes, e personalizar seus
próprios comportamentos. Aqui está um exemplo de uma classe simples Pessoa, que tem um
atributo nome e um método dizer_ola:

Class Pessoa:

Def __init__(self, nome):

Self.nome = nome

Def dizer_ola(self):

Print(f”Olá, meu nome é {self.nome}.”)

P1 = Pessoa(“João”)

P1.dizer_ola() # Olá, meu nome é João.

Neste exemplo, p1 é uma instância da classe Pessoa, que tem um atributo nome com o valor
“João”. O método dizer_ola é chamado no objeto p1, que imprime uma mensagem de
saudação com o nome da pessoa.

Em resumo, em Python, um objeto é uma instância de uma classe, que tem seus próprios
atributos e métodos. Você pode criar seus próprios objetos personalizados usando classes em
Python.

 Um objeto é uma instância de uma classe. Por exemplo, se você tiver uma classe
chamada Pessoa, uma instância dessa classe seria um objeto que representa uma
pessoa específica.

 Um objeto tem atributos que armazenam informações sobre ele. Por exemplo, um
objeto Pessoa pode ter atributos como nome, idade, sexo, etc.

 Um objeto pode ter métodos, que são funções que permitem que o objeto execute
ações ou operações específicas. Por exemplo, um objeto Pessoa pode ter um método
dizer_nome que imprime o nome da pessoa.
  Os objetos são geralmente criados usando o construtor da classe, que é uma função
especial que é chamada quando uma nova instância da classe é criada. Por exemplo,
se você tiver uma classe Pessoa, poderá criar um objeto Pessoa com p =
Pessoa(“João”, 30).

 Os objetos em Python são dinâmicos e podem ser modificados durante a execução do

programa. Por exemplo, você pode adicionar ou remover atributos ou métodos de um
objeto em tempo de execução. Isso torna a programação em Python muito flexível e
poderosa

Aqui está um exemplo que ilustra esses conceitos em código:

Class Pessoa:

Def __init__(self, nome, idade, sexo):

Self.nome = nome

Self.idade = idade

Self.sexo = sexo

Def dizer_nome(self):

Print(“Meu nome é”, self.nome)

# Criando um objeto Pessoa

P = Pessoa(“João”, 30, “masculino”)

# Acessando os atributos do objeto

Print(“Nome:”, p.nome)

Print(“Idade:”, p.idade)

Print(“Sexo:”, p.sexo)

# Chamando um método do objeto

p.dizer_nome()
# Adicionando um novo atributo em tempo de execução

p.profissao = “programador”

# Acessando o novo atributo

Print(“Profissão:”, p.profissao)

# Modificando um atributo existente em tempo de execução

p.idade = 31

# Imprimindo o valor modificado do atributo

Print(“Idade atualizada:”, p.idade)

Neste exemplo, a classe Pessoa tem um construtor que aceita argumentos nome, idade e sexo,
e usa esses argumentos para inicializar os atributos correspondentes do objeto. A classe
também tem um método dizer_nome que imprime o nome da pessoa.

Em seguida, um objeto Pessoa é criado com o nome “João”, idade 30 e sexo masculino. Os
atributos do objeto são acessados usando a sintaxe de ponto, e o método dizer_nome é
chamado no objeto.

Em seguida, um novo atributo profissao é adicionado ao objeto em tempo de execução, e é

acessado usando a mesma sintaxe de ponto. Finalmente, o valor do atributo idade é
modificado em tempo de execução, e o valor atualizado é impresso.

Agora que você já entendeu e deu uma praticada sobre objetos

Iremos pro exercício

Exercício de objetos :

 Crie uma classe Círculo com um construtor que aceite um raio como argumento. A
classe deve ter um método calcular_area que retorna a área do círculo.

 Crie uma classe Retângulo com um construtor que aceite dois lados como argumentos.
A classe deve ter um método calcular_area que retorna a área do retângulo.
  Crie uma classe Pessoa com um construtor que aceite um nome e uma idade como
argumentos. A classe deve ter um método dizer_nome que imprime o nome da
pessoa, e um método dizer_idade que imprime a idade da pessoa.

 Crie uma classe ContaBancaria com um construtor que aceite um saldo inicial como
argumento. A classe deve ter métodos depositar e sacar que permitem que o usuário
adicione ou retire dinheiro da conta, respectivamente.

 Crie uma classe Carro com um construtor que aceite uma marca, um modelo e um ano
como argumentos. A classe deve ter um método acelerar que aumenta a velocidade
do carro em 10 km/h, e um método frear que reduz a velocidade do carro em 10 km/h.

Esses exercícios podem ser adaptados e expandidos de diversas maneiras para desafiar ainda
mais seus conhecimentos em programação orientada a objetos em Python.

Exemplo em código do que você irá fazer :

Class Circulo:

Def __init__(self, raio):

Self.raio = raio

Def calcular_area(self):

Return 3.14 * (self.raio ** 2)

Circulo1 = Circulo(5)

Print(circulo1.calcular_area()) # Saída: 78.5

 Exemplo

Class Retangulo:

Def __init__(self, lado1, lado2):

Self.lado1 = lado1
 Self.lado2 = lado2

Def calcular_area(self):

Return self.lado1 * self.lado2

Retangulo1 = Retangulo(3, 4)

Print(retangulo1.calcular_area()) # Saída: 12

 Exemplo

Class Pessoa:

Def __init__(self, nome, idade):

Self.nome = nome

Self.idade = idade

Def dizer_nome(self):

Print(“Meu nome é”, self.nome)

Def dizer_idade(self):

Print(“Minha idade é”, self.idade)

Pessoa1 = Pessoa(“Maria”, 30)

Pessoa1.dizer_nome() # Saída: Meu nome é Maria

Pessoa1.dizer_idade() # Saída: Minha idade é 30

 Exemplo

Class ContaBancaria:

Def __init__(self, saldo):

Self.saldo = saldo
 Def depositar(self, valor):

Self.saldo += valor

Def sacar(self, valor):

If valor > self.saldo:

Print(“Saldo insuficiente.”)

Else:

Self.saldo -= valor

Conta1 = ContaBancaria(100)

Conta1.depositar(50)

Print(conta1.saldo) # Saída: 150

Conta1.sacar(30)

Print(conta1.saldo) # Saída: 120

 Exemplo

Class Carro:

Def __init__(self, marca, modelo, ano):

Self.marca = marca

Self.modelo = modelo

Self.ano = ano

Self.velocidade = 0

Def acelerar(self):

Self.velocidade += 10

Def frear(self):

If self.velocidade < 10:

 Self.velocidade = 0

Else:

Self.velocidade -= 10

Carro1 = Carro(“Fiat”, “Uno”, 2020)

Carro1.acelerar()

Print(carro1.velocidade) # Saída: 10

Carro1.frear()

Print(carro1.velocidade) # Saída: 0

Exercício :

 Criar uma classe Livro que tenha os atributos titulo, autor e ano_publicacao. Criar um
objeto livro1 e imprimir seus atributos.

 Criar uma classe Pessoa que tenha os atributos nome, idade e endereco. Criar um
método aniversario que adiciona 1 à idade da pessoa. Criar um objeto pessoa1,
imprimir seus atributos, chamar o método aniversario e imprimir novamente seus
atributos.

 Criar uma classe Retangulo que tenha os atributos largura e altura. Criar um método
calcular_perimetro que retorna o perímetro do retângulo e um método calcular_area
que retorna a área do retângulo. Criar um objeto retangulo1, imprimir seu perímetro e
área.

 Criar uma classe ContaCorrente que tenha os atributos numero, titular e saldo. Criar
um método depositar que adiciona um valor ao saldo e um método sacar que retira
um valor do saldo. Criar um objeto conta1 com saldo 100, depositar 50 e sacar 30.
Imprimir o saldo final.

 Criar uma classe Banco que tenha os atributos nome e contas (uma lista de objetos
ContaCorrente). Criar um método adicionar_conta que adiciona uma conta à lista e um
método remover_conta que remove uma conta da lista. Criar um objeto banco1,
adicionar uma conta com saldo 200, imprimir a lista de contas, remover a conta e
imprimir novamente a lista de contas.

Explicação do que você tem que faze logo abaixo :

  Exercício

Class Livro:

Def __init__(self, titulo, autor, ano_publicacao):

Self.titulo = titulo

Self.autor = autor

Self.ano_publicacao = ano_publicacao

Livro1 = Livro(“Dom Casmurro”, “Machado de Assis”, 1899)

Print(livro1.titulo, livro1.autor, livro1.ano_publicacao)

 Exercício

Class Pessoa:

Def __init__(self, nome, idade, endereco):

Self.nome = nome

Self.idade = idade

Self.endereco = endereco

Def aniversario(self):

Self.idade += 1

Pessoa1 = Pessoa(“João”, 30, “Rua X”)

Print(pessoa1.nome, pessoa1.idade, pessoa1.endereco)

Pessoa1.aniversario()

Print(pessoa1.nome, pessoa1.idade, pessoa1.endereco)

 Exercício

Class Retangulo:
 Def __init__(self, largura, altura):

Self.largura = largura

Self.altura = altura

Def calcular_perimetro(self):

Return 2 * (self.largura + self.altura)

Def calcular_area(self):

Return self.largura * self.altura

Retangulo1 = Retangulo(5, 3)

Print(retangulo1.calcular_perimetro())

Print(retangulo1.calcular_area())

 Exercício

Class ContaCorrente:

Def __init__(self, numero, titular, saldo):

Self.numero = numero

Self.titular = titular

Self.saldo = saldo

Def depositar(self, valor):

Self.saldo += valor

Def sacar(self, valor):

If self.saldo >= valor:

Self.saldo -= valor

Else:

Print(“Saldo insuficiente”)
Conta1 = ContaCorrente(123, “João”, 100)

Conta1.depositar(50)

Conta1.sacar(30)

Print(conta1.saldo)

 Exercício

Class Banco:

Def __init__(self, nome):

Self.nome = nome

Self.contas = []

Def adicionar_conta(self, conta):

Self.contas.append(conta)

Def remover_conta(self, conta):

Self.contas.remove(conta)

Conta1 = ContaCorrente(123, “João”, 200)

Banco1 = Banco(“Banco X”)

Banco1.adicionar_conta(conta1)

Print(banco1.contas[0].saldo)

Banco1.remover_conta(conta1)

Print(banco1.contas)

Pra nossa próxima aula iremos fala de

Usando bibliotecas como SQLite ou SQLAlchemy :

SQLite ou SQLAlchemy :
SQLite e SQLAlchemy são duas tecnologias diferentes que são usadas para trabalhar com
bancos de dados em Python.

SQLite é um banco de dados relacional embutido que não requer um servidor separado para
ser executado. Ele é bastante leve e é comumente usado em aplicativos de desktop e móveis,
bem como em pequenas aplicações web. SQLite é ideal para uso em aplicativos que não
exigem muita escalabilidade ou desempenho e não precisam de uma grande quantidade de
recursos.

SQLAlchemy, por outro lado, é uma biblioteca Python que fornece uma API para trabalhar com
bancos de dados relacionais. É uma solução mais avançada e poderosa para trabalhar com
bancos de dados em Python e é mais adequada para aplicativos complexos ou grandes, que
precisam de recursos mais avançados, como mapeamento objeto-relacional, gerenciamento
de transações, etc.

Em resumo, se você está trabalhando em uma aplicação simples que não requer muita
escalabilidade ou desempenho, SQLite pode ser uma boa escolha. Se, por outro lado, você está
trabalhando em um aplicativo mais complexo ou grande que exige recursos mais avançados,
como mapeamento objeto-relacional, gerenciamento de transações, etc., SQLAlchemy seria
uma opção mais adequada

Explicações em código :

Exemplo de uso do SQLite:

Import sqlite3

# Conectar ao banco de dados

Conn = sqlite3.connect(‘exemplo.db’)

# Criar uma tabela

Conn.execute(‘’’CREATE TABLE exemplo (

Id INTEGER PRIMARY KEY,

Nome TEXT NOT NULL,

Idade INTEGER);’’’)
# Inserir dados na tabela

Conn.execute(“INSERT INTO exemplo (nome, idade) VALUES (?, ?)”, (‘Maria’, 25))

Conn.execute(“INSERT INTO exemplo (nome, idade) VALUES (?, ?)”, (‘João’, 30))

# Selecionar dados da tabela

Cursor = conn.execute(“SELECT * from exemplo”)

For row in cursor:

Print(row)

# Fechar a conexão com o banco de dados

Conn.close()

Neste exemplo, estamos usando o SQLite para criar uma tabela e inserir alguns dados nela.
Depois, selecionamos todos os dados da tabela e imprimimos no console. Observe que a
conexão com o banco de dados é fechada no final do código.

Agora, vamos ver um exemplo de uso do SQLAlchemy:

From sqlalchemy import create_engine, Column, Integer, String

From sqlalchemy.orm import sessionmaker

From sqlalchemy.ext.declarative import declarative_base

# Criar uma engine para o banco de dados

Engine = create_engine(‘sqlite:///exemplo.db’)

# Criar uma sessão com o banco de dados

Session = sessionmaker(bind=engine)

Session = Session()

# Criar uma classe que representa a tabela

Base = declarative_base()
Class Exemplo(Base):

__tablename__ = ‘exemplo’

Id = Column(Integer, primary_key=True)

Nome = Column(String)

Idade = Column(Integer)

# Criar a tabela no banco de dados

Base.metadata.create_all(engine)

# Inserir dados na tabela

Session.add(Exemplo(nome=’Maria’, idade=25))

Session.add(Exemplo(nome=’João’, idade=30))

Session.commit()

# Selecionar dados da tabela

Resultados = session.query(Exemplo).all()

For resultado in resultados:

Print(resultado.nome, resultado.idade)

# Fechar a sessão com o banco de dados

Session.close()

Neste exemplo, estamos usando o SQLAlchemy para criar uma tabela e inserir alguns dados
nela. Observe que, em vez de escrever SQL diretamente, estamos definindo uma classe que
representa a tabela e suas colunas. O SQLAlchemy mapeia automaticamente os objetos Python
para linhas no banco de dados. Além disso, estamos usando uma sessão para interagir com o
banco de dados. A sessão nos permite realizar várias operações de banco de dados em uma
única transação, o que é importante para garantir a integridade dos dados

Exemplo de consulta usando SQLite:

Import sqlite3
# Conectar ao banco de dados

Conn = sqlite3.connect(‘exemplo.db’)

# Selecionar dados da tabela

Cursor = conn.execute(“SELECT * from exemplo WHERE idade > 25”)

For row in cursor:

Print(row)

# Fechar a conexão com o banco de dados

Conn.close()

Neste exemplo, estamos usando o SQLite para selecionar os dados da tabela onde a idade é
maior que 25. Observe que estamos escrevendo SQL diretamente para fazer a consulta.

Agora, vamos ver um exemplo de consulta usando SQLAlchemy:

From sqlalchemy import create_engine, Column, Integer, String

From sqlalchemy.orm import sessionmaker

From sqlalchemy.ext.declarative import declarative_base

# Criar uma engine para o banco de dados

Engine = create_engine(‘sqlite:///exemplo.db’)

# Criar uma sessão com o banco de dados

Session = sessionmaker(bind=engine)

Session = Session()

# Criar uma classe que representa a tabela

Base = declarative_base()

Class Exemplo(Base):
 __tablename__ = ‘exemplo’

Id = Column(Integer, primary_key=True)

Nome = Column(String)

Idade = Column(Integer)

# Selecionar dados da tabela

Resultados = session.query(Exemplo).filter(Exemplo.idade > 25).all()

For resultado in resultados:

Print(resultado.nome, resultado.idade)

# Fechar a sessão com o banco de dados

Session.close()

Neste exemplo, estamos usando o SQLAlchemy para selecionar os dados da tabela onde a
idade é maior que 25. Observe que estamos usando um método do SQLAlchemy para filtrar os
dados, em vez de escrever SQL diretamente. Além disso, estamos usando uma sessão para
interagir com o banco de dados, o que nos permite realizar a consulta de forma mais segura e
eficiente.

Outra diferença importante entre SQLite e SQLAlchemy é que o SQLAlchemy fornece um

recurso de mapeamento objeto-relacional (ORM), o que significa que podemos representar
tabelas e colunas em nossos aplicativos Python como objetos. Veja um exemplo de uso do
ORM do SQLAlchemy:

From sqlalchemy import create_engine, Column, Integer, String, ForeignKey

From sqlalchemy.orm import sessionmaker, relationship

From sqlalchemy.ext.declarative import declarative_base

# Criar uma engine para o banco de dados

Engine = create_engine(‘sqlite:///exemplo.db’)

# Criar uma sessão com o banco de dados

Session = sessionmaker(bind=engine)
Session = Session()

# Criar classes que representam as tabelas

Base = declarative_base()

Class Pessoa(Base):

__tablename__ = ‘pessoas’

Id = Column(Integer, primary_key=True)

Nome = Column(String)

Enderecos = relationship(‘Endereco’, back_populates=’pessoa’)

Class Endereco(Base):

__tablename__ = ‘enderecos’

Id = Column(Integer, primary_key=True)

Rua = Column(String)

Cidade = Column(String)

Estado = Column(String)

Pessoa_id = Column(Integer, ForeignKey(‘pessoas.id’))

Pessoa = relationship(‘Pessoa’, back_populates=’enderecos’)

# Criar as tabelas no banco de dados

Base.metadata.create_all(engine)

# Inserir dados nas tabelas

Pessoa1 = Pessoa(nome=’Maria’)

Endereco1 = Endereco(rua=’Rua A’, cidade=’São Paulo’, estado=’SP’)

Exemplo de consulta usando SQLite:

Import sqlite3

# Conectar ao banco de dados

Conn = sqlite3.connect(‘exemplo.db’)

# Executar uma consulta na tabela exemplo

Cursor = conn.execute(“SELECT * FROM exemplo”)

# Imprimir os resultados da consulta

For row in cursor:

Print(row)

# Fechar a conexão com o banco de dados

Conn.close()

Neste exemplo, estamos usando o SQLite para executar uma consulta na tabela exemplo e
imprimir os resultados.

Exemplo de consulta usando SQLAlchemy:

From sqlalchemy import create_engine, Column, Integer, String

From sqlalchemy.orm import sessionmaker

From sqlalchemy.ext.declarative import declarative_base

# Criar uma engine para o banco de dados

Engine = create_engine(‘sqlite:///exemplo.db’)

# Criar uma sessão com o banco de dados

Session = sessionmaker(bind=engine)
Session = Session()

# Criar uma classe que representa a tabela

Base = declarative_base()

Class Exemplo(Base):

__tablename__ = ‘exemplo’

Id = Column(Integer, primary_key=True)

Nome = Column(String)

Idade = Column(Integer)

# Executar uma consulta na tabela exemplo

Resultados = session.query(Exemplo).all()

# Imprimir os resultados da consulta

For resultado in resultados:

Print(resultado.nome, resultado.idade)

# Fechar a sessão com o banco de dados

Session.close()

Neste exemplo, estamos usando o SQLAlchemy para executar uma consulta na tabela exemplo
e imprimir os resultados. Observe que estamos usando uma classe do SQLAlchemy para
representar a tabela e executar a consulta, em vez de escrever SQL diretamente.

Exemplo de atualização de dados usando SQLite:

Import sqlite3

# Conectar ao banco de dados

Conn = sqlite3.connect(‘exemplo.db’)

# Atualizar um registro na tabela exemplo

Conn.execute(“UPDATE exemplo SET idade = 40 WHERE nome = ‘João’”)

# Salvar as alterações no banco de dados

Conn.commit()

# Fechar a conexão com o banco de dados

Conn.close()

Neste exemplo, estamos usando o SQLite para atualizar um registro na tabela exemplo.
Observe que estamos escrevendo SQL diretamente para atualizar o registro.

Exemplo de atualização de dados usando SQLAlchemy:

From sqlalchemy import create_engine, Column, Integer, String

From sqlalchemy.orm import sessionmaker

From sqlalchemy.ext.declarative import declarative_base

# Criar uma engine para o banco de dados

Engine = create_engine(‘sqlite:///exemplo.db’)

# Criar uma sessão com o banco de dados

Session = sessionmaker(bind=engine)

Session = Session()

# Criar uma classe que representa a tabela

Base = declarative_base()

Class Exemplo(Base):

__tablename__ = ‘exemplo’

Id = Column(Integer, primary_key=True)

Nome = Column(String)

Idade = Column(Integer)
# Atualizar um registro na tabela exemplo

Exemplo = session.query(Exemplo).filter_by(nome=’João’).first()

Exemplo.idade = 40

Session.commit()

# Fechar a sessão com o banco de dados

Session.close()

Neste exemplo, estamos usando o SQLAlchemy para atualizar um registro na tabela exemplo.
Observe que estamos usando uma classe do SQLAlchemy para representar a tabela e atualizar
o registro de forma segura e eficiente.

Exemplo de exclusão de dados usando SQLite:

Import sqlite3

# Conectar ao banco de dados

Exercício

 Crie um banco de dados SQLite com uma tabela chamada “clientes”. A tabela deve ter
colunas para “id” (inteiro), “nome” (texto) e “idade” (inteiro).

 Insira alguns registros na tabela “clientes” usando SQL ou SQLAlchemy. Certifique-se

de incluir pelo menos 3 clientes.

 Execute uma consulta na tabela “clientes” para encontrar todos os clientes com mais
de 30 anos de idade. Use SQL ou SQLAlchemy para executar a consulta.

 Atualize o registro mais antigo na tabela “clientes” para ter 50 anos de idade. Use SQL
ou SQLAlchemy para executar a atualização.
  Exclua o registro mais recente na tabela “clientes”. Use SQL ou SQLAlchemy para
executar a exclusão.

Exemplo do Exercício em código :

# Exercício 1: criar um banco de dados SQLite com uma tabela “clientes”

Import sqlite3

Conn = sqlite3.connect(‘clientes.db’)

Conn.execute(‘’’CREATE TABLE clientes

(id INTEGER PRIMARY KEY,

Nome TEXT,

Idade INTEGER);’’’)

# Exercício 2: inserir alguns registros na tabela “clientes”

Conn.execute(“INSERT INTO clientes (nome, idade) VALUES (‘João’, 35)”)

Conn.execute(“INSERT INTO clientes (nome, idade) VALUES (‘Maria’, 40)”)

Conn.execute(“INSERT INTO clientes (nome, idade) VALUES (‘José’, 25)”)

Conn.commit()

# Exercício 3: encontrar todos os clientes com mais de 30 anos de idade

Cursor = conn.execute(“SELECT * FROM clientes WHERE idade > 30”)

For row in cursor:

Print(row)

# Exercício 4: atualizar o registro mais antigo para ter 50 anos de idade

Cursor = conn.execute(“SELECT * FROM clientes ORDER BY id ASC LIMIT 1”)

Row = cursor.fetchone()

Id = row[0]
Conn.execute(“UPDATE clientes SET idade = 50 WHERE id = ?”, (id,))

Conn.commit()

# Exercício 5: excluir o registro mais recente

Cursor = conn.execute(“SELECT * FROM clientes ORDER BY id DESC LIMIT 1”)

Row = cursor.fetchone()

Id = row[0]

Conn.execute(“DELETE FROM clientes WHERE id = ?”, (id,))

Conn.commit()

# Fechar a conexão com o banco de dados

Conn.close()

Neste exemplo, estamos criando um banco de dados SQLite com uma tabela “clientes”,
inserindo alguns registros, executando consultas para encontrar clientes com mais de 30 anos
de idade e atualizando/excluindo registros específicos. Este é apenas um exemplo simples,
mas espero que ajude a ilustrar como trabalhar com SQLite em Python.

Outro exercício pra você

 Crie um banco de dados SQLite com uma tabela chamada “produtos”. A tabela deve
ter colunas para “id” (inteiro), “nome” (texto), “preco” (real) e “quantidade” (inteiro).

 Insira alguns registros na tabela “produtos” usando SQL ou SQLAlchemy. Certifique-se

de incluir pelo menos 3 produtos.

 Execute uma consulta na tabela “produtos” para encontrar todos os produtos com um
preço superior a R$100. Use SQL ou SQLAlchemy para executar a consulta.

 Atualize a quantidade do produto mais vendido na tabela “produtos” para 50. Use SQL
ou SQLAlchemy para executar a atualização.

 Exclua todos os produtos com quantidade igual a zero da tabela “produtos”. Use SQL
ou SQLAlchemy para executar a exclusão.
Exemplo em código :

# Exercício 1: criar um banco de dados SQLite com uma tabela “produtos”

Import sqlite3

Conn = sqlite3.connect(‘produtos.db’)

Conn.execute(‘’’CREATE TABLE produtos

(id INTEGER PRIMARY KEY,

Nome TEXT,

Preco REAL,

Quantidade INTEGER);’’’)

# Exercício 2: inserir alguns registros na tabela “produtos”

Conn.execute(“INSERT INTO produtos (nome, preco, quantidade) VALUES (‘Laptop’, 4500.0,

10)”)

Conn.execute(“INSERT INTO produtos (nome, preco, quantidade) VALUES (‘Smartphone’,

2500.0, 5)”)

Conn.execute(“INSERT INTO produtos (nome, preco, quantidade) VALUES (‘Tablet’, 1500.0,

20)”)

Conn.commit()

# Exercício 3: encontrar todos os produtos com preço superior a R$100

Cursor = conn.execute(“SELECT * FROM produtos WHERE preco > 100”)

For row in cursor:

Print(row)

# Exercício 4: atualizar a quantidade do produto mais vendido para 50

Cursor = conn.execute(“SELECT * FROM produtos ORDER BY quantidade DESC LIMIT 1”)

Row = cursor.fetchone()

Id = row[0]

Conn.execute(“UPDATE produtos SET quantidade = 50 WHERE id = ?”, (id,))

Conn.commit()

# Exercício 5: excluir todos os produtos com quantidade igual a zero

Conn.execute(“DELETE FROM produtos WHERE quantidade = 0”)

Conn.commit()

# Fechar a conexão com o banco de dados

Conn.close()

Neste exemplo, estamos criando um banco de dados SQLite com uma tabela “produtos”,
inserindo alguns registros, executando consultas para encontrar produtos com um preço
superior a R$100 e atualizando/excluindo registros específicos. Este é apenas um exemplo
simples, mas espero que ajude a ilustrar como trabalhar com SQLite em Python.

Outro exercício :

 Crie uma tabela “clientes” com as seguintes colunas: “id” (inteiro), “nome” (texto),
“email” (texto), “telefone” (texto).

 Insira alguns registros na tabela “clientes” usando SQL ou SQLAlchemy. Certifique-se

de incluir pelo menos 3 clientes.

 Execute uma consulta na tabela “clientes” para encontrar todos os clientes com um
email que termine em “@gmail.com”. Use SQL ou SQLAlchemy para executar a
consulta.

 Atualize o telefone do cliente com o nome “João” para “(11) 98765-4321”. Use SQL ou
SQLAlchemy para executar a atualização.

 Exclua o cliente com o email [email protected] da tabela “clientes”. Use SQL ou

SQLAlchemy para executar a exclusão.

Exemplo em código :

# Exercício 1: criar uma tabela “clientes”

Import sqlite3

Conn = sqlite3.connect(‘clientes.db’)

Conn.execute(‘’’CREATE TABLE clientes

(id INTEGER PRIMARY KEY,

Nome TEXT,

Email TEXT,

Telefone TEXT);’’’)

# Exercício 2: inserir alguns registros na tabela “clientes”

Conn.execute(“INSERT INTO clientes (nome, email, telefone) VALUES (‘João’,

‘[email protected]’, ‘(11) 99999-8888’)”)

Conn.execute(“INSERT INTO clientes (nome, email, telefone) VALUES (‘Maria’,

‘[email protected]’, ‘(21) 55555-4444’)”)

Conn.execute(“INSERT INTO clientes (nome, email, telefone) VALUES (‘Pedro’,

‘[email protected]’, ‘(31) 22222-1111’)”)

Conn.commit()

# Exercício 3: encontrar todos os clientes com um email que termine em “@gmail.com”

Cursor = conn.execute(“SELECT * FROM clientes WHERE email LIKE ‘%@gmail.com’”)

For row in cursor:

Print(row)

# Exercício 4: atualizar o telefone do cliente com o nome “João” para “(11) 98765-4321”

Conn.execute(“UPDATE clientes SET telefone = ‘(11) 98765-4321’ WHERE nome = ‘João’”)

Conn.commit()

# Exercício 5: excluir o cliente com o email [email protected]

Conn.execute(“DELETE FROM clientes WHERE email = ‘[email protected]’”)

Conn.commit()

# Fechar a conexão com o banco de dados

Conn.close()

Neste exemplo, estamos criando uma tabela “clientes” e inserindo alguns registros,
executando consultas para encontrar clientes com um email que termina em “@gmail.com” e
atualizando/excluindo registros específicos. Espero que este exemplo ajude a ilustrar como
trabalhar com SQLite em Python!

Próxima aula sobre

Como criar interfaces gráficas de usuário em Python, usando bibliotecas como tkinter, PyQt ou
wxPython.

Criar interfaces gráficas de usuário é um aspecto importante da programação de aplicativos.

Em Python, existem várias bibliotecas que você pode usar para criar interfaces gráficas de
usuário, como tkinter, PyQt e wxPython.

Tkinter é a biblioteca padrão para criar interfaces gráficas em Python. É fácil de aprender e
usar, e pode ser usado para criar interfaces simples e básicas. No entanto, se você precisa de
recursos mais avançados, pode precisar de uma biblioteca mais robusta.

PyQt é uma biblioteca Python que fornece uma interface para a biblioteca Qt de C++. Ele
oferece recursos avançados de interface do usuário, como widgets personalizados e
animações, e é uma boa escolha se você precisa de uma interface gráfica sofisticada.

wxPython é uma biblioteca Python que fornece uma interface para a biblioteca wxWidgets de
C++. Ele também oferece recursos avançados de interface do usuário, como gráficos 3D e
recursos de manipulação de imagens, e é outra boa opção se você precisa de recursos
avançados de interface gráfica.

Com essas bibliotecas, você pode criar janelas, botões, caixas de texto e outros widgets de
interface do usuário, que podem ser organizados em layouts para criar uma interface gráfica
completa. Você pode então adicionar lógica de negócios por trás da interface do usuário para
criar um aplicativo funcional.

Em resumo, criar interfaces gráficas de usuário em Python é um processo relativamente

simples, graças às bibliotecas como tkinter, PyQt e wxPython. Com essas bibliotecas, você
pode criar interfaces gráficas avançadas com recursos personalizados, o que pode ser
especialmente útil para desenvolver aplicativos desktop e interfaces de usuário para projetos
de ciência de dados.

Vou fornecer um exemplo básico usando a biblioteca Tkinter para criar uma interface gráfica
simples. O exemplo a seguir criará uma janela com um rótulo e um botão:

Import tkinter as tk

Def button_clicked():

Print(“O botão foi clicado!”)

# Cria a janela principal

Root = tk.Tk()

# Define o título da janela

Root.title(“Minha janela”)

# Cria um rótulo na janela

Label = tk.Label(root, text=”Bem-vindo à minha janela!”)

Label.pack()

# Cria um botão na janela

Button = tk.Button(root, text=”Clique aqui!”, command=button_clicked)

Button.pack()

# Inicia a janela principal

Root.mainloop()

Neste exemplo, estamos importando a biblioteca Tkinter e definindo uma função chamada
button_clicked() que será executada quando o botão for clicado. Em seguida, criamos a janela
principal usando a classe Tk e definimos seu título usando o método title(). Em seguida,
criamos um rótulo e um botão usando as classes Label e Button, respectivamente, e os
adicionamos à janela principal usando o método pack(). Finalmente, iniciamos o loop principal
da janela usando o método mainloop().

Esse é apenas um exemplo básico, mas com a biblioteca Tkinter, você pode criar janelas mais
complexas e adicionar muitos outros widgets de interface do usuário, como caixas de texto,
menus suspensos e gráficos. Combinando a interface gráfica com a lógica de negócios do seu
aplicativo, você pode criar aplicativos desktop Python completos e funcionais.

Aqui estão alguns exemplos adicionais usando a biblioteca Tkinter para criar interfaces gráficas
de usuário em Python:

Exemplo 1: Caixa de diálogo de confirmação

Import tkinter as tk

From tkinter import messagebox

Def confirm_exit():

Answer = messagebox.askyesno(“Confirmação”, “Tem certeza de que deseja sair?”)

If answer:

Root.quit()

# Cria a janela principal

Root = tk.Tk()

# Define o título da janela

Root.title(“Minha janela”)

# Cria um botão na janela

Button = tk.Button(root, text=”Sair”, command=confirm_exit)

Button.pack()

# Inicia a janela principal

Root.mainloop()

Neste exemplo, criamos uma caixa de diálogo de confirmação que aparece quando o botão
“Sair” é clicado. Usamos a classe messagebox da biblioteca tkinter para criar a caixa de diálogo
e pedir ao usuário que confirme a ação. Se o usuário clicar em “Sim”, a função confirm_exit()
chama o método quit() da janela principal para encerrar o programa.

Exemplo 2: Calculadora básica

Import tkinter as tk

Def add_digit(digit):

Display.insert(tk.END, digit)

Def clear_display():

Display.delete(0, tk.END)

Def calculate():

Expression = display.get()

Try:

Result = eval(expression)

Display.delete(0, tk.END)

Display.insert(tk.END, result)

Except:

Display.delete(0, tk.END)

Display.insert(tk.END, “Erro”)

# Cria a janela principal

Root = tk.Tk()

# Define o título da janela

Root.title(“Calculadora”)
# Cria um campo de entrada para a calculadora

Display = tk.Entry(root, width=20, font=(“Arial”, 16))

Display.grid(row=0, column=0, columnspan=4)

# Cria os botões da calculadora

Button_1 = tk.Button(root, text=”1”, command=lambda: add_digit(1))

Button_1.grid(row=1, column=0)

Button_2 = tk.Button(root, text=”2”, command=lambda: add_digit(2))

Button_2.grid(row=1, column=1)

Button_3 = tk.Button(root, text=”3”, command=lambda: add_digit(3))

Button_3.grid(row=1, column=2)

Button_4 = tk.Button(root, text=”4”, command=lambda: add_digit(4))

Button_4.grid(row=2, column=0)

Button_5 = tk.Button(root, text=”5”, command=lambda: add_digit(5))

Button_5.grid(row=2, column=1)

Button_6 = tk.Button(root, text=”6”, command=lambda: add_digit(6))

Button_6.grid(row=2, column=2)

Button_7 = tk.Button(root, text=”7”, command=lambda: add_digit(7))

Button_7.grid(row=3, column=0)

Button_8 = tk.Button(root, text=”8”, command=lambda: add_digit(8))

Button_8.grid(row=3, column=1)

Button_9 = tk.Button(root, text=”9”, command=lambda: add_digit(9))

Button_9.grid(row=3, column=2)
Button_0 = tk.Button(root, text=”0”, command=lambda: add_digit(0))

Button_0.grid(row=4, column=1

Bibliotecas PyQt e wxPython para criar interfaces gráficas de usuário em Python:

Exemplo usando PyQt: Conversor de temperaturas

Import sys

From PyQt5.QtWidgets import QApplication, QWidget, QLabel, QDoubleSpinBox,

QPushButton, QVBoxLayout

Class TemperatureConverter(QWidget):

Def __init__(self):

Super().__init__()

# Define o título da janela

Self.setWindowTitle(‘Conversor de temperaturas’)

# Cria as caixas de entrada de temperatura

Self.celsius_box = QDoubleSpinBox(self)

Self.celsius_box.setRange(-273.15, 10000)

Self.celsius_box.setSingleStep(0.1)

Self.celsius_box.setSuffix(‘ °C’)

Self.celsius_box.valueChanged.connect(self.convert_temperatures)

Self.fahrenheit_box = QDoubleSpinBox(self)

Self.fahrenheit_box.setRange(-459.67, 10000)

Self.fahrenheit_box.setSingleStep(0.1)
 Self.fahrenheit_box.setSuffix(‘ °F’)

Self.fahrenheit_box.valueChanged.connect(self.convert_temperatures)

# Cria o botão de saída

Self.quit_button = QPushButton(‘Sair’, self)

Self.quit_button.clicked.connect(self.close)

# Cria o layout vertical da janela

Layout = QVBoxLayout(self)

Layout.addWidget(QLabel(‘Digite uma temperatura abaixo:’))

Layout.addWidget(self.celsius_box)

Layout.addWidget(self.fahrenheit_box)

Layout.addWidget(self.quit_button)

Def convert_temperatures(self):

Celsius = self.celsius_box.value()

Fahrenheit = celsius * 9/5 + 32

Self.fahrenheit_box.setValue(fahrenheit)

Fahrenheit = self.fahrenheit_box.value()

Celsius = (fahrenheit – 32) * 5/9

Self.celsius_box.setValue(celsius)

# Cria a aplicação PyQt

App = QApplication(sys.argv)

# Cria a janela principal

Window = TemperatureConverter()

Window.show()

# Inicia a aplicação PyQt

Sys.exit(app.exec_())

Neste exemplo, criamos uma janela com duas caixas de entrada para temperatura (uma para
Celsius e outra para Fahrenheit) e um botão para sair. Quando o usuário insere uma
temperatura em uma das caixas de entrada, a função convert_temperatures() é chamada para
converter a temperatura para a outra unidade. Usamos a biblioteca PyQt5 para criar a
interface gráfica de usuário e definimos as propriedades das caixas de entrada, como faixas de
valores e incrementos de etapa.

Exemplo usando wxPython: Editor de texto simples

Import wx

Class SimpleTextEditor(wx.Frame):

Def __init__(self, parent, title):

Super().__init__(parent, title=title)

# Cria o campo de texto

Self.text_ctrl = wx.TextCtrl(self, style=wx.TE_MULTILINE)

# Cria o botão de saída

Self.quit_button = wx.Button(self, label=’Sair’)

Self.quit_button.Bind(wx.EVT_BUTTON, self.OnQuit)

# Cria o layout vertical da janela

Sizer = wx.BoxSizer(wx.VERTICAL)

Sizer.Add(self.text_ctrl, 1, wx.EXPAND)

Sizer.Add(self.quit_button, 0, wx.ALIGN_RIGHT)

Self.SetSizer(sizer)

# Define o tamanho mínimo da janela

Self.SetMinSize(wx.Size(400, 300))
 Def OnQuit(self,

Exemplo usando PyQt: Calculadora simples

Import sys

From PyQt5.QtWidgets import QApplication, QWidget, QVBoxLayout, QHBoxLayout, QLineEdit,

QPushButton

Class Calculator(QWidget):

Def __init__(self):

Super().__init__()

# Define o título da janela

Self.setWindowTitle(‘Calculadora’)

# Cria a caixa de texto da calculadora

Self.result_display = QLineEdit()

Self.result_display.setReadOnly(True)

Self.result_display.setAlignment(Qt.AlignRight)

# Cria os botões numéricos

Self.button_0 = QPushButton(‘0’)

Self.button_1 = QPushButton(‘1’)

Self.button_2 = QPushButton(‘2’)

Self.button_3 = QPushButton(‘3’)

Self.button_4 = QPushButton(‘4’)

Self.button_5 = QPushButton(‘5’)

Self.button_6 = QPushButton(‘6’)

Self.button_7 = QPushButton(‘7’)
Self.button_8 = QPushButton(‘8’)

Self.button_9 = QPushButton(‘9’)

# Cria os botões de operação

Self.button_plus = QPushButton(‘+’)

Self.button_minus = QPushButton(‘-‘)

Self.button_multiply = QPushButton(‘*’)

Self.button_divide = QPushButton(‘/’)

Self.button_equals = QPushButton(‘=’)

Self.button_clear = QPushButton(‘C’)

# Conecta os sinais dos botões às funções

Self.button_0.clicked.connect(lambda: self.add_digit(‘0’))

Self.button_1.clicked.connect(lambda: self.add_digit(‘1’))

Self.button_2.clicked.connect(lambda: self.add_digit(‘2’))

Self.button_3.clicked.connect(lambda: self.add_digit(‘3’))

Self.button_4.clicked.connect(lambda: self.add_digit(‘4’))

Self.button_5.clicked.connect(lambda: self.add_digit(‘5’))

Self.button_6.clicked.connect(lambda: self.add_digit(‘6’))

Self.button_7.clicked.connect(lambda: self.add_digit(‘7’))

Self.button_8.clicked.connect(lambda: self.add_digit(‘8’))

Self.button_9.clicked.connect(lambda: self.add_digit(‘9’))

Self.button_plus.clicked.connect(lambda: self.add_operator(‘+’))

Self.button_minus.clicked.connect(lambda: self.add_operator(‘-‘))

Self.button_multiply.clicked.connect(lambda: self.add_operator(‘*’))

Self.button_divide.clicked.connect(lambda: self.add_operator(‘/’))

Self.button_equals.clicked.connect(self.calculate)

Self.button_clear.clicked.connect(self.clear)
# Cria o layout da janela

Numeric_buttons_layout = QVBoxLayout()

Numeric_buttons_layout.addWidget(self.button_7)

Numeric_buttons_layout.addWidget(self.button_8)

Numeric_buttons_layout.addWidget(self.button_9)

Numeric_buttons_layout.addWidget(self.button_4)

Numeric_buttons_layout.addWidget(self.button_5)

Numeric_buttons_layout.addWidget(self.button_6)

Numeric_buttons_layout.addWidget(self.button_1)

Numeric_buttons_layout.addWidget(self.button_2)

Numeric_buttons_layout.addWidget(self.button_3)

Numeric_buttons_layout.addWidget(self.button_0)

Operation_buttons_layout = QVBoxLayout()

Operation_buttons_layout.addWidget(self.button_plus)

Operation_buttons_layout.addWidget(self.button_minus)

Operation_buttons_layout.addWidget(self.button_multiply)

Operation_buttons_layout.addWidget(self.button_divide)

Operation_buttons_layout.addWidget(self.button_equals)

Operation_buttons_layout.addWidget(self.button_clear)

Display_layout = QHBoxLayout()

Display_layout.addWidget(self.result_display)

Main_layout = QVBoxLayout()

Main_layout.addLayout(display_layout)

Main_layout.addLayout(numeric_buttons_layout)

Main_layout.addLayout(operation_buttons_layout)

Self.setLayout(main_layout)
 # Define o tamanho da janela

Self.setFixedSize(

Exemplo usando tkinter: Aplicativo de conversão de temperatura

Import tkinter as tk

Class TemperatureConverter(tk.Frame):

Def __init__(self, master=None):

Super().__init__(master)

# Define o título da janela

Self.master = master

Self.master.title(‘Conversor de Temperatura’)

# Cria a caixa de entrada

Self.input_label = tk.Label(self, text=’Temperatura em Celsius:’)

Self.input_label.grid(row=0, column=0, padx=5, pady=5)

Self.input_entry = tk.Entry(self)

Self.input_entry.grid(row=0, column=1, padx=5, pady=5)

# Cria o botão de conversão

Self.convert_button = tk.Button(self, text=’Converter’,

command=self.convert_temperature)

Self.convert_button.grid(row=1, column=0, columnspan=2, padx=5, pady=5)

# Cria a caixa de saída

Self.output_label = tk.Label(self, text=’Temperatura em Fahrenheit:’)

 Self.output_label.grid(row=2, column=0, padx=5, pady=5)

Self.output_entry = tk.Entry(self, state=’readonly’)

Self.output_entry.grid(row=2, column=1, padx=5, pady=5)

Self.pack()

Def convert_temperature(self):

Celsius = float(self.input_entry.get())

Fahrenheit = celsius * 1.8 + 32

Self.output_entry.config(state=’normal’)

Self.output_entry.delete(0, tk.END)

Self.output_entry.insert(0, fahrenheit)

Self.output_entry.config(state=’readonly’)

Root = tk.Tk()

App = TemperatureConverter(master=root)

App.mainloop()

Exemplo usando PyQt: Editor de texto simples

Import sys

From PyQt5.QtWidgets import QApplication, QWidget, QVBoxLayout, QHBoxLayout,

QTextEdit, QPushButton, QFileDialog

Class TextEditor(QWidget):

Def __init__(self):

Super().__init__()

# Define o título da janela

Self.setWindowTitle(‘Editor de Texto’)
 # Cria a caixa de texto

Self.text_edit = QTextEdit()

Self.text_edit.setAcceptRichText(False)

# Cria os botões

Self.open_button = QPushButton(‘Abrir’)

Self.save_button = QPushButton(‘Salvar’)

# Conecta os sinais dos botões às funções

Self.open_button.clicked.connect(self.open_file)

Self.save_button.clicked.connect(self.save_file)

# Cria o layout da janela

Button_layout = QHBoxLayout()

Button_layout.addWidget(self.open_button)

Button_layout.addWidget(self.save_button)

Main_layout = QVBoxLayout()

Main_layout.addWidget(self.text_edit)

Main_layout.addLayout(button_layout)

Self.setLayout(main_layout)

# Define o tamanho da janela

Self.setFixedSize(400, 400)

Def open_file(self):

File_name, _ = QFileDialog.getOpenFileName(self, ‘Abrir arquivo’, ‘’, ‘Text Files (*.txt)’)

If file_name:

With open(file_name, ‘r’) as f:

 Self.text_edit.setText(f.read())

Def save_file(self):

File_name, _ = QFileDialog.getSaveFileName(self, ‘Salvar arquivo’, ‘’, ‘Text Files (*.txt)’)

If file_name:

With open(file_name, ‘w’) as f:

f.write(self.text_edit.toPlainText())

if __name__ == ‘__main__’:

Exercício :

 Crie uma janela simples usando a biblioteca Tkinter com um botão que, quando
clicado, imprime “Hello World” no console.
 Crie uma interface gráfica de usuário usando a biblioteca PyQt que permita ao usuário
inserir um nome e uma idade em campos de entrada e, em seguida, pressionar um
botão para exibir essas informações em uma caixa de diálogo pop-up.
 Crie uma janela usando a biblioteca wxPython que exibe uma imagem e um botão.
Quando o botão é clicado, a imagem é alterada para uma imagem diferente.
 Crie uma interface gráfica de usuário usando a biblioteca Tkinter que permita ao
usuário selecionar um arquivo usando uma caixa de diálogo de seleção de arquivo e,
em seguida, exiba o conteúdo desse arquivo em um widget de texto.
 Crie uma janela usando a biblioteca PyQt que tenha uma barra de menu com uma
opção “Arquivo” que, quando clicada, exibe um menu suspenso com opções “Abrir” e
“Sair”. A opção “Abrir” deve abrir uma caixa de diálogo de seleção de arquivo e exibir o
conteúdo do arquivo selecionado em um widget de texto.

Exemplo desse exercício :

Import tkinter as tk

Def say_hello():

Print(“Hello World”)

Root = tk.Tk()
Root.title(“Minha Janela Tkinter”)

Root.geometry(“300x200”)

Button = tk.Button(root, text=”Clique aqui!”, command=say_hello)

Button.pack(pady=50)

Root.mainloop()

Neste exemplo, criamos uma janela usando tk.Tk() e configuramos o título e as dimensões da
janela. Em seguida, criamos um botão usando tk.Button(), que tem um rótulo “Clique aqui!” e
é vinculado à função say_hello() usando o parâmetro command. Quando o botão é clicado, a
função say_hello() é chamada e imprime “Hello World” no console. Finalmente, usamos
root.mainloop() para executar o loop principal da janela e exibir a interface gráfica de usuário.

Aqui está um exemplo adicional de um exercício que usa a biblioteca PyQt para criar uma
interface gráfica de usuário que permite ao usuário inserir um nome e uma idade em campos
de entrada e, em seguida, pressionar um botão para exibir essas informações em uma caixa de
diálogo pop-up:

Import sys

From PyQt5.QtWidgets import QApplication, QWidget, QLabel, QLineEdit, QPushButton,

QMessageBox

Class MyWindow(QWidget):

Def __init__(self):

Super().__init__()

Self.setWindowTitle(“Minha Interface Gráfica de Usuário PyQt”)

Self.setGeometry(200, 200, 400, 300)

Self.setupUI()

Def setupUI(self):

nameLabel = QLabel(“Nome:”, self)

nameLabel.move(50, 50)
 self.nameInput = QLineEdit(self)

self.nameInput.move(150, 50)

ageLabel = QLabel(“Idade:”, self)

ageLabel.move(50, 100)

self.ageInput = QLineEdit(self)

self.ageInput.move(150, 100)

button = QPushButton(“Exibir Informações”, self)

button.move(150, 150)

button.clicked.connect(self.showInfo)

def showInfo(self):

name = self.nameInput.text()

age = self.ageInput.text()

info = f”Seu nome é {name} e sua idade é {age} anos.”

QMessageBox.information(self, “Informações do Usuário”, info)

If __name__ == ‘__main__’:

App = QApplication(sys.argv)

Window = MyWindow()

Window.show()

Sys.exit(app.exec_())

Neste exemplo, criamos uma janela usando QApplication e QWidget, definimos o título e as
dimensões da janela usando setWindowTitle() e setGeometry(), e adicionamos campos de
entrada de texto usando QLineEdit e QLabel. Também adicionamos um botão usando
QPushButton e vinculamos a função showInfo() ao evento de clique do botão usando
clicked.connect(). Quando o botão é clicado, a função showInfo() é chamada, que coleta os
valores inseridos nos campos de entrada de texto usando text() e exibe essas informações em
uma caixa de diálogo pop-up usando QMessageBox. Finalmente, usamos QApplication.exec_()
para executar o loop principal da janela e exibir a interface gráfica de usuário.

Outro exercício
  Crie uma interface gráfica de usuário usando a biblioteca tkinter que permita ao
usuário selecionar um arquivo de imagem em seu computador e exibi-lo em um rótulo
na interface gráfica de usuário.

 Crie uma interface gráfica de usuário usando a biblioteca PyQt que permita ao usuário
inserir uma lista de nomes em uma caixa de texto e, em seguida, pressionar um botão
para classificar a lista em ordem alfabética e exibi-la em uma caixa de texto separada.

 Crie uma interface gráfica de usuário usando a biblioteca wxPython que permita ao
usuário selecionar uma pasta no seu computador e exibir uma lista de todos os
arquivos nessa pasta em uma janela de lista na interface gráfica de usuário.

 Crie uma interface gráfica de usuário usando a biblioteca tkinter que permita ao
usuário inserir uma lista de números em uma caixa de texto e, em seguida, pressionar
um botão para calcular a média e o desvio padrão desses números e exibi-los em
caixas de texto separadas.

 Crie uma interface gráfica de usuário usando a biblioteca PyQt que permita ao usuário
selecionar um arquivo de texto em seu computador e exibir seu conteúdo em uma
caixa de texto na interface gráfica de usuário, permitindo que o usuário edite o texto e,
em seguida, salve as alterações no arquivo original.

Exemplo em código

Import tkinter as tk

From tkinter import filedialog

From PIL import ImageTk, Image

Root = tk.Tk()

Def open_image():

Filepath = filedialog.askopenfilename(title=”Select na image”, filetypes=((“PNG files”,

“*.png”), (“JPEG files”, “*.jpg”), (“All files”, “*.*”)))

Img = Image.open(filepath)

Img = img.resize((300, 300))

Img = ImageTk.PhotoImage(img)
 Label.config(image=img)

Label.image = img

Button = tk.Button(root, text=”Open Image”, command=open_image)

Button.pack()

Label = tk.Label(root)

Label.pack()

Root.mainloop()

Exemplo em PyQt:

Exemplo

From PyQt5 import QtCore, QtGui, QtWidgets

Class MyWindow(QtWidgets.QWidget):

Def __init__(self):

Super().__init__()

Self.names = QtWidgets.QTextEdit()

Self.names.setPlainText(“John\nMary\nPeter\nAnne”)

Self.sorted_names = QtWidgets.QTextEdit()

Self.sort_button = QtWidgets.QPushButton(“Sort Names”)

Self.sort_button.clicked.connect(self.sort_names)

Layout = QtWidgets.QVBoxLayout()

Layout.addWidget(self.names)

Layout.addWidget(self.sort_button)

Layout.addWidget(self.sorted_names)

Self.setLayout(layout)
 Def sort_names(self):

Names = self.names.toPlainText().split(“\n”)

Names.sort()

Self.sorted_names.setPlainText(“\n”.join(names))

App = QtWidgets.QApplication([])

Win = MyWindow()

Win.show()

App.exec_()

Exemplo em wxPython:

Exemplo

Import wx

Import os

Class MyFrame(wx.Frame):

Def __init__(self):

Super().__init__(None, title=”File Browser”, size=(400, 300))

Panel = wx.Panel(self)

Vbox = wx.BoxSizer(wx.VERTICAL)

Hbox = wx.BoxSizer(wx.HORIZONTAL)

Self.path_label = wx.StaticText(panel, label=””)

Self.file_list = wx.ListBox(panel)

Self.file_list.Bind(wx.EVT_LISTBOX_DCLICK, self.on_double_click)

Hbox.Add(self.path_label, proportion=1, flag=wx.EXPAND)

Vbox.Add(hbox, proportion=0, flag=wx.EXPAND|wx.LEFT|wx.RIGHT|wx.TOP, border=10)

Vbox.Add(self.file_list, proportion=1, flag=wx.EXPAND|wx.LEFT|wx.RIGHT|wx.BOTTOM,

border=10)

Panel.SetSizer(vbox)
 Self.Show()

Def on_double_click(self, event):

Selected_file = self.file_list.GetStringSelection()

If selected_file:

Path = os.path.join(self.path, selected_file)

If os.path.isfile(path):

With open(path, “r”) as f:

Contents = f.read()

Dialog = wx.MessageDialog(None, contents, “File Contents”, wx.OK)

Dialog.ShowModal()

Def update_file_list(self):

Self.file_list.Clear()

Files = os.listdir(self.path)

For file in files:

Self.file_list.Append(file)

Def on_dir_changed(self, event):

Self.path = event.GetPath()

Self.path_label.SetLabel(self.path)

Self.update_file_list()

App = wx.App()

Frame = MyFrame()

Dlg = wx.DirDialog(None, “Choose a directory:”)

If dlg.ShowModal() == wx.ID_OK:

Frame.on_dir_changed(dlg)

Dlg.Destroy()

App.MainLoop()

Exemplo em tkinter:
Exemplo

Import tkinter as tk

Import statistics

Root = tk.Tk()

Def calculate_stats():

Numbers = [float(num) for num in entry.get().split()]

Mean = statistics.mean(numbers)

Stdev =

Outro exercício:

 Crie uma interface gráfica de usuário usando tkinter que permita ao usuário inserir um
número e, ao clicar em um botão, exiba uma mensagem informando se o número é
par ou ímpar.

 Crie uma interface gráfica de usuário usando PyQt que permita ao usuário inserir o
nome e a idade de uma pessoa e, ao clicar em um botão, exiba uma mensagem
informando se a pessoa é maior ou menor de idade.

 Crie uma interface gráfica de usuário usando wxPython que permita ao usuário inserir
dois números e, ao clicar em um botão, exiba uma mensagem informando qual é o
maior número.

 Crie uma interface gráfica de usuário usando tkinter que permita ao usuário inserir
uma palavra e, ao clicar em um botão, exiba uma mensagem informando se a palavra
é um palíndromo (ou seja, se é igual quando lida da esquerda para a direita ou da
direita para a esquerda).

 Crie uma interface gráfica de usuário usando PyQt que permita ao usuário selecionar
uma imagem em seu computador e exibi-la na interface gráfica
Exemplo em código

Import tkinter as tk

Def verificar_paridade():

Numero = int(entrada_numero.get())

If numero % 2 == 0:

Mensagem.config(text=”O número é par.”)

Else:

Mensagem.config(text=”O número é ímpar.”)

Janela = tk.Tk()

Janela.title(“Verificador de paridade”)

Label_numero = tk.Label(janela, text=”Digite um número:”)

Label_numero.pack()

Entrada_numero = tk.Entry(janela)

Entrada_numero.pack()

Botao_verificar = tk.Button(janela, text=”Verificar”, command=verificar_paridade)

Botao_verificar.pack()

Mensagem = tk.Label(janela, text=””)

Mensagem.pack()

Janela.mainloop()
Nesse código, criamos uma janela com um rótulo, uma caixa de entrada, um botão e uma
mensagem. Quando o usuário clica no botão “Verificar”, a função verificar_paridade é
chamada, que verifica se o número inserido na caixa de entrada é par ou ímpar e atualiza a
mensagem de acordo.

Exemplo em PyQt para o exercício 2:

From PyQt5.QtWidgets import QApplication, QWidget, QLabel, QLineEdit, QPushButton,

QMessageBox

Def verificar_idade():

Nome = entrada_nome.text()

Idade = int(entrada_idade.text())

If idade >= 18:

Mensagem = “Parabéns, “ + nome + “! Você é maior de idade.”

Else:

Mensagem = “Desculpe, “ + nome + “. Você é menor de idade.”

QMessageBox.information(janela, “Resultado”, mensagem)

App = QApplication([])

Janela = QWidget()

Janela.setWindowTitle(“Verificador de idade”)

Label_nome = QLabel(“Nome:”, janela)

Label_nome.move(10, 10)

Entrada_nome = QLineEdit(janela)

Entrada_nome.move(70, 10)

Label_idade = QLabel(“Idade:”, janela)

Label_idade.move(10, 40)
Entrada_idade = QLineEdit(janela)

Entrada_idade.move(70, 40)

Botao_verificar = QPushButton(“Verificar”, janela)

Botao_verificar.move(10, 80)

Botao_verificar.clicked.connect(verificar_idade)

Janela.setGeometry(100, 100, 250, 120)

Janela.show()

App.exec_()

Exemplo em wxPython para o exercício 3:

Import wx

Class Janela(wx.Frame):

Def __init__(self, *args, **kwargs):

Super(Janela, self).__init__(*args, **kwargs)

Self.SetTitle(“Verificador de maior número”)

Panel = wx.Panel(self)

Vbox = wx.BoxSizer(wx.VERTICAL)

Hbox1 = wx.BoxSizer(wx.HORIZONTAL)

Label_numero1 = wx.StaticText(panel, label=”Digite o primeiro número:”)

Hbox1.Add(label_numero1, 1, wx.EXPAND | wx.ALL, 10)

Self.entrada_numero1 = wx.TextCtrl(panel)

Hbox1.Add(self.entrada_numero1, 2, wx.EXPAND | wx.ALL, 10)

Vbox.Add(hbox1, 1, wx.EXPAND | wx.ALL, 10)

Hbox2 = wx.BoxSizer(wx.HORIZONTAL)
 Label_numero2 = wx.StaticText(panel, label=”Digite o segundo número:”)

Hbox2.Add(label_numero2, 1, wx.EXPAND | wx.ALL, 10)

Self.entrada_numero2 = wx.TextCtrl(panel)

Hbox2.Add(self.entrada_numero2, 2, wx.EXPAND | wx.ALL, 10)

Vbox.Add(hbox2, 1, wx.EXPAND | wx.ALL, 10)

Hbox3 = wx.BoxSizer(wx.HORIZONTAL)

Botao_verificar = wx.Button(panel, label=”Verificar”)

Botao_verificar.Bind(wx.EVT_BUTTON, self.verificar_maior_numero)

Hbox3.Add(botao_verificar, 1, wx.EXPAND | wx.ALL, 10)

Vbox.Add(hbox3, 1, wx.EXPAND | wx.ALL, 10)

Self.mensagem = wx.StaticText(panel, label=””)

Vbox.Add(self.mensagem, 1, wx.EXPAND | wx.ALL, 10)

Panel.SetSizer(vbox)

Def verificar_maior_numero(self, event):

Numero1 = int(self.entrada_numero1.GetValue())

Numero2 = int(self.entrada_numero2.GetValue())

If numero1 > numero2:

Mensagem = “O primeiro número é maior.”

Elif numero2 > numero1:

Mensagem

 Próxima aula é sobre XML e JSON

XML (Extensible Markup Language) e JSON (JavaScript Object Notation) são formatos de dados
que são frequentemente usados para representar informações estruturadas em um formato
legível por máquina e por humanos. Em Python, existem bibliotecas nativas para lidar com
esses formatos de dados, a biblioteca xml para XML e a biblioteca json para JSON.

A biblioteca xml permite a leitura e escrita de dados XML em Python. Existem duas principais
classes na biblioteca xml: ElementTree e Element. O ElementTree é a classe de alto nível que
representa um documento XML inteiro, enquanto o Element representa um único nó dentro
do documento.

Aqui está um exemplo de como ler um arquivo XML usando a biblioteca xml em Python:

Import xml.etree.ElementTree as ET

Tree = ET.parse(‘exemplo.xml’)

Root = tree.getroot()

# Itera pelos filhos do elemento raiz

For child in root:

Print(child.tag, child.attrib)

# Acessa um elemento específico

Element = root.find(‘elemento’)

Print(element.tag, element.text)

A biblioteca json permite a leitura e escrita de dados JSON em Python. A biblioteca tem duas
principais funções: json.dumps() para codificar um objeto Python em uma string JSON e
json.loads() para decodificar uma string JSON em um objeto Python.

Aqui está um exemplo de como ler um arquivo JSON usando a biblioteca json em Python:

Import json

# Lê um arquivo JSON
With open(‘exemplo.json’, ‘r’) as f:

Data = json.load(f)

# Itera pelos objetos no JSON

For obj in data[‘objetos’]:

Print(obj[‘nome’], obj[‘valor’])

# Cria um objeto Python e codifica como JSON

Objeto = {‘nome’: ‘exemplo’, ‘valor’: 10}

Json_string = json.dumps(objeto)

Print(json_string)

Em resumo, as bibliotecas nativas xml e json em Python oferecem maneiras simples e

eficientes de manipular dados em formato XML e JSON. Essas bibliotecas são amplamente
utilizadas na indústria e podem ser usadas para uma variedade de casos de uso, desde a leitura
e escrita de arquivos de configuração até a integração com APIs da web.

Exemplo de leitura de arquivo XML:

Suponha que você tenha um arquivo XML chamado exemplo.xml com o seguinte conteúdo:

<pessoa>

<nome>João</nome>

<idade>30</idade>

<endereco>

<rua>Rua A</rua>

<cidade>Curitiba</cidade>

</endereco>

</pessoa>

Você pode ler esse arquivo usando a biblioteca xml.etree.ElementTree da seguinte maneira:
Import xml.etree.ElementTree as ET

Tree = ET.parse(‘exemplo.xml’)

Root = tree.getroot()

Nome = root.find(‘nome’).text

Idade = root.find(‘idade’).text

Rua = root.find(‘endereco/rua’).text

Cidade = root.find(‘endereco/cidade’).text

Print(f’Nome: {nome}’)

Print(f’Idade: {idade}’)

Print(f’Endereço: {rua}, {cidade}’)

Exemplo de escrita de arquivo XML:

Para escrever um arquivo XML em Python, você pode criar um objeto Element usando a
biblioteca xml.etree.ElementTree e, em seguida, usar o método ElementTree para salvar o
objeto em um arquivo. Aqui está um exemplo:

Import xml.etree.ElementTree as ET

Root = ET.Element(‘pessoas’)

Pessoa1 = ET.SubElement(root, ‘pessoa’)

Nome1 = ET.SubElement(pessoa1, ‘nome’)

Idade1 = ET.SubElement(pessoa1, ‘idade’)

Endereco1 = ET.SubElement(pessoa1, ‘endereco’)

Rua1 = ET.SubElement(endereco1, ‘rua’)

Cidade1 = ET.SubElement(endereco1, ‘cidade’)

Nome1.text = ‘João’

Idade1.text = ‘30’

Rua1.text = ‘Rua A’

Cidade1.text = ‘Curitiba’

Pessoa2 = ET.SubElement(root, ‘pessoa’)

Nome2 = ET.SubElement(pessoa2, ‘nome’)

Idade2 = ET.SubElement(pessoa2, ‘idade’)

Endereco2 = ET.SubElement(pessoa2, ‘endereco’)

Rua2 = ET.SubElement(endereco2, ‘rua’)

Cidade2 = ET.SubElement(endereco2, ‘cidade’)

Nome2.text = ‘Maria’

Idade2.text = ‘25’

Rua2.text = ‘Rua B’

Cidade2.text = ‘São Paulo’

Tree = ET.ElementTree(root)

Tree.write(‘pessoas.xml’)

Este código cria um arquivo XML chamado pessoas.xml com o seguinte conteúdo:

<pessoas>

<pessoa>

<nome>João</nome>

<idade>30</idade>

<endereco>

<rua>Rua A</rua>

<cidade>Curitiba</cidade>

</endereco>
 </pessoa>

<pessoa>

<nome>Maria</nome>

<idade>25</idade>

<endereco>

<rua>Rua B</rua>

<cidade>São Paulo</cidade>

</endereco>

</pessoa>

</pessoas>

Exemplo de leitura de arquivo JSON:

Suponha que você tenha um arquivo JSON chamado exemplo.json com o seguinte conteúdo:

“pessoa”: {

“nome”: “João”,

“idade”: 30,

Aqui vai um exemplo simples de como ler e escrever dados em formato JSON em Python
usando a biblioteca json:

Import json

# Criando um dicionário com dados a serem escritos em formato JSON

Dados = {

“nome”: “João”,
 “sobrenome”: “Silva”,

“idade”: 30,

“interesses”: [“programação”, “música”, “viagens”]

# Escrevendo os dados em um arquivo no formato JSON

With open(“dados.json”, “w”) as arquivo:

Json.dump(dados, arquivo)

# Lendo os dados de um arquivo no formato JSON

With open(“dados.json”, “r”) as arquivo:

Dados_lidos = json.load(arquivo)

# Imprimindo os dados lidos do arquivo

Print(dados_lidos)

Nesse exemplo, criamos um dicionário com alguns dados pessoais e interesses de uma pessoa,
e depois escrevemos esses dados em um arquivo no formato JSON usando o método
json.dump(). Depois, lemos os dados desse arquivo usando o método json.load() e imprimimos
esses dados na tela.

Esse é apenas um exemplo simples de como a biblioteca json pode ser usada em Python para
trabalhar com dados em formato JSON.

Exemplo :

Lendo dados de um arquivo XML:

Import xml.etree.ElementTree as ET

# Lendo um arquivo XML

Tree = ET.parse(‘dados.xml’)
Root = tree.getroot()

# Extraindo informações do arquivo XML

For child in root:

Print(child.tag, child.attrib)

For subchild in child:

Print(subchild.tag, subchild.attrib, subchild.text)

Criando um arquivo XML a partir de um dicionário em Python:

Import xml.etree.ElementTree as ET

# Criando um dicionário com dados a serem escritos em formato XML

Dados = {

“nome”: “João”,

“sobrenome”: “Silva”,

“idade”: 30,

“interesses”: [“programação”, “música”, “viagens”]

# Criando um novo elemento XML com base no dicionário

Root = ET.Element(“pessoa”)

For key, value in dados.items():

If isinstance(value, list):

For item in value:

Subelement = ET.SubElement(root, key)

Subelement.text = str(item)

Else:

Subelement = ET.SubElement(root, key)

Subelement.text = str(value)
# Escrevendo os dados em um arquivo no formato XML

Tree = ET.ElementTree(root)

Tree.write(“dados.xml”)

Lendo dados de um arquivo JSON:

Import json

# Lendo um arquivo JSON

With open(‘dados.json’) as f:

Dados = json.load(f)

# Extraindo informações do arquivo JSON

Print(dados[‘nome’])

Print(dados[‘idade’])

Print(dados[‘interesses’])

Escrevendo dados em um arquivo JSON:

Import json

# Criando um dicionário com dados a serem escritos em formato JSON

Dados = {

“nome”: “João”,

“sobrenome”: “Silva”,

“idade”: 30,

“interesses”: [“programação”, “música”, “viagens”]

# Escrevendo os dados em um arquivo no formato JSON

With open(‘dados.json’, ‘w’) as f:

 Json.dump(dados, f)

Espero que esses exemplos possam ajudar a entender melhor como trabalhar com XML e JSON
em Python!

Exercício

 Escreva um programa que leia um arquivo XML e imprima na tela todos os valores dos
elementos com a tag “nome”.
 Escreva uma função que receba uma lista de dicionários e salve esses dicionários em
um arquivo JSON.
 Escreva um programa que leia um arquivo JSON e imprima na tela o valor da chave
“idade” para cada objeto no arquivo.
 Escreva uma função que receba um dicionário e retorne uma string com a
representação XML desse dicionário.
 Escreva um programa que leia um arquivo XML e salve as informações em um arquivo
JSON.

Exemplo em código dos exercícios

Exercício – Ler um arquivo XML e imprimir na tela todos os valores dos elementos com a tag
“nome”:

Import xml.etree.ElementTree as ET

# Lê o arquivo XML

Tree = ET.parse(‘exemplo.xml’)

Root = tree.getroot()

# Encontra todos os elementos com a tag “nome” e imprime os seus valores

For elem in root.iter(‘nome’):

Print(elem.text)

Exercício – Criar um arquivo JSON com informações sobre pessoas e salvá-lo em disco:
Import json

# Cria um dicionário com informações sobre pessoas

Pessoas = [

{‘nome’: ‘João’, ‘idade’: 30, ‘cidade’: ‘São Paulo’},

{‘nome’: ‘Maria’, ‘idade’: 25, ‘cidade’: ‘Rio de Janeiro’},

{‘nome’: ‘Pedro’, ‘idade’: 40, ‘cidade’: ‘Belo Horizonte’}

# Salva o dicionário como um arquivo JSON

With open(‘pessoas.json’, ‘w’) as f:

Json.dump(pessoas, f, indent=4)

Exercício – Ler um arquivo JSON e imprimir na tela todas as informações sobre as pessoas:

Import json

# Lê o arquivo JSON

With open(‘pessoas.json’, ‘r’) as f:

Pessoas = json.load(f)

# Imprime as informações sobre as pessoas

For p in pessoas:

Print(‘Nome:’, p[‘nome’])

Print(‘Idade:’, p[‘idade’])

Print(‘Cidade:’, p[‘cidade’])

Print()

Exercício – Converter um dicionário em um objeto JSON e imprimir na tela:

Import json

# Cria um dicionário com informações sobre uma pessoa

Pessoa = {‘nome’: ‘João’, ‘idade’: 30, ‘cidade’: ‘São Paulo’}

# Converte o dicionário em um objeto JSON e imprime na tela

Json_string = json.dumps(pessoa, indent=4)

Print(json_string)

Exercício – Converter um objeto JSON em um dicionário e imprimir na tela:

Copy code

Import json

# Cria uma string JSON com informações sobre uma pessoa

Json_string = ‘{“nome”: “João”, “idade”: 30, “cidade”: “São Paulo”}’

# Converte a string JSON em um dicionário e imprime na tela

Pessoa = json.loads(json_string)

Print(pessoa)

Outro exercício :

 Escreva uma função que receba uma lista de números inteiros como parâmetro e
retorne o menor valor da lista.

 Escreva uma função que receba uma lista de palavras como parâmetro e retorne uma
nova lista contendo apenas as palavras que possuem mais de 5 caracteres.
  Escreva um programa que leia um arquivo de texto e conte o número de ocorrências
de cada palavra no arquivo.

 Escreva uma função que receba um número inteiro como parâmetro e retorne uma
lista contendo todos os divisores desse número.

 Escreva um programa que receba um arquivo de texto contendo uma lista de números
inteiros separados por vírgula e calcule a média desses números.

 Escreva uma função que receba uma lista de números inteiros como parâmetro e
retorne uma nova lista contendo apenas os números pares da lista original.

 Escreva um programa que leia um arquivo de texto contendo uma lista de nomes e
sobrenomes e gere um novo arquivo contendo apenas os sobrenomes em ordem
alfabética.

 Escreva uma função que receba uma lista de números inteiros como parâmetro e
retorne a soma de todos os números da lista.

 Escreva um programa que leia um arquivo de texto contendo uma lista de nomes e
idades e exiba a média de idade dos nomes que começam com a letra ‘A’.

 Escreva uma função que receba uma lista de números inteiros como parâmetro e
retorne uma nova lista contendo apenas os números ímpares da lista original.

Exemplo em código dos exercícios

Exercício : Faça um programa que leia um arquivo XML e imprima o conteúdo na tela.

Import xml.etree.ElementTree as ET

# Lendo o arquivo XML

Tree = ET.parse(‘arquivo.xml’)

Root = tree.getroot()

# Imprimindo o conteúdo na tela

For child in root:

Print(child.tag, child.attrib)

Exercício : Faça um programa que crie um arquivo XML a partir de dados fornecidos pelo
usuário.

Import xml.etree.ElementTree as ET

# Criando a estrutura do XML

Root = ET.Element(‘root’)

Doc = ET.SubElement(root, ‘doc’)

# Adicionando dados ao XML

ET.SubElement(doc, ‘field1’, name=’foo’).text = ‘bar’

ET.SubElement(doc, ‘field2’, name=’spam’).text = ‘eggs’

# Salvando o XML em um arquivo

Tree = ET.ElementTree(root)

Tree.write(‘arquivo.xml’)

Exercício : Faça um programa que leia um arquivo JSON e imprima o conteúdo na tela.

# Lendo o arquivo JSON

With open(‘arquivo.json’, ‘r’) as f:

 Data = json.load(f)

# Imprimindo o conteúdo na tela

For key, value in data.items():

Print(key, value)

Exercício : Faça um programa que crie um arquivo JSON a partir de dados fornecidos pelo
usuário.

# Coletando dados do usuário

Nome = input(‘Digite seu nome: ‘)

Idade = int(input(‘Digite sua idade: ‘))

Endereco = input(‘Digite seu endereço: ‘)

# Criando dicionário com os dados coletados

Dados = {‘nome’: nome, ‘idade’: idade, ‘endereco’: endereco}

# Salvando o dicionário em um arquivo JSON

With open(‘arquivo.json’, ‘w’) as f:

Json.dump(dados, f)

Exercício : Faça um programa que leia um arquivo XML e converta para JSON.

Import xml.etree.ElementTree as ET

Import json

# Lendo o arquivo XML

Tree = ET.parse(‘arquivo.xml’)
Root = tree.getroot()

# Convertendo para JSON

Data = {}

For child in root:

Data[child.tag] = child.text

Json_data = json.dumps(data)

# Imprimindo o JSON na tela

Print(json_data)

Exercício : Faça um programa que leia um arquivo JSON e converta para XML.

Import xml.etree.ElementTree as ET

# Lendo o arquivo JSON

With open(‘arquivo.json’, ‘r’) as f:

Data = json.load(f)

# Convertendo para XML

Root = ET.Element(‘root’)

For key, value in data.items():

Child = ET.SubElement(root, key)

Child.text = str(value)

Xml_data = ET.tostring(root)

# Salvando o XML em um arquivo

With open(‘arquivo.xml’, ‘wb’) as f:

f.write(xml_data)
Exercício : Faça um programa que leia um arquivo JSON e salve apenas os valores únicos em
um novo arquivo JSON.

Import json

# Lendo o arquivo JSON

With open(‘arquivo.json’, ‘r’) as f:

Data = json.load(f)

# Criando uma lista para armazenar os valores únicos

Unique_values = []

# Iterando sobre cada item do arquivo JSON e adicionando apenas valores únicos na lista

For item in data:

If item not in unique_values:

Unique_values.append(item)

# Salvando apenas os valores únicos em um novo arquivo JSON

With open(‘arquivo_unico.json’, ‘w’) as f:

Json.dump(unique_values, f)

Exemplo

Def soma_lista(lista):

Soma = 0

For num in lista:

Soma += num

Return soma

Lista_numeros = [1, 2, 3, 4, 5]

Print(soma_lista(lista_numeros)) # Saída: 15
Exemplo

Supondo que o arquivo pessoas.txt tenha o seguinte conteúdo:

Ana,20

Bruno,25

Arthur,18

Alice,23

Podemos utilizar o seguinte código para calcular a média de idade das pessoas cujos nomes
começam com a letra ‘A’:

Soma_idades = 0

Contagem = 0

With open(‘pessoas.txt’, ‘r’) as arquivo:

For linha in arquivo:

Nome, idade = linha.strip().split(‘,’)

If nome[0] == ‘A’:

Soma_idades += int(idade)

Contagem += 1

If contagem > 0:

Media_idades = soma_idades / contagem

Print(f”A média de idade das pessoas cujos nomes começam com ‘A’ é {media_idades:.2f}”)

Else:

Print(“Não há pessoas cujos nomes começam com ‘A’”)

Saída: A média de idade das pessoas cujos nomes começam com ‘A’ é 20.50

Exemplo

Def numeros_impares(lista):

Impares = []

For num in lista:

If num % 2 != 0:

Impares.append(num)

Return impares

Lista_numeros = [1, 2, 3, 4, 5]

Print(numeros_impares(lista_numeros)) # Saída: [1, 3, 5]

Agora iremos pra Última aula de python

Sobre

Testes de unidade:

Os testes de unidade são uma parte essencial da programação em Python, pois ajudam a
garantir que o código que você escreveu funcione corretamente e atenda aos requisitos
especificados. A biblioteca padrão do Python, unittest, é uma ótima ferramenta para escrever
e executar testes de unidade.

A seguir, descrevemos alguns conceitos importantes e como usar a biblioteca unittest para
escrever testes de unidade em Python.

Conceitos importantes

Antes de começarmos a escrever testes de unidade em Python, é importante entender alguns

conceitos importantes:
  Teste de unidade: um teste de unidade é uma peça de código que testa uma pequena
parte do seu programa, como uma função ou método. O objetivo de um teste de
unidade é verificar se a função ou método está funcionando corretamente.

Explicações :

Teste de unidade é uma prática de programação que envolve escrever testes automatizados
para pequenas partes do código, geralmente funções ou métodos. O objetivo é garantir que
cada parte do código funcione corretamente isoladamente, antes de integrá-las em um
sistema completo.

Em Python, a biblioteca padrão unittest é comumente usada para escrever testes de unidade.
Os testes são escritos em uma classe que herda de unittest.TestCase e são definidos como
métodos que começam com test_. Cada método de teste executa uma ou mais asserções, que
verificam se a saída da função ou método testado é igual ao resultado esperado.

Os testes de unidade permitem que os desenvolvedores encontrem e corrijam erros mais

facilmente, evitando que eles sejam propagados por todo o sistema. Eles também tornam mais
fácil realizar alterações no código, pois permitem que o desenvolvedor teste rapidamente se as
mudanças afetaram outras partes do sistema.

Além disso, os testes de unidade podem ser executados automaticamente a cada alteração de
código, permitindo que os desenvolvedores identifiquem e corrijam problemas rapidamente.
Eles também são úteis para documentar o comportamento esperado de uma função ou
método, tornando mais fácil para outros desenvolvedores entender como usar o código.

Exemplo em código

Aqui está um exemplo básico de como escrever testes de unidade usando a biblioteca unittest
do Python:

Suponha que temos uma função soma que recebe dois números como argumentos e retorna a
soma deles:

Def soma(a, b):

Return a + b
Para testar essa função, podemos escrever uma classe de teste com métodos que verificam se
a saída da função soma é o resultado esperado para diferentes entradas. Por exemplo:

Class TestSoma(unittest.TestCase):

Def test_soma_positivos(self):

Self.assertEqual(soma(2, 3), 5)

Def test_soma_negativos(self):

Self.assertEqual(soma(-2, -3), -5)

Def test_soma_positivo_negativo(self):

Self.assertEqual(soma(2, -3), -1)

Neste exemplo, estamos testando a função soma com três cenários diferentes:

Teste de soma com números positivos: espera-se que a soma de 2 e 3 seja igual a 5.

Teste de soma com números negativos: espera-se que a soma de -2 e -3 seja igual a -5.

Teste de soma com um número positivo e outro negativo: espera-se que a soma de 2 e -3 seja
igual a -1.

Aqui, estamos usando o método assertEqual da classe unittest.TestCase para verificar se a

saída da função soma é igual ao resultado esperado para cada teste.

Para executar esses testes, basta chamar a função unittest.main():

Python

Copy code

If __name__ == ‘__main__’:

Unittest.main()
Quando executamos este arquivo, a saída deve ser algo como:

...

Ran 3 tests in 0.000s

OK

Isso significa que todos os testes passaram com sucesso. Se algum teste falhar, o relatório de
teste indicará qual teste falhou e qual era o resultado esperado.

 Caso de teste: um caso de teste é uma coleção de testes de unidade que testam uma
funcionalidade específica do seu programa.

Explicações

Um caso de teste é um conjunto de condições e/ou variáveis de entrada para testar uma
determinada funcionalidade do software. É uma etapa importante do processo de teste de
software, pois ajuda a garantir que o software esteja funcionando corretamente antes de ser
entregue aos usuários finais.

Um caso de teste consiste em uma descrição do que será testado, as condições de entrada e
saída esperadas e os passos necessários para executar o teste. Os casos de teste devem ser
criados de acordo com os requisitos do software e devem cobrir todas as funcionalidades e
cenários possíveis.

Os casos de teste são geralmente escritos em um documento de especificação de teste ou em

um sistema de gerenciamento de casos de teste. Eles são executados durante o processo de
teste de software para garantir que o software esteja funcionando corretamente e que todos
os requisitos foram atendidos.

Em Python, a biblioteca unittest é frequentemente usada para escrever casos de teste. Com
ela, é possível criar testes de unidade para funções e classes, bem como testes de integração
para verificar se as diferentes partes do software funcionam corretamente juntas.

Exemplo em código :
Aqui está um exemplo simples de como criar um caso de teste usando a biblioteca unittest em
Python:

Class TestStringMethods(unittest.TestCase):

Def test_upper(self):

Self.assertEqual(‘hello’.upper(), ‘HELLO’)

Def test_isupper(self):

Self.assertTrue(‘HELLO’.isupper())

Self.assertFalse(‘Hello’.isupper())

Def test_split(self):

S = ‘hello world’

Self.assertEqual(s.split(), [‘hello’, ‘world’])

# verifique se s.split falhará se o separador for diferente de ‘ ‘

With self.assertRaises(TypeError):

s.split(2)

if __name__ == ‘__main__’:

unittest.main()

Neste exemplo, estamos criando uma classe TestStringMethods que herda da classe
unittest.TestCase. Dentro dessa classe, estamos definindo três métodos de teste diferentes:
test_upper(), test_isupper() e test_split().

Cada um desses métodos de teste contém um ou mais testes, que usam os métodos assert da
classe TestCase para verificar se uma determinada condição é verdadeira ou não. Por exemplo,
no método test_upper(), estamos verificando se a chamada de upper() no objeto string ‘hello’
retorna a string ‘HELLO’.
Para executar esses testes, chamamos o método unittest.main(), que descobre todos os casos
de teste na classe e os executa automaticamente. Se um teste falhar, o método assert lançará
uma exceção, o que fará com que o teste seja marcado como falho.

Esse é apenas um exemplo básico, mas a biblioteca unittest tem muitos recursos poderosos
que permitem criar casos de teste complexos e abrangentes para seus programas em Python.

 Asserção: uma asserção é uma declaração que verifica se uma condição é verdadeira.
Se a condição for falsa, a asserção falhará.

Explicações :

As asserções são usadas em testes unitários para verificar se o comportamento de um

determinado trecho de código está de acordo com o esperado. Uma asserção é uma
declaração que deve ser verdadeira em um ponto específico do programa. Se uma asserção
falhar, isso significa que há um erro no código.

Em Python, a biblioteca de testes unitários “unittest” fornece várias funções de asserção que
podem ser usadas em testes unitários. Essas funções testam diferentes condições e retornam
True ou False dependendo se a condição é verdadeira ou falsa.

Alguns exemplos de funções de asserção comuns incluem:

 assertEqual(a, b): verifica se a e b são iguais

 assertTrue(x): verifica se x é True
 assertFalse(x): verifica se x é False
 assertIn(a, b): verifica se a está contido em b
 assertNotIn(a, b): verifica se a não está contido em b

Essas funções de asserção podem ser usadas para testar diferentes partes do código e garantir
que ele está funcionando corretamente.

Segue um exemplo de código que utiliza asserções em testes unitários:

Def somar(a, b):

 Return a + b

Class TesteSoma(unittest.TestCase):

Def test_soma_positivos(self):

Self.assertEqual(somar(2, 3), 5)

Def test_soma_negativos(self):

Self.assertEqual(somar(-2, -3), -5)

Def test_soma_zero(self):

Self.assertEqual(somar(0, 0), 0)

Def test_soma_positivo_negativo(self):

Self.assertEqual(somar(2, -3), -1)

If __name__ == ‘__main__’:

Unittest.main()

Nesse exemplo, temos uma função somar(a, b) que recebe dois números inteiros e retorna a
soma deles. Em seguida, temos uma classe TesteSoma que herda de unittest.TestCase e
contém quatro métodos que testam diferentes cenários da função somar(). Em cada um
desses métodos, utilizamos uma função de asserção (assertEqual()) para verificar se o
resultado da soma está correto.

Ao executar o programa, a biblioteca “unittest” executará automaticamente todos os métodos

que começam com o prefixo “test_”, permitindo que possamos testar a função somar() e
garantir que ela está funcionando corretamente.

Exemplo em código

Def test_addition():

Assert 2 + 2 == 4
 Assert 1 + 1 == 3

Assert 0 + 1 == 1

Nesse exemplo, temos uma função de teste chamada test_addition, que contém três
asserções diferentes. Cada asserção verifica uma operação de adição diferente e verifica se o
resultado é igual ao valor esperado.

Se todas as asserções passarem, o teste será considerado bem-sucedido. Caso contrário, a

execução do teste falhará e uma mensagem de erro será exibida para indicar qual asserção
falhou e o valor real que foi obtido.

As asserções são uma parte importante dos testes de unidade em Python, pois permitem que
você verifique se o código está funcionando conforme o esperado e ajuda a garantir a
qualidade do software que você está desenvolvendo.

Como usar a biblioteca unittest

A biblioteca unittest fornece uma estrutura para escrever e executar testes de unidade em
Python. Aqui está um exemplo simples de como escrever e executar um teste de unidade
usando unittest:

Import unittest

Def soma(a, b):

Return a + b

Class TesteSoma(unittest.TestCase):

Def test_soma(self):

Self.assertEqual(soma(2, 3), 5)

Self.assertEqual(soma(0, 0), 0)

Self.assertEqual(soma(-2, 3), 1)
Neste exemplo, a função soma é definida e, em seguida, é criada uma classe de teste
TesteSoma que herda da classe unittest.TestCase. O método test_soma é definido dentro da
classe e contém três asserções que verificam se a função soma está funcionando
corretamente.

Para executar este teste, basta chamar a função unittest.main():

If Este có__name__ == ‘__main__’:

Unittest.main()

digo verifica se o módulo está sendo executado como um programa principal e, se sim, chama
a função unittest.main(), que procura por todas as classes de teste no módulo e executa todos
os métodos de teste dentro dessas classes.

Estrutura de um caso de teste

Um caso de teste é uma classe que contém vários métodos de teste. Cada método de teste é
responsável por testar uma funcionalidade específica do seu programa. Aqui está um exemplo
de como estruturar um caso de teste:

Class MeuCasoDeTeste(unittest.TestCase):

Def setUp(self):

# Configuração inicial do caso de teste

Pass

Def tearDown(self):

# Limpeza após cada teste

Pass

Def test_algo(self):

# Teste da funcionalidade “algo”

Pass
 Def test_outra_coisa(self):

# Teste da funcionalidade “outra coisa”

Pass

O método setUp é chamado antes de cada teste e é usado para configurar as condições iniciais
para o teste. O método tearDown é chamado após cada

Exercício de Teste de unidade:

 Escreva um teste de unidade para a função soma(a, b) que deve receber dois
parâmetros e retornar a soma deles.

 Escreva um teste de unidade para a função maior_numero(lista) que deve receber

uma lista de números e retornar o maior deles.

 Escreva um teste de unidade para a função verifica_primo(n) que deve receber um

número inteiro e retornar True se o número for primo e False caso contrário.

 Escreva um teste de unidade para a função calcula_media(numeros) que deve receber

uma lista de números e retornar a média aritmética deles.

 Escreva um teste de unidade para a função remove_vogais(palavra) que deve receber

uma palavra como parâmetro e retornar a palavra sem as vogais

Exemplo em código

Import unittest

# A função a ser testada, que verifica se um número é par ou ímpar

Def is_even(number):

Return number % 2 == 0

# Classe de teste
Class TestIsEven(unittest.TestCase):

# Teste que verifica se o número 2 é par

Def test_even_number(self):

Self.assertTrue(is_even(2))

# Teste que verifica se o número 3 é ímpar

Def test_odd_number(self):

Self.assertFalse(is_even(3))

# Teste que verifica se a função retorna False para um string

Def test_string_input(self):

Self.assertFalse(is_even(“string”))

# Teste que verifica se a função retorna False para uma lista

Def test_list_input(self):

Self.assertFalse(is_even([1, 2, 3]))

If __name__ == ‘__main__’:

Unittest.main()

Neste exemplo, a função is_even é testada em quatro casos diferentes usando a classe
unittest.TestCase. Cada método começa com o prefixo test_ para indicar que é um teste de
unidade.

A função assertTrue é usada para verificar se a expressão booleana é True, enquanto

assertFalse é usada para verificar se a expressão é False.

O método main() da classe unittest é usado para executar os testes. Se todos os testes
passarem, a saída deve ser:

Ran 4 tests in 0.000s

OK

Outro exercício :

 Escreva um teste de unidade para uma função calcula_media(numeros: List[float]) ->

float que calcula a média de uma lista de números.

 Escreva um teste de unidade para uma função encontra_palavra(arquivo: str, palavra:

str) -> bool que verifica se uma palavra está presente em um arquivo de texto.

 Escreva um teste de unidade para uma função verifica_primo(n: int) -> bool que
verifica se um número inteiro é primo.

 Escreva um teste de unidade para uma classe Pessoa com atributos nome e idade e
um método cumprimentar() que retorna uma saudação com o nome da pessoa.

 Escreva um teste de unidade para uma função inverte_string(s: str) -> str que inverte
uma string.

Exemplo em código

Exercício – Escreva um teste de unidade para a função soma(x, y), que retorna a soma de dois
números:

Def soma(x, y):

Return x + y

Class TestSoma(unittest.TestCase):
 Def test_soma_positivos(self):

Self.assertEqual(soma(2, 3), 5)

Def test_soma_negativos(self):

Self.assertEqual(soma(-2, -3), -5)

Def test_soma_positivo_negativo(self):

Self.assertEqual(soma(2, -3), -1)

If __name__ == ‘__main__’:

Unittest.main()

Exercício – Escreva um teste de unidade para a função eh_par(x), que retorna True se um
número é par e False caso contrário:

Def eh_par(x):

If x % 2 == 0:

Return True

Else:

Return False

Class TestEhPar(unittest.TestCase):

Def test_par(self):

Self.assertTrue(eh_par(4))

Def test_impar(self):

Self.assertFalse(eh_par(5))

If __name__ == ‘__main__’:
 Unittest.main()

Exercício – Escreva um teste de unidade para a função remove_duplicados(lista), que remove

elementos duplicados de uma lista:

Def remove_duplicados(lista):

Nova_lista = []

For elemento in lista:

If elemento not in nova_lista:

Nova_lista.append(elemento)

Return nova_lista

Class TestRemoveDuplicados(unittest.TestCase):

Def test_sem_duplicados(self):

Self.assertEqual(remove_duplicados([1, 2, 3]), [1, 2, 3])

Def test_com_duplicados(self):

Self.assertEqual(remove_duplicados([1, 2, 2, 3, 3, 3]), [1, 2, 3])

If __name__ == ‘__main__’:

Unittest.main()

Exercício – Escreva um teste de unidade para a função media(lista), que retorna a média de
uma lista de números:

Def media(lista):

Soma = sum(lista)

Return soma / len(lista)

Class TestMedia(unittest.TestCase):

Def test_media_inteiros(self):

Self.assertEqual(media([1, 2, 3]), 2)

Def test_media_floats(self):

Self.assertAlmostEqual(media([1.5, 2.5, 3.5]), 2.5, places=2)

If __name__ == ‘__main__’:

Unittest.main()

Exercício – Escreva um teste de unidade para a função inverte_string(s), que inverte uma
string:

Def inverte_string(s):

Return s[::-1]

Class TestInverteString(unittest.TestCase):

Def test_string_vazia(self):

Self.assertEqual(inverte_string(‘’), ‘’)

Def test_string_um_caractere(self):

Self.assertEqual(inverte_string(‘a’), ‘a’)

Def test_string_mais_caracteres(self):

Self.assertEqual(inverte_string(‘abcde’), ‘edcba’)

If __name__ == ‘__main__’:

Unittest.main()
 Esperamos que este livro tenha sido útil em sua jornada de aprendizado em Python.
Lembre-se de que a programação é uma habilidade que se desenvolve com a prática, então
continue praticando e experimentando. Não tenha medo de cometer erros, pois é através
deles que você aprende e evolui. O Python é uma linguagem poderosa e versátil, utilizada em
diversas áreas, desde ciência de dados até desenvolvimento web. Continue explorando suas
possibilidades e desfrute do mundo da programação em Python.”