Bônus

Revisão e Exemplos

 

Tipos de Dados

# INT - Número real inteiro, sem casas decimais.

num1 = 12

num2 = int(15)

print(type(num1))

print(type(num2))

 

# FLOAT - Número de ponto flutuante / com casas decimais.

num3 = 12.8

num4 = float(19.0)

print(type(num3))

print(type(num4))

 

# BOOL - Booleano / Binário (0 ou 1)

condicao1 = 0

sensor01 = True

print(type(condicao1))

print(type(sensor01))

 

# STRING - Texto composto de qualquer caractere alfanumérico.

palavra1 = 'palavra'

palavra2 = "marca d'água"

frase1 = 'Uma frase qualquer'

frase3 = 'Ela tinha 8 anos'

frase3 = str('Outra frase qualquer')

print(type(palavra2))

print(type(frase3))

# LIST - Listas de qualquer tipo.

lista = [2, 'Pedro', 15.9]

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

print(type(lista))

print(type(lista2))

 

# DICT - Dicionários.

dicionario = {'Nome':'Fernando', 'Idade':32}

print(type(dicionario))

 

Comentários

# Comentário simples de até uma linha

'''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' #Legível pelo interpretador

#usuario1 = 'Fernando' #Ignorado pelo interpretador

 

Variáveis

# Sintaxe Básica

nome_da_variavel = dado/valor/atributo

variavel1 = 20

variavel2 = 'Veronica'

print(variavel1)

print(variavel2)

 

# Tipos de Variáveis

var_tipo_string = 'Conjunto de caracteres alfanuméricos' # Incluindo símbolos e caracteres especiais var_tipo_int = 12

# Número inteiro

var_tipo_float = 15.3

# Número com casas decimais

var_tipo_bool = 1

# Booleano / Binário (0 ou 1)

var_tipo_lista = [1, 2, 'Paulo', 'Maria', True]

# Lista de dados/valores

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

var_tipo_tupla = ('Ana', 'Fernando', 3)

# Lista de dados/valores porém imutável

var_tipo_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..."""

 

# Declarando uma variável quanto ao seu tipo

numero2 = 1987

ano_nasc = '1987'

print(type(numero2))

print(type(ano_nasc))

 

# Declarando múltiplas variáveis

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

'''

Mesmo que:

nome = 'Maria'

idade = 32

sexo = 'F'

'''

print(nome)

print(idade)

print(sexo)

print(nome, idade, sexo)

 

# Declarando múltiplas variáveis de mesmo tipo e dado/valor

num2 = x = a1 = 10

'''

Mesmo que:

num2 = 10

x = 10

a1 = 10

'''

print(num2)

print(x)

print(a1)

 

# Operações entre variáveis

a = 10

b = 5.2

print(a + b) # Soma simples

 

# Interações entre variáveis

msg = 'Olá '

pessoa = 'Carlos'

print(msg + pessoa) # Concatenação

 

# Sintaxe não permitida / não recomendada

# Formas de declarar uma variável que podem gerar erros de interpretação

Nome Nome de variável iniciando em letra maiúscula NOME Nome de variável escrita totalmente em letras maiúsculas 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ênteses ou colchetes

# Sintaxe usual permitida

nome

nome2

nome_de_variavel

 

# Palavras reservadas ao sistema

# Palavras que não podem ser usadas como nome de uma variável 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

 

Funções Básicas de Entrada e de Saída

# Função de saída que exibe em tela ou em terminal algo para o usuário

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

 

# Exibindo em tela o conteúdo de uma variável

nome = 'Fernando'

print('Fernando')

print(nome)

 

# Realizando operações aritméticas dentro da função print( )

print(15 + 4)

print(15 - 4)

print(15 * 4)

print(15 / 4)

 

# Realizando operações entre dados/valores declarados e dados/valores atribuídos

numero3 = 30

print('O resultado da soma é: ', numero3 + 15)

 

# Realizando operações lógicas dentro da função print( )

numero = 9

print(numero > 3)

print(numero < 10)

print(numero == 11)

print(numero >= 12)

 

# Usando fStrings e máscaras de substituição dentro da função print( )

nome = 'Fernando'

print(f'Seja muito bem-vindo {nome}!!!')

 

# Usando operadores por meio de fStrings e suas máscaras de substituição

camisa = 19.90

calca = 39.90

print(f'A soma dos produtos do carrinho é: {camisa + calca}')

 

# Sintaxe antiga vs 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.

 

# Função de entrada, interage com o usuário fazendo com que o mesmo insira dados # Esta função por sua vez deve ser associada a uma variável

# A mesma só termina dua função no momento que o usuário aperta o botão ENTER

nome = input('Digite o seu nome: ')

print(nome)

 

nome = input('Digite o seu nome: ')

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

 

Operadores Aritméticos

# Soma

print(5 + 7)

 

# Subtração

print(12 - 3)

 

# Multiplicação

print(5 * 7)

 

# Divisão

print(120 / 6)

 

# Mais de uma operação simples

print(5 + 2 * 7)

 

# Operação composta

print((5 + 2) * 7)

# Primeiro será realizada a operação dentro dos parênteses, posteriormente o resto.

 

# Potenciação

print(3 ** 5) #3 elevado a 5ª potência

 

# Divisão exata

print(9.4 // 3)

 

# Módulo/Resto de uma divisão

print(10 % 3)

 

Operadores de Atribuição

# Atribuindo um dado ou valor a uma variável

nome = 'Fernando'

idade = 33

 

# Atribuição aditiva

valor = 4

valor = valor + 5

print(valor)

 

# Atribuição aditiva (método reduzido)

valor = 4

valor += 5

'''

Mesmo que:

valor = valor + 5

'''

print(valor)

 

# Atribuição subtrativa

valor = 4

valor -= 3

'''

Mesmo que:

valor = valor - 3

'''

print(valor)

 

# Atribuição multiplicativa

valor = 4

valor *= 3

'''

Mesmo que:

valor = valor * 3

'''

print(valor)

 

# Atribuição divisiva

valor = 12

valor /= 2

'''

Mesmo que:

valor = valor / 2

'''

print(valor)

 

# Módulo de (ou resto da divisão de)

valor = 12

valor %= 2

'''

Mesmo que:

valor = valor % 4

'''

print(valor)

 

# Divisão inteira

valor = 512

valor //= 256

'''

Mesmo que:

valor = valor // 256

'''

print(valor)

 

# Exponenciação

valor = 4

valor **= 8

'''

Mesmo que:

valor = valor ** 8

ou

valor = 4 * 4 * 4 * 4 * 4 * 4 * 4 * 4

'''

print(valor)

 

Operadores Lógicos

# Igualdade

print(5 == 6)

print(12 == 12)

 

# Diferença

print(7 != 3)

 

# Operadores lógicos compostos

# Todas as condições precisam ser verdadeiras para o retorno ser True

print(7 != 3 and 2 > 3)

 

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

num1 = 4

num2 = 9

num3 = 9

print(num1 == num2)

print(num1 is num2)

print(num2 is 9)

print(num2 is num3)

 

Operadores de Membro

# Verifica se um elemento é membro daquele tipo de dado

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

print(2 in lista)

 

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

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

print('Maria' not in lista)

 

Operadores Relacionais

# Maior que

idade = 12

print(idade > 4)

# 3 é maior que 4?

 

# Igual ou maior que

num1 = 7

print(num1 >= 7)

# 7 é maior ou igual a 3?

 

# 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?

 

# Menor ou igual a

y = 7

z = 5

print(z <= y)

# O valor de z é igual ou menor que o valor de y?

 

# Duas condições lógicas

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?

 

# Operadores em estruturas condicionais

idade = 21

if (idade > 18):

print('Idade adulta.')

 

num1 = 2

num2 = 1

if num1 > num2:

print('2 é maior que 1')

 

Operadores de Identidade

# 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 mesmo valor de energia?

print(aluguel is agua)

# O valor de aluguel é o mesmo valor de agua?

 

Estruturas Condicionais

# if, elif, else

# 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 dela é executado, caso contrario é simplesmente ignorado

 

# Estrutura Condicional com argumento lógico

num = 51

if num < 50:

print('Menor que 50')

else:

print('Maior que 50')

 

# Estrutura Condicional Composta

nome = input('Digite o seu nome:')

if nome == 'Fernando':

print('Bem vindo de volta Fernando!!!')

else:

print('Você não é Fernando...')

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

 

# Estruturas Condicionais Aninhadas (quando se tem mais de duas possibilidades)

num1 = 12

if num1 <= 50:

print('Menor que 50')

elif num1 >= 50:

print('Maior que 50')

else:

print('Número Inválido')

# Se o valor de num1 for igual ou maior que 50, exibe a respectiva mensagem # Caso a primeira condição não for verdadeira, é verificado se o valor de num1 # é maior ou igual a 50. Caso nenhuma condição seja verdadeira, é exibida a # mensagem em else. Quando uma condição for verdadeira, nenhuma das seguintes # será executada.

 

# 1 condição sendo verdadeira já encerra o processo

nome1 = 'Fernando'

nome2 = 'Maria'

if nome1 == 'Fernando':

print('Bem-vindo Fernando!!!')

#if nome2 == 'Maria':

if nome2 == 'Maria':

print('Bem-vinda Maria!!!')

else:

print('Erro: Nome Desconhecido.')

# elif irá executar somente a primeira condição e encerrar o processo se ela # for verdadeira. elif irá imprimir somente o primeiro print() substituir elif # por if irá considerar mais de uma condição como verdadeira. if irá imprimir # o primeiro e o segundo print por ambos serem verdadeiros.

 

# 2 ou mais condições sendo verdadeiras

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 é Maria')

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 (uma condição e outra).

 

# Operações dentro de estruturas condicionais simples

num1 = 1

num2 = 15

if (num1 + num2) >= 20:

print('O resultado da soma é maior do que 20')

else:

print('O resultado da soma é menor do que 20')

 

# Estruturas condicionais com interpolação e máscaras de substituição

nomes = ['Fernando', 'Maria', 'Carlos']

login = input('Digite o seu nome: ')

if login in nomes:

print(f'Bem-vindo(a) {login}')

else:

print('Usuário não cadastrado.')

 

# Operações dentro de estruturas condicionais 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')

 

# Estruturas Condicionais com Validadores Simples (em string)

nome = input('Digite o seu nome: ')

if nome == 'Fernando':

print('Olá Fernando, você é o administraor 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 restritas.')

 

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

nome = input('Digite o seu nome: ')

if nome == 'Fernando':

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 sistema.')

elif nome in 'Carlos José Paulo':

print(f'Bem vindo {nome}, você é um usuário registrado no sistema')

else:

print('Olá, você não está logado no sistema, suas permissões são restritas.')

 

# Mesmo exemplo anterior, aprimorado

nome = input('Digite o seu nome: ')

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

if nome == 'Fernando':

print('Olá Fernando, você é o administrador do sistema!!!')

elif nome in funcionarias_mulheres:

print(f'Bem vinda {nome}, você é uma usuária registrada no sistema.')

elif nome in funcionarios_homens:

print(f'Bem vindo {nome}, você é um usuário registrado no sistema.')

else:

print('Olá, você não está logado no sistema, suas permissões são restritas.')

 

# Estrutura condicional composta com or (ou) e and (e)

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 verdadeira # Condicão em and as duas condicionais precisam serem verdadeiras.

 

Estruturas de Repetição

# Enquanto determinada condição for verdadeira, o processo se repete

x = 0

while x <= 5:

print(x)

x = x + 1

 

# Enquanto o usuário não digitar a palavra específica o código não é executado

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

while validador.strip() != 'Matrix':

print('Palavra-chave não confere, digite novamente:')

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

 

# 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')

 

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

while True:

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

if validador.strip() == 'Matrix':

break

else:

print('Palavra-chave não confere, digite novamente:')

 

# Laço de repetição simples

compras = ['Arroz', 'Feijão', 'Massa', 'Carne', 'Pão'] for i in compras:

print(i)

 

# Laço de repetição que percorre cada elemento de uma string

nome = 'Alberto'

for i in 'Alberto':

print(i)

 

# Laço de repetição dentro de um intervalo predefinido

for i in range(0, 10):

print(i)

 

# Laço de repetição que atualiza valor de variável

vendas = [1000, 459, 911, 200, 838, 50]

total = 0

for i in vendas:

total += i

print(total)

 

# Laço de repetição que separa elementos de uma lista

compras = [['Arroz', 'feijão'], ['Carne', 'Frango', 'Peixe'], ['Leite']]

for i in compras:

print(i)

 

# Laço de repetição que separa elementos de um dicionário

cores = {'verde': 'green', 'azul': 'blue', 'vermelho': 'red'}

for i in cores:

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

 

# Laço for contando de 2 em 2 elementos

for i in range(0, 10, 2):

print(i)

 

# Contagem Regressiva via laço for

for i in range(10, 0,-1): #terceiro parâmetro estipula que o laço será feito do fim para o começo

print(i)

 

# Laço for que realiza 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)

 

# 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)

 

# 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])

# código otimizado via função enumerate( )

for n_indice, valor in enumerate(nome):

print(n_indice, valor)

 

Strings

# Sintaxe básica

nome = 'atributo em formato alfanumérico'

# Contar quantos caracteres compõe uma string

frase1 = 'Porto Alegre é uma cidade Brasileira.'

print(len(frase1))

 

# Substituindo elementos de uma string

frase1 = 'Porto Alegre é uma cidade Brasileira.' frase1 = frase1.replace('Porto Alegre', 'Curitiba')

print(frase1)

 

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

frase1 = 'Porto Alegre é uma cidade Brasileira.'

print(frase1.count('a'))

 

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

frase1 = 'Porto Alegre é uma cidade Brasileira.'

print(frase1.find('é'))

 

# Realizando a leitura de um caractere pelo seu índice

frase1 = 'Porto Alegre é uma cidade Brasileira.'

print(frase1[16])

 

# Desmembrando uma string, separando cada palavra da frase

frase1 = 'Porto Alegre é uma cidade Brasileira.'

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, apenas onde houver ; haverá a separação das strings.

 

# Pegando dados de uma string especificando um intervalo de seu índice

frase1 = 'Porto Alegre é uma cidade Brasileira.'

print(frase1[26:37]) # intervalo específico print(frase1[0:5]) # do início até uma posição i print(frase1[-9]) # de trás para frente

 

# Concatenando strings por meio de variáveis

mensagem = 'Seja bem-vinda '

usuario = 'Ana Clara'

base = mensagem + usuario

print(base)

 

# Concatenando diferentes tipos de dados em uma string

nome = 'Ana Clara'

idade = 12

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

aviso = 'Atenção, geradores entrarão em manutenção às: ' + str(22) + ' horas!'

print(aviso)

 

# 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)

 

# Letras maiúsculas ou minúsculas em uma string

alerta = 'Risco de Morte'

print(alerta.upper())

print(alerta.lower())

 

# Convertendo outro tipo de dado para string

num1 = 5623

num2 = str(num1)

print(type(num1))

print(type(num2))

 

# Removendo espaços no início e no fim de uma string

frase1 = ' Olá, você é o visitante nº 1000 '

print(frase1)

print(frase1.strip())

 

# Convertendo todas iniciais das palavras para maiúsculo, como em um título

tema = 'O diagnóstico por imagem como ferramenta para detecção de câncer'

tema = tema.title()

print(tema)

 

# Verificando se uma string é composta por letras e números

print('aa44'.isalnum()) # Qualquer caractere alfanumérico

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

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

 

# Adicionando espaços antes e depois de uma string

frase1 = 'Alerta, Risco de Morte!!!'

frase1 = frase1.ljust(50)

print(frase1)

frase2 = 'Alerta, Risco de Morte!!!'

frase2 = frase2.rjust(50)

print(frase2)

frase3 = 'Alerta, Risco de Morte!!!'

frase3 = frase3.center(50)

print(frase3)

 

Listas

# Criando uma lista simples

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

print(lista1)

 

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

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

print(lista1[3])

 

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

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

print(lista1.index('Michele'))

 

# Descobrindo o número de elementos de uma lista

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

print(len(lista1))

 

# Adicionando um novo elemento a lista

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

lista1.append('Paulo')

print(lista1)

 

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

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

lista1[2] = 'José'

print(lista1)

 

# Removendo um elemento de uma lista pelo seu número de índice

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

lista1.remove(lista1[5])

print(lista1)

 

# Listas dentro de listas

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

print(cadastro)

 

Conjuntos Numéricos

# Criando um conjunto numérico (set) em Python

conjunto1 = {5, 10, 15, 20}

print(type(conjunto1))

 

# Operações entre conjuntos

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

cj2 = {1, 3, 5, 7, 9}

print(cj2 - cj1)

 

# 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 duplicados.

 

# Interseção de dois conjuntos

conjunto1 = {5, 10, 15, 20, 25}

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

uniao = conjunto1.intersection(conjunto2)

#uniao = conjunto1.update(conjunto2)

print(uniao)

 

# Operadores lógicos em conjuntos numéricos

conjunto1 = {5, 10, 15, 20, 25}

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

uniao = conjunto1.union(conjunto2)

print(uniao == conjunto1)

print(uniao >= conjunto2)

 

# Diferença entre conjuntos

c1 = {1, 2, 3, 4, 5} - {1, 2}

print(c1)

 

# Diferença entre conjuntos associados a variáveis

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

c2 = {1, 3, 5, 7, 9}

print(c1 - c2)

 

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.')

 

# 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!!!')

 

Dicionários

# Sintaxe básica

dicionario = {'chave': 'valor'}

print(dicionario)

 

# Adicionando novos elementos ao dicionário

dicionario1 = {'Nome1':'Paulo'}

print(dicionario1)

dicionario1['Nome2'] = 'Veronica'

print(dicionario1)

 

# Alterando o valor de uma chave do dicionário

dicionario1 = {'Nome1': 'Ana',

'Nome2': 'Carla',

'Nome3': 'Maria'}

print(dicionario1)

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

print(dicionario1)

 

# Acessando um elemento do dicionário

dicionario1 = {'Nome':'Fernando',

'Idade':32,

'Sexo':'Masculino',

'Nacionalidade':'Brasileiro'}

print(dicionario1['Nome'])

print(dicionario1['Nacionalidade'])

 

# Usando o construtor de dicionários do Python

dicionario2 = dict(chave1 = 'valor da chave1',

chave2 = 'valor da chave 2')

print(dicionario2)

print(type(dicionario2))

 

# Consultando apenas as chaves de um dicionário

dicionario2 = dict(chave1 = 'valor da chave1',

chave2 = 'valor da chave 2')

dicionario2.keys()

 

# Consultando apenas os valores de um dicionário

dicionario2 = dict(chave1 = 'valor da chave1',

chave2 = 'valor da chave 2')

dicionario2.values()

# Verificando se uma chave ou valor consta em um dicionário

# Pesquisando pela chave, obtendo valor

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

print(d3.get('5'))

print(d3.get('2'))

'''Mesmo que:

print('3' in d3)'''

# Pesquisando se o dado/valor consta em uma chave

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

# Pesquisando se o dado/valor consta em um valor

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

# Pesquisando se o dado/valor de um valor de dicionário é o dado/valor que se espera ser print(d3['2'] == 'Maria') # o valor da chave '2' é 'Maria' ?

 

# Atualizando um elemento do dicionário

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

print(d4)

d4.update({'2':'E'})

'''Mesmo que:

d4['3'] = 'F'

print(d4)'''

print(d4)

 

# Removendo um elemento do dicionário

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

print(d4)

del d4['4']

print(d4)

 

# Pesquisando o tamanho de um dicionário / de quantos elementos ele é composto

d4 = {'1':'A', '2':'B', '3':'C', '4':'D', '5':'E', '6':'F'} print(len(d4))

 

# Imprimindo só chaves e só valores

d4 = {'1':'A', '2':'B', '3':'C', '4':'D', '5':'E', '6':'F'}

print(d4.keys())

print(d4.values())

 

# Lendo as chaves ou valores 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)

for m in d4.items():

print('Chaves:',m[0],' - ','Valores:',m[1])

for n, o in d4.items(): # 2 variáveis temporárias n e o, o mesmo que desempacotamento de elementos

print('Chaves:',n,' - ','Valores:',o)

print(f'Chaves: {n}, Valores: {o}') # trazendo para a sintaxe atual f'Strings

 

# 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])

 

# Transformando chaves ou valores de um dicionário em tupla para fácil indexação

dicionario1 = {'Nome':'Fernando', 'Idade':32, 'Sexo':'Masculino', 'Nacionalidade':'Brasileiro'}

print(dicionario1.keys())

dict_chaves = tuple(dicionario1.keys())

print(dict_chaves)

print(dict_chaves[3])

# 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}')

 

# Removendo elementos de um dicionário por meio da função pop( )

dicionario1 = {'Nome':'Fernando', 'Idade':32, 'Sexo':'Masculino', 'Nacionalidade':'Brasileiro'}

dicionario1.pop('Nacionalidade')

'''

Mesmo que:

del dicionário1['Nacionalidade']

porém del é uma palavra reservada ao sistema

'''

print(dicionario1)

 

# Usando do método get( ) para não gerar exceções quando um elemento não faz 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', 'nova chave') # '4' é um elemento não existe,te, será substituído por 'nova chave'

# caso instanciasse no primeiro parâmetro um elemento presente no # dicionário iria retornar o mesmo normalmente, caso for um elemento # faltante já irá tratar a exceção normalmente, inserindo o novo dado

 

Funções

# Sintaxe básica

def nome_da_funcao(parametros):

"corpo da função"

 

# Definindo uma função sem parâmetros

def mensagem():

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

# poderia ser, dependendo o contexto, return 'Seja Bem-Vindo!!!'

print(mensagem())

 

# Chamando a função

def mensagem():

print('Seja Bem Vindo!!!')

mensagem()

 

# Função associada a uma variável

def mensagem():

print('Seja Bem Vindo!!!')

mensagem1 = mensagem()

print(mensagem1)

 

# Criando uma função que temporariamente não faz nada

def funcao():

pass

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

print(type(var1)) # Retornará NoneType

 

# Função interagindo com variável que interage com o usuário

usuario3 = input('Digite o seu nome:')

def mensagem(nome):

print('Bem Vindo ' + nome + '!!!')

print(mensagem(usuario3))

 

# Passando o parâmetro ao chamar a função

def funcao(msg):

print(msg)

funcao('Bem Vindo!!!')

 

# Passando o parâmetro ao chamar a função = exemplo 2

def mensagem(nome):

print(f'Bem Vindo(a) {nome}!!!')

usuario1 = mensagem('Fernando')

print(mensagem)

 

# Passando mais de um parâmetro para uma função

def mensagem(nome, idade):

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

usuario1 = mensagem('Fernando', 33) # respeitar a ordem dos parâmetros

print(usuario1)

 

# Definindo parâmetros "padrão", para caso o usuário não passe nenhum parâmetro.

def funcao(msg='Olá', nome='usuário'):

print(msg, nome)

funcao()

 

# Passando apenas um parâmetro e recebendo o resto padrão

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

print(msg, nome, msg2)

funcao(nome='Fernando')

 

# Passando parâmetro e interagindo com o usuário

def funcao(mensagem, nome):

print(mensagem, nome)

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

 

# Interagindo com o usuário #2

def funcao(msg='Ola', nome='usuário', msg2='Seja Bem Vindo!!!'): nome = input('Digite o seu nome: ')

print(msg, nome, msg2)

variavel1 = funcao()

# Interagindo com o usuário #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: '))

print(variavel1)

 

# Passando um parâmetro manualmente e fora da ordem padrão do índice

def msg(nome = 'Ana', idade = 25, prof = 'Cozinheira'):

print(f'{nome}, {idade} anos, {prof}')

variavel5 = msg(prof = 'Costureira')

# assim não foi preciso declarar as prmeiras variáveis até chegar na prof

print(msg)

 

# Fazendo 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:'))

soma = n1 + n2

print(soma)

# Pode ser reescrito por:

def soma(n1, n2):

return n1 + n2

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

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

print(soma(n1, n2))

 

# Fazendo operações dentro de uma função #2

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('O valor será de: ',calculo,'%')

# Estruturas condicionais dentro de funções #1

def repetidor(msg):

contador = 0

while contador < 5:

print(msg)

contador += 1

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

 

# Estruturas condicionais dentro de funções #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(divisao(num1, num2))

 

# Estruturas condicionais dentro de funções #3 - 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: '))))

 

# Função com argumentos externos

def funcao(*args):

for v in args:

print(v)

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

print(funcao(argumentos))

 

# Desempacotando uma lista para que os elementos dela virem argumentos da função

lista1 = ['nome', 'idade', 'sexo', 'nacionalidade']

def funcao(*args):

print('Informações Necessárias:')

print(args)

funcao(*lista1)

 

# 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]

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

# senhas_padrao substituirá args e o parametro nomeado aqui usuario substituirá kwargs

 

# Função com parâmetros baseados em *args e **kwargs

# Buscando dados do modelo anterior

def funcao(*args, **kwargs):

nome = kwargs['usuario']

nome2 = kwargs['administrador']

senha1 = args[0]

senha2 = args[1]

print('O usuário comum é: ',nome)

print('O administrador do sistema é: ', nome2)

print('A senha padrão é: ', senha1)

print('A senha alternativa é: ', senha2)

senhas_padrao = [12345, 11111]

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

# senhas_padrao substituirá args e o parametro nomeado aqui usuario substituirá kwargs

 

# Função que recebe outra função como parâmetro

def msg_boas_vindas():

return 'Seja Muito Bem Vindo!!!'

def mestre(funcao):

return funcao()

exec = mestre(msg_boas_vindas)

print(exec)

 

# 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')

 

Expressões Lambda

variavel1 = lambda num1, num2: num1 * num2

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

num2 = int(input('Digite outro número:'))

print(num1)

print(num2)

print(variavel1(num1,num2))

 

Escopo Global e Escopo Local

variavel1 = 'Paulo'

print('Exibindo direto da variável: ', variavel1)

def funcao1():

print('Print de dentro da função 1: ', variavel1)

funcao1()

def funcao2():

variavel1 = 'Paulo Silva'

print('Print da variável local / função 2: ', variavel1)

funcao2()

print('Printando a variável global novamente: ', variavel1)

# Não confundir o nome da variável, apesar de igual, a variável1 que consta na função 2 só funciona dentro dela a variável que consta na função 2 não altera/atualiza o valor da variável declarada inicialmente, ela só tem valor modificado dentro da função.

 

# Modificando uma variável global de dentro de uma função

num1 = 100

print('Variável com seu valor inicial: ', num1)

def modificador():

global num1

num1 = 200

print('Variável alterada dentro da função: ', num1)

modificador()

print('Variável atualizada pela função anterior: ',num1)

 

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

print(set1)

# A diferença de um set para um dicionário será que um set não tem aquele par de elementos chave:valor. Um set não tem índice e os elementos guardados dentro dele ficam em ordem aleatória.

 

# Criando um set via construtor

set1 = set()

set1.add('Ana')

set1.add(23)

print(set1)

set1.add(15.6)

set1.add('Maria')

set1.discard(23)

print(set1)

 

# 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)

 

List Comprehension

# Fazendo 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 multiplica por 2

print(lista1)

print(lista2)

 

# Desmembrando uma string elemento por elemento

string = '12345678901234567890'

comprehension = [letra for letra in string]

print(comprehension)

 

# Pegando partes de uma string

string = '123456789012345678905925249529562956243482649287529843482548258922'

print(string[0:10])

print(string[10:20])

print(string[20:30])

 

# Trabalhando com partes de uma string

string = '01234567890123456789012345678901234567890123456789' 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)

 

# Aprimorando um código mudando sua função por uma list comprehension

carrinho = []

carrinho.append(('Item 1', 30))

carrinho.append(('Item 2', 45))

carrinho.append(('Item 3', 22))

total = 0

for produto in carrinho:

total = total + produto[1]

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

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

print('Usando list comprehension', total3)

 

Dictionary Comprehension

# Basicamente a mesma lógica de list comprehension, mas quando tempos 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)

 

# Realizando operações dentro do 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)

 

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 string

lista = [1,2,3,4]

nome = 'Fernando'

for i in lista:

print(i)

for j in nome:

print(j)

 

# Gerador gera valores onde não existem para poupar tempo e codificação

lista_0_a_100 = list(range(101))

print(lista_0_a_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))

 

# Guardando valores em uma variável, de forma que a cada vez que eu chame ela ela me retorne um valor diferente

import sys

import time

def variavel_iterada():

variavel = 'Valor 1'

yield variavel

variavel = 'Valor 2'

yield variavel

variavel = 'Valor 3'

yield variavel

var1 = variavel_iterada()

print(next(var1))

print(next(var1))

print(next(var1))

 

Zip

# Zip para iterar e unir duas listas

cidades = ['Porto Alegre', 'Curitiba', 'Salvador', 'Belo Horizonte'] estados = ['RS', 'PR', 'BH', 'MG']

cidades_estados = zip(cidades, estados)

for i in cidades_estados:

print(i)

 

# Zip_longest para 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)

 

Count

# Usando o contador do sistema

from itertools import count

contador = count()

for numero in contador:

print(numero)

if numero >= 10:

break

 

# Contando dentro de um intervalo personalizado

from itertools import count

contador = count(start = 40)

for numero in contador:

print(numero)

if numero >= 50:

break

 

# Personalizando de quantos em quantos números o contador irá trabalhar

from itertools import count

contador = count(start = 0, step = 2)

for numero in contador:

print(numero)

if numero >= 20:

break

 

Map

# Map = função que serve para aplicar uma função em cada elemento ou linha por linha de uma lista/tupla/dicionario

produtos = [

{'nome': 'item 1', 'preco': 32},

{'nome': 'item 2', 'preco': 23},

{'nome': 'item 3', 'preco': 12},

{'nome': 'item 4', 'preco': 10},

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

]

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)

 

# Usando map( ) para extrair dados de um dicionário

produtos = [

{'nome': 'item 1', 'preco': 32},

{'nome': 'item 2', 'preco': 23},

{'nome': 'item 3', 'preco': 12},

{'nome': 'item 4', 'preco': 10},

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

]

precos = map(lambda p: p['preco'], produtos)

for preco in precos:

print(preco)

 

# Usando uma função ativa no lugar da lambra (que é uma função vazia)

def aumenta_precos(p):

p['preco'] = p['preco'] * 1.05

return p

precos2 = map(aumenta_precos, produtos)

for produto in precos2:

print(produto)

 

Filter

# Mesma coisa que a map, só que trabalha com lógica condicional, servindo para aplicar funções ou extrair informação de um elemento desde que uma condição seja True

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)

print(list(idosos))

 

produtos2 = [

{'nome': 'item 1', 'preco': 32},

{'nome': 'item 2', 'preco': 23},

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

{'nome': 'item 4', 'preco': 10},

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

]

def filtra(p):

if p['preco'] > 50:

return True

nova_lista3 = filter(filtra, produtos2)

for produtox in nova_lista3:

print(produtox)

 

Try, Except

# Tratando exceções para que não se interrompa a execução de um código

try:

print(a)

except:

pass

# Nesse caso nada acontecerá, mas também não acontecerá um erro ou interrupção em função de não conseguir imprimir o comando print(a).

 

# Exibindo que erro aconteceu

try:

print(a)

except NameError as erro:

print('Ocorreu um erro:',erro)

#Except genérico:

except Exception as erro:

print('Ocorreu um erro inesperado')

 

# Exibindo que erro específico aconteceu

try:

print(a)

except NameError as erro:

print('Ocorreu um erro:',erro)

 

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 None

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

if num1 is not None:

print(num1 + 100)

else:

print('Operação inválida.')

 

# 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!!!

Bibliotecas, Módulos e Pacotes

# Função dir( ) exibe quais módulos/pacotes/funções foram carregadas por padrão

dir()

 

# Explorando tudo o que vem importado por padrão no Python

import builtins

dir(builtins)

 

# Importando módulos que por padrão não são carregados junto ao Python em sua inicialização

import random

dir()

# Agora random( ) está carregada na memória e pronta para uso

 

# Verificando 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.

 

# Abreviando a nomenclatura de um módulo

import random as ra

for i in range(10):

print(ra.randint(1,10))

 

# Importando apenas uma função específica de um módulo

from random import randint

for i in range(10):

print(randint(0,10))

 

Criando Módulos Manualmente

# Arquivo soma.py

def soma(num1, num2):

s = int(num1) + int(num2)

return s

# Arquivo index.py

import soma

print(f'O resultado da soma é: {soma.soma(8,3)}')

 

Manipulando Arquivos

# Abrindo/criando um arquivo para leitura e escrita

arquivo = open('nomedoarquivo.txt', 'w+')

# w+ permite a leitura e escrita

arquivo.write('Prineira Linha \n')

arquivo.write('Segunda Linha \n')

arquivo.write('Terceira Linha \n')

arquivo.write('Quarta Linha \n')

arquivo.close()

arquivo.seek(0,0) # força a leitura do arquivo desde sua posição 0

print(arquivo.read())

# print(arquivo.readline()) linha por linha

arquivo.close()

 

# Apagando um arquivo via IDE

import os

os.remove('arquivo.txt')

 

Programação Orientada a Objetos

# Sintaxe básica

class Nome:

objetos

 

# Criando uma classe vazia

class Pessoa:

pass

 

# Criando objetos (atributos de classe) dentro de uma classe class Pessoa:

pass

pessoa1 = Pessoa()

pessoa1.nome = 'Fernando'

pessoa1.idade = 32

print(pessoa1.nome)

 

# Criando funções (métodos) dentro de uma classe

class Pessoa:

def acao1(self):

print('Ação 1 sendo executada...')

pessoa1 = Pessoa()

pessoa1.acao1()

 

# Criando uma classe com construtor e variáveis internas

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.idade} anos!!!')

 

# Mais de uma função dentro de uma classe

class Pessoa:

ano_atual = 2019

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())

# Lembrando que nesse exemplo ano_atual é um atributo da classe, e está acessível a todas funções internas, já ano_nasc por exemplo é 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 receber a nomenclatura de "métodos" e seus atributos podem ser chamados de "instâncias".

 

# 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 = 2019

def __init__(self, nome, idade):

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(pessoa2.idade)

 

# Métodos estáticos

# Aqueles que não possuem instâncias como atributos, funciona como uma função normal dentro da classe

from random import randint

class Pessoa:

@staticmethod

def gerador_id():

gerador = randint(100, 999)

return gerador

print(Pessoa.gerador_id())

 

# @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 processado 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}')

 

# 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)

 

# Mudando um atributo de classe

class Classe1:

var1 = 101001

variavel1 = Classe1()

Classe1.var1 = 111111

print(Classe1.var1)

 

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 fora da classe)

#self.__dados = {} declarado como privado (inacessível e imutável de fora da classe)

base = BaseDeDados()

print(base.dados)

 

Recursividade

def fatorial(num: int) -> int:

if num == 1:

return 1

return num * fatorial(num - 1)

fator = fatorial(5)

print(fator)

 

Expressões Regulares

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))

 

minha_string = 'Fernando chegará a meia noite.' print(re.findall(r'Fernando|Fernanda', minha_string))

 

import re

# r'Strings

# 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))

print(re.findall(r'.oão|.aria', texto1))

 

# Meta caractere " | " significa "ou"

# | significa ou, e tem suporte a número de palavras ilimitadas

print(re.findall(r'.oão|.aria', texto1))

print(re.findall(r'.oão|.aria|mil', texto1))

 

# Meta caractere " [] " significa "conjunto de caracteres"

# Usado para definir quais possíveis caracteres estarão numa determinada 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 também sabemos que os possíveis caracteres são J ou j, mas em outras strings precisaremos ampliar a abordagem

 

# pode conter quantos possíveis caracteres forem necessarios

print(re.findall(r'[AaBbCcDdEeFfGgHhIiJj]oão', texto1))

# 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))

 

# Alterando o comportamento de uma expressão regular via flags

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úsculas)

 

# Meta caracteres 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 ou um intervalo específico de repetições {8} ou {0,15}

mensagem = 'Nãããããããããããooooooo esquecer de pagar a mensalidade, 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 ali 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))

 

# Meta caracteres 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))

 

# substituindo um elemento de uma string via expressão regular

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.sub(r'jOãO', 'Carlos', texto1, flags = re.I))

 

minha_string = 'Fernando chegará a meia noite.'

print(re.match(r'Fernando', minha_string))

print(re.match(r'noite', minha_string))

 

minha_string2 = 'Fernando chegará, a meia noite.'

print(re.split(r',', minha_string2))

 

Expressões Ternárias

# Parecido com o "comprehension", mas iterando sobre estruturas condicionais e sobre expressões booleanas

num = 2

'Positivo' if num >= 0 else 'Negativo'

 

Map, Filter, Reduce + List Comprehension

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}

]

# Método convencional para extrair dados

precos01 = []

for preco in estoque:

precos01.append(preco['Preco'])

print(f'Preços de estoque (normal) {precos01}')

 

# Extraindo dados via Map + Função Lambda

precos02 = list(map(lambda p: p['Preco'], estoque)) for preco in precos02:

print(preco)

print(f'Preços de estoque (Map + Lambda) {precos02}') #print(next(precos02)) retornaria apenas o primeiro valor, executando novamente apenas o segundo, e assim por diante

 

# Extraindo dados via List Comprehension

precos03 = [preco['Preco'] for preco in estoque]

print(f'Preços de estoque (List Comprehension) {precos03}')

 

# Extraindo dados via Filter

precos04 = list(filter(lambda p: p['Preco'] >= 60, estoque)) #precisa especificar um parâmetro a ser filtrado

print(f'Preços de estoque (Filter) {precos04}')

 

# Combinando Filter e List Comprehension

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}')

# Combinando Map e Filter para extrair um dado

precos06 = list(map(lambda p: p['Preco'],

filter(lambda p: p['Preco'], estoque)))

print(f'Preços de estoque (Map + Filter) {precos06}')

 

# Extraindo dados via Reduce

from functools import reduce

def func_reduce(soma, valores):

return soma + valores['Preco']

precos_total = reduce(func_reduce, estoque, 0)

print(f'Soma dos Preços (Reduce) {precos_total}')

 

# Extraindo dados via Reduce + List Comprehension

from functools import reduce

precos_total = reduce(lambda soma, valores: soma + valores['Preco'], estoque, 0)

print(f'Soma dos Preços (Reduce + List Comprehension) {precos_total}')

 

# Extraindo dados via Reduce (Método Otimizado)

from functools import reduce

precos_total = sum([preco['Preco'] for preco in estoque])

print(f'Soma dos Preços (Reduce Método Otimizado) {precos_total}')

 

Módulos Nativos

#import datetime

from datetime import datetime, date, time

data = datetime(2020, 6, 12, 15, 24, 59)

print(data.date())

print(data.time())

print(data.year)

print(data.month)

print(data.day)

print(data.hour)

print(data.minute)

print(data.second)

 

# uma 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'''

 

# convertendo uma string em datetime

data2 = datetime.strptime('20200101', '%Y%m%d') print(data2)

 

# substituindo um valor de datetime

data3 = datetime(2020, 6, 12, 15, 24, 59)

#data3.year = 2001 retorna um erro porque o datetime inicial é imutavel data3 = data3.replace(year = 2001)

print(data3)

 

# Diferença entre dois datetimes

delta = data3 - data2

print(delta)

 

Tópicos Avançados em POO

# Métodos que até interagem com funções internas, mas retorna dados para o escopo global da classe

class Pessoa:

ano_atual = 2020

def __init__(self, nome, idade):

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(pessoa2.idade)

# Aqueles que não possuem instâncias como atributos, funciona como uma função normal dentro da classe

from random import randint

class Usuario:

@staticmethod

def gerador_id():

gerador = randint(100, 999)

return gerador

print(Usuario.gerador_id())

 

class Usuario:

# Método construtor

def __init__(self, nome, identificador):

self.nome = nome

self.identificador = identificador

@classmethod

def autenticador(cls, identificador):

@staticmethod

def gerador_cod_seguranca():

 

# 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

 

# Permutações

from itertools import permutations

lista10 = ['Ana', 'Bianca', 'Carla', 'Daniela', 'Franciele', 'Maria']

for combinacoes in permutations(lista10, 2): # possíveis combinações 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...

# Product

from itertools import product

lista10 = ['Ana', 'Bianca', 'Carla', 'Daniela', 'Franciele', 'Maria']

for combinacoes in product(lista10, repeat = 2): # possíveis combinações em grupos de 2

print(combinacoes)

# Parecido com Permutations, mas aqui é permitido que um elemento se combine com ele mesmo

 

# 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

usuario1.logar.logar()

 

# 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))

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())

 

# Herança Simples

class Corsa:

def __init__(self, nome, ano):

self.nome = nome

self.ano = ano

class Gol:

def __init__(self, nome, ano):

self.nome = nome

self.ano = ano

class Carro:

def __init__(self, nome, ano):

self.nome = nome

self.ano = ano

class Corsa(Carro):

pass

class Gol(Carro):

pass

 

# Cadeia de Heranças

class Carro:

def __init__(self, nome, ano):

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

 

# Mesmo que

class Jeep:

def carro():

def __init__(self, nome, ano):

self.nome = nome

self.ano = ano

def gasolina(self, tipogasolina=True, tipoalcool=False):

self.tipogasolina = tipogasolina

self.tipoalcool = tipoalcool

jeep = Jeep()

 

# Código otimizado

class Carro:

def __init__(self, nome, ano):

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)

 

# Herança Múltipla

class Mercadoria:

def __init__(self, nome, preco):

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

 

# Sobreposição de Membros

class Pessoa:

def __init__(self, nome):

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')

print(p1.nome)

p1.Acao1()

p1.Acao2()

 

class Pessoa:

def __init__(self, nome):

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):

def Acao1(self):

super().Acao1()

print(f'{self.nome} está acordado')

p1 = SaveJogador1('Fernando')

p1.Acao1()

p1.Acao2()

 

class SaveJogador1(Jogador1):

def Acao1(self):

super().Acao1()

print(f'{self.nome} está acordado')

 

class Pessoa:

def acao(self):

print('Inicializando o sistema')

class Acao1(Pessoa):

def acao(self):

print('Sistema pronto para uso')

class Acao2(Pessoa):

def acao(self):

print('Desligando o sistema')

class SaveJogador1(Acao2, Acao1):

pass

p1 = SaveJogador1()

p1.acao()

 

# 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()

 

# Polimorfismo

from abc import ABC, abstractclassmethod

class Pessoa(ABC):

@abstractclassmethod

def logar(self, chaveseguranca):

pass

class Usuario(Pessoa):

def logar(self, chaveseguranca):

print('Usuario logado no sistema')

class Bot(Pessoa):

def logar(self, chaveseguranca):

print('Sistema rodando em segundo plano')

user1 = Usuario()

user1.logar('I5m8b4y9')

 

# Sobrecarga de Operadores

class Caixa:

def __init__(self, largura, altura):

self.largura = largura

self.altura = altura

caixa1 = Caixa(10,10)

caixa2 = Caixa(10,20)

print(caixa1 + caixa2)

 

class Caixa:

def __init__(self, largura, altura):

self.largura = largura

self.altura = altura

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})'>"

caixa1 = Caixa(10,10)

caixa2 = Caixa(10,20)

caixa3 = caixa1 + caixa2

print(caixa3)

 

# 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 elemento que não consta no índice 0, será gerado um erro

 

PYTHON + NUMPY

 

Instalação das dependências

pip install numpy

 

Importando a biblioteca numpy

import numpy as np

 

Criando uma array numpy

data = np.array([2, 4, 6, 8, 10])

print(data)

print(type(data))

print(data.shape)

 

Criando automaticamente uma array numpy com dados ordenados.

data = np.arange(15)

print(data)

 

Criando automaticamente uma array numpy com dados aleatórios (float entre 0 e 1) data = np.random.rand(15)

print(data)

 

Criando uma array numpy com dados aleatórios (int entre 0 e o valor especificado). data = np.random.randint(10, size = 10)

# números de 0 a 10, size define quantos elementos serão gerados

print(data)

 

Criando uma array numpy com dados aleatórios (float entre 0 e 1) data = np.random.random((2, 2))

print(data)

 

Criando uma array numpy composta de zeros

data = np.zeros((3, 4))

# 3 linhas e 4 colunas

print(data)

 

Criando uma array numpy composta de números um

data = np.ones((3, 4))

# 3 linhas e 4 colunas

print(data)

 

Criando uma array numpy com valores vazios.

data = np.empty((3, 4))

# haverá um valor, representado em notação científica, algo muito próximo ao zero absoluto.

print(data)

 

Criando uma array numpy de números negativos.

data = np.arange(10) * -1

print(data)

 

Criando uma array numpy unidimensional

data = np.random.randint(5, size = 10)

# números de 0 a 5, size define quantos elementos serão gerados

print(data)

print(data.shape)

 

Criando uma array numpy bidimensional data2 = np.random.randint(5, size = (3, 4))

# números de 0 a 5, distribuidos em 3 linhas e 4 colunas

print(data2)

print(data2.shape)

 

Criando uma array numpy tridimensional

data3 = np.random.randint(5, size = (5, 3, 4))

# números de 0 a 5, 5 camadas cada uma com 3 linhas e 4 colunas

print(data3)

print(data3.shape)

 

Convertendo uma array multidimensional para unidimensional

data4 = np.array([(1,2,3,4),(3,1,4,2)])

print(data4)

data4_flat = data4.flatten()

print(data4_flat)

 

Criando uma array numpy a partir de elementos de uma lista

data4 = np.array([[1, 2, 3, 4], [1, 3, 5, 7]])

print(data4)

 

Verificando o tipo de dado de uma array

print(type(data3))

print(data3.dtype)

 

Verificando o tamanho de uma array

data3 = np.random.randint(5, size = (5, 3, 4))

print(data3.ndim)

# número de dimensões

print(data3.shape)

# formato de cada dimensão

print(data3.size)

# tamanho total da matriz

 

Verificando o tamanho em bytes de cada item e de toda uma array print(f'Cada elemento possui {data3.itemsize} bytes')

print(f'Toda a matriz possui {data3.nbytes} bytes')

 

Consultando o elemento de maior valor em uma array

data = np.arange(15)

print(data)

print(data.max())

 

Consultando um elemento através de seu índice (unidimensional)

data = np.arange(15)

print(data)

print(data[8])

 

data

print(data)

print(data[-5])

# 5º elemento a contar do fim para o começo

 

Consultando um elemento através de seu índice (multidimensional)

data2 = np.random.randint(5, size = (3, 4))

print(data2)

print(data2[0, 2])

# linha 0, coluna 2 (lembrando que o índice para coluna também começa em 0, 0-1-2-3)

 

Consultando um intervalo de elementos em uma array

data

print(data)

print(data[:5])

# apenas os 5 primeiros

print(data[3:])

# do terceiro elemento em diante (elemento, e não índice)

print(data[4:8])

# do quarto elemento até o oitavo (4º, 5º, 6º 7º e 8º elemento)

print(data[::2])

# de dois em dois elementos

print(data[3::])

# pula os 3 primeiros elementos e imprime o resto

 

Modificando dados/valores manualmente por meio de seu índice

data2

print(data2)

data2[0, 0] = 10

# elemento situado na posição 0x0 do índice passará a ter o valor atribuído 10

print(data2)

 

Inserindo elementos diferentes de int

data2

data2[1, 1] = 6.82945

# mesmo declarado como float será convertido em int

print(data2)

 

Definindo manualmente o tipo de dados de uma array

data2 = np.array([8,-3, 5, 9], dtype = 'float')

# todos elementos serão convertidos para float

print(data2)

print(type(data2[0]))

 

Criando uma array numpy de intervalos igualmente distribuídos

data = np.linspace(0, 1, 7)

# 7 números, gerados de 0 a 1, com intervalo igual entre cada número gerado

print(data)

Criando uma array numpy com formato definido manualmente data5 = np.arange(8)

print(data5)

data5 = data5.reshape(2, 4)

# a multiplicação dessas dimensões deve ser o número de elementos. ex 2 x 4 = 8

print(data5)

 

Criando uma array numpy com tamanho predefinido em variável tamanho = 10

data6 = np.random.permutation(tamanho)

# matriz de 10 elementos conforme variável tamanho define

print(data6)

 

Operadores lógicos em arrays numpy (todos elementos)

data7 = np.arange(10)

print(data7)

print(data7 > 3)

# irá verificar cada elemento da matriz, retornando true para os que forem maior que 3 e false para os que forem menor.

 

Operadores lógicos em arrays numpy (elemento específico)

data7 = np.arange(10)

print(data7)

print(data7[4] > 5)

# o elemento e é maior que 5?

 

Operadores aritméticos em arrays numpy

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

print(data8)

 

data8 = np.array(data8)

# após convertido para array o operador + sempre fará a soma

print(data8 + 10)

 

Criando uma matriz diagonal

data9 = np.diag((1, 2, 3, 4, 5, 6, 7, 8))

# os elementos serão distribuídos em uma coluna diagonal

print(data9)

 

Criando padrões duplicados

data10 = np.tile(np.array([[9, 4], [3, 7]]), 4)

# 9, 4, elementos da primeira linha, 3, 7 da segunda, duplicados 4 vezes na mesma linha

print(data10)

 

data10 = np.tile(np.array([[9, 4], [3, 7]]), (2,2)) # mesmo exemplo que o anterior, mas duplicados linha e coluna

print(data10)

 

Somando um valor a cada elemento de uma array

data11 = np.arange(0, 15)

print(data11)

data11 = np.arange(0, 15) + 1

# irá somar 1 a cada elemento

print(data11)

 

data11 = np.arange(0, 30,3) + 3

# somando 3 ao valor de cada elemento, de 3 em 3 elementos

print(data11)

 

Realizando a soma de arrays

d1 = np.array([ 3, 6, 9, 12, 15])

d2 = np.array([ 1, 2, 3, 4, 5])

d3 = d1 + d2

print(d3)

 

Realizando a subtração de arrays

d1 = np.array([ 3, 6, 9, 12, 15])

d2 = np.array([ 1, 2, 3, 4, 5])

d3 = d1 - d2

print(d3)

 

Realizando a divisão de arrays

d1 = np.array([ 3, 6, 9, 12, 15])

d2 = np.array([ 1, 2, 3, 4, 5])

d3 = d1 / d2

print(d3)

 

Realizando a multiplicação de arrays

d1 = np.array([ 3, 6, 9, 12, 15, 18, 21, 24, 27, 30]) d2 = np.array([ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10])

d3 = d1 * d2

print(d3)

 

Operações lógicas entre arrays

d1 = np.array([ 3, 6, 9, 12, 15, 18, 21])

d2 = np.array([ 1, 2, 3, 4, 5, 20, 25])

d3 = d2 > d1

# os elementos de d2 são maiores do que os de d1?

print(d3)

 

Transposição de arrays

arr1 = np.array([[1, 2, 3], [4, 5, 6]])

print(arr1)

print(arr1.shape)

arr1_transposta = arr1.transpose()

# realizará a conversão de linhas para colunas e vice-versa

print(arr1_transposta)

print(arr1_transposta.shape)

 

Salvando uma array no disco local

data = np.array([ 3, 6, 9, 12, 15])

np.save('minha_array', data)

# irá gerar um arquivo com extensão .npy

 

Carregando uma array do disco local

np.load('minha_array.npy')