Relacionados
2023-02-09 - 💭️ Melhorias para o jardim
Modificado em: 11:50 AM - February 11, 2023 | Criado em: 9:56 PM - July 30, 2023
Python - avançando na linguagem
Modificado em: 10:50 AM - February 08, 2023 | Criado em: 9:58 PM - July 30, 2023
Python - começando com a linguagem
Modificado em: 6:36 PM - February 05, 2023 | Criado em: 9:58 PM - July 30, 2023
Python Collections parte 1 - listas e tuplas
Modificado em: 3:59 PM - February 09, 2023 | Criado em: 9:58 PM - July 30, 2023

Caderno de Python

Este caderno não pretende ser uma reprodução da documentação, mas sim anotações que me ajudem a construir, memorizar e melhorar na linguagem.

Provavelmente estará em constante construção.


Ferramentas

pyCharm|50 colaboratory |100

Cursos

logocurso|50 logocurso | 50 icone|50

Até agora, fiz isso usando python

A linguagem

Padrões do Python

Snake_Case em nomes de variáveis
idade_esposa = 32
perfil_vip = 'Fulano'
recibos_em_atraso = 20

Python tem tipagem dinâmica

sempre usar a indentação correta

legibilidade do código

Compilada ou interpretada?

”Python é uma linguagem interpretada, em oposição às compiladas, embora a distinção possa ficar desfocada devido à presença do compilador de bytecode. Python é uma linguagem interpretada, em oposição às compiladas, embora a distinção possa ficar desfocada devido à presença do compilador de bytecode.” Documentação

Operadores de comparação

  • < - menor que
  • > - maior que
  • <= - menor ou igual a
  • >= - maior ou igual a
  • == igual a
  • != - diferente de

Ordem natural

15 < 32
>>> True
numeros (inteiros ou float)
nomes = ["Trator", "Meia", "Bagagem", "tosco"]
sorted(nomes)
>>> ['Bagagem', 'Meia', 'Trator', 'tosco']
Alfabética (maiusculas e minusculas)

Sintaxe

Função print()

Novo código

print()

Documentação da função print

Tipos de dados e funções relacionadas

Novo código

type()<class 'float/int/str/bool'>


pais = "Italia" # Declara variavel
quantidade = 4
quartil = 7.9
acertou = (chute == numero_secreto)


type(pais) # pergunta o tipo da variável
<class 'str'> # tipo string
type(quantidade)
<class 'int'> # tipo inteiro (numero)
type(quartil)
<class 'float'> # tipo decimal (numero)
type(acertou)
<class 'bool'> # tipo binário (true/false)

print(pais, "ganhou", quantidade, "titulos mundiais") # imprimir esse resultado na tela
Italia ganhou 4 titulos mundiais # resultado do codigo anterior
O tipo Bool

 Ele pode ter os valores True (Verdadeiro) e False (Falso).
 Atenção às maiusculas

palavra_secreta = "banana"

enforcou = False # definindo variaveis do tipo bool
acertou = False # ambas Falsas

while(not acertou and not enforcou): # usando condições booleanas na função while
    print("Jogando...")
Nova estrutura de dados

variavel = []
<class 'list'>
Lista é uma sequencia de dados. Documentação

Funções da lista

max(variavel)
Maior valor dentro da lista

min(variavel)
Menor valor dentro da lista

len(variavel)
Quantidade de itens na lista

del(variavel[0])
Deleta o item da posição 0

variavel.count()
Conta quantas ocorrencias de um determinado elemento

variavel.index()
Indice da primeira ocorrencia de um determinado elemento

variavel.append("valor a acrescentar")
Acrescenta um valor à lista

variavel.pop()
Remove o ultimo valor da lista ou string, não funciona em tuplas

>>> valores = [] # declarou variavel tipo lista
>>> type(valores)
<class 'list'> 

>>> valores = [0,1,2,3,4] # populou a lista com valores

>>> valores = [0,1,2,3,4]
>>> min(valores) # menor valor
0
>>> max(valores) # maior valor
4

>>> len(valores) # quantidade de itens na lista
5

>>> valores[2] # valor na posição 2
2

>>> 0 in valores # Existe este valor dentro da lista?
True # sim
>>> 8 in valores
False # nao

>>> valores = [ 0, 0, 0, 1, 2, 3, 4] 
>>> print(valores.count(0)) #numero de ocorrencias do elemento 0
3

>>>frutas = ['Banana', 'Morango', 'Maçã', 'Uva', 'Maçã', 'Uva']
>>>print(frutas.index('Uva')) #primeira ocorrencia do elemento uva
3 # o indice começa em 0

>>>print(frutas.index('Melancia')) #primeira ocorrencia do elemento melancia
ValueError: 'Melancia' is not in list

frutas = ['Banana', 'Morango', 'Maçã', 'Uva']

fruta_buscada = 'Melancia'
if fruta_buscada in frutas:
    print(frutas.index(fruta_buscada))
else:
    print('Desculpe, a {} não está na lista frutas'.format( fruta_buscada))
Nova estrutura de dados | Tupla

variavel = (x, y, z, w)
A tupla é um tipo de sequencia, porém imutável
Várias funções da lista se aplicam nela

Set

variavel = {valor1, valor2, valor3,}
Um set é uma coleção não ordenada de elementos. Cada elemento é único, isso significa que não existem elementos duplicados dentro do set.
Não funciona como sequencia e não tem indice

variavel.add(valor4)
Adiciona elementos ao Set

Nova estrutura de dados | Dictionary

variavel = {chave1 : valor1, chave2 : valor2}
print variavel['chave1']
imprime valor1
Se usa em par, temos no lado esquerdo a chave e no lado direito o valor. Isso é importante pois usamos a chave para recuperar um valor

List comprehension

variavel = [condição for alguma_coisa in algum_lugar]
permite utilizar condições para o preenchimento da lista

Input

Nova função

input("Captura entrada do usuário")

If, else e elif

Nova função

if (condição):
executa código caso a condição seja verdadeira
else:
executa código caso a condição seja falsa
elif(condição)
else com condição de entrada

if (numero_secreto == chute):
    print("Você acertou!")
else:
    if (chute > numero_secreto):
        print("Você errou! O seu chute foi maior que o número secreto.")
    elif (chute < numero_secreto):
        print("Você errou! O seu chute foi menor que o número secreto.")

Int

Nova função

int(muda_tipo_da_variavel)
tipo numero inteiro

Exemplo

print("**********************************")  # Decorativo
print("Bem vindo ao jogo de adivinhação")  
print("**********************************")  
  
numero_secreto = 42  
chute_str = input("Digite seu chute ")  
  
print("Você digitou ", chute_str)  # Mostra ao usuario o input dele
  
chute = int(chute_str)  # Tranforma input em string para inteiro
  
if (numero_secreto == chute):  # Se (compara)
    print("Você acertou!")  
else:  
    print("Você errou :(")  
  
print ("Fim do jogo ...")

While e interpolação de strings

Nova função

while(condição):
codigo a ser executado

Nova função

"{} {}".format(var1, var2)
interpolação de strings
usada para formatação de decimais e inteiros também
documentação

print("**********************************")  
print("Bem vindo ao jogo de adivinhação")  
print("**********************************")  
  
numero_secreto = 42  
tentativas = 3  
rodada = 1  
  
while(rodada <= tentativas):  
    print("Tentativa {} de {}".format(rodada, tentativas))  # interpolação de strings
    chute = int(input("Digite seu chute "))  
    acertou = chute == numero_secreto  
    chute_maior = chute > numero_secreto  
    chute_menor = chute < numero_secreto  
  
    print("Você digitou ", chute)  
  
    if (acertou):  
        print("***********************")  
        print("**** Você acertou! ****")  
        print("***********************")  
    else:  
        if(chute_maior):  
            print("****  Você errou :( ****\nSeu chute foi MAIOR que o numero secreto")  
        elif(chute_menor):  
            print("**** Você errou :( ****\nSeu chute foi MENOR que o numero secreto")  
    rodada = rodada + 1  
  
print("Fim do jogo ...") # unica coisa fora do laço while
O que o if e while tem em comum?

Ambos, if e while, possuem uma condição de entrada. A diferença é que o if executa o bloco apenas uma vez, mas o while repete o bloco enquanto a condição for verdadeira.

For e range

Nova função

for VARIAVEL in [1, 2, 3, 4, 5]:
para variavel nestes valores: faça algo
for VARIAVEL in range(X,Y):
para variavel em série de valores: faça algo
range(X, Y, Z)
pode ser definido um intervalo entre os elementos, um step

for não deve ter parênteses.

o segundo parâmetro da função range não é inclusivo

range(1,3) irá gerar a série 1 e 2 somente.

A função range possui os seguintes parâmetros:

range(start, stop, [step])
Onde o step é opcional. Como queremos "pular" de 3 em 3, começando com 1 (start) até 10 (stop).

Controle de fluxo com break e continue

Novos comandos - Controle de fluxo / Control Flow

break
sai do bloco do laço abruptamente
continue
pula para próxima iteração
Apenas em for ou while

print("**********************************")  
print("Bem vindo ao jogo de adivinhação")  
print("**********************************")  
  
numero_secreto = 42  
tentativas = 3  
  
  
for rodada in range(1, tentativas + 1):  # começo do loop com for
    print("Tentativa {} de {}".format(rodada, tentativas)) 
    chute = int(input("Digite seu chute (1 a 100)"))  
    print("Você digitou ", chute)  
  
    if(chute < 1 or chute > 100):  # teste de numero valido
        print("Digite um numero válido")  
        continue  # conta como se tivesse dado a volta no loop
  
    acertou = chute == numero_secreto  
    chute_maior = chute > numero_secreto  
    chute_menor = chute < numero_secreto  
  
    if (acertou):  
        print("***********************")  
        print("**** Você acertou! ****")  
        print("***********************")  
        break  
    else:  
        if(chute_maior):  
            print("****  Você errou :( ****\nSeu chute foi MAIOR que o numero secreto")  
        elif(chute_menor):  
            print("**** Você errou :( ****\nSeu chute foi MENOR que o numero secreto")  
  
  
print("Fim do jogo ...")

Round

Nova Função

round()
arredonda o valor

Random

Nova Função | Precisa ser importada

import random
no começo do código
random.random()
Gera um numero decimal entre 0 e 1 então precisa ser multiplicado dependendo do propósito
random.randrange(1,101)
gera um numero aleatório nesse range

import random  # importa a biblioteca
  
print("**********************************")  
print("Bem vindo ao jogo de adivinhação")  
print("**********************************")  
  
numero_secreto = random.randrange(1,101)  # gera numero aleatorio no range de 1 a 100
tentativas = 3  
  
  
  
  
for rodada in range(1, tentativas + 1):  
    print("Tentativa {} de {}".format(rodada, tentativas))  
    chute = int(input("Digite seu chute (1 a 100)"))  
    print("Você digitou ", chute)  
  
    if(chute < 1 or chute > 100):  
        print("Digite um numero válido")  
        continue  
  
    acertou = chute == numero_secreto  
    chute_maior = chute > numero_secreto  
    chute_menor = chute < numero_secreto  
  
    if (acertou):  
        print("***********************")  
        print("**** Você acertou! ****")  
        print("***********************")  
        break  
    else:  
        if(chute_maior):  
            print("****  Você errou :( ****\nSeu chute foi MAIOR que o numero secreto")  
        elif(chute_menor):  
            print("**** Você errou :( ****\nSeu chute foi MENOR que o numero secreto")  
  
  
print("Fim do jogo ...")
Tipos de cálculos

>>> 3 / 2
1.5
float division retorna números decimais
>>> 3 // 2
1
integer division retorna números inteiros

import random  # importa função random
  
  
print("**********************************")  
print("Bem vindo ao jogo de adivinhação")  
print("**********************************")  
  
numero_secreto = random.randrange(1,101)  
total_de_tentativas = 0  
pontos = 1000  # variavel pontos
  
print("Escolha um nivel de dificuldade")  # intro nivel
print("(1) Fácil | (2) Médio | (3) Difícil")  # legenda nivel
  
nivel = int(input("Digite o nivel"))  # input do nivel escolhido pelo usuario
  
if (nivel == 1):  # define total de tentativas para:
    total_de_tentativas = 20  # nivel 1 ou fácil
elif(nivel == 2):  # else com condição
    total_de_tentativas = 10  # nivel 2 ou médio
else:  # sem condição
    total_de_tentativas = 5  # 3 ou dificil
  
  
for rodada in range(1, total_de_tentativas + 1):  
    print("Tentativa {} de {}".format(rodada, total_de_tentativas))  
    chute = int(input("Digite seu chute (1 a 100)"))  
    print("Você digitou ", chute)  
  
    if(chute < 1 or chute > 100):  
        print("Digite um numero válido")  
        continue  
  
    acertou = chute == numero_secreto  
    chute_maior = chute > numero_secreto  
    chute_menor = chute < numero_secreto  
  
    if (acertou):  
        print("*********************************************")  
        print("***** Você acertou e fez {} pontos! *****".format(pontos))  # quantos pontos usuário fez ao ganhar
        print("*********************************************")  
        break  
    else:  
        if(chute_maior):  
            print("****  Você errou :( ****\nSeu chute foi MAIOR que o numero secreto")  
        elif(chute_menor):  
            print("**** Você errou :( ****\nSeu chute foi MENOR que o numero secreto")  
            pontos_perdidos = abs(numero_secreto - chute)  
            pontos = pontos - pontos_perdidos  
  
print("Fim do jogo ...")

Definir funções e importar arquivos

Definir funções

def nome_da_funcao():
todo o código identado faz parte da função, pode chamar outra função
nome_da_funcao()
chama a nossa função em qualquer lugar do arquivo

def soma(a, b):
return a + b
A função também pode receber parâmetros e retornar valores

Importar arquivos e chamar funções

import nome_arquivo
importa igual uma biblioteca

nome_arquivo.nome_da_funcao()
Chama a função criada em outro arquivo

def jogar():  # declara a função jogar que contem todo o nosso código, precisa ser chamada para executar
    print("**********************************")  
    print("****Bem vindo ao jogo de forca****")  
    print("**********************************")  
  
  
    print("Fim do jogo ...")
import forca  # chama o arquivo forca
import adivinhacao  # chama o arquivo adivinhacao
  
  
print("**********************************")  
print("*********Escolha seu jogo*********")  
print("**********************************")  
  
print("(1) Forca | (2) Adivinhação")  # legenda de jogos
  
jogo = int(input("qual jogo?"))  # input do usuário
  
if (jogo == 1):  # teste de qual jogo rodar
    print("~~~Jogando Forca~~~")  
    forca.jogar()  # chama a função jogar definida no arquivo forca
elif(jogo == 2):  
    print("~~~Jogando Adivinhação~~~")  
    adivinhacao.jogar() # chama a função jogar dentro do arquivo adivinhacao
# adivinhacao.py

import random

def jogar():
    # código omitido

if (__name__ == "__main__"): # modulo se chama automáticamente
    jogar()

Funções da string

Novas funções da String

nome_da_variavel.find("")
encontra a primeira ocorrência do texto que estamos procurando e devolve o índice.
o índice começa com 0.

nome_da_variavel.find("", 1)
aceita um segundo parâmetro, que define a partir de qual posição gostaríamos de começar

nome_da_variavel.lower()
todas as letras da string em minusculo

nome_da_variavel.upper()
todas as letras da string em maiusculo

nome_da_variavel.casefold()
ignora capitalização na palavra

nome_da_variavel.strip()
remove todos os espaços

findstartswith ou endswith
verificam se há substrings

>>> palavra = "aluracursos"
>>> palavra.find("a",1) #procurando "a" a partir da segunda posição 
4 # resultado

Abrir, escrever e fechar arquivos

Abrir, escrever e fechar arquivos

variavel = open(palavras.txt, "w/r/a")
abre o arquivo
variavel.write("Alguma coisa")
escreve no arquivo
variavel.read()
Retorna o arquivo inteiro em uma unica linha
variavel.readLine()
Lê linha por linha
variavel.close()
fecha o arquivo

Modificadores de acesso

w para write - sobrescreve o arquivo
r para read
a para append - adicionar conteúdo
b para binário
rb para imagens

Terminando o codigo

Legibilidade do código

transformar código em funções com nomes descritivos para maior legibilidade
deixar as funções juntas no fim ou começo do arquivo

import random # importa a função random 
def jogar(): # define a função jogar

    imprime_mensagem_abertura() # chama a função que imprime a tela de inicio
    palavra_secreta = carrega_palavra_secreta() # variavel palavra_secreta chama a função que carrega uma palavra aleatoria 
    letras_acertadas = inicializa_letras_acertadas(palavra_secreta) # chama a função mas a alimenta com um paramentro
    print(letras_acertadas) 

    enforcou = False # comeca sem estar enforcado, nem ter acertado e 0 erros
    acertou = False
    erros = 0

    while(not enforcou and not acertou):
        
        chute = pede_chute() 
        
        if(chute in palavra_secreta):
            marca_chute_correto(chute, letras_acertadas, palavra_secreta) # outra função que dá parametros
        else:
            erros += 1 # incrementa em 1
            desenha_forca(erros)

        enforcou = erros == 7
        print("Você tem {} tentativas até ser enforcado".format(7 - erros))
        acertou = "_" not in letras_acertadas
        print(letras_acertadas)


    if(acertou):
        imprime_ganhador()
    else:
        imprime_perdedor(palavra_secreta)



def imprime_mensagem_abertura():
    print("**********************************")
    print("****Bem vindo ao jogo de forca****")
    print("**********************************")

def carrega_palavra_secreta():
    palavras = [] # cria uma lista para a palavra
    with open("palavras.txt") as arquivo: # abre o arquivo
        for linha in arquivo: # a cada linha do arquivo
            linha = linha.strip() # tira os espaços e os /n
            palavras.append(linha) # adiciona uma palavraa a linha
    numero = random.randrange(0, len(palavras)) # gera um numero aleatorio dentro da quantidade de palavras que estavam no arquivo
    palavra_secreta = palavras[numero].upper() # gera uma e a coloca em caps lock
    return palavra_secreta # retorna a palavra
    
def inicializa_letras_acertadas(palavra_secreta):
    return ["_" for letra in palavra_secreta] # gera "_" a cada letra para o usuario

def pede_chute():
    chute = input("Chute uma letra ").strip().upper() # tira espaços e deixa em caps lock
    return chute

def marca_chute_correto(chute, letras_acertadas, palavra_secreta):
    index = 0 # index define a posição 0
    for letra in palavra_secreta: # a cada letra da palavra
        if (chute == letra): # se usuario acertar
            letras_acertadas[index] = letra # substitui o "_" pela letra
        index += 1 # aumenta o index para que esse loop rode em todas as letras possiveis

def desenha_forca(erros): # imprime um pouquinho a cada erro
    print("  _______     ")
    print(" |/      |    ")

    if(erros == 1):
        print(" |      (_)   ")
        print(" |            ")
        print(" |            ")
        print(" |            ")

    if(erros == 2):
        print(" |      (_)   ")
        print(" |      \     ")
        print(" |            ")
        print(" |            ")

    if(erros == 3):
        print(" |      (_)   ")
        print(" |      \|    ")
        print(" |            ")
        print(" |            ")

    if(erros == 4):
        print(" |      (_)   ")
        print(" |      \|/   ")
        print(" |            ")
        print(" |            ")

    if(erros == 5):
        print(" |      (_)   ")
        print(" |      \|/   ")
        print(" |       |    ")
        print(" |            ")

    if(erros == 6):
        print(" |      (_)   ")
        print(" |      \|/   ")
        print(" |       |    ")
        print(" |      /     ")

    if (erros == 7):
        print(" |      (_)   ")
        print(" |      \|/   ")
        print(" |       |    ")
        print(" |      / \   ")

    print(" |            ")
    print("_|___         ")
    print()
def imprime_ganhador():
    print("Parabéns, você ganhou!")
    print("       ___________      ")
    print("      '._==_==_=_.'     ")
    print("      .-\\:      /-.    ")
    print("     | (|:.     |) |    ")
    print("      '-|:.     |-'     ")
    print("        \\::.    /      ")
    print("         '::. .'        ")
    print("           ) (          ")
    print("         _.' '._        ")
    print("        '-------'       ")
def imprime_perdedor(palavra_secreta):
    print("(Ops), você foi enforcado!")
    print("A palavra era {}".format(palavra_secreta))
    print("    _______________         ")
    print("   /               \       ")
    print("  /                 \      ")
    print("//                   \/\  ")
    print("\|   XXXX     XXXX   | /   ")
    print(" |   XXXX     XXXX   |/     ")
    print(" |   XXX       XXX   |      ")
    print(" |                   |      ")
    print(" \__      XXX      __/     ")
    print("   |\     XXX     /|       ")
    print("   | |           | |        ")
    print("   | I I I I I I I |        ")
    print("   |  I I I I I I  |        ")
    print("   \_             _/       ")
    print("     \_         _/         ")
    print("       \_______/           ")

if(__name__ == "__main__"): # função para abrir o jogo mesmo que diretamente
    jogar()

Data Structures

Listas

idade1 = 39
idade2 = 30   # Declaração de variaveis uma a uma
idade3 = 27
idade4 = 18

print(idade1, idade2, idade3, idade4)
idades = [39, 30, 27, 18] # Declaração de variaveis em lista
print(idades)
.

type(var)

Open in ColabOpen in Colab

len(var)

Open in ColabOpen in Colab

.sort(*key=Nonereverse=False)

Open in ColabOpen in Colab

Posições na lista

idades[0] # qual a idade na posição 0?

idades

print(idades[0])
print(idades[1])
print(idades[2])
print(idades[3])  # Chamando as posições da nosssa lista individualmente
---------------------------------------------------------------------------

IndexError                                Traceback (most recent call last)

  
IndexError: list index out of range

list.append(x)

Open in ColabOpen in Colab

---------------------------------------------------------------------------

TypeError                                 Traceback (most recent call last)

TypeError: append() takes exactly one argument (2 given)
list.remove(x)

Open in ColabOpen in Colab

---------------------------------------------------------------------------

ValueError                                Traceback (most recent call last)


ValueError: list.remove(x): x not in list
list.insert(i,x)

Open in ColabOpen in Colab

idades.insert(0,20)
idades

idades = [20, 39, 18]
idades
list.extend([ ])

Open in ColabOpen in Colab

idades = [20, 39, 18]
idades.extend([27, 19])
idades
>[20, 39, 18, 27, 19]

List compreheension

Aplicando filtros e comparações

Open in ColabOpen in Colab

idades_no_ano_que_vem = [ ] 

for idade in idades:

  idades_no_ano_que_vem.append(idade+1)

idades_no_ano_que_vem
idades_no_ano_que_vem = [(idade+1)for idade in idades]

idades_no_ano_que_vem
Filtragens
Filtragens

for, in, if
>, <

Open in ColabOpen in Colab

Mutabilidade das listas

Tuplas

Open in ColabOpen in Colab

idades = [15, 87, 32, 65, 56, 32, 49, 37]  
  
for i in range(len(idades)):  
  print(i, idades[i])  
  
enumerate(idades) # lazy  
  
list(range(len(idades))) # forçou a geração de valores  
  
list(enumerate(idades))  # Gerou tuplas pois a posição tem significado"""  
  
for indice, idade in enumerate(idades): # unpacking da nossa tupla  
  print(indice, "x", idade)  
  
usuarios =[  
    ("Marta", 29, 1993),  
    ("Eduardo", 33, 1989),  
    ("Trator", 6, 2016)  
]  
  
for nome, idade, nascimento in usuarios: # desempacotar - legivel, explicito  
  print(nome)  
  
for nome, _, _ in usuarios: # desempacotar ignorando o resto  
  print(nome)

class nome:

Open in ColabOpen in Colab

__eq__

Open in ColabOpen in Colab

class ContaSalario: 

  def __init__(self, codigo):
      self._codigo = codigo
      self._saldo = 0

  def __eq__(self, outro): # declara igualdade
    return self._codigo == outro._codigo

  def deposita(self, valor):
      self._saldo += valor

  def __str__(self):
      return "[>>Codigo {} Saldo {}<<]".format(self._codigo, self._saldo)

__lt__

Open in ColabOpen in Colab


class ContaSalario:

  def __init__(self, codigo):
    self._codigo = codigo
    self._saldo = 0

  def __eq__(self, outro):
    if type(outro) != ContaSalario:
      return False

  def __lt__(self, outro):
    return self._saldo < outro._saldo

  def deposita(self, valor): # assim não quebrou o enclapsulamento, lida com o saldo dentro da função conta
    self._saldo += valor

  def __str__(self):
    return "[>>Codigo {} Saldo {}<<]".format(self._codigo, self._saldo)

total ordering | functools

Open in ColabOpen in Colab

from functools import total_ordering

@total_ordering # notação antes da area que usa total ordering

Array (evitaremos usar)

Open in ColabOpen in Colab

Array

import array as array

arr.aray('d', [1, 3.5])

Numpy

Open in ColabOpen in Colab

Info

!pip install numpy
import numpy as np

numeros = np.array([1, 3.5])

Método Abstrato

Open in ColabOpen in Colab

Importar e implementar

from abc import ABCMeta, abstractmethod

class Conta(metaclass=ABCMeta):

@abstractmethod

Quote

[02:56] Então, a sacada é: se você tem um método que você quer definir na sua classe mãe e que todo mundo seja forçado a implementar, coloque um @abstractmethod nela, defina ela como uma classe abstrata através da meta classe ABCmeta.
[03:12] Então dessa maneira, forçamos para que o erro apareça na hora que você tem que instanciar, que é muito mais cedo do que o momento que você tenta chamar o método, porque você instancia em algum momento e os métodos só são chamados bem depois, não sabemos quando.
[03:30] Agora, se o erro acontecendo logo que você tentou instanciar, você consegue pegar mais cedo esse erro. Essa é a vantagem, quando eu tente instanciar eu já descobri que a classe não está completa. Então, eu queria refinar esse ponto do nosso código.

Built in

Open in ColabOpen in Colab

isinstance(objectclassinfo)

Open in ColabOpen in Colab

Quote

Return True if the object argument is an instance of the classinfo argument, or of a (direct, indirect, or virtual) subclass thereof. Documentação

enumerate(iterablestart=0)

sorted(iterable/*key=Nonereverse=False)

attrgetter

from operator import attrgetter

  for conta in sorted(contas, key=attrgetter("_saldo")):
  print(conta)

  1. https://docs.python.org/3/library/stdtypes.html?highlight=sort#list.sort ↩︎

Este é o jardim digital de Marta Safaneta, ou EiBarracuda, pessoa não-binária e autista, bacharel em Conservação-Restauração e estudando Divulgação Cientifica. Trabalhando atualmente no Projeto "Tem ciência no museu?", da Rede de Museus UFMG | FAPEMIG.
Saiba mais sobre mim, sobre meu curriculo ou navegue por aí.
2023