Introdução ao Python

11 de fevereiro de 2021

Introdução ao Python

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

Este caderno foi traduzido automaticamente para torná-lo acessível a mais pessoas, por favor me avise se você vir algum erro de digitação..

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 classes. Também veremos como usar objetos iteráveis, como usar módulos, etc.

2. Tipos de dados Python

Existem 7 tipos de dados em Python

do tipo text:str

Numérico: int, float, complex.

sequências: list, tuple, range; 4.
Mapeamento: dict.
Conjuntos: set, frozenset.
Booleanos: bool.
Binários: bytes, bytearray, memoryview.

Podemos obter o tipo de dados usando a função type().

	
		type(5.)

	
		float

Python é uma linguagem tipada dinamicamente, ou seja, você pode ter uma variável de um tipo e depois atribuir outro tipo a ela.

	
		a = 5
type(a)

int

	
		a = 'MaximoFN'
type(a)

str

O Python digita as variáveis para você, mas se você quiser digitá-las você mesmo, isso pode ser feito

	
		b = int(5.1)
type(b), b

	
		(int, 5)

Embora b tenha sido inicializado como 5.1, ou seja, deveria ser do tipo float, quando o digitamos para o tipo int, vemos que ele é do tipo int e seu valor também é 5.

2.1 Cadeias de caracteres

Strings são cadeias de caracteres, que podem ser definidas com aspas duplas " ou aspas simples '.

	
		string = "MaximoFN"
string

	
		'MaximoFN'

	
		string = 'MaximoFN'
string

	
		'MaximoFN'

Para escrever uma string muito longa e não ter uma linha que ocupe muito espaço, ela pode ser inserida em várias linhas.

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

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

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

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

No entanto, podemos ver que o caractere n foi inserido no meio; esse caractere indica a quebra de linha. Se usarmos a função print(), veremos que ele não aparece mais.

	
		print(string)

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

Como já dissemos, as cadeias de caracteres são cadeias de caracteres, portanto, podemos navegar e iterar por elas.

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

	
		Este es un

Podemos obter o comprimento de nossa string usando a função len().

	
		len(string)

Verificar se há uma determinada cadeia de caracteres em nossa cadeia de caracteres

	
		'ejemplo' in string

	
		True

As cadeias de caracteres têm certos atributos úteis, como a capitalização de tudo.

	
		print(string.upper())

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

Tudo em letras minúsculas

	
		print(string.lower())

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

Substituir caracteres

	
		print(string.replace('o', '@'))

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

Obter todas as palavras

	
		print(string.split())

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

Você pode ver todos os métodos das cadeias de caracteres neste [link] (https://docs.python.org/3.9/library/stdtypes.html#string-methods)

Outra coisa útil a ser feita com cadeias de caracteres é concatená-las.

	
		string1 = 'Maximo'
string2 = 'FN'
string1 + string2

	
		'MaximoFN'

Anteriormente, explicamos que o caractere n correspondia a uma quebra de linha; esse caractere especial corresponde a uma série de caracteres especiais chamados Escape Characters. Vamos dar uma olhada em outros

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

	
		print("Este es el blog de \"MaximoFN\"")

	
		Este es el blog de "MaximoFN"

O mesmo acontece com as aspas simples, adicionamos `'.

	
		print('Este es el blog de \'MaximoFN\'')

	
		Este es el blog de 'MaximoFN'

Agora temos o problema de adicionar ou não o caractere de escape, pois, como vimos, ele é um caractere de escape, então resolvemos isso colocando uma barra invertida dupla barreira.

	
		print('Este es el blog de \\MaximoFN\\')

	
		Este es el blog de \MaximoFN\

Já vimos anteriormente o escape character da nova linha n.

	
		print('Este es el blog de \nMaximoFN')

	
		Este es el blog de 
MaximoFN

Se quisermos escrever a partir do início da linha, adicionaremos r.

	
		print('Esto no se imprimirá \rEste es el blog de MaximoFN')

	
		Este es el blog de MaximoFN

Se quisermos adicionar um espaço grande (recuo), usaremos ``t`.

	
		print('Este es el blog de \tMaximoFN')

	
		Este es el blog de 	MaximoFN

Podemos excluir um caractere com b.

	
		print('Este es el blog de \bMaximoFN')

	
		Este es el blog deMaximoFN

Podemos adicionar o código ASCII em octal usando ooo.

	
		print('\115\141\170\151\155\157\106\116')

	
		MaximoFN

Ou adicione o código ASCII em hexadecimal usando xhh.

	
		print('\x4d\x61\x78\x69\x6d\x6f\x46\x4e')

	
		MaximoFN

Por fim, podemos converter outro tipo de dados em uma string

	
		n = 5
print(type (n))
string = str(n)
print(type(string))

	
		<class 'int'>
<class 'str'>

2.2 Números

2.2.1. inteiros

Números do tipo inteiro

	
		n = 5
n, type(n)

	
		(5, int)

2.2.2. flutuante

Números do tipo ponto flutuante

	
		n = 5.1
n, type(n)

	
		(5.1, float)

2.2.3 Complexos

Números complexos

	
		n = 3 + 5j
n, type(n)

	
		((3+5j), complex)

2.2.4. Conversão

Você pode converter entre tipos de números

	
		n = 5
n = float(n)
n, type(n)

	
		(5.0, float)

	
		n = 5.1
n = complex(n)
n, type(n)

	
		((5.1+0j), complex)

	
		n = 5.1
n = int(n)
n, type(n)

	
		(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 armazenam vários itens em uma variável. Elas são declaradas usando os símbolos [], com os itens separados por vírgulas.

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

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

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

	
		len(lista)

As listas podem ter itens de diferentes tipos

	
		lista = ['item0', 1, True, 5.3, "item4", 5, 6.6]
lista

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

Em Python, começamos a contar a partir da posição 0, ou seja, se quisermos obter a primeira posição na lista

	
		lista[0]

	
		'item0'

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

	
		lista[-1]

6.6

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

	
		lista[-2]

Se quisermos apenas um intervalo de valores, por exemplo, do segundo ao quinto item, usaremos [2:5].

	
		lista[2:5]

	
		[True, 5.3, 'item4']

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

	
		lista[:5]

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

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

	
		lista[3:]

	
		[5.3, 'item4', 5, 6.6]

Você pode escolher o intervalo de itens também com números negativos, ou seja, se quiser do antepenúltimo ao penúltimo, use [-3:-1]. Isso é útil quando você tem listas cujo comprimento não conhece, mas sabe que deseja um intervalo de valores a partir do final, porque, por exemplo, a lista foi criada com medições que você está fazendo e você deseja saber as últimas médias.

	
		lista[-3:-1]

	
		['item4', 5]

Você pode verificar se um item está na lista

	
		'item4' in lista

	
		True

2.3.1.1 Edição de listas

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

	
		lista[2] = False
lista

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

Um intervalo de valores também pode ser modificado

	
		lista[1:4] = [1.1, True, 3]
lista

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

Os valores podem ser adicionados ao final da lista usando o método append().

	
		lista.append('item7')
lista

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

Ou podemos inserir um valor em uma determinada posição usando o método insert().

	
		lista.insert(2, 'insert')
lista

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

As listas podem ser unidas usando o método extend().

	
		lista2 = ['item8', 'item9']
lista.extend(lista2)
lista

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

Não é necessário estender a lista por outra lista, isso pode ser feito por outro tipo de dados Python iterável (tuplas, conjuntos, dicionários etc.).

	
		tupla = ('item10', 'item11')
lista.extend(tupla)
lista

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

Podemos remover uma determinada posição usando o método pop().

	
		lista.pop(2)
lista

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

Se o índice não for especificado, o último item será excluído.

	
		lista.pop()
lista

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

Ou você pode remover um item conhecendo seu valor usando o método remove().

	
		lista.remove('item7')
lista

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

Com a função del(), um item também pode ser removido da posição especificada.

	
		del lista[3]
lista

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

Se o índice não for fornecido, a lista inteira será excluída.

Com o método clear(), ele deixa a lista vazia.

	
		lista.clear()
lista

[]

O número de itens com um determinado valor pode ser obtido com o método count().

	
		lista = [5, 4, 6, 5, 7, 8, 5, 3, 1, 5]
lista.count(5)

Você também pode obter o primeiro índice de um item com um determinado valor usando o método index().

	
		lista = [5, 4, 6, 5, 7, 8, 5, 3, 1, 5]
lista.index(5)

2.3.1.2. compreensão de lista

Podemos operar por meio da lista

	
		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

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

Outro recurso poderoso do Python é a compreensão de lista, que permite fazer tudo em uma única linha e tornar o código mais compacto.

	
		fruits = ["apple", "banana", "cherry", "kiwi", "mango"]
newlist = [x for x in fruits if "a" in x]
newlist

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

A sintaxe é a seguinte

newlist = [expression for item in iterable if condition == True]]

Você pode tirar proveito disso para executar operações na lista original.

	
		newlist = [x.upper() for x in fruits if "a" in x]
newlist

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

2.3.1.3. Classificando listas

Para classificar listas, usamos o método sort().

	
		lista = [5, 8, 3, 4, 9, 5, 6]
lista.sort()
lista

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

Ele também os ordena em ordem alfabética

	
		lista = ["orange", "mango", "kiwi", "pineapple", "banana"]
lista.sort()
lista

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

Ao classificar em ordem alfabética, ele diferencia maiúsculas de minúsculas.

	
		lista = ["orange", "mango", "kiwi", "Pineapple", "banana"]
lista.sort()
lista

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

Eles podem ser classificados em ordem decrescente usando o atributo reverse = True.

	
		lista = [5, 8, 3, 4, 9, 5, 6]
lista.sort(reverse = True)
lista

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

Elas podem ser classificadas em qualquer ordem que desejarmos usando o atributo key.

	
		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

	
		[50, 65, 23, 82, 100]

Você pode tirar proveito disso para que, por exemplo, ao classificar, ele não faça distinção entre letras maiúsculas e minúsculas.

	
		lista = ["orange", "mango", "kiwi", "Pineapple", "banana"]
lista.sort(key = str.lower)
lista

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

Você pode inverter a lista usando o método reverse.

	
		lista = [5, 8, 3, 4, 9, 5, 6]
lista.reverse()
lista

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

2.3.1.4. Copiando listas

As listas não podem ser copiadas usando list1 = list2, pois se list1 for modificada, list2 também será modificada.

	
		lista1 = [5, 8, 3, 4, 9, 5, 6]
lista2 = lista1
lista1[0] = True
lista2

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

Portanto, você deve usar o método copy().

	
		lista1 = [5, 8, 3, 4, 9, 5, 6]
lista2 = lista1.copy()
lista1[0] = True
lista2

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

Ou use o construtor de lista list().

	
		lista1 = [5, 8, 3, 4, 9, 5, 6]
lista2 = list(lista1)
lista1[0] = True
lista2

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

2.3.1.5. Concatenar listas

As listas podem ser concatenadas usando o operador +.

	
		lista1 = [5, 8, 3, 4, 9, 5, 6]
lista2 = ['a', 'b', 'c']
lista = lista1 + lista2
lista

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

Ou usando o método extend

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

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

Outra maneira de concatenar é repetir a tupla X vezes usando o operador *.

	
		lista1 = ['a', 'b', 'c']
lista2 = lista1 * 3
lista2

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

2.3.2. tuplas

As tuplas são semelhantes às listas, armazenam vários itens em uma variável, podem conter itens de tipos diferentes, mas não podem ser modificadas ou reordenadas. Elas são definidas por (), com itens separados por vírgulas.

O fato de não poderem ser modificadas faz com que as tuplas sejam executadas um pouco mais rapidamente do que as listas, portanto, se você não precisar modificar os dados, é melhor usar tuplas em vez de listas.

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

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

Seu comprimento pode ser obtido com a função len().

	
		len (tupla)

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

	
		tupla = ('item0',)
tupla, type(tupla)

	
		(('item0',), tuple)

Para acessar um elemento de tupla, proceda da mesma forma que para as listas.

	
		tupla = ('item0', 1, True, 3.3, 'item4', True)
print(tupla[0])
print(tupla[-1])
print(tupla[2:4])
print(tupla[-4:-2])

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

Podemos verificar se há um item na tupla

	
		'item4' in tupla

	
		True

2.3.2.1. Modificando 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 novamente em uma tupla.

	
		lista = list(tupla)
lista[4] = 'ITEM4'
tupla = tuple(lista)
tupla

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

Ao convertê-lo em uma lista, podemos fazer todas as modificações vistas em listas.

O que você pode fazer é excluir a tupla inteira.

	
		del tupla
if 'tupla' not in locals():
  print("tupla eliminada")

	
		tupla eliminada

2.3.2.2.2. Desempacotando tuplas

Quando criamos tuplas, na verdade estamos empacotando dados

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

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

mas podemos desempacotá-los

	
		item0, item1, item2, item3, item4, item5 = tupla
item0, item1, item2, item3, item4, item5

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

Se quisermos obter menos dados do que o comprimento da tupla, adicionaremos um *.

	
		item0, item1, item2, *item3 = tupla
item0, item1, item2, item3

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

Você pode colocar o asterisco * em outro lugar se, por exemplo, quiser o último item.

	
		item0, item1, *item2, item5 = tupla
item0, item1, item2, item5

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

2.3.2.2.3. Concatenar tuplas

Você pode concatenar tuplas usando o operador +.

	
		tupla1 = ("a", "b" , "c")
tupla2 = (1, 2, 3)
tupla3 = tupla1 + tupla2
tupla3

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

Outra maneira de concatenar é repetir a tupla X vezes usando o operador *.

	
		tupla1 = ("a", "b" , "c")
tupla2 = tupla1 * 3
tupla2

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

2.3.2.2.4. Métodos de tuplas

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

	
		tupla = (5, 4, 6, 5, 7, 8, 5, 3, 1, 5)
tupla.count(5)

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

	
		tupla = (5, 4, 6, 5, 7, 8, 5, 3, 1, 5)
tupla.index(5)

2.3.3. Alcance

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

range(start, stop, step)

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

	
		for i in range(5):
  print(f'{i} ', end='')

	
		0 1 2 3 4

Se, por exemplo, não quisermos que ele comece em 0

	
		for i in range(2, 5):
  print(f'{i} ', end='')

	
		2 3 4

	
		for i in range(-2, 5):
  print(f'{i} ', end='')

	
		-2 -1 0 1 2 3 4

Por fim, se não quisermos que ela seja incrementada em 1. Se, por exemplo, quisermos uma sequência de números pares

	
		for i in range(0, 10, 2):
  print(f'{i} ', end='')

	
		0 2 4 6 8

2.4. Dicionários

Os dicionários são usados para armazenar dados em pares chave:dados. Eles são modificáveis, não ordenados e não permitem duplicação. São definidos pelos símbolos {}. Eles suportam itens de diferentes tipos de dados

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

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

Como mencionado acima, eles não permitem a duplicação.

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

Seu comprimento pode ser obtido com a função len().

	
		len(diccionario)

Como você pode ver, o comprimento é 4 e não 5, pois year conta apenas uma vez.

2.4.1. Acessando os itens

Para acessar um item, podemos fazê-lo por meio de sua chave.

	
		diccionario["model"]

	
		'Mustang'

Ele também pode ser acessado pelo método get().

	
		diccionario.get("model")

	
		'Mustang'

Para conhecer todas as "chaves" dos dicionários, você pode usar o método keys().

	
		diccionario.keys()

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

Uma variável pode ser usada para apontar para o dicionário keyss, portanto, é necessário chamá-la uma vez.

	
		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)

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

O método "values()" pode ser usado para obter os valores do dicionário.

	
		diccionario.values()

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

Uma variável pode ser usada para apontar para os valores no dicionário, portanto, é necessário chamá-la uma vez.

	
		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)

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

Se você quiser os inteiros do item, ou seja, chave e valor, deverá usar o método items().

	
		diccionario.items()

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

Uma variável pode ser usada para apontar para os itens no dicionário, portanto, é necessário chamá-la uma vez.

	
		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)

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

Você pode verificar se uma chave existe no dicionário.

	
		"model" in diccionario

	
		True

2.4.2. Modificar itens

Você pode modificar um item acessando-o diretamente

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

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

Ou pode ser modificado usando o método update().

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

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

2.4.3. Adicionando itens

Você pode adicionar um item adicionando-o sem mais delongas.

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

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

Ou pode ser adicionado por meio do método update().

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

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

2.4.4. Excluir itens

Você pode remover um item com uma chave específica usando o método pop().

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

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

Ou você pode excluir um item com uma chave específica, indicando o nome da chave entre os símbolos [].

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

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

O dicionário inteiro será excluído se del for usado e a chave de um item não for especificada.

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

	
		diccionario eliminado

Se quiser excluir o último item inserido, você pode usar o método popitem().

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

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

Se você quiser limpar o dicionário, deverá usar o método clear().

	
		diccionario = {
  "brand": "Ford",
  "model": "Mustang",
  "year": 1964
}
diccionario.clear()
diccionario

{}

2.4.5. Copiar dicionários

Não é possível copiar dicionários usando dictionary1 = dictionary2, pois se você modificar dictionary1, também modificará dictionary2.

	
		diccionario1 = {
  "brand": "Ford",
  "model": "Mustang",
  "year": 1964
}
diccionario2 = diccionario1
diccionario1["year"] = 2000
diccionario2["year"]

Portanto, você deve usar o método copy().

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

Ou use o construtor de dicionário dict().

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

2.4.6. Dicionários aninhados

Os dicionários podem ter itens de qualquer tipo de dados, inclusive outros dicionários. Esses dicionários são chamados de dicionários "aninhados".

	
		diccionario_nested = {
  "child1" : {
    "name" : "Emil",
    "year" : 2004
  },
  "child2" : {
    "name" : "Tobias",
    "year" : 2007
  },
  "child3" : {
    "name" : "Linus",
    "year" : 2011
  }
}
diccionario_nested

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

	
		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

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

2.4.7. Métodos de dicionário

Estes são os [métodos] (https://www.w3schools.com/python/python_dictionaries_methods.asp) que podem ser usados nos dicionários

2.4.8. Compreensão de dicionário

Assim como poderíamos fazer compreensões de listas usando a sintaxe

list_comprehension = [expression for item in iterable if condition == True].
      ```
      
      Podemos fazer compreensões de `discionários` com a seguinte sintaxe
      
      ``` python
      dictionary_comprehension = [expressão de chave: expressão de valor para item em iterável se condição == True].
      ```
      
      Aqui está um exemplo

	
		dictionary_comprehension = {x: x**2 for x in (2, 4, 6) if x > 2}
dictionary_comprehension

	
		{4: 16, 6: 36}

2.5. Conjuntos

2.5.1. definir

Os conjuntos são usados em python para armazenar um conjunto de itens em uma única variável. Você pode armazenar itens de diferentes tipos. Eles não são ordenados e não têm índice.

Elas diferem das listas por não terem ordem nem índice.

Eles são declarados pelos símbolos {}.

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

	
		set_ = {'item0', 1, 5.3, "item4", 5, 6.6}
set_

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

Não pode haver itens duplicados; se você encontrar um item duplicado, manterá apenas um.

	
		set_ = {'item0', 1, 5.3, "item4", 5, 6.6, 'item0'}
set_

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

O comprimento do set pode ser obtido com a função len().

	
		len(set_)

Como você pode ver, o comprimento do conjunto é 6 e não 7, pois você fica com apenas um 'item0'.

Você pode verificar se um item está no conjunto.

	
		'item4' in set_

	
		True

2.5.1.1. Adicionando itens

Um item pode ser adicionado ao conjunto usando o método add().

	
		set_.add(8.8)
set_

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

Outro conjunto pode ser adicionado usando o método update().

	
		set2 = {"item5", "item6", 7}
set_.update(set2)
set_

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

Você também pode adicionar itens de tipos de dados Python iteráveis

	
		lista = ["item9", 10, 11.2]
set_.update(lista)
set_

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

2.5.1.2. Excluindo itens

Um determinado item pode ser removido com o método remove().

	
		set_.remove('item9')
set_

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

Ou por meio do método discard()

	
		set_.discard('item6')
set_

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

Usando o método pop() você pode remover o último item, mas como os sets não estão ordenados, não há como saber qual é o último item. O método pop() retorna o item excluído.

	
		print(f"set antes de pop(): {set_}")
eliminado = set_.pop()
print(f"Se ha eliminado {eliminado}")

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

Usando o método clear(), o conjunto pode ser esvaziado.

	
		set_.clear()
set_

	
		set()

Por fim, com del você pode excluir o conjunto

	
		del set_
if 'set_' not in locals():
  print("set eliminado")

	
		set eliminado

2.5.1.3. vinculação de itens

Uma forma de unir conjuntos é por meio do método union().

	
		set1 = {"a", "b" , "c"}
set2 = {1, 2, 3}
set3 = set1.union(set2)
set3

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

Outra maneira é usar o método update(), mas dessa forma você adiciona um conjunto a outro, não cria um novo.

	
		set1 = {"a", "b" , "c"}
set2 = {1, 2, 3}
set1.update(set2)
set1

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

Esses métodos de união removem as duplicatas, mas se quisermos obter os itens duplicados em dois conjuntos, usaremos o método intersection().

	
		set1 = {"apple", "banana", "cherry"}
set2 = {"google", "microsoft", "apple"}
set3 = set1.intersection(set2)
set3

	
		{'apple'}

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

	
		set1 = {"apple", "banana", "cherry"}
set2 = {"google", "microsoft", "apple"}
set1.intersection_update(set2)
set1

	
		{'apple'}

Por outro lado, se quisermos manter as não duplicatas, usaremos o método symmetric_difference().

A diferença entre isso e a união de dois conjuntos é que, na união, ele mantém todos os itens, mas só pega os itens duplicados uma vez. Agora ficamos com os itens que não estão duplicados.

	
		set1 = {"apple", "banana", "cherry"}
set2 = {"google", "microsoft", "apple"}
set3 = set1.symmetric_difference(set2)
set3

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

Se quisermos manter as não duplicatas sem criar um novo conjunto, usaremos o método symmetric_difference_update().

	
		set1 = {"apple", "banana", "cherry"}
set2 = {"google", "microsoft", "apple"}
set1.symmetric_difference_update(set2)
set1

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

2.5.1.4. definir métodos

Estes são os [métodos] (https://www.w3schools.com/python/python_sets_methods.asp) que podem ser usados nos conjuntos

2.5.2. Frozenset

Frozensets são como sets, mas imutáveis, assim como tuples são como lists, mas imutáveis. Portanto, não é possível adicionar ou remover itens

2.6. Booleanos

Existem apenas dois booleanos no Python: True e False.

Usando a função bool(), você pode avaliar se algo é True ou False.

	
		print(bool("Hello"))
print(bool(15))
print(bool(0))

	
		True
True
False

2.6.1. Outros tipos de dados Verdadeiro ou Falso

Os dados a seguir são True:

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

	
		print(bool("Hola"))
print(bool(""))

	
		True
False

	
		print(bool(3))
print(bool(0))

	
		True
False

	
		lista = [1, 2, 3]
print(bool(lista))
lista = []
print(bool(lista))

	
		True
False

	
		tupla = (1, 2, 3)
print(bool(tupla))
tupla = ()
print(bool(tupla))

	
		True
False

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

	
		True
False

	
		set_ = {'item0', 1, 5.3, "item4", 5, 6.6}
print(bool(set_))
set_.clear()
print(bool(set_))

	
		True
False

2.7. Binários

2.7.1. Bytes

O tipo bytes é uma sequência imutável de bytes. Somente caracteres ASCII são suportados. Os bytes também podem ser representados por inteiros cujos valores devem satisfazer 0 <= x < 256.

Para criar um tipo de byte, devemos primeiro inserir o caractere b.

	
		byte = b"MaximoFN"
byte

	
		b'MaximoFN'

Eles também podem ser criados por seu construtor bytes().

	
		byte = bytes(10)
byte

b''

	
		byte = bytes(range(10))
byte

	
		b'	'

Os bytes podem ser concatenados usando o operador +.

	
		byte1 = b'DeepMax'
byte2 = b'FN'
byte3 = byte1 + byte2
byte3

	
		b'DeepMaxFN'

Ou por meio de repetição com o operador *.

	
		byte1 = b'MaximoFN '
byte2 = byte1 * 3
byte2

	
		b'MaximoFN MaximoFN MaximoFN '

Podemos verificar se um caractere está dentro da cadeia de caracteres

	
		b'D' in byte1

	
		False

Esses são os [métodos] (https://plataforma.josedomingo.org/pledin/cursos/python3/curso/u30/#m%C3%A9todos-de-bytes-y-bytearray) que podem ser usados nos bytes.

2.7.2 Bytearray

Os bytearrays são iguais aos bytes, mas são mutáveis.

	
		byte_array = bytearray(b'MaximoFN')
byte_array

	
		bytearray(b'MaximoFN')

2.7.3. visualização de memória

Os objetos de visualização de memória permitem que o código Python acesse os dados internos de um objeto que suporta o protocolo de buffer sem fazer cópias.

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

Buffer, você pode criar outro objeto de acesso para modificar os big data sem copiá-los. Isso faz com que o programa use menos memória e aumenta a velocidade de execução.

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

	
		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 de soma +

	
		3 + 5

Oeprador subtrai -

	
		3 - 5

-2

Operador de multiplicação *

	
		3 * 5

Divisão de operadores /

	
		3 / 5

0.6

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

	
		25 % 2

Operador de expoente **

	
		5 ** 2

Operador de divisão de números inteiros //

	
		25 // 2

3.2. Operadores de comparação

Operador igual a ==

	
		1 == 1

	
		True

O operador é distinto !=

	
		1 != 2

	
		True

O operador é maior que >

	
		3 > 2

	
		True

O operador é menor que <

	
		2 < 3

	
		True

O operador é maior ou igual a >=.

	
		3 >= 3

	
		True

O operador é menor ou igual a <=.

	
		3 <= 3

	
		True

Operadores lógicos

Operador e

	
		True and True

	
		True

Operador ou

	
		True or False

	
		True

Operador not

	
		not False

	
		True

3.4. Operadores de identidade

Operador is

	
		5.3 is 5.3

	
		True

Operador não é

	
		5.3 is not 5

	
		True

3.5. Operadores de associação

Operador in

	
		x = ["apple", "banana"]
"banana" in x

	
		True

Operador "Not in

	
		x = ["apple", "banana"]
"orange" not in x

	
		True

3.6. Operadores bit a bit

Operador AND &

	
		a = 60 # 60 = 0011 1100 
b = 13 # 13 = 0000 1101 
c = a & b; # 12 = 0000 1100
c

Operador OR |

	
		a = 60 # 60 = 0011 1100 
b = 13 # 13 = 0000 1101 
c = a | b; # 61 = 0011 1101
c

Operador XOR ^

	
		a = 60 # 60 = 0011 1100 
b = 13 # 13 = 0000 1101 
c = a ^ b; # 49 = 0011 0001
c

Operador NOT ~

	
		a = 60 # 60 = 0011 1100 
c = ~a; # -61 = 1100 0011
c

-61

Operador de deslocamento à esquerda << operador

	
		a = 60 # 60 = 0011 1100 
c = a << 2; # 240 = 1111 0000
c

Operador shift right >>> operador

	
		a = 60 # 60 = 0011 1100 
c = a >> 2; # 15 = 0000 1111
c

3.7. Operadores de atribuição

Operador =

	
		a = 5
a

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

	
		a += 5
a

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

	
		a -= 5
a

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

	
		a *= 3
a

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

	
		a /= 3
a

5.0

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

	
		a = 25
a %= 2
a

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

	
		a = 25
a //= 2
a

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

	
		a = 5
a **= 2
a

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

	
		a = 60 # 60 = 0011 1100 
b = 13 # 13 = 0000 1101 
a &= b; # 12 = 0000 1100
a

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

	
		a = 60 # 60 = 0011 1100 
b = 13 # 13 = 0000 1101 
a |= b; # 61 = 0011 1101
a

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

	
		a = 60 # 60 = 0011 1100 
b = 13 # 13 = 0000 1101 
a ^= b; # 49 = 0011 0001
a

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

	
		a = 60 # 60 = 0011 1100 
a <<= 2; # 240 = 1111 0000
a

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

	
		a = 60 # 60 = 0011 1100 
a >>= 2; # 15 = 0000 1111
a

Controle de fluxo

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

Diferentemente de outras linguagens, o Python requer indentação (adição de espaço em branco) para definir o código dentro de uma ferramenta de fluxo de controle.

Se

Usando if, podemos criar condições

	
		if len('MaximoFN') == 8:
  print('MaximoFN tiene 8 caracteres')

	
		MaximoFN tiene 8 caracteres

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

	
		if len('MaximoFN') < 8:
  print('MaximoFN tiene menos de 8 caracteres')
elif len('MaximoFN') == 8:
  print('MaximoFN tiene 8 caracteres')

	
		MaximoFN tiene 8 caracteres

Se quisermos que algo seja executado se nenhuma das condições acima for atendida, podemos usar else.

	
		if len('MaximoFN') < 8:
  print('MaximoFN tiene menos de 8 caracteres')
elif len('MaximoFN') > 8:
  print('MaximoFN tiene más de 8 caracteres')
else:
  print('MaximoFN tiene 8 caracteres')

	
		MaximoFN tiene 8 caracteres

Se quisermos escrever tudo em uma única linha

	
		if len('MaximoFN') == 8: print('MaximoFN tiene 8 caracteres')

	
		MaximoFN tiene 8 caracteres

O mesmo acontece se quisermos escrever tudo em uma linha, mas com várias condições

	
		print('MaximoFN tiene menos de 8 caracteres') if len('MaximoFN') < 8 else print('MaximoFN tiene más de 8 caracteres') if len('MaximoFN') > 8 else print('MaximoFN tiene 8 caracteres')

	
		MaximoFN tiene 8 caracteres

Se, por exemplo, quisermos criar a estrutura if, mas não quisermos codificar uma das condições no momento, podemos usar pass.

	
		if len('MaximoFN') < 8:
  print('MaximoFN tiene menos de 8 caracteres')
elif len('MaximoFN') > 8:
  pass
else:
  print('MaximoFN tiene 8 caracteres')

	
		MaximoFN tiene 8 caracteres

4.2. enquanto

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

	
		i = 0
string = 'MaximoFN'
while len(string) > i:
  print(string[i], end='')
  i += 1

	
		MaximoFN

Se quisermos que o loop seja interrompido por alguma condição, usaremos break.

	
		i = 0
string = 'MaximoFN'
while len(string) > i:
  if string[i] == 'F':
    break
  print(string[i], end='')
  i += 1

	
		Maximo

Se quisermos que uma das iterações não seja executada por algum motivo, usaremos continue.

	
		i = 0
string = 'Maximo FN'
while len(string) > i:
  if string[i] == ' ':
    i += 1
    continue
  print(string[i], end='')
  i += 1

	
		MaximoFN

Usando else, você pode executar um bloco de código se a condição while não for True.

	
		i = 0
string = 'MaximoFN'
while len(string) > i:
  print(string[i], end='')
  i += 1
else:
  print("\nSe ha terminado el while")

	
		MaximoFN
Se ha terminado el while

4.3. Para

O loop for é usado para executar código durante a iteração em uma sequência, que pode ser qualquer elemento Python iterável (string, list, tuple, range, dictionary, set).

	
		string = 'MaximoFN'
for x in string:
  print(x, end='')

	
		MaximoFN

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

	
		MaximoFN

	
		tupla = ('M', 'a', 'x', 'i', 'm', 'o', 'F', 'N')
for x in tupla:
  print(x, end='')

	
		MaximoFN

	
		string = 'MaximoFN'
for i in range(len(string)):
  print(string[i], end='')

	
		MaximoFN

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

	
		MaximoFN

Também é possível iterar pelos sets, mas como eles são elementos não ordenados, não há controle sobre a ordem de execução.

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

	
		NximoaMF

Se quisermos que o loop seja interrompido por alguma condição, usaremos break.

	
		string = 'MaximoFN'
for x in string:
  if x == 'F':
    break
  print(x, end='')

	
		Maximo

Se quisermos que uma das iterações não seja executada por algum motivo, usaremos continue.

	
		string = 'Maximo FN'
for x in string:
  if x == ' ':
    continue
  print(x, end='')

	
		MaximoFN

Usando else, você pode executar um bloco de código se a condição while não for True.

	
		string = 'MaximoFN'
for x in string:
  print(x, end='') 
else:
  print("\nSe ha terminado el for")

	
		MaximoFN
Se ha terminado el for

Se, por exemplo, quisermos criar a estrutura do for, mas não quisermos, no momento, codificar o interior, poderemos usar o pass.

	
		string = 'MaximoFN'
for x in string:
  pass
print('Interior del for no codificado')

	
		Interior del for no codificado

5. funções

Uma função é um trecho de código que pode ser executado quantas vezes você quiser. Ela pode receber argumentos e retornar dados como resultado.

Para definir uma função, você começa com a palavra reservada def seguida pelo nome da função, colchetes (), dois pontos : e, em seguida, em uma nova linha, recua o código da função

	
		def funcion():
        print('MaximoFN')

Para chamar a função, é necessário apenas escrever seu nome

	
		def funcion():
  print('MaximoFN')
funcion()

	
		MaximoFN

As funções podem receber quantos argumentos você quiser, entre parênteses e separados por vírgulas.

	
		def funcion(string1, string2):
  print(string1 + ' ' + string2)
funcion("Hola", "MaximoFN")

	
		Hola MaximoFN

Ao chamar a função, você deve passar o mesmo número de argumentos declarados; se você passar mais ou menos, receberá um erro.

Se você não souber os argumentos que a função receberá, poderá usar *args, ou seja, ao colocar um * antes dos argumentos, você indica que o número de argumentos é livre.

Isso é feito passando uma tupla (lembre-se, ela é imutável) com os argumentos

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

	
		funcion con varios argumentos sin especificar cuantos

Caso não saibamos a ordem dos argumentos de uma função, podemos indicar o argumento que queremos passar para ela, indicando seu nome

	
		def funcion(argumento1, argumento2, argumento3):
  print(argumento1 + ' '+ argumento2 + ' ' + argumento3)
funcion(argumento3 = "MaximoFN", argumento1 = "Blog", argumento2 = "de")

	
		Blog de MaximoFN

Caso queira passar os argumentos com seus nomes, mas não saiba quantos argumentos passar, você pode usar **kargs. Nesse caso, um dicionário de argumentos será passado para ele

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

	
		Autor del blog: MaximoFN

Se quisermos que um argumento tenha um valor padrão, podemos indicá-lo entre os parênteses da função. Dessa forma, se no momento da chamada da função esse argumento não for passado, ele terá o valor padrão na função

	
		def funcion(argumento1, argumento2, argumento3 = "MaximoFN"):
  print(argumento1 + ' '+ argumento2 + ' ' + argumento3)
funcion("Blog", "de")

	
		Blog de MaximoFN

Você pode passar qualquer tipo de dados como argumento; por exemplo, se você passar uma lista como argumento, dentro da função, esse argumento será tratado como uma lista.

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

	
		Blog de MaximoFN

As funções podem retornar dados, o que é feito pela palavra reservada return.

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

	
		Blog de MaximoFN

Pode retornar mais de uma parte dos dados

	
		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)

	
		Blog de MaximoFN

Se não estivermos interessados em um dos dados retornados, podemos ignorá-lo com _.

	
		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)

	
		MaximoFN

Se, por exemplo, quisermos criar a estrutura da função, mas não quisermos codificar a parte interna no momento, poderemos usar pass.

	
		def funcion():
        pass
      
      funcion()

Uma função pode chamar a si mesma, o que é chamado de recursão de função ou recursão de função.

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

	
		def funcion():
  pass
funcion()
def factorial(n):
  if n == 0 or n == 1:
    return 1
  else:
    return n * factorial(n-1)
factorial(5)

5.1. Funções incorporadas

Há várias funções já definidas no Python que podem ser usadas, como a função abs(), que retorna o valor absoluto

	
		abs(-5)

A seguir, uma lista dessas funções

	
		import builtins
dir(builtins)

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

Uma explicação de uma função que criamos pode ser adicionada como um comentário no início da função, de modo que, quando chamarmos a função built in help(), ela mostrará essa explicação.

	
		def funcion():
  "Esta es la explicación de la función"
  None
help(funcion)

	
		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

	
		funcion.__doc__

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

5.3. Decoradores

Os decoradores são um recurso do Python que permite adicionar novos recursos a uma função.

Uma função decoradora é criada com outra função como parâmetro. Em seguida, a função decoradora adiciona o novo recurso à função que recebe.

	
		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('\nFunción con decoradores: ')
funcion_envoltorio()

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

Mas outra maneira mais eficiente de usar decoradores é usar @ e o nome do decorador antes da função.

Ou seja, primeiro o decorador é definido e, em seguida, uma função é chamada com o decorador definido.

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

	
		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 my_function(arg1, arg2, *args, **kwargs):
          # código de função aqui

5.4.1. `*args`.

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

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

	
		Hola, Alicia
Hola, Roberto
Hola, Carlos

5.4.2. `**kwargs`.

O **kwargs é usado da mesma forma, mas para enviar um número variável de argumentos de palavras-chave a uma função. Ao usar **kwargs, você pode enviar um número variável de argumentos para a função e especificar o valor de cada argumento usando seu nome. Os argumentos são recebidos pela função como um dicionário.

	
		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)

	
		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

Uma função call é uma pequena função anônima.

Uma função call pode receber qualquer número de argumentos, mas só pode ter uma expressão.

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

    argumentos lambda : expressão

	
		x = lambda a : a + 10
print(x(5))

	
		x = lambda a, b, c : a + b + c
print(x(5, 6, 2))

O poder do lambda é melhor demonstrado quando usado como uma função anônima dentro de outra função.

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

	
		mydoubler: 22
mytripler: 33

6.2. Função de mapa

A função map permite que você aplique uma função a cada elemento de uma estrutura iterável.

	
		lista = [1, 2, 3]
def funcion_mas_1(valor):
  return valor + 1
lista_modificada = list(map(funcion_mas_1, lista))
lista_modificada

	
		[2, 3, 4]

Isso é equivalente a usar a compreensão de lista.

	
		lista_modificada = [funcion_mas_1(x) for x in lista]
lista_modificada

	
		[2, 3, 4]

6.3. Função de filtro

A função filter permite que você selecione os elementos de uma estrutura iterável que atendam a uma característica.

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

	
		[2, 4, 6]

Isso é equivalente a usar a compreensão de lista.

	
		lista_filtrada = [x for x in lista if esPar(x)]
lista_filtrada

	
		[2, 4, 6]

6.4. Função `reduce`.

A função reduce permite a execução de tarefas cumulativas em estruturas iteráveis.

	
		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'\nacumulacion = {acumulacion}')

	
		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 compactar várias estruturas iteráveis em uma única, ou seja, é possível agrupar várias estruturas A_x em uma única estrutura B. A estrutura B consiste em tuplas dos elementos das estruturas A_x.

	
		nombres = ["Manolo", "Andres", "Fernando"]
altura = [181, 178, 180]
my_zip = list(zip(nombres, altura))
my_zip

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

6.5. Geradores

Suponha que queiramos iterar em uma sequência de números, mas de uma forma especial que não nos dê nenhum tipo de loop. Para poder fazer isso, a função geradora não precisa retornar o valor com return, mas com yield para que saiba que deve continuar a iteração.

	
		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)

Acabamos de criar um iterador para números múltiplos de 3

6.6. Funções de alta ordem

Podemos criar funções que recebem outras funções como parâmetros, de modo que a função que recebe outra função como parâmetro é chamada de função de alta ordem. Vamos dar uma olhada em um exemplo

	
		def increment(x):
    return x + 1
def hof(f, x):
    return 2*f(x)
print(hof(increment, 3))

Classes e objetos

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

Uma classe é como um construtor de objetos ou um "projeto" para a criação de objetos.

Para criar uma classe, use a palavra reservada class.

	
		class Clase:
        variable = 'MaximoFN'

Depois que a classe for criada, um objeto dessa classe poderá ser criado.

	
		class Clase:
  variable = 'MaximoFN'
objeto = Clase()
Clase.variable

	
		'MaximoFN'

Normalmente, as classes têm uma função inicial, que é executada quando um objeto da classe é criado. Essa função é chamada de dunder init e é escrita __init__(). A função dunder init deve sempre receber a variável self, que indica a própria classe e, em seguida, as variáveis que você deseja usar

Essa função é usada para inicializar as variáveis da classe ou para executar o código necessário ao criar um objeto da classe.

	
		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)

	
		Miguel
36

Além da função inicial dunder init, outras funções podem ser criadas. Essas funções são chamadas de métodos da classe. Esses métodos devem sempre receber a variável self.

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

	
		Hola mi nombre es Miguel y tengo 36 años

A variável self não precisa se chamar self, ela pode ter qualquer nome, mas dentro de cada classe ela deve ser sempre a mesma. Mas, por convenção, é comum usar self.

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

	
		Hola mi nombre es Miguel y tengo 36 años

As variáveis de objeto podem ser modificadas

	
		objeto_persona.nombre = 'Marta'
objeto_persona.saludar()

	
		Hola mi nombre es Marta y tengo 36 años

Até mesmo eliminá-los

	
		del objeto_persona.nombre

Você também pode excluir o objeto inteiro

	
		del objeto_persona.nombre
del objeto_persona

Se, por exemplo, quisermos criar a estrutura da classe, mas não quisermos codificar o interior da classe no momento, poderemos usar pass.

	
		del objeto_persona.nombre
del objeto_persona
class Persona:
        pass
      
      objeto_persona = Persona()

7.1. Herança

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

A classe pai é a classe da qual ela é herdada, também chamada de classe base.

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

Criamos uma classe pai

	
		del objeto_persona.nombre
del objeto_persona
class Persona:
  pass
objeto_persona = Persona()
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()

	
		Me llamo Laura Perez

Para criar a classe filha, é necessário indicar entre parênteses, ao declarar a classe, de qual classe ela herda.

	
		class Estudiante(Persona):
        pass

E ao criar o objeto da classe filha, os parâmetros de que a classe pai precisa são passados para ela.

	
		class Estudiante(Persona):
  pass
objeto_hijo = Estudiante("Mariano", "Sanz")
objeto_hijo.imprimir_nombre()

	
		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 duder init.

Se você reescrever a função dunder init, se quiser que a função dunder init da classe pai seja chamada, você deverá chamá-la.

Há duas maneiras de fazer isso: uma é por meio do nome da classe pai; nesse caso, você deve passar a variável self para ela.

	
		class Estudiante(Persona):
  def __init__(self, nombre, apellido):
    Persona.__init__(self, nombre, apellido)
objeto_hijo = Estudiante("Mariano", "Sanz")
objeto_hijo.imprimir_nombre()

	
		Me llamo Mariano Sanz

Outra forma é por meio de super(), caso em que você não precisa passar a variável self.

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

	
		Me llamo Mariano Sanz

Ao modificar funções, um novo código pode ser adicionado

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

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

Por fim, novos métodos podem ser adicionados

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

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

7.2. Sobrecarga do operador

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

	
		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)

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

Todas as possíveis sobrecargas operacionais são:

__add__(self, other): sobrecarrega o operador de adição (+).
__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 à direita (>>).
__and__(self, other): sobrecarrega o operador and (&).
__or__(self, other): sobrecarrega o operador or (|).
__xor__(self, other): sobrecarrega o operador xor (^).
__lt__(self, other): sobrecarrega o operador de comparação menor que (<).
__le__(self, other): sobrecarrega o operador de comparação menor que ou igual a (<=).
__eq__(self, other): sobrecarrega o operador de comparação igual a (==).
__ne__(self, other): sobrecarrega o operador de comparação diferente de (!=).
__gt__(self, other): sobrecarrega o operador de comparação maior que (>).
__ge__(self, other): sobrecarrega o operador de comparação maior que ou igual a (>=).
__neg__(self): sobrecarrega o operador de negação (-).
__pos__(self): sobrecarrega o operador de posição (+).
__abs__(self): sobrecarrega a função abs().
__invert__(self): sobrecarrega o operador de inversão (~).
__complex__(self): sobrecarrega a função complex().
__int__(self): sobrecarrega a função int().
__float__(self): sobrecarrega a função float().

7.3. Iteradores personalizados

Como vimos na seção 2 (Python data types), existem alguns tipos de dados que podem ser iterados. Mas podemos criar nossa própria classe iterável, desde que ela tenha as funções __len__ e __getitem__.

	
		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

Agora podemos iterar com o objeto de nossa classe com loops for, por exemplo.

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

	
		0 1 2 3 4 5 6 7 8 9

7.4. Chamada de objetos como funções

Talvez desejemos chamar um objeto de uma função como uma classe, o que pode ser feito adicionando a função __call__ à classe.

	
		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

7.5. Atributos e funções privados

Ao criar uma classe, podemos tornar alguns atributos ou funções privados e não acessíveis de fora da classe, adicionando __ antes do atributo class.

	
		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("\tNo se puede acceder al atributo privado")
print("Acceso al atributo privado: ", end="")
try:
    print(f"{privados.__privado}")
except:
    print("\tNo se puede acceder al atributo privado")
print("Acceso al atributo privado mediante el accesor: ", end="")
try:
    print(f"{privados.getPrivado()}")
except:
    print("\tNo 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("\tNo 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("\tNo se puede llamar a la función pública")

	
		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

Iteradores

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

Um iterador é um objeto que pode ser iterado, o que significa que ele pode percorrer todos os valores.

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

Listas, tuplas, dicionários e conjuntos são todos objetos iteráveis. Eles são contêineres iteráveis dos quais você pode obter um iterador.

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

	
		tupla = ("manzana", "plátano", "cereza")
iterable = iter(tupla)
print(next(iterable))
print(next(iterable))
print(next(iterable))

	
		manzana
plátano
cereza

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

	
		p l á t a n o

O loop for na verdade cria um objeto iterador e executa o método next() para cada loop.

	
		tupla = ("manzana", "plátano", "cereza")
for x in tupla:
  print(x)

	
		manzana
plátano
cereza

	
		string = "plátano"
for x in string:
  print(x, end=' ')

	
		p l á t a n o

8.1. Criar um objeto iterador

Para criar um objeto/classe como um iterador, os métodos __iter__() e __next__() devem ser implementados.

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

	
		1 2 3 4 5

O exemplo acima continuaria para sempre se você tivesse chamadas suficientes para next() ou se fosse usado em um loop for.

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

No método __next__(), podemos adicionar uma condição de término para gerar um erro se a iteração for executada um número especificado de vezes:

	
		class Numeros:
  def __iter__(self):
    self.a = 1
    return self
  def __next__(self):
    if self.a <= 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=' ')

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

8.2. Iterar obtendo o índice e o valor

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

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

	
		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 por dois objetos iteráveis ao mesmo tempo.

Se tivermos dois objetos iteráveis, cujo comprimento seja o mesmo, poderemos iterar por ambos ao mesmo tempo usando o método zip().

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

	
		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

Escopo das variáveis

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

9.1. Escopo local

Uma variável criada em uma função pertence ao escopo local dessa função e só pode ser usada dentro dela.

	
		def funcion():
  x = 300
  print(x)
funcion()

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

	
		def funcion():
  x = 300
  def funcion_interna():
    print(x)
  funcion_interna()
funcion()

9.2. Escopo global

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

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

	
		x = 300
def funcion():
  print(f'Ámbito local: {x}')
funcion()
print(f'Ámbito global: {x}')

	
		Ámbito local: 300
Ámbito global: 300

Se você criar duas variáveis, uma global e uma local, ambas com o mesmo nome, o Python as criará como duas variáveis diferentes.

	
		x = 300
def funcion():
  x = 200
  print(f'Variable local: {x}')
funcion()
print(f'Variable global: {x}')

	
		Variable local: 200
Variable global: 300

Se você precisar criar uma variável global, mas ela for declarada localmente, poderá usar a palavra-chave global.

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

	
		def funcion():
  global x
  x = 300
funcion()
print(f'Variable global: {x}')

	
		Variable global: 300

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

	
		x = 300
def funcion():
  global x
  x = 200
funcion()
print(f'Variable global: {x}')

	
		Variable global: 200

Módulos

Um módulo é um arquivo que contém um conjunto de funções que você deseja incluir em seu aplicativo.

Para criar um módulo, basta salvar o código desejado em um arquivo com a extensão .py.

Dica: nos notebooks Jupyter (o Colab é um notebook Jupyter on-line), se você digitar o caractere ! antes de um comando, poderá executar comandos do console.

Primeiro, vamos ver em que diretório estamos. Para isso, usamos o comando pwd (imprimir diretório de trabalho).

	
		!pwd

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

Vamos criar uma pasta para criar nossos módulos com o comando mkdir (criar diretório).

	
		!mkdir introduccion_python

Em seguida, vamos ver quais arquivos estão em nossa pasta. Para isso, usamos o comando ls (list).

	
		!mkdir introduccion_python
!ls introduccion_python

Vemos que ele está vazio, criamos um novo arquivo .py no qual criaremos nosso módulo.

	
		!mkdir introduccion_python
!ls introduccion_python
%%writefile introduccion_python/modulo1.py
def funcion_del_modulo(nombre):
  print("Hola, " + nombre)

	
		Writing introduccion_python/modulo1.py

Voltamos para ver quais arquivos estão em nossa pasta

	
		!ls introduccion_python

	
		modulo1.py  __pycache__

Vemos que um arquivo module1.py foi criado. Agora podemos usá-lo

Para usar um módulo externo, use a palavra import. Para usar as funções do módulo, você deve primeiro colocar o nome do módulo, um . e, em seguida, o nome da função que deseja usar.

	
		import introduccion_python.modulo1
introduccion_python.modulo1.funcion_del_modulo('MaximoFN')

	
		Hola, MaximoFN

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

	
		import introduccion_python.modulo1 as mod1
mod1.funcion_del_modulo('MaximoFN')

	
		Hola, MaximoFN

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

de <módulo> importar <função>

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

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

	
		Writing introduccion_python/modulo2.py

	
		from introduccion_python.modulo2 import funcion2_del_modulo
funcion2_del_modulo('MaximoFN')

	
		Hola, MaximoFN, funcion 2

Podemos usar não apenas os módulos que criamos, mas também os módulos que já estão instalados (módulos embutidos).

Por exemplo, podemos usar o módulo platform.

	
		import platform
x = platform.system()
x

	
		'Linux'

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

Agora, vamos criar um arquivo chamado module3.py.

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

	
		Overwriting introduccion_python/modulo3.py

Se agora importarmos module3.py para usar a função module_function, vamos ver o que acontece.

	
		import introduccion_python.modulo3 as mod3
print(mod3.funcion_del_modulo())

	
		Hola desde modulo3
Hola desde la función del modulo3

Podemos ver que o print do modulo3.py foi executado, mas não é o que queríamos. Isso ocorre porque, quando o arquivo modulo3.py é chamado, o python o executa como um script.

Mas e se quisermos executar o introduction_python/main.py como um script?

	
		!python introduccion_python/modulo3.py

	
		Hola desde modulo3

Vemos que apenas o print é executado, mas não a função module_function. Se quisermos ter a dualidade de funcionalidade do arquivo module3.py, ou seja, podemos importá-lo de outro módulo sem que ele seja executado como um script, executá-lo sozinho e fazer com que ele execute a função que desejamos, usaremos um entry point. Ou seja, usamos a condição if __name__ == '__main__': e, em seguida, indicamos o que queremos que seja executado. Vamos ver isso com um exemplo, vou reescrever o arquivo module3.py.

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

	
		Overwriting introduccion_python/modulo3.py

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

	
		import introduccion_python.modulo3 as mod3
print(mod3.funcion_del_modulo())

	
		Hola desde la función del modulo3

E se eu o executar como um script autônomo, a função module_function será executada.

	
		!python introduccion_python/modulo3.py

	
		Hola desde modulo3

Pacotes

No python, podemos criar nossos próprios pacotes. Para isso, criamos uma pasta com o nome do pacote

	
		!mkdir mi_paquete_de_python

Agora, criamos dois arquivos dentro de

	
		!mkdir mi_paquete_de_python
!touch mi_paquete_de_python/modulo1.py mi_paquete_de_python/modulo2.py

E escrevemos nelas

	
		!mkdir mi_paquete_de_python
!touch mi_paquete_de_python/modulo1.py mi_paquete_de_python/modulo2.py
%%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")

	
		Overwriting mi_paquete_de_python/modulo1.py

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

	
		Overwriting mi_paquete_de_python/modulo2.py

Agora podemos chamar as funções do nosso pacote

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

	
		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 e se o nosso pacote tiver dezenas de arquivos com funções que queremos usar, teremos que importar todos os arquivos um por um. Para evitar isso, você pode criar um arquivo __init__.py dentro do pacote, onde toda a importação de arquivos é feita.

	
		!touch mi_paquete_de_python/__init__.py

	
		!touch mi_paquete_de_python/__init__.py
%%writefile mi_paquete_de_python/__init__.py
import modulo1
import modulo2

	
		Overwriting mi_paquete_de_python/__init__.py

Agora podemos simplesmente importar nosso pacote, pois todos os módulos já foram importados internamente.

	
		import mi_paquete_de_python as mi_paquete
mi_paquete.modulo1.funcion1()
mi_paquete.modulo1.funcion2()
mi_paquete.modulo2.funcion1()
mi_paquete.modulo2.funcion2()

	
		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 forma, só precisamos fazer uma "importação".

12. Tente... Exceto

Quando ocorre um erro, ou uma exceção como é realmente chamado, o Python normalmente para e gera uma mensagem de erro.

Essas exceções podem ser tratadas com as instruções try e except.

	
		try:
  print(variable_no_declarada)
except:
  print("Ha ocurrido una excepción")

	
		Ha ocurrido una excepción

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

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

Você pode definir quantos blocos de exceção desejar, por exemplo, se quiser executar um bloco de código especial para um tipo especial de erro

	
		try:
  print(variable_no_declarada)
except NameError:
  print("La variable \'variable_no_declarada\' no está definida")
except:
  print("Algo inesperado ha ocurrido")

	
		La variable 'variable_no_declarada' no está definida

A palavra else pode ser usada para indicar o caso em que não ocorreu um erro.

	
		try:
  print('MaximoFN')
except NameError:
  print("Ha ocurrido una excepción")
else:
  print('Todo OK')

	
		MaximoFN
Todo OK

com a palavra finally, um código será executado no final, independentemente de ter ocorrido uma exceção ou não.

	
		try:
  print(variable_no_declarada)
except:
  print("Ha ocurrido una excepción")
finally:
  print("'try except' finallizado")

	
		Ha ocurrido una excepción
'try except' finallizado

Isso pode ser útil para fechar objetos e limpar recursos.

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

	
		Ha ocurrido una excepción

Criando uma exceção

Como desenvolvedor Python, você pode optar por lançar uma exceção se ocorrer uma condição.

Para lançar (ou gerar) uma exceção, use a palavra-chave raise.

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

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

É possível definir o tipo de erro a ser gerado e o texto a ser impresso para o usuário.

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

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

Palavras-chave ou palavras reservadas

Durante esta postagem, em várias ocasiões, apareceram palavras reservadas do Python ou "keywords", que são uma série de palavras reservadas pelo Python.

A seguir, uma lista das "palavras-chave

	
		import keyword
keyword.kwlist

	
		['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']

O Zen do Python

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

	
		import this

	
		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

Fundamentos de RAG

Esqueça o Ctrl+F! 🤯 Com RAG, seus documentos responderão às suas perguntas diretamente. 😎 Tutorial passo a passo com Hugging Face e ChromaDB. Liberte o poder da IA (e impressione seus amigos)! 💪

Conventional commits

😠 Seus commits parecem escritos em uma língua alienígena? 👽 Junte-se ao clube! 😅 Aprenda Conventional Commits em Python e pare de tortura sua equipe com mensagens enigmáticas. git-changelog e commitizen serão seus novos melhores amigos. 🤝

DoLa – Decoding by Contrasting Layers Improves Factuality in Large Language Models

Você já conversou com um LLM e ele lhe respondeu algo que parece ter bebido café de máquina a noite toda? 😂 Isso é o que chamamos de alucinação no mundo dos LLMs! Mas não se preocupe, pois não é que seu modelo de linguagem esteja louco (embora às vezes possa parecer isso 🤪). A verdade é que os LLMs podem ser um pouco... criativos quando se trata de gerar texto. Mas graças ao DoLa, um método que usa camadas de contraste para melhorar a viabilidade dos LLMs, podemos evitar que nossos modelos de linguagem se transformem em escritores de ficção científica 😂. Nesta publicação, explicarei como o DoLa funciona e mostrarei um exemplo de código para que você possa entender melhor como tornar seus LLMs mais confiáveis e menos propensos a inventar histórias. Vamos salvar nossos LLMs da loucura e torná-los mais úteis! 🚀

Últimos posts -->

Você viu esses projetos?

Subtify

GPU monitor

Alfred

Ver todos os projetos -->

Quer aplicar IA no seu projeto? Entre em contato!

Quer melhorar com essas dicas?

Memory Calculator

Espaço para calcular a memória necessária para executar um modelo

Formatador de código Black

Seu colega Filipao está escrevendo código que é difícil de ler? Compartilhe com ele este formatador de código que eu mostro neste post! Venha e aprenda a formatar o código para torná-lo mais compreensível. Não vamos resolver os problemas de Filipao, mas pelo menos você não sofrerá ao lê-lo

Declare redes neurais de forma clara

Declare redes neurais de forma clara no Pytorch

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