Linguagem de

Programação Python

Vanilton da Thálita 💍
Pai do Louie 👦🏻 e Lourenzo 👶🏻
Cientista da Computação 🤓
🎓 Especialista em Engenharia de Software e Gestão de Pessoas
👨🏻‍💻Pessoas e Processos na @fpf.tech 😃
👨🏻‍🏫 Professor na @fpftech.educacional

APRESENTAÇÃO

QUEM SÃO VOCÊS?

Nome, profissão ou ocupação e sua expertise em informática.
Uma expectativa para disciplina

ACORDOS DE TIME

1

Introdução aos conceitos de linguagem de programação

2

Python

Definição

Ranking de Linguagens de Programação.
Porque usar Python?
Quem usa Python?
Aplicabilidade da linguagem Python
Instalação e configuração do ambiente
Gerenciador de pacote PIP
Virtual Environment

3

Tipos Básicos, Operadores e Variáveis

4

Estrutura de controle de fluxo

5

Listas, Tuplas e Dicionários

AGENDA

6

Funções

7

Arquivos

8

Orientação a Objetos

Classes

Objetos

Atributos

Métodos

Herança

Módulos

9

Importações

10

Exceções

AGENDA

11

Outros Pacotes Python

AGENDA

O que é uma linguagem de programação?

Comando em Português para Python

# Mostre a mensagem "Olá, mundo!"
print("Olá, mundo!")

Cite um comando em português.

# Guarde o nome "Ana" em uma variável
nome = "Ana"

# Some 2 com 3 e guarde o resultado
resultado = 2 + 3

# Se a idade for maior ou igual a 18, diga "Pode votar"
if idade >= 18:
    print("Pode votar")

# Repita de 0 até 4 e mostre o número
for i in range(5):
    print(i)

TIPOS DE LINGUAGEM

Definições

write()

exit()

data()

Linguagem de máquina

Linguagem de montagem

LINGUAGEM COMPILADA

O código-fonte é traduzido de uma só vez para linguagem de máquina por um compilador.
O resultado é um arquivo executável independente (.exe, .out, etc.).
Exemplos: C, C++, Go, Rust

LINGUAGEM COMPILADA X INTERPRETADA

package main

import "fmt"

func main() {
    fmt.Println("Olá, mundo!")
}

go build main.go     
./main

main.exe

print("Olá, mundo!")

python programa.py

“Enquanto o Python precisa estar instalado em qualquer máquina que vá rodar seu script, com Go você pode compilar e enviar só o executável.”

LINGUAGEM COMPILADA X INTERPRETADA

Característica	Compilada	Interpretada
Tradução	Todo o código de uma vez	Linha por linha
Velocidade de execução	Mais rápida	Pode ser mais lenta
Portabilidade	Menos portável	Mais portável
Detecção de erros	Antes da execução (em tempo de compilação)	Durante a execução (em tempo real)
Gera arquivo executável?	Sim	Não
Exemplo de linguagem	C, C++, Rust, GO	Python, JavaScript

LINGUAGEM INTERPRETADA X COMPILADA - PARA FIXAR

"Linguagens compiladas são como traduzir um livro inteiro antes de ler. Já as interpretadas são como ter um tradutor lendo e traduzindo cada frase em tempo real."

RANKING DE LINGUAGENS DE PROGRAMAÇÃO

Python

Domínio em IA e Ciência de Dados: Bibliotecas como TensorFlow e Pandas consolidam sua posição.
Sintaxe Amigável: Atraente para iniciantes e poderosa para tarefas complexas.
Apoio Corporativo: Empresas como Google e Amazon investem fortemente.

RANKING DE LINGUAGENS DE PROGRAMAÇÃO

TypeScript

Superset do JavaScript: Oferece tipagem estática, melhorando a qualidade e manutenção do código.
Adoção Empresarial: Utilizado por empresas como Microsoft e Slack.

RANKING DE LINGUAGENS DE PROGRAMAÇÃO

C++

Desempenho em Aplicações Críticas: Preferido para motores de jogos, sistemas operacionais e sistemas embarcados devido ao controle preciso dos recursos do sistema.

RANKING DE LINGUAGENS DE PROGRAMAÇÃO

Em crescimento, especialmente em infraestrutura, back-end e cloud computing.
Adotado por empresas como Google, Uber, Dropbox, Kubernetes e Docker.
Go tem como objetivo substituir linguagens como C/C++ em sistemas distribuídos e escaláveis com foco em simplicidade, desempenho e concorrência.

Dito isso iremos trabalhar com...

DEFINIÇÃO

Python é uma linguagem de programação de alto nível, interpretada de script, imperativa, orientada a objetos, funcional, de tipagem dinâmica e forte. Foi lançada por Guido van Rossum em 1991.

DEFINIÇÃO

É reconhecida por ser muito versátil, com ênfase na legibilidade do código, e por ter uma abordagem que permite aos programadores desenvolverem algoritmos melhor estruturados. Ela é orientada por uma lista de 19 princípios chamada de “The Zen of Python”

DEFINIÇÃO

PORQUE USAR PYTHON?

Facilidade
Aumento de produtividade
Comunidade ampla e popularidade
Utilização Versátil
Inteligência Artificial
Programação Web
Gerenciamento de Big Data
Computação Gráfica
Automação
Mercado Amplo
Bons Salários

QUEM USA PYTHON?

Instagram: Utiliza Django como backend
Google: Grande parte do algoritmo de busca é escrito em python
Spotify: O Aplicativo é construído em Python
Netflix: Utiliza diversas bibliotecas em Python em serviços
Uber: Boa parte do aplicativo é feito com Python

QUEM USA PYTHON?

Dropbox: contratou o criador da linguagem Guido van Rossum
Pinterest: utiliza Python e Django
FPFtech: Em grande parte das aplicações web com o uso do framework Django e em alguns interfaces que rodam na linha de produção com uso do PyQT.

APLICABILIDADE DA LINGUAGEM PYTHON

Aplicações Web

Aplicações Desktop

Embarcado

Análise de Dados e Aprendizado de máquina

INSTALAÇÃO E CONFIGURAÇÃO DO AMBIENTE

Download do interpretador

INSTALAÇÃO E CONFIGURAÇÃO DO AMBIENTE

Instalação Python

INSTALAÇÃO E CONFIGURAÇÃO DO AMBIENTE

Esqueci de marcar a opção para adicionar a variável de ambiente no path. O que fazer?
Abra o Explorer do Windows clique o botão direito na opção Este Computador e siga pra Propriedades.

INSTALAÇÃO E CONFIGURAÇÃO DO AMBIENTE

Clique na opção Configurações avançadas do sistema.

INSTALAÇÃO E CONFIGURAÇÃO DO AMBIENTE

Clique na opção Variáveis de Ambiente.

INSTALAÇÃO E CONFIGURAÇÃO DO AMBIENTE

Edite a variável Path

INSTALAÇÃO E CONFIGURAÇÃO DO AMBIENTE

Adicione os caminhos da instalação do Python.
Raiz e \Scripts

INSTALAÇÃO E CONFIGURAÇÃO DO AMBIENTE

Abra o prompt de comando para confirmar a instalação e configuração do Python.

INSTALAÇÃO E CONFIGURAÇÃO DO AMBIENTE

Instalação IDE PyCharm

GERENCIADOR DE PACOTE PIP

Pip é um sistema de gerenciamento de pacotes padrão usado para instalar e gerenciar pacotes de software escritos em Python.
Muitos pacotes podem ser encontrados na fonte padrão para pacotes e suas dependências - Python Package Index.

GERENCIADOR DE PACOTE PIP

INSTALANDO UM PACOTE PIP

pip install ipython

A biblioteca IPython (Interactive Python) é uma ferramenta poderosa para desenvolvimento interativo, muito utilizada por quem trabalha com análise de dados, ciência, automação e ensino de programação.

VERIFICANDO PACOTES PIP INSTALADOS

pip list

ATUALIZANDO PIP

COMPARTILHANDO BIBLIOTECAS

Em um ambiente distribuído quando outros colegas precisarem instalar a mesma versão de bibliotecas precisamos compartilhar estas bibliotecas, e para isso criamos um arquivo que cria essas referências.

INSTALANDO BIBLIOTECAS COM REQUIREMENTS

Instalando biblioteca a partir de um arquivo que já contêm as bibliotecas com suas respectivas versões.

VIRTUAL ENVIRONMENT (AMBIENTE VIRTUAL)

Um ambiente virtual empacota todas as dependências que um projeto precisa e armazena em um diretório.

INSTALAÇÃO E CONFIGURAÇÃO DO AMBIENTE

CRIANDO VIRTUAL ENVIRONMENT - MANUALMENTE

Criando um ambiente virtual Python

Ativando um ambiente virtual Python

Saindo de um ambiente virtual Python

nome_do_ambiente

CRIANDO VIRTUAL ENVIRONMENT - IDE

Também podemos criar o ambiente virtual diretamente pelo PyCharm.
O ideal é que você escolha uma pasta em seu sistema operacional, onde você deseja criar os ambientes virtuais.

CRIANDO VIRTUAL ENVIRONMENT - IDE

Ao criar um projeto no PyCharm é possível que na mesma hora você já faça a criação do ambiente virtual.

TIPOS BÁSICOS

# Inteiro
numero = 10
print(numero, type(numero)) # Output: 10 <class 'int'>

# Float
pi = 3.14159
print(pi, type(pi)) # Output: 3.14159 <class 'float'>

# String
nome = "Python"
print(nome, type(nome)) # Output: Python <class 'str'>

# Booleano
verdadeiro = True
print(verdadeiro, type(verdadeiro)) # Output: <class 'bool'>

TIPOS BÁSICOS - TYPE HINT

# Inteiro com type hint
numero: int = 10
print(numero, type(numero)) # Output: 10 <class 'int'>

# Float com type hint
pi: float = 3.14159
print(pi, type(pi)) # Output: 3.14159 <class 'float'>

# String com type hint
nome: str = "Python"
print(nome, type(nome)) # Output: Python <class 'str'>

# Booleano com type hint
verdadeiro: bool = True
print(verdadeiro, type(verdadeiro)) # Output: <class 'bool'>

Os type hints, ou “dicas de tipo”, foram introduzidos em Python para permitir que os desenvolvedores indiquem explicitamente os tipos de dados das variáveis e dos retornos de funções.

COMANDOS EXTRAS PARA USO NOS EXERCÍCIO

# Sintaxe do input()
variavel = input("Mensagem ou prompt para o usuário: ")

# Exemplo Simples de Uso:

nome = input("Digite seu nome: ")
print("Olá, ", nome)

O comando input() é utilizado em Python para capturar dados fornecidos pelo usuário durante a execução do programa. O valor retornado pelo input() é sempre uma string, independentemente do que o usuário digitar.

COMANDOS EXTRAS PARA USO NOS EXERCÍCIO

# Exemplo com conversão de tipo
idade = int(input("Digite sua idade: "))
print("Você tem, ", idade, "anos.")

COMANDOS EXTRAS PARA USO NOS EXERCÍCIO

# Exemplo sintaxe print()
print(objeto1, objeto2, ..., sep=' ', end='/n')

# Exemplo com Vários objetos e parâmetros
nome = "Alice"
idade = 30
print("Nome:", nome, "Idade:", idade, sep=" ", end=".\n")

COMANDOS EXTRAS PARA USO NOS EXERCÍCIO

# Exemplo usando F-strings (a partir do Python 3.6):
nome = "João"
idade = "34"
print(f"Meu Nome é {nome} e eu tenho {idade} anos.")

Você pode usar a formatação de strings para criar saídas mais sofisticadas e legíveis.

COMANDOS EXTRAS PARA USO NOS EXERCÍCIO

# Exemplo usando F-strings (a partir do Python 3.6):
a=5
b=3
print(f"O resultado de {a} + {b} = {a + b}.")

Qual o resultado aqui?

COMANDOS EXTRAS PARA USO NOS EXERCÍCIO

nome = input("Digite seu nome: ")
idade = int(input("Digite sua idade: "))
print(f"Meu Nome é {nome} e eu tenho {idade} anos.")

Exemplo de entrada e saída

OPERADORES ARITMÉTICOS

# Definindo variáveis
a = 10
b = 5

# Adição
resultado_adicao = a + b
print("O resultado da adição é: ", resultado_adicao) # Output: Adição: 15

# Subtração
resultado_subtracao = a - b
print("O resultado da subtração é: ", resultado_subtracao) # Output: Subtração: 5

# Multiplicação
resultado_multiplicacao = a * b
print("O resultado da multiplicação é: ", resultado_multiplicacao) # Output: Multiplicação: 50

# Divisão
resultado_divisao = a / b
print("O resultado da divisão é: ", resultado_divisao) # Output: Divisão: 2.0

# Divisão Inteira
resultado_divisao_inteira = a // b
print("O resultado da divisão inteira é: ", resultado_divisao_inteira) # Output: Divisão inteira: 2

# Módulo (Resto divisão)
resultado_modulo = a % b
print("Módulo: ", resultado_modulo) # Output: Módulo: 0

# Exponenciação
resultado_exponenciacao = a ** b
print("Exponenciação: ", resultado_exponenciacao) # Output: Exponenciação: 100000

OPERADORES RELACIONAIS

# Definindo variáveis
a = 10
b = 5

# Maior que
resultado_maior = a > b
print("Maior que: ", resultado_maior) # Output: Maior que: True

# Menor que
resultado_menor = a < b
print("Menor que: ", resultado_menor) # Output: Menor que: False

# Maior ou igual
resultado_maior_ou_igual = a >= b
print("Maior ou igual: ", resultado_maior_ou_igual) # Output: Maior ou igual: True

# Menor ou igual
resultado_menor_ou_igual = a <= b
print("Menor ou igual: ", resultado_menor_ou_igual) # Output: Menor ou igual: False

# Igual a
resultado_igual = a == b
print("Igual a: ", resultado_igual) # Output: Igual a: False

# Diferente de
resultado_diferente = a != b
print("Diferente de: ", resultado_diferente) # Output: Diferente de: True

OPERADORES LÓGICOS

# Definindo variáveis
a = 10
b = 5
c = 7

# Exemplo sem parênteses usando 'and' e operadores relacionais 
resultado = a > b and  b < c
print("Resultado de a > b and b < c: ", resultado) # Output: True

# Exemplo sem parênteses usando 'or' e operadores relacionais 
resultado = a < b or c >= b
print("Resultado de a < b or c >= b: ", resultado) # Output: True

# Exemplo sem parênteses usando 'not' para inverter o resultado 
resultado = not a == b
print("Resultado de not a == b: ", resultado) # Output: True

OPERADORES LÓGICOS

# Definindo variáveis
x = [1, 2, 3]
y = x  # y e x referenciam o mesmo objeto
z = [1, 2, 3]  # z é um objeto diferente, apesar de ter o mesmo conteúdo

# Comparação de identidade com o operados 'is' 
resultado_is = x is y
print("Resultado de x is y: ", resultado_is) # Output: True

# Comparação de identidade com um objeto diferente 
resultado_is_not = x is z
print("Resultado de x is z: ", resultado_is_not) # Output: False

# Usando 'is' com operadores lógicos 
resultado_logico = x is y and z is not y
print("Resultado de x is y and z is not y: ", resultado_logico) # Output: True

# Verificando que as variáveis refenciam o mesmo objeto por meio do 'id'
print(id(x))
print(id(y))

# Comprovando a referência 
# das variáveis x e y

x.append(4)
print(x)
print(y)
print(id(x))
print(id(y))

OPERADORES LÓGICOS

O operador is é pode ser utilizado para verificar se o valor está em uma lista mas, também é utilizado para verificarmos valores boleanos True ou False e valores vazios que em python é determinado por None.

x = True
y = None
print(x is not False)

print(y is None)

ESTRUTURA DE DECISÃO

Estruturas de decisão (ou estruturas condicionais) são usadas para controlar o fluxo de execução de um programa com base em condições. Em Python, a principal estrutura de decisão é o bloco if, que pode ser complementado pelos blocos elif e else para verificar múltiplas condições e tomar diferentes decisões.

ESTRUTURA DE DECISÃO

if: Avalia uma condição e, se for verdadeira, executa o bloco de código associado.
elif: (abreviação de “else if”) Permite verificar outras condições se a condição if anterior for falsa.
else: Executa um bloco de código quando todas as condições anteriores são falsas.

if condicao:
    # Código executado se a condição for verdadeira
elif outra_condicao:
    # Código executado se a primeira condição for falsa e a outra_condicao for verdadeira
else: 
    # Executado se todas as outras condições forem falsas

ESTRUTURA DE DECISÃO

# Definindo a variável
idade = int(input("Qual sua idade: "))

# Estrutura de decisão básica
if 18 <= idade <= 150:
  print("Você é maior de idade.")
elif idade > 200:
  print("Você é Noé.")
elif 13 <= idade < 18:
  print("Você é adolescente.")
else:
print("Você é menor de idade.")

ESTRUTURA DE DECISÃO

# Exemplo com múltiplas condições e operadores lógicos
numero = int(input("Digite um número inteiro: "))

if numero > 0 and numero % 2 == 0:
    print("O número digitado é par.")
elif numero > 0 and numero % 2 != 0:
    print("O número digitado é impar.")
else:
    print("O número digitado é zero ou negativo.")

ESTRUTURA DE DECISÃO

# Exemplo de estrutura aninhada
idade = int(input("Qual sua idade: "))
possui_carteira = int(input("Digite 1 se possui carteira ou 0 senão possui:"))
tem_carteira = 1 == possui_carteira

if idade >= 18:
    if tem_carteira:
        print("Você pode dirigir")
    else:
        print("Você não pode dirigir sem carteira.")
else:
    print("Você é menor de idade e não pode dirigir.")

ESTRUTURA DE DECISÃO

match-case: é uma estrutura de decisão introduzida no Python 3.10 que funciona como o switch de outras linguagens, mas com mais poder. Ele permite comparar valores, padrões, tipos e estruturas complexas de forma clara e elegante.

match valor:
    case padrão1:
        # bloco de código
    case padrão2:
        # outro bloco
    case _:
        # caso padrão (equivalente ao 'else')
        # O caractere _ é usado como caso coringa (default).

ESTRUTURA DE DECISÃO

# Exemplo simples
comando = input("Digite um comando: ")

match comando:
    case "iniciar":
        print("Iniciando...")
    case "parar":
        print("Parando...")
    case _:
        print("Comando inválido.")

ESTRUTURA DE DECISÃO

# Exemplo com padrão complexo
pessoa = ("João", 30)

match pessoa:
    case (nome, idade) if idade >= 18:
        print(f"{nome} é maior de idade.")
    case (nome, idade):
        print(f"{nome} é menor de idade.")

Os padrões são avaliados sequencialmente, o primeiro que casar será executado.

ESTRUTURA DE REPETIÇÃO

O laço for em Python é utilizado para iterar sobre uma sequência (como uma lista, tupla, string, ou intervalo de números). Ele percorre os elementos da sequência um por um, executando o bloco de código para cada elemento.

ESTRUTURA DE REPETIÇÃO

# Sintaxe do for
for variavel in sequencia:
  	# Bloco de código a ser repetido

# Exemplo com for    

# Iterando sobre uma lista 
frutas = ["maça", "pêra", "morango", "biribá"]

for fruta in frutas:
  	print(fruta)

range(5) gera uma sequência de números de 0 a 4.
O laço for percorre essa sequência, atribuindo cada número à variável i e imprimindo a iteração atual.

# Exemplo com range():
 
for i in range(5):
	print("Iteração:", i)

ESTRUTURA DE REPETIÇÃO

1. Faça um Programa que pergunte quanto você ganha por hora e o número de horas trabalhadas no mês. Calcule e mostre o total do seu salário no referido mês.

2. Faça um Programa que peça a temperatura em graus Fahrenheit, transforme e mostre a temperatura em graus Celsius.

C = 5 * ((F-32) / 9).

3. Tendo como dado de entrada a altura (h) de uma pessoa, construa um algoritmo que calcule seu peso ideal, utilizando as seguintes fórmulas:

Para homens: (72.7*h) - 58

Para mulheres: (62.1*h) - 44.7

EXERCÍCIOS DE FIXAÇÃO

4. Faça um Programa que pergunte o Salário Bruto. Calcule e mostre o total do seu Salário Líquido no referido mês, sabendo-se que são descontados Imposto de Renda e INSS conforme tabelas abaixo, faça um programa que nos dê: salário bruto, quanto pagou ao IR e INSS e o salário líquido, exiba conforme a tabela de resultados abaixo:

+ Salário Bruto : R$

- INSS : R$

- IR: R$

= Salário Liquido : R$

EXERCÍCIOS DE FIXAÇÃO

Tabela INSS

Base de Cálculo Mensal (R$)	Alíquota (%)	Parcela a Deduzir (R$)
Até 2.428,80	0%	0,00
De 2.428,81 até 2.826,65	7,5%	182,16
De 2.826,66 até 3.751,05	15%	394,16
De 3.751,06 até 4.664,68	22,5%	675,49
Acima de 4.664,68	27,5%	908,73

Tabela IR

# Base cálculo IR
Base = Salário Bruto – INSS
# Exemplo
Base = R$ 20.200,00 – R$ 908,86 = R$ 19.291,14
IRRF = (Base × Aliquota%) – Parcela a deduzir

Faixa Salarial (R$)	Alíquota (%)	Parcela a Deduzir (R$)
Até 1.518,00	7,5%	0,00
De 1.518,01 até 2.793,88	9%	22,77
De 2.793,89 até 4.190,83	12%	106,59
De 4.190,84 até 8.157,41	14%	190,40

R$ Faixa Salarial (FS)	Alíquota (%) (ALI)	R$ Parcela a Deduzir (PD)	Total s/ Dedução (TSD) -> FS * ALI	R$ INSS Pago (TSD - PD)
8.157,41	0,14	190,4	1142,0374	951,6374

Resultados

5. Desenvolva um gerador de tabuada, capaz de gerar a tabuada de qualquer número inteiro entre 1 a 10. O usuário deve informar de qual numero ele deseja ver a tabuada. A saída deve ser conforme o exemplo abaixo:
Tabuada de 5:
5 X 1 = 5
5 X 2 = 10
...
5 X 10 = 50

EXERCÍCIOS DE FIXAÇÃO

O enumerate() é uma função útil em Python que permite iterar sobre uma sequência, como uma lista ou uma string, ao mesmo tempo em que mantém um contador automático. Essa função retorna pares contendo o índice (ou contador) e o valor correspondente da sequência.

# Sintaxe Básica
 
for indice, valor in enumerate(sequencia, start=0):
	# Bloco de código a ser executado

    
# sequencia: Sequência pela qual deseja iterar
# start (opcional): O valor inicial do contador. O padrão é 0.

ESTRUTURA DE REPETIÇÃO

# Definindo array de frutas
frutas = ["maça", "pêra", "morango", "biribá"] 
  
# Iterando com enumerate  
for indice, fruta in enumerate(frutas, start=1):
	print(f"Fruta {indice}: {fruta}")


# Saída esperada
Fruta 1: maça
Fruta 2: pêra
Fruta 3: morango
Fruta 4: biribá

ESTRUTURA DE REPETIÇÃO

O laço while repete um bloco de código enquanto uma condição especificada é verdadeira. É útil quando você não sabe com antecedência quantas vezes o laço precisará ser executado.

# Sintaxe do while
 
while condicao:
	# Bloco a ser repetido

ESTRUTURA DE REPETIÇÃO

# Definindo variável
contador = 0

# Iterando enquanto respeitar a condição
while contador < 5:
    print(f"Contador: {contador}")
    contador += 1

ESTRUTURA DE REPETIÇÃO

O laço while continua a execução enquanto a condição contador < 5 for verdadeira.
O valor de contador é incrementado em 1 a cada iteração, e o laço termina quando contador atinge 5.

Interromper a iteração imediatamente "break".

for i in range(10):
    if i == 5:
        break
    print(i)

ESTRUTURA DE REPETIÇÃO

Pula a iteração imediatamente "continue".

for i in range(10):
    if i == 2:
        continue
    print(i)

ESTRUTURA DE REPETIÇÃO

Exemplo utilizando while, break e continue

while contador < 10:
    contador += 1
    if contador == 5:
        continue     # Pula impressão do 5
    if contador == 8:
        break        # Interrompe o laço ao alcançar 8
    print("Contador: ", contador)

ESTRUTURA DE REPETIÇÃO

Python possui várias estruturas de dados integradas que permitem armazenar e manipular coleções de dados. As mais comuns são listas, tuplas e dicionários. Cada uma dessas estruturas tem características específicas e métodos associados que são úteis para diferentes situações.

LISTAS, TUPLAS E DICIONÁRIOS

Listas são coleções ordenadas de elementos que são mutáveis (ou seja, podem ser alteradas). Uma lista pode conter elementos de tipos diferentes, incluindo outras listas.

# Criando uma lista de números
numeros = [1, 2, 3, 4, 5]

# Criando uma lista mista com diferentes tipos de dados
mista = [1, "Olá", 3.14, True]

LISTAS, TUPLAS E DICIONÁRIOS

Declarando Listas com o list()

# Criando uma lista vazia
lista_vazia = list()
print(lista_vazia) # Output: []

# Criando uma lista a partir de uma sequência
lista_numeros = list([1, 2, 3, 4, 5])
print(lista_numeros) # Output: [1, 2, 3, 4, 5]

# Criando uma lista a partir de uma string (a string será dividida em caracteres)
lista_caracteres = list("Python")
print(lista_caracteres) # Output: ['P', 'y', 't' , 'h', 'o', 'n']

# Criando uma lista a partir de um range
lista_range = list(range (5))
print(lista_range) # Output: [0, 1, 2, 3, 41

LISTAS, TUPLAS E DICIONÁRIOS

Acessando elementos

numeros = [1, 2, 3, 4, 5]
print(numeros[0])
print(numeros[-2])

O que será impresso no output?

LISTAS, TUPLAS E DICIONÁRIOS

Adicionando elementos a lista com "append"

numeros = [1, 2, 3, 4, 5]
print(numeros[0]) 
print(numeros[-1])
numeros.append(6)
print(numeros[-2])

O que será impresso no output?

LISTAS, TUPLAS E DICIONÁRIOS

remove: Remove a primeira ocorrência de uma valor específico.

numeros = [1, 2, 3, 4, 5]
numeros.append(3)
numeros.remove(3)
print(numeros)

O que será impresso no output?

LISTAS, TUPLAS E DICIONÁRIOS

pop(): Remove e retorna o elemento em uma posição específica (ou último, se a posição não for especificada.

numeros = [1, 2, 3, 4, 5]
ultimo = numeros.pop()
print(ultimo)
print(numeros)

O que será impresso no output?

numeros = [1, 2, 3, 4, 5]
selecionado = numeros.pop(1)
print(selecionado)
print(numeros)

LISTAS, TUPLAS E DICIONÁRIOS

index(): Retorna o índice da primeira ocorrência de um valor.

numeros = [1, 2, 3, 4, 5]
posicao = numeros.index(4)
print(posicao)

O que será impresso no output?

LISTAS, TUPLAS E DICIONÁRIOS

Exemplos com len() para uma Lista

# Definido uma lista de frutas
frutas = ["maça", "pêra", "uva", "laranja", "biribá"]

# Obtendo o tamanho da lista com len()
tamanho = len(frutas)

# Exibindo o tamanho da lista
print("O tamanho da lista de frutas é: ", tamanho)

O que será impresso no output?

LISTAS, TUPLAS E DICIONÁRIOS

LISTAS, TUPLAS E DICIONÁRIOS

Tuplas são coleções ordenadas de elementos que são imutáveis (ou seja, uma vez criadas, não podem ser alteradas). As tuplas são úteis quando você deseja que os dados sejam protegidos contra modificações acidentais.

Criando uma Tupla

# Tupla de números
tupla_numeros = (1, 2, 3, 4, 5)

# Tupla com tipos mistos
tupla_mista = (1, "Olá", 3.14, True)

LISTAS, TUPLAS E DICIONÁRIOS

Acessando Elementos

# Tupla de números
tupla_numeros = (1, 2, 3, 4, 5)
print(tupla_numeros[0])  # Acessa o primeiro elemento: 1
print(tupla_numeros[-1]) # Acessa o primeiro elemento: 5

LISTAS, TUPLAS E DICIONÁRIOS

Funções Importantes para Tuplas

# count(): Retorna o número de ocorrências de um valor específico.
tupla_numeros = (1, 2, 3, 4, 5)
ocorrencias = tupla_numeros.count(3)
print(ocorrencias) # Output: 1

# index(): Retorna o índice da primeira ocorrência de um valor.
posicao = tupla_numeros.index(4)
print(posicao) # Output: 3

LISTAS, TUPLAS E DICIONÁRIOS

LISTAS, TUPLAS E DICIONÁRIOS

Dicionários são coleções desordenadas de pares chave-valor, onde cada chave é única. Eles são muito úteis para armazenar dados que precisam ser acessados por uma chave identificadora.

Criando e acessando um Dicionário

# Dicionário com informações de uma pessoa
pessoa = {"nome": "Vanilton", "idade": 34, "cidade": "Manaus"}

# Acessando valores
print(pessoa["nome"]) # Output: Vanilton

LISTAS, TUPLAS E DICIONÁRIOS

Criando e acessando um Dicionário com dict()

# Criando dicionário vazio
dicionario_vazio = dict()
print(dicionario_vazio) # Output: {}

# Criando um dicionário com pares chave-valor
dicionario_pessoa = dict(nome="Louie", idade=6, cidade="Manaus")
print(dicionario_pessoa) # Output: {'nome': 'Louie', 'idade': 6, 'cidade': 'Manaus'}

LISTAS, TUPLAS E DICIONÁRIOS

Funções Importantes para Dicionários

# Definindo um dicionário de pessoa
pessoa = {"nome": "Vanilton", "idade": 34, "cidade": "Manaus"}

# # keys(): Retorna uma lista (ou view) das chaves no dicionário
chaves = pessoa.keys()
print(chaves) # Output: dict_keys(['nome', 'idade', 'cidade'])

# values(): Retorna uma lista (ou view) dos valores no dicionário.
valores = pessoa.values()
print(valores) # Output: dict_values(['Vanilton', 34, 'Manaus'])

# items(): Retorna uma lista (ou view) de pares chave-valor (tuplas).
itens = pessoa.items()
print(itens) # Output: dict_items([('nome', 'Vanilton'), ('idade', 34), ('cidade', 'Manaus')])

LISTAS, TUPLAS E DICIONÁRIOS

get(): Retorna o valor associado a uma chave, mas evita um erro se a chave não existir,
retornando um valor padrão (ou None).

# Definindo um dicionário de pessoa
pessoa = {"nome": "Vanilton", "idade": 34, "cidade": "Manaus"}

# Acessando uma chave existente
idade = pessoa.get("idade")
print(idade)

# Tentando acessar uma chave inexistente sem causar um erro
estado = pessoa.get("estado", "Desconhecido")
print(estado) # Output: Desconhecido

LISTAS, TUPLAS E DICIONÁRIOS

# Definindo um dicionário de pessoa
pessoa = {"nome": "Vanilton", "idade": 34, "cidade": "Manaus"}
print(pessoa)

# update(): Atualiza o dicionário com pares chave-valor de outro dicionário ou de um iterável de pares
pessoa.update({"idade": 34, "estado": "AM"})
print(pessoa)

# pop(): Remove a chave especificada e retorna o valor correspondente
idade_removida = pessoa.pop("idade")
print(idade_removida) # Output: 34
print(pessoa) # Output: {'nome': 'Vanilton', 'cidade': 'Manaus', 'estado': 'AM'}

LISTAS, TUPLAS E DICIONÁRIOS

ITERANDO SOBRE LISTAS, TUPLAS E DICIONÁRIOS

# Definido uma lista de frutas
frutas = ["maça", "pêra", "uva", "laranja", "biribá"]

# Iterando sobre uma lista 
for fruta in frutas:
    print("Fruta:", fruta)
    
# Output:

Fruta: maça
Fruta: pêra
Fruta: uva
Fruta: laranja
Fruta: biribá

ITERANDO SOBRE LISTAS, TUPLAS E DICIONÁRIOS

# Definido uma tupla de números
numeros = [1, 2, 3, 4, 5]

# Iterando sobre uma tupla 
for numero in numeros:
    print("Número:", numero)
    
# Output:

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

ITERANDO SOBRE LISTAS, TUPLAS E DICIONÁRIOS

# Definindo um dicionário com informações de uma pessoa
pessoa = dict(nome="Louie", idade=6, cidade="Manaus")

# Iterando sobre as chaves
for chave in pessoa:
    print("Chave: ", chave)
    
# Output: 
Chave:  nome
Chave:  idade
Chave:  cidade

Há várias maneiras de iterar sobre dicionários, dependendo do que você deseja acessar (chaves, valores ou ambos).

ITERANDO SOBRE LISTAS, TUPLAS E DICIONÁRIOS

# Definindo um dicionário com informações de uma pessoa
pessoa = dict(nome="Louie", idade=6, cidade="Manaus")

# Iterando sobre os valores
for valor in pessoa.values():
    print("Valor: ", valor)
    
# Output: 
Valor:  Louie
Valor:  6
Valor:  Manaus

ITERANDO SOBRE LISTAS, TUPLAS E DICIONÁRIOS

# Definindo um dicionário com informações de uma pessoa
pessoa = dict(nome="Louie", idade=6, cidade="Manaus")

# Iterando sobre os pares de Chave-Valor
for chave, valor in pessoa.items():
    print(f"Chave: {chave}, Valor: {valor}")
    
# Output: 
Chave: nome, Valor: Louie
Chave: idade, Valor: 6
Chave: cidade, Valor: Manaus

ITERANDO SOBRE LISTAS, TUPLAS E DICIONÁRIOS X NAMEDTUPLE

from collections import namedtuple

Pessoa = namedtuple("Pessoa", ["nome", "idade", "cidade"])
ana = Pessoa("Ana", 30, "São Paulo")

Namedtuple
- Cria objetos com campos nomeados
- Imutável como uma tuple, legível como uma class

ITERANDO SOBRE LISTAS, TUPLAS E DICIONÁRIOS X NAMEDTUPLE

from collections import namedtuple

Pessoa = namedtuple("Pessoa", ["nome", "idade", "cidade"])
ana = Pessoa("Ana", 30, "São Paulo")

print(ana.nome)      # Ana
print(ana[1])        # 30

Acessando dados de uma Namedtuple

✅ Acesso por índice ou nome
❌ Não é possível alterar os valores diretamente

ITERANDO SOBRE LISTAS, TUPLAS E DICIONÁRIOS X NAMEDTUPLE

Comparação entre dict e namedtuple

Característica	dict	namedtuple
Mutável?	Sim	Não
Acesso por chave?	Sim (p["nome"])	Sim (p.nome)
Ordem dos campos?	Não garantida (antes do Py 3.7)	Sim (ordem definida na criação)
Performance	Mais lento	Mais leve
Ideal para...	Dados dinâmicos	Registros fixos, estruturados

ITERANDO SOBRE LISTAS, TUPLAS E DICIONÁRIOS X NAMEDTUPLE

from collections import namedtuple

# 1. Dado um dicionário
dados = {
    "nome": "João",
    "idade": 28,
    "cidade": "Belo Horizonte"
}

# 2. Criar o namedtuple com os mesmos campos
Pessoa = namedtuple("Pessoa", dados.keys())

# 3. Converter usando o desempacotamento **
# Com ** → cada chave vira um argumento nomeado (nome="João", idade="28")
joao = Pessoa(**dados) 

# 4. Acessar como atributos
print(joao.nome)    # João
print(joao.idade)   # 28

Convertendo um dicionário para namedtuple

ITERANDO SOBRE LISTAS, TUPLAS E DICIONÁRIOS X NAMEDTUPLE

from collections import namedtuple

lista_dados = [
    {"nome": "Ana", "idade": 30},
    {"nome": "Carlos", "idade": 25}
]

Pessoa = namedtuple("Pessoa", ["nome", "idade"])

lista_namedtuples = [Pessoa(**d) for d in lista_dados]

print(lista_namedtuples[0].nome)

Convertendo uma lista de dicionário para namedtuple

ITERANDO SOBRE LISTAS, TUPLAS E DICIONÁRIOS

# List comprehension (ou "compreensão de listas")
[nova_expressao for item in coleção if condição_opcional]

# Quadrado de 0 a 4
lista_numero_quadrado = [ x**2 for x in range(5) ] 
print(lista_numero_quadrado) # Output: [0, 1, 4, 9, 16]

# Filtrar apenas números pares:
lista_pares = [ x for x in range(10) if x % 2 == 0 ] 
print(lista_pares) # Output: [0, 2, 4, 6, 8]

List Comprehension: É uma forma compacta de criar listas em uma única linha, usando uma sintaxe de for + expressão.

EXERCÍCIOS DE FIXAÇÃO - LISTAS E ESTRUTURA DE REPETIÇÃO

1. Dada uma lista de valores inteiros criar um programa para somar os valores pares e valores ímpares

2. Dada uma palavra criar um programa para retornar a quantidade de vogais e quantidade de consoantes

3. Criar um programa para adicionar funcionários. Os funcionários devem ter nome, sexo e salário o programa deve retornar a soma de salários dos homens e soma dos salários das mulheres

EXERCÍCIOS DE FIXAÇÃO - LISTAS E ESTRUTURA DE REPETIÇÃO

4. Monte um programa que permita ao usuário cadastrar produtos com nome e preço. Armazene os dados em um dicionário, onde o nome do produto é a chave e o preço é o valor. No final, exiba todos os produtos e o preço total.

5. Armazene em uma tupla as notas de 4 alunos. Calcule e mostre a média das notas e diga quais notas ficaram acima da média.

EXERCÍCIOS DE FIXAÇÃO - LISTAS E ESTRUTURA DE REPETIÇÃO

6. Crie um programa em Python que simule um jogo de adivinhação de um número inteiro.

O programa deve:

Peça para uma pessoa definir o valor a ser adivinhado.
Pedir ao jogador que tente adivinhar o número.
Informar se o chute está alto, baixo ou correto.
Dar 5 tentativas ou até que o jogador acerte.
Caso as tentativas se esgotem exiba uma mensagem de tente novamente e o número que deveria ter sido adivinhado, caso contrário exibe uma mensagem parabenizando o jogador.

FUNÇÕES

Funções em Python são blocos de código reutilizáveis que realizam uma tarefa específica. Elas ajudam a tornar o código mais modular, organizado e fácil de entender. Python possui várias funções integradas (como print() e len()), mas também permite que você defina suas próprias funções.

FUNÇÕES - CRIANDO

Para definir uma função em Python, você usa a palavra-chave def, seguida pelo nome da função, parênteses () que podem conter parâmetros, e dois pontos :. O código da função é então escrito em um bloco indentado.

def saudacao():
    print("Olá bb")

FUNÇÕES - EXECUTANDO

Uma função é executada quando você a chama pelo nome, seguido de parênteses.

def saudacao():
    print("Olá bb")

    
# Chamando a função saudacao
saudacao() # Output: Olá bb

FUNÇÕES - PARAMETRIZANDO

Você pode passar informações para uma função usando parâmetros. Esses parâmetros são especificados dentro dos parênteses na definição da função.

def saudacao(nome):
    print(f"Olá, {nome}!")

    
# Chamando a função com Argumento
saudacao("Vavá") # Output: Olá, Vavá"

FUNÇÕES - RETORNO

Uma função pode retornar um valor usando a palavra-chave return. Isso permite que a função envie um resultado de volta para o ponto onde foi chamada.

def soma(a, b):
    return a + b;

    
# Chamando a função e Usando o valor Retornado
resultado = soma(3, 5)
print(resultado) # Output: 8

FUNÇÕES - PARÂMETRO OPCIONAL

Você pode fornecer valores padrão para os parâmetros, tornando-os opcionais ao chamar a função.

def saudacao(nome="mundo"):
    print(f"Olá, {nome}!") 

    
# Chamando com ou sem Argumentos
saudacao()          # Output: Olá, mundo
saudacao("José") # Output: 8lá, José!

FUNÇÕES - PARÂMETRO OPCIONAL

Uma função pode retornar múltiplos valores usando uma tupla.

def dividir(a, b):
    quociente = a // b
    resto = a % b
    return quociente, resto

    
# Usando os valores retornados:
q, r = dividir(10, 3)
print(f"Quociente: {q}, Resto: {r}")

FUNÇÕES - PARÂMETROS DINÂMICOS

O Python também permite que usemos parâmetros dinâmicos. O que isso quer dizer? Imagine precisar criar uma função que some valores, porém, você pode passar dois parâmetros ou 3, ou 4 e assim por diante.
*args permite que você passe um número variável de argumentos posicionais para uma função. Dentro da função, args será tratado como uma tupla.

FUNÇÕES - PARÂMETROS DINÂMICOS

def soma(*args):
    resultado = 0
    for num in args:
        resultado += num
    return resultado

# Exemplo de uso
print(soma(2, 3, 4, 5)) # Output: 14
print(soma(2, 2, 4, 5)) # Output: 13

FUNÇÕES - PARÂMETROS DINÂMICOS

É possível também que esses parâmetros dinâmicos sejam dicionários, isso basicamente quer dizer que podem ser enviados várias chaves e vários valores.
**kwargs permite que você passe um número variável de argumentos nomeados (ou seja, pares chave-valor) para uma função. Dentro da função, kwargs será tratado como um dicionário.

FUNÇÕES - PARÂMETROS DINÂMICOS

def exibir_informacoes(**kwargs):
    for chave, valor in kwargs.items():
        print(f"{chave}: {valor}")


# Exemplo de uso
exibir_informacoes(nome="Vanilton", idade=34, cidade="Manaus")

  # Output:
  # nome: Vanilton
  # idade: 34
  # cidade: Manaus

FUNÇÕES - MAIN

Utilizamos a função main para:

Para organizar melhor o código.
Deixa o programa mais fácil de ler e entender.
Permite rodar o código só se o arquivo for executado diretamente, não se for importado como módulo em outro projeto.

FUNÇÕES - MAIN

# arquivo.py 
 
# Função principal do programa
def main():
  # Códigos que serão executados ao chamar o arquivo.py

  
# Condição para rodar o programa
if __name__ == "__main__":
    # Esta linha garante que a main() só será chamada se o arquivo
    # for executado diretamente (não quando importado como módulo)
    main()

FUNÇÕES - MAIN

# Exemplo importando como módulo

# exemplo.py
print(f"O valor de __name__ é: {__name__}")

def saudacao():
    print("Olá do exemplo.py!")

def main():
    print("Executando a main() de exemplo.py")
    saudacao()

if __name__ == "__main__":
    main()


# teste_importação.py
import exemplo

print("Estamos dentro de teste_importacao.py")

O valor de __name__ é: exemplo
Estamos dentro de teste_importacao.py

O valor de __name__ é: __main__
Executando a main() de exemplo.py
Olá do exemplo.py!

FUNÇÕES DE STRING

Funções de string em Python são métodos que permitem manipular e operar em strings de forma eficiente. Python oferece uma ampla variedade de métodos embutidos para trabalhar com strings, facilitando tarefas comuns como formatação, substituição, busca, e modificação de texto.

FUNÇÕES DE STRING

len(): Retorna o comprimento da string (o número de carateres).

texto = "Louie"
print(len(texto)) # Output: 5

str.upper(): Converte todos os caracteres da string para maiúsculas.

texto = "Louie"
print(texto.upper()) # Output: LOUIE

str.lower(): Converte todos os caracteres da string para minúsculas.

texto = "Louie"
print(texto.lower()) # Output: louie

FUNÇÕES DE STRING

str.capitalize(): Converte o primeiro caractere da string para maiúsculo e o restante para minúsculo.

texto = "python programMing"
print(texto.capitalize()) # Output: python programming

str.strip(): Remove espaços vazios do início e fim da string.

texto = "   python programMing   "
print(texto.strip()) # Output: "python programming"

str.replace(): Substitui uma substring por outra, caso identifique o padrão de procura, do contrário mantêm a string do modo original.

texto = "Olá, Fulano"
print(texto.replace("Fulano", "Mario")) # Output: "Olá, Mário"

FUNÇÕES DE STRING

str.find(): Retorna o índice da primeira ocorrência de uma substring. Retorna -1 se a substring não for encontrada.

texto = "Igarapé é frio"
print(texto.find("frio")) # Output: 10
print(texto.find("quente")) # Output: -1

str.split(): Divide a string em uma lista de substrings com base em um delimitador.

texto = "Igarapé é frio"
print(texto.split())        # Output: ['Igarapé', 'é', 'frio']
print(texto.split(sep="/"))

str.join(): Junta uma sequência de strings em uma única string, usando uma string como delimitador

palavras = ['Igarapé', 'é', 'frio']
print(" ".join(palavras)) # Output: "Igarapé é frio"

FUNÇÕES DE STRING

str.startswith(): Verifica se a string começa com uma determinada substring.

texto = "Igarapé é frio"
print(texto.startswith("Iga")) # Output: True

str.endswith(): Verifica se a string termina com uma determinada substring.

texto = "Igarapé é frio"
print(texto.endswith("io")) # Output: True

str.isdigit(): Verifica se todos os caracteres na string são dígitos.

texto = "12345"
print(texto.isdigit()) # Output: True

FUNÇÕES DE STRING

str.isalpha(): Verifica se todos caracteres na string são letras.

texto = "Igarapé é frio"
print(texto.isalpha()) # Output: False

str.count(): Conta o número de ocorrências de uma substring na string.

texto = "Igarapé é frio"
print(texto.count("a")) # Output: 2

str.format(): Formata a string utilizando placeholders

nome = "Vanilton"
idade = 34
print("Meu nome é {} e eu tenho {} anos.".format(nome, idade))
# Output: Meu nome é Vanilton e eu tenho 34 anos.

FUNÇÕES DE STRING

Encadeamento de métodos

texto = "   python programMing   "
print(texto.strip().capitalize().upper())

Slicing (fatiamento)

texto = "python"
print(texto[:])     # Output: python (cópia igual)
print(texto[::1])   # Output: python (igual)
print(texto[::2])   # Output: pto (lê 1, pula 1)
print(texto[::-1])  # Output: nohtyp (invertido)
print(texto[1::3])	# Output: yo (Começa no índice 1 e vai pulando de 3 em 3)

EXERCÍCIOS DE FIXAÇÃO

1. Crie um programa que leia o nome de 5 pessoas e armazene em uma lista. Em seguida, exiba apenas os nomes que começam com a letra "A".

2. Embaralha palavra. Construa uma função que receba uma string como parâmetro e devolva outra string com os carateres embaralhados. Por exemplo: se função receber a palavra python, pode retornar npthyo, ophtyn ou qualquer outra combinação possível, de forma aleatória. Padronize em sua função que todos os caracteres serão devolvidos em caixa alta ou caixa baixa, independentemente de como foram digitados.

EXERCÍCIOS DE FIXAÇÃO

3. Reverso do número. Faça uma função que retorne o reverso de um número inteiro informado. Por exemplo: 127 -> 721.
4. Faça um programa, com uma função que necessite de três argumentos, e que forneça a soma desses três argumentos.

5. Conta espaços e vogais. Dado uma string com uma frase informada pelo usuário (incluindo espaços em branco), conte:

quantos espaços em branco existem na frase.
quantas vezes aparecem as vogais a, e, i, o, u.

EXERCÍCIOS DE FIXAÇÃO

6. Nome na vertical em escada. Faça um programa para mostrar o nome em formato de escada.
F
FU
FUL
FULA
FULAN
FULANO

FUNÇÕES BUILT-IN

As funções built-in (ou internas) em Python são funções que estão disponíveis automaticamente em qualquer programa Python, sem a necessidade de importar módulos ou bibliotecas adicionais. Elas são parte integrante da linguagem e oferecem uma ampla gama de funcionalidades úteis para manipulação de dados, conversão de tipos, operações matemáticas, controle de fluxo e muito mais.

print(): Exibe informações no console.

FUNÇÕES BUILT-IN

print("Olá, Universo!")

len(): Retorna o número de itens em um objeto, como uma string, lista, tupla ou dicionário.

lista = [1, 2, 3, 4]
print(len(lista)) # Output: 4

type(): Retorna o tipo do objeto passado como argumento.

print(type(10))       # Output: <class 'int'>
print(type("Python")) # Output: <class 'str'>

input(): Lê uma entrada do usuário e a retorna como uma string.

FUNÇÕES BUILT-IN

nome = input("Digite seu nome: ")
print("Olá, ", nome)

int(), float(), str(): Convertem valores conforme os seus tipos respectivamente.

numero_str = "123"
numero_int = int(numero_str)
numero_float = float(numero_str)
print(numero_int, numero_float)

sum(): Retorna a soma dos elementos de um iterável, como uma lista ou tupla

numeros = [1, 2, 3, 4]
print(sum(numeros)) # Output: 10

max() e min(): Retornam o maior e o menor valor de um iterável, respectivamente.

FUNÇÕES BUILT-IN

numeros = [1, 2, 3, 4]
print(max(numeros)) # Output: 4
print(min(numeros)) # Output: 1

sorted(): Retorna uma nova lista ordenada a partir dos elementos de um iterável.

numeros = [3, 1, 4, 2]
print(sorted(numeros)) # Output: [1, 2, 3, 4]

range(): Gera uma sequência de números, geralmente usada em loops.

for i in range(5):
    print(i) # Output: 0 1 2 3 4

enumerate(): Retorna um objeto enumerado, que contém pares de índice e valor.

FUNÇÕES BUILT-IN

lista = ["a", "b", "c"]
for indice, valor in enumerate(lista):
    print(indice, valor)
    
# Output:
0 a
1 b
2 c

zip(): Combina dois ou mais iteráveis (como listas) em um único iterável de tuplas.

nomes = ["José", "Maria", "Pedro"]
idades = [23, 40, 35]
for nome, idade in zip(nomes, idades):
    print(nome, idade)
    
# Output:
José 23
Maria 40
Pedro 35

map(): Aplica um função a todos os itens de um iterável.

FUNÇÕES BUILT-IN

def quadrado(x):
    return x ** 2
  
numeros = [1, 2, 3, 4]
print(list(map(quadrado, numeros))) # Output: [1, 4, 9, 16]

filter(): Filtra itens de um iterável com base em um função.

def par(x):
    return x % 2 == 0
  
numeros = [1, 2, 3, 4]
print(list(filter(par, numeros))) # Output: [2, 4]

reduce(): Aplica repetidamente uma função aos itens de um iterável, reduzindo-os a um único valor, reduce está disponível no módulo functools.

FUNÇÕES BUILT-IN

from functools import reduce


def soma(x, y):
    return x + y

numeros = [1, 2, 3, 4]
print(reduce(soma, numeros)) # Output: 10

any() e all(): any() retorna True se algum item em um iterável for True. all() retorna True se todos os itens em um iterável forem True.

booleanos = [True, False, True]
print(any(booleanos)) # Output: True
print(all(booleanos)) # Output: False

reversed(): Inverte a ordem de uma sequência str, lista ou tuplas para um iterável de lista. reversed() precisa de algo que tenha uma ordem. Por este motivo não funciona com Dicionários (dict) no Python dado que são coleções não indexadas de pares chave-valor.

FUNÇÕES BUILT-IN

print(list(reversed("jaca")))       # Output: ['a', 'c', 'a', 'j']
print(list(reversed([1, 2, 3, 4]))) # Output: [4, 3, 2, 1]

abs(): Retorna o valor absoluto.

print(abs(-7))     # Output: 7
print(abs(-7.3))   # Output: 7.3
print(abs(7))      # Output: 7
print(abs(0))      # Output: 0

FUNÇÕES BUILT-IN

abs(): Retorna o valor absoluto.

z = 3 + 4j    # Número complexo
print(abs(z)) # Output: 5.0 (porque sqrt(3² + 4²) = 5)

3 + 4j = \sqrt{3^2 + 4^2} = \sqrt{9 + 16} = \sqrt{25} = 5

real

imaginário

FUNÇÕES BUILT-IN

complex(): Retorna a função do número complexo.

z = complex(3, 4)
print(z)  # output: (3+4j)

round(): Arredonda números

print(round(3.1415, 2)) # Output: 3.14

breakpoint(): Utiliza Python Debugger pausando a execução deixando-se ver/interagir com o programa. Nas pausas digite c ou continue no console para seguir o programa.

a = 10
b = 20

breakpoint()  # O código vai pausar aqui!

c = a + b
print(c)

FUNÇÕES BUILT-IN

random: Gerar números aleatórios e fazer operações aleatórias com listas e sequências.

import random

# Gera Número inteiro randomicamente para um intervalo
print(random.randint(1, 10))

lista_caracteres = list("Vanilton")

# Altera uma lista diretamente
random.shuffle(lista_caracteres)
print(''.join(lista_caracteres))
print(random.shuffle(lista_caracteres))

 
nome = "Walkiria"
# Cria uma nova lista randomicamente
lista_randomica = random.sample(nome, len(nome))
print(lista_randomica)

FUNÇÕES BUILT-IN

random: Gerar números aleatórios e fazer operações aleatórias com listas e sequências.

import random


# Retorna um número float aleatório entre 0.0 e 1.0
print(random.random())

# Retorna aleatoriamente um elemento da sequencia
print(random.choice(['a', 'b', 'c'])) # ex: 'b'

# Retorna um número aleatório para um intervalo float
print(random.uniform(10.0, 20.5))

TRABALHANDO COM ARQUIVOS

Trabalhar com arquivos em Python é uma tarefa comum e bem suportada pela linguagem. Python oferece várias funções e métodos para abrir, ler, escrever e manipular arquivos de diferentes tipos, como arquivos de texto, binários, CSVs, entre outros.

TRABALHANDO COM ARQUIVOS

Para trabalhar com arquivos em Python, você primeiro precisa abri-los usando a função open(), que retorna um objeto de arquivo.

TRABALHANDO COM ARQUIVOS

Atenção: Você deve sempre fechar o arquivo após terminar de usá-lo para liberar recursos do sistema. Isso pode ser feito com o método close() ou, de forma mais segura, usando uma instrução with que garante que o arquivo seja fechado automaticamente.

TRABALHANDO COM ARQUIVOS

Exemplo básico

# Abrindo um arquivo para leitura
arquivo = open("exemplo.txt", "r")

# Trabalhando com o arquivo
conteudo = arquivo.read()
print(conteudo)

# Fechando o arquivo
arquivo.close()

TRABALHANDO COM ARQUIVOS

Modos de abertura: A função open() aceita diferentes modos de abertura, que determinam como você pode interagir com o arquivo:

r: Abre para leitura (modo padrão). O arquivo deve existir.
w: Abre para escrita. Cria um novo arquivo se não existir ou sobrescreve o arquivo existente.
a: Abre para escrita, mas no modo de anexar (adiciona no final do arquivo, sem sobrescrever).

TRABALHANDO COM ARQUIVOS

Modos de abertura: A função open() aceita diferentes modos de abertura, que determinam como você pode interagir com o arquivo:

b: Modo binário (por exemplo, "rb", "wb"), utilizado para arquivos que não são de texto (imagens, áudio, etc.).
x: Cria um novo arquivo, mas gera um erro se o arquivo já existir.

TRABALHANDO COM ARQUIVOS

Lendo arquivos: Python oferece várias maneiras de ler o conteúdo de um arquivo:

# Lendo o arquivo inteiro de uma vez:
with open("exemplo", "r") as arquivo:
    conteudo = arquivo.read()
    print(conteudo)
    

# Lendo o arquivo linha por linha:
with open("exemplo.txt", "r") as arquivo:
    for indice, linha in enumerate(arquivo):
        print(f"Linha: {indice} -> {linha.strip()}")

TRABALHANDO COM ARQUIVOS

Lendo arquivos: Python oferece várias maneiras de ler o conteúdo de um arquivo:

# Lendo um número específico de caracteres:
with open("exemplo.txt", "r") as arquivo:
    print(arquivo.read(2))  # Lê os dois primeiros caracteres do arquivo      


# Lendo todas as linhas em uma lista
with open("exemplo.txt", "r") as arquivo:
    linhas = arquivo.readlines()
    print(linhas)
    print([linha.strip() for linha in linhas]) # Aqui estamos removendo as quebras de linhas (\n) do arquivo

TRABALHANDO COM ARQUIVOS

Escrevendo arquivos: Para escrever em um arquivo, você pode usar os métodos write() ou writelines(). Lembre-se de que ao abrir um arquivo em modo de escrita ("w"), seu conteúdo será apagado antes da escrita, a menos que você use o modo de anexar ("a").

# Escrevendo uma string em um arquivo:
with open("saida.txt", "w") as arquivo:
    print(arquivo.write("Olá, Meu Primeiro arquivo escrito com Python!\n"))  


# Escrevendo várias linhas
linhas = ["Linha 1\n", "Linha 2\n", "Linha 3\n"]
with open("saida.txt", "w") as arquivo:
    arquivo.writelines(linhas) # Qual o conteúdo do arquivo saída.txt

TRABALHANDO COM ARQUIVOS

Arquivos JSON: JSON (JavaScript Object Notation) é um formato de dados leve e flexível, utilizado para representar informações de forma estruturada e legível para humanos e máquinas. É amplamente utilizado em aplicações web e mobile para a troca de dados entre sistemas, como em APIs.

import json

with open('pessoa.json', 'r') as arquivo:
    data = json.load(arquivo)
    for pessoa in data:
        nome = pessoa["nome"]
        idade = pessoa["idade"]
        cidade = pessoa["cidade"]
        print(f"Nome: {nome}, Idade: {idade}, Cidade: {cidade}")

TRABALHANDO COM ARQUIVOS

Lendo JSON: Abaixo um exemplo de json à direita e como realizar a leitura a esquerda. No exemplo abaixo estamos trabalhando com um JSON existindo uma lista de objetos que representam uma pessoa.

import json

with open('pessoa.json', 'r', encoding='utf-8') as arquivo:
    data = json.load(arquivo)
    for pessoa in data:
        nome = pessoa["nome"]
        idade = pessoa["idade"]
        cidade = pessoa["cidade"]
        print(f"Nome: {nome}, Idade: {idade}, Cidade: {cidade}")

[{
  "nome": "Maria Adenilsa",
  "idade": 30,
  "cidade": "São Paulo"
},
  {
  "nome": "Mario Alberto",
  "idade": 32,
  "cidade": "Manaus"
}]

TRABALHANDO COM ARQUIVOS

Escrevendo JSON:

# Adicionando uma nova pessoa
nova_pessoa = {
    "nome": "Joana Silva",
    "idade": 28,
    "cidade": "Recife"
}
data.append(nova_pessoa)

# Salvando de volta no mesmo arquivo
with open('pessoa.json', 'w', encoding='utf-8') as arquivo:
    json.dump(pessoas, arquivo, ensure_ascii=False, indent=4)

EXERCÍCIO DE FIXAÇÃO

1. Dado o arquivo de usuarios.txt faça um programa que leia esse arquivo e mostre os dados formatados. Utilize funções de manipulação de strings e crie funções para manipular os dados do arquivo.

Ex. saída:
--------------------- Info Usuários--------------------
Nr: 1 | Usuário: Alexandre
Espaço Utilizado: 430MB | % de Uso: 85%
------------------------------------------------------------
Nr: 2 | Usuário: Raimundo
Espaço Utilizado: 430MB | % de Uso: 85%
------------------------------------------------------------

Alexandre 430 85
Raimundo 430 85
Maria 210 42
José 120 24

EXERCÍCIO DE FIXAÇÃO

2. Leet spek generator. Leet é uma forma de se escrever o alfabeto latino usando outros símbolos em lugar das letras, como números por exemplo. A própria palavra leet admite muitas variações, como l33t ou 1337. O uso do leet reflete uma subcultura relacionada ao mundo dos jogos de computador e internet, sendo muito usada para confundir os iniciantes e afirmar-se como parte de um grupo. Pesquise sobre as principais formas de traduzir as letras. Depois, faça um programa que peça um texto e transforme-o para a grafia leet speak.

dict_leet = { 'a': '4', 'b': '8', 'c': '(', 'd': '|)', 'e': '3', 'f': '|=', 'g': '6', 'h': '#', 'i': '1', 'j': '_|', 'k': '|<', 'l': '1', 'm': '|v|', 'n': '|\|', 'o': '0', 'p': '|>', 'q': '0_', 'r': '|2', 's': '5', 't': '7', 'u': '|_|', 'v': '\/', 'w': '\/\/', 'x': '><', 'y': '`/', 'z': '2' }

ORIENTAÇÃO A OBJETOS

Orientação a Objetos (OO) é um paradigma de programação que organiza o software em torno de objetos, que são instâncias de classes. Esses objetos encapsulam dados (atributos) e comportamentos (métodos), permitindo a criação de programas que são mais modularizados, reutilizáveis e fáceis de manter.

ORIENTAÇÃO A OBJETOS

Python suporta completamente a programação orientada a objetos e oferece várias funcionalidades que tornam o desenvolvimento OO fácil e intuitivo.