Guia Completa de Python 2025 (3/3): classes, objetos e tópicos avançados

11 de fevereiro de 2021

Nas partes anteriores vimos os tipos de datos e os operadores, controle de fluxo e funções. Neste último capítulo vemos as **classes e objetos**, os **iteradores**, o **escopo de variáveis**, os **módulos e pacotes**, o manejo de erros com **try... except**, as **palavras reservadas** e o **Zen de Python**.

Aviso: Este post foi traduzido para o português usando um modelo de tradução automática. Por favor, me avise se encontrar algum erro.

📚 **Esta entrada faz parte da série _Guía completa de Python_**, dividida em três capítulos que são lidos em ordem:

> * Parte 1: Tipos de datos

* Parte 2: Operadores, control de fluxo y funciones

* 👉 **Parte 3: Clases, objetos y temas avançados**

7. Classes e objetos

Python é uma linguagem de programação orientada a objetos. Quase tudo em Python é um objeto, com seus atributos e métodos.

Uma classe é como um construtor de objetos ou um “plano” para criar objetos.

Para criar uma classe, usa-se a palavra reservada class

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		class Clase:
  variable = 'MaximoFN'
	
	Copied

Uma vez criada a classe, pode-se criar um objeto dessa classe

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		objeto = Clase()
Clase.variable
	
	Copied

>_ Output

			
				'MaximoFN'

Normalmente as classes têm uma função inicial, que é executada quando um objeto da classe é criado. Esta função denomina-se *dunder init* e escreve-se __init__(). À função *dunder init* tem de ser sempre passada a variável self, que indica a própria classe, e, em seguida, as variáveis que se queiram passar

Com esta função, normalmente se inicializam as variáveis das classes, ou executa-se o código necessário quando um objeto da classe é criado

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		class Persona:
  def __init__(self, nombre, edad):
    self.nombre = nombre
    self.edad = edad
 
objeto_persona = Persona("Miguel", 36)
 
print(objeto_persona.nombre)
print(objeto_persona.edad)
	
	Copied

>_ Output

			
				Miguel
36

Além da função inicial *dunder init*, podem ser criadas mais funções. Essas funções são chamadas de *métodos* da classe. A esses *métodos* sempre é necessário passar a variável self

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		class Persona:
  def __init__(self, nombre, edad):
    self.nombre = nombre
    self.edad = edad
 
  def saludar(self):
    print(f'Hola mi nombre es {self.nombre} y tengo {self.edad} años')
 
objeto_persona = Persona("Miguel", 36)
 
objeto_persona.saludar()
	
	Copied

>_ Output

			
				Hola mi nombre es Miguel y tengo 36 años

A variável self não precisa ser chamada self, pode ter qualquer nome, mas dentro de cada classe tem que ser sempre o mesmo. Porém, por convenção, costuma-se usar self

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		class Persona:
  def __init__(yo_mismo, nombre, edad):
    yo_mismo.nombre = nombre
    yo_mismo.edad = edad
 
  def saludar(yo_mismo):
    print(f'Hola mi nombre es {yo_mismo.nombre} y tengo {yo_mismo.edad} años')
 
objeto_persona = Persona("Miguel", 36)
 
objeto_persona.saludar()
	
	Copied

>_ Output

			
				Hola mi nombre es Miguel y tengo 36 años

Podem ser modificáveis as variáveis dos objetos

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		objeto_persona.nombre = 'Marta'
objeto_persona.saludar()
	
	Copied

>_ Output

			
				Hola mi nombre es Marta y tengo 36 años

Mesmo removê-las

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		del objeto_persona.nombre
	
	Copied

Também se pode eliminar o objeto inteiro

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		del objeto_persona
	
	Copied

Se, por exemplo, quisermos fazer a estrutura da classe, mas não quisermos, por enquanto, codificar o interior, podemos usar pass

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		class Persona:
  pass
 
objeto_persona = Persona()
	
	Copied

7.1. Herança

A herança nos permite definir uma classe que herde todos os métodos e propriedades de outra classe.

A **classe pai** é a classe da qual se herda, também chamada **classe base**.

A **classe filha** é a classe que herda de outra classe, também chamada de **classe derivada**.

Criamos uma classe pai

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		class Persona:
  def __init__(self, nombre, apellido):
    self.nombre = nombre
    self.apellido = apellido
 
  def imprimir_nombre(self):
    print(f'Me llamo {self.nombre} {self.apellido}')
 
objeto_padre = Persona("Laura", "Perez")
objeto_padre.imprimir_nombre()
	
	Copied

>_ Output

			
				Me llamo Laura Perez

Para criar a classe filha, é preciso indicar entre parênteses, na hora de declarar a classe, de que classe ela herda.

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		class Estudiante(Persona):
  pass
	
	Copied

E no momento de criar o objeto da classe filha, são passados os parâmetros que a classe pai precisa

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		objeto_hijo = Estudiante("Mariano", "Sanz")
objeto_hijo.imprimir_nombre()
	
	Copied

>_ Output

			
				Me llamo Mariano Sanz

Até agora, a classe filha herdou as funções da classe pai, mas podemos modificá-las reescrevendo-as. Por exemplo, reescrevendo a função *dunder init*.

Se a função *dunder init* for reescrita, se quisermos chamar a função *dunder init* da classe pai, temos de a chamar.

Para isso, há duas maneiras: uma é por meio do nome da classe pai. Nesse caso, é preciso passar a variável self.

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		class Estudiante(Persona):
  def __init__(self, nombre, apellido):
    Persona.__init__(self, nombre, apellido)
 
objeto_hijo = Estudiante("Mariano", "Sanz")
objeto_hijo.imprimir_nombre()
	
	Copied

>_ Output

			
				Me llamo Mariano Sanz

Outra forma é por meio de super(), neste caso não é necessário passar a variável self

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		class Estudiante(Persona):
  def __init__(self, nombre, apellido):
    super().__init__(nombre, apellido)
 
objeto_hijo = Estudiante("Mariano", "Sanz")
objeto_hijo.imprimir_nombre()
	
	Copied

>_ Output

			
				Me llamo Mariano Sanz

Ao modificar as funções, pode-se adicionar novo código

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		class Estudiante(Persona):
  def __init__(self, nombre, apellido, curso):
    Persona.__init__(self, nombre, apellido)
    self.curso = curso
 
  def imprimir_nombre(self):
    Persona.imprimir_nombre(self)
    print(f'Estoy en el curso número {self.curso}')
 
objeto_hijo = Estudiante("Mariano", "Sanz", 4)
objeto_hijo.imprimir_nombre()
	
	Copied

>_ Output

			
				Me llamo Mariano Sanz
Estoy en el curso número 4

Por fim, podem ser adicionados novos métodos

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		class Estudiante(Persona):
  def __init__(self, nombre, apellido, curso):
    Persona.__init__(self, nombre, apellido)
    self.curso = curso
 
  def imprimir_nombre(self):
    Persona.imprimir_nombre(self)
    print(f'Estoy en el curso número {self.curso}')
 
  def imprimir_estudiante(self):
    print(f"Soy un estudiante del curso número {self.curso}")
 
objeto_hijo = Estudiante("Mariano", "Sanz", 4)
objeto_hijo.imprimir_nombre()
objeto_hijo.imprimir_estudiante()
	
	Copied

>_ Output

			
				Me llamo Mariano Sanz
Estoy en el curso número 4
Soy un estudiante del curso número 4

7.2. Sobrecarga de operadores

Podemos definir operações básicas, como a soma, entre vários objetos de uma classe. Por exemplo, se temos uma classe que representa um vetor, podemos definir a soma e a multiplicação entre objetos dessa classe

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		class Vector:
    def __init__(self, x, y):
        self.x = x
        self.y = y
    
    def __add__(self, other):
        return Vector(self.x + other.x, self.y + other.y)
    
    def __mul__(self, other):
        return Vector(self.x * other.x, self.y * other.y)
    
    def __str__(self):
        return f"Vector ({self.x}, {self.y})"
 
v1 = Vector(1, 2)
v2 = Vector(3, 4)
print(v1 + v2) # Vector (4, 6)
print(v1 * v2) # Vector (3, 8)
	
	Copied

>_ Output

			
				Vector (4, 6)
Vector (3, 8)

Todas as possíveis sobrecargas de operadores são:

__add__(self, other): sobrecarrega o operador de soma (+).
__sub__(self, other): sobrecarga o operador de subtração (-).
__mul__(self, other): sobrecarrega o operador de multiplicação (*).
__truediv__(self, other): sobrecarrega o operador de divisão (/).
__floordiv__(self, other): sobrecarrega o operador de divisão inteira arredondada (//).
__mod__(self, other): sobrecarrega o operador de módulo (%).
__divmod__(self, other): sobrecarrega a função divmod().
__pow__(self, other): sobrecarrega o operador de potência (**).
__lshift__(self, other): sobrecarrega o operador de deslocamento à esquerda (<<).
__rshift__(self, other): sobrecarrega o operador de deslocamento à direita (>>).
__and__(self, other): sobrecarrega o operador and (&).
__or__(self, other): sobrecarga o operador or (|).
__xor__(self, other): sobrecarrega o operador de xor (^).* __lt__(self, other): sobrecarrega o operador de comparação menor que (<).
__le__(self, other): sobrecarrega o operador de comparação menor ou igual que (<=).
__eq__(self, other): sobrecarrega o operador de comparação igual a (==).
__ne__(self, other): sobrecarrega o operador de comparação diferente de (!=).
__gt__(self, other): sobrecarrega o operador de comparação maior que (>).
__ge__(self, other): sobrecarrega o operador de comparação maior ou igual que (>=).
__neg__(self): sobrecarrega o operador de negação (-).
__pos__(self): sobrecarrega o operador de posição (+).
__abs__(self): sobrecarrega a função abs().
__invert__(self): sobrecarrega o operador de inversão (~).
__complex__(self): sobrecarrega a função complex().
__int__(self): sobrecarrega a função int().
__float__(self): sobrecarrega a função float().

7.3. Iteradores personalizados

Como vimos na seção 2 (Tipos de datos de Python), existem alguns tipos de dados sobre os quais se pode iterar. Mas podemos criar nossa própria classe iterável, desde que tenha as funções __len__ e __getitem__

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		class custonIterator:
    def __init__(self, n):
        self.items = [i for i in range(n)]
    
    def __len__(self):
        return len(self.items)
    
    def __getitem__(self, index):
        return self.items[index]
 
iterator = custonIterator(10)
print(len(iterator)) # 10
print(iterator[0]) # 0
print(iterator[1]) # 1
	
	Copied

>_ Output

Agora podemos iterar com o objeto da nossa classe com laços for, por exemplo

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		for i in iterator:
    print(i, end=" ") # 0 1 2 3 4 5 6 7 8 9
	
	Copied

>_ Output

			
				0 1 2 3 4 5 6 7 8 9

7.4. Chamada a objetos como funções

Pode nos interessar chamar um objeto de uma função como se fosse uma classe. Isso pode ser conseguido adicionando a função __call__ à classe

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		class potencia:
    def __init__(self, base):
        self.base = base
    
    def __call__(self, potencia):
        return self.base ** potencia
    
potencia_cuadrado = potencia(2)
print(potencia_cuadrado(3)) # 8
	
	Copied

>_ Output

7.5. Atributos e funções privados

Quando criamos uma classe, podemos fazer com que alguns atributos ou funções sejam privados e não possam ser acessados de fora da classe; para isso, é necessário adicionar __ antes do atributo ou método

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		class Privados:
    def __init__(self):
        self.publico = "Soy público"
        self.__privado = "Soy privado"
    
    def getPrivado(self):
        return self.__privado
    
    def setPrivado(self, valor):
        self.__privado = valor
    
    def __funcion_privada(self):
        return "Soy una función privada"
    
    def funcion_publica(self):
        return self.__funcion_privada()
 
privados = Privados()
 
print("Acceso al atributo publico: ", end="")
try:
    print(f"{privados.publico}")
except:
    print("	No se puede acceder al atributo privado")
print("Acceso al atributo privado: ", end="")
try:
    print(f"{privados.__privado}")
except:
    print("	No se puede acceder al atributo privado")
print("Acceso al atributo privado mediante el accesor: ", end="")
try:
    print(f"{privados.getPrivado()}")
except:
    print("	No se puede acceder al atributo privado mediante el accesor")
print("Llamada a la función privada: ", end="")
try:
    print(f"{privados.__funcion_privada()}")
except:
    print("	No se puede llamar a la función privada")
print("Llamada a la función pública: ", end="")
try:
    print(f"{privados.funcion_publica()}")
except:
    print("	No se puede llamar a la función pública")
	
	Copied

>_ Output

			
				Acceso al atributo publico: Soy público
Acceso al atributo privado: 	No se puede acceder al atributo privado
Acceso al atributo privado mediante el accesor: Soy privado
Llamada a la función privada: 	No se puede llamar a la función privada
Llamada a la función pública: Soy una función privada

8. Iteradores

Um iterador é um objeto que contém um número contável de valores.

Um iterador é um objeto sobre o qual se pode iterar, o que significa que pode percorrer todos os elementos.

Tecnicamente, em Python, um iterador é um objeto que implementa o protocolo do iterador, que consiste nos métodos __iter__() e __next__().

As listas, tuplas, dicionários e conjuntos são todos objetos iteráveis. São contêineres iteráveis dos quais se pode obter um iterador.

Todos esses objetos têm um método iter() que é usado para obter um iterador:

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		tupla = ("manzana", "plátano", "cereza")
iterable = iter(tupla)
 
print(next(iterable))
print(next(iterable))
print(next(iterable))
	
	Copied

>_ Output

			
				manzana
plátano
cereza

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		string = "plátano"
iterable = iter(string)
 
print(next(iterable), end=' ')
print(next(iterable), end=' ')
print(next(iterable), end=' ')
print(next(iterable), end=' ')
print(next(iterable), end=' ')
print(next(iterable), end=' ')
print(next(iterable), end=' ')
	
	Copied

>_ Output

			
				p l á t a n o

O laço for na verdade cria um objeto iterador e executa o método next() em cada iteração.

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		tupla = ("manzana", "plátano", "cereza")
 
for x in tupla:
  print(x)
	
	Copied

>_ Output

			
				manzana
plátano
cereza

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		string = "plátano"
 
for x in string:
  print(x, end=' ')
	
	Copied

>_ Output

			
				p l á t a n o

8.1. Criar um objeto iterador

Para criar um objeto/classe como iterador, é preciso implementar os métodos __iter__() e __next__().

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		class Numeros:
  def __iter__(self):
    self.a = 1
    return self
 
  def __next__(self):
    x = self.a
    self.a += 1
    return x
 
objeto_iterador = Numeros()
iterador = iter(objeto_iterador)
 
print(next(iterador), end=' ')
print(next(iterador), end=' ')
print(next(iterador), end=' ')
print(next(iterador), end=' ')
print(next(iterador), end=' ')
	
	Copied

>_ Output

			
				1 2 3 4 5

O exemplo anterior continuaria para sempre se tivesse chamadas suficientes a next(), ou se fosse usado num ciclo for.

Para evitar que a iteração continue para sempre, podemos usar a declaração StopIteration.

No método __next__(), podemos adicionar uma condição de terminação para gerar um erro se a iteração for realizada um número específico de vezes:

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		class Numeros:
  def __iter__(self):
    self.a = 1
    return self
 
  def __next__(self):
    if self.a &lt;= 20:
      x = self.a
      self.a += 1
      return x
    else:
      raise StopIteration
 
objeto_iterador = Numeros()
iterador = iter(objeto_iterador)
 
for x in iterador:
  print(x, end=' ')
	
	Copied

>_ Output

			
				1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

8.2. Iterar obtendo o índice e o valor

Podemos iterar por um objeto iterável obtendo em cada iteração seu índice e seu valor por meio do método enumerate()

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		string = "MaximoFN"
 
for index, valor in enumerate(string):
  print(f"En la posición {index}, está el caracter {valor}")
	
	Copied

>_ Output

			
				En la posición 0, está el caracter M
En la posición 1, está el caracter a
En la posición 2, está el caracter x
En la posición 3, está el caracter i
En la posición 4, está el caracter m
En la posición 5, está el caracter o
En la posición 6, está el caracter F
En la posición 7, está el caracter N

8.3. Iterar simultaneamente sobre dois objetos iteráveis

Se tivermos dois objetos iteráveis, do mesmo comprimento, podemos iterar pelos dois ao mesmo tempo por meio do método zip()

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		string1 = 'MaximoFN__'
string2 = 'PythonPost'
 
if len(string1) == len(string2):
  for valor1, valor2 in zip(string1, string2):
    print(f"En el primer string hay {valor1}, en el segundo string hay {valor2}")
	
	Copied

>_ Output

			
				En el primer string hay M, en el segundo string hay P
En el primer string hay a, en el segundo string hay y
En el primer string hay x, en el segundo string hay t
En el primer string hay i, en el segundo string hay h
En el primer string hay m, en el segundo string hay o
En el primer string hay o, en el segundo string hay n
En el primer string hay F, en el segundo string hay P
En el primer string hay N, en el segundo string hay o
En el primer string hay _, en el segundo string hay s
En el primer string hay _, en el segundo string hay t

9. Escopo de variáveis

Uma variável só está disponível dentro da região em que é criada. Isso é chamado de *escopo*

9.1. Escopo local

Uma variável criada dentro de uma função pertence ao âmbito local dessa função e só pode ser usada dentro dessa função.

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		def funcion():
  x = 300
  print(x)
 
funcion()
	
	Copied

>_ Output

A variável x não está disponível fora da função, mas está disponível para qualquer função dentro dela

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		def funcion():
  x = 300
  def funcion_interna():
    print(x)
  funcion_interna()
 
funcion()
	
	Copied

>_ Output

9.2. Alcance global

Uma variável criada no corpo principal do código Python é uma variável global e pertence ao escopo global.

As variáveis globais estão disponíveis a partir de qualquer escopo, global e local.

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		x = 300
 
def funcion():
  print(f'Ámbito local: {x}')
 
funcion()
 
print(f'Ámbito global: {x}')
	
	Copied

>_ Output

			
				Ámbito local: 300
Ámbito global: 300

Se forem criadas duas variáveis, uma global e outra local, ambas com o mesmo nome, o Python as criará como duas variáveis distintas

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		x = 300
 
def funcion():
  x = 200
  print(f'Variable local: {x}')
 
funcion()
 
print(f'Variable global: {x}')
	
	Copied

>_ Output

			
				Variable local: 200
Variable global: 300

Se for necessário criar uma variável global, mas ela estiver declarada no escopo local, pode-se usar a palavra-chave global.

A palavra-chave global torna a variável global.

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		def funcion():
  global x
  x = 300
 
funcion()
 
print(f'Variable global: {x}')
	
	Copied

>_ Output

			
				Variable global: 300

Além disso, o uso da palavra-chave global permite realizar uma alteração em uma variável global dentro de uma função.

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		x = 300
 
def funcion():
  global x
  x = 200
 
funcion()
 
print(f'Variable global: {x}')
	
	Copied

>_ Output

			
				Variable global: 200

10. Módulos

Um módulo é um arquivo que contém um conjunto de funções que você deseja incluir em sua aplicação.

Para criar um módulo, simplesmente salve o código que deseja em um arquivo com a extensão .py

Dica: Nos notebooks Jupyter (Colab é um notebook Jupyter online), se escrevemos o caractere ! antes de um comando, poderemos executar comandos de terminal

Primeiro vamos ver em que diretório estamos, para isso usamos o comando pwd (*print working directory*)

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		!pwd
	
	Copied

>_ Output

			
				/home/wallabot/Documentos/web/portafolio/posts

Vamos criar uma pasta para criar nossos módulos com o comando mkdir (make directory)

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		!mkdir introduccion_python
	
	Copied

A seguir, vamos ver quais arquivos há em nossa pasta. Isso faremos por meio do comando ls (*list*)

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		!ls introduccion_python
	
	Copied

Vemos que ela está vazia, criamos um novo arquivo .py no qual vamos criar o nosso módulo

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		%%writefile introduccion_python/modulo1.py
 
def funcion_del_modulo(nombre):
  print("Hola, " + nombre)
	
	Copied

>_ Output

			
				Writing introduccion_python/modulo1.py

Vamos ver novamente quais arquivos existem na nossa pasta

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		!ls introduccion_python
	
	Copied

>_ Output

			
				modulo1.py  __pycache__

Vemos que um arquivo módulo1.py foi criado. Já podemos usá-lo

Para usar um módulo externo, é preciso usar a palavra import. Para usar as funções do módulo, é preciso primeiro colocar o nome do módulo, um . e, em seguida, o nome da função que se quer usar

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		import introduccion_python.modulo1
 
introduccion_python.modulo1.funcion_del_modulo('MaximoFN')
	
	Copied

>_ Output

			
				Hola, MaximoFN

Se quisermos que, dentro do nosso código, o módulo tenha um nome específico, podemos usar a palavra as

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		import introduccion_python.modulo1 as mod1
 
mod1.funcion_del_modulo('MaximoFN')
	
	Copied

>_ Output

			
				Hola, MaximoFN

Se o módulo tiver várias funções, mas quisermos importar apenas uma, podemos fazer isso mediante o uso das palavras from e import. A forma seria

from <módulo> import <função>

Neste caso, não é necessário indicar o nome do módulo ao chamar a função

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		%%writefile introduccion_python/modulo2.py
 
def funcion1_del_modulo(nombre):
  print("Hola, " + nombre + ", funcion 1")
 
def funcion2_del_modulo(nombre):
  print("Hola, " + nombre + ", funcion 2")
 
def funcion3_del_modulo(nombre):
  print("Hola, " + nombre + ", funcion 3")
	
	Copied

>_ Output

			
				Writing introduccion_python/modulo2.py

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		from introduccion_python.modulo2 import funcion2_del_modulo
 
funcion2_del_modulo('MaximoFN')
	
	Copied

>_ Output

			
				Hola, MaximoFN, funcion 2

Não podemos usar apenas módulos criados por nós, mas também módulos já instalados (built-in modules)

Por exemplo, podemos usar o módulo platform

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		import platform
 
x = platform.system()
x
	
	Copied

>_ Output

			
				'Linux'

10.1. Pontos de entrada: arquivos como módulos e não como scripts

Vamos agora criar um arquivo chamado módulo3.py

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		%%writefile introduccion_python/modulo3.py
 
print("Hola desde modulo3")
 
def funcion_del_modulo():
  return "Hola desde la función del modulo3"
	
	Copied

>_ Output

			
				Overwriting introduccion_python/modulo3.py

Se agora importamos modulo3.py para usar a função funcion_del_modulo vejamos o que ocorre

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		import introduccion_python.modulo3 as mod3
 
print(mod3.funcion_del_modulo())
	
	Copied

>_ Output

			
				Hola desde modulo3
Hola desde la función del modulo3

Vemos que foi executado o print de modulo3.py, mas não é o que queríamos; isso acontece porque, ao chamar o arquivo modulo3.py, o Python o executa como um script

Mas o que acontece se quisermos executar introduccion_python/main.py como um script?

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		!python introduccion_python/modulo3.py
	
	Copied

>_ Output

			
				Hola desde modulo3

Vemos que apenas o print é executado, mas não a função funcion_del_modulo. Se quisermos ter a dualidade de funcionalidade do arquivo modulo3.py, isto é, que possamos importá-lo a partir de outro módulo sem que ele seja executado como um script e executá-lo isoladamente, e que seja executada a função que nós queremos, usa-se um entry point. Isto é, usar a condição if __name__ == '__main__': e, em seguida, indicar o que queremos que seja executado. Vejamos com um exemplo, vou reescrever o arquivo modulo3.py

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		%%writefile introduccion_python/modulo3.py
 
print("Hola desde modulo3")
 
def funcion_del_modulo():
  return "Hola desde la función del modulo3"
 
if __name__ == "__main__":
  funcion_del_modulo()
	
	Copied

>_ Output

			
				Overwriting introduccion_python/modulo3.py

Se agora eu chamar main.py de outro módulo, o print não será mais executado

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		import introduccion_python.modulo3 as mod3
 
print(mod3.funcion_del_modulo())
	
	Copied

>_ Output

			
				Hola desde la función del modulo3

E se eu o executar como um script independente, a função función_del_modulo será executada

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		!python introduccion_python/modulo3.py
	
	Copied

>_ Output

			
				Hola desde modulo3

11. Pacotes

Em Python, podemos criar nossos próprios pacotes; para isso, criamos uma pasta com o nome do pacote

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		!mkdir mi_paquete_de_python
	
	Copied

Criamos agora dois arquivos dentro

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		!touch mi_paquete_de_python/modulo1.py mi_paquete_de_python/modulo2.py
	
	Copied

E escrevemos neles

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		%%writefile mi_paquete_de_python/modulo1.py
 
def funcion1():
  print("Hola desde la función 1 del módulo 1")
 
def funcion2():
    print("Hola desde la función 2 del módulo 1")
	
	Copied

>_ Output

			
				Overwriting mi_paquete_de_python/modulo1.py

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		%%writefile mi_paquete_de_python/modulo2.py
 
def funcion1():
  print("Hola desde la función 1 del módulo 2")
 
def funcion2():
    print("Hola desde la función 2 del módulo 2")
	
	Copied

>_ Output

			
				Overwriting mi_paquete_de_python/modulo2.py

Agora podemos chamar as funções do nosso pacote

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		from mi_paquete_de_python import modulo1 as mod1
from mi_paquete_de_python import modulo2 as mod2
 
mod1.funcion1()
mod1.funcion2()
mod2.funcion1()
mod2.funcion2()
	
	Copied

>_ Output

			
				Hola desde la función 1 del módulo 1
Hola desde la función 2 del módulo 1
Hola desde la función 1 del módulo 2
Hola desde la función 2 del módulo 2

Mas o que acontece se o nosso pacote tiver dezenas de arquivos com funções que queremos usar? Teríamos que importar todos os arquivos um a um. Para evitar isso, pode-se criar um arquivo __init__.py dentro do pacote onde se faça toda essa importação de arquivos

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		!touch mi_paquete_de_python/__init__.py
	
	Copied

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		%%writefile mi_paquete_de_python/__init__.py
 
import modulo1
import modulo2
	
	Copied

>_ Output

			
				Overwriting mi_paquete_de_python/__init__.py

Agora podemos simplesmente importar nosso pacote, que internamente já importou todos os módulos

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		import mi_paquete_de_python as mi_paquete
 
mi_paquete.modulo1.funcion1()
mi_paquete.modulo1.funcion2()
mi_paquete.modulo2.funcion1()
mi_paquete.modulo2.funcion2()
	
	Copied

>_ Output

			
				Hola desde la función 1 del módulo 1
Hola desde la función 2 del módulo 1
Hola desde la función 1 del módulo 2
Hola desde la función 2 del módulo 2

Dessa maneira, só temos que fazer um import

12. Try... except

Quando ocorre um erro, ou uma exceção, como realmente se chama, o Python normalmente o capturará e gerará uma mensagem de erro.

Essas exceções podem ser tratadas usando as declarações try e except

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		try:
  print(variable_no_declarada)
except:
  print("Ha ocurrido una excepción")
	
	Copied

>_ Output

			
				Ha ocurrido una excepción

Como o bloco try gera um erro, então o bloco except será executado

Sem o bloco try, o programa travaria e geraria um erro

Podem ser definidos quantos blocos de exceção se desejar, por exemplo, se quiser executar um bloco de código especial para um tipo especial de erro

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		try:
  print(variable_no_declarada)
except NameError:
  print("La variable 'variable_no_declarada' no está definida")
except:
  print("Algo inesperado ha ocurrido")
	
	Copied

>_ Output

			
				La variable 'variable_no_declarada' no está definida

Você pode usar a palavra else para indicar o caso em que não tenha ocorrido um erro

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		try:
  print('MaximoFN')
except NameError:
  print("Ha ocurrido una excepción")
else:
  print('Todo OK')
	
	Copied

>_ Output

			
				MaximoFN
Todo OK

com a palavra finally será executado um código ao final, tenha ocorrido uma exceção ou não

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		try:
  print(variable_no_declarada)
except:
  print("Ha ocurrido una excepción")
finally:
  print("'try except' finallizado")
	
	Copied

>_ Output

			
				Ha ocurrido una excepción
'try except' finallizado

Isso pode ser útil para fechar objetos e limpar recursos

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		class Clase:
  variable = 'MaximoFN'
 
objeto = Clase()
 
try:
  print(Clase.mi_variable)
except:
  print("Ha ocurrido una excepción")
finally:
  del objeto
	
	Copied

>_ Output

			
				Ha ocurrido una excepción

12.1. Criar uma exceção

Como desenvolvedor Python, é possível optar por lançar uma exceção se ocorrer uma condição.

Para lançar (ou gerar) uma exceção, é necessário usar a palavra-chave raise

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		def division(numerador, denominador):
  if denominador == 0:
    raise Exception("El denominador no puede ser 0")
  
  return numerador/denominador
 
print(division(10, 0))
	
	Copied

>_ Output

			
				---------------------------------------------------------------------------Exception                                 Traceback (most recent call last)&lt;ipython-input-16-33fb6066fa78&gt; in &lt;module&gt;
      5   return numerador/denominador
      6
----&gt; 7 print(division(10, 0))
&lt;ipython-input-16-33fb6066fa78&gt; in division(numerador, denominador)
      1 def division(numerador, denominador):
      2   if denominador == 0:
----&gt; 3     raise Exception("El denominador no puede ser 0")
      4
      5   return numerador/denominador
Exception: El denominador no puede ser 0

É possível definir que tipo de erro gerar e o texto que será mostrado ao usuário

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		def division(numerador, denominador):
  if denominador == 0:
    raise TypeError("El denominador no puede ser 0")
  
  return numerador/denominador
 
print(division(10, 0))
	
	Copied

>_ Output

			
				---------------------------------------------------------------------------TypeError                                 Traceback (most recent call last)&lt;ipython-input-17-26bfa63ae44c&gt; in &lt;module&gt;
      5   return numerador/denominador
      6
----&gt; 7 print(division(10, 0))
&lt;ipython-input-17-26bfa63ae44c&gt; in division(numerador, denominador)
      1 def division(numerador, denominador):
      2   if denominador == 0:
----&gt; 3     raise TypeError("El denominador no puede ser 0")
      4
      5   return numerador/denominador
TypeError: El denominador no puede ser 0

13. Palavras-chave ou palavras reservadas

Durante este post, em várias ocasiões, apareceram palavras reservadas de Python ou keywords; estas são uma série de palavras reservadas pelo Python

A seguir, é mostrada uma lista das keywords

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		import keyword
 
keyword.kwlist
	
	Copied

>_ Output

			
				['False',
'None',
'True',
'and',
'as',
'assert',
'async',
'await',
'break',
'class',
'continue',
'def',
'del',
'elif',
'else',
'except',
'finally',
'for',
'from',
'global',
'if',
'import',
'in',
'is',
'lambda',
'nonlocal',
'not',
'or',
'pass',
'raise',
'return',
'try',
'while',
'with',
'yield']

14. O ZEN do Python

Ao importar o módulo this, podemos ler o zen do Python, ou seja, sua filosofia ou princípios

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		import this
	
	Copied

>_ Output

			
				The Zen of Python, by Tim Peters
Beautiful is better than ugly.
Explicit is better than implicit.
Simple is better than complex.
Complex is better than complicated.
Flat is better than nested.
Sparse is better than dense.
Readability counts.
Special cases aren't special enough to break the rules.
Although practicality beats purity.
Errors should never pass silently.
Unless explicitly silenced.
In the face of ambiguity, refuse the temptation to guess.
There should be one-- and preferably only one --obvious way to do it.
Although that way may not be obvious at first unless you're Dutch.
Now is better than never.
Although never is often better than *right* now.
If the implementation is hard to explain, it's a bad idea.
If the implementation is easy to explain, it may be a good idea.
Namespaces are one honking great idea -- let's do more of those!

Continuar lendo

Deep Research com LangGraph (3/3): agente Writer e relatório final

Terceira e última parte da série Deep Research com LangGraph. Implemente o agente Writer que redige o relatório final a partir da pesquisa, integre todo o grafo do deep researcher e execute o assistente completo de ponta a ponta.

Deep Research com LangGraph (2/3): Research Supervisor multiagente

Segunda parte da série Deep Research com LangGraph. Construa o Research Supervisor que coordena vários agentes Researche...

Deep Research com LangGraph (1/3): agentes Scope e Researcher

Primeira parte da série para criar um assistente de pesquisa com LangGraph. Conheça a arquitetura do sistema e construa ...

Últimos posts -->

Você viu esses projetos?

Gymnasia

Horeca chatbot

Naviground

Ver todos os projetos -->

>_ Disponível para projetos

Tem um projeto com IA?

Vamos conversar.

maximofn@gmail.com

Especialista em Machine Learning e Inteligência Artificial. Desenvolvo soluções com IA generativa, agentes inteligentes e modelos personalizados.

Escreva-me LinkedIn

Quer assistir alguma palestra?

Agentes do Amanhã: Descifrando os Mistérios da Planificação, UX e Memória

Agentes de IA, impulsionados por LLMs, prometem transformar aplicações. Mas eles são meros executores hoje ou futuros colaboradores inteligentes? Para...

Crie sua própria inteligência Apple

Aprenda a criar um sistema de IA para executar eficientemente em um dispositivo

Últimas palestras -->

Quer melhorar com essas dicas?

Boas práticas criando agentes com Claude Code

Palestra técnica: skills, subagentes, slash commands e MCPs no Claude Code

o1 prompt engineering

Criar prompts melhores para o1 seguindo um exemplo

Memory profiler

Ver o uso de memória de um script

Últimos tips -->

Use isso localmente

Os espaços do Hugging Face nos permitem executar modelos com demos muito simples, mas e se a demo quebrar? Ou se o usuário a deletar? Por isso, criei contêineres docker com alguns espaços interessantes, para poder usá-los localmente, aconteça o que acontecer. Na verdade, se você clicar em qualquer botão de visualização de projeto, ele pode levá-lo a um espaço que não funciona.