Códigos em python

1
Escreve todos os numero pares ate o numero que foi escolhido em num1

num1 = int(input("Digite um numero: "))

i = 1

while i <= num1:

if i % 2 == 0:
print(i)

i += 1

2
código em for

for i in range(0 , 6):

for j in range(0 , 5):
print(f"i = {i} , j = {j}")

resposta:

i=0,j=0 i=1,j=0 i=2,j=0 i=3,j=0 i=4,j=0 i=5,j=0

i=0,j=1 i=1,j=1 i=2,j=1 i=3,j=1 i=4,j=1 i=5,j=1

i=0,j=2 i=1,j=2 i=2,j=2 i=3,j=2 i=4,j=2 i=5,j=2

i=0,j=3 i=1,j=3 i=2,j=3 i=3,j=3 i=4,j=3 i=5,j=3

i=0,j=4 i=1,j=4 i=2,j=4 i=3,j=4 i=4,j=4 i=5,j=4

3
calculadora usando for

n = int(input("Digite um numero"))

for i in range(0 , 11):

print(f"{n} X {i} == {i * n}")
4
calculadora de todos os numero usando for

for i in range(0 , 11):

for j in range(1 , 11):
print(f"{i} X {j} == {i * j}")

lista = [1 , 3 , 'caio' , 4 ,5 ,6,7,8 ]

x = list(enumerate(lista))
print(x)

[(0, 1), (1, 3), (2, 'caio'), (3, 4), (4, 5), (5, 6), (6, 7), (7, 8)]

Escreve os números pares da lista

numero = [ 2 ,6 ,8 ,5 ,1 ,9 ,7 ,6 ,33 ,54, 45]

numero_pares = []
for i in numero:
if i % 2 == 0:
numero_pares.append(i)
print(numero_pares)

[2, 6, 8, 6, 54]

Estrutura de uma matris em python

List = [[0, 1, 2, 3, 4]

[5, 6, 7, 8, 9]

[10, 11, 12, 13, 14]]

idade = [[0, 1, 2, 3, 4],
[5, 6, 7, 8, 9],
[10, 11, 12, 13, 14]]

print(idade [1] [2])

mostra o valor 7

print(idade [seleciona o n° da lista dentro da lista] [seleciona o numero dentro da lista

escolhida])

idade = [[0, 1],

[5, 6],
[10, 11]]

for i in range(0, len(idade)):

for j in range(0, len(idade[i])):
print(idade[i] [j])

10

11

x = [int(input()) for i in range(0 , 10)]

# print(sum(x))

soma = 0
for i in x:
soma = soma + i

print(soma)

pede para escrever 10 numero e no final soma tudo.

O código que esta com comentário faz a mesma coisa

CODIGO sum(X) soma os n° da lista
X = lista

x = [i for i in range(0, 10)]

print(x)

y = []
for i in range(0,10):
[Link](i)

print(y)

resultado do código:

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

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

os dois códigos(X e Y ) fazem a mesma coisa, so muda que um de escrito de forma funcional e
o outro não

x = [input("digite um nome: ") for i in range(0,3)]

print(x)

pede para digitar o nome 3 vezes e adiciona na lista

resultado:

digite um nome: julio

digite um nome: duda

digite um nome: ana

['julio', 'duda', 'ana']

x = [[input("Digite um nome: ") for j in range(0,3 )] for i in
range(0,3)]

print(x)

lendo o código:

vai pedir para digitar um nome três vezes para cada uma das listas que forem criadas, que no
caso são 3. Formando uma matriz, “uma lista dentro de outra lista”

Resultado:

Digite um nome: julio

Digite um nome: danilo

Digite um nome: ana

Digite um nome: daniel

Digite um nome: carla

Digite um nome: thaty

Digite um nome: marcelo

Digite um nome: pai

Digite um nome: duda

[['julio', 'danilo', 'ana'], ['daniel', 'carla', 'thaty'], ['marcelo', 'pai', 'duda']]

x = [i for i in range(0 , 20) if i % 2 == 0 ]

print(x)

y = []
for j in range(0,20):
if j % 2 == 0:
[Link](j)

print(y)

mesmo código estruturas diferentes de escrever

Resultado:

[0, 2, 4, 6, 8, 10, 12, 14, 16, 18]

[0, 2, 4, 6, 8, 10, 12, 14, 16, 18]

x = 2
y = x

print(id(x))
print(id(y))

esse código print(id(x)) mostra o endereço em que vai estar a variável!

Lembrar da explicação de que as variáveis são guardadas como se focem em armários e o

código ID fala o nome do armário

Resultado:

1870258045200

1870258045200

x = 2
y = x
print(hex(id(x)))
print(hex(id(y)))

O código hex transforma o endereço para hexadecimal

Resultado:

0x150939c0110

0x150939c0110

x = [ 1, 2, 3, 4]
y = x
y[0] = 5
print(x)
print(y)

com esse código as duas variáveis estaram usando a mesma gaveta no guarda roupa das
variáveis, então se eu mudo a posição 0 na variável y logicamente a posição 0 na variável x
também vai mudar

Resultado:

[5, 2, 3, 4]

[5, 2, 3, 4]
x = [ 1, 2, 3, 4]
y = [Link]()
y[0] = 5
print(x)
print(y)

agora se eu coloco o [Link]() as duas variáveis não estarão na mesma gaveta do guarda roupa
das variáveis, mas as duas serão copias. Mas se eu alterar uma que nem eu alterei a variável y
só a y vai mudar.

Resultado:

[1, 2, 3, 4]

[5, 2, 3, 4]

Organização de uma lista de forma dicionário

pessoa = {'nome' : 'Julio' , 'idade' : 18, 'cep' : 74520010 , 'cpf'

: 29015755 }
print(pessoa['nome'])

a diferença da lista para esse dicionario é que ao em vez do nome da posição de 0 ou 1 ou 2 ou

3 eu que escrevo nome da posição por exemplo. Pessoa ={‘nome’ : ‘julio’}

do lado esquedo dos dois pontos é o nome da posição, que no caso é (nome). E do lado direito
dos dois pontos esta oque esta ocupando a posição (nome), que no caso é (julio).

Resultado:

Julio

Caso que queira mudar o nome que esta em alguma posição eu uso esse código:

pessoa = {'nome' : 'Julio' , 'idade' : 18, 'cep' : 74520010 , 'cpf'

: 29015755 }
pessoa['nome'] = 'daniel'
print(pessoa['nome'])

resultado:

Daniel
Código cadastro de clientes ep 46

clientes = []
while True:
selecao_cadastro = int(input("Digite o numero da opção
selecionada\n 1) Cadastrar cliente \n 2)Sair"))

if selecao_cadastro == 1:
nome = input("Digite o nome do cliente: ")
idade = int(input("Digite a idade do cliente: "))
altura = int(input("Digite a altura do cliente"))
cliente = {'nome' : nome , 'idade' : idade, 'altura' :
altura}
[Link](cliente)

elif selecao_cadastro == 2:
break

else:
print("Valor invalido! \nTente novamente.")

print(clientes)

para adicionar alguma coisa na lista pode usar um desses dois códigos:

forma pratica

pessoa = {'nome' : 'julio', 'idade' : 17, 'peso' : 49}

pessoa['cpf'] = 41070290127

print(pessoa)

forma usando comandos:

pessoa = {'nome' : 'julio', 'idade' : 17, 'peso' : 49}

[Link]({'cpf' : 41072090127})

print(pessoa)
 CONJUNTOS
.union() união dos conjuntos

.intersection() mostra a intersecção

[Link](z) retira os valores de x que estão presentes em z

x.symmetric_difference(z) ele une os conjuntos X e Z mas não escreve os valores repetidos nos
dois conjuntos

x = {1, 2, 3, 4, 5}
y = {6, 7, 8, 9, 10}
z = {2, 4, 5, 9}
u = [Link](y) #une os valores dos dois conjuntos X e Y
v = [Link](z) #mostra os valores que estao presentes no
conjunto X e Z
s = [Link](z) #retira os valores qe X que estao presentes em
Z (retira os valores 2, 4 e 5) e escreve o resto
d =x.symmetric_difference(z) #ele une os conjuntos X e Z mas não
escreve os valores que estao presentes nos dois conjuntos

print(u)
print(v)
print(s)
print(d)

Resultado:

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

{2, 4, 5}

{1, 3}

{1, 3, 9}

Função

def conversa(): #define e cria a função conversa

print("Seja bem vindo!")
print("Qual seu nome?")

conversa() #puxa a função

calculadora usando função

num1 = int(input("Digite um numero!: "))

num2 = int(input("Digite mais um numero!: "))

def soma():
print(f"a soma de {num1} + {num2} = {num1 + num2}")

soma()

adicionando valores usando args

o args faz com que eu possa adicionar a quantidade de números que eu quiser sem precisar
criar uma variável para cada numero

def soma(*args):
som = 0
for i in args:
som = som + i
print(som)

soma(1, 5, 9, 8)

modularização
Dentro de umas pasta de modularização é possível importar uma variável de outra pasta
usando esse código.

Com esse código eu importo apenas a variável x da pasta minha_lib

from minha_lib import x

print(x)

com esse código eu importo todas as variáveis da pasta minha_lib

from minha_lib import *

print(x)
print(y)
quando eu escrevo from minha_lib import x as x_importa essa parte que esta sublinhada de
vermelho esta indicando que a variável que era nomeada como X na outra pasta, agora vai ter
o nome de X_importada. Utilizado em pastas em que já existem a variável X ai é preciso criar
outro nome.

from minha_lib import x as x_importa

x = 55
print(x)
print(x_importa)

quando eu printar o X vai aparecer o valor 55, e quando eu printar o X_importada vai aparer o
valor atribuído a variável X da outra pasta.

Com esse código eu evito aparecer aquela mensagem de erro caso o computador não consiga
efetuar oque eu mando. Por que quando eu uso o código TRY eu peço para o computador
fazer alguma coisa, e se ele não conseguir ele faz oque o EXCEPT pediu para ele fazer. E
independente se ele executou o TRY ou o EXCEPT ele sempre vai executar o FINALLY após
executar um desses dois códigos.

n1 = int(input("Digite um numero: "))

n2 = float(input("Digite outro numero: "))
try:
print(n1 / n2)
except:
print("nao consegui!")
finally:
print("Codigo finalizado!")

com esse código eu pedi para ele fazer essa divisão, ai se ele não conseguisse ele iria escrever
outra coisa dependendo do tipo de erro que der. Se o erro for ValueError (O valor digitado
não foi numerico) o computador vai printar a frase digite um numero inteiro. E se o
erro for ZeroDivisionError (o valor digitado foi zero e não é possível dividir por zero) vai
ser printado a frase Não digite zero.

try:
num = int(input("DIgite um numero: "))
print(5 / num)
except ValueError:
print("digite um numero inteiro!")
except ZeroDivisionError:
print("Nao digite zero!")
o código raise puxa uma invalidação para o código. Um exemplo de invalidação:

def soma (n1,n2):

if n1 < 0 or n2 < 0:
raise ValueError("Os valores de n1 e n2 devem ser
positivos")
return n1 + n2
print(soma(2, -5))

quando compilar vai aparecer isso:

Traceback (most recent call last):

File "C:\Users\Julio SANTOS\Desktop\sprit\[Link]", line 5, in <module>

print(soma(2, -5))

File "C:\Users\Julio SANTOS\Desktop\sprit\[Link]", line 3, in soma

raise ValueError("Os valores de n1 e n2 devem ser positivos")

ValueError: Os valores de n1 e n2 devem ser positivos

Mas se o n1 e n2 forem positivos o código vai apenas somar os valores

Já o código assert tenta fazer com que essa verdadeiro e coloca uma opção para caso não
seja verdadeiro.

x = 0
assert x > 0, "o x deve ser maior que zero"
print(x)
quando o código compilar vai aparecer isso:

raceback (most recent call last):

File "C:\Users\Julio SANTOS\Desktop\sprit\[Link]", line 7, in <module>

assert x > 0, "o x deve ser maior que zero"

AssertionError: o x deve ser maior que zero

A estrutura do código assert é: o que esta em vermelho é a exigência e oque esta em azul é
oque vai aparecer caso a exigência não seja comprida:

assert x > 0, "o x deve ser maior que zero"

Essa importação mostra quantos bits o numero 1 gasta no programa. Lembrando que pode
colocar outras coisas além do numero 1, qualquer coisa que estiver entre os parênteses ele vai
mostrar o espaço que ele ocupa

from [Link] import asizesof

print(asizesof(1))

com esse código ele vi ver quantos bits a função que monta uma lista gasta e vai printar a
quantidade de bits gastos

from [Link] import asizesof

def dobro(lista):
lista_dobro = []
for i in lista:
lista_dobro.append(i * 2)
return lista_dobro
x = asizesof(dobro(range(0 , 120)))
print(x)

nas funções geradoras não se usa o return e sim o yield. exemplo de função geradora:

def dobro(lista):
for i in lista:
yield i*2
x = dobro(range(0, 100000))
print(asizesof(x))

As funções geradoras gastam bem menos memorias que uma função comum.

Exemplo de código mostrando que as funções geradoras gastam menos que as comuns:

def dobro(lista):
for i in lista:
yield i*2
def dobro2(lista):
lista_2 = []
for i in lista:
lista_2.append(i)
return lista_2
x = dobro(range(0, 100000))
y = dobro2(range(0, 100000))
print(asizesof(x))
print(asizesof(y))
pode-se perceber que a função de cima é a função geradora pela utilização do yield

esse código filtra a lista x e escreve os valores filtrados

x = [10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24,
25, 26, 27]
x = list(filter(lambda x: x < 18, x))
print(x)

quando compila aparece isso:

[10, 11, 12, 13, 14, 15, 16, 17]

Esse código filtra um dicionário dentro da lista e escreve os que foram filtrados.

y = [{'nome' : 'julio', 'idade' : 20 , 'cpf' : 41702}, {'nome' :

'ana' , 'idade' : 16 , 'cpf' : 515253}, {'nome' : 'danilo', 'idade'
: 31 , 'cpf' : 66402}, {'nome' : 'rafael', 'idade' : 25 , 'cpf' :
488802}]
y = list(filter(lambda y: y['idade'] > 19, y))
print(y)
quando compila aparece isso:

[{'nome': 'julio', 'idade': 20, 'cpf': 41702}, {'nome': 'danilo', 'idade': 31, 'cpf': 66402}, {'nome':
'rafael', 'idade': 25, 'cpf': 488802}]

Esse código olha se a idade é menor que 27 e se a idade for menor que 27 ele muda oque esta
escrito no lugar da idade para “ idade menor que 27”

x = [{'nome' : 'julio', 'idade' : 25}, {'nome' : 'ana' , 'idade' :

28}]
x = list(map(lambda x: {'nome' : x['nome'], 'idade' : 'idade menor
que 27'} if x['idade'] < 27 else (x), x))
print(x)

quando compila aparece isso:

[{'nome': 'julio', 'idade': 'idade menor que 27'}, {'nome': 'ana', 'idade': 28}]

Vídeo 63

Armazenamento persistente de dados

Função do pythom que abre um arquivo é o

Open()
arquivo = open('[Link]', 'w' ) #'w' é para escrever dentro de
um arquivo, 'a' é para adicionar elementos dentro de um aquivo 'r'
é para ler elementos dentro de um arquivo

quando eu executo esse programa ele cria uma pasta com o nome [Link] e escreve a
palavra ‘ola’.

arquivo = open('[Link]', 'w' )

[Link]("olá")
se eu apagar o OLA e escrever outra coisa no lugar e rodar o código, la no arquivo [Link]
não vai aparecer mais o ‘ola’ e so vai aparecer a outra coisa nova que eu escrever.

Se eu trocar o ‘w’ por ‘a’ quando eu executar:

arquivo = open('[Link]', 'a' )

[Link]('ola \n')
e depois executar:

arquivo = open('[Link]', 'a' )

[Link]('Tudo bem?')
vai aparecer no arquivo [Link]:

ola

Tudo bem?

arquivo = open('[Link]', 'a' )

i = 0
while True:
if i > 1:
break
[Link](input("Digite um nome: ") + ” “ + input(" Digite
a idade") + "\n")
i += 1

esse código adiciona o nome e a idade de duas pessoas.

O if serve para finalizar o código quando eu já tiver informado o nome e a idade das duas
pessoas, por que se eu finalizar o código so apertando para ele finalizar de forma brusca o
codigo vai entender que ele não foi concluído e não vai mandar os nomes para o arquivo
pessoas. Txt
arquivo = open('[Link]', 'r' )
resultados = [Link]()
x = []
for i in resultados:
[Link]([Link]())
print(x)
[Link]()

esse código serve para ler as coisas que foram escritas no arquivo [Link]

o código .readlines le cada linha do meu arquivo e escreve como se fosse uma posição
de uma lista.

O código [Link]() serve para assim que eu terminar de fazer oque eu estiver fazendo no
arquivo ele ser fechado, para não deixar brechas no sistemas nem criar bugs.

quando eu compilar esse código vai aparecer em forma de lista pois eu estou adicionando os
nomes e as idades a lista X:

[['julio20'], ['danilo15'], ['julio', '20'], ['caro', '22'], ['matias', '29'], ['caio', '16']]

Ao invés de eu ter que ficar escrevendo [Link]() toda vez ou correr o risco de deixar o
arquivo aberto eu posso reescrever o começo da abertura do arquivo de forma que quando eu
sair da tabulação do White o arquivo seja fechado instantaneamente.

with open('[Link]', 'r') as arq:

resultados = [Link]()
x = []
for i in resultados:
[Link]([Link]())
print(x)

dessa forma quando o código acabar de executar o print(x) e voltar para tabulação normal o
arquivo (arq) sera fechado.
 Aula 1 programação orientada a objetos
class Pessoas:
def __init__(self, nome, idade, cpf):
[Link] = nome
[Link] = idade
[Link] = cpf

def logar_sistema(self):
print(f"{[Link]} esta logando no sistema!")

p1 = Pessoas('julio', 18, '41702901277')

p2 = Pessoas('danilo', 39, '95785184657')
print([Link])
p2.logar_sistema()
nesse código eu criei a classe Pessoas e coloquei para ela atribuir o nome o cpf e a idade das
pessoas

class Pessoas():
def __init__ (self):
print("ola")
def logar_sistema(self):
print("Estou logando no sistema")
p1 = Pessoas()

Nesse código o “OLA” sempre sera executado, uma vez que a variável p1 esta criando uma
nova instancia com o nome Pessoa().

Sempre que eu criar o método __init__ quando eu criar uma nova instancia o método __init__
sera [Link] caso quando criou a instancia p1 e o método __init__ foi executado
fazendo printar a palavra “OLA”

class Pessoas():
def __init__ (self, nome, idade, cpf):
print(f" {nome} | {idade} | {cpf}")
def logar_sistema(self):
print("Estou logando no sistema")
p1 = Pessoas('julio', 18, '14213651')

Nesse outro caso o __init__ vai printar o nome, a idade e o cpf

julio | 18 | 14213651

class Pessoas():
possui_olho = True
possui_boca = True
possui_nariz = True
def __init__ (self, nome, idade, cpf):
[Link] = nome
[Link] = idade
[Link] = cpf
# print(f" {[Link]} | {[Link]} | {[Link]}")
def logar_sistema(self):
print("Estou logando no sistema")
p1 = Pessoas("julio" , 18, 20252343102)
print(p1.possui_boca)
as variáveis (“Possui_”) é um atributo da classe, então independente de que seja a pessoa da
instancia esses atributos sempre continuaram a serem os mesmos ate serem modificados

metodos de classes

o método de classe pode ser chamado sem precisar de uma instancia, utilizando apenas a
classe

oque caracteriza um método de classe é o @ que fica antes do método. O @ é @classmethod

e ao invez de usar o SELF usa-se o CLS. Um exemplo de método de classe é o método andar:

lass Pessoas:
def __init__(self, nome, idade, cpf ):
[Link] = nome
[Link] = idade
[Link] = cpf
print(f"{nome} | {idade} | {cpf}")
def logando_sistema(self):
print(f"{[Link]} esta logando no sistema")

@classmethod
def andar(cls, velocidade):
print(f"Estou andando a {velocidade} m/s")
[Link](10)
O único que é um método de classse é o andar, que esta em baixo do @

O CLS é um parâmetro que recebe o estado da classe.

class Pessoas:
 possui_boca = True
@classmethod
def andar(cls, ):
cls.possui_boca = False
print(Pessoas.possui_boca)
[Link]()
print(Pessoas.possui_boca)
o parâmetro cls faz com que eu consiga criar um método como se eu estivesse criando um
método direto de classe, no exemplo possui_boca eu printei uma vez e na primeira vez saiu
True só que já no segundo print saiu False, uma vez que eu criei uma cls dentro do método de
classe andar para mudar o possui_boca para False.

Método estático
É um método que pode ser chamado sem precisar de uma instancia usando apenas a classe.
Ele é bem parecido com o método de classe, porem diferente do método de classe o método
estático não consegue acessar nem alterar nenhum atributo de classe.

E diferente do Metodo de classe o método estático não precisa colocar nem self e nem cls,
mas deve adicionar o @staticmethod para afirmar que é um método estatico

Exemplo:

@staticmethod
def is_adulto(idade):
if(idade > 18):
return True
return False

print(Pessoas.is_adulto(11))

Herança
Na herança utiliza a gíria classe pai para a classe que é herdada (classe pai = Pessoa) e classe
filha para quem herda da classe pai ( classe filha = Cliente)

class Pessoa:
def andar(self):
print("Estou andando")
def falar(self):
print("estou falando ")
class Cliente(Pessoa):
pass
c1 = Cliente()
[Link]()
nesse código todos os clientes erdam (recebem como herança) a classe Pessoa, fazendo com
que todas as instancias que tiver na classe Pessoa possa ser utilizado na classe Cliente.

Outro exemplo utilizando herança:

Nesse caso eu criei uma classe vendedor, adicionei a herança da classe cliente e pedi para o
v1(vendedor1) mostrar a instancia que estava na classe cliente que é a andar e a que estava na
classe vendedor que é a vender.

class Pessoa:
def andar(self):
print("Estou andando")
def falar(self):
print("estou falando ")
class Cliente(Pessoa):
def comprar(self):
print("Estou comprando")
class Vendedor(Pessoa):
def vender(self):
print("Estou vendendo")
v1 = Vendedor()
[Link]()
[Link]()

sobreposição de métodos
para que tenha uma sobreposição de métodos é necessário que exista uma herança.

class Pessoa:
def andar(self):
print("Estou andando")
def falar(self):
print("estou falando ")
class Cliente(Pessoa):
def comprar(self):
print("Estou comprando")
class Vendedor(Pessoa):
def vender(self):
print("Estou vendendo")
def andar(self):
print("estou correndo")
v1 = Vendedor()
[Link]()
[Link]()
Nesse código eu criei duas funções chamadas andar e executei o código. A função que foi
chamada foi a que dizia estou correndo, pois ela foi a ultima a ser criada, e a ordem de
checagem é sempre de cima para baixo. Por isso quando eu rodo esse código sempre vai
aparecer apenas estou correndo.

class Pessoa:
def andar(self):
print("Estou andando")
def falar(self):
print("estou falando ")
class Cliente(Pessoa):
def comprar(self):
print("Estou comprando")
class Vendedor(Pessoa):
def vender(self):
print("Estou vendendo")
def andar(self):
super().andar()
print("estou correndo")
v1 = Vendedor()
[Link]()
Já nesse outro código, quando eu rodar vai aparecer estou andando e depois estou correndo.
Uma vez que o código super() faz com que o computador procure na classe pai se tem alguma
função que também se chama andar, e se tiver ele executa primeiro ela depois a que esta
escrita depois do super().

Nesse outro exemplo de código eu usei o super() para puxar a função __init__ da classe Pessoa

class Pessoa():
def __init__(self, nome, cpf):
[Link] = nome
[Link] = cpf
class Cliente(Pessoa):
def __init__(self, id_cliente, nome, cpf):
super().__init__(nome, cpf)
self.id_cliente = id_cliente
class Vendedor(Pessoa):
def __init__ (self, id_vendedor, nome, cpf):
super().__init__(nome, cpf)
self.id_vendedor = id_vendedor
c1 = Cliente(3, 'julio' , 54545)
print("Dados do cliente:")
print("id_cliente : ",c1.id_cliente)
print("Nome: ", [Link])
print("cpf: ",[Link])

print("------------------------")
v1 = Vendedor( 1 , 'danilo', 89963 )
print("Dados do vendedor")
print("id_Vendedor : ",v1.id_vendedor)
print("Nome: ", [Link])
print("cpf: ",[Link])

herança múltipla
class Animal:
def andar(self):
print("Estou andando")
def Pular(self):
print("Estou pulando")
def Correr(self):
print("Estou correndo")
class Felino(Animal):
def felino(self):
print("eu sou um felino")
class Gato(Felino):
def miar(self):
print("Eu estou miando")
class Tigre(Felino, Animal):
def rugir(self):
print("eu estou rugindo")
y = Gato()
[Link]()

utilizando a herança múltipla eu posso conectar diferentes classes sem conectar todas. Um
gato também é um felino, então as coisas que um felino faz um gato também faz mas nem
todas as coisas que um felino faz um animal qualquer também faz, por isso deve dividir em
duas classes os animais e os felinos, assim quando eu quero criar a classe gato eu posso usar a
herança múltipla que nem eu usei agora, o felino pega as coisas que a classe animal pode fazer
e a classe gato pega as coisas que a classe felino pode fazer. Assim a classe gato ta pegando
tanto a classe felino quanto a classe animal.
 Padrão MVC
View é a parte do meu projeto responsável pela interface do projeto, view é a parte que o
usuário vai ver.

Model é responsável pelo armazenamento e a estrutura dos dados. Ele que reserva quais são
os tipos e para que serve cada dado

Controller é responsável pela logica mais pesada do código.

Ex: validação de cpf, da view que é a parte que o usuário esta vendo que é pra escrever o cpf,
vai para a controller e a controller vai tratar o cpf e ver se ele é valido, se for valido ela manda
para a model para cadastrar o cpf na model