Untitled

Avisos

Este notebook contém exemplos utilizados nos
livros Python do ZERO à Programação Orientada a Objetos,
Tópicos Avançados em Python e Tópicos Especiais em
Python, de autoria de Fernando Feltrin, além de exemplos
praticados no curso Python do ZERO ministrado na
plataforma Udemy pelo mesmo. Para todo referencial teórico
dos tópicos abordados, assim como as devidas explicações
para cada linha de código, consultar os livros.
Para melhor aproveitamento do conteúdo
apresentado neste material, é recomendável noções de
lógica de programação.

Este livro conta com mecanismo anti pirataria
Amazon Kindle Protect DRM. Cada cópia possui um
identificador próprio rastreável, a distribuição ilegal deste
conteúdo resultará nas medidas legais cabíveis.

É permitido o uso de trechos do conteúdo para uso
como fonte desde que dados os devidos créditos ao autor.

Livro em processo de revisão, em conta de
incompatibilidades com a plataforma Kindle, novos
conteúdos serão adicionados assim que a diagramação do
livro esteja compatível com todos dispositivos.

Sobre o Autor

Fernando Feltrin é Engenheiro da Computação com

especializações na área de ciência de dados e inteligência
artificial, Professor licenciado para docência de nível técnico
e superior, Autor de mais de 10 livros sobre programação de
computadores e responsável pelo desenvolvimento e
implementação de ferramentas voltadas a modelos de redes
neurais artificiais aplicadas à radiologia (diagnóstico por
imagem).

Livros

Python do ZERO à Programação Orientada a Objetos
Programação Orientada a Objetos com Python
Ciência de Dados e Aprendizado de Máquina
Inteligência Artificial com Python
Redes Neurais Artificiais com Python
Análise Financeira com Python
Arrays com Python + Numpy
Tópicos Avançados em Python
Visão Computacional em Python
Python na Prática (Exercícios resolvidos e comentados)
Tópicos Especiais em Python vol. 1
Tópicos Especiais em Python vol. 2
Blockchain e Criptomoedas em Python
Coletânea Tópicos Especiais em Python
Python na Prática (Códigos comentados)
PYTHON TOTAL (Coletânea de 12 livros)

Índice
Sumário
Avisos
Sobre o Autor
Livros
Índice
Sintaxe Básica em Python
Declaração de Variáveis
Sintaxe básica, leitura léxica e indentação
Estrutura básica de um programa
Olá Mundo!!! em Java
Olá Mundo!!! em C#
Olá Mundo!!! Em Python
Linguagens de Alto Nível Vs Linguagens de Baixo Nível
Olá Mundo!!! em Assembly
Tipos de Dados Básicos
Int – Número inteiro
Float – Número com casas decimais
String – Texto composto de qualquer caractere
alfanumérico
Tupla – Conjunto de elementos imutável
List – Listas – Conjunto de elementos indexados e
mutáveis
Dict – Dicionários – Estrutura de dados baseada em ‘chave
: valor’
Bool – Booleano (True ou False)
Comentários
Comentário simples de até uma linha
Comentários sem limite de extensão
Comentando uma variável para desabilitar a mesma
Variáveis
Tipos de variáveis
Declarando uma variável quanto ao seu tipo
Declarando múltiplas variáveis por justaposição
Declarando múltiplas variáveis de mesmo tipo e dado
Operações entre variáveis
Interações entre variáveis
Sintaxe usual permitida
Sintaxe não permitida / não recomendada
Palavras reservadas ao sistema
Variáveis globais Vs variáveis locais
Declarando variáveis de forma reduzida
Tornando números extensos visualmente melhor legíveis
Funções Básicas
Função de saída print( )
Exibindo em tela o conteúdo de uma variável
Operações aritméticas diretamente dentro da função print(
)
Operações entre dados/valores declarados e
dados/valores atribuídos
Operações lógicas diretamente dentro da função print( )
f'Strings e máscaras de substituição dentro da função print(
)
Operadores aritméticos dentro de máscaras de
substituição
Operadores lógicos dentro de máscaras de substituição
Sintaxe antiga Vs sintaxe atual moderna
Função de entrada input( )
Operadores Aritméticos
Soma
Subtração
Multiplicação
Divisão
Mais de uma operação simples
Operação matemática composta
Potenciação
Divisão exata
Módulo/resto de uma divisão
Operadores de Atribuição
Operador “ = “
Atribuição aditiva
Atribuição subtrativa
Atribuição multiplicativa
Atribuição divisiva
Atribuição de módulo/resto de divisão
Atribuição divisiva inteira
Atribuição exponenciativa
Arredondamento de casas decimais
Operadores Lógicos
Operador de igualdade
Operador de diferença
Operadores Lógicos Compostos
Operador or
Operador and
Operador is
Operadores de Membro
Operador in
Operador not in
Operadores Relacionais
Maior que
Igual ou maior que
Menor ou igual a
Condicionais lógicas compostas
Operadores em estruturas condicionais
Operadores de Identidade
Operador is
Estruturas Condicionais
if – Estrutura condicional simples
if, else – Estrutura condicional com dois possíveis
desfechos
Estrutura condicional composta
if, elif, else – Estruturas condicionais aninhadas
Duas ou mais condições sendo verdadeiras
Operações dentro de estruturas condicionais
Estruturas condicionais com interpolação / máscaras de
substituição
Operações dentro de estruturas condicionais compostas
Estruturas condicionais com validação simples (em string)
Estrutura condicional composta com operadores or e and
Estruturas de Repetição
While
Estruturas de repetição com validação
Estruturas condicionais dentro de laços de repetição
while True
Laço for
Laço for percorrendo cada elemento de uma string
Laço for repetindo ciclo dentro de um intervalo numérico
específico
Laço de repetição que atualiza o dado/valor de uma
variável
Desempacotando os elementos de uma lista via laço de
repetição
Laço de repetição que desempacota e separa os itens de
um dicionário
Laço for contando de 2 em 2 elementos
Contagem regressiva via laço for
Realizando contagem com base em número digitado pelo
usuário
Laço de repetição com múltiplos parâmetros de múltiplas
variáveis
Usando de alternativas quando o laço for não for eficiente
Função enumerate( )
Strings
Sintaxe básica
Contando quantos caracteres compõe uma string
Contando caracteres de uma string, desconsiderando os
espaços
Substituindo elementos de uma string
Contando quantos de um tipo específico de caractere
estão na string
Exibindo a posição de índice de um determinado elemento
da string
Realizando a leitura de um caractere pelo seu número de
índice
Desmembrando uma string, separando cada palavra da
frase
Extraindo dados de uma string especificando um intervalo
de índice
Concatenando strings por meio de variáveis
Concatenando diferentes tipos de dados em uma string
Operadores lógicos em uma string
Letras maiúsculas ou minúsculas em uma string
Convertendo outro tipo de dado para string
Removendo espaços desnecessários do início de uma
string
Convertendo todas as iniciais das palavras para maiúsculo,
como em um título
Verificando se uma string é composta por letras e/ou por
números
Adicionando espaços antes e depois de uma string
Particularidades envolvendo o tamanho de uma string
Tratando os espaços desnecessários de uma string
Reposicionando elementos de uma string
Resumo de todos métodos inclusos nos built-ins
Listas
Criando uma lista simples
Descobrindo o elemento de uma lista através de seu
número de índice
Descobrindo o número de índice de um determinado
elemento
Descobrindo o número total de elementos de uma lista
Adicionando um novo elemento na lista por justaposição
Adicionando um novo elemento na lista em uma posição
específica
Adicionando um novo elemento na lista em uma posição
específica via função insert( )
Removendo um elemento de uma lista via função pop( )
Removendo um elemento de uma lista via função remove(
)
Ordenando os elementos de uma lista
Invertendo a ordem dos elementos de uma lista via
reversed( )
Ordenando elementos de uma lista composta de
caracteres alfanuméricos
Listas dentro de listas
Concatenando listas
Unindo listas
Fatiando elementos de uma lista
Conjuntos Numéricos
Criando um conjunto numérico (set)
Operações entre conjuntos numéricos
União de conjuntos numéricos
Interseção de dois conjuntos
Diferença entre dois conjuntos
Diferença entre conjuntos associados à variáveis
Operadores lógicos em conjuntos numéricos
Reiniciando um conjunto
Validações aplicadas a elementos de dois conjuntos
Pilhas
Adicionando elementos a uma pilha
Removendo elementos de uma pilha
Interpolação
Uso de máscaras de substituição
Operações dentro de máscaras de substituição
Dicionários
Sinxata básica
Adicionando novos itens ao dicionário
Alterando o valor de uma chave
Acessando um determinado elemento do dicionário
Usando o construtor de dicionários
Transformando listas em chaves/valores de um dicionário
Consultando apenas as chaves de um dicionário
Consultando apenas os valores de um dicionário
Verificando se uma chave/valor consta no dicionário
Pesquisando se um dado/valor consta em uma chave
Pesquisando se um dado/valor consta em um valor
Pesquisando de o dado/valor de um dicionário é o
dado/valor esperado
Atualizando um elemento do dicionário
Removendo um elemento do dicionário
Pesquisando o tamanho de um dicionário (de quantos itens
ele é composto)
Exibindo em tela somente as chaves e somente os valores
de um dicionário
Lendo as chaves/valores de um dicionário por meio do laço
for
Listas como valores de uma chave do dicionário
Transformando chaves ou valores de um dicionário em
tupla
Dicionários dentro de dicionários
Removendo elementos de um dicionário por meio da
função pop( )
Removendo elementos de um dicionário por meio da
função do sistema del
Criando um dicionário, sendo suas chaves importadas de
uma lista e seus valores definidos manualmente
Usando do método get( ) para não gerar exceções quando
um elemento inspecionado não fizer parte do dicionário
Descobrindo a hash de um valor
Resumo de todos os métodos inclusos nos built-ins
Funções
Sintaxe básica
Definindo uma função sem parâmetros
Chamando uma função
Instanciando uma função (função associada a uma
variável)
Criando uma função que temporariamente não realiza
nenhuma ação
Função interagindo com variável que interage com o
usuário
Parametrizando uma função
Instanciando e parametrizando uma função
Repassando mais de um parâmetro para função
Definindo parâmetros “padrão”
Repassando apenas um parâmetro, recebendo os demais
padrão
Passando parâmetro e interagindo com o usuário
Repassando um parâmetro manualmente fora da ordem de
justaposição
Realizando operações dentro de uma função
Realizando operações compostas dentro de uma função
Estruturas condicionais dentro de funções
*args – Função com argumentos externos
Desempacotando uma lista para que seus elementos virem
argumentos da função
Função com parâmetros baseados em *args e **kwargs
Função que recebe outra função como parâmetro
Função que recebe um tipo de dado como parâmetro, e
retorna outro tipo de dado pré-definido
Escopo Global Vs Escopo Local
Modificando uma variável global de dentro de uma função
Sets (Conjuntos)
Sintaxe básica
Criando um set via construtor
Adicionando/removendo elementos de um set
Convertendo lista para set para que sejam removidos os
elementos duplicados
Bool
Tipo de dado booleano
List Comprehension
Operações com elementos de uma lista usando
comprehension
Desmembrando uma string elemento por elemento
Extraindo partes de uma string
Trabalhando com partes de uma string
Otimizando um código mudando sua função por uma
comprehension
Dictionary Comprehension
Realizando operações dentro de um dicionário via
comprehension
Geradores e Iteradores
Gerando valores como alternativa para otimizar o código
Zip
Iterando e unindo listas via zip( )
Zip_longest para iterar e unir listas de diferentes tamanhos
Count
Usando do contador do sistema
Contando dentro de um intervalo personalizado
Personalizando de quantos em quantos números o
contador irá trabalhar
Map
Aplicando uma função em cada elemento, ou linha por
linha de uma lista/dicionário
Usando map( ) para extrair dados de um dicionário
Usando uma função ativa no lugar da lambda
Filter
Aplicando funções sobre dados usando de lógica
condicional
Reduce
Try, Except
Tratando exceções para que não se interrompa a execução
de um programa
Exibindo em tela que erro específico ocorreu
Asserções
Bibliotecas, Módulos e Pacotes
Função dir( ) exibe quais bibliotecas e módulos foram
carregados por padrão
Explorando tudo o que vem importado por padrão
Importando bibliotecas, módulos e pacotes que por padrão
não são carregados na inicialização do núcleo Python
Verificando tudo o que existe dentro de um módulo/pacote
externo
Explorando as funcionalidades de uma biblioteca, módulo
ou pacote
Usando funções de um módulo, pacote externo
Abreviando a nomenclatura de um módulo
Importando apenas uma função específica de um módulo
Criando módulos manualmente
Empacotamento e Desempacotamento
Empacotamento
Desempacotamento
Programação Orientada a Objetos
Sintaxe básica
Criando uma classe vazia
Criando objetos (atributos de classe) dentro de uma classe
Criando funções (métodos de classe) dentro de uma classe
Criando uma classe com método construtor e objetos
internos
Mais de um método de classe dentro de uma classe
Métodos de classe
Métodos estáticos
@property, Getters e Setters
Atributos de classe
Alterando um atributo de classe
Exemplo de aplicação de orientação à objetos
Encapsulamento
Tipagem de Dados Avançada
%whos
Tipagem dinâmica vs estática
Tipando um dado manualmente
Tipagem manual via gerador de objeto
Tipo esperado e tipo retornado
Definindo manualmente o tipo de dado da variável e de seu
atributo
Duck Typing
Tipagem em Comentário
Tipos de Dados Especiais Para Validações
Tipo Literal
Tipo Union
Tipo Final
Decorador “final”
TypedDict
Protocol
Função print( ) (Avançado)
Quebrando em linhas o conteúdo de uma string parâmetro
da função print( )
Exibindo em tela uma mensagem colorida
Exibindo em tela o nome e o conteúdo de uma variável
f'Strings (Avançado)
f'String como atributo de uma variável
Operações matemáticas especiais diretamente na máscara
de substituição
Saída de múltiplas linhas via print( ) + f’strings
f'String chamando função do corpo do código
f'String como retorno de um método mágico
Funções (Avançado)
Parâmetros em justaposição e parâmetros nomeados
Função com número de parâmetros indefinido
Função com número de parâmetros indefinido, porém
nomeados
Função que recebe parâmetros tanto por justaposição
quanto nomeados
Empacotamento e desempacotamento
Funções aninhadas
Parâmetro/argumento somente posicional
Parâmetro/argumento obrigatoriamente nomeado
Funções em Python são objetos
Closures
Decoradores
Sys.argv
Recursividade
Dicionários (Avançado)
Dicionário ordenado
DefaultDict
Expressões Regulares
r'Strings
r'Strings e metacaracteres
Alterando o comportamento de uma expressão regular via
flags
Metacaracteres quantificadores
Metacaracteres aplicados a um intervalo de caracteres de
uma expressão regular
Substituindo um elemento de uma string via expressão
regular
Buscando uma string específica no início de uma sentença
Separando uma string em partes
Números Avançados
Números complexos
Criando um número complexo via construtor
String como argumento
Binário
Hexadecimal
Um número elevado a outro número
Valor absoluto de um número
NaN
Infinity
List Comprehension (Avançado)
Gerando uma nova lista via comprehension
Desmembrando uma string elemento por elemento
Desmembrando uma string dentro de um intervalo de
índice
Separando a string de n em n números
Realizando o fatiamento da string
Otimizando código via list comprehension
Combinando diferentes métodos em comprehension
Frequência de um elemento de uma lista
Expressões Ternárias
Expressão ternária aplicada à função print( )
Any e All
any( )
all( )
Operador Walrus
Sintaxe básica
Geradores e Iteradores (Avançado)
Gerando valores onde não existe para poupar tempo e
codificação
Yeld
Map, Filter, Reduce + Comprehension
Método convencional para extração de dados
Extraindo dados via map( ) + função lambda
Extraindo dados via list comprehension
Extraindo dados via filter( )
Combinando filter( ) e list comprehension
Combinando map( ) e filter( ) para extração de dados
Extraindo dados via reduce( )
Extraindo dados via reduce( ) + list comprehension
Extraindo dados via reduce( ) ( método otimizado)
Try, Except, Finally, Raise (Avançado)
Tratando exceções
Except genérico
Exibindo o erro específico
Try e except como condicional, servindo para prever
exceções geradas pelo usuário
Finally
Raise
If __name__ == (‘__main__’)
Módulos Nativos do Python
Datetime
Datetime como string
Convertendo uma string em datetime
Substituindo um valor de datetime
Diferença entre dois datetimes
Combinações, Permutações e Produto (Itertools)
Combinações
Permutações
Product
Combinations with replacement
Accumulate
GroupBy
Repeat
Expressões Lambda
Tópicos Avançados em POO
Associação de classes
Agregação e composição de classes
Herança simples
Cadeia de heranças
Herança múltipla
Sobreposição de membros
Sobreposição via super( )
Classes abstratas
Polimorfismo
Sobrecarga de operadores
Gerenciamento de Filas
Gerenciamento de filas via nodes
Gerenciamento de filas via deque
Docstrings
Docstrings de bibliotecas/módulos de terceiros
Criando uma docstring personalizada
Citações
Citações dentro de strings
Built-ins / Métodos Genéricos
abs( )
ascii( )
bytes( )
callable( )
eval( )
exec( )
format( )
id( )
iter( )
open( )
slice( )
Contêineres de Dados
Desempacotando e iterando sobre contêineres
Migrando dados de contêineres
Threads
Método sequencial regular
Threads paralelas
Single-thread Vs multi-thread
GIL – Python global interpreter lock
Gerenciamento de Memória
Memória stack e memória heap
Contagem de referência
Verificando o tempo de execução de um código
Banco de Dados
Criando uma conexão / SQLite3
Criando uma conexão / MySQL
Criando uma conexão persistente / MySQL
Visualizando bancos de dados existentes
Criando uma tabela com campos personalizados
diretamente via cursor
importados de variáveis
Inserindo dados/registros na base
Inserindo dados/registros da base através de *args
Alterando dados
Atualizando dados
Excluindo registros existentes
Visualizando o conteúdo da base de dados
Buscando um registro específico
Listando tabelas existentes
Excluindo uma tabela
Encerrando os trabalhos na base de dados

Sintaxe Básica em Python

Declaração de Variáveis
# nome_da_variavel = dado/valor/atributo

numero = 20
# Nome da variável: numero
# Dado/valor atribuído: 20

nome = 'Veronica'

variavel = [21, 'Maria', 19.90]

print(numero)
# Exibe em tela o conteúdo da variável numero

print(nome)
print(variavel)

20
Veronica
[21, 'Maria', 19.9]

Sintaxe básica, leitura léxica e indentação
dicionario = {'Nome':'Fernando',
'Idade':33,
'Formação':'Eng. da Computação'}

print(dicionario)

# Por leitura léxica entenda que o interpretador lê o código sequenci
almente,de cima para baixo, da esquerda para direita, levando em c
onta os espaços e tabulações aplicadas ao código (indentação).

{'Nome': 'Fernando', 'Idade': 33, 'Formação': 'Eng. da Computação'}

Estrutura básica de um programa

Olá Mundo!!! em Java
class MeuPrograma {
public static void main(String args[]) {
System.out.println("Olá Mundo!!!");
}
}

Olá Mundo!!!

Olá Mundo!!! em C#
using System;
namespace MeuPrograma {
class OlaMundo {
static void Main(string[] args) {
Console.WriteLine("Olá Mundo!!!");
Console.ReadKey();
}
}
}

Olá Mundo!!!

print('Olá Mundo!!!')

Olá Mundo!!!

Linguagens de Alto Nível Vs Linguagens
de Baixo Nível

Olá Mundo!!! em Assembly
section .text
global _start

_start:

mov edx,len
mov ecx,msg
mov ebx,1
mov eax,4
int 0x80

mov eax,1
int 0x80

section .data

msg db 'Olá Mundo!!!',0xa
len equ $ - msg

print('Olá Mundo!!!')

Olá Mundo!!!

Tipos de Dados Básicos

Int – Número inteiro
num1 = 12

num2 = int(15)

print(num1)
# Exibe em tela o conteúdo da variável num1

print(type(num1))
# Exibe em tela o tipo de dado da variável num1

print(num2)
print(type(num2))

12
<class 'int'>
15
<class 'int'>

num1 = 12
# Será automaticamente identificado pelo interpretador como dado d
o tipo int

num2 = int(15)
# Será manualmente identificado pelo interpretador como dado do ti
po int

num3 = str(15)
# Será manualmente identificado pelo interpretador como dado do ti
po string

print(type(num1))
print(type(num2))
print(type(num3))

<class 'int'>
<class 'int'>
<class 'str'>

Float – Número com casas decimais
num3 = 12.8
# Ao inserir o ponto demarcador de casa decimal, tal número será
# automaticamente reconhecido pelo interpretador como tipo float

num4 = float(19.0)

print(num3)
print(type(num3))

print(num4)
print(type(num4))

12.8
<class 'float'>
19.0
<class 'float'>

String – Texto composto de qualquer caractere
alfanumérico
palavra1 = 'palavra'
# Todo conteúdo contido entre aspas é lido como texto pelo interpret
ador

palavra2 = "marca d'água"
# Uso de aspas duplas para não gerar conflito com o apóstrofo '

frase1 = 'Uma frase qualquer'

frase3 = 'Ela tinha 8 anos'

frase3 = str('Outra frase qualquer')

print(palavra1)
print(palavra2)

print(frase3)
print(type(frase3))

palavra
marca d'água
Outra frase qualquer
<class 'str'>

codigo1 = '887237'
# Apesar de composto apenas por números, o atributo da variável c
odigo1 por
# conta de sua sintaxe é um texto, tipo de dado string

print(codigo1)
print(type(codigo1))

887237
<class 'str'>

Tupla – Conjunto de elementos imutável
# Método simples para guardar mais de um dado/valor atribuído a u
ma variável.

tupla = ('Ana', 'Fernando', 3, 19.90)
# Cada elemento declarado conforme sua sintaxe.

print(tupla)
print(type(tupla))

('Ana', 'Fernando', 3, 19.9)
<class 'tuple'>

List – Listas – Conjunto de elementos indexados
e mutáveis
# Basicamente o mesmo tipo de dado array de outras linguagens de
programação.

lista = [2, 'Pedro', 15.9]
# Cada elemento possui um número de índice, começando em 0.

lista2 = list([1, 'Maria', 19.99])

print(lista)
print(type(lista))

print(lista2)

[2, 'Pedro', 15.9]
<class 'list'>
[1, 'Maria', 19.99]

lista_compras = ['Arroz',
'Açúcar',
'Café',
'Carne',
'Frutas',
'Pão',
'Sabão em pó']
# Apenas por organização, os elementos de uma lista podem ser org
anizados
# em linhas separadas, desde que mantenham a indentação

print(lista_compras)

['Arroz', 'Açúcar', 'Café', 'Carne', 'Frutas', 'Pão', 'Sabão em pó']

Dict – Dicionários – Estrutura de dados baseada
em ‘chave : valor’
dicionario = {'Nome':'Fernando', 'Idade':32}
# Na primeira entrada, 'Nome' é a chave e 'Fernando' é o valor.

print(dicionario)
print(type(dicionario))

{'Nome': 'Fernando', 'Idade': 32}
<class 'dict'>

dicionario = {'Nome':'Fernando',
'Idade': 32,
'Altura': 1.90,
'Peso': '120kg'}
# Por uma questão de organização, os itens de um dicionário podem
# ser dispostos em linhas independentes, desde que respeitando a
# indentação.

print(dicionario)

{'Nome': 'Fernando', 'Idade': 32, 'Altura': 1.9, 'Peso': '120kg'}

Bool – Booleano (True ou False)
condicao1 = True
# Tipo de dado usado em expressões/proposições lógicas, onde o re
torno é True
# ou False, referente a Verdadeiro ou Falso, válido ou inválido, ligad
o ou
# desligado, etc... de acordo com a proposição.

print(condicao1)
print(type(condicao1))

True
<class 'bool'>

Comentários

Comentário simples de até uma linha
# Comentário simples de até uma linha.

# Embora possa acarretar perda de performance
# para o código, é perfeitamente possível comentar
# linha por linha individualmente.

Comentários sem limite de extensão
'''Comentário onde não há limite de linhas,
podendo ser usado para descrever blocos
de código mais detalhadamente'''

Comentando uma variável para desabilitar a
mesma
usuario1 = 'Fernando' # Visível para o interpretador.

#usuario1 = 'Fernando' # Invisível para o interpretador, ignorada.

Variáveis

Tipos de variáveis
var_int = 12
# Número inteiro

var_float = 15.3
# Número com casas decimais

var_string = 'Conjunto de caracteres alfanuméricos'
# Incluindo símbolos, caracteres e/ou algarismos especiais

var_lista = [1, 2, 'Paulo', 'Maria', True]
# Lista de dados/valores

var_dicionario = {'nome':'Fernando', 'idade':31}
# Conjunto de dados:valores

var_tupla = ('Ana', 'Fernando', 3)
# Lista de dados/valores porém imutável

var_set = {1999, 2000, 2001, 2002, 2003, 2004, 2005}
# Conjunto de dados numéricos

var_bool = True
# Booleano / Binário (0 ou 1)

var_comentario = """Um comentário atribuído a uma
variável deixa de ser apenas
um comentário, vira um texto
que pode ser incorporado ao
código..."""

# Os tipos de variáveis como listas, tuplas, dicionários, etc comporta
m
# múltiplos dados em sua composição, suportando dados de qualqu
er tipo.

# Exibindo os conteúdos das variáveis declaradas anteriormente

print(var_int)

print(var_float)

print(var_string)

print(var_lista)

print(var_dicionario)

print(var_tupla)

print(var_set)

print(var_bool)

print(var_comentario)

12
15.3
Conjunto de caracteres alfanuméricos
[1, 2, 'Paulo', 'Maria', True]
{'nome': 'Fernando', 'idade': 31}
('Ana', 'Fernando', 3)
{1999, 2000, 2001, 2002, 2003, 2004, 2005}
True
Um comentário atribuído a uma
variável deixa de ser apenas
um comentário, vira um texto
que pode ser incorporado ao
código...

# Exibindo os tipos de dados das variáveis declaradas anteriormente

print(type(var_int))

print(type(var_float))

print(type(var_string))

print(type(var_lista))

print(type(var_dicionario))

print(type(var_tupla))

print(type(var_set))

print(type(var_bool))

print(type(var_comentario))

<class 'int'>
<class 'float'>
<class 'str'>
<class 'list'>
<class 'dict'>
<class 'tuple'>
<class 'set'>
<class 'bool'>
<class 'str'>

Declarando uma variável quanto ao seu tipo
ano_nasc = 1987
# Automaticamente será identificado como do tipo int

ano_nasc2 = '1987'
# Automaticamente será identificado como do tipo string

ano_nasc = int(1987)
# Tipo de dado definido manualmente como int, usando do construto
r do objeto

ano_nasc2 = str(1987)

print(ano_nasc)
print(type(ano_nasc))

print(ano_nasc2)
print(type(ano_nasc2))

1987
<class 'int'>
1987
<class 'str'>

Declarando múltiplas variáveis por justaposição
nome, idade, sexo = 'Maria', 32, 'F'

# Primeira variável "nome" receberá o primeiro atributo "'Maria'", seg
unda
# variável "idade" receberá o segundo atributo "32", e assim por dian
te...
# Esse processo se chama declaração por justaposição.

'''
Mesmo que:

nome = 'Maria'
idade = 32
sexo = 'F'

mas em forma reduzida.
'''

print(nome)
print(idade)
print(sexo)

print(nome, idade, sexo)

Maria
32
F
Maria 32 F

Declarando múltiplas variáveis de mesmo tipo e
dado
num2 = x = a1 = 10

# Como as 3 variáveis (num2, x e a1) possuem o mesmo atributo (1
0), podemos
dizer que são iguais entre si, pois possuem o mesmo atributo.

'''
Mesmo que:

num2 = 10
x = 10
a1 = 10
'''

print(num2)
print(x)
print(a1)

10
10
10

Operações entre variáveis
a = 10
b = 5.2

print(a + b)
# Soma simples dos conteúdos das variáveis a e b

15.2

Interações entre variáveis
msg = 'Olá '
pessoa = 'Carlos'

print(msg + pessoa)
# Concatenação dos conteúdos das variáveis msg e pessoa pois am
bas são strings

Olá Carlos

Sintaxe usual permitida
nome = 'Fernando'

nome2 = 'Fernando'

nome_de_variavel = 'Fernando'

Sintaxe não permitida / não recomendada
# Formas de declarar uma variável que podem gerar erros de interpr
etação

Nome Nome de variável iniciando em letra maiúscula

NOME Nome de variável escrita totalmente em letras maiús
culas*

8dados Nome de variável iniciando com números

_numero Nome de variável iniciando com caractere especial

minha variavel Nome de variável com espaços

número = 12345 Nome de variável contendo acentos

(variavel2) Nome de variável encapsulado em chaves, parêntese
s ou colchetes

# *Uma variável com nome escrito com letras totalmente maiúsculas
por
# convenção pode ser tratado como uma constante, embora em Pyt
hon não
# existam constantes.

Palavras reservadas ao sistema
# Palavras que não podem ser usadas como nome de variáveis, fun
ções, classes, etc...

and del from not while

as elif global or with

assert else if pass yield

break except import print

class exec in raise

continue finally is return

def for lambda try

# Palavras reservadas ao sistema são marcadores para que o interp
retador da
# linguagem identifique estruturas de código padrão, expressões qu
e em geral
# estão associadas a possíveis ações a serem realizadas pelo códig
o.
# Por exemplo "while" é a palavra-
chave para uma estrutura de repetição.

Variáveis globais Vs variáveis locais
num1 = 19
# Escopo global, visível e iterável por qualquer estrutura do corpo do
código.

if num1 > 100:
novo_num = num1
# novo_num é acessível e iterável apenas dentro desse bloco de c
ódigo.
print(novo_num)

Declarando variáveis de forma reduzida
# Código usual, prezando pela legibilidade do mesmo

nome = 'Maria'
idade = 29

print(f'{nome} tem {idade} anos!!!')

Maria tem 29 anos!!!

# Código reduzido

nome = 'Maria'; idade = 29; print(f'{nome} tem {idade} anos!!!')

# Uso do separador " ; " para incluir na mesma linha várias
# declarações/expressões, quando necessário.

Maria tem 29 anos!!!

Tornando números extensos visualmente melhor
legíveis
num1 = 1000000000000000000
# Difícil de identificar

num1 = 1_000_000_000_000_000_000
# Melhor identificável, um quintilhão
# O marcador " _ " não afeta a leitura do valor

print(num1)

1000000000000000000

# Tornando o marcador visível no retorno

num1 = 1_000_000_000_000_000_000

print(f'{num1:,}')

1,000,000,000,000,000,000

Funções Básicas

Função de saída print( )
# Exibe em tela ou em terminal algo para o usuário

print('Seja Bem-Vindo!!!')

Seja Bem-Vindo!!!

Exibindo em tela o conteúdo de uma variável
nome = 'Fernando'

print('Fernando')
# Exibindo diretamente a string 'Fernando'

print(nome)
# Exibindo o conteúdo da variável nome, nesse caso, 'Fernando'

Fernando
Fernando

Operações aritméticas diretamente dentro da
função print( )
print(15 + 4)
# 15 mais 4

print(15 - 4)
# 15 menos 4

print(15 * 4)
# 15 vezes 4

print(15 / 4)
# 15 dividido por 4

# O resultado será exibido normalmente, porém, a função print( ) ap
enas exibe
# em tela o resultado, o mesmo não ficará salvo, a menos que estej
a associado
# a uma variável.

19
11
60
3.75

Operações entre dados/valores declarados e
dados/valores atribuídos
numero3 = 30

print('O resultado da soma é: ', numero3 + 15)
# Mesmo que: print('O resultado da soma é: 30 + 15')

O resultado da soma é: 45

Operações lógicas diretamente dentro da função
print( )
numero = 9

print(numero > 3)
# o conteúdo da variável numero (9) é maior que 3?

print(numero < 10)
# 9 é menor que 10?

print(numero == 11)
# 9 é igual a 11?

print(numero >= 12)
# 9 é igual ou maior que 12?

True
True
False
False

f'Strings e máscaras de substituição dentro da
função print( )
nome = 'Fernando'

print(f'Seja muito bem-vindo {nome}!!!')
# Dentro da máscara { } será instanciado o conteúdo da variável no
me.

Seja muito bem-vindo Fernando!!!

Operadores aritméticos dentro de máscaras de
substituição
camisa = 19.90
calca = 39.90

print(f'A soma dos produtos do carrinho é: {camisa + calca}')
# Dentro da máscara { } serão somados os conteúdos das variáveis
camisa e calca

A soma dos produtos do carrinho é: 59.8

Operadores lógicos dentro de máscaras de
substituição
altura = 29
largura = 12

print(f'A altura do prédio é maior que sua largura? {altura > largura}')
# Dentro da máscara { } será validada a expressão lógica "o valor de
altura é
# maior que o valor de largura?"

A altura do prédio é maior que sua largura? True

Sintaxe antiga Vs sintaxe atual moderna
nome = 'Maria'

# Sintaxe funcional básica // Defasada
print('Bem-vindo', nome,'!!!')

# Sintaxe funcional // Defasada
print('Bem-vindo' + ' ' + nome + ' ' '!!!')

# Sintaxe antiga // Defasada
print('Bem-vindo %s !!!'%nome)

# Sintaxe usual // Defasada
print('Bem-vindo {} !!!'.format(nome))

# Sintaxe moderna atual
print(f'Bem-vindo {nome} !!!')

# Apesar da evolução da linguagem, é perfeitamente possível
# usar da sintaxe antiga de acordo com sua preferência.

Bem-vindo Maria !!!
Bem-vindo Maria !!!
Bem-vindo Maria !!!
Bem-vindo Maria !!!
Bem-vindo Maria !!!

Função de entrada input( )
nome = input('Digite o seu nome: ')

print(nome)

# Função de entrada, interage com o usuário fazendo com que o me
smo
# insira dados. Esta função por sua vez deve ser associada a uma v
ariável.
# A mesma só termina sua função no momento que o usuário aperta
o botão ENTER.

Digite o seu nome: Fernando
Fernando


print(f'Bem-vindo {nome} !!!')

# É pedido ao usuário que digite o seu nome, por meio da função in
put( ),
# supondo que o mesmo tenha digitado Alberto, esse dado fica atrib
uído à
# variável nome. Em seguida, o conteúdo da variável nome é instan
ciado na
# máscara de sibstituição { } inserida na função print( ).

Bem-vindo Fernando !!!

Operadores Aritméticos

Soma
print(5 + 7)

12

Subtração
print(12 - 3)

9

Multiplicação
print(5 * 7)

35

Divisão
print(120 / 6)

20.0

Mais de uma operação simples
print(5 + 2 * 7)

19

Operação matemática composta
print((5 + 2) * 7)
# Primeiro será realizada a operação dentro dos parênteses, posteri
ormente o resto.

49

Potenciação
print(3 ** 5)
# 3 elevado a 5ª potência

243

Divisão exata
print(9.4 // 3)

3.0

Módulo/resto de uma divisão
print(10 % 3)

1

Operadores de Atribuição

Operador “ = “
nome = 'Fernando'
# = atribui um dado/valor a uma variável

idade = 33

# Símbolo " = " quando usado uma vez é um operador de atribuição,
# quando usado duas vezes " == " é um operador de igualdade.

print(nome)
print(idade)

Fernando
33

Atribuição aditiva
valor = 4

valor += 5

'''
Mesmo que:
valor = valor + 5
'''

print(valor)

9

Atribuição subtrativa
valor = 4

valor -= 3

'''
Mesmo que:
valor = valor - 3
'''

print(valor)

1

Atribuição multiplicativa
valor = 4

valor *= 3

'''
Mesmo que:
valor = valor * 3
'''

print(valor)

12

Atribuição divisiva
valor = 12

valor /= 2

'''
Mesmo que:
valor = valor / 2
'''

print(valor)

6.0

Atribuição de módulo/resto de divisão
valor = 12

valor %= 2

'''
Mesmo que:
valor = valor % 4
'''

print(valor)

0

Atribuição divisiva inteira
valor = 512

valor //= 256

'''
Mesmo que:
valor = valor // 256
'''

print(valor)

2

Atribuição exponenciativa
valor = 4

valor **= 8

'''
Mesmo que:
valor = valor ** 8
ou
valor = 4 * 4 * 4 * 4 * 4 * 4 * 4 * 4
'''

print(valor)

65536

Arredondamento de casas decimais
equacao = ((50 + 25) * 7.2) / 3.8

print(f'O resultado bruto da equação é: {equacao}')

print(f'O resultado arredondado da equação é: {equacao:.2f}')
# :.2f define quantas casas decimais serão exibidas após a vírgula

print(f'O resultado arredondado da equação é: {round(equacao, 2)}')
# Função round() parametrizada com a expressão e em seguida co
m o número de casas após a vírgula

O resultado bruto da equação é: 142.10526315789474
O resultado arredondado da equação é: 142.11
O resultado arredondado da equação é: 142.11

Operadores Lógicos

Operador de igualdade
print(5 == 6)
# 5 é igual a 6?

print(12 == 12)

False
True

Operador de diferença
print(7 != 3)
# 7 é diferente de 3?

True

Operadores Lógicos Compostos

Operador or
# Apenas uma proposição precisa ser verdadeira para o retorno ser
True

print(7 != 3 or 2 > 3)
# 7 é diferente de 3 OU 2 é maior que 3?

True

Operador and
# Todas as condições precisam ser verdadeiras para o retorno ser Tr
ue

print(7 != 3 and 2 > 3)
#7 é diferente de 3 E 2 é maior que 3?

False

Operador is
num1 = 4
num2 = 9
num3 = 9

print(num1 == num2)
# o valor de num1 é igual ao valor de num2?

print(num1 is num2)
# o valor de num1 é a mesma coisa que o valor de num2?

print(num2 is 9)
# o valor de num2 é 9?

# Outras expressões dependem de qual contexto serão aplicadas.

False
False
True

Operadores de Membro

Operador in
# Verifica se um elemento é membro daquele tipo de dado

lista = [1, 2, 3, 'Ana', 'Maria']

print(2 in lista)
# 2 está dentro de lista (dentro do conteúdo de lista)?

True

Operador not in
# Verifica se um elemento não faz parte daquele tipo de dado

lista = [1, 2, 3, 'Ana', 'Maria']

print('Maria' not in lista)
# 'Maria' não está em lista (dentro do conteúdo de lista)?

False

Operadores Relacionais

Maior que
idade = 3

print(idade > 4)
# 3 é maior que 4?

False

Igual ou maior que
num1 = 7

print(num1 >= 7)
# 7 é maior ou igual a 3?

True

# Operações entre valores atribuídos a variáveis

x = 2
z = 5

print(x > z)
# O valor de x é maior que o valor de z?

False

Menor ou igual a
y = 7
z = 5

print(z <= y)
# O valor de z é igual ou menor que o valor de y?

True

Condicionais lógicas compostas
x = 2
y = 7

print(x is 2 and y != x)
# O valor de x é 2? E o valor de y é diferente do valor de x?

True

Operadores em estruturas condicionais
idade = 21

if (idade > 18):
print('Idade adulta.')
# se o valor de idade for maior que 18:

Idade adulta.

num1 = 2
num2 = 1

if num1 > num2:
print('2 é maior que 1')
# se o valor de num1 for maior que o valor de num2:

2 é maior que 1

Operadores de Identidade

Operador is
# O valor de uma variável é compatível com outra?

aluguel = 250
energia = 250
agua = 65

print(aluguel is energia)
# (O valor de) aluguel é (o valor de) energia?

print(aluguel is agua)
# (O valor de) aluguel é (o mesmo valor) de agua?

True
False

Estruturas Condicionais

if – Estrutura condicional simples
nome = input('Digite o seu nome:')

if nome == 'Fernando':
print('Bem vindo de volta Fernando!!!')

print(f'Você é novo(a) aqui, olá {nome}!!!')

# Se a condição for atingida, o bloco indentado a ela é
# executado, caso contrario é simplesmente ignorado.

# Também chamadas de estruturas de controle de fluxo.

Digite o seu nome:Fernando
Bem vindo de volta Fernando!!!
Você é novo(a) aqui, olá Fernando!!!

if, else – Estrutura condicional com dois possíveis
desfechos
num = 51

if num < 50:
print('Menor que 50')
else:
print('Maior que 50')

# Se o valor de num for menor que 50, exiba em tela 'Menor que 50',
# caso contrário, exiba em tela 'Maior que 50'.

Maior que 50

Estrutura condicional composta

if nome == 'Maria':
print('Bem vinda de volta Maria!!!')

# Sendo a primeira proposição verdadeira, a execução desse bloco
# de código é encerrada.

Bem vindo de volta Fernando!!!


if nome == 'Maria':

# Quando a primeira proposição não é validada como verdadeira, o
# interpretador irá para a segunda proposição, e assim por diante
# até encontrar uma proposição verdadeira.

Digite o seu nome:Maria
Bem vinda de volta Maria!!!


if nome == 'Carlos':
print('Bem vindo de volta Carlos!!!')
if nome == 'Maria':
if nome == 'Tânia':
print('Bem vinda de volta Tânia!!!')
else:
print('Você não é Fernando nem Maria...')
print(f'Você é novo(a) aqui, olá {nome}!!!')

# Quando nenhuma proposição for verdadeira, é possível por meio
# de else criar um retorno padrão para esses casos.

Digite o seu nome:Maria
Bem vinda de volta Maria!!!
Você não é Fernando nem Maria...
Você é novo(a) aqui, olá Maria!!!

if, elif, else – Estruturas condicionais aninhadas
# Usando elif a partir da segunda proposição, uma proposição send
o verdadeira
# já encerra o processo naquele ponto.

num1 = float(input('Digite um número: '))

if num1 <= 49:
elif num1 == 50:
print('Igual a 50')
elif num1 >= 51 and num1 < 100:
else:
print('Número Inválido')

Digite um número: 68
Maior que 50

num1 = float(input('Digite um número: '))

if num1 <= 49:
elif num1 == 50:
print('Igual a 50')
elif num1 >= 51 and num1 < 100:
else:
print('Número Inválido')

Igual a 50

Duas ou mais condições sendo verdadeiras
nome1 = 'Fernando'
nome2 = 'Maria'

if nome1 == 'Fernando':
print('Bem-vindo Fernando!!!')
if nome2 == 'Maria':
print('Bem-vinda Maria!!!')
else:
print('Erro: Nome Desconhecido.')

# Usando de ifs, mais de uma proposição pode ser considerada verd
adeira,
# nesse caso, retornando Bem-vindo Fernando!!! e Bem-
vinda Maria!!!

Bem-vindo Fernando!!!
Bem-vinda Maria!!!

nome1 = 'Fernando'
nome2 = 'Maria'

if nome1 == 'Fernando':
print('Bem-vindo Fernando!!!')
elif nome2 == 'Maria':
print('Bem-vinda Maria!!!')
else:
print('Erro: Nome Desconhecido.')

# Usando de elif, o retorno seria apenas Bem-vindo Fernando!!!
# pois uma proposição sendo verdadeira já encerra o processo.

Bem-vindo Fernando!!!

num1 = 12
num2 = 44
nome1 = 'Fernando'
nome2 = 'Maria'

if num1 >= 10 and nome1 == 'Fernando':
print('Número maior que 10 e o usuário é Fernando')
if num1 <= 10 and nome1 == 'Fernando':
print('Número menor que 10 e o usuário é Fernando')
if num1 == num2 and nome2 == 'Maria':
print('Número 1 e número 2 são iguais, assim como o usuário é Ma
ria')
if num1 != num2 and nome2 == 'Maria':
print('Número 1 e número 2 são diferentes, assim como o usuário é
Maria')

# Operador and exige que as duas condições sejam verdadeiras (u
ma condição e outra).

Número maior que 10 e o usuário é Fernando
Número 1 e número 2 são diferentes, assim como o usuário é Maria

num1 = 12
num2 = 44
nome1 = 'Fernando'
nome2 = 'Maria'

if num1 >= 10 and nome1 == 'Fernando':
# Se o valor de num1 for igual ou maior que 10 e nome1 for igual a
Fernando...
print('Número maior que 10 e o usuário é Fernando')
if num1 <= 10 and nome1 == 'Fernando':
# Se o valor de num1 for igual ou menor que 10 e nome1 for igual
a Fernando
print('Número menor que 10 e o usuário é Fernando')
if num1 == num2 and nome2 == 'Maria':
# Se o valor de num1 for igual ao valor de num2 e nome2 for igual
a Maria
print('Número 1 e número 2 são iguais, assim como o usuário é Ma
ria')
if num1 != num2 and nome2 == 'Maria':
# Se o valor de num1 for diferente de num2 e nome2 for igual a Ma
ria
print('Número 1 e número 2 são diferentes, assim como o usuário é
Maria')

Número maior que 10 e o usuário é Fernando
Número 1 e número 2 são diferentes, assim como o usuário é Maria

num1 = 2
num2 = 15

if (num1 + num2) > 20:
print('O resultado da soma é MAIOR do que 20')
elif (num1 + num2) == 20:
print('O resultado da soma é IGUAL a 20')
else:
print('O resultado da soma é MENOR do que 20')

O resultado da soma é MENOR do que 20

num1 = 2
num2 = 15

if (num1 + num2) > 20:
# Se o resultado da soma de num1 e num2 for maior que 20...
print('O resultado da soma é MAIOR do que 20')
elif (num1 + num2) == 20:
# Se o resultado da soma de num1 e num2 for igual a 20
print('O resultado da soma é IGUAL a 20')
else:
# Caso nenhuma das condições anteriores seja válida
print('O resultado da soma é MENOR do que 20')

O resultado da soma é MENOR do que 20

Estruturas condicionais com interpolação /
máscaras de substituição
nomes = ['Fernando', 'Maria', 'Carlos']
login = input('Digite o seu nome: ')

if login in nomes:
# Se o nome atribuído a login for um dos elementos da lista nomes.
..
print(f'Bem-vindo(a) {login}')
else:
print('Usuário não cadastrado.')

Digite o seu nome: Carlos
Bem-vindo(a) Carlos

compostas
num1 = 15
num2 = 40
num3 = 2
soma = num1 + num2 + num3

if (num1 + num2) >= 0:
print('O número é positivo')
if (num1 + num2) > 50 and soma < 100:
print('O número é maior que 50 e menor que 100')

O número é positivo
O número é maior que 50 e menor que 100

num1 = 15
num2 = 40
num3 = 2
soma = num1 + num2 + num3

if (num1 + num2) >= 0:
# Se o resultado da soma de num1 e num2 for um número igual ou
maior que zero...
print('O número é positivo')
if (num1 + num2) > 50 and soma < 100:
# Se o resultado da soma de num1 e num2 for maior que 50 e o val
or de soma,
# que por sua vez é a soma dos valores das variáveis num1, num2
e num3 for
# menor que 100...
print('O número é maior que 50 e menor que 100')

O número é positivo
O número é maior que 50 e menor que 100

Estruturas condicionais com validação simples
(em string)

print('Olá Fernando, você é o administrador do sistema!!!')
elif nome in 'Ana Bárbara Carlos José Maria Paulo Tatiana':
print(f'Bem vindo(a) {nome}, você é um(a) usuário(a) registrado no
sistema.')
else:
print('Olá, você não está logado no sistema, suas permissões são r
estritas.')

Digite o seu nome: Tatiana
Bem vindo(a) Tatiana, você é um(a) usuário(a) registrado no
sistema.


# Se o nome atribuído a variável nome for Fernando...
# Se o nome atribuído a variável nome for um dos nomes em 'Ana
Bárbara
# Carlos José Maria Paulo Tatiana'...
sistema.')
else:
# Caso contrário
estritas.')

Digite o seu nome: Alberto
Olá, você não está logado no sistema, suas permissões são
restritas.


sistema.')
else:
estritas.')

Digite o seu nome: Paulo
Bem vindo(a) Paulo, você é um(a) usuário(a) registrado no sistema.

# Mesmo exemplo que o anterior, mas diferenciando gêneros


print('Olá Fernando, você é o administraor do sistema!!!')
elif nome in 'Ana Bárbara Maria Tatiana':
print(f'Bem vinda {nome}, você é uma usuária registrada no sistem
a.')
elif nome in 'Carlos José Paulo':
print(f'Bem vindo {nome}, você é um usuário registrado no sistema.'
)
else:
estritas.')

Digite o seu nome: Ana
Bem vinda Ana, você é uma usuária registrada no sistema.


# Se nome for igual a Fernando
print('Olá Fernando, você é o administraor do sistema!!!')
elif nome in 'Ana Bárbara Maria Tatiana':
# Se nome for um dos nomes em 'Ana Bárbara Maria Tatiana'
a.')
elif nome in 'Carlos José Paulo':
# Se nome for um dos nomes em 'Carlos José Paulo'
)
else:
# Caso contrário
estritas.')

Digite o seu nome: Ana
Bem vinda Ana, você é uma usuária registrada no sistema.

# Mesmo exemplo anterior, aprimorado


funcionarios_homens = ['Carlos', 'José', 'Paulo']
funcionarias_mulheres = ['Ana', 'Bárbara', 'Maria', 'Tatiana']

elif nome in funcionarias_mulheres:
a.')
elif nome in funcionarios_homens:
)
else:
estritas.')

Digite o seu nome: José
Bem vindo José, você é um usuário registrado no sistema.


funcionarios_homens = ['Carlos', 'José', 'Paulo']
funcionarias_mulheres = ['Ana', 'Bárbara', 'Maria', 'Tatiana']

# Se nome for igual a Fernando
elif nome in funcionarias_mulheres:
# Se nome for um dos elementos da lista funcionarias_mulheres
a.')
elif nome in funcionarios_homens:
# Se nome for um dos elementos da lista funcionarios_homens
)
else:
# Caso contrário
estritas.')

Digite o seu nome: Maria
Bem vinda Maria, você é uma usuária registrada no sistema.

Estrutura condicional composta com operadores
or e and
veiculo1 = 'Gol'
veiculo2 = 'Corsa'
veiculo3 = 'Onibus'

cor1 = 'Branco'
cor2 = 'Vermelho'

if veiculo1 == 'Gol' or veiculo2 == 'Celta':
print('Carro')
if veiculo1 == 'Gol' and cor1 == 'Branco':
print('Gol Branco')
if veiculo1 == 'Onibus' and cor2 == 'Vermelho':
print('Onibus Vermelho')

# Condição em or apenas uma das condicionais precisa ser verdade
ira.
# Condicão em and as duas condicionais precisam serem verdadeir
as.

Carro
Gol Branco

veiculo1 = 'Gol'
veiculo2 = 'Corsa'
veiculo3 = 'Onibus'

cor1 = 'Branco'
cor2 = 'Vermelho'

if veiculo1 == 'Gol' or veiculo2 == 'Celta':
# Se veiculo1 for igual a Gol ou veiculo2 for igual a Celta
print('Carro')
if veiculo1 == 'Gol' and cor1 == 'Branco':
# Se veiculo1 for igual a gol e cor1 for igual a Branco
print('Gol Branco')
if veiculo1 == 'Onibus' and cor2 == 'Vermelho':
# Se veiculo1 for igual a Onibus e cor2 for igual a Vermelho
print('Onibus Vermelho')

Carro
Gol Branco

Estruturas de Repetição

While
# Enquanto determinada condição for verdadeira, o processo se rep
ete.

x = 0

while x <= 5:
print(x)
x = x + 1

0
1
2
3
4
5

x = 0

while x <= 5:
# Enquanto o valor de x for igual ou menor que 5
print(x)
x = x + 1
# o valor de x é atualizado, incrementado/somado em 1

0
1
2
3
4
5

Estruturas de repetição com validação
# Enquanto o usuário não digitar a palavra específica o código não é
executado.

validador = input('Digite "Brasil" para continuar:')

while validador != 'Brasil':
print('Palavra-chave não confere, digite novamente:')

if validador == 'Brasil':
print('Agora você digitou Brasil corretamente.')

Digite "Brasil" para continuar:Itália
Palavra-chave não confere, digite novamente:
Digite "Brasil" para continuar:Brasil
Agora você digitou Brasil corretamente.


while validador != 'Brasil':
# Enquanto validador for diferente de Brasil
# é pedido que o usuário digite Brasil, repetidamente, até que o m
esmo
# digite Brasil conforme pedido na mensagem.

# Se validador for igual a Brasil
print('Agora você digitou Brasil corretamente.')


Estruturas condicionais dentro de laços de
repetição
num = 0
total = 10

while num <= 10:
print(num)
num += 1
if num == 5:
print('50% computado')
if num == 10:
print('100%, processo encerrado')

# O ciclo se repete até que a condição inicial imposta, nesse caso, q
ue o valor
# de num seja menor ou igual a 10.

0
1
2
3
4
50% computado
5
6
7
8
9
100%, processo encerrado
10

num = 0
total = 10

while num <= 10:
# Enquanto o valor de num for igual ou menor que 10
print(num)
num += 1
# num é atualizado, incrementado em 1 unidade
if num == 5:
# Se o valor de num for igual a 5
print('50% computado')
if num == 10:
# Se o valor de num for igual a 10
print('100%, processo encerrado')

0
1
2
3
4
50% computado
5
6
7
8
9
100%, processo encerrado
10

while True
# Reescrevendo o exemplo de palavra-
chave específica, aprimorado com while True

while True:

print('Você digitou Brasil corretamente!!!')
break # interrompe o processo / loop
else:

# while True nesse caso simula um ciclo "infinito", sendo necessário
que quando
# a condição for atingida, o marcador break interrompe o ciclo.

Digite "Brasil" para continuar:Brazil
Palavra-chave não confere, digite novamente:
Você digitou Brasil corretamente!!!

Laço for
# Laço de repetição simples

compras = ['Arroz', 'Feijão', 'Massa', 'Carne', 'Pão']

for i in compras:
print(i)

# A variável temporária i a cada ciclo irá ler um dos elementos da list
a
# compras, sendo que a cada ciclo lê e retorna o elemento subsequ
ente.

Arroz
Feijão
Massa
Carne
Pão

Laço for percorrendo cada elemento de uma
string
nome = 'Alberto'

for i in nome:
print(i)

# A cada ciclo a variável temporária i retornará um dos caracteres da
string

A
l
b
e
r
t
o

Laço for repetindo ciclo dentro de um intervalo
numérico específico
for i in range(0, 10):
print(i)

# A variável i percorrerá e retornará um intervalo numérico pré-
determinado,
# sendo que o último valor numérico usado como parâmetro para fu
nção range( )
# serve como gatilho para encerrar o processo. Nesse caso, último v
alor 10 fará
# que o ciclo encerre retornando o último valor antes de 10, no caso,
9.

0
1
2
3
4
5
6
7
8
9

Laço de repetição que atualiza o dado/valor de
uma variável
vendas = [1000, 459, 911, 200, 838, 50]

total = 0

for i in vendas:
total += i
print(total)

# A cada ciclo, a variável temporária i lê e retornar um dos elemento
s
# da lista vendas, a variável total, indentada no laço de repetição,
# a cada ciclo soma a seu valor atual o último valor de atribuído em i

3458

Desempacotando os elementos de uma lista via
laço de repetição
compras = [['Arroz', 'Feijão'], ['Carne', 'Frango', 'Peixe'], ['Leite']]

for i in compras:
print(i)

# De acordo com o separador " , " , o primeiro elemento da lista com
pras é
# a lista ['Arroz', 'Feijão'], o segundo elemento é a lista ['Carne', 'Fran
go',
# 'Peixe'] e o terceiro elemento é a lista ['Leite'], de modo que o laço
está
# extraindo as listas de dentro da lista compras.

['Arroz', 'Feijão']
['Carne', 'Frango', 'Peixe']
['Leite']

Laço de repetição que desempacota e separa os
itens de um dicionário
cores = {'verde': 'green', 'azul': 'blue', 'vermelho': 'red'}

for i in cores:
print(i, ':', cores[i])

# A cada ciclo, a variável i lê e retorna o dado/valor do dicionário cor
es,
# na mensagem de retorno, instanciando cores na posição i, o interp
retador
# retornará o padrão de um dicionário, onde quando se lê uma chav
e ele retorna
# seu respectivo valor.

verde : green
azul : blue
vermelho : red

Laço for contando de 2 em 2 elementos
for i in range(0, 10, 2):
print(i)

# Terceiro parâmetro define de quantos em quantos elementos o laç
o percorrerá
# dentro do intervalo numérico definido.

0
2
4
6
8

Contagem regressiva via laço for
for i in range(10, 0, -1):
print(i)

# Terceiro parâmetro -1 estipula que o laço será feito do fim para o c
omeço.

10
9
8
7
6
5
4
3
2
1

Realizando contagem com base em número
digitado pelo usuário
num = int(input('Digite o número limite: '))

for i in range(0, num+1):
print(i)

# Lembrando que o último valor numérico em range( ) é o gatilho par
a
# que o processo se encerre, logo, é necerrário realizar a validação
# onde o número digitado pelo usuário deve ser acrescido de uma u
nidade

Digite o número limite: 20
0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

Laço de repetição com múltiplos parâmetros de
múltiplas variáveis
repetir = 's'
fatura = []
total = 0

while repetir == 's':
produto = input('Digite o nome do produto: ')
preco = float(input('Digite o preço: '))
fatura.append([produto, preco])
total += preco
repetir = input('Cadastrar mais algum item? (S ou N)').lower()

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

print('O Total da fatura é: ', total)

Digite o nome do produto: Camisa
Digite o preço: 59
Cadastrar mais algum item? (S ou N)s
Digite o nome do produto: Calça
Digite o preço: 99
Digite o nome do produto: Tênis
Digite o preço: 159
Digite o nome do produto: Meia
Digite o preço: 9
Cadastrar mais algum item? (S ou N)n
Camisa : 59.0
Calça : 99.0
Tênis : 159.0
Meia : 9.0
O Total da fatura é: 326.0

repetir = 's'
fatura = []
total = 0

while repetir == 's':
# Enquanto repetir for igual a s
produto = input('Digite o nome do produto: ')
preco = float(input('Digite o preço: '))
fatura.append([produto, preco])
# Adiciona a lista fatura um elemento em forma de lista onde const
a
# os dados atribuídos para as variáveis produto e preco
total += preco
# Atualiza a variável total somando para seu valor atual o valor de
preco
repetir = input('Cadastrar mais algum item? (S ou N)').lower()
# .lower() valida convertendo maiúscula para minúscula, caso nece
ssário

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

print('O Total da fatura é: ', total)

Digite o nome do produto: Camisa
Digite o preço: 59
Digite o nome do produto: Calça
Digite o preço: 99
Digite o nome do produto: Tênis
Digite o preço: 159
Digite o nome do produto: Meia
Digite o preço: 9
Cadastrar mais algum item? (S ou N)n
Camisa : 59.0
Calça : 99.0
Tênis : 159.0
Meia : 9.0
O Total da fatura é: 326.0

Usando de alternativas quando o laço for não for
eficiente
# Código convencional
# Percorrendo os elementos de uma string e exibindo-
os junto ao seu índice

nome = 'Fernando'
n_indice = 0

for n_indice in range(len(nome)):
print(n_indice, nome[n_indice])

# Desmembra caractere por caractere de nome, associando seu nú
mero de índice
# com a variável n_indice.

0F
1e
2r
3n
4a
5n
6d
7o

Função enumerate( )
# Código anterior otimizado via função enumerate( )

for n_indice, valor in enumerate(nome):
print(n_indice, valor)

# enumerate( ) automaticamente realiza a contagem de elementos a
ssociados
# a uma determinada variável.

0F
1e
2r
3n
4a
5n
6d
7o

Strings

Sintaxe básica
nome = 'atributo em formato alfanumérico'

# Todo e qualquer conteúdo entre aspas ' ' será identificado como str
ing

Contando quantos caracteres compõe uma string
frase1 = 'Porto Alegre é uma cidade Brasileira.'

print(len(frase1))

# Lembrando que todos elementos dentro da string serão contabiliza
dos,
# incluindo os espaços e símbolos.

37

Contando caracteres de uma string,
desconsiderando os espaços
frase1 = str('Porto Alegre é uma cidade Brasileira.')

print(len(frase1))
# string completa, incluindo espaços

print(len(frase1) - frase1.count(' '))
# string completa, removendo os elementos ' ' , que são espaços

37
32

Substituindo elementos de uma string
frase1 = frase1.replace('Porto Alegre', 'Curitiba')

print(frase1)

# replace( ) recebe dois parâmetros, sendo o primeiro o elemento a
ser
# substituído, e o segundo, o elemento a ser o substituto.

Curitiba é uma cidade Brasileira.

Contando quantos de um tipo específico de
caractere estão na string

print(frase1.count('a'))
# count( ) realizará a contagem de quantos elementos 'a' especifica
mente
# existem na string atribuída a frase1.

4

Exibindo a posição de índice de um determinado
elemento da string

print(frase1.find('é'))
# find( ) encontrará o elemento 'é', retornando sua posição de índice

13

Realizando a leitura de um caractere pelo seu
número de índice

print(frase1[16])

# Indicando a posição de índice, será retornado o respectivo elemen
to

m

Desmembrando uma string, separando cada
palavra da frase

print(frase1.split())

# split() sem parâmetros considerará os espaços entre as palavras,
caso
# queira um delimitador diferente é necessário definir via parâmetro,
por exemplo
# split(';'), dessa forma, onde houver ; haverá a separação dos elem
entos
# em novas strings.

['Porto', 'Alegre', 'é', 'uma', 'cidade', 'Brasileira.']

Extraindo dados de uma string especificando um
intervalo de índice

print(frase1[26:37])
# do elemento 26 até o 37

Brasileira.


print(frase1[0:5])
# do início até uma posição 5

Porto


print(frase1[-9])
# elemento de número 9, a contar de trás para frente

a

Concatenando strings por meio de variáveis
mensagem = 'Seja bem-vinda '
usuario = 'Ana Clara'

base = mensagem + usuario
# Como os atributos das variáveis mensagem e usuario são textos o
interpretador
# apenas juntará os mesmos em uma nova string.

print(base)

Seja bem-vinda Ana Clara

Concatenando diferentes tipos de dados em uma
string
nome = 'Ana Clara'
idade = 12

print(f'{nome} tem {idade} anos')

# Não haverá problema em concatenar diferentes tipos de dados de
sde que
# os mesmos estejam em máscaras de substituição separadas.

Ana Clara tem 12 anos

# Exemplo 2:

aviso = 'Atenção, geradores entrarão em manutenção às: ' + str(22)
+ ' horas!'
# A variável aviso recebe três atributos distintos, concatenados pelo
marcador
# " + ", sendo o segundo atributo convertido para string para evitar c
onflitos

print(aviso)
print(type(aviso))

Atenção, geradores entrarão em manutenção às: 22 horas!
<class 'str'>

Operadores lógicos em uma string
aviso = 'Não é permitida a entrada de menores de 18 anos'

print(aviso)

print('anos' in aviso)

print('gestante' not in aviso)

Não é permitida a entrada de menores de 18 anos
True
True

aviso = 'Não é permitida a entrada de menores de 18 anos'

print(aviso)
# Exibe todo o conteúdo da variável aviso

print('anos' in aviso)
# Retorna True caso 'anos' for um dos elementos da string em aviso

print('gestante' not in aviso)
# Retorna True caso 'gestante' não conste nos elementos da string

Não é permitida a entrada de menores de 18 anos
True
True

Letras maiúsculas ou minúsculas em uma string
alerta = 'Risco de Morte'

print(alerta.upper())

print(alerta.lower())

RISCO DE MORTE
risco de morte

alerta = 'Risco de Morte'

print(alerta.upper())
# upper( ) converterá todos os caracteres para maiúsculo

print(alerta.lower())
# lower( ) converterá todos os caracteres para minúsculo

RISCO DE MORTE
risco de morte

Convertendo outro tipo de dado para string
num1 = 5623
num2 = str(num1)

print(type(num1))
print(type(num2))

<class 'int'>
<class 'str'>

num1 = 5623
num2 = str(num1)
# Recebe como atributo o dado/valor de num1 convertido para string

print(type(num1))
print(type(num2))

<class 'int'>
<class 'str'>

Removendo espaços desnecessários do início de
uma string
frase1 = ' Olá, você é o visitante nº 1000 '

print(frase1)
# string em seu formato original

print(frase1.strip())
# string sem espaços desnecessários

Olá, você é o visitante nº 1000
Olá, você é o visitante nº 1000

Convertendo todas as iniciais das palavras para
maiúsculo, como em um título
tema = 'O diagnóstico por imagem como ferramenta para detecção d
e câncer'

print(tema)

tema = tema.title()
# title( ) converterá todas letras iniciais da string para letra maiúscula

print(tema)

O diagnóstico por imagem como ferramenta para detecção de
câncer
O Diagnóstico Por Imagem Como Ferramenta Para Detecção De
Câncer

Verificando se uma string é composta por letras
e/ou por números
print('aa44'.isalnum())
# Qualquer caractere alfanumérico

print('aa44'.isalpha())
# Apenas letras

print('aa44'.isdigit())
# Apenas números

True
False
False

Adicionando espaços antes e depois de uma
string
frase1 = 'Alerta, Risco de Morte!!!'
frase1 = frase1.ljust(50)
# em um intervalo de 50 caracteres, alinhando a string à esquerda

print(frase1)

frase2 = frase2.rjust(50)
# em um intervalo de 50 caracteres, alinhando a string à direita

print(frase2)

frase3 = frase3.center(50)
# em um intervalo de 50 caracteres, alinhando a string ao centro

print(frase3)

Alerta, Risco de Morte!!!

Particularidades envolvendo o tamanho de uma
string
nome = 'Alberto'
# 7 elementos

nome2 = 'Alberto\n' # marcador \n é lido como apenas 1 caractere
nome3 = 'Alberto ' # espaço é lido como 1 caractere

print(len(nome))
print(len(nome2))
print(len(nome3))

7
8
8

Tratando os espaços desnecessários de uma
string
nome = ' Fernando '
print(nome)

nome2 = nome.rstrip()
print(nome2)

nome3 = nome.lstrip()
print(nome3)

nome4 = nome.strip()
print(nome4)

Fernando
Fernando
Fernando
Fernando

nome = ' Fernando '

print(nome)

nome2 = nome.rstrip()
# rstrip( ) removerá os espaços desnecessários à direita
print(nome2)

nome3 = nome.lstrip()
# rstrip( ) removerá os espaços desnecessários à esquerda
print(nome3)

nome4 = nome.strip()
# rstrip( ) removerá os espaços desnecessários em ambos os lados
print(nome4)

Fernando
Fernando
Fernando
Fernando

Reposicionando elementos de uma string
codigo = 'AAA\rBBB'

print(codigo)

codigo2 = ' AAA\rBBB'

print(codigo2)

AAA BBB
AAA BBB

capitalize()
# Converte o primeiro caractere para maiúsculo

casefold()
# Converte uma string para letras minúsculas

center()
# Retorna uma string centralizada

count()
# Retorna o número de vezes em que um elemento aparece na strin
g

encode()
# Retorna uma versão convertida da string (parametrizar com o tipo
de texto, ex: utf-8)

endswith()
# Dado um dado/valor a ser usado para identificador do fim do texto,
retornará True caso o texto de fato termine com tal dado

expandtabs()
# Define o tamanho da tabulação do texto (margens)

find()
# Busca no texto um determinado elemento, retornando a posição d
e índice onde o mesmo foi localizado

index()
# Dada uma certa palavra, retorna o número de índice onde a mesm
a foi localizada por primeiro

isalnum()
# Retorna True se todos os caracteres forem de um tipo numérico

isalpha()
# Retorna True se todos os caracteres forem alfanuméricos, sem sí
mbolos especiais

isdecimal()
# Retorna True se todos os elementos forem do tipo numérico com c
asa decimal

isdigit()
# Retorna True se todos os elementos forem dígitos

islower()
# Retorna True se todos os caracteres da string estiverem em minús
culo

isnumeric()
# Retorna True se todos os elementos forem números, sem símbolo
s especiais

isspace()
# Retorna True se todos os elementos de uma string forem espaços
em branco

istitle()
# Retorna True se todas as palavras de uma frase forem iniciadas c
om letra maiúscula

isupper()
# Retorna True se todas as letras de uma string forem letras maiúsc
ulas

join()
# Junta uma nova string ao final da primeira usada como referência

ljust()
# Alinha à esquerda uma string

rjust()
# Alinha à direita uma string

lower()
# Converte todos elementos de uma string para letra minúscula

lstrip()
# Remove todos os espaços à esquerda de uma string

rstrip()
# Remove todos os espaços à direita de uma string

maketrans()
# Retorna uma tradução para a string a partir de outra variável

partition()
# Retorna uma tupla onde a string original é dividida em 3 partes

replace()
# Substitui um elemento de uma string por outro

rfind()
# Busca por uma determinada string mas retorna a última instancia
da mesma encontrada

rindex()
# Busca por uma determinada string mas retorna o último número d
e índice onde a mesma foi encontrada

startswith()
# Com base em uma palavra-
chave, retorna True caso essa palavra seja a primeira da string

title()
# Converte o primeiro caractere de cada string para maiúsculo

translate()
# Retorna uma string traduzida com base em informação contida em
uma variável

upper()
# Converte toda a string para letras maiúsculas

Listas

Criando uma lista simples
lista1 = ['Ana Clara', 'Carlos', 'Maria', 'Michele', 'Fernando', 1987]

print(lista1)

['Ana Clara', 'Carlos', 'Maria', 'Michele', 'Fernando', 1987]

lista1 = ['Ana Clara',
'Carlos',
'Maria',
'Michele',
'Fernando',
1987]

print(lista1)

# Para uma melhor legibilidade do código, os elementos de uma list
a podem ser
# organizados dispostos em linhas diferentes, separada pelo marcad
or " , "

'Ana Clara', 'Carlos', 'Maria', 'Michele', 'Fernando', 1987]

Descobrindo o elemento de uma lista através de
seu número de índice

print(lista1[3])

# Lembrando que em Python o índice se uma lista sempre inicial em
0

Michele

Descobrindo o número de índice de um
determinado elemento

print(lista1.index('Michele'))
# index( ) retornará o número de índice de um determinado element
o da lista,
# string ou contêiner de dados de estrutura lógica parecida

3

Descobrindo o número total de elementos de uma
lista

print(len(lista1))

6

Adicionando um novo elemento na lista por
justaposição

lista1.append('Paulo')
# Via append( ) o novo elemento será inserido como último element
o da lista

print(lista1)

['Ana Clara', 'Carlos', 'Maria', 'Michele', 'Fernando', 1987, 'Paulo']

Adicionando um novo elemento na lista em uma
posição específica

lista1[2] = 'José'
# Referenciando a posição de índice, é possível inserir um novo ele
mento
# na referente posição ou substituir um elemento que ocupava tal po
sição

print(lista1)

['Ana Clara', 'Carlos', 'José', 'Michele', 'Fernando', 1987]

Adicionando um novo elemento na lista em uma
posição específica via função insert( )

lista1.insert(2, 'José')
# Via insert( ) é possível adicionar um novo elemento em uma posiç
ão específica
# sem que o mesmo substitua o elemento antigo daquela posição de
índice

print(lista1)

['Ana Clara', 'Carlos', 'José', 'Maria', 'Michele', 'Fernando', 1987]

Removendo um elemento de uma lista via função
pop( )

lista1.pop(1)
# pop( ) remove um determinado elemento por meio de seu número
de índice.

print(lista1)

['Ana Clara', 'Maria', 'Michele', 'Fernando', 1987]

Removendo um elemento de uma lista via função
remove( )

lista1.remove(lista1[5])
# Via função remove( ) é necessário parametrizar a mesma com a v
ariável em
# questão e seu número de índice.

print(lista1)

['Ana Clara', 'Carlos', 'Maria', 'Michele', 'Fernando']

Ordenando os elementos de uma lista
num = [9, 4, 7, 2, 5, 1, 8, 3, 6, 0]

num.sort()
# Ordena os números em sua ordem natural

print(num)

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

num.sort(reverse = True)
# Ordena os números de trás para frente

print(num)

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

Invertendo a ordem dos elementos de uma lista
via reversed( )
num2 = [9, 4, 7, 2, 5, 1, 8, 3, 6, 0]

num3 = list(reversed(num2))
# Para inverter os elementos de uma lista pelo método reversed( )
# é necessário gerar uma nova lista, além de instanciar a variável
# da lista original.

print(num3)

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

Ordenando elementos de uma lista composta de
caracteres alfanuméricos
# Método sorted( ) oferece suporte a ordenação de qualquer elemen
to sendo este
# composto de letras e de números.

animal = 'ornitorrinco'

letras = sorted(animal)

print(letras)

['c', 'i', 'i', 'n', 'n', 'o', 'o', 'o', 'r', 'r', 'r', 't']

Listas dentro de listas
cadastro = [[1, 2, 3, 4], ['Ana', 'Maria', 'Paulo', 'Roberto']]

print(cadastro)

# O primeiro elemento da lista atribuída a Carlos é a lista [1, 2, 3, 4],
# sendo que o segundo elemento da mesma é a lista ['Ana', 'Maria', '
Paulo',
# 'Roberto']

[[1, 2, 3, 4], ['Ana', 'Maria', 'Paulo', 'Roberto']]

Concatenando listas
pessoas1 = ['Ana', 'Bárbara', 'Carla', 'Daiane']
pessoas2 = ['André', 'Carlos', 'Diego', 'Fernando']

todas_pessoas = pessoas1 + pessoas2

print(pessoas1)
print(pessoas2)
print(todas_pessoas)

# Para concatenação é necessário criar uma nova lista

['Ana', 'Bárbara', 'Carla', 'Daiane']
['André', 'Carlos', 'Diego', 'Fernando']
['Ana', 'Bárbara', 'Carla', 'Daiane', 'André', 'Carlos', 'Diego',
'Fernando']

Unindo listas
pessoas1 = ['Ana', 'Bárbara', 'Carla', 'Daiane']
pessoas2 = ['André', 'Carlos', 'Diego', 'Fernando']

print(pessoas1)
print(pessoas2)

pessoas1.extend(pessoas2)

print(pessoas1)

# É possível unir uma lista a outra já existente, nesse caso, por meio
# do método extend( ) aplicado a pessoas1, o conteúdo de pessoas
2 será
# acicionado ao conteúdo de pessoas1.

['Ana', 'Bárbara', 'Carla', 'Daiane']
['André', 'Carlos', 'Diego', 'Fernando']
['Ana', 'Bárbara', 'Carla', 'Daiane', 'André', 'Carlos', 'Diego',
'Fernando']

Fatiando elementos de uma lista
lista5 = ['Ana', 'Carlos', 'Diego', 'Elis', 'Fernando',
'Graziela', 'Marcos', 'Paulo', 'Viviane']

lista6 = lista5[1:5]
# extraindo do segundo ao quinto elemento por meio de seus índice
s

print(lista5)
print(lista6)

['Ana', 'Carlos', 'Diego', 'Elis', 'Fernando', 'Graziela', 'Marcos', 'Paulo',
'Viviane']
['Carlos', 'Diego', 'Elis', 'Fernando']

append()
# Adiciona um elemento ao final de uma lista

insert()
# Adiciona um elemento em uma posição específica do índice

clear()
# Remove todos os elementos de uma lista

copy()
# Associado a outra variável, copia todo o conteúdo de uma lista

count()
# Retorna o número de vezes que um elemento aparece em uma list
a

extend()
# Adiciona os elementos de um objeto (ou de outra lista) ao final da l
ista original

index()
# Retorna o número de índice de um determinado elemento da lista

pop()
# Remove um determinado elemento da lista por meio de seu númer
o de índice

remove()
# Remove um determinado elemento da lista por meio de seu nome/
dado/valor

reverse()
# Inverte a ordem dos elementos da lista

sort()
# Ordena os elementos da lista

Conjuntos Numéricos

Criando um conjunto numérico (set)
conjunto1 = {5, 10, 15, 20}

print(conjunto1)
print(type(conjunto1))

# Apesar da notação do conteúdo entre chaves { }, como não existe
m
# conjuntos de chaves : valores, o interpretador identifica tal tipo
# de dado como set

{10, 20, 5, 15}
<class 'set'>

Operações entre conjuntos numéricos
cj1 = {1, 2, 3, 4, 5}
cj2 = {1, 3, 5, 7, 9}

print(cj2 - cj1)

{9, 7}

União de conjuntos numéricos
conjunto1 = {5, 10, 15, 20, 25}
conjunto2 = {1, 2, 3, 4, 5}

uniao = conjunto1.union(conjunto2)

print(uniao)

# Os dados que forem comum aos dois conjuntos não serão duplica
dos.

{1, 2, 3, 4, 5, 10, 15, 20, 25}

# Método alternativo usando do operador " | "

conjunto1 = {5, 10, 15, 20, 25}
conjunto2 = {1, 2, 3, 4, 5}

uniao2 = conjunto1 | conjunto2

print(uniao2)

# O operador " | " significa ou em contextos gerais, mas quando usa
do para
# conjuntos tem o mesmo comportamento do método union( )

{1, 2, 3, 4, 5, 10, 15, 20, 25}

Interseção de dois conjuntos
conjunto1 = {5, 10, 15, 20, 25}
conjunto2 = {1, 2, 3, 4, 5}

intersecao = conjunto1.intersection(conjunto2)
# intersection( ) retornará apenas o elemento que for comum aos doi
s conjuntos

print(intersecao)

{5}

# Método alternativo usando do operador " & "

conjunto1 = {5, 10, 15, 20, 25}
conjunto2 = {1, 2, 3, 4, 5}

intersecao2 = conjunto1 & conjunto2

print(intersecao2)

# O operador " & " quando aplicado a conjuntos numéricos tem o co
mportamento
# semelhante ao método intersection( )

{5}

Diferença entre dois conjuntos
conjunto1 = {5, 10, 15, 20, 25}
conjunto2 = {1, 2, 3, 4, 5}

conjunto3 = conjunto1.intersection(conjunto2)
# Variável conjunto3 recebendo como atributo o resultado da interse
ção
# de conjunto2 para conjunto1

print(conjunto3)

{5}

# Método alternativo usando do operador " - "

c1 = {2, 4, 6, 8, 10} - {2, 4, 5, 7, 9}
# Retornará os elementos que pertencem ao primeiro conjunto que
não constam
# nem independentes nem duplicados quando comparado ao segun
do conjunto.
# Nesse caso, 2 e 4 se anulam pois constam em ambos conjuntos, 6
, 8 e 10 são
# retornados pois são únicos e pertencentes ao primeiro conjunto.

print(c1)

{8, 10, 6}

Diferença entre conjuntos associados à variáveis
c1 = {1, 2, 3, 4, 5, 6, 7, 8, 9}
c2 = {1, 3, 5, 7, 9}

c3 = c1 - c2
# Da mesma forma como no tópico anterior, o primeiro conjunto, no
caso
# c1 será usado como referência, realizando as devidas diferenciaçõ
es
# comparando seus elementos com o conjunto c2.

print(c3)

{8, 2, 4, 6}

Operadores lógicos em conjuntos numéricos
conjunto1 = {5, 10, 15, 20, 25}
conjunto2 = {1, 2, 3, 4, 5}


print(uniao == conjunto1)
print(uniao >= conjunto2)

False
True

conjunto1 = {5, 10, 15, 20, 25}
conjunto2 = {1, 2, 3, 4, 5}


print(uniao == conjunto1)
# O conteúdo de uniao é igual ao de conjunto1?

print(uniao >= conjunto2)
# O conteúdo de uniao é maior ou igual se comparado com o conteú
do de conjunto2?

False
True

Reiniciando um conjunto
conjunto1 = {1, 2, 3, 4, 5, 6, 7, 8, 9}

print(conjunto1)

conjunto1.clear()
# clear( ) apagará todos os elementos do conjunto

print(conjunto1)

{1, 2, 3, 4, 5, 6, 7, 8, 9}
set()

Validações aplicadas a elementos de dois
conjuntos
conjunto1 = {5, 10, 15, 20, 25}
conjunto2 = {1, 2, 3, 4, 5}

print(conjunto1.issubset(conjunto2))
# retornará True caso os elementos de conjunto1 estiverem contidos
em conjunto2

print(conjunto1.issuperset(conjunto2))
# retornará True caso os elementos de conjunto2 estiverem contidos
em conjunto1

print(conjunto1.isdisjoint(conjunto2))
# retornará True caso conjunto1 e conjunto 2 não tiverem elementos
em comum

False
False
False

Pilhas

Adicionando elementos a uma pilha
sequencia = [11, 22, 33, 444]

pilha = []

for elemento in sequencia:
pilha.append(elemento)

print(pilha)

pilha.append(555)
# Acrescenta como último elemento da pilha o valor 555

print(pilha)

pilha.append(1000)
pilha.append(2000)

print(pilha)

# Todos novos elementos sempre serão adicionados como último el
emento da pilha

[11, 22, 33, 444]
[11, 22, 33, 444, 555]
[11, 22, 33, 444, 555, 1000, 2000]

Removendo elementos de uma pilha
sequencia = [11, 22, 33, 444, 555]

pilha = []


print(pilha)

pilha.pop()
# Mesmo sem parâmetros, removerá o último elemento da pilha

print(pilha)

[11, 22, 33, 444, 555]
[11, 22, 33, 444]

# Automatizando o processo de remoção de elementos da pilha

sequencia = [11, 22, 33, 444, 555]

pilha = []


while len(pilha) > 0:
print(pilha)

topo = pilha.pop()

print(f'Objeto do topo da pilha: {topo}')

# Uma pilha segue a lógica de objetos empilhados, onde o último a s
er
# inserido será o primeiro a ser removido quando necessário.

[11, 22, 33, 444, 555]
Objeto do topo da pilha: 555
[11, 22, 33, 444]
[11, 22, 33]
[11, 22]
[11]

sequencia = [11, 22, 33, 444, 555]

pilha = []

# A cada ciclo a variável elemento lê e retorna o dado/valor contid
o em
# sequência
# A cada laço, o último valor atribuído para elemento é inserido na
lista
# atribuída a variável pilha

while len(pilha) > 0:
# Enquanto o tamanho de pilha for maior que zero
print(pilha)

topo = pilha.pop()
# pop( ) elimina o último elemento inserido na pilha

print(f'Objeto do topo da pilha: {topo}')

[11, 22, 33, 444, 555]
[11, 22, 33, 444]
[11, 22, 33]
[11, 22]
[11]

Interpolação

Uso de máscaras de substituição
nome = 'Maria'
exp = 33

print(f'Olá {nome}, queremos te parabenizar por seus {exp} anos em
nossa empresa.')

# Máscaras de substituição serão espaços alocados na própria strin
g para
# instanciar neste espaço o conteúdo de algum objeto qualquer

Olá Maria, queremos te parabenizar por seus 33 anos em nossa
empresa.

Operações dentro de máscaras de substituição
nome = 'Maria'
idade = 30

print(f'{nome} tem 3 vezes minha idade, ela tem {3 * idade} anos!!!')

# Dentro de uma máscara de substituição é possivel realizar qualqu
er tipo
# de operação lógica ou aritmética, além de funções

Maria tem 3 vezes minha idade, ela tem 90 anos!!!

Dicionários

Sinxata básica
dicionario = {'chave': 'valor'}

print(dicionario)

# Obrigatoriamente um dicionário deve ter conjuntos de dados dispo
stos
# em forma de chave e valor.

{'chave': 'valor'}

Adicionando novos itens ao dicionário
dicionario1 = {'Nome1':'Paulo'}

print(dicionario1)

dicionario1['Nome2'] = 'Veronica'
# Gera a chave 'Nome2' repassando como valor para a mesma 'Ver
onica'

print(dicionario1)

{'Nome1': 'Paulo'}
{'Nome1': 'Paulo', 'Nome2': 'Veronica'}

Alterando o valor de uma chave
dicionario1 = {'Nome1': 'Ana',
'Nome2': 'Carla',
'Nome3': 'Maria'}

print(dicionario1)

dicionario1['Nome2'] = 'Bárbara'

print(dicionario1)

# Para alterar/atualizar um valor de um item do dicionário, se deve
# fazer referência à sua chave, para alterar seu valor.

{'Nome1': 'Ana', 'Nome2': 'Carla', 'Nome3': 'Maria'}
{'Nome1': 'Ana', 'Nome2': 'Bárbara', 'Nome3': 'Maria'}

Acessando um determinado elemento do
dicionário
dicionario1 = {'Nome':'Fernando',
'Idade':32,
'Sexo':'Masculino',
'Nacionalidade':'Brasileiro'}

print(dicionario1['Nome'])
print(dicionario1['Nacionalidade'])

# Ao consultar a chave, será retornado o valor

Fernando
Brasileiro

Usando o construtor de dicionários
dicionario2 = dict(chave1 = 'valor da chave1',
chave2 = 'valor da chave 2')

print(dicionario2)
print(type(dicionario2))

# Lembrando que ao inserir itens no dicionário, devemos sempre
# os inserir e conjuntos de chave : valor

{'chave1': 'valor da chave1', 'chave2': 'valor da chave 2'}
<class 'dict'>

Transformando listas em chaves/valores de um
dicionário
itens = ['Caneta', 'Lápis', 'Borracha', 'Caderno']
precos = ['1,99', '0,99', '0,50', '9,90']

dicionario1 = dict(keys = itens, values = precos)

print(dicionario1)
print(type(dicionario1))

# Por meio do construtor de dicionários, usando de seus parâmetros
# nomeados keys e values é possível atribuir chaves e valores a par
tir
# de uma variável, normalmente de uma lista

{'keys': ['Caneta', 'Lápis', 'Borracha', 'Caderno'], 'values': ['1,99',
'0,99', '0,50', '9,90']}
<class 'dict'>

Consultando apenas as chaves de um dicionário

dicionario2.keys()

dict_keys(['chave1', 'chave2'])

Consultando apenas os valores de um dicionário

dicionario2.values()

dict_values(['valor da chave1', 'valor da chave 2'])

Verificando se uma chave/valor consta no
dicionário
# Pesquisando pela chave, obtendo valor

d3 = {'1':'Ana',
'2':'Maria',
'3':'Paulo',
'4':'Marcos'}

print(d3.get('5'))

print(d3.get('3'))
# Mesmo que: print('3' in d3)

# Pelo método get( ), caso o usuário tente consultar um item que nã
o
# pertence ao dicionário, no lugar de gerar um erro é simplesmente
# retornado None indicando que naquela posição de índice não exist
e
# nenhum item.

None
Paulo

Pesquisando se um dado/valor consta em uma
chave
d3 = {'1':'Ana',
'2':'Maria',
'3':'Paulo',
'4':'Marcos'}

print('2' in d3.keys())

# Lembrando que in é um operador lógico, logo, o retorno será
# True ou False dependendo da situação

True

Pesquisando se um dado/valor consta em um
valor
d3 = {'1':'Ana',
'2':'Maria',
'3':'Paulo',
'4':'Marcos'}

print('Ana' in d3.values())

True

Pesquisando de o dado/valor de um dicionário é
o dado/valor esperado
d3 = {'1':'Ana',
'2':'Maria',
'3':'Paulo',
'4':'Marcos'}

print(d3['2'] == 'Maria')
# No dicionário d3, o valor da chave '2' é igual a 'Maria'?

True

Atualizando um elemento do dicionário
d4 = {'1':'A',
'2':'B',
'3':'C',
'4':'D'}

print(d4)

d4.update({'2':'F'})
# Mesmo que: d4['2'] = 'F'

print(d4)

# update( ) é simplesmente uma forma alternativa de atualizar itens

{'1': 'A', '2': 'B', '3': 'C', '4': 'D'}
{'1': 'A', '2': 'F', '3': 'C', '4': 'D'}

Removendo um elemento do dicionário
d4 = {'1':'A',
'2':'B',
'3':'C',
'4':'D'}

print(d4)

del d4['4']

print(d4)

# del é uma palavra reservada ao sistema, de uma função interna qu
e
# serve para deletar dados de objetos alocados em memória.
# Ao instanciar uma chave, é deletado também seu respectivo valor.

{'1': 'A', '2': 'B', '3': 'C', '4': 'D'}
{'1': 'A', '2': 'B', '3': 'C'}

Pesquisando o tamanho de um dicionário (de
quantos itens ele é composto)
d4 = {'1':'A',
'2':'B',
'3':'C',
'4':'D',
'5':'E',
'6':'F'}

print(len(d4))

# Retornará o número de conjuntos de chaves:valores

6

Exibindo em tela somente as chaves e somente
os valores de um dicionário
d4 = {'1':'A',
'2':'B',
'3':'C',
'4':'D',
'5':'E',
'6':'F'}

print(d4.keys())
# Somente chaves

print(d4.values())
# Somente valores

dict_keys(['1', '2', '3', '4', '5', '6'])
dict_values(['A', 'B', 'C', 'D', 'E', 'F'])

Lendo as chaves/valores de um dicionário por
meio do laço for
d4 = {'1':'A',
'2':'B',
'3':'C'}

for i in d4.keys():
# somente as chaves
print('Chaves:', i)

for j in d4.values():
# somente os valores
print('Valores:', j)

for l in d4.items():
# chaves e valores
print('Chaves : Valores =', l)

Chaves: 1
Chaves: 2
Chaves: 3
Valores: A
Valores: B
Valores: C
Chaves : Valores = ('1', 'A')
Chaves : Valores = ('2', 'B')
Chaves : Valores = ('3', 'C')

# Itens desempacotados

d4 = {'1':'A',
'2':'B',
'3':'C'}

for m in d4.items():
print('Chaves:',m[0],' - ','Valores:',m[1])

Chaves: 1 - Valores: A
Chaves: 2 - Valores: B
Chaves: 3 - Valores: C

# Itens desempacotados e separados

d4 = {'1':'A',
'2':'B',
'3':'C'}

for n, o in d4.items():
# 2 variáveis temporárias n e o, referente às chaves e valores, resp
ectivamente
print(f'Chaves: {n}, Valores: {o}')

Chaves: 1, Valores: A
Chaves: 2, Valores: B
Chaves: 3, Valores: C

Listas como valores de uma chave do dicionário
dict = {'almox':['Folha de Oficio', 'Caneta', 'Grampeador'],
'cozinha':['Café', 'Açúcar']}

print(dict['almox'][0])

print(dict['cozinha'][1])

Folha de Oficio
Açúcar

dict = {'almox':['Folha de Oficio',
'Caneta',
'Grampeador'],
'cozinha':['Café',
'Açúcar']}

print(dict['almox'][0])
# Retornará o elemento de índice 0 dos valores referentes a chave a
lmox

print(dict['cozinha'][1])
# Retornará o elemento de índice 1 dos valores referentes a chave c
ozinha

Folha de Oficio
Açúcar

Transformando chaves ou valores de um
dicionário em tupla
'Idade':32,
'Sexo':'Masculino',

print(dicionario1.keys())

dict_chaves = tuple(dicionario1.keys())

print(dict_chaves)

print(dict_chaves[3])

# Lembrando que a transformação de uma lista para uma tupla norm
almente
# tem o propósito de tornar tais dados imutáveis, ou protegidos para
# certas modificações.

dict_keys(['Nome', 'Idade', 'Sexo', 'Nacionalidade'])
('Nome', 'Idade', 'Sexo', 'Nacionalidade')
Nacionalidade

Dicionários dentro de dicionários
usuarios = {'João':{'Identificador':'0001',
'Cargo':'Porteiro',
'Salario':'2000'},
'Maria':{'Identificador':'0003',
'Cargo':'Aux. Limpeza',
'Salario':'1900'},
'José':{'Identificador':'0002',
'Cargo':'Técnico',
'Salario':'2500'}}

for i, j in usuarios.items():
print(f'Funcionário: {i}')
for k, l in j.items():
print(f'\t {k} = {l}')

# Um laço for dentro de outro se faz necessário pois os valores são
uma
# camada a mais por se tratar de outro dicionário.

Funcionário: João
Identificador = 0001
Cargo = Porteiro
Salario = 2000
Funcionário: Maria
Cargo = Aux. Limpeza
Salario = 1900
Funcionário: José
Cargo = Técnico
Salario = 2500

Removendo elementos de um dicionário por meio
da função pop( )
'Idade':32,
'Sexo':'Masculino',

dicionario1.pop('Nacionalidade')

print(dicionario1)

# pop( ) pode remover um item específico quando parametrizado co
m o mesmo
# assim como quando usado sem nenhum parâmetro removerá o últ
imo conjunto
# de chaves:valores do dicionário.

{'Nome': 'Fernando', 'Idade': 32, 'Sexo': 'Masculino'}

Removendo elementos de um dicionário por meio
da função do sistema del
'Idade':32,
'Sexo':'Masculino',

del dicionario1['Nacionalidade']
# del seguido do objeto e de seu atributo específico

print(dicionario1)

{'Nome': 'Fernando', 'Idade': 32, 'Sexo': 'Masculino'}

Criando um dicionário, sendo suas chaves
importadas de uma lista e seus valores definidos
manualmente
lista = ['camisas',
'calcas',
'vestidos',
'sapatos',
'tenis',
'acessorios']

mercadoria = dict.fromkeys(lista, 0)

print(mercadoria)

mercadoria['camisas'] = 22
mercadoria['vestidos'] = 3
mercadoria['tenis'] = 10

print(mercadoria)

# Método fromkeys( ) recebe como primeiro parâmetro justaposto o
que se
# tornará as chaves, assim como para segundo parâmetro deve ser
repassado
# os dados que se tornarão os valores. Caso não haja dados iniciais
, é
# necessário preencher este campo com 0 para evitar conflitos.

{'camisas': 0, 'calcas': 0, 'vestidos': 0, 'sapatos': 0, 'tenis': 0,
'acessorios': 0}
{'camisas': 22, 'calcas': 0, 'vestidos': 3, 'sapatos': 0, 'tenis': 10,
'acessorios': 0}

Usando do método get( ) para não gerar
exceções quando um elemento inspecionado não
fizer parte do dicionário
dict1 = {'1':'A', '2':'B', '3':'C'}

print(dict1['1']) # ok
#print(dict1['4']) # chave não existente, irá gerar um KeyError

dict1.get('4')

# '4' é um elemento não existente, porém não será gerado um erro a
o tentar
# buscar dados/valores deste item.

A

Descobrindo a hash de um valor
'Idade':32,
'Sexo':'Masculino',

print(hash('Idade'))

# Chaves em um dicionário normalmente são dados imutáveis, em f
unção
# disso é possível descobrir sua hash de indexação interna.

3506287743454017275

Resumo de todos os métodos inclusos nos built-
ins
keys()
# Retorna uma lista contendo todas as chaves de um dicionário

values()
# Retorna uma lista contendo todos os valores de um dicionário

items()
# Retorna uma lista contendo tuplas com os pares de chaves e valor
es de um dicionário

get()
# Retorna o valor de uma chave específica

clear()
# Remove todos os elementos de um dicionário

copy()
# Associado a outra variável, retorna uma cópia do dicionário origina
l

fromkeys()
# Retorna um dicionário apenas com chaves e valores específicos

pop()
# Remove uma chave e seu respectivo valor

popitem()
# Remove o último par de chaves:valores inserido no dicionário

setdefault()
# Retorna o valor de uma chave específica, caso a mesma não exist
a, cria uma chave com valor padrão

update()
# Atualiza um dicionário inserindo no mesmo um novo par de chaves
:valores

Funções

Sintaxe básica
def nome_da_funcao(parametros):
"corpo da função"

Definindo uma função sem parâmetros
def exibe_mensagem():
print('Seja Bem-Vindo!!!')
# Quando executada a função será exibido em tela 'Seja Bem-
Vindo!!!'

print(exibe_mensagem())

Seja Bem-Vindo!!!
None

def exibe_mensagem():
return 'Seja Bem-Vindo!!!'
# Quando executada a função será retornado 'Seja Bem-Vindo!!!

print(exibe_mensagem())

Seja Bem-Vindo!!!

Chamando uma função
def mensagem():
print('Seja Bem Vindo!!!')

mensagem()

Seja Bem Vindo!!!

Instanciando uma função (função associada a
uma variável)
def mensagem():
print('Seja Bem Vindo!!!')

mensagem1 = mensagem()

print(mensagem1)

Seja Bem Vindo!!!
None

Criando uma função que temporariamente não
realiza nenhuma ação
def funcao():
pass

var1 = funcao()
# Não acontecerá absolutamente nada

print(type(var1))
# Retornará NoneType, pois é uma variável que não faz nada

<class 'NoneType'>

Função interagindo com variável que interage
com o usuário
usuario3 = input('Digite o seu nome:')

def mensagem(nome):
print(f'Bem Vindo {nome}!!!')

print(mensagem(usuario3))

Bem Vindo Fernando!!!
None

Parametrizando uma função
def funcao(msg):
print(msg)

funcao('Bem Vindo!!!')
# A string será repassada para a função, substituindo o campo do pa
râmetro
# msg por este dado/valor.

Bem Vindo!!!

Instanciando e parametrizando uma função
def mensagem(nome):
print(f'Bem Vindo(a) {nome}!!!')

usuario1 = mensagem('Fernando')

print(mensagem)

Bem Vindo(a) Fernando!!!
<function mensagem at 0x7f4356eef7a0>

Repassando mais de um parâmetro para função
def mensagem(nome, idade):
print(f'{nome} tem {idade} anos...')

usuario1 = mensagem('Fernando', 33)
# por justaposição, Fernando será repassado para nome, assim com
o 33 será
# repassado para idade, pois é a ordem a serem declarados tais arg
umentos

print(usuario1)

Fernando tem 33 anos...
None

Definindo parâmetros “padrão”
def funcao(msg, nome='usuário'):
print(msg, nome)

funcao('Olá')

# Ao chamar a função, repassando como parâmetro para a mesma
apenas Olá,
# por justaposição este argumento será atribuído a msg, já o segund
o
# parâmetro da função (nome) usará do valor padrão 'usuário'.

Olá usuário

Repassando apenas um parâmetro, recebendo
os demais padrão
def funcao(msg='Olá', nome='usuário', msg2='Seja Bem Vindo!!!'):
print(msg, nome, msg2)

funcao(nome='Fernando')

# Ao instanciar o parâmetro nome, atribuindo um novo dado/valor, o
# parâmetro padrão 'usuário' será substituído por 'Fernando'

Olá Fernando Seja Bem Vindo!!!

Passando parâmetro e interagindo com o usuário
def funcao(mensagem, nome):
print(mensagem, nome)

funcao('Olá', input('Digite o seu nome: '))

# Olá será atribuído para mensagem, assim como o que o usuário di
gitar
# como seu nome será repassado para o parâmetro nome.

Olá Fernando

# Interagindo com o usuário, exemplo 2

def funcao(msg='Ola', nome='usuário', msg2='Seja Bem Vindo!!!'):
print(msg, nome, msg2)

variavel1 = funcao()

# Inicialmente a função já possui um parâmetro nome com um valor
padrão,
# dentro de seu corpo existe a variável nome que recebe do usuário
um novo
# nome, caso o mesmo o digite, nome será atualizado, caso contrári
o, irá
# manter o padrão 'usuário'.

Ola Fernando Seja Bem Vindo!!!

# Interagindo com o usuário, exemplo 3

def funcao(msg='Ola', nome='usuário', msg2='Seja Bem Vindo!!!'):
return f'{msg} {nome}, {msg2}'

variavel1 = funcao(nome=input('Digite o seu nome: '))
# Chamando a função, diretamente pedindo ao usuário um dado/val
or a ser
# usado como parâmetro para nome.

print(variavel1)

Ola Fernando, Seja Bem Vindo!!!

Repassando um parâmetro manualmente fora da
ordem de justaposição
def msg(nome = 'Ana', idade = 25, prof = 'Cozinheira'):
print(f'{nome}, {idade} anos, {prof}')

variavel5 = msg(prof = 'Costureira')
# Sempre que é instanciado um parâmetro nomeado, a ordem do m
esmo não importa

print(msg)

Ana, 25 anos, Costureira
<function msg at 0x7f4356ea4b90>

Realizando operações dentro de uma função
# o código:

n1 = int(input('Digite o Primeiro Número: '))
n2 = int(input('Digite o Segundo Número: '))

print(f'O resultado da soma é: {n1 + n2}')

Digite o Primeiro Número: 15
Digite o Segundo Número: 37

# Pode ser reescrito por:

def soma(n1, n2):
return f'O resultado da soma é: {n1 + n2}'


print(soma(n1, n2))


# O exemplo anterior pode ser reescrito por:

def soma(n1, n2):
return n1 + n2


print(f'O resultado da soma é: {soma(n1, n2)}')
# Dentro da máscara de substituição é chamada a função soma( )
# parametrizando a mesma com os dados/valores de n1 e n2.


Realizando operações compostas dentro de uma
função
def aumento_percentual(valor, percentual):
return (valor + (valor * percentual / 100))

num1 = int(input('Digite o valor: '))
num2 = int(input('Você deseja somar quantos % ? '))

calculo = aumento_percentual(num1, num2)

print(f'O valor final será: {calculo}')

print(f'O valor final será: {round(calculo, 2)} reais ')

print(f'O valor final será: R${calculo:.2f} reais.')

Digite o valor: 180
Você deseja somar quantos % ? 6
O valor final será: 190.8
O valor final será: 190.8 reais
O valor final será: R$190.80 reais.

def aumento_percentual(valor, percentual):
return (valor + (valor * percentual / 100))
# Retornará o resultado da soma do valor referente ao primeiro par
âmetro pela
# multiplicação deste valor por um percentual aplicado, dividido por
100.

num1 = int(input('Digite o valor: '))
num2 = int(input('Você deseja somar quantos % ? '))

calculo = aumento_percentual(num1, num2)
# Variável calculo chama a função aumento_percentual() para metriz
ando a mesma
# com os dados atribuídos para num1 e num2 que por sua vez fora
m inseridos pelo
# usuário.

print(f'O valor final será: {calculo}')
# Dentro da máscara é instanciada a variável calculo

print(f'O valor final será: {round(calculo, 2)} reais ')

print(f'O valor final será: R${calculo:.2f} reais.')

Digite o valor: 500
Você deseja somar quantos % ? 3
O valor final será: 515.0
O valor final será: 515.0 reais
O valor final será: R$515.00 reais.

Estruturas condicionais dentro de funções
def repetidor(msg):
contador = 0
while contador < 5:
print(msg)
contador += 1

print(repetidor(msg=input('Digite algo para ser repetido 5 vezes: ')))

Digite algo para ser repetido 5 vezes: Python
Python
Python
Python
Python
Python

# Exemplo 2

def divisao(n1, n2):
if n1 == 0 or n2 == 0:
return 'Operação Inválida'
return n1 / n2

num1 = int(input('Digite o Primeiro Número:'))
num2 = int(input('Digite o Segundo Número:'))

print(f'O resultado da divisão é: {divisao(num1, num2)}')

Digite o Primeiro Número:99
Digite o Segundo Número:18
O resultado da divisão é: 5.5

# Exercício Fizz Buzz

def fizz_buzz(num):
if num % 3 == 0 and num % 5 == 0:
return f'FizzBuzz, {num} é divisível por 3 e por 5'
if num % 5 == 0:
return f'Buzz, {num} é divisível por 5'
if num % 3 == 0:
return f'Fizz, {num} é divisível por 3)'
return num

print(fizz_buzz(num=int(input('Digite um Número: '))))

Digite um Número: 15
FizzBuzz, 15 é divisível por 3 e por 5

*args – Função com argumentos externos
def funcao(*args):
for v in args:
print(v)

argumentos = (1, 2, 3, 'Paulo', 'Ana')

print(funcao(argumentos))

(1, 2, 3, 'Paulo', 'Ana')

Desempacotando uma lista para que seus
elementos virem argumentos da função
lista1 = ['nome', 'idade', 'sexo', 'nacionalidade']

def funcao(*args):
print('Informações Necessárias:')
print(args)

funcao(*lista1)

Informações Necessárias:
('nome', 'idade', 'sexo', 'nacionalidade')

Função com parâmetros baseados em *args e
**kwargs
# Supondo que está cadastrando senhas e usuários em um sistema

def funcao(*args, **kwargs):
print(args)
print(kwargs)

senhas_padrao = [12345, 11111, 54321]

resultado = funcao(*senhas_padrao, usuario='user', administrador='
admin')

print(resultado)

# senhas_padrao substituirá *args e o parametro nomeado aqui usu
ario substituirá **kwargs

(12345, 11111, 54321)
{'usuario': 'user', 'administrador': 'admin'}

# Buscando dados do modelo anterior

def funcao(*args, **kwargs):
nome = kwargs['usuario']
nome2 = kwargs['administrador']
senha1 = args[0]
senha2 = args[1]

print(f'O usuário padrão é: {nome}')
print(f'O administrador é:{nome2}')
print(f'A senha padrão é: {senha1}')
print(f'A senha alternativa é: {senha2}')

senhas_padrao = [12345, 11111]

funcao(*senhas_padrao, usuario='user', administrador='admin')

# senhas_padrao substituirá *args e o parametro nomeado aqui usu
ario substituirá **kwargs

O usuário padrão é: user
O administrador é:admin
A senha padrão é: 12345
A senha alternativa é: 11111

Função que recebe outra função como parâmetro
def msg_boas_vindas():
return 'Seja Muito Bem Vindo!!!'

def mestre(funcao):
return funcao()

executa = mestre(msg_boas_vindas)

print(executa)

Seja Muito Bem Vindo!!!

Função que recebe um tipo de dado como
parâmetro, e retorna outro tipo de dado pré-
definido
def funcao(valor: int) -> str: # recebe int, retorna string
return f'R$ {valor}'

var1 = input('Digite um valor: ')
var2 = funcao(var1)

print(var2)
print(type(var2))

Digite um valor: 59
R$ 59
<class 'str'>

Escopo Global Vs Escopo Local

variavel1 = 'Paulo'
# Escopo global / no corpo geral do código, iterável por qualquer obj
eto

def funcao1():
print(f'Print da variável do escopo global: {variavel1}')

funcao1()

def funcao2():
variavel2 = 'Maria'
# Escopo local / dentro do corpo da função, visível e iterável apena
s de
# dentro da função funcao2( )
print(f'Print da variável do escopo local: {variavel2}')

funcao2()

Print da variável do escopo global: Paulo
Print da variável do escopo local: Maria

Modificando uma variável global de dentro de
uma função
num1 = 100

print(f'Variável com seu valor inicial: {num1}')

def modificador():
global num1
num1 = 200
print(f'Variável alterada dentro da função: {num1}')

modificador()

print(f'Variável atualizada pela função modificador: {num1}')

Variável com seu valor inicial: 100
Variável alterada dentro da função: 200
Variável atualizada pela função modificador: 200

num1 = 100
# Valor inicial 100

print(f'Variável com seu valor inicial: {num1}')

def modificador():
global num1
# Instanciando a variável global num1 para fazer uso da mesma
num1 = 200
# Atualizando o valor de num1 para 200
print(f'Variável alterada dentro da função: {num1}')

modificador()

print(f'Variável atualizada pela função modificador: {num1}')

# Pela leitura léxica, o último valor atribuído a uma variável será
# seu valor atual, até que outro objeto a atualize novamente.

Sets (Conjuntos)

Sintaxe básica
set1 = {1, 2, 3, 4, 5, 6, 7, 8, 9, 0}

print(set1)
print(type(set1))

set2 = {1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 9, 9, 9, 9, 5, 6, 7}

print(set2)

# A diferença de um set para um dicionário será que um set não pos
sui
# par de elementos chave:valor. Um set não tem índice e os element
os
# guardados dentro dele ficam em ordem aleatória. Um set não pod
e ter
# elementos duplicados, caso houver, os mesmos serão ignorados.

{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
<class 'set'>
{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}

set2 = {1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 9, 9, 9, 9, 5, 6, 7}

print(set2[3])
# Irá gerar um erro pois em um set não é possível buscar um eleme
nto
# por meio de número de índice.

---------------------------------------------------------------------------
TypeError Traceback (most recent call last)
<ipython-input-1-245846a2b2c9> in <module>()
1 set2 = {1,2,3,4,5,6,7,8,9,0,9,9,9,9,5,6,7}
2
----> 3 print(set2[3])

TypeError: 'set' object is not subscriptable

Criando um set via construtor
set1 = set()
# Método construtor set( )

set1.add('Ana')
set1.add(23)

print(set1)

{'Ana', 23}

Adicionando/removendo elementos de um set
set2 = set()

set2.add(2001)
# add( ) para adicionar um novo elemento ao set

set2.add(500)
set2.add('Tânia')

print(set2)

set2.discard(500)
# discard( ) para remover um elemento do set

print(set2)

{2001, 'Tânia', 500}
{2001, 'Tânia'}

Convertendo lista para set para que sejam
removidos os elementos duplicados
lista1 = [1,1,2,3,4,4,4,4,4,5,6,7,8,9,'Luiz', 'Maria', 'Carlos', 'Luiz']
print(lista1)

lista1 = set(lista1)
# Transformando em set
print(lista1)

lista1 = list(lista1)
# Transformando em lista novamente
print(lista1)

[1, 1, 2, 3, 4, 4, 4, 4, 4, 5, 6, 7, 8, 9, 'Luiz', 'Maria', 'Carlos', 'Luiz']
{1, 2, 3, 4, 5, 6, 7, 8, 9, 'Carlos', 'Luiz', 'Maria'}
[1, 2, 3, 4, 5, 6, 7, 8, 9, 'Carlos', 'Luiz', 'Maria']

add()
# Adiciona um elemento ao set

pop()
# Remove um elemento específico do set

remove()

discard()

clear()
# Remove todos os elementos de um set

copy()
# Associado a outra variável, retorna uma cópia do set original

difference()
# Associado a outra variável, retorna um novo set contendo a diferen
ça entre dois sets

intersection()
# Associado a outra variável, retorna um novo set contendo a interse
ção de dois outros sets

union()
# Retorna um set contendo a união dos elementos de dois outros se
ts

update()
# Atualiza um set unindo seu conteúdo original com o de outro set

isdisjoint()
# Retorna True se dois sets tem uma interseção

issubset()
# Retorna True se outro set contém os elementos do set original

issuperset()
# Retorna True se o set original contém os elementos de outro set

Bool

Tipo de dado booleano
# Quase todo tipo de dado/valor válido será True quando verificado

# Qualquer string é True, exceto strings vazias

print(bool('Fernando'))

print(bool(''))

True
False

# Qualquer número é True, com exceção do 0

print(bool(1987))

print(bool(0))

True
False

# Qualquer lista, tupla, set ou dicionário é True, exceto quando vazio
s

nomes = ['Ana', 'Carolina', 'Jéssica']

print(bool(nomes))

lista = []

print(bool(lista))

True
False

# Expressão lógica/booleana diretamente na função print( )

print(bool(15 > 9))

print(bool(15 < 9))

True
False
# None retorna False

id = None

print(bool(id))

False

# Situações onde o retorno padrão (zero) é usado, será interpretado
de forma
# literal, logo, será False.

class MinhaClasse():
def __len__(self):
return 0

variavel1 = MinhaClasse()
print(bool(variavel1))

False

# Funções podem retornar um booleano

def minha_funcao():
return True

print(minha_funcao())

True

List Comprehension

Operações com elementos de uma lista usando
comprehension
lista1 = [1,2,3,4,5,6]
lista2 = [i * 2 for i in lista1]

# Variável temporária i que percorre cada elemento da lista1 e multip
lica por 2

print(lista1)
print(lista2)
[1, 2, 3, 4, 5, 6]
[2, 4, 6, 8, 10, 12]

Desmembrando uma string elemento por
elemento
string = '12345678901234567890'
comprehension = [letra for letra in string]

print(comprehension)

['1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0']

Extraindo partes de uma string
string = '123456789012345678905925249529562956243482649287
529843482548258922'

print(string[0:10])

print(string[10:20])


1234567890
1234567890
5925249529

Trabalhando com partes de uma string
string = '012345678901234567890123456789012345678901234567
89'
n = 10
comp = [i for i in range(0, len(string), n)]
# Separando a string de 10 em 10 de acordo com a variável n

print(comp)

comp2 = [(i, i + n) for i in range(0, len(string), n)]
# Verificando de quanto a quanto é esse intervalo

print(comp2)

comp3 = [string[i:i + n] for i in range(0, len(string), n)]
# Realizando o fatiamento de nossa string

print(comp3)

lista = [string[i:i + n] for i in range(0, len(string), n)]
retorno = '.'.join(lista)
# Caractere "." usado como separador. join( ) para juntar novamente
os elementos da lista

print(retorno)

[0, 10, 20, 30, 40]
[(0, 10), (10, 20), (20, 30), (30, 40), (40, 50)]
['0123456789', '0123456789', '0123456789', '0123456789',
'0123456789']
0123456789.0123456789.0123456789.0123456789.0123456789

Otimizando um código mudando sua função por
uma comprehension
carrinho = []
carrinho.append(('Item 1', 30))
total = 0

for produto in carrinho:
total = total + produto[1]

print('Método tradicional', total)

Método tradicional 97

# Mesmo que:

carrinho = []
total2 = []

total2.append(produto[1])
print('Usando funções internas', sum(total2))

Usando funções internas 97

# Usando list comprehension

carrinho = []

total3 = sum([y for x, y in carrinho])

print(f'Usando list comprehension {total3}')

Usando list comprehension 97

# Estrutura Inicial

carrinho = []
total = 0
print(f'O valor total é: R$ {total}')

# Código Otimizado

print(f'O Valor total é: R$ {total2}')

O valor total é: R$ 196
O Valor total é: R$ 196

Dictionary Comprehension

# Basicamente a mesma lógica implementada de list comprehension
,
# mas quando temos chave:valor podemos transormar em dicionário
.

lista = [('chave1','chave2'), ('chave2','valor2'),('chave3','valor3')]

dicionario = {x:y for x, y in lista}
# Mesmo que dicionario = dict(lista)

print(dicionario)

{'chave1': 'chave2', 'chave2': 'valor2', 'chave3': 'valor3'}

Realizando operações dentro de um dicionário
via comprehension
produtos = [('Caneta',1.99), ('Lápis',1.49), ('Caderno',8.99)]

produtos_com_imposto = {x:y * 1.6 for x, y in produtos}

print('Preços SEM Imposto: ', produtos)
print('Preços COM Imposto: ', produtos_com_imposto)

Preços SEM Imposto: [('Caneta', 1.99), ('Lápis', 1.49), ('Caderno',
8.99)]
Preços COM Imposto: {'Caneta': 3.184, 'Lápis': 2.384, 'Caderno':
14.384}

Geradores e Iteradores

# Um objeto iterável é aquele com que você consegue interagir
# com cada elemento de sua composição, ex cada letra de uma strin
g

lista = [1,2,3,4]
nome = 'Fernando'

for i in lista:
print(i)

for j in nome:
print(j)

1
2
3
4
F
e
r
n
a
n
d
o

Gerando valores como alternativa para otimizar o
código
lista_0_a_100 = list(range(101))

print(lista_0_a_100)

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20,
21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38,
39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56,
57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74,
75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92,
93, 94, 95, 96, 97, 98, 99, 100]

# Porém dados gerados com muitos elementos tem impacto sobre a
memória

import sys

lista100 = list(range(101))
listamilhao = list(range(1000001))

print('Tamanho em bytes:', sys.getsizeof(lista100))
print('Tamanho em bytes:', sys.getsizeof(listamilhao))

Tamanho em bytes: 1024
Tamanho em bytes: 9000128

Zip

Iterando e unindo listas via zip( )
cidades = ['Porto Alegre', 'Curitiba',
'Salvador', 'Belo Horizonte']
estados = ['RS', 'PR', 'BH', 'MG']

cidades_estados = zip(cidades, estados)

for i in cidades_estados:
print(i)

# Pareia cada elemento de uma lista com o mesmo elemento equiva
lente
# em índice de outra lista.

('Porto Alegre', 'RS')
('Curitiba', 'PR')
('Salvador', 'BH')
('Belo Horizonte', 'MG')

Zip_longest para iterar e unir listas de diferentes
tamanhos
from itertools import zip_longest

cidades = ['Porto Alegre', 'Curitiba',
'Salvador', 'Belo Horizonte',
'Rio de Janeiro', 'Goiânia']

estados = ['RS', 'PR', 'BH', 'MG']

cidades_estados = zip_longest(cidades, estados)

cidades_estados2 = zip_longest(cidades,
estados,
fillvalue='Desconhecido')

for i in cidades_estados:
print(i)

for j in cidades_estados2:
print(j)

('Curitiba', 'PR')
('Salvador', 'BH')
('Rio de Janeiro', None)
('Goiânia', None)
('Curitiba', 'PR')
('Salvador', 'BH')
('Rio de Janeiro', 'Desconhecido')
('Goiânia', 'Desconhecido')

Count

Usando do contador do sistema
from itertools import count
contador = count()

for numero in contador:
print(numero)
if numero >= 10:
break

0
1
2
3
4
5
6
7
8
9
10

Contando dentro de um intervalo personalizado
contador = count(start = 40)

print(numero)
if numero >= 50:
break

40
41
42
43
44
45
46
47
48
49
50

Personalizando de quantos em quantos números
o contador irá trabalhar
contador = count(start = 0, step = 2)

print(numero)
if numero >= 20:
break

0
2
4
6
8
10
12
14
16
18
20

Map

Aplicando uma função em cada elemento, ou
linha por linha de uma lista/dicionário
lista = [1,2,3,4,5,6,7,8,9,10]

nova_lista = map(lambda x: x * 2, lista)

# Mesmo que:
nova_lista2 = [x * 2 for x in lista]

print(lista)
print(list(nova_lista))

print(nova_lista2)

# map( ) permite iterar individualmente sobre cada elemento de um
# contêiner de dados.

[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
[2, 4, 6, 8, 10, 12, 14, 16, 18, 20]
[2, 4, 6, 8, 10, 12, 14, 16, 18, 20]

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

nova_lista = map(lambda x: x * 2, lista)
# map( ) recebe como parâmetros em justaposição uma função (pod
endo ser lambda)
# seguido de uma variável onde irá iterar sobre seus dados.

# Mesmo que:
nova_lista2 = [x * 2 for x in lista]

print(lista)
print(list(nova_lista))

print(nova_lista2)

[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
[2, 4, 6, 8, 10, 12, 14, 16, 18, 20]
[2, 4, 6, 8, 10, 12, 14, 16, 18, 20]

Usando map( ) para extrair dados de um
dicionário
produtos = [
{'nome': 'item 1', 'preco': 32},
]

precos = map(lambda p: p['preco'], produtos)
# Combinando map( ) com lambda, extraindo dado por dado apenas
do campo 'preco'

for preco in precos:
print(preco)

32
23
12
10
55

Usando uma função ativa no lugar da lambda
def aumenta_precos(p):
p['preco'] = p['preco'] * 1.05
return p

precos2 = map(aumenta_precos, produtos)
# Função aumenta_precos( ) como parâmetro de map( )

for produto in precos2:
print(produto)

{'nome': 'item 1', 'preco': 33.6}
{'nome': 'item 2', 'preco': 24.150000000000002}
{'nome': 'item 3', 'preco': 12.600000000000001}
{'nome': 'item 4', 'preco': 10.5}
{'nome': 'item 5', 'preco': 57.75}

Filter

Aplicando funções sobre dados usando de lógica
condicional
pessoas = [
{'nome': 'Ana', 'idade': 22},
{'nome': 'Maria', 'idade': 72},
{'nome': 'Paulo', 'idade': 55},
{'nome': 'Pedro', 'idade': 68},
{'nome': 'Rafael', 'idade': 99},
{'nome': 'Tania', 'idade': 18},
]

idosos = filter(lambda x: x['idade'] > 70, pessoas)
# filter( ) pode receber como parâmetro uma função associada a um
a
# expressão lógica, iterando individualmente sobre os elementos de
# um contêiner de dados.

print(list(idosos))

[{'nome': 'Maria', 'idade': 72}, {'nome': 'Rafael', 'idade': 99}]

produtos2 = [
]

def filtra(p):
if p['preco'] > 50:
return True

nova_lista3 = filter(filtra, produtos2)
for produtox in nova_lista3:
print(produtox)

# É perfeitamente possível usar de uma função externa como parâm
etro
# de filter( ).

{'nome': 'item 3', 'preco': 62}
{'nome': 'item 5', 'preco': 55}

Reduce

from functools import reduce

def soma(num1, num2):
return num1 + num2

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

resultado = reduce(soma, lista)

print(resultado)

# reduce( ) "reduz" todo um conjunto de elementos de um contêiner
de dados
# a um elemento único, resultado da soma de todos os elementos d
e um contêiner
# de dados.

55

Try, Except

Tratando exceções para que não se interrompa a
execução de um programa
try:
print(a)
except:
pass

# Nesse caso nada acontecerá, mas também não acontecerá um err
o ou
# interrupção em função de não conseguir executar o comando print
(a).

try:
print(av)
except:
print('A Variável Não Existe!!!')

# Como a tentativa de exibir o conteúdo de av não obteve sucesso,
então
# via except é exibida em tela uma mensagem de erro.

A Variável Não Existe!!!

Exibindo em tela que erro específico ocorreu
try:
print(ax)
except NameError as erro:
print('Ocorreu um erro:', erro)

Ocorreu um erro: name 'ax' is not defined

Asserções

# Gera uma exceção personalizada, e sua declaração é reduzida se
comparado
# a outras estruturas de validação de erros.

def cadastro(nome, idade):
assert idade >= 18 and idade <= 65, 'Idade do funcionário deve est
ar entre 18 e 65 anos.'
print(f'{nome} está em idade ativa, pois possui {idade} anos.')

idade = 71
nome = 'Fernando'

verificador = cadastro(nome, idade)

---------------------------------------------------------------------------
AssertionError Traceback (most recent call last)
<ipython-input-302-e2ce4e7789e6> in <module>()
9 nome = 'Fernando'
10
---> 11 verificador = cadastro(nome, idade)

<ipython-input-302-e2ce4e7789e6> in cadastro(nome, idade)
3
4 def cadastro(nome, idade):
----> 5 assert idade >= 18 and idade <= 65, 'Idade do funcionário
deve estar entre 18 e 65 anos.'
6 print(f'{nome} está em idade ativa, pois possui {idade} anos.')
7

AssertionError: Idade do funcionário deve estar entre 18 e 65 anos.

Bibliotecas, Módulos e Pacotes

Função dir( ) exibe quais bibliotecas e módulos
foram carregados por padrão
dir()

['In',
'MinhaClasse',
'Out',
'_',
'_204',
'_205',
'_24',
'__',
'___',
'__builtin__',
'__builtins__',
'__doc__',
'__loader__',
'__name__',
'__package__',
'__spec__',
'_dh',
'_i',
'_i1',
'_i10',
'_i100',
'_i101',
'_i102',
'_i103',
'_i104',
'_i105',
'_i106',
'_i107',
'_i108',
'_i109',
'_i11',
'_i110',
'_i111',
'_i112',
'_i113',
'_i114',
'_i115',
'_i116',
'_i117',
'_i118',
'_i119',
'_i12',
'_i120',
'_i121',
'_i122',
'_i123',
'_i124',
'_i125',
'_i126',
'_i127',
'_i128',
'_i129',
'_i13',
'_i130',
'_i131',
'_i132',
'_i133',
'_i134',
'_i135',
'_i136',
'_i137',
'_i138',
'_i139',
'_i14',
'_i140',
'_i141',
'_i142',
'_i143',
'_i144',
'_i145',
'_i146',
'_i147',
'_i148',
'_i149',
'_i15',
'_i150',
'_i151',
'_i152',
'_i153',
'_i154',
'_i155',
'_i156',
'_i157',
'_i158',
'_i159',
'_i16',
'_i160',
'_i161',
'_i162',
'_i163',
'_i164',
'_i165',
'_i166',
'_i167',
'_i168',
'_i169',
'_i17',
'_i170',
'_i171',
'_i172',
'_i173',
'_i174',
'_i175',
'_i176',
'_i177',
'_i178',
'_i179',
'_i18',
'_i180',
'_i181',
'_i182',
'_i183',
'_i184',
'_i185',
'_i186',
'_i187',
'_i188',
'_i189',
'_i19',
'_i190',
'_i191',
'_i192',
'_i193',
'_i194',
'_i195',
'_i196',
'_i197',
'_i198',
'_i199',
'_i2',
'_i20',
'_i200',
'_i201',
'_i202',
'_i203',
'_i204',
'_i205',
'_i206',
'_i207',
'_i208',
'_i209',
'_i21',
'_i210',
'_i211',
'_i212',
'_i213',
'_i214',
'_i215',
'_i216',
'_i217',
'_i218',
'_i219',
'_i22',
'_i220',
'_i221',
'_i222',
'_i223',
'_i224',
'_i225',
'_i226',
'_i227',
'_i228',
'_i229',
'_i23',
'_i230',
'_i231',
'_i232',
'_i233',
'_i234',
'_i235',
'_i236',
'_i237',
'_i238',
'_i239',
'_i24',
'_i240',
'_i241',
'_i242',
'_i243',
'_i244',
'_i245',
'_i246',
'_i247',
'_i248',
'_i249',
'_i25',
'_i250',
'_i251',
'_i252',
'_i253',
'_i254',
'_i255',
'_i256',
'_i257',
'_i258',
'_i259',
'_i26',
'_i260',
'_i261',
'_i262',
'_i263',
'_i264',
'_i265',
'_i266',
'_i267',
'_i268',
'_i269',
'_i27',
'_i270',
'_i271',
'_i272',
'_i273',
'_i274',
'_i275',
'_i276',
'_i277',
'_i278',
'_i279',
'_i28',
'_i280',
'_i281',
'_i282',
'_i283',
'_i284',
'_i285',
'_i286',
'_i287',
'_i288',
'_i289',
'_i29',
'_i290',
'_i291',
'_i292',
'_i293',
'_i294',
'_i295',
'_i296',
'_i297',
'_i298',
'_i299',
'_i3',
'_i30',
'_i300',
'_i301',
'_i302',
'_i303',
'_i31',
'_i32',
'_i33',
'_i34',
'_i35',
'_i36',
'_i37',
'_i38',
'_i39',
'_i4',
'_i40',
'_i41',
'_i42',
'_i43',
'_i44',
'_i45',
'_i46',
'_i47',
'_i48',
'_i49',
'_i5',
'_i50',
'_i51',
'_i52',
'_i53',
'_i54',
'_i55',
'_i56',
'_i57',
'_i58',
'_i59',
'_i6',
'_i60',
'_i61',
'_i62',
'_i63',
'_i64',
'_i65',
'_i66',
'_i67',
'_i68',
'_i69',
'_i7',
'_i70',
'_i71',
'_i72',
'_i73',
'_i74',
'_i75',
'_i76',
'_i77',
'_i78',
'_i79',
'_i8',
'_i80',
'_i81',
'_i82',
'_i83',
'_i84',
'_i85',
'_i86',
'_i87',
'_i88',
'_i89',
'_i9',
'_i90',
'_i91',
'_i92',
'_i93',
'_i94',
'_i95',
'_i96',
'_i97',
'_i98',
'_i99',
'_ih',
'_ii',
'_iii',
'_oh',
'_sh',
'a',
'a1',
'agua',
'alerta',
'altura',
'aluguel',
'animal',
'ano_nasc',
'ano_nasc2',
'argumentos',
'aumenta_precos',
'aumento_percentual',
'aviso',
'b',
'base',
'c',
'c1',
'c2',
'c3',
'cadastro',
'calca',
'calculo',
'camisa',
'carrinho',
'cidades',
'cidades_estados',
'cidades_estados2',
'cj1',
'cj2',
'codigo',
'codigo1',
'codigo2',
'comp',
'comp2',
'comp3',
'compras',
'comprehension',
'condicao1',
'conjunto1',
'conjunto2',
'conjunto3',
'contador',
'cor1',
'cor2',
'cores',
'count',
'd3',
'd4',
'dicionario',
'dicionario1',
'dicionario2',
'dict',
'dict1',
'dict_chaves',
'divisao',
'elemento',
'energia',
'equacao',
'estados',
'executa',
'exibe_mensagem',
'exit',
'exp',
'fatura',
'filtra',
'fizz_buzz',
'frase1',
'frase2',
'frase3',
'funcao',
'funcao1',
'funcao2',
'funcionarias_mulheres',
'funcionarios_homens',
'get_ipython',
'i',
'id',
'idade',
'idosos',
'intersecao',
'intersecao2',
'itens',
'j',
'k',
'l',
'largura',
'letras',
'lista',
'lista1',
'lista100',
'lista2',
'lista5',
'lista6',
'lista_0_a_100',
'lista_compras',
'listamilhao',
'login',
'm',
'mensagem',
'mensagem1',
'mercadoria',
'mestre',
'minha_funcao',
'modificador',
'msg',
'msg_boas_vindas',
'n',
'n1',
'n2',
'n_indice',
'nome',
'nome1',
'nome2',
'nome3',
'nome4',
'nome_da_funcao',
'nome_de_variavel',
'nomes',
'nova_lista',
'nova_lista2',
'nova_lista3',
'num',
'num1',
'num2',
'num3',
'num4',
'numero',
'numero3',
'o',
'palavra1',
'palavra2',
'pessoa',
'pessoas',
'pessoas1',
'pessoas2',
'pilha',
'preco',
'precos',
'precos2',
'produto',
'produtos',
'produtos2',
'produtos_com_imposto',
'produtox',
'quit',
'reduce',
'repetidor',
'repetir',
'resultado',
'retorno',
'senhas_padrao',
'sequencia',
'set1',
'set2',
'sexo',
'soma',
'string',
'sys',
'tema',
'todas_pessoas',
'topo',
'total',
'total2',
'total3',
'tupla',
'uniao',
'uniao2',
'usuario',
'usuario1',
'usuario3',
'usuarios',
'validador',
'valor',
'var1',
'var2',
'var_bool',
'var_comentario',
'var_dicionario',
'var_float',
'var_int',
'var_lista',
'var_set',
'var_string',
'var_tupla',
'variavel',
'variavel1',
'variavel5',
'veiculo1',
'veiculo2',
'veiculo3',
'vendas',
'x',
'y',
'z',
'zip_longest']

Explorando tudo o que vem importado por padrão
import builtins

dir(builtins)

['ArithmeticError',
'AssertionError',
'AttributeError',
'BaseException',
'BlockingIOError',
'BrokenPipeError',
'BufferError',
'BytesWarning',
'ChildProcessError',
'ConnectionAbortedError',
'ConnectionError',
'ConnectionRefusedError',
'ConnectionResetError',
'DeprecationWarning',
'EOFError',
'Ellipsis',
'EnvironmentError',
'Exception',
'False',
'FileExistsError',
'FileNotFoundError',
'FloatingPointError',
'FutureWarning',
'GeneratorExit',
'IOError',
'ImportError',
'ImportWarning',
'IndentationError',
'IndexError',
'InterruptedError',
'IsADirectoryError',
'KeyError',
'KeyboardInterrupt',
'LookupError',
'MemoryError',
'ModuleNotFoundError',
'NameError',
'None',
'NotADirectoryError',
'NotImplemented',
'NotImplementedError',
'OSError',
'OverflowError',
'PendingDeprecationWarning',
'PermissionError',
'ProcessLookupError',
'RecursionError',
'ReferenceError',
'ResourceWarning',
'RuntimeError',
'RuntimeWarning',
'StopAsyncIteration',
'StopIteration',
'SyntaxError',
'SyntaxWarning',
'SystemError',
'SystemExit',
'TabError',
'TimeoutError',
'True',
'TypeError',
'UnboundLocalError',
'UnicodeDecodeError',
'UnicodeEncodeError',
'UnicodeError',
'UnicodeTranslateError',
'UnicodeWarning',
'UserWarning',
'ValueError',
'Warning',
'ZeroDivisionError',
'__IPYTHON__',
'__build_class__',
'__debug__',
'__doc__',
'__import__',
'__loader__',
'__name__',
'__package__',
'__spec__',
'abs',
'all',
'any',
'ascii',
'bin',
'bool',
'breakpoint',
'bytearray',
'bytes',
'callable',
'chr',
'classmethod',
'compile',
'complex',
'copyright',
'credits',
'delattr',
'dict',
'dir',
'display',
'divmod',
'dreload',
'enumerate',
'eval',
'exec',
'filter',
'float',
'format',
'frozenset',
'get_ipython',
'getattr',
'globals',
'hasattr',
'hash',
'help',
'hex',
'id',
'input',
'int',
'isinstance',
'issubclass',
'iter',
'len',
'license',
'list',
'locals',
'map',
'max',
'memoryview',
'min',
'next',
'object',
'oct',
'open',
'ord',
'pow',
'print',
'property',
'range',
'repr',
'reversed',
'round',
'set',
'setattr',
'slice',
'sorted',
'staticmethod',
'str',
'sum',
'super',
'tuple',
'type',
'vars',
'zip']

Importando bibliotecas, módulos e pacotes que
por padrão não são carregados na inicialização
do núcleo Python
import random

dir()

# Agora random( ) está carregada na memória e pronta para uso

['In',
'MinhaClasse',
'Out',
'_',
'_204',
'_205',
'_24',
'_303',
'_304',
'__',
'___',
'__builtin__',
'__builtins__',
'__doc__',
'__loader__',
'__name__',
'__package__',
'__spec__',
'_dh',
'_i',
'_i1',
'_i10',
'_i100',
'_i101',
'_i102',
'_i103',
'_i104',
'_i105',
'_i106',
'_i107',
'_i108',
'_i109',
'_i11',
'_i110',
'_i111',
'_i112',
'_i113',
'_i114',
'_i115',
'_i116',
'_i117',
'_i118',
'_i119',
'_i12',
'_i120',
'_i121',
'_i122',
'_i123',
'_i124',
'_i125',
'_i126',
'_i127',
'_i128',
'_i129',
'_i13',
'_i130',
'_i131',
'_i132',
'_i133',
'_i134',
'_i135',
'_i136',
'_i137',
'_i138',
'_i139',
'_i14',
'_i140',
'_i141',
'_i142',
'_i143',
'_i144',
'_i145',
'_i146',
'_i147',
'_i148',
'_i149',
'_i15',
'_i150',
'_i151',
'_i152',
'_i153',
'_i154',
'_i155',
'_i156',
'_i157',
'_i158',
'_i159',
'_i16',
'_i160',
'_i161',
'_i162',
'_i163',
'_i164',
'_i165',
'_i166',
'_i167',
'_i168',
'_i169',
'_i17',
'_i170',
'_i171',
'_i172',
'_i173',
'_i174',
'_i175',
'_i176',
'_i177',
'_i178',
'_i179',
'_i18',
'_i180',
'_i181',
'_i182',
'_i183',
'_i184',
'_i185',
'_i186',
'_i187',
'_i188',
'_i189',
'_i19',
'_i190',
'_i191',
'_i192',
'_i193',
'_i194',
'_i195',
'_i196',
'_i197',
'_i198',
'_i199',
'_i2',
'_i20',
'_i200',
'_i201',
'_i202',
'_i203',
'_i204',
'_i205',
'_i206',
'_i207',
'_i208',
'_i209',
'_i21',
'_i210',
'_i211',
'_i212',
'_i213',
'_i214',
'_i215',
'_i216',
'_i217',
'_i218',
'_i219',
'_i22',
'_i220',
'_i221',
'_i222',
'_i223',
'_i224',
'_i225',
'_i226',
'_i227',
'_i228',
'_i229',
'_i23',
'_i230',
'_i231',
'_i232',
'_i233',
'_i234',
'_i235',
'_i236',
'_i237',
'_i238',
'_i239',
'_i24',
'_i240',
'_i241',
'_i242',
'_i243',
'_i244',
'_i245',
'_i246',
'_i247',
'_i248',
'_i249',
'_i25',
'_i250',
'_i251',
'_i252',
'_i253',
'_i254',
'_i255',
'_i256',
'_i257',
'_i258',
'_i259',
'_i26',
'_i260',
'_i261',
'_i262',
'_i263',
'_i264',
'_i265',
'_i266',
'_i267',
'_i268',
'_i269',
'_i27',
'_i270',
'_i271',
'_i272',
'_i273',
'_i274',
'_i275',
'_i276',
'_i277',
'_i278',
'_i279',
'_i28',
'_i280',
'_i281',
'_i282',
'_i283',
'_i284',
'_i285',
'_i286',
'_i287',
'_i288',
'_i289',
'_i29',
'_i290',
'_i291',
'_i292',
'_i293',
'_i294',
'_i295',
'_i296',
'_i297',
'_i298',
'_i299',
'_i3',
'_i30',
'_i300',
'_i301',
'_i302',
'_i303',
'_i304',
'_i305',
'_i31',
'_i32',
'_i33',
'_i34',
'_i35',
'_i36',
'_i37',
'_i38',
'_i39',
'_i4',
'_i40',
'_i41',
'_i42',
'_i43',
'_i44',
'_i45',
'_i46',
'_i47',
'_i48',
'_i49',
'_i5',
'_i50',
'_i51',
'_i52',
'_i53',
'_i54',
'_i55',
'_i56',
'_i57',
'_i58',
'_i59',
'_i6',
'_i60',
'_i61',
'_i62',
'_i63',
'_i64',
'_i65',
'_i66',
'_i67',
'_i68',
'_i69',
'_i7',
'_i70',
'_i71',
'_i72',
'_i73',
'_i74',
'_i75',
'_i76',
'_i77',
'_i78',
'_i79',
'_i8',
'_i80',
'_i81',
'_i82',
'_i83',
'_i84',
'_i85',
'_i86',
'_i87',
'_i88',
'_i89',
'_i9',
'_i90',
'_i91',
'_i92',
'_i93',
'_i94',
'_i95',
'_i96',
'_i97',
'_i98',
'_i99',
'_ih',
'_ii',
'_iii',
'_oh',
'_sh',
'a',
'a1',
'agua',
'alerta',
'altura',
'aluguel',
'animal',
'ano_nasc',
'ano_nasc2',
'argumentos',
'aumenta_precos',
'aumento_percentual',
'aviso',
'b',
'base',
'builtins',
'c',
'c1',
'c2',
'c3',
'cadastro',
'calca',
'calculo',
'camisa',
'carrinho',
'cidades',
'cidades_estados',
'cidades_estados2',
'cj1',
'cj2',
'codigo',
'codigo1',
'codigo2',
'comp',
'comp2',
'comp3',
'compras',
'comprehension',
'condicao1',
'conjunto1',
'conjunto2',
'conjunto3',
'contador',
'cor1',
'cor2',
'cores',
'count',
'd3',
'd4',
'dicionario',
'dicionario1',
'dicionario2',
'dict',
'dict1',
'dict_chaves',
'divisao',
'elemento',
'energia',
'equacao',
'estados',
'executa',
'exibe_mensagem',
'exit',
'exp',
'fatura',
'filtra',
'fizz_buzz',
'frase1',
'frase2',
'frase3',
'funcao',
'funcao1',
'funcao2',
'funcionarias_mulheres',
'funcionarios_homens',
'get_ipython',
'i',
'id',
'idade',
'idosos',
'intersecao',
'intersecao2',
'itens',
'j',
'k',
'l',
'largura',
'letras',
'lista',
'lista1',
'lista100',
'lista2',
'lista5',
'lista6',
'lista_0_a_100',
'lista_compras',
'listamilhao',
'login',
'm',
'mensagem',
'mensagem1',
'mercadoria',
'mestre',
'minha_funcao',
'modificador',
'msg',
'msg_boas_vindas',
'n',
'n1',
'n2',
'n_indice',
'nome',
'nome1',
'nome2',
'nome3',
'nome4',
'nome_da_funcao',
'nome_de_variavel',
'nomes',
'nova_lista',
'nova_lista2',
'nova_lista3',
'num',
'num1',
'num2',
'num3',
'num4',
'numero',
'numero3',
'o',
'palavra1',
'palavra2',
'pessoa',
'pessoas',
'pessoas1',
'pessoas2',
'pilha',
'preco',
'precos',
'precos2',
'produto',
'produtos',
'produtos2',
'produtos_com_imposto',
'produtox',
'quit',
'random',
'reduce',
'repetidor',
'repetir',
'resultado',
'retorno',
'senhas_padrao',
'sequencia',
'set1',
'set2',
'sexo',
'soma',
'string',
'sys',
'tema',
'todas_pessoas',
'topo',
'total',
'total2',
'total3',
'tupla',
'uniao',
'uniao2',
'usuario',
'usuario1',
'usuario3',
'usuarios',
'validador',
'valor',
'var1',
'var2',
'var_bool',
'var_comentario',
'var_dicionario',
'var_float',
'var_int',
'var_lista',
'var_set',
'var_string',
'var_tupla',
'variavel',
'variavel1',
'variavel5',
'veiculo1',
'veiculo2',
'veiculo3',
'vendas',
'x',
'y',
'z',
'zip_longest'
‘random’]

Verificando tudo o que existe dentro de um
módulo/pacote externo
dir(random)

# Todas linhas após '__spec__' são os nomes das funções da
# biblioteca random disponíveis para serem usadas.

['BPF',
'LOG4',
'NV_MAGICCONST',
'RECIP_BPF',
'Random',
'SG_MAGICCONST',
'SystemRandom',
'TWOPI',
'_BuiltinMethodType',
'_MethodType',
'_Sequence',
'_Set',
'__all__',
'__builtins__',
'__cached__',
'__doc__',
'__file__',
'__loader__',
'__name__',
'__package__',
'__spec__',
'_acos',
'_bisect',
'_ceil',
'_cos',
'_e',
'_exp',
'_inst',
'_itertools',
'_log',
'_os',
'_pi',
'_random',
'_sha512',
'_sin',
'_sqrt',
'_test',
'_test_generator',
'_urandom',
'_warn',
'betavariate',
'choice',
'choices',
'expovariate',
'gammavariate',
'gauss',
'getrandbits',
'getstate',
'lognormvariate',
'normalvariate',
'paretovariate',
'randint',
'random',
'randrange',
'sample',
'seed',
'setstate',
'shuffle',
'triangular',
'uniform',
'vonmisesvariate',
'weibullvariate']

Explorando as funcionalidades de uma biblioteca,
módulo ou pacote
import random

help(random)

Help on module random:

NAME
random - Random variable generators.

MODULE REFERENCE
https://docs.python.org/3.7/library/random

The following documentation is automatically generated from the
Python
source files. It may be incomplete, incorrect or include features
that
are considered implementation detail and may vary between
Python
implementations. When in doubt, consult the module reference at
the
location listed above.

DESCRIPTION
integers
--------
uniform within range

sequences
---------
pick random element
pick random sample
pick weighted random sample
generate random permutation

distributions on the real line:
------------------------------
uniform
triangular
normal (Gaussian)
lognormal
negative exponential
gamma
beta
pareto
Weibull

distributions on the circle (angles 0 to 2pi)
---------------------------------------------
circular uniform
von Mises

General notes on the underlying Mersenne Twister core
generator:

* The period is 2**19937-1.
* It is one of the most extensively tested generators in existence.
* The random() method is implemented in C, executes in a single
Python step,
and is, therefore, threadsafe.

CLASSES
_random.Random(builtins.object)
Random
SystemRandom

class Random(_random.Random)
| Random(x=None)
|
| Random number generator base class used by bound module
functions.
|
| Used to instantiate instances of Random to get generators that
don't
| share state.
|
| Class Random can also be subclassed if you want to use a
different basic
| generator of your own devising: in that case, override the
following
| methods: random(), seed(), getstate(), and setstate().
| Optionally, implement a getrandbits() method so that
randrange()
| can cover arbitrarily large ranges.
|
| Method resolution order:
| Random
| _random.Random
| builtins.object
|
| Methods defined here:
|
| __getstate__(self)
| # Issue 17489: Since __reduce__ was defined to fix #759889
this is no
| # longer called; we leave it here because it has been here
since random was
| # rewritten back in 2001 and why risk breaking something.
|
| __init__(self, x=None)
| Initialize an instance.
|
| Optional argument x controls seeding, as for Random.seed().
|
| __reduce__(self)
| Helper for pickle.
|
| __setstate__(self, state)
|
| betavariate(self, alpha, beta)
| Beta distribution.
|
| Conditions on the parameters are alpha > 0 and beta > 0.
| Returned values range between 0 and 1.
|
| choice(self, seq)
| Choose a random element from a non-empty sequence.
|
| choices(self, population, weights=None, *, cum_weights=None,
k=1)
| Return a k sized list of population elements chosen with
replacement.
|
| If the relative weights or cumulative weights are not specified,
| the selections are made with equal probability.
|
| expovariate(self, lambd)
| Exponential distribution.
|
| lambd is 1.0 divided by the desired mean. It should be
| nonzero. (The parameter would be called "lambda", but that
is
| a reserved word in Python.) Returned values range from 0 to
| positive infinity if lambd is positive, and from negative
| infinity to 0 if lambd is negative.
|
| gammavariate(self, alpha, beta)
| Gamma distribution. Not the gamma function!
|
|
| The probability distribution function is:
|
| x ** (alpha - 1) * math.exp(-x / beta)
| pdf(x) = --------------------------------------
| math.gamma(alpha) * beta ** alpha
|
| gauss(self, mu, sigma)
| Gaussian distribution.
|
| mu is the mean, and sigma is the standard deviation. This is
| slightly faster than the normalvariate() function.
|
| Not thread-safe without a lock around calls.
|
| getstate(self)
| Return internal state; can be passed to setstate() later.
|
| lognormvariate(self, mu, sigma)
| Log normal distribution.
|
| If you take the natural logarithm of this distribution, you'll get
a
| normal distribution with mean mu and standard deviation
sigma.
| mu can have any value, and sigma must be greater than
zero.
|
| normalvariate(self, mu, sigma)
| Normal distribution.
|
| mu is the mean, and sigma is the standard deviation.
|
| paretovariate(self, alpha)
| Pareto distribution. alpha is the shape parameter.
|
| randint(self, a, b)
| Return random integer in range [a, b], including both end
points.
|
| randrange(self, start, stop=None, step=1, _int=<class 'int'>)
| Choose a random item from range(start, stop[, step]).
|
| This fixes the problem with randint() which includes the
| endpoint; in Python this is usually not what you want.
|
| sample(self, population, k)
| Chooses k unique random elements from a population
sequence or set.
|
| Returns a new list containing elements from the population
while
| leaving the original population unchanged. The resulting list
is
| in selection order so that all sub-slices will also be valid
random
| samples. This allows raffle winners (the sample) to be
partitioned
| into grand prize and second place winners (the subslices).
|
| Members of the population need not be hashable or unique.
If the
| population contains repeats, then each occurrence is a
possible
| selection in the sample.
|
| To choose a sample in a range of integers, use range as an
argument.
| This is especially fast and space efficient for sampling from a
| large population: sample(range(10000000), 60)
|
| seed(self, a=None, version=2)
| Initialize internal state from hashable object.
|
| None or no argument seeds from current time or from an
operating
| system specific randomness source if available.
|
| If *a* is an int, all bits are used.
|
| For version 2 (the default), all of the bits are used if *a* is a
str,
| bytes, or bytearray. For version 1 (provided for reproducing
random
| sequences from older versions of Python), the algorithm for
str and
| bytes generates a narrower range of seeds.
|
| setstate(self, state)
| Restore internal state from object returned by getstate().
|
| shuffle(self, x, random=None)
| Shuffle list x in place, and return None.
|
| Optional argument random is a 0-argument function returning
a
| random float in [0.0, 1.0); if it is the default None, the
| standard random.random will be used.
|
| triangular(self, low=0.0, high=1.0, mode=None)
| Triangular distribution.
|
| Continuous distribution bounded by given lower and upper
limits,
| and having a given mode value in-between.
|
| http://en.wikipedia.org/wiki/Triangular_distribution
|
| uniform(self, a, b)
| Get a random number in the range [a, b) or [a, b] depending
on rounding.
|
| vonmisesvariate(self, mu, kappa)
| Circular data distribution.
|
| mu is the mean angle, expressed in radians between 0 and
2*pi, and
| kappa is the concentration parameter, which must be greater
than or
| equal to zero. If kappa is equal to zero, this distribution
reduces
| to a uniform random angle over the range 0 to 2*pi.
|
| weibullvariate(self, alpha, beta)
| Weibull distribution.
|
| alpha is the scale parameter and beta is the shape
parameter.
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| __dict__
| dictionary for instance variables (if defined)
|
| __weakref__
| list of weak references to the object (if defined)
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| VERSION = 3
|
| ----------------------------------------------------------------------
| Methods inherited from _random.Random:
|
| __getattribute__(self, name, /)
| Return getattr(self, name).
|
| getrandbits(...)
| getrandbits(k) -> x. Generates an int with k random bits.
|
| random(...)
| random() -> x in the interval [0, 1).
|
| ----------------------------------------------------------------------
| Static methods inherited from _random.Random:
|
| __new__(*args, **kwargs) from builtins.type
| Create and return a new object. See help(type) for accurate
signature.

class SystemRandom(Random)
| SystemRandom(x=None)
|
| Alternate random number generator using sources provided
| by the operating system (such as /dev/urandom on Unix or
| CryptGenRandom on Windows).
|
| Not available on all systems (see os.urandom() for details).
|
| Method resolution order:
| SystemRandom
| Random
| _random.Random
| builtins.object
|
| Methods defined here:
|
| getrandbits(self, k)
| getrandbits(k) -> x. Generates an int with k random bits.
|
| getstate = _notimplemented(self, *args, **kwds)
|
| random(self)
| Get the next random number in the range [0.0, 1.0).
|
| seed(self, *args, **kwds)
| Stub method. Not used for a system random number
generator.
|
| setstate = _notimplemented(self, *args, **kwds)
|
| ----------------------------------------------------------------------
| Methods inherited from Random:
|
| __getstate__(self)
| # Issue 17489: Since __reduce__ was defined to fix #759889
this is no
| # longer called; we leave it here because it has been here
since random was
| # rewritten back in 2001 and why risk breaking something.
|
| __init__(self, x=None)
| Initialize an instance.
|
| Optional argument x controls seeding, as for Random.seed().
|
| __reduce__(self)
| Helper for pickle.
|
| __setstate__(self, state)
|
| betavariate(self, alpha, beta)
| Beta distribution.
|
| Returned values range between 0 and 1.
|
| choice(self, seq)
| Choose a random element from a non-empty sequence.
|
| choices(self, population, weights=None, *, cum_weights=None,
k=1)
| Return a k sized list of population elements chosen with
replacement.
|
| If the relative weights or cumulative weights are not specified,
| the selections are made with equal probability.
|
| expovariate(self, lambd)
| Exponential distribution.
|
| lambd is 1.0 divided by the desired mean. It should be
| nonzero. (The parameter would be called "lambda", but that
is
| a reserved word in Python.) Returned values range from 0 to
| positive infinity if lambd is positive, and from negative
| infinity to 0 if lambd is negative.
|
| gammavariate(self, alpha, beta)
| Gamma distribution. Not the gamma function!
|
|
| The probability distribution function is:
|
| x ** (alpha - 1) * math.exp(-x / beta)
| pdf(x) = --------------------------------------
| math.gamma(alpha) * beta ** alpha
|
| gauss(self, mu, sigma)
| Gaussian distribution.
|
| mu is the mean, and sigma is the standard deviation. This is
| slightly faster than the normalvariate() function.
|
| Not thread-safe without a lock around calls.
|
| lognormvariate(self, mu, sigma)
| Log normal distribution.
|
| If you take the natural logarithm of this distribution, you'll get
a
| normal distribution with mean mu and standard deviation
sigma.
| mu can have any value, and sigma must be greater than
zero.
|
| normalvariate(self, mu, sigma)
| Normal distribution.
|
| mu is the mean, and sigma is the standard deviation.
|
| paretovariate(self, alpha)
| Pareto distribution. alpha is the shape parameter.
|
| randint(self, a, b)
| Return random integer in range [a, b], including both end
points.
|
| randrange(self, start, stop=None, step=1, _int=<class 'int'>)
| Choose a random item from range(start, stop[, step]).
|
| This fixes the problem with randint() which includes the
| endpoint; in Python this is usually not what you want.
|
| sample(self, population, k)
| Chooses k unique random elements from a population
sequence or set.
|
| Returns a new list containing elements from the population
while
| leaving the original population unchanged. The resulting list
is
| in selection order so that all sub-slices will also be valid
random
| samples. This allows raffle winners (the sample) to be
partitioned
| into grand prize and second place winners (the subslices).
|
| Members of the population need not be hashable or unique.
If the
| population contains repeats, then each occurrence is a
possible
| selection in the sample.
|
| To choose a sample in a range of integers, use range as an
argument.
| This is especially fast and space efficient for sampling from a
| large population: sample(range(10000000), 60)
|
| shuffle(self, x, random=None)
| Shuffle list x in place, and return None.
|
| Optional argument random is a 0-argument function returning
a
| random float in [0.0, 1.0); if it is the default None, the
| standard random.random will be used.
|
| triangular(self, low=0.0, high=1.0, mode=None)
| Triangular distribution.
|
| Continuous distribution bounded by given lower and upper
limits,
| and having a given mode value in-between.
|
| http://en.wikipedia.org/wiki/Triangular_distribution
|
| uniform(self, a, b)
| Get a random number in the range [a, b) or [a, b] depending
on rounding.
|
| vonmisesvariate(self, mu, kappa)
| Circular data distribution.
|
| mu is the mean angle, expressed in radians between 0 and
2*pi, and
| kappa is the concentration parameter, which must be greater
than or
| equal to zero. If kappa is equal to zero, this distribution
reduces
| to a uniform random angle over the range 0 to 2*pi.
|
| weibullvariate(self, alpha, beta)
| Weibull distribution.
|
| alpha is the scale parameter and beta is the shape
parameter.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from Random:
|
| __dict__
| dictionary for instance variables (if defined)
|
| __weakref__
| list of weak references to the object (if defined)
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from Random:
|
| VERSION = 3
|
| ----------------------------------------------------------------------
| Methods inherited from _random.Random:
|
| __getattribute__(self, name, /)
| Return getattr(self, name).
|
| ----------------------------------------------------------------------
| Static methods inherited from _random.Random:
|
| __new__(*args, **kwargs) from builtins.type
| Create and return a new object. See help(type) for accurate
signature.

FUNCTIONS
betavariate(alpha, beta) method of Random instance
Beta distribution.

Conditions on the parameters are alpha > 0 and beta > 0.
Returned values range between 0 and 1.

choice(seq) method of Random instance
Choose a random element from a non-empty sequence.

choices(population, weights=None, *, cum_weights=None, k=1)
method of Random instance
Return a k sized list of population elements chosen with
replacement.

If the relative weights or cumulative weights are not specified,
the selections are made with equal probability.

expovariate(lambd) method of Random instance
Exponential distribution.

lambd is 1.0 divided by the desired mean. It should be
nonzero. (The parameter would be called "lambda", but that is
a reserved word in Python.) Returned values range from 0 to
positive infinity if lambd is positive, and from negative
infinity to 0 if lambd is negative.

gammavariate(alpha, beta) method of Random instance
Gamma distribution. Not the gamma function!

Conditions on the parameters are alpha > 0 and beta > 0.

The probability distribution function is:

x ** (alpha - 1) * math.exp(-x / beta)
pdf(x) = --------------------------------------
math.gamma(alpha) * beta ** alpha

gauss(mu, sigma) method of Random instance
Gaussian distribution.

mu is the mean, and sigma is the standard deviation. This is
slightly faster than the normalvariate() function.

Not thread-safe without a lock around calls.

getrandbits(...) method of Random instance
getrandbits(k) -> x. Generates an int with k random bits.

getstate() method of Random instance
Return internal state; can be passed to setstate() later.

lognormvariate(mu, sigma) method of Random instance
Log normal distribution.

If you take the natural logarithm of this distribution, you'll get a
normal distribution with mean mu and standard deviation sigma.
mu can have any value, and sigma must be greater than zero.

normalvariate(mu, sigma) method of Random instance
Normal distribution.

mu is the mean, and sigma is the standard deviation.

paretovariate(alpha) method of Random instance
Pareto distribution. alpha is the shape parameter.

randint(a, b) method of Random instance
Return random integer in range [a, b], including both end points.

random(...) method of Random instance
random() -> x in the interval [0, 1).

randrange(start, stop=None, step=1, _int=<class 'int'>) method of
Random instance
Choose a random item from range(start, stop[, step]).

This fixes the problem with randint() which includes the
endpoint; in Python this is usually not what you want.

sample(population, k) method of Random instance
Chooses k unique random elements from a population
sequence or set.

Returns a new list containing elements from the population
while
leaving the original population unchanged. The resulting list is
in selection order so that all sub-slices will also be valid random
samples. This allows raffle winners (the sample) to be
partitioned
into grand prize and second place winners (the subslices).

Members of the population need not be hashable or unique. If
the
population contains repeats, then each occurrence is a possible
selection in the sample.

To choose a sample in a range of integers, use range as an
argument.
This is especially fast and space efficient for sampling from a
large population: sample(range(10000000), 60)

seed(a=None, version=2) method of Random instance
Initialize internal state from hashable object.

None or no argument seeds from current time or from an
operating
system specific randomness source if available.

If *a* is an int, all bits are used.

For version 2 (the default), all of the bits are used if *a* is a str,
bytes, or bytearray. For version 1 (provided for reproducing
random
sequences from older versions of Python), the algorithm for str
and
bytes generates a narrower range of seeds.

setstate(state) method of Random instance
Restore internal state from object returned by getstate().

shuffle(x, random=None) method of Random instance
Shuffle list x in place, and return None.

Optional argument random is a 0-argument function returning a
random float in [0.0, 1.0); if it is the default None, the
standard random.random will be used.

triangular(low=0.0, high=1.0, mode=None) method of Random
instance
Triangular distribution.

Continuous distribution bounded by given lower and upper
limits,
and having a given mode value in-between.

http://en.wikipedia.org/wiki/Triangular_distribution

uniform(a, b) method of Random instance
Get a random number in the range [a, b) or [a, b] depending on
rounding.

vonmisesvariate(mu, kappa) method of Random instance
Circular data distribution.

mu is the mean angle, expressed in radians between 0 and
2*pi, and
kappa is the concentration parameter, which must be greater
than or
equal to zero. If kappa is equal to zero, this distribution reduces
to a uniform random angle over the range 0 to 2*pi.

weibullvariate(alpha, beta) method of Random instance
Weibull distribution.

alpha is the scale parameter and beta is the shape parameter.

DATA
__all__ = ['Random', 'seed', 'random', 'uniform', 'randint',
'choice',...

FILE
/usr/lib/python3.7/random.py

Usando funções de um módulo, pacote externo
for i in range(10):
print(random.randint(0,10))

1
2
4
4
3
7
2
7
0
0

Abreviando a nomenclatura de um módulo
import random as ra

for i in range(10):
print(ra.randint(1,10))

4
8
7
3
1
6
3
3
9
2

Importando apenas uma função específica de um
módulo
from random import randint

for i in range(10):
print(randint(0,10))

2
6
7
8
2
8
1
8
7
6

Criando módulos manualmente
# Arquivo soma.py

s = int(num1) + int(num2)
return s

# Arquivo index.py

import soma

print(f'O resultado da soma é: {soma.soma(8,3)}')

Empacotamento e Desempacotamento

Empacotamento
numeros = 2, 4, 6, 8, 10, 12
# Todos atributos serão empacotados em uma tupla

print(numeros)

print(type(numeros))

(2, 4, 6, 8, 10, 12)
<class 'tuple'>

Desempacotamento
numeros2 = 1, 2, 3

a, b, c = numeros2
# Desempacotará sequencialmente cada elemento de numeros2 par
a sua respectiva
# variável, após isto, as variáveis a, b e c já tem dados/valores iteráv
eis

print(numeros2)

print(a)

print(b)

print(c)

(1, 2, 3)
1
2
3

Programação Orientada a Objetos

Sintaxe básica
class Nome:
objetos

# Palavra reservada class para identificar um Objeto

Criando uma classe vazia
class Pessoa:
pass

# Palavra reservada pass dá o comando ao interpretador que simple
smente
# ignore essa linha de código e parta para a próxima.

Criando objetos (atributos de classe) dentro de
uma classe
class Pessoa:
pass

pessoa1 = Pessoa()

pessoa1.nome = 'Fernando'
pessoa1.idade = 32

print(pessoa1.nome)

Fernando

class Pessoa:
pass

pessoa1 = Pessoa()
# Variável pessoa1 instancia a classe Pessoa, incorporando toda su
a estrutura

pessoa1.nome = 'Fernando'
# Aplicando sobre pessoa1 nome = 'Fernando' é criado dentro da cla
sse Pessoa
# o objeto/atributo de classe nome com seu respectivo dado/valor 'F
ernando'

pessoa1.idade = 32
# Da mesma forma, cria o atributo de classe idade, com valor 32

print(pessoa1.nome)

Criando funções (métodos de classe) dentro de
uma classe
class Pessoa:
def acao1(self):
print('Ação 1 sendo executada...')

pessoa1 = Pessoa()

pessoa1.acao1()

Ação 1 sendo executada...

class Pessoa:
def acao1(self):
# Cria o método de classe acao1( ) que realiza uma ação e retorna
algum
# dado ou valor dentro da classe via self.
print('Ação 1 sendo executada...')

pessoa1 = Pessoa()
# Variável pessoa1 instancia a classe Pessoa( ), incorporando toda
sua estrutura

pessoa1.acao1()
# Variável pessoa1 possui todas as estruturas da classe, sendo assi
m, consegue
# executar a função/método acao1( ) que por sua vez exibirá em tela
uma mensagem
# via função print( )

Criando uma classe com método construtor e
objetos internos
class Pessoa:
def __init__(self, nome, idade, sexo, altura):
self.nome = nome
self.idade = idade
self.sexo = sexo
self.altura = altura

pessoa1 = Pessoa('Fernando', 32, 'M', 1.90)

print(pessoa1.nome, pessoa1.idade)
print(f'Bem vindo {pessoa1.nome}, parabéns pelos seus {pessoa1.id
ade} anos!!!')

Fernando 32
Bem vindo Fernando, parabéns pelos seus 32 anos!!!

class Pessoa:
def __init__(self, nome, idade, sexo, altura):
# Método construtor __init__( ) cria objetos/atributos de classe iterá
veis
# por qualquer outra estrutura interna a classe.
self.nome = nome
# self.nome cria o objeto nome no escopo global da classe, receb
endo um
# nome a ser repassado pela variávei/objeto que instanciar a clas
se Pessoa

self.idade = idade
self.sexo = sexo

pessoa1 = Pessoa('Fernando', 32, 'M', 1.90)
# Variável pessoa1 instancia a classe Pessoa, repassando por justa
posição
# parâmetros para os objetos nome, idade, sexo e altura.

print(pessoa1.nome, pessoa1.idade)

print(f'Bem vindo {pessoa1.nome}, parabéns pelos seus {pessoa1.id
ade} anos!!!')

Mais de um método de classe dentro de uma
classe
class Pessoa:
ano_atual = 2021

def __init__(self, nome, idade):
self.nome = nome
self.idade = idade

def ano_nascimento(self):
ano_nasc = self.ano_atual - self.idade
print(f'Seu ano de nascimento é {ano_nasc}')

pessoa1 = Pessoa('Fernando', 32)

print(pessoa1.ano_nascimento())

Seu ano de nascimento é 1989

class Pessoa:
ano_atual = 2021

# Método construtor/inicializador de objetos
self.nome = nome
self.idade = idade

def ano_nascimento(self):
# Método ano_nascimento( ) com comportamento padrão de uma f
unção qualquer
ano_nasc = self.ano_atual - self.idade
print(f'Seu ano de nascimento é {ano_nasc}')

pessoa1 = Pessoa('Fernando', 32)

print(pessoa1.ano_nascimento())

# Lembrando que nesse exemplo ano_atual é um objeto/atributo da
classe,
# e está acessível a todas funções internas, já ano_nasc por exempl
o
# é uma variável do escopo da função ano_nascimento(), e não está
# acessível fora dessa função. Funções dentro de classes podem re
ceber
# a nomenclatura de "métodos" assim como seus atributos podem s
er
# chamados de "instâncias".'''

Seu ano de nascimento é 1989
None

Métodos de classe
# Métodos que até interagem com funções internas,
# mas retorna dados para o escopo global da classe

class Pessoa:
ano_atual = 2021

self.nome = nome
self.idade = idade

@classmethod
def ano_nasc(cls, nome, ano_nascimento):
idade = cls.ano_atual - ano_nascimento
return cls(nome, idade)

pessoa2 = Pessoa.ano_nasc('Fernando', 1987)

print(f'{pessoa2.nome} tem {pessoa2.idade} anos.')

Fernando tem 34 anos.

Métodos estáticos
# Aqueles que não possuem instâncias como atributos,
# funciona como uma função normal dentro da classe.


class Pessoa:
@staticmethod
def gerador_id():
gerador = randint(100, 999)
return gerador

print(Pessoa.gerador_id())

896
<__main__.Pessoa object at 0x7fd0eecc2bd0>


class Pessoa:
@staticmethod
def gerador_id():
gerador = randint(100, 999)
return gerador

print(Pessoa.gerador_id())
# Instancia diretamente da classe Pessoa o método de classe gerad
or_id( )

pessoa3 = Pessoa()
pessoa3.gerador_id()
print(pessoa3)
# Apenas como exemplo, retornará o identificador do objeto dentro d
a classe

186
<__main__.Pessoa object at 0x7fd0eebd7710>

@property, Getters e Setters
class Produto:
def __init__(self, nome, preco):
self.nome = nome
self.preco = preco

def desconto(self, percentual):
self.preco = self.preco - (self.preco * (percentual / 100))

#Getter
@property
def preco(self):
return self._preco

#Setter
@preco.setter
def preco(self, valor):
if isinstance(valor, str):
valor = float(valor.replace('R$', ''))

self._preco = valor

produto1 = Produto('Camiseta', 99)
produto1.desconto(5)
print(produto1.preco)

# Supondo que o usuário passou um valor que não pode ser proces
sado
# porque foi passado em tipo de dado incorreto
# produto2 = Produto('Calça', 'R$59')
# produto2.desconto(15)
# print(produto2.preco)
# Irá gerar um erro pois R$59 não é um int, então é necessário criar
# uma estrutura de métodos que farão essa correção.

produto2 = Produto('Calça', 'R$59')
produto2.desconto(15)
print(f'Produto2 após aplicação do desconto terá valor de {produto2.
preco}')

94.05
Produto2 após aplicação do desconto terá valor de 50.15

Atributos de classe
# Variáveis de classe vão ser as variáveis que estarão declaradas
# dentro de uma classe, e que serão atribuídas a toda variável
# externa que instanciar essa classe.

class Classe1:
var1 = 101001

variavel1 = Classe1()

print(Classe1.var1)
print(variavel1.var1)

101001
101001

Alterando um atributo de classe
class Classe1:
var1 = 101001

variavel1 = Classe1()
Classe1.var1 = 111111

print(Classe1.var1)

111111

Exemplo de aplicação de orientação à objetos
class BaseDeDados:
def __init__(self):
self.base = {}

def inserir(self, nome, fone):
if 'clientes' not in self.base:
self.base['clientes'] = {nome:fone}
else:
self.base['clientes'].update({nome:fone})

def listar(self):
for n, f in self.base['clientes'].items():
print(n, f)

def apagar(self, nome):
del self.base['clientes'][nome]

clientes = BaseDeDados()

clientes.inserir('Ana', 991358899)
clientes.inserir('Fernando', 981357295)
clientes.inserir('Maria', 999891415)

#clientes.listar()

clientes.apagar('Ana')

clientes.listar()

Fernando 981357295
Maria 999891415

Encapsulamento
# Serve para definir se alguma função de alguma classe será acessí
vel ou não fora dela.
# Muito pareceido com o public ou private em outras linguagens de
programação.

class BaseDeDados:
def __init__(self):
self.dados = {}
#self._dados = {} declarado como protegido (ainda acessível de fo
ra da classe)
#self.__dados = {} declarado como privado (inacessível de fora da
classe)

base = BaseDeDados()

print(base.dados)

Tipagem de Dados Avançada

%whos
num = 1987

%whos

Variable Type Data/Info
----------------------------
num int 1987

Tipagem dinâmica vs estática
# Python é uma linguagem de programação dinamicamente tipada, l
ogo, todos os
# tipos de dados são automaticamente identificados pelo interpretad
or.

numero = 1987

print(type(numero))
# Retornará int

numero = '1987'
# Mesma variável, pela leitura léxica terá seu tipo de dado atualizad
o para str

print(type(numero))

<class 'int'>
<class 'str'>

Tipando um dado manualmente
numero = int(1987)
# Definido manualmente como do tipo inteiro

print(type(numero))

numero = int('1987')
# Método int( ) preserva o tipo do dado como inteiro

print(type(numero))

<class 'int'>
<class 'int'>

Tipagem manual via gerador de objeto
nomes: list = ['Alberto', 'Fernando', 'Tania']

print(nomes)
print(type(nomes))

idades: tuple = (74, 33, 61)

print(idades)
print(type(idades))

['Alberto', 'Fernando', 'Tania']
<class 'list'>
(74, 33, 61)
<class 'tuple'>

var1: set = {}
var2: list = []
var3: tuple = ()
var4: dict = {}

print(__annotations__)
# Retornará cada variável e seu respectivo tipo de dado

print(list(__annotations__))

{'var1': <class 'set'>, 'var2': <class 'list'>, 'var3': <class 'tuple'>, 'var4':
<class 'dict'>}
['var1', 'var2', 'var3', 'var4']

Tipo esperado e tipo retornado
# Define o tipo de variável que é esperado, e qual tipo será retornad
o

def dobro_valor(num: int) -> float:
return num * 2
# Nesse caso é esperado que o número fornecido seja do tipo int, e
que
# o número retornado pela função seja float. Ainda sim, por conta de
o
# Python ser dinamicamente tipado, para evitar erros o interpretador
# pode ignorar tais instruções.

Definindo manualmente o tipo de dado da
variável e de seu atributo
from typing import List
# Também é possível importar Dict, Tuple e Set

digitos1: List[int] = [2, 4, 6, 8]
digitos2: List[str] = ['1', '3', '5', '7']

print(type(digitos1))
print(type(digitos1[0]))

print(type(digitos2))
print(type(digitos2[0]))

print(__annotations__)
# Irá retornar digitos1': typing.List[int] e 'digitos2': typing.List[str]
# pois digitos1 é uma lista de inteiros assim como digitos2 é uma list
a
# de strings.

<class 'list'>
<class 'int'>
<class 'list'>
<class 'str'>
{'nomes': <class 'list'>, 'idades': <class 'tuple'>, 'var1': <class 'set'>,
'var2': <class 'list'>, 'var3': <class 'tuple'>, 'var4': {'almox': ['Folha de
Oficio', 'Caneta', 'Grampeador'], 'cozinha': ['Café', 'Açúcar']},
'digitos1': typing.List[int], 'digitos2': typing.List[str]}

Duck Typing
# Conceito onde o tipo de dado é menos importante que o método q
ue o define
# Tipos de dados parecidos suportam os mesmos métodos

lista2 = [1, 2, 3, 4, 5, 6, 7, 8]
nome2 = 'Fernando Feltrin'
# Tanto lista2 quanto nome2 são contêineres de dados

print(len(lista2))
print(len(nome2))
# Logo, suportam os mesmos métodos

8
16

nascimento = 1987

print(len(nascimento))

# Irá gerar um erro pois o método len não se aplica a esse tipo de d
ado

---------------------------------------------------------------------------
<ipython-input-348-7d812111c847> in <module>()
1 nascimento = 1987
2
----> 3 print(len(nascimento))
4 # Irá gerar um erro pois o método len não se aplica a esse tipo
de dado

TypeError: object of type 'int' has no len()

class Pessoa:
def __len__(self):
return 1987

pessoa1 = Pessoa()
print(len(pessoa1))

# Transformando o dado em parte de um contêiner, assim como seu
método,
# é possível retornar essa iteração antes não permitida para um dad
o
# do tipo int, inclusive usando do método len( ) como nos demais co
ntêineres

1987

Tipagem em Comentário
# Para que seja possível interpretar a instrução type, o processo de
verificação
# dos tipos de dados e suas conversões ao longo do código é feita p
ela biblioteca
# mypy.

import math

def circunferencia(num):
# type: (int) -> float
return 2 * math.pi * num

calculo = circunferencia(8)

print(calculo)
print(type(calculo))

50.26548245743669
<class 'float'>

# pip install mypy

# Executar o arquivo via terminal, ex: mypy arquivo.py, será verificad
o
# o arquivo em busca de erros e será interpretada a instrução repas
sada
# via comentário.

# Para permitir dois ou mais tipos de dados de entrada, basta especi
ficá-los
# usando vírgula como separador. Ex: # type: (str, bool) -> str

Tipos de Dados Especiais Para Validações

Tipo Literal
from typing import Literal

def usuario(user: str) -> Literal['logado', 'deslogado']:
# Definimos que a função receberá um dado no formato string e r
etornará
# literalmente/obrigatoriamente ou 'logado' ou 'deslogado'.
if user == 'logado':
print('Logado no sistema')
if user == 'deslogado':
print('Deslogado do sistema')
if user != 'logado' and user != 'deslogado':
print('Status inválido')

var1 = usuario('deslogado')

Tipo Union
from typing import Union

def soma(num1: int, num2: int) -> Union[str, int]:
# Recebe dois números do tipo int e permite que retorne um dado
do tipo
# string ou int.
res_soma = num1 + num2
print(f'O resultado da soma é: {res_soma}')
return res_soma

calculo1 = soma(99, 12)

# Pode ser usado em qualquer parâmetro/argumento

from typing import Union

def soma(num1: Union[int, float], num2: Union[int, float]) -
> Union[str, int]:
# Recebe dois números do tipo int e permite que retorne um dado
do tipo
# string ou int.
res_soma = num1 + num2
print(f'O resultado da soma é: {res_soma}')
return res_soma

calculo1 = soma(99, 12)

Tipo Final
# Tipo de dado equivalente a uma constante

from typing import Final

NOME: Final = 'Fernando'

print(NOME)

# Em Python não existem literalmente constantes, porém uma másc
ara de identificação
# é criada tipando esse dado, usando do MyPy é possível verificar s
e algum
# iterador em algum momento tentou modificar essa "constante", e s
e sim, irá
# gerar um erro apontando que algo modificou o valor padrão desse
objeto.

Decorador “final”
from typing import final

class Pessoa:

def acao1(self):
print('Trabalhando...')

@final
class Pessoa:
def acao1(self):

class Pessoa:
@final
def acao1(self):

from typing import final

# Sem restrições
class Pessoa:

def acao1(self):

# Classe inteira protegida como constante pelo decorador
@final
class Pessoa:
def acao1(self):
# Nenhuma classe que herdar essa estrutura conseguirá sobrescrev
er dados
# Via Mypy é possível ver um erro gerado, dizendo que não se deve
ria
# iterar sobre a classe Pessoa

# Método de classe protegida como constante pelo decorador
class Pessoa:
@final
def acao1(self):

# No código geral o interpretador contornará esse "problema" e
# executará os blocos das classes, porém é possível verificar
# via MyPy que internamente são geradas pequenas exceções.

TypedDict
# Dicionário tipado orientado a objetos

from typing import TypedDict

class Programa(TypedDict):
versao: str
revisao: float

projeto1 = Programa(versao = '1.0.237', revisao = 0.01)

print(projeto1)

Protocol
# Define ojetos / atributos de classe tipados, onde uma tipagem é
# definida e a partir daí todas classes filhas terão de "seguir o protoc
olo",
# respeitando a tipagem para que seus dados internamente não ger
em exceções.

from typing import Protocol

class Pessoa(Protocol):
nome: str

def identificacao(primeiro_nome: Pessoa) -> str:
print(f'Usuário identificado como: {primeiro_nome.nome}')

class Pessoa1:
nome = 'Fernando'

pessoa1 = Pessoa1()
identificacao(pessoa1)

from typing import Protocol

class Pessoa(Protocol):
nome: str
# Define que obrigatoriamente classes herdeiras terão de ter um no
me
# do tipo string para que se comportem de acordo com a "classe m
olde"

def identificacao(primeiro_nome: Pessoa) -> str:
# Função identificacao( ) recebe como parâmetro um primeiro_nom
e
# que tem sua estrutura moldada e regrada por Pessoa(Protocol)
print(f'Usuário identificado como: {primeiro_nome.nome}')

class Pessoa1: # classe herdeira
nome = 'Fernando' # objeto obrigatório segundo o protocolo

pessoa1 = Pessoa1()
identificacao(pessoa1)

Função print( ) (Avançado)

Quebrando em linhas o conteúdo de uma string
parâmetro da função print( )
print('O resultado dos testes serão divulgados amanhã. Grato pela c
ompreensão.')

print('O resultado dos testes serão divulgados amanhã. \nGrato pela
compreensão.')

O resultado dos testes serão divulgados amanhã. Grato pela
compreensão.
O resultado dos testes serão divulgados amanhã.
Grato pela compreensão.

Exibindo em tela uma mensagem colorida
import sys

class cores:
VERDE = '\033[32m'
AZUL = '\033[34m'
AMARELO = '\033[33m'
VERMELHO = '\033[31m'
PADRAO = '\033[0m'
# Para mais cores buscar a referência da tabela de cores

mensagem1 = 'Estamos vivendo uma pandemia!'

def msg(cor, mensagem):
print(cor + mensagem + cores.PADRAO)

msg1 = msg(cores.AMARELO, mensagem1)

print(msg(cores.VERMELHO, mensagem1))
print(msg(cores.VERDE, mensagem1))
print(msg(cores.AZUL, mensagem1))

Estamos vivendo uma pandemia!

Exibindo em tela o nome e o conteúdo de uma
variável
nome: str = 'Fernando Feltrin'

print(f"A variável é composta de: '{nome = }'")
# Retornará o nome literal da variável e seu respectivo atributo

Nome = ‘Fernando Feltrin’

f'Strings (Avançado)

# Máscara de substituição tem a mesma notação de um dicionário
# em função disso, ao trabalhar com dicionários em máscaras de
# substituição não é preciso fazer nada além de puramente iterar
# sobre os dados.

pessoa1 = {
'Nome': 'Fernando',
'Linguagem': 'Python'
}

print(f"{pessoa1['Nome']} é professor de {pessoa1['Linguagem']}")
# Lembrando de contornar o uso de aspas simples e

Fernando é professor de Python

f'String como atributo de uma variável
nome = 'Fernando'
mensagem1 = f'Olá {nome}!!!'

print(mensagem1)

Olá Fernando!!!

Operações matemáticas especiais diretamente
na máscara de substituição
import math

num = 2.2

print(f'{math.sin(num) = }')
print(f'{math.cos(num) = }')

0. 8084964038195901
-0. 5885011172553458

Saída de múltiplas linhas via print( ) + f’strings
nome1 = 'Fernando'
nasc1 = '08/11/1987'
sexo1 = 'M'

msg1 = (
f'Nome: {nome1}\n'
f'Nascido em: {nasc1}\n'
f'Sexo: {sexo1}'
)

print(msg1)

Nome: Fernando
Nascido em: 08/11/1987
Sexo: M

# Simplesmente mostrando o que é uma máscara de substituição

print(f'Python usa {{}} para incorporar variáveis, objetos,\n'
f'dados, valores, métodos, etc... diretamente na string.')

Python usa {} para incorporar variáveis, objetos,
dados, valores, métodos, etc... diretamente na string.

f'String chamando função do corpo do código
def soma(n1, n2):
return n1 + n2

n1 = 15
n2 = 77

print(f'O resultado da soma é: {soma(n1, n2)}')


f'String como retorno de um método mágico
class Pessoa:
def __init__(self, nome, profissao):
self.nome = nome
self.profissao = profissao
def __repr__(self):
return f'{self.nome} trabalha como {self.profissao}'

pessoa1 = Pessoa('Fernando', 'Eng. da Computação')

print(f'{pessoa1}')

Fernando trabalha como Eng. da Computação

Funções (Avançado)

Parâmetros em justaposição e parâmetros
nomeados
# Justaposição = ordenados sequencialmente

# 1º 2º 3º
def pessoa1(nome, idade, funcao):
print(f'{nome} tem {idade} anos, função: {funcao}')

p1 = pessoa1('Fernando', 32, funcao = 'gerente')

Fernando tem 32 anos, função: gerente

Função com número de parâmetros indefinido
# *args - marcador para múltiplos parâmetros

def msg(nome, *args):
print(f'{nome} = {args}')

ex1 = msg('Fernando')
ex2 = msg('Fernando', 'idade = 33', 'profissão = professor')

# O primeiro parâmetro nome é obrigatório, *args reserva espaço pa
ra que
# outros parâmetros sejam repassados conforme necessário.

Fernando = ()
Fernando = ('idade = 33', 'profissão = professor')

def soma(*args):
num = 0
for valordigitado in args:
num += valordigitado
print(num)

soma = soma(14, 89)

# É possível definir diretamente que a função tem parâmetros indefi
nidos

103

Função com número de parâmetros indefinido,
porém nomeados
# **kwargs - marcador para parâmetros nomeados

def identificacao(**kwargs):
print(kwargs)

pessoa1 = identificacao(nome = 'Fernando')
pessoa2 = identificacao(nome = 'Maria',
idade = 33)
pessoa3 = identificacao(nome = 'Alberto',
funcao = 'Tec. em Radiologia',
salario = 1960.00)

{'nome': 'Fernando'}
{'nome': 'Maria', 'idade': 33}
{'nome': 'Alberto', 'funcao': 'Tec. em Radiologia', 'salario': 1960.0}

Função que recebe parâmetros tanto por
justaposição quanto nomeados
def identificacao(*args, **kwargs):
print(args, kwargs)

pessoa = identificacao('Fernando', idade = 33)

# *args reserva espaço para parâmetros justapostos, **kwargs reser
va
# espaço para parâmetros nomeados.

('Fernando',) {'idade': 33}

Empacotamento e desempacotamento
# Criando uma função que recebe parâmetros tanto por justaposição
# quanto nomeados, a partir de uma lista e de um dicionário,
# desempacotando os elementos e reorganizando os mesmos na fu
nção:

numeros = (33, 1987, 2020, 19.90, 100000000)
dados = {'Nome':'Fernando', 'Profissão':'Engenheiro'}

def identificacao(*args, **kwargs):
print(args)
print(kwargs)

identificacao(*numeros, **dados)

(33, 1987, 2020, 19.9, 100000000)
{'Nome': 'Fernando', 'Profissão': 'Engenheiro'}

Funções aninhadas
# Basicamente quando se fala em uma função aninhada significa qu
e
# temos uma função dentro de outra função. Em algumas literaturas
# essa particularidade é chamada como funções de alta ordem e de
# baixa ordem, sendo a se alta a função principal, e a de baixa a
# função interna a função principal.

def funcao1(): # função externa
print ("Alô, alguêm me ouvindo?")
def funcao2(): # função interna
print ("Cambio desligo!!!")
funcao2()

funcao1()

Alô, alguêm me ouvindo?
Cambio desligo!!!

# Exemplo de funções aninhadas interagindo

def make_adder(x):
def add(y):
return x + y
return add

plus5 = make_adder(23)
print(plus5(10))

33

Parâmetro/argumento somente posicional
def msg(nome, /, idade):
# tudo o que estiver à esquerda de " / " será somente posicional
return f'Olá {nome}, você tem {idade} anos.'

print(msg('Fernando', idade = 33))
# Irá executar normalmente repassando esses dados como parâmet
ros

print(msg(nome = 'Alberto', idade = 67))
# Irá gerar um erro pois o parâmetro nome é somente posicional,
# em outras palavras, não aceita nenhum atributo nomeado.

def msg(nome, idade, /):
# Nesse caso, todos parâmetros serão somente posicionais

print(msg('Fernando', 33))
ros
# inclusive respeitando a justaposição.

Parâmetro/argumento obrigatoriamente nomeado
def msg(*, nome, idade):
# tudo o que estiver após " * " terá de ser parâmetro nomeado

print(msg(nome = 'Fernando', idade = 33))
ros
# pois ambos são parâmetros nomeados.

Olá Fernando, você tem 33 anos.

# Ambos métodos combinados

def msg(nome, /, idade, *, altura):
return f'Olá {nome}, você tem {idade} anos e mede {altura}m.'

print(msg('Fernando', 33, altura = 1.90))
# O primeiro parâmetro é posicional, o segundo é justaposto, o terce
iro é nomeado

Funções em Python são objetos
def msg(nome):
print(f'Olá {nome}!!!')

print(id(msg))
# retornará o número identificador do objeto alocado em memória

print(type(msg))
# retornará o tipo de objeto, neste caso, 'function'

print(dir(msg))
# retornará os builtins padrão para toda e qualquer função

2024628443456
<class 'function' >
['__ annotations __', '__call__', '__class__', '__closure__',
'__code__', '__defaults__', '__delattr__', '__ dict __', '__dir__',
'__doc__', '__eq__', '__format__', '__ge__', '__get__',
'__getattribute__', '__ globals __', '__gt__', '__hash__', '__init__',
'__init_subclass__', '__kwdefaults__', '__le__', '__lt__',
'__ module __', '__name__', '__ne__', '__new__', '__qualname__',
'__reduce__', '__reduce_ex__', '__ repr __', '__setattr__',
'__sizeof__', '__str__', '__subclasshook__']

Closures

# Equivalente ao escopo global e local, porém, tratando-
se de escopos de funções aninhadas

def media():
valores = [] # variável no escopo global

def calcula_media(valor):
valores.append(valor)
# usando da variável do escopo global da função externa, como e
scopo local/estendido
return sum(valores)/len(valores)
return calcula_media

# Closure da função, é a junção do escopo da funcao externa com o
da interna

media = media()

media(68)
media(45)
media(70)
media(91)

68.5

Decoradores

# Em Python até mesmo uma função é um objeto, sendo assim, pod
emos criar cadeias
# de funções dentro de funções, funções que usam funções como ar
gumentos, ou
# simplesmente adicionar funcionalidades em uma função a partir de
outra.
# Tudo isso é possível criando um marcador (decorador) para identifi
car para o
# interpretador que uma determinada função pode ser usada como p
arâmetro para
# outra. Em outras palavras, uma função decoradora recebe uma fu
nção e devolve
# outra função já com modificações.

def soma_dois_num(funcao_decorada):
def nova_funcao(*args, **kwargs):
return funcao_decorada(*args, **kwargs)
return nova_funcao

@soma_dois_num
# instancia a função soma_dois_num( ) passando como parâmetro a
função soma( )
return num1 + num2

num1 = int(input('Digite o primeiro número: '))
num2 = int(input('Digite o segundo número: '))

print(soma_dois_num(soma))

Digite o primeiro número: 237
Digite o segundo número: 44
<function soma_dois_num.<locals>.nova_funcao at
0x7f4356de9680>

# Outro exemplo, com variável de controle para identificar quantas v
ezes o decorador foi usado

contador = 0

def contar_acessos(funcao_decorada):
def nova_func(*args, **kw):
global contador
contador += 1
return funcao_decorada(*args, **kw)
return nova_func

@contar_acessos
def soma(a, b):
print(f'O resultado da soma é: {a + b}')
return a + b

ui = contar_acessos(soma(4,5))

eu = contar_acessos(soma(9,2))

print(contador)
print(ui)
print(eu)

2
<function contar_acessos.<locals>.nova_func at 0x7f4354f35ef0>
<function contar_acessos.<locals>.nova_func at 0x7f4356de93b0>

Sys.argv

import sys

var1 = print(f'Argumentos: {sys.argv}')

# executar o arquivo .py seguido dos argumentos, estes por sua vez
aparecerão
# no campo sys.argv .
# Ex: via terminal digitar: python arquivo.py Casa Carro Celular
# O retorno será Argumentos: Casa Carro Celular

Recursividade

# Situações onde uma determinada ação/função do código tem de s
er executada
# repetidas vezes, por inúmeras vezes.

def fatorial(num):
if num == 1:
return 1

return num * fatorial(num - 1)

fator = fatorial(5)
print(fator)

Dicionários (Avançado)

Dicionário ordenado
from collections import OrderedDict

dicionario = OrderedDict()
dicionario['a'] = 1
dicionario['b'] = 2
dicionario['c'] = 3
dicionario['d'] = 4
dicionario['e'] = 5
print(dicionario)

for k, v in dicionario.items():
print(k, v)

# Internamente é gerado um mapeamento da ordem aos quais os ite
ns foram inseridos
# Caso uma nova entrada tente atualizar uma chave:valor do dicioná
rio, a posição
# original é mantida, esse log de alterações pode ser visualizado via
MyPy.

OrderedDict([('a', 1), ('b', 2), ('c', 3), ('d', 4), ('e', 5)])
a1
b2
c3
d4
e5

DefaultDict
# Mesmas funcionalidades de um dicionário padrão, porém caso o u
suário tente
# consultar uma entrada inexistente, ao invés de um erro é retornad
o um valor padrão

from collections import defaultdict

dicionario = defaultdict(int)
dicionario['Ano'] = 2021
dicionario['Mês'] = 5

print(dicionario.items())
print(dicionario['Dia'])
# Retornará 0 no lugar de uma exceção

dict_items([('Ano', 2021), ('Mês', 5)])
0

Expressões Regulares

r'Strings
import re

minha_string = 'Fernando chegará a meia noite.'
print(re.findall(r'Fernand.', minha_string))

minha_string2 = 'Fernanda chegará a meia noite.'
print(re.findall(r'Fernand.', minha_string2))

['Fernando']
['Fernanda']

import re

print(re.findall(r'Fernand.', minha_string))
# Método findall( ) irá buscar na origem uma string específica,
# o ponto no lugar do o ou a em Fernand é um validador regular,
# permitindo que neste ponto esteja todo e qualquer caractere.

minha_string2 = 'Fernanda chegará a meia noite.'
print(re.findall(r'Fernand.', minha_string2))

['Fernando']
['Fernanda']


print(re.findall(r'Fernando|Fernanda', minha_string))
# Operador " ou" " | " também pode ser perfeitamente utilizado,
# desde que se saiba todas as possíveis variantes da string,
# nesse caso, apenas Fernando ou Fernanda.

['Fernando']

r'Strings e metacaracteres
import re

# Meta caractere " . "

texto1 = '''No dia trinta de março de dois mil e vinte
foi inaugurado o novo ginásio de esportes da escola
estatual Professor Annes Dias, na cidade de Cruz Alta,
no estado do Rio Grande do Sul. A obra inicialmente
orçada em um milhão de, reais acabou não utilizando de
todo o recurso, uma vez que dois grandes empresários da
cidade, João Fagundes e Maria Terres doaram juntos em
torno de duzentos mil reais. João Fagundes se manifestou
dizendo que apoiou a obra pois acredita no desenvolvimento
da cidade, assim investe regularmente para hospitais e
escolas da mesma. maria Terres não quis se pronunciar
sobre o assunto.'''

print(re.findall(r'.oão', texto1))
# O metacaractere " . " no início de uma sentença serve para validar
# o caractere inicial sa string, que nesse caso poderia ser uma letra
# maiúscula ou minúscula.

print(re.findall(r'.oão|.aria', texto1))

['João', 'João']
['João', 'Maria', 'João', 'maria']

# Meta caractere " | " significa "ou"
# | significa ou, e tem suporte a número de palavras ilimitadas

print(re.findall(r'.oão|.aria', texto1))
# Metacaracteres podem ser perfeitamente combinados em uma se
ntença

print(re.findall(r'.oão|.aria|mil', texto1))

['mil', 'mil', 'João', 'Maria', 'mil', 'João', 'maria']

# Meta caractere " [] " significa "conjunto de caracteres"
# Usado para definir quais possíveis caracteres estarão numa deter
minada
# posição da string.

print(re.findall(r'[Jj]oão|.aria', texto1))
# Suponto que toos os caracteres possíveis no início de João são J
# maiúsculo e j minúsculo. Nesse caso sabemos que os possíveis c
aracteres
# são J ou j, mas em outras strings precisaremos ampliar a abordag
em.


# pode conter quantos possíveis caracteres forem necessarios
print(re.findall(r'[AaBbCcDdEeFfGgHhIiJj]oão', texto1))

['João', 'João']

# otimizado com um intervalo predefinido
print(re.findall(r'[a-z]oão|[A-Z]oão', texto1))
print(re.findall(r'[a-zA-Z]oão', texto1))

['João', 'João']
['João', 'João']

Alterando o comportamento de uma expressão
regular via flags
# Ignore Case

print(re.findall(r'jOãO|maRIA', texto1, flags = re.I))

# Flags serve para passar uma instrução local, nesse caso, re.I
# significa ignore case (não diferenciar letras maiúsculas de minúscu
las)


Metacaracteres quantificadores
# * significa 0 ou ilimitado número de vezes
# + significa 1 ou ilimitado número de vezes
# ? significa 0 ou 1, apenas uma vez
# {} significa um número específico, por exemplo {8} define 8 repetiç
ões

# {} com dois parâmetros justapostos definem um intervalo, por exe
mplo {0,15}
# define que algo será repetido 15 vezes, iniciando o contador em 0.

mensagem = 'Nããããããããããooooooo esquecer de pagar a conta, nã
o deixar para depois'

print(re.findall(r'não', mensagem, flags = re.I))

print(re.findall(r'Nã+o', mensagem))
# o operador " + " ao lado de ã diz que esse caractere, naquela posi
ção
# pode se repetir uma ou mais vezes

print(re.findall(r'Nã+o+', mensagem))

print(re.findall(r'[Nn]ã+o+', mensagem))

print(re.findall(r'nã+o+', mensagem, flags = re.I))

['não']
['Nãããããããããão']
['Nããããããããããooooooo']
['Nããããããããããooooooo', 'não']
['Nããããããããããooooooo', 'não']

Metacaracteres aplicados a um intervalo de
caracteres de uma expressão regular
# [A-Za-z0-9]+ significa que vai permitir qualquer caractere,
# quantas vezes o mesmo estiver repetido...

chamando_nome = 'Fernnnnnnnannnnndo'

print(re.findall(r'fer[a-z]+a[Nn]+do', chamando_nome, flags = re.I))

['Fernnnnnnnannnnndo']

Substituindo um elemento de uma string via
expressão regular
texto1 = '''No dia trinta de março de dois mil e vinte
cidade, João Fagundes e Maria Terres doaram juntos em
torno de duzentos mil reais. João Fagundes se manifestou
sobre o assunto.'''

print(re.sub(r'jOãO', 'Carlos', texto1, flags = re.I))
# método sub( ) recebe três parâmetros, sendo o primeiro a string a
ser
# substituída, seguido da string substituta, seguido da fonte onde ser
ão
# lidas e feitas as devidas alterações.

No dia trinta de março de dois mil e vinte
cidade, Carlos Fagundes e Maria Terres doaram juntos em
torno de duzentos mil reais. Carlos Fagundes se manifestou
sobre o assunto.

Buscando uma string específica no início de uma
sentença

print(re.match(r'Fernando', minha_string))

print(re.match(r'noite', minha_string))

<re.Match object; span=(0, 8), match='Fernando'>


print(re.match(r'Fernando', minha_string))
# match( ) gera um retorno caso a string usada como parâmetro seja
a string
# inicial de uma sentença. Como retorno será apontado o intervalo d
e índice
# de onde inicia até onde se extende a string inicial.

print(re.match(r'noite', minha_string))
# Retornará None, pois apesar de noite constar na string de origem,
a mesma
# não é a string inicial da sentença.

<re.Match object; span=(0, 8), match='Fernando'>

Separando uma string em partes
minha_string2 = 'Fernando chegará, a meia noite.'

print(re.split(r',', minha_string2))
# Onde houver vírgula, a sentença será quebrada em duas. É perfeit
amente
# possível definir outros marcadores para que sejam indicadores de
separação

['Fernando chegará', ' a meia noite.']

Números Avançados

Números complexos
# Números complexos são compostos de uma parte real e uma ima
ginária
# sendo cada parte representada por um número de casa decimal.

num = 3.1 + 8.5j

print(type(num))

<class 'complex'>

num = 3.1 + 8.5j

print(num)
# retornará todo o número imaginário

print(num.real)
# retornará apenas a parte real

print(num.imag)
# retornará apenas a parte imaginária

(3.1+8.5j)
3.1
8.5

Criando um número complexo via construtor
num2 = complex(4.3, 9.9)
# primeiro argumento referente a parte real, segundo argumento ref
erente
# a parte imaginária

print(num2)

print(type(num2))

(4.3+9.9j)
<class 'complex'>

String como argumento
num3 = complex('1.9+2.9j')

print(num3)

print(type(num3))

(1.9+2.9j)
<class 'complex'>

Binário
num1 = 1987

num1_bin = bin(num1)

print(f'O número original é: {num1}')
print(f'Sua forma binária é: {num1_bin}')

O número original é: 1987
Sua forma binária é: 0b11111000011

Hexadecimal
num1 = 1987

num1_hex = hex(num1)

print(f'O número original é: {num1}')
print(f'Sua forma hexadecimal é: {num1_hex}')

O número original é: 1987
Sua forma hexadecimal é: 0x7c3

Um número elevado a outro número
num1 = 2
num2 = 8

num3 = pow(num1, num2)

print(f'Quando elevamos {num1} a {num2} o resultado é: {num3}')

Quando elevamos 2 a 8 o resultado é: 256

Valor absoluto de um número
print(abs(19))
# Irá retornar 19

print(abs(-19))
# Irá retornar 19, pois em números absolutos não existem números
negativos

19
19

NaN
# Em tradução literal "Não é número" pode ser uma alternativa espe
cífica para
# situações onde None não é aplicável

float('nan')
# Alocará em memória um objeto do tipo "não é número"

nan

Infinity
float('infinity')
# Criará um objeto que é um número tendendo ao infinito positivo

inf

float('-infinity')
# Criará um objeto que é um número tendendo ao infinito negativo

-inf

List Comprehension (Avançado)

Gerando uma nova lista via comprehension
lista1 = [1,2,3,4,5,6]

for i in lista1:
print(i * 2)

#print(lista1)

lista2 = [i * 2 for i in lista1]

# Variável temporária i que percorre cada elemento da lista1 e multip
lica por 2

print(lista2)

2
4
6
8
10
12
[2, 4, 6, 8, 10, 12]

Desmembrando uma string elemento por
elemento
string = '1234567890'
comprehension = [letra for letra in string]
# Retornará elemento por elemento da variável como uma nova strin
g

print(comprehension)

['1', '2', '3', '4', '5', '6', '7', '8', '9', '0']

Desmembrando uma string dentro de um
intervalo de índice
string = '123456789012345678905925249529562'

print(string[0:10])
# Retornará do primeiro ao décimo elemento da string

# Retornará do décimo ao vigésimo elemento

# Retornará do vigésimo ao trigésimo elemento

1234567890
1234567890
5925249529

Separando a string de n em n números
string = '012345678901234567890123456789012'
n = 10

comp = [i for i in range(0, len(string), n)]
# Separando a string de 10 em 10 de acordo com a variável n, repas
sada como
# terceiro parâmetro da função range( )

print(comp)

comp2 = [(i, i + n) for i in range(0, len(string), n)]
# Verificando de quanto a quanto é esse intervalo

print(comp2)

[0, 10, 20, 30]
[(0, 10), (10, 20), (20, 30), (30, 40)]

Realizando o fatiamento da string
string = '012345678901234567890123456789012'
n = 10

comp3 = [string[i:i + n] for i in range(0, len(string), n)]
# Realizando o fatiamento de nossa string, desmembrando a mesm
a de 10 em 10
# caracteres.

print(comp3)

lista = [string[i:i + n] for i in range(0, len(string), n)]
retorno = '.'.join(lista)
# Caractere "." usado como separador, join( ) para juntar novamente
os elementos

print(retorno)

['0123456789', '0123456789', '0123456789', '012']
0123456789.0123456789.0123456789.012

Otimizando código via list comprehension
carrinho = []
total = 0


print('Método tradicional', total)

# Mesmo que:
# total2 = []
# for produto in carrinho:
# total2.append(produto[1])
# print('Usando funções internas', sum(total2))

# Usando list comprehension
# Notação entre colchetes para que se trabalha na camada interna d
a lista carrinho

print('Usando list comprehension', total3)

Método tradicional 97
Usando list comprehension 97

Combinando diferentes métodos em
comprehension
carros = ['Vectra', 'Golf', 'Civic', 'Tucson', 'Uno', 'Azera', 'Montana']

print(f'Carros em Estoque: ' + ' , '.join(sorted(set(carros))))
# sorted( ) organizará os elementos em ordem alfabética de acordo
com sua inicial

Carros em Estoque: Azera , Civic , Golf , Montana , Tucson , Uno ,
Vectra

carros = ['Vectra',
'Uno',
'Golf',
'Civic',
'Tucson',
'Uno',
'Azera',
'Montana',
'Vectra']

print(f'Carros em Estoque: ' + ' , '.join(sorted(set(carros))))

# Se houverem elementos repetidos na string, no retorno será apres
entado apenas
# uma amostra destes elementos

Vectra

Frequência de um elemento de uma lista
carros = ['Vectra',
'Uno',
'Golf',
'Civic',
'Tucson',
'Uno',
'Azera',
'Montana',
'Vectra']

lista_frequencia = dict()

for carro in carros:
lista_frequencia[carro] = lista_frequencia.get(carro, 0) + 1

print(lista_frequencia)

print(f'Carros em Estoque: ' + ' , '.join(sorted(set(lista_frequencia))))

{'Vectra': 2, 'Uno': 2, 'Golf': 1, 'Civic': 1, 'Tucson': 1, 'Azera': 1,
'Montana': 1}
Vectra

# Ordenando por frequência a lista anterior

from operator import itemgetter

', '.join([carro for carro, frequencia in sorted(lista_frequencia.items(),
key = itemgetter(1),
reverse = True)])
# Retornará uma lista com os elementos ordenados do mais frequen
te para o
# menos frequente.

Vectra, Uno, Golf, Civic, Tucson, Azera, Montana

Expressões Ternárias

# Parecido com comprehension, mas iterando sobre estruturas cond
icionais
# tornando as mesmas reduzidas.

num = 2

'Positivo' if num >= 0 else 'Negativo'

# Retorno esperado 'Positivo' caso a condição imposta seja verdadei
ra, caso
# contrário, retorna 'Negativo', tudo reduzido em uma expressão.

Positivo

Expressão ternária aplicada à função print( )
num = int(input('Digite um número entre 1 e 10: '))

if num >= 0 and num <= 10:
print('Maior que 5') if num >= 5 else print('Menor que 5')
else:
print('Número inválido')

Any e All

any( )
# Retornará True se ao menos um dos elementos de uma tupla/lista/
dicionário
# ou qualquer contêiner de dados for válido

condicoes = [False, False, False, True, False]
# Elemento de índice 3 é True, já validando o método

condicoes2 = {'ligado': 1, 'desligado': 0}
# No caso de um dicionário, o método irá chegar se alguma das cha
ves é True

print(any(condicoes))
print(any(condicoes2))

True
True

condicoes2 = {'ligado': 1, 'desligado': 0}
# Duas chaves com elementos válidos

condicoes3 = {None: 1, 'desligado': 0}
# Uma chave com elemento válido

condicoes4 = {None: 1, False: 0}
# Nenhuma chave com elemento válido


True
True
False

all( )
# Retornará True somente se todos elementos de uma tupla/lista/dici
onário
# ou contêiner de dados forem válidos

condicoes = [True, True, True, True, True]
condicoes2 = {True: 1, True: 0}

print(all(condicoes))
print(all(condicoes2))

True
True

condicoes3 = (1, 'Fernando', True, True)
# Todos elementos válidos

condicoes4 = (0, 'Fernando', True, True)
# 0 é interpretado como False, logo, um elemento False invalida tod
o o método

condicoes5 = (1, 'Fernando', True, False)
# 3 elementos válidos e um inválido

condicoes6 = {True: 1, True: 0}
# As duas chaves são elementos válidos


True
False
False
True

Operador Walrus

Sintaxe básica
# Operador que permite iterar, atribuir e retornar valor em forma red
uzida.
# Permite criar objetos diretamente dentro da função print( ).

# variavel := expressão

# Operador " := "

print(cidade := 'Curitiba')
# Dentro da função print( ) foi declarada a variável cidade com seu r
espectivo
# atributo e ao mesmo tempo foi executada a função realizada pelo
print( )

# Mesmo que:
# cidade = 'Curitiba'
# print(cidade)
# Porém, a variável cidade é funcional, como se estivesse declarada
no corpo/
# escopo global do código.

Curitiba

print(cidade := 'Curitiba')
# Nesta etapa é criada uma variável que fica suspensa em memória,
sendo iterável
# como qualquer outra variável declarada ao longo do código geral

print(cidade)
# irá exibir em tela o conteúdo da variável cidade, que apesar de nã
o declarada
# no escopo global do código, existe e possui conteúdo atribuído.

Curitiba
Curitiba

num1 = 2021

if num1 > 2000:
print(seculo := 'XXI')
# Variável seculo é criada e tem seu dado/valor atribuído 'XXI'

print(num1)
# Exibe em tela o conteúdo da variável num1, do escopo global do c
ódigo

print(seculo)
# Exibe em tela o conteúdo da variável seculo, suspensa em memóri
a

XXI
2021
XXI

# Pela leitura léxica, uma variável recém criada pelo operador Walru
s
# já é reconhecida e pode ser instanciada na mesma linha de código

print(f'{(metade := 16 / 2)} é a metade de {metade * 2}')
# Na primeira máscara de substituição é criada a variável metade, q
ue
# recebe como atributo o resultado da divisão de 16 por 2, em segui
da
# a própria variável metade é instanciada, agora sendo usada para
# uma operação matemática que pega seu valor e multiplica por 2.

8.0 é a metade de 16.0

carrinho = []

print('Quando quiser, digite "sair" para encerrar o programa.')
while (objeto := input('Digite um objeto: ')) != 'sair':
carrinho.append(objeto)
print(carrinho)

# Repare na linha 4, por meio do operador walrus é criada uma variá
vel chamada
# objeto, que recebe do usuário um dado/valor, a cada laço de repeti
ção.
# Fora desta expressão ainda temos uma estrutura de validação, on
de o loop
# só será encerrado quando o usuário digitar 'sair'.

Quando quiser, digite "sair" para encerrar o programa.
Digite um objeto: bola
Digite um objeto: casa
Digite um objeto: python
Digite um objeto: dólar
Digite um objeto: sair
['bola', 'casa', 'python', 'dólar']

Geradores e Iteradores (Avançado)

# Um objeto iterável é aquele com que você consegue interagir
# com cada elemento de sua composição, ex: cada letra de uma stri
ng...

minha_lista = [1,2,3,4]
minha_lista = iter(minha_lista)
# Construtor iter( ) "força" um objeto a permitir iterações

print(hasattr(minha_lista, '__iter__'))
# Verificando se minha_lista é iterável

for i in minha_lista:
print(i)

True
1
2
3
4

Gerando valores onde não existe para poupar
tempo e codificação
lista_0_a_100 = list(range(101))
# Método range( ) dentro de um construtor de lista precisará apenas
do
# valor final como parâmetro para gerar tal sequência numérica.

print(lista_0_a_100)

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20,
21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38,
39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56,
57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74,
75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92,
93, 94, 95, 96, 97, 98, 99, 100]

# Porém dados gerados com muitos elementos tem impacto sobre a
memória

import sys

lista_manual = list([0,1,2,3,4,5,6,7,8,9,10,11,12,13,14])
lista_gerada = list(range(14))

lista_milhao = list(range(1000001))

print('Tamanho em bytes de lista_manual:', sys.getsizeof(lista_manu
al))
# sys.getsizeof( ) retorna o tamanho em bytes de um objeto

print('Tamanho em bytes de lista_gerada:', sys.getsizeof(lista_gerad
a))

print('Tamanho em bytes de lista_milhao:', sys.getsizeof(lista_milhao
))

Tamanho em bytes de lista_manual: 248
Tamanho em bytes de lista_gerada: 240
Tamanho em bytes de lista_milhao: 9000128

Yeld
# Guardando valores em uma variável, de forma que a cada vez
# que eu chame ela ela me retorne um valor diferente.

import sys

def gera_numero():
num = 0
while True:
yield num
num += 1

gerador = gera_numero()

print(next(gerador))


0
1
2
3
4

import sys
import time

def variavel_iterada():
variavel = 'Valor 1'
yield variavel
yield variavel
yield variavel

var1 = variavel_iterada()

print(next(var1))
print(next(var1))
print(next(var1))

Valor 1
Valor 2
Valor 3

Map, Filter, Reduce + Comprehension

Método convencional para extração de dados
estoque = [
{'Item01': 'Camisa Nike', 'Preco':39.90},
{'Item02': 'Camisa Adidas', 'Preco':37.90},
{'Item03': 'Moletom 00', 'Preco':79.90},
{'Item04': 'Calca Jeans', 'Preco': 69.90},
{'Item05': 'Tenis AllStar', 'Preco': 59.90}
]

precos01 = []
for preco in estoque:
precos01.append(preco['Preco'])

print(f'Preços de estoque (normal) {precos01}')

Preços de estoque (normal) [39.9, 37.9, 79.9, 69.9, 59.9]

Extraindo dados via map( ) + função lambda
# map( ) permite aplicar uma função individualmente sobre cada ele
mento de um
# contêiner de dados.

estoque = [
]

precos02 = list(map(lambda p: p['Preco'], estoque))
# map( ) percorrendo cada elemento de estoque, retornando a cada
laço
# especificamente o valor de 'Preco', retornando esses valores em f
orma
# de lista

print(f'Preços de estoque (Map + Lambda) {precos02}')

Preços de estoque (Map + Lambda) [39.9, 37.9, 79.9, 69.9, 59.9]

Extraindo dados via list comprehension
estoque = [
]

precos03 = [preco['Preco'] for preco in estoque]
# Para cada valor associado a 'Preco' em estoque, retorne preco

print(f'Preços de estoque (List Comprehension) {precos03}')

Preços de estoque (List Comprehension) [39.9, 37.9, 79.9, 69.9,
59.9]

Extraindo dados via filter( )
estoque = [
]

precos04 = list(filter(lambda p: p['Preco'] >= 60, estoque))
# Precisa especificar um parâmetro a ser filtrado, nesse caso, "filtran
do"
# apenas os valores da chave 'Preco' cujo valor seja igual ou maior
que 60

print(f'Preços de estoque (Filter) {precos04}')

Preços de estoque (Filter) [{'Item03': 'Moletom 00', 'Preco': 79.9},
{'Item04': 'Calca Jeans', 'Preco': 69.9}]

Combinando filter( ) e list comprehension
estoque = [
]

precos05 = [preco['Preco'] for preco in estoque if preco['Preco'] > 60]
# filtrados somente precos maiores que 60

print(f'Preços de estoque (Filter + List Comprehension) {precos05}')

Preços de estoque (Filter + List Comprehension) [79.9, 69.9]

Combinando map( ) e filter( ) para extração de
dados
estoque = [
]

precos06 = list(map(lambda p: p['Preco'],
filter(lambda p: p['Preco'], estoque)))

print(f'Preços de estoque (Map + Filter) {precos06}')

Preços de estoque (Map + Filter) [39.9, 37.9, 79.9, 69.9, 59.9]

Extraindo dados via reduce( )
estoque = [
]


def func_reduce(soma, valores):
return soma + valores['Preco']

precos_total = reduce(func_reduce, estoque, 0)
# reduce( ) recebe como parâmetros uma função, um objeto origem
e um valor inicial

print(f'Soma dos Preços (Reduce) {precos_total}')

Soma dos Preços (Reduce) 287.5

Extraindo dados via reduce( ) + list
comprehension
estoque = [
]


precos_total = reduce(lambda soma, valores: soma + valores['Preco'
], estoque, 0)

print(f'Soma dos Preços (Reduce + List Comprehension) {precos_tot
al}')

Soma dos Preços (Reduce + List Comprehension) 287.5

Extraindo dados via reduce( ) ( método otimizado)
estoque = [
]


precos_total = sum([preco['Preco'] for preco in estoque])

print(f'Soma dos Preços (Reduce Método Otimizado) {precos_total}')

Soma dos Preços (Reduce Método Otimizado) 287.5

Try, Except, Finally, Raise (Avançado)

Tratando exceções
try:
print(abc)
except:
print('Não foi possível exibir o conteúdo de "a"')

# Nesse caso nada acontecerá, mas também não acontecerá um err
o ou
# interrupção em função de não conseguir imprimir o comando print(
a).

Não foi possível exibir o conteúdo de "a"

Except genérico
try:
print(abc)
except Exception as erro:
print('Ocorreu um erro inesperado')

Ocorreu um erro inesperado

Exibindo o erro específico
try:
print(abc)
except NameError as erro:
print(f'Ocorreu um erro: {erro}')

Ocorreu um erro: name 'abc' is not defined

Try e except como condicional, servindo para
prever exceções geradas pelo usuário
def conversor_num(num):
try:
num = int(num) # tentará converter para int
return num
except ValueError:
try:
num = float(num) # tentará converter para float
return num
except ValueError:
pass # caso não consiga nenhuma opção anterior irá retornar No
ne

num1 = conversor_num(input('Digite um número: '))

if num1 is not None:
print(num1 + 100)
else:
print('Operação inválida.')

185

Finally
def conversor_num(num):
try:
num = int(num)
return num
except:
num = float(num)
return num
finally:
print('Você digitou um caractere que não pode ser convertido')

num1 = conversor_num(input('Digite um número: '))

Você digitou um caractere que não pode ser convertido

Raise
idade = int(input('Digite sua idade: '))

if idade <= 0:
raise Exception('Idade inválida!!!')

print(f'Você tem {idade} anos!!!')

# Será gerado um erro Exception: Idade inválida!!!

Digite sua idade: 0
---------------------------------------------------------------------------
Exception Traceback (most recent call last)
<ipython-input-482-d316ba1626df> in <module>()
2
3 if idade <= 0:
----> 4 raise Exception('Idade inválida!!!')
5
6 print(f'Você tem {idade} anos!!!')

Exception: Idade inválida!!!

If __name__ == (‘__main__’)

# arquivo soma.py
def soma_num(num1, num2):
return num1 + num2

#print(__name__) # irá retornar __main__
#print(soma_num(9, 4))

if __name__ == '__main__':
print(soma_num(9, 4))
print('Teste de validação')

# Esse é um código de teste, se executar este arquivo, esse resulta
do será
# impresso, quando esse arquivo for importado como módulo para o
utro arquivo,
# esse arquivo deixará de ter o __name__ igual a __main__ e passa
rá a ter o
# __name__ igual a soma, então, esse código de teste não será exe
cutado.

13
Teste de validação

# arquivo meuprograma.py
import soma

num1 = int(input('Digite um número: '))
num2 = int(input('Digite outro número: '))
resultado = soma.soma_num(num1, num2)

print(resultado)
# irá retornar soma porque o módulo passa a ter o nome do próprio
arquivo
# quando importado
print(__name__)
# irá retornar __main__

Módulos Nativos do Python

Datetime
# import datetime

from datetime import datetime, date, time

data = datetime(2020, 6, 12, 15, 24, 59)
# Por justaposição, os parâmetros estarão como:
# ano, mês, dia, hora, minuto, segundo

print(data.date())
print(data.time())

print(data.year)
print(data.month)
print(data.day)

print(data.hour)
print(data.minute)
print(data.second)

2020-06-12
15:24:59
2020
6
12
15
24
59

Datetime como string
print(data.strftime('%m/%d/%Y %H:%M'))

# %Y - Ano com 4 dígitos
# %y - Ano com 2 dígitos
# %m - Mês com 2 dígitos
# %d - Dia com 2 dígitos
# %w - Dia da semana (entre 0 (domingo) e 6 (sábado))
# %H - Hora com notação de 24 horas
# %h - Hora com notação de 12 horas
# %M - Minuto com 2 dígitos
# %S - Segundos com 2 dígitos
# %W - Semana do ano (entre 00 e 53)
# %z - Fuso horário

06/12/2020 15:24

Convertendo uma string em datetime
data2 = datetime.strptime('20200101', '%Y%m%d')

print(data2)

2020-01-01 00:00:00

Substituindo um valor de datetime
data3 = datetime(2020, 6, 12, 15, 24, 59)
#data3.year = 2001 # retorna um erro porque o datetime inicial é imu
tavel

data3 = data3.replace(year = 2001)

print(data3)

2001-06-12 15:24:59

Diferença entre dois datetimes
data2 = datetime.strptime('20200101', '%Y%m%d')
data3 = datetime(2020, 6, 12, 15, 24, 59)

delta = data3 - data2

print(delta)

163 days, 15:24:59

Combinações, Permutações e Produto
(Itertools)

Combinações
from itertools import combinations

lista10 = ['Ana', 'Bianca', 'Carla', 'Daniela', 'Franciele', 'Maria']

for combinacoes in combinations(lista10, 2):
# possíveis combinações em grupos de 2
print(combinacoes)

# A ordem não importa e não haverão combinações repetidas entre
os elementos

('Ana', 'Bianca')
('Ana', 'Carla')
('Ana', 'Daniela')
('Ana', 'Franciele')
('Ana', 'Maria')
('Bianca', 'Carla')
('Bianca', 'Daniela')
('Bianca', 'Franciele')
('Bianca', 'Maria')
('Carla', 'Daniela')
('Carla', 'Franciele')
('Carla', 'Maria')
('Daniela', 'Franciele')
('Daniela', 'Maria')
('Franciele', 'Maria')

from itertools import combinations

combina = combinations([1, 2, 3, 4], 2)
# combinações entre os elementos, separados em grupos de 2 elem
entos

print(list(combina))

[(1, 2), (1, 3), (1, 4), (2, 3), (2, 4), (3, 4)]

Permutações
from itertools import permutations


for combinacoes in permutations(lista10, 2):
# possíveis combinações de elementos em grupos de 2
print(combinacoes)

# Neste caso, as combinações podem se repetir, alterando a ordem
dos elementos
# Ex: Ana e Bianca, Bianca e Ana...

('Ana', 'Bianca')
('Ana', 'Carla')
('Ana', 'Daniela')
('Ana', 'Maria')
('Bianca', 'Ana')
('Bianca', 'Carla')
('Bianca', 'Maria')
('Carla', 'Ana')
('Carla', 'Bianca')
('Carla', 'Maria')
('Daniela', 'Ana')
('Daniela', 'Bianca')
('Daniela', 'Carla')
('Franciele', 'Ana')
('Franciele', 'Bianca')
('Franciele', 'Carla')
('Franciele', 'Daniela')
('Maria', 'Ana')
('Maria', 'Bianca')
('Maria', 'Carla')
('Maria', 'Daniela')
('Maria', 'Franciele')

from itertools import permutations

permuta = permutations([1, 2, 3])

print(list(permuta))
# Irá retornar as devidas combinações, desde que o mesmo element
o numérico
# não não se repita em sua posição da tupla gerada.

[(1, 2, 3), (1, 3, 2), (2, 1, 3), (2, 3, 1), (3, 1, 2), (3, 2, 1)]

Product
from itertools import product


for combinacoes in product(lista10, repeat = 2):
# possíveis combinações de elementos separados em grupos de 2
print(combinacoes)

# Parecido com Permutations, mas aqui é permitido que um element
o se combine
# com ele mesmo.

('Ana', 'Ana')
('Ana', 'Bianca')
('Ana', 'Carla')
('Ana', 'Daniela')
('Ana', 'Maria')
('Bianca', 'Ana')
('Bianca', 'Bianca')
('Bianca', 'Carla')
('Bianca', 'Maria')
('Carla', 'Ana')
('Carla', 'Bianca')
('Carla', 'Carla')
('Carla', 'Maria')
('Daniela', 'Ana')
('Daniela', 'Bianca')
('Daniela', 'Carla')
('Daniela', 'Daniela')
('Franciele', 'Ana')
('Franciele', 'Bianca')
('Franciele', 'Carla')
('Franciele', 'Daniela')
('Franciele', 'Franciele')
('Maria', 'Ana')
('Maria', 'Bianca')
('Maria', 'Carla')
('Maria', 'Daniela')
('Maria', 'Franciele')
('Maria', 'Maria')

from itertools import product

produto = product([1, 2], [3, 4])

print(list(produto))
# Irá retornar uma lista onde cada elemento de cada lista é combina
do
# por cada elemento da outra. Ex: 1 e 3, 1 e 4, 2 e 3, 2 e 4.

[(1, 3), (1, 4), (2, 3), (2, 4)]

Combinations with replacement
# Forma alternativa de combinations, permitindo a repetição de elem
entos

from itertools import combinations_with_replacement

combina = combinations_with_replacement([1, 2, 3, 4], 2)

print(list(combina))

[(1, 1), (1, 2), (1, 3), (1, 4), (2, 2), (2, 3), (2, 4), (3, 3), (3, 4), (4, 4)]

Accumulate
# Como acumulação entenda-
se a soma dos elementos subsequentes

from itertools import accumulate

acumula = accumulate([1,2,3,4])

print(list(acumula))
# Retornará o equivalente a (1) no índice 0, (1 + 2) no índice 1, (1 +
2 + 3)
# no índice 2 e (1 + 2 + 3 + 4) no índice 3 da lista retornada.

[1, 3, 6, 10]

# accumulate( ) interagindo com operador aritmético

from itertools import accumulate
import operator

acumula2 = accumulate([1,2,3,4], func=operator.mul)

print(list(acumula2))
# Irá retornar o equivalente a (1 * 1) para o índice 0, (1 * 2) no índice
1,
# (1 * 2 * 3) no índice 2 e finalmente o equivalente a (1 * 2 * 3 * 4) pa
ra o
# índice 3 da lista retornada.

[1, 2, 6, 24]

GroupBy
from itertools import groupby

def par(n):
if n % 2 == 0:
return n

grupo = groupby([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], key = par)
for num in grupo:
print(num)

(None, <itertools._grouper object at 0x7f4356fcc3d0>)
(2, <itertools._grouper object at 0x7f4356ec4150>)
(None, <itertools._grouper object at 0x7f4356ec4c90>)
(None, <itertools._grouper object at 0x7f4356f7a910>)
(None, <itertools._grouper object at 0x7f4356ec4250>)
(8, <itertools._grouper object at 0x7f43578d2f90>)
(None, <itertools._grouper object at 0x7f43578d2650>)
(10, <itertools._grouper object at 0x7f43578d2850>)

Repeat
from itertools import count, cycle, repeat

var1 = 'Python'

for i in repeat(var1, 8):
print(i)
# repeat( ) irá repetir um dado/valor um número específico de vezes
definido
# em seu segundo parâmetro.

Python
Python
Python
Python
Python
Python
Python
Python

Expressões Lambda

# Também chamadas de funções anônimas, vazias ou reduzidas

def mensagem(x):
return x

# lambda
lambda x: x

# x: é a versão reduzida da função mensagem(x), enquanto o eleme
nto x seguinte
# é o retorno da função, que nesse caso apenas retorna o que foi pa
ssado como
# parâmetro da função.

<function __main__.<lambda>>

# Muito utilizado como método de redução e otimização de código

# A estrutura:
def mensagem():
return 'Olá Mundo!!!'

msg1 = mensagem()
print(msg1)

# Pode ser reduzida para:
msg2 = lambda: 'Olá Mundo!!!'
print(msg2())

Olá Mundo!!!
Olá Mundo!!!

variavel1 = lambda n1, n2: n1 * n2

n1 = int(input('Digite um número:'))
n2 = int(input('Digite outro número:'))

print(n1)
print(n2)

print(variavel1(n1, n2))

Digite um número:8
Digite outro número:5
8
5
40

Tópicos Avançados em POO

Associação de classes
class Usuario:
def __init__(self, nome):
self.__nome = nome
self.__logar = None
@property
def nome(self):
return self.__nome
@property
def logar(self):
return self.__logar
@logar.setter
def logar(self, logar):
self.__logar = logar

class Identificador:
def __init__(self, numero):
self.__numero = numero
@property
def numero(self):
return self.__numero
def logar(self):
print('Logando no sistema...')

usuario1 = Usuario('Fernando')
identificador1 = Identificador('0001')

usuario1.logar = identificador1
# Irá repassar como argumento para o método de classe logar(logar
)
# da classe Usuario( ) a classe Identificador('0001'), dessa forma
# Usuario( ) irá incorporar para si a estrutura de Identificador( )

usuario1.logar.logar()

Logando no sistema...

Agregação e composição de classes
class Contato:
def __init__(self, residencial, celular):
self.residencial = residencial
self.celular = celular

class Cliente:
def __init__(self, nome, idade, fone=None):
self.nome = nome
self.idade = idade
self.fone = []

def addFone(self, residencial, celular):
self.fone.append(Contato(residencial, celular))
# Adiciona a estrutura e conteúdo dos objetos de classe reside
ncial
# e celular da classe Contato( ) como atributo para o objeto fon
e da
# classe Cliente( ).
def listaFone(self):
for fone in self.fone:
print(fone.residencial, fone.celular)

cliente1 = Cliente('Fernando', 32)
cliente1.addFone(33221766, 991357258)

print(cliente1.nome)

print(cliente1.listaFone())

Fernando
33221766 991357258

Herança simples
class Corsa:
def __init__(self, nome, ano):
self.nome = nome
self.ano = ano

class Gol:
self.nome = nome
self.ano = ano

class Carro:
self.nome = nome
self.ano = ano

class Corsa(Carro):
# Incorpora toda estrutura da classe Carro() para a classe Corsa()
pass

class Gol(Carro):
pass

Cadeia de heranças
class Carro:
self.nome = nome
self.ano = ano

class Gasolina(Carro):
def __init__(self, tipogasolina=True, tipoalcool=False):
self.tipogasolina = tipogasolina
self.tipoalcool = tipoalcool

class Jeep(Gasolina):
pass

carro1 = Jeep()

print(carro1.tipogasolina)

True

class Carro:
self.nome = nome
self.ano = ano


# A classe Jeep( ) incorpora em sua estrutura as estruturas da cla
sse
# Gasolina( ) que por sua vez possui em sua estrutura a estrutura
da
# classe Carro( )
pass

# Internamente é o mesmo que:
# class Jeep():
# def __init__(self, nome, ano, tipogasolina=True, tipoalcool=False
):
# self.nome = nome
# self.ano = ano
# self.tipogasolina = tipogasolina
# self.tipoalcool = tipoalcool

carro1 = Jeep()


True

# Mesmo que:

class Jeep:
def carro():
self.nome = nome
self.ano = ano

def gasolina(self, tipogasolina=True, tipoalcool=False):

jeep = Jeep()

# Código otimizado

class Carro:
self.nome = nome
self.ano = ano


pass

carro1 = Jeep()


True

Herança múltipla
class Mercadoria:
self.nome = nome
self.preco = preco

class Carnes(Mercadoria):
def __init__(self, tipo, peso):
self.tipo = tipo
self.peso = peso

class Utensilios:
def __init__(self, espetos, carvao):
self.espetos = espetos
self.carvao = carvao

class KitChurrasco(Carnes, Utensilios):
pass

pacote1 = KitChurrasco('carne', 14.90)
pacote1.tipo = 'costela'
pacote1.peso = 1
pacote1.espetos = 1
pacote1.carvao = 1

class Mercadoria:
self.nome = nome
self.preco = preco

class Carnes(Mercadoria):
def __init__(self, tipo, peso):
self.tipo = tipo
self.peso = peso

class Utensilios:
def __init__(self, espetos, carvao):
self.espetos = espetos
self.carvao = carvao

class KitChurrasco(Carnes, Utensilios):
# KitChurrasco recebe como argumento para seus atributos de cl
asse
# toda estrutura e conteúdos das classes Carnes( ) e Utensilios( )
pass

pacote1 = KitChurrasco('carne', 14.90)
pacote1.tipo = 'costela'
pacote1.peso = 1
pacote1.espetos = 1
pacote1.carvao = 1

# Internamente é o mesmo que:
# class KitChurrasco(Carnes, Utensilios):
# def __init__(self, nome, preco, tipo, peso, espetos, carvao):
# self.nome = nome
# self.preco = preco
# self.tipo = tipo
# self.peso = peso
# self.espetos = espetos
# self.carvao = carvao
# pass

Sobreposição de membros
class Pessoa:
self.nome = nome

def Acao1(self):
print(f'{self.nome} está dormindo')

class Jogador1(Pessoa):
def Acao2(self):
print(f'{self.nome} está comendo')

class SaveJogador1(Jogador1):
pass

p1 = SaveJogador1('Fernando')
# O argumento 'Fernando' será repassado para o atributo de classe
nome da
# classe Pessoa(), que por sua vez é objeto da classe Jogador1(), q
ue por
# sua vez é objeto da classe SaveJogador1( ).
print(p1.nome)

p1.Acao1()
p1.Acao2()

Fernando
Fernando está dormindo
Fernando está comendo

class Pessoa:
self.nome = nome

def Acao1(self):

def Acao2(self):

def Acao1(self):
super().Acao1()
print(f'{self.nome} está acordado')

p1.Acao1()
p1.Acao2()

Fernando está acordado

Sobreposição via super( )
class Pessoa:
self.nome = nome

def Acao1(self):

def Acao2(self):

# super() para definir a prioridade de execução de um método de cla
sse

def Acao1(self):
super().Acao2()
# Define que dos métodos de classe associados a classe Pess
oa(),
# Acao2() terá prioridade de execução
print(f'{self.nome} encerrando as atividades')

p1.Acao1()

Fernando encerrando as atividades

def Acao1(self):
super().Acao1()
print(f'{self.nome} encerrando as atividades')

p1.Acao1()

Fernando encerrando as atividades

# Outro exemplo

class Pessoa:
self.nome = nome

def Acao1(self):
print(f'{self.nome} Primeira Ação')

def Acao2(self):
print(f'{self.nome} Segunda Ação')

class SaveJogador1(Pessoa):
def Acao(self):
super().Acao1() # Executará primeiro o método de classe Acao
1()
#super().Acao2() # Executará primeiro o método de classe Aca
o2()

p1.Acao()

Fernando Primeira Ação

Classes abstratas
from abc import ABC, abstractclassmethod

class Pessoa(ABC):
@abstractclassmethod
def logar(self):
pass

class Usuario(Pessoa):
def logar(self):
print('Usuario logado no sistema')

#user1 = Pessoa()
#user1.logar()

user1 = Usuario()
user1.logar()

Usuario logado no sistema

Polimorfismo
from abc import ABC, abstractclassmethod

class Pessoa(ABC):
@abstractclassmethod
def logar(self, chaveseguranca):
pass

class Usuario(Pessoa):
print('Usuario logado no sistema')

class Bot(Pessoa):
print('Sistema rodando em segundo plano')

user1 = Usuario()
user1.logar('I5m8b4y9')

Usuario logado no sistema

Sobrecarga de operadores
class Caixa:
def __init__(self, largura, altura):
self.largura = largura

caixa1 = Caixa(10,10)

print(caixa1 + caixa2)

# Irá gerar um erro, pois estaríamos tentando sobrepor objetos

---------------------------------------------------------------------------
<ipython-input-517-186cd61e3323> in <module>()
7 caixa2 = Caixa(10,20)
8
----> 9 print(caixa1 + caixa2)
10
11 # Irá gerar um erro, pois estaríamos tentando sobrepor
objetos

TypeError: unsupported operand type(s) for +: 'Caixa' and 'Caixa'

# Contornando o erro anterior:

class Caixa:
def __init__(self, largura, altura):
self.largura = largura

def __add__(self, other):
largura1 = self.largura + other.largura
altura1 = self.altura + other.altura
return Caixa(largura1, altura1)

def __repr__(self):
return f"<class 'Caixa({self.largura}, {self.altura})'>"

caixa3 = caixa1 + caixa2

print(caixa3)

<class 'Caixa(20, 30)'>

Gerenciamento de Filas

Gerenciamento de filas via nodes
from typing import Any

EMPTY_NODE_VALUE = '__EMPTY_NODE_VALUE__'

class Erro(Exception):
...

class Node:
def __init__(self, value: Any) -> None:
self.value = value
self.next = Node

def __repr__(self) -> str:
return f'{self.value}'

def __bool__(self) -> bool:
return bool(self.value != EMPTY_NODE_VALUE)

class Queue:
def __init__(self) -> None:
self.first: Node = Node(EMPTY_NODE_VALUE)
self.last: Node = Node(EMPTY_NODE_VALUE)
self._count = 0

def enqueue(self, node_value: Any) -> None:
novo_node = Node(node_value)

if not self.first:
self.first = novo_node
if not self.last:
self.last = novo_node
else:
self.last.next = novo_node
self.last = novo_node
self._count += 1

def pop(self) -> Node:
if not self.first:
raise Erro('Sem elementos na fila')
first = self.first

if hasattr(self.first, 'next'):
self.first = self.first.next
else:
self.first = Node(EMPTY_NODE_VALUE)
self._count += 1
return first

def peek(self) -> Node:
return self.first

def __len__(self) -> int:
return - self._count

def __bool__(self) -> bool:
return bool(self._count)

def __iter__(self) -> Queue:
return self

def __next__(self) -> Any:
try:
next_value = self.pop()
return next_value
except Erro:
raise StopIteration

fila1 = Queue()
fila1.enqueue('Maria')
fila1.enqueue('Carlos')
fila1.pop()

Gerenciamento de filas via deque
from typing import Deque, Any
from collections import deque

fila2: Deque[Any] = deque()

fila2.append('Ana')
fila2.append('Carlos')
fila2.append('Fernando')
fila2.append('Maria')

for pessoas in fila2:
print(pessoas)

fila2.popleft()

for pessoas in fila2:
print(pessoas)

# Deque trabalha com índices, sendo assim, ao tentar remover um l
emento que não
# consta no índice 0, seré gerado um erro.

Ana
Carlos
Fernando
Maria
Carlos
Fernando
Maria

Docstrings

Docstrings de bibliotecas/módulos de terceiros
import pickle

print(pickle.__doc__)

Create portable serialized representations of Python objects.

See module copyreg for a mechanism for registering custom
picklers.
See module pickletools source for extensive comments.

Classes:

Pickler
Unpickler

Functions:

dump(object, file)
dumps(object) -> string
load(file) -> object
loads(string) -> object

Misc variables:

__version__
format_version
compatible_formats

Criando uma docstring personalizada
# módulo soma.py

def soma(n1, n2):
''' Esta é uma simples função de soma de dois números,
ao chamar a função, dois números devem ser obrigatoriamente
repassados para a função, a mesma irá retornar o valor
da soma destes números, em formato float.'''

return float(n1 + n2)

soma_numeros = soma(7, 14)

print(f'O resultado da soma é: {soma_numeros}')
# retornará o resultado da soma

print(f'Documentação do módulo soma: \n {soma.__doc__}')
# retornará a "documentação" criada para o módulo, que nesse caso
# se encontra dentro da própria função soma( ).

O resultado da soma é: 21.0
Documentação do módulo soma:
Esta é uma simples função de soma de dois números,
ao chamar a função, dois números devem ser obrigatoriamente
repassados para a função, a mesma irá retornar o valor
da soma destes números, em formato float.

Citações

Citações dentro de strings
msg1 = 'Olá, seja bem-vindo(a)!!!'

msg2 = "Marca d'água"

print(msg1)
print(msg2)

Olá, seja bem-vindo(a)!!!
Marca d'água

msg3 = 'Ele disse, \"Python é a melhor linguagem de programação!!!
" '
# intercalando aspas simples e duplas para contornar a sintaxe

msg4 = 'Ele disse, \'Python é a melhor linguagem de programação!!!
\''
# usando de barra \ para permitir o uso de apenas um tipo de aspas

msg5 = "Ela disse, \"Não encontrei a marca d'água neste objeto...\" "
# usando de aspas duplas e simples para contornar o apóstrofo

print(msg3)
print(msg4)
print(msg5)

Ele disse, "Python é a melhor linguagem de programação!!!"
Ele disse, 'Python é a melhor linguagem de programação!!!'
Ela disse, "Não encontrei a marca d'água neste objeto..."

Built-ins / Métodos Genéricos

abs( )
# Valor absoluto de um número

num_negativo = -276

print(num_negativo)

num_absoluto = abs(num_negativo)

print(num_absoluto)

-276
276

# Conversão direta de um número para seu estado matemático abso
luto

num = abs(-276)

print(num)

276

ascii( )
nome = 'Fernando'

nome_ascii = ascii(nome)

print(nome)
print(nome_ascii)

Fernando
'Fernando'

# Retornará o código de caractere especial no lugar do símbolo, evit
ando erros

nome = ' 网络 Fernando'

nome_ascii = ascii(nome)

print(nome)
print(nome_ascii)

网络 Fernando
'\u7f51\u7edcFernando'

# -*- coding: utf-8 -*-

# Declarado na primeira linha do código "força" o interpretador a rec
onhecer
# caracteres especiais evitando exceções ou erros de sintaxe.

bytes( )
# int para bytes

tamanho = 8
tam_bytes = bytes(tamanho)

print(tam_bytes)
print(type(tam_bytes))

b'\x00\x00\x00\x00\x00\x00\x00\x00'
<class 'bytes'>

# str para bytes

nome = 'Fernando'
tam_bytes = bytes(nome, 'utf-8')

print(tam_bytes)
print(type(tam_bytes))

b'Fernando'
<class 'bytes'>

# list para bytes

pares = [2, 4, 6, 8, 10]
tbytes = bytes(pares)

print(pares)
print(type(pares))

print(tbytes)
print(type(tbytes))

[2, 4, 6, 8, 10]
<class 'list'>
b'\x02\x04\x06\x08\n'
<class 'bytes'>

# bytearray

tamanho = 8
barr = bytearray(tamanho)
# Retornará uma array de 8 bytes

print(tamanho)
print(barr)

8
bytearray(b'\x00\x00\x00\x00\x00\x00\x00\x00')

callable( )
def soma(n1, n2):
return n1 + n2

print(callable(soma))
# Retorna True caso a função esteja declarada corretamente, pronta
para usp

True

eval( )
# Avalia uma expressão fora de contexto, normalmente em formato
de string,
# e caso essa expressão seja válida executa a expressão mesmo fo
ra de contexto.

variavel = 'print(99)'
# Em forma de string existe uma função com parâmetro

print(variavel)

print(eval(variavel))
# Executará a função identificada na string de variavel

print(99)
99

from math import *

opr = {'raiz_quadrada': sqrt, 'potenciacao': pow}

print(eval('dir()', opr))
# retornará as expressões associadas a variável opr

print(eval('raiz_quadrada(81)', opr))
# Retornará o resultado da expressão em si

['__builtins__', 'potenciacao', 'raiz_quadrada']
9.0

from math import *

opr = {'raiz_quadrada': sqrt, 'potenciacao': pow}
eval1 = eval('raiz_quadrada(81)', opr)
# Identifica e executa a expressão, atribuindo o dado resultante para
si

print(f'O resultado da operação é: {eval1}')
# Apenas instancia a variável eval1

O resultado da operação é: 9.0

exec( )
# Funcionalidade parecida com o eval( ), porém suportando duas ou
mais expressões na mesma string

programa = 'n1 = 5\nn2 = 10\nprint("Resultado da soma:", n1 + n2)'
exec(programa)

# Cada linha demarcada por \n atua como separador para cada ele
mento e operação

# Seria o mesmo que:
# programa = 'n1 = 5,
# n2 = 10,
# print("Resultado da soma:", n1 + n2)'
# mas essa forma não é permitida.

Resultado da soma: 15

format( )
# Altera o identificador do tipo de dado, mas sem alterar o tipo do m
esmo de fato

num1 = format(128, 'o') # octal
num2 = format(1987, 'x') # hexadecimal

print(num1)
print(num2)
# Retornará o dado/valor em seu novo formato identificável

print(type(num1))
# Retorna o tipo de dado verdadeiro, basicamente string em função
do marcador

200
7c3
<class 'str'>

# Marcadores e seus respectivos tipos de dados

'b' - binário
'c' - unicode
'd' - decimal
'e' - número científico
'g' - geral
'o' - octal
'x' - hexadecimal
'n' - número genérico
'%' - percentual

id( )
# Todos dados possuem um identificador interno, caso seja necessá
rio,
# é possível descobrir o número identificador desse objeto

carros = ['Astra', 'Golf', 'Vectra']

ids = id(carros)

print(ids)

140596099803408

iter( )
# Útil para iterar isoladamente desmembrando elementos de uma tu
pla/lista/dicionário

cidades = iter(['Curitiba', 'Brasília', 'Florianópolis'])

cidade1 = next(cidades)
# Retornará o primeiro elemento isoladamente
print(cidade1)

# next() retornará o segundo elemento, e assim por diante, até o nú
mero total de elementos
print(cidade2)

print(cidade3)

Curitiba
Brasília
Florianópolis

open( )
# Abre um arquivo, possibilitando manipular o mesmo diretamente vi
a código

arquivo1 = open('pareceres.txt', 'r')

print(arquivo1.read())

# Modos de leitura de arquivo:

'r' - apenas leitura
'w' - leitura e escrita
't' - abre um arquivo em formato apenas texto
'b' - abre um arquivo em seu modo binário
'x' - cria no diretório um arquivo

slice( )
# Fatia e extrai informação dos elementos de uma tupla, a contar do
número
# de índice 0 até o número especificado.

nomes = ('Ana', 'Carlos', 'Daniela', 'Elis', 'Fernando', 'Mariana', 'Paulo
')
primeiros3 = slice(3)
# A variável servirá apenas como parâmetro para leitura dos element
os instanciados

print(nomes[primeiros3])

('Ana', 'Carlos', 'Daniela')

Contêineres de Dados

Desempacotando e iterando sobre contêineres
# Entende-
se por contêiner toda variável/objeto que guarda múltiplos
# dados atribuídos para si.

numeros = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10)

*primeiros, ultimo = numeros

print(f'Os primeiros números são: {primeiros}')
print(f'O último número é: {ultimo}')

Os primeiros números são: [1, 2, 3, 4, 5, 6, 7, 8, 9]
O último número é: 10

numeros = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10)

primeiro, *ultimos = numeros

print(f'O primeiro número é: {primeiro}')
print(f'Os demais números são: {ultimos}')

O primeiro número é: 1
Os demais números são: [2, 3, 4, 5, 6, 7, 8, 9, 10]

numeros = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10)

primeiro, *intermediarios, ultimo = numeros

print(f'O primeiro números é: {primeiro}')
print(f'Os números intermediários são: {intermediarios}')
print(f'O último número é: {ultimo}')

O primeiro números é: 1
Os números intermediários são: [2, 3, 4, 5, 6, 7, 8, 9]
O último número é: 10

nomes = ['Ana Luiza', 'Carolina', 'Daiane', 'Franciele', 'Maria']

primeiro, *intermediarios, ultimo = nomes

print(f'A lista de chamada começa com: {primeiro}')
print(f'E termina com: {ultimo}')

A lista de chamada começa com: Ana Luiza
E termina com: Maria

Migrando dados de contêineres
tupla = (1, 2, 3)
conjunto = {4, 5, 6}

lista = [*tupla, *conjunto]
# Um marcador " * " pois estamos trabalhando com elementos indep
endentes

print(lista)

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

dicionario1 = {'one': 1, 'two': 2}
dicionario2 = {'three': 3, 'four': 4}

dicionario3 = {**dicionario1, **dicionario2}
# Marcador " ** " pois em dicionários estamos trabalhando com chav
es : valores

print(dicionario3)

{'one': 1, 'two': 2, 'three': 3, 'four': 4}

Threads

Método sequencial regular
def mensagem1():
contador = 0
while contador <= 3:
print('Estou trabalhando...')
contador += 1

def mensagem2():
contador2 = 0
while contador2 <= 3:
print('Estou estudando...')
contador2 += 1

mensagem1()
mensagem2()

Estou trabalhando...
Estou estudando...
Estou estudando...
Estou estudando...
Estou estudando...

Threads paralelas
import threading

def mensagem3():
contador = 0
while contador <= 3:
print('Estou trabalhando...')
contador += 1

def mensagem4():
contador2 = 0
while contador2 <= 3:
print('Estou estudando...')
contador2 += 1

threading.Thread(target=mensagem3).start()
mensagem4()

Estou estudando...
Estou estudando...
Estou estudando...

Single-thread Vs multi-thread
# single-thread

import time
from threading import Thread

contador = 100000000

def contagem_regressiva(num):
while num > 0:
num -= 1

inicio = time.time()
contagem_regressiva(contador)
fim = time.time()

print(f'Tempo de execução: {fim - inicio}')

Tempo de execução: 4.415599584579468

# multi-thread

import time
from threading import Thread


while num > 0:
num -= 1

tempo = Thread(target = contagem_regressiva,
args = (contador//2,))

tempo.start()
tempo.join()
fim = time.time()



GIL – Python global interpreter lock
# Utiliza multi-processing ao invés de multi-threading

# Em outras palavras, cada processo ganha seu próprio interpretado
r
# Python e espaço dedicado em memória, como em computação pa
ralela.

from multiprocessing import Pool
import time


while num > 0:
num -= 1

if __name__ == '__main__':
pool = Pool(processes = 4) # número de threads independentes
tempo = pool.apply_async(contagem_regressiva, [contador//2])
pool.close()
pool.join()
fim = time.time()


Gerenciamento de Memória

Memória stack e memória heap
# Meu Programa
variavel1 = 1987

# variavel1 estará situada na stack layer, como uma referência mape
ada e indexada
# para um objeto que está carregado na memória, alocando espaço
para guardar um
# dado ou valor a ser utilizado.

# 1987, atributo do objeto variavel1, estará em um espaço de memó
ria alocado na
# memória heap, sendo um objeto que pode ser instanciado e manip
ulado pelo programa

# cada vez que um objeto tem seu atributo modificado por uma funç
ão, é criado um
# novo stack com o mesmo objeto porém com seu atributo diferente.
Em outras palavras
# um dado/valor da memoria heap pode ser compartilhado por vário
s objetos da memória
# stack, mas o contrário não é possível, cada objeto que instancia e
itera sobre
# um dado/valor alocado em memória é uma stack única.

num1 = 1987
# Um objeto alocando um espaço em memória para guardar seu da
do

num2 = 237
num3 = num2
# Dois objetos usando apenas de um dado alocado em memória

print(num2)
print(type(num2))
print(id(num2))

print(num3)
print(type(num3))
print(id(num3))

# Verificando se de fato dois ou mais objetos usam do mesmo dado
alocado em memória

n1 = 1987
n2 = 1987

if id(n1) == id(n2):
print(f'{n1} e {n2} São o mesmo dado alocado em memória.')
else:
print(f'{n1} e {n2} possuem dados alocados em memória diferentes.
')

1987 e 1987 possuem dados alocados em memória diferentes.

n1 = 1987
n2 = 1988

else:
print(f'{n1} e {n2} possuem dados alocados em memória diferente
s.')

1987 e 1988 possuem dados alocados em memória diferentes.

n1 = 1987
n2 = n1

else:
print(f'{n1} e {n2} possuem dados alocados em memória diferente
s.')

1987 e 1987 São o mesmo dado alocado em memória.

num1 = 20

def soma(num):
num = num + 10
return num

calculo = soma(10)

print(id(num1))
print(id(calculo))
# Uma vez que os valores de num1 e de calculo serão iguais (20), e
xibindo em
# tela o id desses objetos podemos ver que os mesmos apontam pa
ra o mesmo dado
# alocado em memória.

94220624440416
94220624440416

# Em uma estrutura orientada a objetos, uma classe poderá ter atrib
utos de classe
# e métodos de classe, porém haverá uma identificação e indexação
interna, onde
# quando a classe deixar de ser molde para um objeto, internamente
os atributos
# iniciais serão classificados como dead object e um mecanismo cha
mado garbage
# collector irá zerar as referências de dados/valores alocados em m
emória

class Pessoa:
def __init__(self, idade):
self.idade = idade

def att_idade(self):
return self.idade

pessoa1 = Pessoa(18)

pessoa2 = pessoa1

print(pessoa1)
print(pessoa2)

# pessoa1 e pessoa2 apontam para o mesmo dado/valor alocado e
m memória

<__main__.Pessoa object at 0x7f72dbdb8710>
<__main__.Pessoa object at 0x7f72dbdb8710>

class Pessoa:
def __init__(self, idade):
self.idade = idade

def att_idade(self):
return self.idade


pessoa2 = pessoa1


# 3 objetos apontando para 2 dados/valores alocados em memória

Contagem de referência
# Serve para contar quantos objetos estão usando um dado/valor al
ocado
# em memória, lembrando que na orientação a objetos quando uma
variável/objeto
# deixa de instanciar um dado/valor alocado em memória, o mesmo
se torna um
# dead object, em seguida tendo seus registros e conteúdo limpados
por completo.

# Lembrando também que em python uma função também é um obj
eto, logo, ao buscar
# pela contagem de quantos objetos existem com dados/valores alic
ados em memória
# a própria função de contagem será mais uma instância que interag
e com o dado/
# valor em memória.

import sys

lista = ['Paulo', 'Mariana']
nomes = lista

print(sys.getrefcount(lista))

# Retornará 3, sendo na contagem de referência 1 referente a variév
el lista, 2
# referente a variável nomes e 3 referente a função getrefcount().

3

Verificando o tempo de execução de um código
from timeit import timeit as t
from collections import namedtuple

Pessoa = namedtuple('Pessoa', 'nome email')

pessoa1 = Pessoa('Pessoa', 'fernando2rad@gmail.com')

print(t(pessoa1.nome, globals=globals()))
# Irá retornar o tempo em segundos que o núcleo Python levou para
abrir
# e processar todo o conteúdo desse código.

0.02830556899994008

Banco de Dados

import sqlite3 # no caso de SQLite3
from mysql.connector import connect # no caso de MySQL

Criando uma conexão / SQLite3
conexao = sqlite3.connect('base.db')

cursor = conexao.cursor()

Criando uma conexão / MySQL
from mysql.connector import connect

conexao = connect(host='localhost',
port=3306,
user='root',
passwd='123456789')

Criando uma conexão persistente / MySQL
from mysql.connector import connect
from contextlib import contextmanager

parametros = dict(host = 'localhost',
port = 3306,
user = 'root',
passwd = '123456789',
database = 'base_de_dados)

@contextmanager
def nova_conexao():
conexao = connect(**parametros)
try:
yield conexao
finally:
if (conexao and conexao.is_connected()):
conexao.close()

Visualizando bancos de dados existentes

cursor.execute('SHOW DATABASES')

diretamente via cursor
cursor.execute('CREATE TABLE IF NOT EXISTS usuarios ('
'id INTEGER PRIMARY KEY AUTOINCREMENT,'
'nome TEXT,'
'peso REAL'
')')

importados de variáveis
tabela_contatos = """
CREATE TABLE IF NOT EXISTS contatos(nome VARCHAR(50), te
lefone VARCHAR(40))
"""

tabela_emails = """
CREATE TABLE IF NOT EXISTS emails(
id INT AUTO_INCREMENT PRYMARY KEY,
dono VARCHAR(50)
)
"""

cursor.execute(tabela_contatos)
cursor.execute(tabela_emails)

Inserindo dados/registros na base
cursor.execute('INSERT INTO usuarios (nome, peso) VALUES ("Fer
nando Feltrin", 130.5)')
# método comum, não seguro

#cursor.execute('INSERT INTO usuarios (nome, peso) VALUES (?, ?
)', ('Fernando Feltrin', 130.5))
# Dados repassados via tupla com justaposição de argumentos

#cursor.execute('INSERT INTO usuarios (nome, peso) VALUES (:no
me, :peso)', {'nome':'Fernando Feltrin', 'peso':130.5})
# via dicionário com justaposição

#cursor.execute('INSERT INTO clientes VALUES (id:, :nome, :peso)',
{'id': None, 'nome':'Fernando Feltrin', 'peso':130.5})
# Via dicionário com justaposição, método reduzido

conexao.commit()

Inserindo dados/registros da base através de
*args
insere = 'INSERT INTO contatos (nome, telefone) VALUES (%s, %s)
'
args = (
('Ana', '55-991357258'),
('Carla', '55-991357254'),
('Daiane', '55-811357258'),
('Michele', '55-999957258'),
('Paula', '55-991359999'),
('Tania', '55-991357258'),
('Ana', '55-999997259'),
)

cursor.executemany(insere, args)

conexao.commit()

Alterando dados
altera = 'ALTER TABLE contatos ADD COLUMN id INT AUTO_INCR
EMENT PRIMARY KEY'

cursor.execute(altera)

conexao.commit()

Atualizando dados
cursor.execute('UPDATE usuarios SET nome=:nome WHERE id=:id'
,
{'nome':'Mariana Veiga', 'id':2}
)

conexao.commit()

Excluindo registros existentes
cursor.execute('DELETE FROM usuarios WHERE id=:id',
{'id':3}
)

conexao.commit()

Visualizando o conteúdo da base de dados
cursor.execute('SELECT * FROM usuarios')

for linha in cursor.fetchall():
num, nome, peso = linha # desempacotando os dados em variáve
is
print(f'Identificador: {num}, Nome: {nome}, Peso: {peso}')
#print(linha)

Buscando um registro específico
cursor.execute('SELECT nome FROM usuarios WHERE peso > 100'
)

for linha in cursor.fetchall():
nome = linha
print(nome)

Listando tabelas existentes

cursor.execute('SHOW TABLES')

for i, tabela in enumerate(cursor, start = 1):
print(f'Tabela {i}: {tabela[0]}')

Excluindo uma tabela

cursor.execute('DROP TABLE IF EXISTS emails')

conexao.commit()

Encerrando os trabalhos na base de dados
cursor.close()

conexao.close()

Untitled

Enviado por

Dados do documento

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

Untitled

Enviado por

Direitos autorais:

Formatos disponíveis

Fernando Feltrin é Engenheiro da Computação com

Você também pode gostar