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.

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: str2. Numéricos: int, float, complex3. Sequências: list, tuple, range4. Mapeamento: dict5. Conjuntos: set, frozenset6. Booleanos: bool7. Binários: bytes, bytearray, memoryview

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

	
		type(5.)

	
		float

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

	
		a = 5
type(a)

int

	
		a = 'MaximoFN'
type(a)

str

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

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

	
		(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 '.

	
		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, pode-se introduzi-la 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, vemos que no meio foi inserido o caractere , este caractere indica a quebra de linha. Se usarmos a função print() veremos como já não aparece

	
		print(string)

	
		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.

	
		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 da nossa string através da função len()

	
		len(string)

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

	
		'ejemplo' in string

	
		True

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

	
		print(string.upper())

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

tudo em 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 strings neste enlace

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

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

	
		'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 \"

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

	
		Este es el blog de "MaximoFN"

O mesmo com a aspa simples, adicionamos \'

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

	
		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) \\.

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

	
		Este es el blog de \MaximoFN\

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

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

	
		Este es el blog de 
MaximoFN

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

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

	
		Este es el blog de MaximoFN

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

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

	
		Este es el blog de 	MaximoFN

Podemos apagar um caractere com \b

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

	
		Este es el blog deMaximoFN

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

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

	
		MaximoFN

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

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

	
		MaximoFN

Por último, podemos converter outro tipo de dado 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 de tipo inteiro

	
		n = 5
n, type(n)

	
		(5, int)

2.2.2. Float

Números de 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

Pode-se 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 guardam múltiplos itens em uma variável. Elas são declaradas através dos 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 mediante 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ça a contar a partir da posição 0, ou seja, se quisermos obter o primeiro elemento da 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 da lista quisermos a penúltima

	
		lista[-2]

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

	
		lista[2:5]

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

	
		lista[:5]

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

	
		lista[3:]

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

	
		lista[-3:-1]

	
		['item4', 5]

Pode-se verificar se um item está na lista

	
		'item4' in lista

	
		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.

	
		lista[2] = False
lista

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

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

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

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

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

	
		lista.append('item7')
lista

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

	
		lista.insert(2, 'insert')
lista

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

Listas podem ser unidas através do 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 através de outra lista, pode ser feito através de outro tipo de dado iterável do Python (tuplas, sets, 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 eliminar uma posição determinada mediante o método pop()

	
		lista.pop(2)
lista

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

	
		lista.pop()
lista

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

	
		lista.remove('item7')
lista

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

	
		del lista[3]
lista

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

	
		lista.clear()
lista

[]

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

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

Também é possível obter o primeiro índice de um item com um valor determinado através do 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 através 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']

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.

	
		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 = [expressão for item in iterável if condição == True]```

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

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

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

2.3.1.3. Ordenar listas

Para ordenar listas usamos o método sort()

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

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

Também as ordena alfabeticamente

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

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

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

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

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

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

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

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

Podem ser ordenados da maneira que quisermos 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]

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

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

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

Pode-se 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. Copiar listas

Não se pode copiar listas com lista1 = lista2, pois se lista1 for modificada, lista2 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, é necessário 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]

Ó hay que usar o construtor de listas 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

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

O mediante 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 forma de concatenar é repetir a tupla X vezes mediante 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, 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.

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

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

Pode-se obter seu comprimento através da 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 da tupla, procede-se da mesma forma que com 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. 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.

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

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

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

	
		tupla eliminada

2.3.2.2. Desempacotar 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 tirar menos dados que o comprimento da tupla, adicionamos um *

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

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

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

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

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

2.3.2.3. Concatenar tuplas

Tuplas podem ser concatenadas utilizando o operador +

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

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

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

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

	
		('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.

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

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

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

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)

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

	
		0 1 2 3 4

Se por exemplo não quisermos que 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 último, se não quisermos que se incremente 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: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.

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

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

Como foi dito, não permitem duplicidades.

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

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

	
		len(diccionario)

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

	
		diccionario["model"]

	
		'Mustang'

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

	
		diccionario.get("model")

	
		'Mustang'

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

	
		diccionario.keys()

	
		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

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

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

	
		diccionario.values()

	
		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.

	
		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 items inteiros forem desejados, ou seja, keys e values, deve-se usar o método items().

	
		diccionario.items()

	
		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

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

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

	
		"model" in diccionario

	
		True

2.4.2. Modificar os itens

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 através do 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. Adicionar itens

Pode adicionar um item adicionando-o desta maneira:

	
		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 através 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. Remover itens

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

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

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

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

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

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

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

	
		diccionario eliminado

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

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

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

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

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

{}

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.

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

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

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

Ó hay que usar o construtor de dicionários 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 items de qualquer tipo de dado, inclusive outros dicionários. A este tipo de dicionários se les denomina dicionários nested

	
		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 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
      ``` python
      dictionary_comprehension = {expressão_chave: expressão_valor for item in iterável if condição == True}```
      
      Vamos ver um exemplo

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

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

	
		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 encontrar algum item duplicado, fica apenas com um.

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

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

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

	
		len(set_)

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

	
		'item4' in set_

	
		True

2.5.1.1. Adicionar itens

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

	
		set_.add(8.8)
set_

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

Pode-se adicionar outro conjunto 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'}

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

	
		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. Eliminar itens

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

	
		set_.remove('item9')
set_

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

O mediante o discard()

	
		set_.discard('item6')
set_

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

	
		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

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

	
		set_.clear()
set_

	
		set()

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

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

	
		set eliminado

2.5.1.3. Unir itens

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

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

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

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

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

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

	
		{'apple'}

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

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

	
		{'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.

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

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

Se quisermos ficar com os não duplicados sem criar um novo conjunto, usamos 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. 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

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

	
		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

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

	
		byte = b"MaximoFN"
byte

	
		b'MaximoFN'

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

	
		byte = bytes(10)
byte

b''

	
		byte = bytes(range(10))
byte

	
		b'	'

Bytes podem ser concatenados utilizando o operador +

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

	
		b'DeepMaxFN'

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

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

	
		b'MaximoFN MaximoFN MaximoFN '

Podemos verificar se um caractere está dentro da string

	
		b'D' in byte1

	
		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.

	
		byte_array = bytearray(b'MaximoFN')
byte_array

	
		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.

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

	
		3 + 5

Operador subtração -

	
		3 - 5

-2

Operador de multiplicação *

	
		3 * 5

Operador divisão /

	
		3 / 5

0.6

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

	
		25 % 2

Operador exponencial **

	
		5 ** 2

Operador divisão inteira //

	
		25 // 2

3.2. Operadores de comparação

Operador é igual ==

	
		1 == 1

	
		True

Operador diferente !=

	
		1 != 2

	
		True

Operador é maior que >

	
		3 > 2

	
		True

Operador é menor que <

	
		2 < 3

	
		True

Operador é maior ou igual que >=

	
		3 >= 3

	
		True

Operador é menor ou igual que <=

	
		3 <= 3

	
		True

3.3. Operadores lógicos

Operador and

	
		True and True

	
		True

Operador or

	
		True or False

	
		True

Operador not

	
		not False

	
		True

34. Operadores de identidade

Operador is

	
		5.3 is 5.3

	
		True

Operador is not

	
		5.3 is not 5

	
		True

35. Operadores de pertinência

Operador in

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

	
		True

Operador not in

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

	
		True

36. Operadores bit a bit

Operador AND &

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

Operador OU |

	
		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 para a esquerda <<

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

Operador de deslocamento para a direita >>

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

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

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

	
		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 se execute algo em caso de que não se cumpra nenhuma das condições indicadas, 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

Igual, 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 quisermos fazer a estrutura do if mas não quisermos, por enquanto, codificar uma das condições, 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 bloco 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 bucle pare por alguma condição usamos 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 se execute por algum motivo, usamos continue

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

	
		MaximoFN

Com else é possível executar um bloco de código se a condição do 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 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)

	
		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 se pode iterar pelos sets, mas como são elementos não ordenados, não teremos 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 bucle pare por alguma condição usamos break

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

	
		Maximo

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

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

	
		MaximoFN

Com else é possível executar um bloco de código se a condição do 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, se quisermos fazer a estrutura do for mas não quisermos, por enquanto, codificar seu interior, podemos usar 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 é 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.

	
		def funcion():
  print('MaximoFN')

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

	
		funcion()

	
		MaximoFN

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

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

	
		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

	
		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

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

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

	
		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.

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

	
		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.

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

	
		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

	
		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 devolver dados, isso é feito através da 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

Podem devolver mais de um dado

	
		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 um dos dados devolvidos não nos interessar, podemos ignorá-lo utilizando _

	
		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 quisermos criar a estrutura da função, mas não quisermos, por enquanto, codificar o interior, podemos usar pass

	
		def funcion():
  pass
 
funcion()

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

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

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.

	
		abs(-5)

A seguir-se 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

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.

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

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

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

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

	
		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.

	
		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

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

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

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

O poder de lambda mostra-seu melhor quando as usa 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 `map`

A função map permite aplicar 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]

Isto é equivalente a usar list comprehension

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

	
		[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

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