Python 2025: Tutorial Completo

11 de fevereiro de 2021

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.

1. Resumo

Vamos fazer uma breve introdução ao Python, explicando os tipos de dados que temos, os operadores, o uso de funções e de classes. Além disso, veremos como usar objetos iteráveis, como usar módulos, etc.

2. Tipos de dados do Python

Existem 7 tipos de dados em Python

De tipo texto: str
Numéricos: int, float, complex
Sequências: list, tuple, range
Mapeamento: dict
Conjuntos: set, frozenset
Booleanos: bool
Binários: bytes, bytearray, memoryview

Podemos obter o tipo de dado através da função type()

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		type(5.)
	
	Copied

>_ Output

			
				float

Python é uma linguagem de tipagem dinâmica, ou seja, você pode ter uma variável de um tipo e depois atribuir outro tipo.

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		a = 5
type(a)
	
	Copied

>_ Output

int

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		a = 'MaximoFN'
type(a)
	
	Copied

>_ Output

str

Python tipa as variáveis para você, mas se você quiser tipá-las, pode fazer.

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		b = int(5.1)
type(b), b
	
	Copied

>_ Output

			
				(int, 5)

Embora b tenha sido inicializado como 5.1, ou seja, deveria ser do tipo float, ao tipá-lo como int, vemos que é do tipo int e, além disso, seu valor é 5

2.1. Cadeias de Caracteres

Os strings são cadeias de caracteres, estas podem ser definidas com aspas duplas " ou aspas simples '.

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		string = "MaximoFN"
string
	
	Copied

>_ Output

			
				'MaximoFN'

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		string = 'MaximoFN'
string
	
	Copied

>_ Output

			
				'MaximoFN'

Para escrever uma string muito longa e não ter uma linha que ocupe muito espaço, pode-se introduzi-la em várias linhas

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		string = """Este es un ejemplo de
como estoy introduciendo un string
en varias lineas"""
string
	
	Copied

>_ Output

			
				'Este es un ejemplo de
como estoy introduciendo un string
en varias lineas'

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		string = '''Este es un ejemplo de
como estoy introduciendo un string
en varias lineas'''
string
	
	Copied

>_ Output

			
				'Este es un ejemplo de
como estoy introduciendo un string
en varias lineas'

No entanto, vemos que no meio foi inserido o caractere indica a quebra de linha. Se usarmos a função print() veremos como já não aparece

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		print(string)
	
	Copied

>_ Output

			
				Este es un ejemplo de
como estoy introduciendo un string
en varias lineas

Como dissemos, as strings são cadeias de caracteres, portanto podemos navegar e iterar através delas.

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		for i in range(10):
  # Se indica a la función print que cuando imprima no termine con un salto de 
  # linea para escribir todo en la misma linea
  print(string[i], end='')
	
	Copied

>_ Output

			
				Este es un

Podemos obter o comprimento da nossa string através da função len()

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		len(string)
	
	Copied

>_ Output

Verificar se há uma string específica dentro da nossa

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		'ejemplo' in string
	
	Copied

>_ Output

			
				True

As strings têm certos atributos úteis, como colocar tudo em maiúsculas

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		print(string.upper())
	
	Copied

>_ Output

			
				ESTE ES UN EJEMPLO DE
COMO ESTOY INTRODUCIENDO UN STRING
EN VARIAS LINEAS

tudo em minúsculas

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		print(string.lower())
	
	Copied

>_ Output

			
				este es un ejemplo de
como estoy introduciendo un string
en varias lineas

Substituir caracteres

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		print(string.replace('o', '@'))
	
	Copied

>_ Output

			
				Este es un ejempl@ de
c@m@ est@y intr@duciend@ un string
en varias lineas

Obter todas as palavras

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		print(string.split())
	
	Copied

>_ Output

			
				['Este', 'es', 'un', 'ejemplo', 'de', 'como', 'estoy', 'introduciendo', 'un', 'string', 'en', 'varias', 'lineas']

Você pode ver todos os métodos das strings neste enlace

Outra coisa útil que se pode fazer com as strings é concatená-las

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		string1 = 'Maximo'
string2 = 'FN'
string1 + string2
	
	Copied

>_ Output

			
				'MaximoFN'

Antes explicamos que o caractere \n correspondia a uma quebra de linha, este caractere especial corresponde a uma série de caracteres especiais chamados Escape Characters. Vejamos outros

Se declararmos uma string com aspas duplas e quisermos adicionar uma aspa dupla dentro da string, usamos o caractere de escape \"

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		print("Este es el blog de "MaximoFN"")
	
	Copied

>_ Output

			
				Este es el blog de "MaximoFN"

O mesmo com a aspa simples, adicionamos \'

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		print('Este es el blog de 'MaximoFN'')
	
	Copied

>_ Output

			
				Este es el blog de 'MaximoFN'

Agora temos o problema de querer adicionar o caractere \, pois como vimos, ele é um escape character, então resolvemos isso colocando duas barras (backslash) \.

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		print('Este es el blog de \\MaximoFN\\')
	
	Copied

>_ Output

			
				Este es el blog de \MaximoFN\

Já vimos antes o escape character de nova linha \n

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		print('Este es el blog de \nMaximoFN')
	
	Copied

>_ Output

			
				Este es el blog de
MaximoFN

Se quisermos escrever desde o início da linha, adicionamos \r

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		print('Esto no se imprimirá \rEste es el blog de MaximoFN')
	
	Copied

>_ Output

			
				Este es el blog de MaximoFN

Se quisermos adicionar um grande espaço (recuo) usamos \t

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		print('Este es el blog de \tMaximoFN')
	
	Copied

>_ Output

			
				Este es el blog de 	MaximoFN

Podemos apagar um caractere com \b

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		print('Este es el blog de \bMaximoFN')
	
	Copied

>_ Output

			
				Este es el blog deMaximoFN

Podemos adicionar o código ASCII em octal mediante \ooo

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		print('\115\141\170\151\155\157\106\116')
	
	Copied

>_ Output

			
				MaximoFN

O adicionar o código ASCII em hexadecimal mediante \xhh

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		print('\x4d\x61\x78\x69\x6d\x6f\x46\x4e')
	
	Copied

>_ Output

			
				MaximoFN

Por último, podemos converter outro tipo de dado em uma string

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		n = 5
print(type (n))
string = str(n)
print(type(string))
	
	Copied

>_ Output

			
				&lt;class 'int'&gt;
&lt;class 'str'&gt;

2.2. Números

2.2.1. Inteiros

Números de tipo inteiro

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		n = 5
n, type(n)
	
	Copied

>_ Output

			
				(5, int)

2.2.2. Float

Números de tipo ponto flutuante

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		n = 5.1
n, type(n)
	
	Copied

>_ Output

			
				(5.1, float)

2.2.3. Complexos

Números complexos

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		n = 3 + 5j
n, type(n)
	
	Copied

>_ Output

			
				((3+5j), complex)

2.2.4. Conversão

Pode-se converter entre tipos de números

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		n = 5
n = float(n)
n, type(n)
	
	Copied

>_ Output

			
				(5.0, float)

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		n = 5.1
n = complex(n)
n, type(n)
	
	Copied

>_ Output

			
				((5.1+0j), complex)

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		n = 5.1
n = int(n)
n, type(n)
	
	Copied

>_ Output

			
				(5, int)

Não é possível converter um número complex para o tipo int ou float.

2.3. Sequências

2.3.1. Listas

As listas guardam múltiplos itens em uma variável. Elas são declaradas através dos símbolos [], com os itens separados por vírgulas.

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		lista = ['item0', 'item1', 'item2', 'item3', 'item4', 'item5']
lista
	
	Copied

>_ Output

			
				['item0', 'item1', 'item2', 'item3', 'item4', 'item5']

Podemos obter o comprimento de uma lista mediante a função len()

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		len(lista)
	
	Copied

>_ Output

As listas podem ter itens de diferentes tipos

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		lista = ['item0', 1, True, 5.3, "item4", 5, 6.6]
lista
	
	Copied

>_ Output

			
				['item0', 1, True, 5.3, 'item4', 5, 6.6]

Em Python, começa a contar a partir da posição 0, ou seja, se quisermos obter o primeiro elemento da lista

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		lista[0]
	
	Copied

>_ Output

			
				'item0'

Mas uma das coisas poderosas do Python é que, se quisermos acessar a última posição, podemos usar índices negativos

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		lista[-1]
	
	Copied

>_ Output

6.6

Se em vez da última posição da lista quisermos a penúltima

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		lista[-2]
	
	Copied

>_ Output

Se quisermos apenas um intervalo de valores, por exemplo, do segundo ao quinto item, acessamos através de [2:5]

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		lista[2:5]
	
	Copied

>_ Output

			
				[True, 5.3, 'item4']

Se o primeiro número do intervalo for omitido, significa que queremos do primeiro item da lista até o item indicado, ou seja, se quisermos do primeiro item até o quinto, usamos [:5]

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		lista[:5]
	
	Copied

>_ Output

			
				['item0', 1, True, 5.3, 'item4']

Se o último número do intervalo for omitido, isso significa que queremos do item indicado até o último. Ou seja, se quisermos do terceiro item até o último, usamos [3:].

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		lista[3:]
	
	Copied

>_ Output

			
				[5.3, 'item4', 5, 6.6]

Podemos escolher o range de itens também com números negativos, ou seja, se quisermos do antepenúltimo até o penúltimo usamos [-3:-1]. Isso é útil quando se tem listas cuja comprimento não se sabe, mas se sabe que se quer um range de valores do final, porque, por exemplo, a lista foi criada com medidas que vão sendo tomadas e se quer saber as últimas medidas.

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		lista[-3:-1]
	
	Copied

>_ Output

			
				['item4', 5]

Pode-se verificar se um item está na lista

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		'item4' in lista
	
	Copied

>_ Output

			
				True

2.3.1.1. Editar listas

As listas em Python são dinâmicas, ou seja, podem ser modificadas. Por exemplo, pode-se modificar o terceiro item.

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		lista[2] = False
lista
	
	Copied

>_ Output

			
				['item0', 1, False, 5.3, 'item4', 5, 6.6]

Também é possível modificar um intervalo de valores

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		lista[1:4] = [1.1, True, 3]
lista
	
	Copied

>_ Output

			
				['item0', 1.1, True, 3, 'item4', 5, 6.6]

Valores podem ser adicionados ao final da lista através do método append()

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		lista.append('item7')
lista
	
	Copied

>_ Output

			
				['item0', 1.1, True, 3, 'item4', 5, 6.6, 'item7']

O podemos inserir um valor em uma posição determinada através do método insert()

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		lista.insert(2, 'insert')
lista
	
	Copied

>_ Output

			
				['item0', 1.1, 'insert', True, 3, 'item4', 5, 6.6, 'item7']

Listas podem ser unidas através do método extend()

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		lista2 = ['item8', 'item9']
lista.extend(lista2)
lista
	
	Copied

>_ Output

			
				['item0', 1.1, 'insert', True, 3, 'item4', 5, 6.6, 'item7', 'item8', 'item9']

Não é necessário estender a lista através de outra lista, pode ser feito através de outro tipo de dado iterável do Python (tuplas, sets, dicionários, etc)

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		tupla = ('item10', 'item11')
lista.extend(tupla)
lista
	
	Copied

>_ Output

			
				['item0',
1.1,
'insert',
True,
3,
'item4',
5,
6.6,
'item7',
'item8',
'item9',
'item10',
'item11']

Podemos eliminar uma posição determinada mediante o método pop()

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		lista.pop(2)
lista
	
	Copied

>_ Output

			
				['item0',
1.1,
True,
3,
'item4',
5,
6.6,
'item7',
'item8',
'item9',
'item10',
'item11']

Se não for especificado o índice, o último item é removido.

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		lista.pop()
lista
	
	Copied

>_ Output

			
				['item0', 1.1, True, 3, 'item4', 5, 6.6, 'item7', 'item8', 'item9', 'item10']

Ou pode-se remover um item sabendo seu valor através do método remove()

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		lista.remove('item7')
lista
	
	Copied

>_ Output

			
				['item0', 1.1, True, 3, 'item4', 5, 6.6, 'item8', 'item9', 'item10']

Com a função del() também pode ser usada para eliminar um item da posição indicada.

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		del lista[3]
lista
	
	Copied

>_ Output

			
				['item0', 1.1, True, 'item4', 5, 6.6, 'item8', 'item9', 'item10']

Se não for indicado o índice, a lista completa é eliminada.

Com o método clear() eu deixo a lista vazia

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		lista.clear()
lista
	
	Copied

>_ Output

[]

Pode-se obter a quantidade de itens com um valor determinado através do método count()

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		lista = [5, 4, 6, 5, 7, 8, 5, 3, 1, 5]
lista.count(5)
	
	Copied

>_ Output

Também é possível obter o primeiro índice de um item com um valor determinado através do método index()

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		lista = [5, 4, 6, 5, 7, 8, 5, 3, 1, 5]
lista.index(5)
	
	Copied

>_ Output

2.3.1.2. Compreensão de lista

Podemos operar através da lista

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		fruits = ["apple", "banana", "cherry", "kiwi", "mango"]
newlist = []
 
# Iteramos por todos los items de la lista
for x in fruits:
  # Si el item contiene el caracter "a" lo añadimos a newlist
  if "a" in x:
    newlist.append(x)
 
newlist
	
	Copied

>_ Output

			
				['apple', 'banana', 'mango']

Outras das coisas potentes do Python são as list comprehensions, que permitem fazer tudo em uma única linha e deixar o código mais compacto.

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		fruits = ["apple", "banana", "cherry", "kiwi", "mango"]
 
newlist = [x for x in fruits if "a" in x]
 
newlist
	
	Copied

>_ Output

			
				['apple', 'banana', 'mango']

A sintaxe é a seguinte:

newlist = [expressão for item in iterável if condição == True]

Pode ser aproveitado para realizar operações na lista original

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		newlist = [x.upper() for x in fruits if "a" in x]
newlist
	
	Copied

>_ Output

			
				['APPLE', 'BANANA', 'MANGO']

2.3.1.3. Ordenar listas

Para ordenar listas usamos o método sort()

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		lista = [5, 8, 3, 4, 9, 5, 6]
lista.sort()
lista
	
	Copied

>_ Output

			
				[3, 4, 5, 5, 6, 8, 9]

Também as ordena alfabeticamente

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		lista = ["orange", "mango", "kiwi", "pineapple", "banana"]
lista.sort()
lista
	
	Copied

>_ Output

			
				['banana', 'kiwi', 'mango', 'orange', 'pineapple']

Ao ordenar alfabeticamente, distinga entre maiúsculas e minúsculas.

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		lista = ["orange", "mango", "kiwi", "Pineapple", "banana"]
lista.sort()
lista
	
	Copied

>_ Output

			
				['Pineapple', 'banana', 'kiwi', 'mango', 'orange']

Podem ser ordenados em ordem decrescente através do atributo reverse = True

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		lista = [5, 8, 3, 4, 9, 5, 6]
lista.sort(reverse = True)
lista
	
	Copied

>_ Output

			
				[9, 8, 6, 5, 5, 4, 3]

Podem ser ordenados da maneira que quisermos usando o atributo key

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		def myfunc(n):
  # devuelve el valor absoluto de n - 50
  return abs(n - 50)
 
lista = [100, 50, 65, 82, 23]
lista.sort(key = myfunc)
lista
	
	Copied

>_ Output

			
				[50, 65, 23, 82, 100]

Isso pode ser aproveitado para, por exemplo, na hora de ordenar, não distinguir entre maiúsculas e minúsculas

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		lista = ["orange", "mango", "kiwi", "Pineapple", "banana"]
lista.sort(key = str.lower)
lista
	
	Copied

>_ Output

			
				['banana', 'kiwi', 'mango', 'orange', 'Pineapple']

Pode-se inverter a lista usando o método reverse

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		lista = [5, 8, 3, 4, 9, 5, 6]
lista.reverse()
lista
	
	Copied

>_ Output

			
				[6, 5, 9, 4, 3, 8, 5]

2.3.1.4. Copiar listas

Não se pode copiar listas com lista1 = lista2, pois se lista1 for modificada, lista2 também será modificada.

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		lista1 = [5, 8, 3, 4, 9, 5, 6]
lista2 = lista1
lista1[0] = True
lista2
	
	Copied

>_ Output

			
				[True, 8, 3, 4, 9, 5, 6]

Portanto, é necessário usar o método copy()

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		lista1 = [5, 8, 3, 4, 9, 5, 6]
lista2 = lista1.copy()
lista1[0] = True
lista2
	
	Copied

>_ Output

			
				[5, 8, 3, 4, 9, 5, 6]

Ó hay que usar o construtor de listas list()

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		lista1 = [5, 8, 3, 4, 9, 5, 6]
lista2 = list(lista1)
lista1[0] = True
lista2
	
	Copied

>_ Output

			
				[5, 8, 3, 4, 9, 5, 6]

2.3.1.5. Concatenar listas

Listas podem ser concatenadas usando o operador +

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		lista1 = [5, 8, 3, 4, 9, 5, 6]
lista2 = ['a', 'b', 'c']
lista = lista1 + lista2
lista
	
	Copied

>_ Output

			
				[5, 8, 3, 4, 9, 5, 6, 'a', 'b', 'c']

O mediante o método extend

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		lista1 = [5, 8, 3, 4, 9, 5, 6]
lista2 = ['a', 'b', 'c']
lista1.extend(lista2)
lista1
	
	Copied

>_ Output

			
				[5, 8, 3, 4, 9, 5, 6, 'a', 'b', 'c']

Outra forma de concatenar é repetir a tupla X vezes mediante o operador *

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		lista1 = ['a', 'b', 'c']
lista2 = lista1 * 3
lista2
	
	Copied

>_ Output

			
				['a', 'b', 'c', 'a', 'b', 'c', 'a', 'b', 'c']

2.3.2. Tuplas

As tuplas são semelhantes às listas, guardam múltiplos itens em uma variável, podem conter itens de tipos diferentes, mas não podem ser modificadas nem reordenadas. São definidas através de (), com os itens separados por vírgulas.

Como não podem ser modificadas, as tuplas se executam um pouco mais rápido que as listas, portanto, se você não precisar modificar os dados, é melhor usar tuplas em vez de listas.

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		tupla = ('item0', 1, True, 3.3, 'item4', True)
tupla
	
	Copied

>_ Output

			
				('item0', 1, True, 3.3, 'item4', True)

Pode-se obter seu comprimento através da função len()

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		len (tupla)
	
	Copied

>_ Output

Para criar tuplas com um único elemento é necessário adicionar uma vírgula

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		tupla = ('item0',)
tupla, type(tupla)
	
	Copied

>_ Output

			
				(('item0',), tuple)

Para acessar um elemento da tupla, procede-se da mesma forma que com as listas.

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		tupla = ('item0', 1, True, 3.3, 'item4', True)
print(tupla[0])
print(tupla[-1])
print(tupla[2:4])
print(tupla[-4:-2])
	
	Copied

>_ Output

			
				item0
True
(True, 3.3)
(True, 3.3)

Podemos verificar se há um item na tupla

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		'item4' in tupla
	
	Copied

>_ Output

			
				True

2.3.2.1. Modificar tuplas

Embora as tuplas não sejam modificáveis, elas podem ser modificadas convertendo-as em listas, modificando a lista e, em seguida, convertendo-a de volta em uma tupla.

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		lista = list(tupla)
lista[4] = 'ITEM4'
tupla = tuple(lista)
tupla
	
	Copied

>_ Output

			
				('item0', 1, True, 3.3, 'ITEM4', True)

Ao convertê-la em lista, podemos fazer todas as modificações vistas nas listas

O que se pode é eliminar a tupla completa

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		del tupla
 
if 'tupla' not in locals():
  print("tupla eliminada")
	
	Copied

>_ Output

			
				tupla eliminada

2.3.2.2. Desempacotar tuplas

Quando criamos tuplas, na verdade estamos empacotando dados

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		tupla = ('item0', 1, True, 3.3, 'item4', True)
tupla
	
	Copied

>_ Output

			
				('item0', 1, True, 3.3, 'item4', True)

mas podemos desempacotá-los

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		item0, item1, item2, item3, item4, item5 = tupla
item0, item1, item2, item3, item4, item5
	
	Copied

>_ Output

			
				('item0', 1, True, 3.3, 'item4', True)

Se quisermos tirar menos dados que o comprimento da tupla, adicionamos um *

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		item0, item1, item2, *item3 = tupla
item0, item1, item2, item3
	
	Copied

>_ Output

			
				('item0', 1, True, [3.3, 'item4', True])

Pode colocar o asterisco * em outro lugar, se por exemplo o que desejamos é o último item.

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		item0, item1, *item2, item5 = tupla
item0, item1, item2, item5
	
	Copied

>_ Output

			
				('item0', 1, [True, 3.3, 'item4'], True)

2.3.2.3. Concatenar tuplas

Tuplas podem ser concatenadas utilizando o operador +

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		tupla1 = ("a", "b" , "c")
tupla2 = (1, 2, 3)
 
tupla3 = tupla1 + tupla2
tupla3
	
	Copied

>_ Output

			
				('a', 'b', 'c', 1, 2, 3)

Outra forma de concatenar é repetir a tupla X vezes mediante o operador *

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		tupla1 = ("a", "b" , "c")
 
tupla2 = tupla1 * 3
tupla2
	
	Copied

>_ Output

			
				('a', 'b', 'c', 'a', 'b', 'c', 'a', 'b', 'c')

2.3.2.4. Métodos das tuplas

As tuplas têm dois métodos, o primeiro é o método count() que retorna o número de vezes que um item aparece dentro da tupla.

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		tupla = (5, 4, 6, 5, 7, 8, 5, 3, 1, 5)
tupla.count(5)
	
	Copied

>_ Output

Outro método é index() que retorna a primeira posição de um item dentro da tupla.

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		tupla = (5, 4, 6, 5, 7, 8, 5, 3, 1, 5)
tupla.index(5)
	
	Copied

>_ Output

2.3.3. Intervalo

Com range() podemos criar uma sequência de números, começando de 0 (por padrão), incrementando em 1 (por padrão) e parando antes de um número especificado.

range(início, fim, passo)

Por exemplo, se quisermos uma sequência de 0 a 5 (sem incluir o 5)

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		for i in range(5):
  print(f'{i} ', end='')
	
	Copied

>_ Output

			
				0 1 2 3 4

Se por exemplo não quisermos que comece em 0

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		for i in range(2, 5):
  print(f'{i} ', end='')
	
	Copied

>_ Output

			
				2 3 4

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		for i in range(-2, 5):
  print(f'{i} ', end='')
	
	Copied

>_ Output

			
				-2 -1 0 1 2 3 4

Por último, se não quisermos que se incremente em 1, se por exemplo quisermos uma sequência de números pares.

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		for i in range(0, 10, 2):
  print(f'{i} ', end='')
	
	Copied

>_ Output

			
				0 2 4 6 8

2.4. Dicionários

Os dicionários são usados para armazenar dados em pares chave:valor. São modificáveis, não ordenados e não permitem duplicidades. São definidos usando os símbolos {}. Aceitam itens de diferentes tipos de dados.

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		diccionario = {
  "brand": "Ford",
  "model": "Mustang",
  "year": 1964,
  "colors": ["red", "white", "blue"]
}
diccionario
	
	Copied

>_ Output

			
				{'brand': 'Ford',
'model': 'Mustang',
'year': 1964,
'colors': ['red', 'white', 'blue']}

Como foi dito, não permitem duplicidades.

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		diccionario = {
  "brand": "Ford",
  "model": "Mustang",
  "year": 1964,
  "year": 2000,
  "colors": ["red", "white", "blue"]
}
diccionario["year"]
	
	Copied

>_ Output

Pode-se obter seu comprimento através da função len()

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		len(diccionario)
	
	Copied

>_ Output

Como se pode ver, a comprimento é 4 e não 5, pois year é contado apenas uma vez.

2.4.1. Acessar os itens

Para acessar, podemos fazer isso através de sua key

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		diccionario["model"]
	
	Copied

>_ Output

			
				'Mustang'

Também pode ser acessado através do método get

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		diccionario.get("model")
	
	Copied

>_ Output

			
				'Mustang'

Para saber todas as keys dos dicionários se pode usar o método keys()

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		diccionario.keys()
	
	Copied

>_ Output

			
				dict_keys(['brand', 'model', 'year', 'colors'])

Pode-se usar uma variável para apontar para as keys do dicionário, com o que chamando-a uma vez é necessário

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		diccionario = {
"brand": "Ford",
"model": "Mustang",
"year": 1964
}
 
# Se declara una vez la variable que apunta a las keys
x = diccionario.keys()
print(x)
 
# Se añade una nueva key
diccionario["color"] = "white"
 
# Se consulta la variable que apunta a las key
print(x)
	
	Copied

>_ Output

			
				dict_keys(['brand', 'model', 'year'])
dict_keys(['brand', 'model', 'year', 'color'])

Para obter os valores do dicionário, pode-se usar o método values()

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		diccionario.values()
	
	Copied

>_ Output

			
				dict_values(['Ford', 'Mustang', 1964, 'white'])

Pode-se usar uma variável para apontar para os values do dicionário, com isso, chamando-a uma vez é necessário.

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		diccionario = {
"brand": "Ford",
"model": "Mustang",
"year": 1964
}
 
# Se declara una vez la variable que apunta a los values
x = diccionario.values()
print(x)
 
# Se modifica un value
diccionario["year"] = 2020
 
# Se consulta la variable que apunta a los values
print(x)
	
	Copied

>_ Output

			
				dict_values(['Ford', 'Mustang', 1964])
dict_values(['Ford', 'Mustang', 2020])

Se items inteiros forem desejados, ou seja, keys e values, deve-se usar o método items().

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		diccionario.items()
	
	Copied

>_ Output

			
				dict_items([('brand', 'Ford'), ('model', 'Mustang'), ('year', 2020)])

Pode-se usar uma variável para apontar para os items do dicionário, com o que chamá-la uma vez é necessário

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		diccionario = {
"brand": "Ford",
"model": "Mustang",
"year": 1964
}
 
# Se declara una vez la variable que apunta a los items
x = diccionario.items()
print(x)
 
# Se modifica un value
diccionario["year"] = 2020
 
# Se consulta la variable que apunta a los items
print(x)
	
	Copied

>_ Output

			
				dict_items([('brand', 'Ford'), ('model', 'Mustang'), ('year', 1964)])
dict_items([('brand', 'Ford'), ('model', 'Mustang'), ('year', 2020)])

Pode-se verificar se uma key existe no dicionário

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		"model" in diccionario
	
	Copied

>_ Output

			
				True

2.4.2. Modificar os itens

Pode modificar um item acessando-o diretamente

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		diccionario = {
"brand": "Ford",
"model": "Mustang",
"year": 1964
}
 
# Se modifica un item
diccionario["year"] = 2020
 
diccionario
	
	Copied

>_ Output

			
				{'brand': 'Ford', 'model': 'Mustang', 'year': 2020}

Ou pode ser modificado através do método update()

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		diccionario = {
  "brand": "Ford",
  "model": "Mustang",
  "year": 1964
}
 
# Se modifica un item
diccionario.update({"year": 2020})
 
diccionario
	
	Copied

>_ Output

			
				{'brand': 'Ford', 'model': 'Mustang', 'year': 2020}

2.4.3. Adicionar itens

Pode adicionar um item adicionando-o desta maneira:

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		diccionario = {
"brand": "Ford",
"model": "Mustang",
"year": 1964
}
 
# Se modifica un item
diccionario["colour"] = "blue"
 
diccionario
	
	Copied

>_ Output

			
				{'brand': 'Ford', 'model': 'Mustang', 'year': 1964, 'colour': 'blue'}

Ou pode ser adicionado através do método update()

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		diccionario = {
  "brand": "Ford",
  "model": "Mustang",
  "year": 1964
}
 
# Se modifica un item
diccionario.update({"colour": "blue"})
 
diccionario
	
	Copied

>_ Output

			
				{'brand': 'Ford', 'model': 'Mustang', 'year': 1964, 'colour': 'blue'}

2.4.4. Remover itens

Pode-se eliminar um item com uma key específica mediante o método pop()

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		diccionario = {
  "brand": "Ford",
  "model": "Mustang",
  "year": 1964
}
 
# Se elimina un item
diccionario.pop("model")
 
diccionario
	
	Copied

>_ Output

			
				{'brand': 'Ford', 'year': 1964}

Ou se pode eliminar um item com uma key específica mediante del indicando o nome da key entre os símbolos []

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		diccionario = {
  "brand": "Ford",
  "model": "Mustang",
  "year": 1964
}
 
# Se elimina un item
del diccionario["model"]
 
diccionario
	
	Copied

>_ Output

			
				{'brand': 'Ford', 'year': 1964}

O dicionário inteiro é removido se del for usado e não for especificada a key de um item

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		diccionario = {
  "brand": "Ford",
  "model": "Mustang",
  "year": 1964
}
 
# Se elimina un item
del diccionario
 
if 'diccionario' not in locals():
  print("diccionario eliminado")
	
	Copied

>_ Output

			
				diccionario eliminado

Se popitem() é o método a ser usado se deseja remover o último item inserido.

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		diccionario = {
  "brand": "Ford",
  "model": "Mustang",
  "year": 1964
}
 
# Se elimina el último item introducido
diccionario.popitem()
 
diccionario
	
	Copied

>_ Output

			
				{'brand': 'Ford', 'model': 'Mustang'}

Se quer limpar o dicionário, é necessário usar o método clear()

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		diccionario = {
  "brand": "Ford",
  "model": "Mustang",
  "year": 1964
}
diccionario.clear()
diccionario
	
	Copied

>_ Output

{}

2.4.5. Copiar dicionários

Não se podem copiar dicionários mediante diccionario1 = diccionario2, já que se diccionario1 for modificado, diccionario2 também será modificado.

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		diccionario1 = {
  "brand": "Ford",
  "model": "Mustang",
  "year": 1964
}
diccionario2 = diccionario1
diccionario1["year"] = 2000
diccionario2["year"]
	
	Copied

>_ Output

Portanto, é necessário usar o método copy()

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		diccionario1 = {
  "brand": "Ford",
  "model": "Mustang",
  "year": 1964
}
diccionario2 = diccionario1.copy()
diccionario1["year"] = 2000
diccionario2["year"]
	
	Copied

>_ Output

Ó hay que usar o construtor de dicionários dict()

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		diccionario1 = {
  "brand": "Ford",
  "model": "Mustang",
  "year": 1964
}
diccionario2 = dict(diccionario1)
diccionario1["year"] = 2000
diccionario2["year"]
	
	Copied

>_ Output

2.4.6. Dicionários aninhados

Os dicionários podem ter items de qualquer tipo de dado, inclusive outros dicionários. A este tipo de dicionários se les denomina dicionários nested

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		diccionario_nested = {
  "child1" : {
    "name" : "Emil",
    "year" : 2004
  },
  "child2" : {
    "name" : "Tobias",
    "year" : 2007
  },
  "child3" : {
    "name" : "Linus",
    "year" : 2011
  }
}
diccionario_nested
	
	Copied

>_ Output

			
				{'child1': {'name': 'Emil', 'year': 2004},
'child2': {'name': 'Tobias', 'year': 2007},
'child3': {'name': 'Linus', 'year': 2011}}

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		child1 = {
  "name" : "Emil",
  "year" : 2004
}
child2 = {
  "name" : "Tobias",
  "year" : 2007
}
child3 = {
  "name" : "Linus",
  "year" : 2011
}
 
diccionario_nested = {
  "child1" : child1,
  "child2" : child2,
  "child3" : child3
}
 
diccionario_nested
	
	Copied

>_ Output

			
				{'child1': {'name': 'Emil', 'year': 2004},
'child2': {'name': 'Tobias', 'year': 2007},
'child3': {'name': 'Linus', 'year': 2011}}

2.4.7. Métodos dos dicionários

Estes são os métodos que podem ser usados em dicionários

2.4.8. Compreensão de dicionário

Igual que podíamos fazer list comprehensions mediante a sintaxe

list_comprehension = [expressão for item in iterável if condição == True]

Podemos fazer dictionaries comprehensions mediante a seguinte sintaxe

dictionary_comprehension = {expressão_chave: expressão_valor for item in iterável if condição == True}

Vamos ver um exemplo

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		dictionary_comprehension = {x: x**2 for x in (2, 4, 6) if x &gt; 2}
dictionary_comprehension
	
	Copied

>_ Output

			
				{4: 16, 6: 36}

2.5. Sets

2.5.1. Conjunto

Os sets são usados em Python para guardar um conjunto de itens em uma única variável. Eles podem armazenar itens de diferentes tipos. São não ordenados e não têm índice.

Diferem das listas em que não têm nem ordem nem índice.

São declarados com os símbolos {}

Como set é uma palavra reservada em Python, criamos um set com o nome set_

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		set_ = {'item0', 1, 5.3, "item4", 5, 6.6}
set_
	
	Copied

>_ Output

			
				{1, 5, 5.3, 6.6, 'item0', 'item4'}

Não pode haver itens duplicados, se encontrar algum item duplicado, fica apenas com um.

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		set_ = {'item0', 1, 5.3, "item4", 5, 6.6, 'item0'}
set_
	
	Copied

>_ Output

			
				{1, 5, 5.3, 6.6, 'item0', 'item4'}

Pode-se obter o comprimento do set através da função len()

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		len(set_)
	
	Copied

>_ Output

Como se pode ver, o comprimento do set é 6 e não 7, pois ele mantém apenas um 'item0'.

Pode-se verificar se um item está presente no set

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		'item4' in set_
	
	Copied

>_ Output

			
				True

2.5.1.1. Adicionar itens

Pode-se adicionar um elemento ao conjunto usando o método add()

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		set_.add(8.8)
set_
	
	Copied

>_ Output

			
				{1, 5, 5.3, 6.6, 8.8, 'item0', 'item4'}

Pode-se adicionar outro conjunto usando o método `update()'

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		set2 = {"item5", "item6", 7}
set_.update(set2)
set_
	
	Copied

>_ Output

			
				{1, 5, 5.3, 6.6, 7, 8.8, 'item0', 'item4', 'item5', 'item6'}

Também é possível adicionar itens de tipos de dados iteráveis de Python

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		lista = ["item9", 10, 11.2]
set_.update(lista)
set_
	
	Copied

>_ Output

			
				{1, 10, 11.2, 5, 5.3, 6.6, 7, 8.8, 'item0', 'item4', 'item5', 'item6', 'item9'}

2.5.1.2. Eliminar itens

Pode-se remover um item específico através do método remove()

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		set_.remove('item9')
set_
	
	Copied

>_ Output

			
				{1, 10, 11.2, 5, 5.3, 6.6, 7, 8.8, 'item0', 'item4', 'item5', 'item6'}

O mediante o discard()

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		set_.discard('item6')
set_
	
	Copied

>_ Output

			
				{1, 10, 11.2, 5, 5.3, 6.6, 7, 8.8, 'item0', 'item4', 'item5'}

Com o método pop() pode ser usado para remover o último item, mas como os sets não são ordenados, não há como saber qual é o último item. O método pop() retorna o item removido.

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		print(f"set antes de pop(): {set_}")
eliminado = set_.pop()
print(f"Se ha eliminado {eliminado}")
	
	Copied

>_ Output

			
				set antes de pop(): {1, 5, 5.3, 6.6, 8.8, 7, 10, 11.2, 'item5', 'item0', 'item4'}
Se ha eliminado 1

Por meio do método clear() é possível esvaziar o conjunto

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		set_.clear()
set_
	
	Copied

>_ Output

			
				set()

Por último, com del pode-se eliminar o set

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		del set_
 
if 'set_' not in locals():
  print("set eliminado")
	
	Copied

>_ Output

			
				set eliminado

2.5.1.3. Unir itens

Uma forma de unir conjuntos é mediante o método union()

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		set1 = {"a", "b" , "c"}
set2 = {1, 2, 3}
set3 = set1.union(set2)
set3
	
	Copied

>_ Output

			
				{1, 2, 3, 'a', 'b', 'c'}

Outra forma é através do método update(), mas desta maneira um set é adicionado a outro, não é criado um novo.

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		set1 = {"a", "b" , "c"}
set2 = {1, 2, 3}
set1.update(set2)
set1
	
	Copied

>_ Output

			
				{1, 2, 3, 'a', 'b', 'c'}

Estes métodos de união eliminam os duplicados, mas se quisermos obter os elementos duplicados em dois sets usamos o método intersection()

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		set1 = {"apple", "banana", "cherry"}
set2 = {"google", "microsoft", "apple"}
 
set3 = set1.intersection(set2)
set3
	
	Copied

>_ Output

			
				{'apple'}

Se quisermos obter os elementos duplicados em dois conjuntos, mas sem criar um novo conjunto, usamos o método intersection_update()

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		set1 = {"apple", "banana", "cherry"}
set2 = {"google", "microsoft", "apple"}
 
set1.intersection_update(set2)
set1
	
	Copied

>_ Output

			
				{'apple'}

Agora ao contrário, se quisermos ficar com os não duplicados usamos o método symmetric_difference().

A diferença entre isso e a união entre dois conjuntos é que na união são mantidos todos os itens, mas os que estão duplicados são pegos apenas uma vez. Agora ficamos com os que não estão duplicados.

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		set1 = {"apple", "banana", "cherry"}
set2 = {"google", "microsoft", "apple"}
 
set3 = set1.symmetric_difference(set2)
set3
	
	Copied

>_ Output

			
				{'banana', 'cherry', 'google', 'microsoft'}

Se quisermos ficar com os não duplicados sem criar um novo conjunto, usamos o método symmetric_difference_update()

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		set1 = {"apple", "banana", "cherry"}
set2 = {"google", "microsoft", "apple"}
 
set1.symmetric_difference_update(set2)
set1
	
	Copied

>_ Output

			
				{'banana', 'cherry', 'google', 'microsoft'}

2.5.1.4. Métodos dos conjuntos

Estes são os métodos que podem ser usados em sets

2.5.2. FrozenSet

Os frozensets são como os sets, mas com a diferença de que são imutáveis, assim como as tuplas são como as lists, mas imutáveis. Portanto, não podemos adicionar ou remover itens.

2.6. Booleanos

Há apenas dois booleanos em Python: True e False

Com a função bool() pode ser usada para avaliar se algo é True ou False

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		print(bool("Hello"))
print(bool(15))
print(bool(0))
	
	Copied

>_ Output

			
				True
True
False

2.6.1. Outros tipos de dados True e False

Os seguintes dados são True:

Qualquer string que não esteja vazia
Qualquer número exceto o 0
Qualquer lista, tupla, dicionário ou set que não esteja vazio

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		print(bool("Hola"))
print(bool(""))
	
	Copied

>_ Output

			
				True
False

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		print(bool(3))
print(bool(0))
	
	Copied

>_ Output

			
				True
False

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		lista = [1, 2, 3]
print(bool(lista))
 
lista = []
print(bool(lista))
	
	Copied

>_ Output

			
				True
False

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		tupla = (1, 2, 3)
print(bool(tupla))
 
tupla = ()
print(bool(tupla))
	
	Copied

>_ Output

			
				True
False

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		diccionario = {
  "brand": "Ford",
  "model": "Mustang",
  "year": 1964,
  "colors": ["red", "white", "blue"]
}
print(bool(diccionario))
 
diccionario.clear()
print(bool(diccionario))
	
	Copied

>_ Output

			
				True
False

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		set_ = {'item0', 1, 5.3, "item4", 5, 6.6}
print(bool(set_))
 
set_.clear()
print(bool(set_))
	
	Copied

>_ Output

			
				True
False

2.7. Binários

2.7.1. Bytes

O tipo bytes é uma sequência imutável de bytes. Apenas aceitam caracteres ASCII. Também se podem representar os bytes através de números inteiros cujos valores devem satisfazer 0 <= x < 256

Para criar um tipo byte devemos introduzir antes o caractere b

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		byte = b"MaximoFN"
byte
	
	Copied

>_ Output

			
				b'MaximoFN'

Também podem ser criados através do seu construtor bytes()

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		byte = bytes(10)
byte
	
	Copied

>_ Output

b''

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		byte = bytes(range(10))
byte
	
	Copied

>_ Output

			
				b'	'

Bytes podem ser concatenados utilizando o operador +

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		byte1 = b'DeepMax'
byte2 = b'FN'
byte3 = byte1 + byte2
byte3
	
	Copied

>_ Output

			
				b'DeepMaxFN'

Ou através da repetição com o operador *

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		byte1 = b'MaximoFN '
byte2 = byte1 * 3
byte2
	
	Copied

>_ Output

			
				b'MaximoFN MaximoFN MaximoFN '

Podemos verificar se um caractere está dentro da string

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		b'D' in byte1
	
	Copied

>_ Output

			
				False

Estes são os métodos que podem ser usados em bytes

2.7.2. Bytearray

Os bytearrays são iguais aos bytes só que são mutáveis.

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		byte_array = bytearray(b'MaximoFN')
byte_array
	
	Copied

>_ Output

			
				bytearray(b'MaximoFN')

2.7.3. MemoryView

Os objetos memoryview permitem que o código Python acesse os dados internos de um objeto que suporta o protocolo de buffer sem realizar cópias.

A função memoryview() permite o acesso direto de leitura e escrita aos dados orientados a bytes de um objeto sem necessidade de copiá-los primeiro. Isso pode gerar grandes ganhos de desempenho ao operar com objetos grandes, pois não cria uma cópia ao fatiar.

Protocolo de buffer, pode criar outro objeto de acesso para modificar dados grandes sem copiá-los. Isso faz com que o programa utilize menos memória e aumente a velocidade de execução.

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		byte_array = bytearray('XYZ', 'utf-8')
print(f'Antes de acceder a la memoria: {byte_array}')
 
mem_view = memoryview(byte_array)
 
mem_view[2]= 74
print(f'Después de acceder a la memoria: {byte_array}')
	
	Copied

>_ Output

			
				Antes de acceder a la memoria: bytearray(b'XYZ')
Después de acceder a la memoria: bytearray(b'XYJ')

3. Operadores

3.1. Operadores aritméticos

Operador soma +

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		3 + 5
	
	Copied

>_ Output

Operador subtração -

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		3 - 5
	
	Copied

>_ Output

-2

Operador de multiplicação *

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		3 * 5
	
	Copied

>_ Output

Operador divisão /

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		3 / 5
	
	Copied

>_ Output

0.6

Operador módulo %. Retorna o resto de uma divisão.

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		25 % 2
	
	Copied

>_ Output

Operador exponencial **

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		5 ** 2
	
	Copied

>_ Output

Operador divisão inteira //

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		25 // 2
	
	Copied

>_ Output

3.2. Operadores de comparação

Operador é igual ==

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		1 == 1
	
	Copied

>_ Output

			
				True

Operador diferente !=

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		1 != 2
	
	Copied

>_ Output

			
				True

Operador é maior que >

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		3 &gt; 2
	
	Copied

>_ Output

			
				True

Operador é menor que <

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		2 &lt; 3
	
	Copied

>_ Output

			
				True

Operador é maior ou igual que >=

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		3 &gt;= 3
	
	Copied

>_ Output

			
				True

Operador é menor ou igual que <=

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		3 &lt;= 3
	
	Copied

>_ Output

			
				True

3.3. Operadores lógicos

Operador and

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		True and True
	
	Copied

>_ Output

			
				True

Operador or

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		True or False
	
	Copied

>_ Output

			
				True

Operador not

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		not False
	
	Copied

>_ Output

			
				True

34. Operadores de identidade

Operador is

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		5.3 is 5.3
	
	Copied

>_ Output

			
				True

Operador is not

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		5.3 is not 5
	
	Copied

>_ Output

			
				True

35. Operadores de pertinência

Operador in

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		x = ["apple", "banana"]
 
"banana" in x
	
	Copied

>_ Output

			
				True

Operador not in

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		x = ["apple", "banana"]
 
"orange" not in x
	
	Copied

>_ Output

			
				True

36. Operadores bit a bit

Operador AND &

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		a = 60 # 60 = 0011 1100 
b = 13 # 13 = 0000 1101 
 
c = a &amp; b; # 12 = 0000 1100
c
	
	Copied

>_ Output

Operador OU |

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		a = 60 # 60 = 0011 1100 
b = 13 # 13 = 0000 1101 
 
c = a | b; # 61 = 0011 1101
c
	
	Copied

>_ Output

Operador XOR ^

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		a = 60 # 60 = 0011 1100 
b = 13 # 13 = 0000 1101 
 
c = a ^ b; # 49 = 0011 0001
c
	
	Copied

>_ Output

Operador NOT ~

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		a = 60 # 60 = 0011 1100 
 
c = ~a; # -61 = 1100 0011
c
	
	Copied

>_ Output

-61

Operador de deslocamento para a esquerda <<

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		a = 60 # 60 = 0011 1100 
 
c = a &lt;&lt; 2; # 240 = 1111 0000
c
	
	Copied

>_ Output

Operador de deslocamento para a direita >>

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		a = 60 # 60 = 0011 1100 
 
c = a &gt;&gt; 2; # 15 = 0000 1111
c
	
	Copied

>_ Output

37. Operadores de atribuição

Operador =

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		a = 5
a
	
	Copied

>_ Output

Operador +=. x += y é equivalente a x = x + y

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		a += 5
a
	
	Copied

>_ Output

Operador -=. x -= y é equivalente a x = x - y

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		a -= 5
a
	
	Copied

>_ Output

Operador *=. x *= y é equivalente a x = x * y

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		a *= 3
a
	
	Copied

>_ Output

Operador /=. x /= y é equivalente a x = x / y

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		a /= 3
a
	
	Copied

>_ Output

5.0

Operador %=. x %= y é equivalente a x = x % y

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		a = 25
a %= 2
a
	
	Copied

>_ Output

Operador //=. x //= y é equivalente a x = x // y

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		a = 25
a //= 2
a
	
	Copied

>_ Output

Operador **=. x **= y é equivalente a x = x ** y

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		a = 5
a **= 2
a
	
	Copied

>_ Output

Operador &=. x &= y é equivalente a x = x & y

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		a = 60 # 60 = 0011 1100 
b = 13 # 13 = 0000 1101 
 
a &amp;= b; # 12 = 0000 1100
a
	
	Copied

>_ Output

Operador |=. x |= y é equivalente a x = x | y

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		a = 60 # 60 = 0011 1100 
b = 13 # 13 = 0000 1101 
 
a |= b; # 61 = 0011 1101
a
	
	Copied

>_ Output

Operador ^=. x ^= y é equivalente a x = x ^ y

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		a = 60 # 60 = 0011 1100 
b = 13 # 13 = 0000 1101 
 
a ^= b; # 49 = 0011 0001
a
	
	Copied

>_ Output

Operador >>=. x >>= y é equivalente a x = x >> y

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		a = 60 # 60 = 0011 1100 
 
a &lt;&lt;= 2; # 240 = 1111 0000
a
	
	Copied

>_ Output

Operador <<=. x <<= y é equivalente a x = x << y

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		a = 60 # 60 = 0011 1100 
 
a &gt;&gt;= 2; # 15 = 0000 1111
a
	
	Copied

>_ Output

4. Controle de fluxo

Para poder utilizar as ferramentas de controle de fluxo é necessário adicionar a sentença, dois pontos : e em uma nova linha escrever o código com indentação.

Diferente de outras linguagens, Python precisa de indentação (adicionar um espaço em branco) para definir o código dentro de uma ferramenta de Controle de Fluxo.

4.1. Se

Com if podemos criar condicionais

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		if len('MaximoFN') == 8:
  print('MaximoFN tiene 8 caracteres')
	
	Copied

>_ Output

			
				MaximoFN tiene 8 caracteres

Se quisermos criar mais de uma condição, podemos usar elif.

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		if len('MaximoFN') &lt; 8:
  print('MaximoFN tiene menos de 8 caracteres')
elif len('MaximoFN') == 8:
  print('MaximoFN tiene 8 caracteres')
	
	Copied

>_ Output

			
				MaximoFN tiene 8 caracteres

Se quisermos que se execute algo em caso de que não se cumpra nenhuma das condições indicadas, podemos usar else

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		if len('MaximoFN') &lt; 8:
  print('MaximoFN tiene menos de 8 caracteres')
elif len('MaximoFN') &gt; 8:
  print('MaximoFN tiene más de 8 caracteres')
else:
  print('MaximoFN tiene 8 caracteres')
	
	Copied

>_ Output

			
				MaximoFN tiene 8 caracteres

Se quisermos escrever tudo em uma única linha

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		if len('MaximoFN') == 8: print('MaximoFN tiene 8 caracteres')
	
	Copied

>_ Output

			
				MaximoFN tiene 8 caracteres

Igual, se quisermos escrever tudo em uma linha, mas com várias condições.

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		print('MaximoFN tiene menos de 8 caracteres') if len('MaximoFN') &lt; 8 else print('MaximoFN tiene más de 8 caracteres') if len('MaximoFN') &gt; 8 else print('MaximoFN tiene 8 caracteres')
	
	Copied

>_ Output

			
				MaximoFN tiene 8 caracteres

Se quisermos fazer a estrutura do if mas não quisermos, por enquanto, codificar uma das condições, podemos usar pass

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		if len('MaximoFN') &lt; 8:
  print('MaximoFN tiene menos de 8 caracteres')
elif len('MaximoFN') &gt; 8:
  pass
else:
  print('MaximoFN tiene 8 caracteres')
	
	Copied

>_ Output

			
				MaximoFN tiene 8 caracteres

4.2. Enquanto

O bloco while é executado enquanto a condição for True

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		i = 0
string = 'MaximoFN'
while len(string) &gt; i:
  print(string[i], end='')
  i += 1
	
	Copied

>_ Output

			
				MaximoFN

Se quisermos que o bucle pare por alguma condição usamos break

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		i = 0
string = 'MaximoFN'
while len(string) &gt; i:
  if string[i] == 'F':
    break
  print(string[i], end='')
  i += 1
	
	Copied

>_ Output

			
				Maximo

Se quisermos que uma das iterações não se execute por algum motivo, usamos continue

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		i = 0
string = 'Maximo FN'
while len(string) &gt; i:
  if string[i] == ' ':
    i += 1
    continue
  print(string[i], end='')
  i += 1
	
	Copied

>_ Output

			
				MaximoFN

Com else é possível executar um bloco de código se a condição do while não for True

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		i = 0
string = 'MaximoFN'
 
while len(string) &gt; i:
  print(string[i], end='')
  i += 1
else:
  print("
Se ha terminado el while")
	
	Copied

>_ Output

			
				MaximoFN
Se ha terminado el while

4.3. Para

O bloco for é usado para executar código enquanto itera por uma sequência, esta sequência pode ser qualquer elemento iterável de Python (string, lista, tupla, range, dicionário, set)

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		string = 'MaximoFN'
 
for x in string:
  print(x, end='')
	
	Copied

>_ Output

			
				MaximoFN

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		lista = ['M', 'a', 'x', 'i', 'm', 'o', 'F', 'N']
 
for x in lista:
  print(x, end='')
	
	Copied

>_ Output

			
				MaximoFN

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		tupla = ('M', 'a', 'x', 'i', 'm', 'o', 'F', 'N')
 
for x in tupla:
  print(x, end='')
	
	Copied

>_ Output

			
				MaximoFN

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		string = 'MaximoFN'
 
for i in range(len(string)):
  print(string[i], end='')
	
	Copied

>_ Output

			
				MaximoFN

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		diccionario = {
  "letra1": "M",
  "letra2": "a",
  "letra3": "x",
  "letra4": "i",
  "letra5": "m",
  "letra6": "o",
  "letra7": "F",
  "letra8": "N",
}
 
for x in diccionario.values():
  print(x, end='')
	
	Copied

>_ Output

			
				MaximoFN

Também se pode iterar pelos sets, mas como são elementos não ordenados, não teremos controle sobre a ordem de execução.

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		set_ = {'M', 'a', 'x', 'i', 'm', 'o', 'F', 'N'}
 
for x in set_:
  print(x, end='')
	
	Copied

>_ Output

			
				NximoaMF

Se quisermos que o bucle pare por alguma condição usamos break

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		string = 'MaximoFN'
 
for x in string:
  if x == 'F':
    break
  print(x, end='')
	
	Copied

>_ Output

			
				Maximo

Se quisermos que uma das iterações não se execute por algum motivo, usamos continue

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		string = 'Maximo FN'
 
for x in string:
  if x == ' ':
    continue
  print(x, end='')
	
	Copied

>_ Output

			
				MaximoFN

Com else é possível executar um bloco de código se a condição do while não for True

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		string = 'MaximoFN'
 
for x in string:
  print(x, end='')
else:
  print("
Se ha terminado el for")
	
	Copied

>_ Output

			
				MaximoFN
Se ha terminado el for

Se por exemplo, se quisermos fazer a estrutura do for mas não quisermos, por enquanto, codificar seu interior, podemos usar pass

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		string = 'MaximoFN'
for x in string:
  pass
print('Interior del for no codificado')
	
	Copied

>_ Output

			
				Interior del for no codificado

5. Funções

Uma função é uma porção de código que pode ser executada tantas vezes quantas quiser. Ela pode receber argumentos e pode devolver dados como resultado.

Para definir uma função, começa-se com a palavra reservada def, seguida do nome da função, parênteses (), dois pontos : e, em seguida, na linha seguinte, o código da função indentado.

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		def funcion():
  print('MaximoFN')
	
	Copied

Para chamar a função, basta escrever seu nome.

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		funcion()
	
	Copied

>_ Output

			
				MaximoFN

As funções podem receber todos os argumentos que se deseja, dentro dos parênteses e separados por vírgulas.

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		def funcion(string1, string2):
  print(string1 + ' ' + string2)
 
funcion("Hola", "MaximoFN")
	
	Copied

>_ Output

			
				Hola MaximoFN

Quando se chama a função, deve-se passar o mesmo número de argumentos que foram declarados. Se forem passados mais ou menos, obteremos um Erro.

Se *args é usado quando não sabemos quantos argumentos a função vai receber. Isso significa que podemos passar um número variável de argumentos.

Ao fazer isso, passamos uma tupla (lembrando que ela é imutável) com os argumentos

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		def funcion(*argumentos):
  numero_argumentos = len(argumentos)
 
  for i in range(numero_argumentos):
    print(argumentos[i], end=' ')
 
funcion("funcion", "con", "varios", "argumentos", "sin", "especificar", "cuantos")
	
	Copied

>_ Output

			
				funcion con varios argumentos sin especificar cuantos

Em caso de não saber a ordem dos argumentos de uma função, podemos indicar o argumento que queremos passar indicando seu nome.

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		def funcion(argumento1, argumento2, argumento3):
  print(argumento1 + ' '+ argumento2 + ' ' + argumento3)
 
funcion(argumento3 = "MaximoFN", argumento1 = "Blog", argumento2 = "de")
	
	Copied

>_ Output

			
				Blog de MaximoFN

Em caso de querer passar os argumentos com seus nomes, mas em caso de não saber quantos argumentos vão ser passados, pode usar **kwargs. Neste caso, será passado um dicionário com os argumentos.

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		def funcion(**kargumentos):
  print("Autor del blog: " + kargumentos["autor"])
 
funcion(blog = "Blog", pertenencia = "de", autor = "MaximoFN")
	
	Copied

>_ Output

			
				Autor del blog: MaximoFN

Se quisermos que algum argumento tenha um valor padrão, podemos indicá-lo entre os parênteses da função. Dessa forma, se na hora de chamar a função não for passado esse argumento, este na função terá o valor padrão.

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		def funcion(argumento1, argumento2, argumento3 = "MaximoFN"):
  print(argumento1 + ' '+ argumento2 + ' ' + argumento3)
 
funcion("Blog", "de")
	
	Copied

>_ Output

			
				Blog de MaximoFN

Pode passar qualquer tipo de dado como argumento. Por exemplo, se você passar uma lista como argumento, dentro da função, esse argumento será tratado como uma lista

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		def funcion(argumento):
  longitud_lista = len(argumento)
 
  for i in range(longitud_lista):
    print(argumento[i], end=' ')
 
funcion(["Blog", "de", "MaximoFN"])
	
	Copied

>_ Output

			
				Blog de MaximoFN

As funções podem devolver dados, isso é feito através da palavra reservada return

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		def funcion(argumento):
  longitud_lista = len(argumento)
  string = ""
 
  for i in range(longitud_lista):
    string = string + argumento[i] + ' '
 
  return string
 
print(funcion(["Blog", "de", "MaximoFN"]))
	
	Copied

>_ Output

			
				Blog de MaximoFN

Podem devolver mais de um dado

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		def funcion(argumento):
  longitud_lista = len(argumento)
  string0 = argumento[0]
  string1 = argumento[1]
  string2 = argumento[2]
 
  return string0, string1, string2
 
dato0, dato1, dato2 = funcion(["Blog", "de", "MaximoFN"])
 
print(dato0 + ' ' + dato1 + ' ' + dato2)
	
	Copied

>_ Output

			
				Blog de MaximoFN

Se um dos dados devolvidos não nos interessar, podemos ignorá-lo utilizando _

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		def funcion(argumento):
  longitud_lista = len(argumento)
  string0 = argumento[0]
  string1 = argumento[1]
  string2 = argumento[2]
 
  return string0, string1, string2
 
_, _, dato_de_interes = funcion(["Blog", "de", "MaximoFN"])
 
print(dato_de_interes)
	
	Copied

>_ Output

			
				MaximoFN

Se quisermos criar a estrutura da função, mas não quisermos, por enquanto, codificar o interior, podemos usar pass

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		def funcion():
  pass
 
funcion()
	
	Copied

A função pode chamar a si mesma, a isso se chama recursão ou recursividade da função.

Por exemplo, podemos usar esta qualidade para calcular o fatorial de um número

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		def factorial(n):
  if n == 0 or n == 1:
    return 1
  else:
    return n * factorial(n-1)
 
factorial(5)
	
	Copied

>_ Output

5.1. Funções integradas

Há uma série de funções já definidas em Python que podem ser usadas, como, por exemplo, a função abs(), que retorna o valor absoluto.

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		abs(-5)
	
	Copied

>_ Output

A seguir-se uma lista dessas funções

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		import builtins
 
dir(builtins)
	
	Copied

>_ Output

			
				['ArithmeticError',
'AssertionError',
'AttributeError',
'BaseException',
'BlockingIOError',
'BrokenPipeError',
'BufferError',
'BytesWarning',
'ChildProcessError',
'ConnectionAbortedError',
'ConnectionError',
'ConnectionRefusedError',
'ConnectionResetError',
'DeprecationWarning',
'EOFError',
'Ellipsis',
'EnvironmentError',
'Exception',
'False',
'FileExistsError',
'FileNotFoundError',
'FloatingPointError',
'FutureWarning',
'GeneratorExit',
'IOError',
'ImportError',
'ImportWarning',
'IndentationError',
'IndexError',
'InterruptedError',
'IsADirectoryError',
'KeyError',
'KeyboardInterrupt',
'LookupError',
'MemoryError',
'ModuleNotFoundError',
'NameError',
'None',
'NotADirectoryError',
'NotImplemented',
'NotImplementedError',
'OSError',
'OverflowError',
'PendingDeprecationWarning',
'PermissionError',
'ProcessLookupError',
'RecursionError',
'ReferenceError',
'ResourceWarning',
'RuntimeError',
'RuntimeWarning',
'StopAsyncIteration',
'StopIteration',
'SyntaxError',
'SyntaxWarning',
'SystemError',
'SystemExit',
'TabError',
'TimeoutError',
'True',
'TypeError',
'UnboundLocalError',
'UnicodeDecodeError',
'UnicodeEncodeError',
'UnicodeError',
'UnicodeTranslateError',
'UnicodeWarning',
'UserWarning',
'ValueError',
'Warning',
'ZeroDivisionError',
'__IPYTHON__',
'__build_class__',
'__debug__',
'__doc__',
'__import__',
'__loader__',
'__name__',
'__package__',
'__spec__',
'abs',
'all',
'any',
'ascii',
'bin',
'bool',
'breakpoint',
'bytearray',
'bytes',
'callable',
'chr',
'classmethod',
'compile',
'complex',
'copyright',
'credits',
'delattr',
'dict',
'dir',
'display',
'divmod',
'enumerate',
'eval',
'exec',
'filter',
'float',
'format',
'frozenset',
'get_ipython',
'getattr',
'globals',
'hasattr',
'hash',
'help',
'hex',
'id',
'input',
'int',
'isinstance',
'issubclass',
'iter',
'len',
'license',
'list',
'locals',
'map',
'max',
'memoryview',
'min',
'next',
'object',
'oct',
'open',
'ord',
'pow',
'print',
'property',
'range',
'repr',
'reversed',
'round',
'set',
'setattr',
'slice',
'sorted',
'staticmethod',
'str',
'sum',
'super',
'tuple',
'type',
'vars',
'zip']

5.2. Documentação de uma função

Pode-se adicionar uma explicação de uma função que criamos por meio de um comentário no início da função, dessa forma quando chamarmos a função built in help() ela mostrará essa explicação.

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		def funcion():
  "Esta es la explicación de la función"
 
  None
 
help(funcion)
	
	Copied

>_ Output

			
				Help on function funcion in module __main__:
funcion()
    Esta es la explicación de la función

Outra opção para ver a explicação da função é usar o método __doc__ da função

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		funcion.__doc__
	
	Copied

>_ Output

			
				'Esta es la explicación de la función'

5.3. Decoradores

Os decoradores são uma funcionalidade do Python que permitem adicionar características novas a uma função.

Cria-se uma função decoradora que tem como parâmetro outra função. Então, a função decoradora adiciona a nova característica à função que recebe.

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		def decorador(parametro_funcion):
  """Agrega barritas arriba y abajo de la funcion"""
 
  def envoltorio():
    """Aplica las barritas al texto"""
 
    print("==================")
    parametro_funcion()
    print("==================")
      
  return envoltorio
 
def funcion():
  print("MaximoFN")
 
funcion_envoltorio = decorador(funcion)
 
print('Función sin decoradores: ')
funcion()
 
print('
Función con decoradores: ')
funcion_envoltorio()
	
	Copied

>_ Output

			
				Función sin decoradores:
MaximoFN
Función con decoradores:
==================
MaximoFN
==================

Mas uma maneira mais potente de usar decoradores é através do uso de @ e o nome do decorador antes da função.

Isto é, primeiro se define o decorador e em seguida se chama uma função com o decorador definido.

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		def decorador2(parametro_funcion2):
  """Agrega barritas arriba y abajo de la funcion"""
 
  def envoltorio2():
    """Aplica las barritas al texto"""
 
    print("==================")
    parametro_funcion2()
    print("==================")
      
  return envoltorio2
 
@decorador2
def funcion2():
  print("MaximoFN")
 
print('Función con decoradores: ')
funcion2()
	
	Copied

>_ Output

			
				Función con decoradores:
==================
MaximoFN
==================

5.4. `*args` e `**kwargs`

*args e **kwargs são argumentos opcionais que podem ser usados ao definir uma função em Python. A sintaxe é a seguinte:

def minha_funcao(arg1, arg2, *args, **kwargs):
          # código da função aqui

2.5.1. `*args`

*args é usado para enviar um número variável de argumentos para uma função. Ao usar *args, você pode enviar uma quantidade variável de argumentos para a função sem precisar o número exato de argumentos que a função precisa. Os argumentos são recebidos na função como uma tupla.

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		def saludo(saludo, *nombres):
    for nombre in nombres:
        print(f"{saludo}, {nombre}")
 
saludo("Hola", "Alicia", "Roberto", "Carlos")
	
	Copied

>_ Output

			
				Hola, Alicia
Hola, Roberto
Hola, Carlos

2.5.4.2. `**kwargs`

**kwargs é usado da mesma maneira, mas para enviar um número variável de argumentos com palavras-chave (keyword arguments) para uma função. Ao usar **kwargs, você pode enviar uma quantidade variável de argumentos para a função e especificar o valor de cada argumento usando seu nome. Os argumentos são recebidos na função como um Dicionário.

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		def saludo(saludo, **personas):
    for key, value in personas.items():
        print(f"{saludo} {key}, tu edad es {value} años")
 
saludo("Hola", Juan=22, Maria=32, Pedro=25)
	
	Copied

>_ Output

			
				Hola Juan, tu edad es 22 años
Hola Maria, tu edad es 32 años
Hola Pedro, tu edad es 25 años

6. Funções Adicionais

6.1. Funções lambda

A função *lambda* é uma pequena função anônima.

A função *lambda* pode tomar qualquer número de argumentos, mas só pode ter uma expressão.

As funções *lambda* são definidas da seguinte maneira:

lambda argumentos : expressão

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		x = lambda a : a + 10
print(x(5))
	
	Copied

>_ Output

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		x = lambda a, b, c : a + b + c
print(x(5, 6, 2))
	
	Copied

>_ Output

O poder de *lambda* mostra-seu melhor quando as usa como uma função anônima dentro de outra função.

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		def myfunc(n):
  return lambda a : a * n
 
mydoubler = myfunc(2)
mytripler = myfunc(3)
 
print(f"mydoubler: {mydoubler(11)}")
print(f"mytripler: {mytripler(11)}")
	
	Copied

>_ Output

			
				mydoubler: 22
mytripler: 33

6.2. Função `map`

A função map permite aplicar uma função a cada elemento de uma estrutura iterável.

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		lista = [1, 2, 3]
 
def funcion_mas_1(valor):
  return valor + 1
 
lista_modificada = list(map(funcion_mas_1, lista))
lista_modificada
	
	Copied

>_ Output

			
				[2, 3, 4]

Isto é equivalente a usar list comprehension

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		lista_modificada = [funcion_mas_1(x) for x in lista]
lista_modificada
	
	Copied

>_ Output

			
				[2, 3, 4]

6.3. Função `filter`

A função filter permite selecionar os elementos de uma estrutura iterável que cumpram com uma condição

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		lista = [1, 2, 3, 4, 5, 6, 7]
 
def esPar(valor):
  return valor % 2 == 0
 
lista_filtrada = list(filter(esPar, lista))
lista_filtrada
	
	Copied

>_ Output

			
				[2, 4, 6]

Isto é equivalente a usar list comprehension

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		lista_filtrada = [x for x in lista if esPar(x)]
lista_filtrada
	
	Copied

>_ Output

			
				[2, 4, 6]

6.4. Função `reduce`

A função reduce permite realizar tarefas acumulativas sobre estruturas iteráveis.

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		from functools import reduce
 
lista = [1, 22, 33]
 
def acumular(valor, acumulador):
  print(f'valor = {valor}, acumulador = {acumulador}, acumulacion = {valor + acumulador}')
  return valor + acumulador
 
acumulacion = reduce(acumular, lista)
print(f'
acumulacion = {acumulacion}')
	
	Copied

>_ Output

			
				valor = 1, acumulador = 22, acumulacion = 23
valor = 23, acumulador = 33, acumulacion = 56
acumulacion = 56

6.5. Função `zip`

Com a função zip, é possível combinar várias estruturas iteráveis em uma única, ou seja, permite agrupar vários elementos das estruturas *A_x* em uma única estrutura *B*. A estrutura *B* é formada por tuplas dos elementos das estruturas *A_x*.

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		nombres = ["Manolo", "Andres", "Fernando"]
altura = [181, 178, 180]
 
my_zip = list(zip(nombres, altura))
my_zip
	
	Copied

>_ Output

			
				[('Manolo', 181), ('Andres', 178), ('Fernando', 180)]

6.5. Geradores

Suponhamos que queremos iterar sobre uma sequência de números, mas de uma maneira especial que não nos oferece nenhum tipo de bucle. Isso podemos resolver com os geradores. Para poder fazer isso, a função geradora não tem que devolver o valor com return, mas com yield para que saiba que tem que seguir iterando.

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		def iterador_custom(N):
    for i in range (N):
        if i % 3 == 0:
            yield i
 
generador = iterador_custom(20)
for i in generador:
    print(i)
	
	Copied

>_ Output

Acabamos de fazer um iterador por números múltiplos de 3

6.6. Funções de ordem superior

Podemos criar funções que recebem outras funções como parâmetros, de maneira que a função que recebe outra função como parâmetro é chamada de função de ordem superior (high order function). Vejamos um exemplo

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		def increment(x):
    return x + 1
 
def hof(f, x):
    return 2*f(x)
 
print(hof(increment, 3))
	
	Copied

>_ Output

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.

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

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 se cria um objeto da classe. Esta função é denominada *dunder init* e é escrita __init__(). À função *dunder init* deve-se sempre passar a variável self, que indica a própria classe, e em seguida, as variáveis que se deseja passar.

Com esta função, geralmente se inicializam as variáveis das classes ou se executa 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. A estas funções chamamos *métodos* da classe. A estes *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 deve ser sempre o mesmo. Mas por convenção, geralmente se usa 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

As variáveis dos objetos podem ser modificadas.

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

>_ Output

			
				Hola mi nombre es Marta y tengo 36 años

Até eliminá-las

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		del objeto_persona.nombre
	
	Copied

Também é possível eliminar o objeto inteiro.

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		del objeto_persona
	
	Copied

Se quisermos, por exemplo, criar 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 **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, é necessário indicar entre parênteses, no momento de declarar a classe, de qual classe ela herda.

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

E no momento de criar o objeto da classe filha, passam-se 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 reescreve a função *dunder init*, se quisermos que seja chamada a função *dunder init* da classe pai, temos que chamá-la.

Para isso, existem duas maneiras: uma é através do nome da classe pai. Nesse caso, é necessário 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 é através 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 último, podem adicionar 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 tivermos 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): sobrecarrega 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 de arredondamento (//).
__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 para a direita (>>).
__and__(self, other): sobrecarrega o operador de and (&).
__or__(self, other): sobrecarrega o operador de 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 (!=).
__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 no o tópico 2 (Tipos de dados do Python), existem alguns tipos de dados sobre os quais podemos 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 loops 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

Podemos nos interesar llamar a un objeto de uma função como se fosse uma classe. Isto pode ser conseguido adicionando a função __call__ à classe.

(Note: There seems to be a mix of Spanish and Portuguese in the original text. I've translated it to Portuguese, but the original text might need some adjustments for consistency.)

Here is the corrected Portuguese translation:

Podemos nos interessar em chamar a um a objeto:

Pod we interest to Portuguese:

Podemos the texto:

Note) as:

Podemos__Pod) interest to função) função__) a função) função) function) chamar a função__) que) função função uma port the, que a following:

a) to-:

__ a `) a função) função a function) to to:

__ função )-se em ( ( ( ) a função (.. function functionar a a a que que a function function function a function )__ que a a função to uma to função a following a __ a .

a função ` Portuguese:

Portuguese the function a to that, but a a a ` a:

function `__.

the function a function a function to a a a a a function called a function method a function:

a function. a function a to the function be called to the. a ability to , function se function function a function ` called to a function.

to call function to function function a function to a function. a to the function of calling the function a function to a function be called function to Portuguese the function a function to the class to the ability to the class se function to be called a function.

a function ser function a function have , but the function call to the class.

the function to be called function to the called to the Portuguese:

function:

the function to be called:

a function ` a way of a call to function to have function:

to function __call a function to call a to call the function ` be called to:

the function to be called to the function, have the ability to be called to a function, being a ability to call a object.

a function to the object.

the function.

function function.. function ` function to be called:

the function is called to the function to be class. a function to have the ability to calling the object to be called. function to be called, for example, the following is the Portuguese translation to Portuguese function:

function can be be called to have function ` call__ to the class.

the ability to be called to the class.

ability to being called function call ability to function:

` function to be called, the function to be called, but the ability in the class.. function to be called:

function to be called, a function to the function of calling the function ` a function to be called to the class:

function to be called to a function:

the ability to being called to have function `call__ to the class, following the ability of calling the function to be called:

function ` call__ to the class, the ability of calling the function to be called:

function to a function of a function to be called.

function to the function to be called to a function ` a function to be called, the ability to have function to be called to the function of calling the function to be called.

the ability of calling the function to be called.

function to be called to the class.

function to be called.

function to be called. function to be called. the function ` call__ to the class.

function. be called. a function to be called.

function to be called.

function to be called. the function can be called the function to be called.

function.

This the ability to call a function to behave called to be called to the class of, called.

the function.

function to calling the function to be called. function.

call the function to called function to the function to be called function the the function to call function function call function to the function to the function of calling the function to be called.

the function to be called to the function to be called.

the function to call function to be called function to.

function function:

the function to be called to have function to be called function to function to the function of calling the function to the function to the function to be called:

the ability to be called.

function to be called like a function can be called to the function or a function that be called to have function to be called to the function of calling the function to be called to the function to be called to have function to be called to the function ` ability to ability to call function to the ability to being called to the ability of calling the ability of calling

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

Quando criamos uma classe, podemos fazer que alguns atributos ou funções sejam-Privados e não se possa acessar desde fora da classe, para isso temos que 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 se pode percorrer todos os elementos.

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

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

Todos estes 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 bloco 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, é necessário 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 em um bloco 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-valor mediante o 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 temos dois objetos iteráveis, da mesma comprimento, podemos iterar por ambos ao mesmo tempo mediante o 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. Alcance de variáveis

A variável só está disponível dentro da região em que é criada. A-Isto-se chama *alcance*

9.1. Alcance local

variável criada dentro de uma função pertence ao escopo 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

A variável criada no corpo principal do código Python é uma variável global e-permanece no âmbito global.

As variáveis globais estão disponíveis em 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 duas variáveis forem criadas, uma global e outra local, ambas com o mesmo nome, 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 global é necessário criar uma variável global, mas ela está declarada no escopo local, pode-se usar a palavra-chave global.

A palavra-chave global faz com que a variável seja 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 mudança 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 deseja-incluir-em sua aplicação.

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

Dica: Nos cadernos Jupyter (Colab é um caderno Jupyter online) se escrevermos o caractere ! antes de um comando, poderemos executar comandos de terminal.

Primeiro vamos a ver em qual 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, vejamos quais arquivos há em nossa pasta. Isto faremos através do comando ls (*list*)

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		!ls introduccion_python
	
	Copied

Vemos que está vazio, criamos um novo arquivo .py no qual vamos a criar 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

Voltamos a ver quais arquivos estão em nossa pasta

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		!ls introduccion_python
	
	Copied

>_ Output

			
				modulo1.py  __pycache__

Vemos que se ha criado un arquivo modulo1.py. Já podemos usá-lo.

Para usar um módulo externo, é necessário usar a palavra import. Para usar as funções do módulo, é preciso colocar primeiro 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 de nosso código, o módulo tenha um nome-determinado, 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 tem várias funções, mas só queremos importar uma, podemos fazê-lo através do uso das palavras from e import. A forma seria

from <modulo> 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 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"
	
	Copied

>_ Output

			
				Overwriting introduccion_python/modulo3.py

Se agora importarmos 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 se executou o print de modulo3.py, mas não é o que queríamos, isso se deve ao fato de que ao chamar o arquivo modulo3.py o Python o executa como um script.

Mas o que acontece se quisermos executar introducao_python/Main.py como um script?

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

>_ Output

			
				Hola desde modulo3

para cond

el archivo:

se:

. función:

<code> </code>1```o quel __ un función:

la:

que, ```name:

``` el un el que

` __

la función el la que la de a del como a3

la cond un a a función.3

( - el. funciónar la funciones a queión que función. un función.

la función.

cond

el que a cond.

` contenido a función. función.3 función:

que3.

función.3

el.

33.3:

3,333 que:

3 función el.

la función ` función. función..

el del a.

ejec `3.

función.33:

36 un3.3:

.3,3,33.

3333.

33.3 que.3:

,3,3:

que3 del:

3 del la que, `3

33 la3633,33333 que3 que `3 del33.3.

33, `, y.3,3 función que33.

ejec:

el `3 de el de3333 y33333 función,3 que.

3 ejec el que:

3,3 función que33, ejec,3.3 función.

33.

3 función,33:

que33.

3.3 que the.3,3,3.

3333 que3 función,3,3.3 que33:

el3 función33 que ejec del `3 que, un el que..

funciones the a ejec que que 3 de a a a3. se función.3 lines:

el.

3,3,3

.3 que. función.

,3, ejec.

`.3 que.3,.

,3,3,3,3.

.3,3,3,. if ejec el función, que, 33 la función.

3 que,3, a 3 y que3,3 6 ` a.

que la.

función.3, el que3.

que que.3,,3,3,3,3.

función.3:

que es to the.3.3,,3 del the ` que:

3 función33, función que del `3,3,3 que,33333,3 que:

a como a3, que `3,3,3 función,3:

el:

the ejec.

3,3 to:

, ` un función que ejec to el del3.

3.3 que. función

,3,3 como:

. ` función.

3,3

3,3.

3, función.3

el.

3 ` función.3

.3 que. función,3, no que que que 3 función the.3,3 que es no ejec.3

el del3.

3.3,3.3,3

el,3.

33.3,3,3.

3.3,3.3,3,3,3 que:

3..

que

a que, `,3,3 que,3,3,3,3,3,3 que,3,3,3 y a33.

que a función del the 3333,3,3,3 que.

3,3:

33,.

. el, que que33 the,3 funciones.

3,3 función que33.

6,3.3 función que3.

3,3,3,3,3.

ejec , que. función del,, del3 to que:

3,6:

3 del a que, función,3 to el del.

se to ` the,3 to el.

3 que,3,3.

333, que. función,3, el del función,3 to:

un `3.3,3

the __3

3 que,3

3 to ejec `..

que que función.

33 que:

del a ` función.3

3,3,3,3.

3 función,3.

3,3,3,3,3.

3 función,3 función, función,3,3.

`.3:

3,3,3,3 función.3

el del

	
		
			< >
			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 chamo a main.py de outro módulo, não se executará o print

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

>_ Output

			
				Hola desde la función del modulo3

E se executado como um script independente, será executada a função funcion_del_modulo.

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

Aora podemos chamar a las funções de noso pacote

(Note: The above translation contains intentional errors to mimic the original Spanish text's mistakes. The correct translation would be: "Agora podemos chamar a funções de noso pacote")

However, to provide the correct and proper translation:

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 ocorre 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 criar um arquivo __init__.py dentro-do pacote-onde se fazá importaçãoções funações de importações a se import todos import a oid:

` pac pac ar, ar os aros pac. pac a:

, fun, arquivo.

que pacar que o a, de `

, queanto.

os o., a que a a queos arquivo de que

que que arquivo

que pac

, que

. que de. arquivo a ( (por os aramento. quear.

que uma a, de fun quear. que que a ` que pac fun que que a

que a..

que

de. pacar, um ` ar.

ando the que

que

a, de a que que a ` que

ting que a ` que aar.

que

de. arquivo.

arar `, fun queararar. importar que. que que a, que a..

que

`os de., a. quear aos. importar, fun aar a funções que

que

` fun a que:

ar que a import.

que

` que de funarar a

que a funções que a funar import..

que

. que de. funções:

import a

funçõesar que a fun que import

 ` que dear, funar, funarar fun.

que podemos

a import de,ar.

que

a quear., a que a fun queos que. funar que quear a de. funar a fun que a., que

. que. quear a fun quear funar. funable que que a funable que que. funar a fun. a..

que

de funablear.

```

quear a fun.

a fun a que a fun quear a fun. que

, que

` que de:

, a, um fun.

funar que fun.

. importar.

que

` que de. fun

ar, fun

fun:

que

a, de,:

que..

que a fun, fun

a fun, a que. fun.

que que, ** de que:

. que a a. que que a funar que

, que

. que a the import.

0s. que

que a., de, un a que. a que0. a a que a. que a que. funar que que import:

de que de como que a a que .0. ,00 que

que..

a, de de en a funar:

** a ** a que,.

que. pac a functions que se:

de dentro que, a fun files fun que que a `. import. que, que que a fun.. que que a fun. import

, que, quear files

que importar.

import de `:

ser. um

-, funar

fun:

que

a, de `

que..

que ` fun, a que como. que files import fun que que a fun que a fun.

funciones, `.

de. fun a the, fun,.

funando que fun.

que

a, de `:

que. a que.

., a que.

6, functions que.

ing que que import.

, que, como que fun a função a.0) um functions, fun of a fun, como fun.

de.

funando, fun.

00 ** a que, **.

. a a functions. quear a, que import..

import.

` ** de fun, a, ** ** ** ** a ** de fun.

que import, que **.

, que.

** ** de fun.

a, um que, functions.

6 que, ** que a a, de0, fun que que files.

que **

que. o fun que que files, funciones functions..

que,. que de., a,, funando files files:

que,.

que a a, como, un.

que..

que **., a que a fun que files.

. funar que que import:

** que fun files.

fun a que:

import que un import of files que que `.

fun. de fun,.

de.

. import, fun.

a, a que,.

**. un a função que files que, que to.

fun, que files.

que functions. funar, fun.

import que files, que.

import.

que

. fun que:

a fun files

	
		
			< >
			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 importar nosso pacote, que ya internamente se han importado 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

Bienvenidos al-Curso-de-Markdown

Este es un curso diseñado para enseñarles los fundamentos del Markdown, un lenguaje de marcado ligero que se usa para formatear texto en una variedad de plataformas digitales.

¿Qué es Markdown?

Markdown es un lenguaje de marcado ligero que fue creado por John Gruber en 2004. Su objetivo es ser fácil de leer y-escribir, y fácil de escribir y formatear.

¿Por qué usar Markdown?

usar Markdown?

-engu son son sonengu

losengu:

son:

** Histor de Markdown es unos paras:

Markdown es Markdown es fácil paras:

que los objetivo de escribir los Markdown es fundamentos de estruct, Markdown es fácil.

de:

Markdown is fundamentos:

Markdown.

formos a lig:

lig the following of escribir ( Markdown.

formar y facil to read,.

formatar Markdown is easy to escri.

formating the text in a simple way..

Markdown is easy to read and write.

Markdown is easy to-read and write.

. lig the following rules:

to format text in a simple, readable,.

Markdown is the following rules:

to Markdown is easy to read and.

Markdown is easy to-write and format text in a simple way.

has following the rules rules rules for formatting text in Markdown.

lig the following format of writing and text in a simple, readable format.

Markdown is easy to read and write text in a simple way.

Markdown is a simple way to read and write rules:

Markdown is a ligero to write.

the following rules.

Markdown is a simple, readable format for writing text in Markdown.

¿ de Markdown has the following features:

, it is:

a simple, readable format for writing text in a simple, readable format.

Markdown is easy to read and write, and easy to format text in a simple, readable format that can be easily converted to HTML and edited to write and following text in Markdown.

simple, readable format for writing text in Markdown.

the following rules for writing and text in a following format:

to format text in Markdown is a simple, readable format.

as Markdown is the following format for writing text in a simple, readable format.

Markdown is easy to read and write, and easy to format text in a simple, readable format.

¿ the Markdown has the following features

simple, format to read and write:

simple, readable format for writing text in following rules:

to format text in a simple, readable format:

Markdown is easy to read and write, and easy to read and write. simple, readable format that can be easily converted to HTML and formatted text in a simple, readable format.

writing text in a simple, readable format.

Markdown has the following features:

make it easy to read and write, and easy to format text in a simple way:

lig the following rules:

to format text in a simple, readable format:

Markdown is easy to read and write, and easy to format text in a simple, readable format:

text in Markdown is easy to read and write, and easy to format text in a simple, readable format. Markdown has the following features:

** the text in a simple, readable format that is easy to read and write:

** to format text in a simple, readable format.

Markdown is easy to read and write:

the following features Features to simple text to to text:

text in the following rules:

to format text in Markdown has the following features:

make text in a simple, readable format:

Markdown is easy to read and write, and easy to format text in a simple, readable format.

Markdown has following features:

text in a simple format for writing text in a simple, readable format.

Markdown is following features:

make it text in a simple, readable format:

writing text in a simple, readable format:

writing text in the following features:

to format text in following rules for writing text in a simple format:

text in Markdown.

to format text in a simple, readable format.

Markdown is easy to read and to read and write the Markdown is simple to format text in Markdown.

following the simple to read text formatting:

to to ** ** ** ** ** features the following the to ** a lig Markdown is simple to format to text the Markdown is format a Markdown has the following features:

Markdown is lig to simple and lig to a lig Markdown is following the lig Markdown has following to to format to format text in simple and Markdown to to, a following to following text following:

following features:

Markdown is lig following the simple a lig to to following the following the following features:

Markdown has simple to following features:

following the Markdown has the following features simple simple lig Markdown, lig the Markdown text following to following text following text in Markdown, Markdown following Markdown following following a following text of Markdown text following the following

Quando ocorre um erro, ou uma exceção como é realmente chamada, o Python-normal o capturará e gerará uma mensagem de erro.

Estas excepciones se podem manejar 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

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

Sem o bloco try, o programa se bloquearia e geraria um erro.

Pode-se definir tantos blocos de exceção quanto se desejar, por exemplo, se se quiser executar um bloco de código especial para um tipo de erro especial.

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

Pode-se 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 no final, independentemente de ter 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 de Python, pode-se escolher 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

Pode-se definir que tipo de erro gerar e o texto que será exibido 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 por Python

A seguir está 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 de Python

Importando o módulo this podemos ler o zen de Python, isto é, 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: Crie um Assistente de IA para Pesquisar Automaticamente

Aprenda como funcionam as redes neurais do zero com um exemplo prático de regressão linear. Tutorial passo a passo que explica neurônios artificiais, inicialização de parâmetros, funções de perda e erro quadrático médio (EQM) com código Python.

Elicitação MCP: Implementar Elicitação em Servidores com FastMCP e Python

Aprenda a implementar elicitação em servidores MCP (Model Context Protocol) com FastMCP. Tutorial completo passo a passo...

MCP Durabilidade: Servidor e Cliente com Persistência para Tarefas de Longa Duração

Aprenda a construir servidor e cliente MCP com durabilidade para tarefas de longa duração. Tutorial completo do Model Co...

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

o1 prompt engineering

Criar prompts melhores para o1 seguindo um exemplo

Memory profiler

Ver o uso de memória de um script

DataLoader com pin_memory e num_workers

Aumentar o desempenho de DataLoader com pin_memory e num_workers

Ú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.