Aviso: Este post foi traduzido para o português usando um modelo de tradução automática. Por favor, me avise se encontrar algum erro.
1. Resumo
Vamos fazer uma breve introdução ao Python, explicando os tipos de dados que temos, os operadores, o uso de funções e de classes. Além disso, veremos como usar objetos iteráveis, como usar módulos, etc.
2. Tipos de dados do Python
Existem 7 tipos de dados em Python
- De tipo texto:
str - Numéricos:
int,float,complex - Sequências:
list,tuple,range - Mapeamento:
dict - Conjuntos:
set,frozenset - Booleanos:
bool - Binários:
bytes,bytearray,memoryview
Podemos obter o tipo de dado através da função type()
type(5.)Copied
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 = 5type(a)Copied
int
a = 'MaximoFN'type(a)Copied
str
Python tipa as variáveis para você, mas se você quiser tipá-las, pode fazer.
b = int(5.1)type(b), bCopied
(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"stringCopied
'MaximoFN'
string = 'MaximoFN'stringCopied
'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 decomo estoy introduciendo un stringen varias lineas"""stringCopied
'Este es un ejemplo de como estoy introduciendo un string en varias lineas'
string = '''Este es un ejemplo decomo estoy introduciendo un stringen varias lineas'''stringCopied
'Este es un ejemplo de como estoy introduciendo un string en varias lineas'
No entanto, vemos que no meio foi inserido o caractere indica a quebra de linha. Se usarmos a função print() veremos como já não aparece
print(string)Copied
Este es un ejemplo decomo estoy introduciendo un stringen 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 lineaprint(string[i], end='')Copied
Este es un
Podemos obter o comprimento da nossa string através da função len()
len(string)Copied
73
Verificar se há uma string específica dentro da nossa
'ejemplo' in stringCopied
True
As strings têm certos atributos úteis, como colocar tudo em maiúsculas
print(string.upper())Copied
ESTE ES UN EJEMPLO DECOMO ESTOY INTRODUCIENDO UN STRINGEN VARIAS LINEAS
tudo em minúsculas
print(string.lower())Copied
este es un ejemplo decomo estoy introduciendo un stringen varias lineas
Substituir caracteres
print(string.replace('o', '@'))Copied
Este es un ejempl@ dec@m@ est@y intr@duciend@ un stringen varias lineas
Obter todas as palavras
print(string.split())Copied
['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 + string2Copied
'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"")Copied
Este es el blog de "MaximoFN"
O mesmo com a aspa simples, adicionamos \'
print('Este es el blog de 'MaximoFN'')Copied
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\\')Copied
Este es el blog de \MaximoFN\
Já vimos antes o escape character de nova linha \n
print('Este es el blog de \nMaximoFN')Copied
Este es el blog deMaximoFN
Se quisermos escrever desde o início da linha, adicionamos \r
print('Esto no se imprimirá \rEste es el blog de MaximoFN')Copied
Este es el blog de MaximoFN
Se quisermos adicionar um grande espaço (recuo) usamos \t
print('Este es el blog de \tMaximoFN')Copied
Este es el blog de MaximoFN
Podemos apagar um caractere com \b
print('Este es el blog de \bMaximoFN')Copied
Este es el blog deMaximoFN
Podemos adicionar o código ASCII em octal mediante \ooo
print('\115\141\170\151\155\157\106\116')Copied
MaximoFN
O adicionar o código ASCII em hexadecimal mediante \xhh
print('\x4d\x61\x78\x69\x6d\x6f\x46\x4e')Copied
MaximoFN
Por último, podemos converter outro tipo de dado em uma string
n = 5print(type (n))string = str(n)print(type(string))Copied
<class 'int'><class 'str'>
2.2. Números
2.2.1. Inteiros
Números de tipo inteiro
n = 5n, type(n)Copied
(5, int)
2.2.2. Float
Números de tipo ponto flutuante
n = 5.1n, type(n)Copied
(5.1, float)
2.2.3. Complexos
Números complexos
n = 3 + 5jn, type(n)Copied
((3+5j), complex)
2.2.4. Conversão
Pode-se converter entre tipos de números
n = 5n = float(n)n, type(n)Copied
(5.0, float)
n = 5.1n = complex(n)n, type(n)Copied
((5.1+0j), complex)
n = 5.1n = int(n)n, type(n)Copied
(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']listaCopied
['item0', 'item1', 'item2', 'item3', 'item4', 'item5']
Podemos obter o comprimento de uma lista mediante a função len()
len(lista)Copied
6
As listas podem ter itens de diferentes tipos
lista = ['item0', 1, True, 5.3, "item4", 5, 6.6]listaCopied
['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]Copied
'item0'
Mas uma das coisas poderosas do Python é que, se quisermos acessar a última posição, podemos usar índices negativos
lista[-1]Copied
6.6
Se em vez da última posição da lista quisermos a penúltima
lista[-2]Copied
5
Se quisermos apenas um intervalo de valores, por exemplo, do segundo ao quinto item, acessamos através de [2:5]
lista[2:5]Copied
[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]Copied
['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:]Copied
[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]Copied
['item4', 5]
Pode-se verificar se um item está na lista
'item4' in listaCopied
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] = FalselistaCopied
['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]listaCopied
['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')listaCopied
['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')listaCopied
['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)listaCopied
['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)listaCopied
['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)listaCopied
['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()listaCopied
['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')listaCopied
['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]listaCopied
['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()listaCopied
[]
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)Copied
4
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)Copied
0
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 listafor x in fruits:# Si el item contiene el caracter "a" lo añadimos a newlistif "a" in x:newlist.append(x)newlistCopied
['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]newlistCopied
['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]newlistCopied
['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()listaCopied
[3, 4, 5, 5, 6, 8, 9]
Também as ordena alfabeticamente
lista = ["orange", "mango", "kiwi", "pineapple", "banana"]lista.sort()listaCopied
['banana', 'kiwi', 'mango', 'orange', 'pineapple']
Ao ordenar alfabeticamente, distinga entre maiúsculas e minúsculas.
lista = ["orange", "mango", "kiwi", "Pineapple", "banana"]lista.sort()listaCopied
['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)listaCopied
[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 - 50return abs(n - 50)lista = [100, 50, 65, 82, 23]lista.sort(key = myfunc)listaCopied
[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)listaCopied
['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()listaCopied
[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 = lista1lista1[0] = Truelista2Copied
[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] = Truelista2Copied
[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] = Truelista2Copied
[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 + lista2listaCopied
[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)lista1Copied
[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 * 3lista2Copied
['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)tuplaCopied
('item0', 1, True, 3.3, 'item4', True)
Pode-se obter seu comprimento através da função len()
len (tupla)Copied
6
Para criar tuplas com um único elemento é necessário adicionar uma vírgula
tupla = ('item0',)tupla, type(tupla)Copied
(('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])Copied
item0True(True, 3.3)(True, 3.3)
Podemos verificar se há um item na tupla
'item4' in tuplaCopied
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)tuplaCopied
('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 tuplaif 'tupla' not in locals():print("tupla eliminada")Copied
tupla eliminada
2.3.2.2. Desempacotar tuplas
Quando criamos tuplas, na verdade estamos empacotando dados
tupla = ('item0', 1, True, 3.3, 'item4', True)tuplaCopied
('item0', 1, True, 3.3, 'item4', True)
mas podemos desempacotá-los
item0, item1, item2, item3, item4, item5 = tuplaitem0, item1, item2, item3, item4, item5Copied
('item0', 1, True, 3.3, 'item4', True)
Se quisermos tirar menos dados que o comprimento da tupla, adicionamos um *
item0, item1, item2, *item3 = tuplaitem0, item1, item2, item3Copied
('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 = tuplaitem0, item1, item2, item5Copied
('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 + tupla2tupla3Copied
('a', 'b', 'c', 1, 2, 3)
Outra forma de concatenar é repetir a tupla X vezes mediante o operador *
tupla1 = ("a", "b" , "c")tupla2 = tupla1 * 3tupla2Copied
('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)Copied
4
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)Copied
0
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='')Copied
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='')Copied
2 3 4
for i in range(-2, 5):print(f'{i} ', end='')Copied
-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='')Copied
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"]}diccionarioCopied
{'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"]Copied
2000
Pode-se obter seu comprimento através da função len()
len(diccionario)Copied
4
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"]Copied
'Mustang'
Também pode ser acessado através do método get
diccionario.get("model")Copied
'Mustang'
Para saber todas as keys dos dicionários se pode usar o método keys()
diccionario.keys()Copied
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 keysx = diccionario.keys()print(x)# Se añade una nueva keydiccionario["color"] = "white"# Se consulta la variable que apunta a las keyprint(x)Copied
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()Copied
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 valuesx = diccionario.values()print(x)# Se modifica un valuediccionario["year"] = 2020# Se consulta la variable que apunta a los valuesprint(x)Copied
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()Copied
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 itemsx = diccionario.items()print(x)# Se modifica un valuediccionario["year"] = 2020# Se consulta la variable que apunta a los itemsprint(x)Copied
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 diccionarioCopied
True
2.4.2. Modificar os itens
Pode modificar um item acessando-o diretamente
diccionario = {"brand": "Ford","model": "Mustang","year": 1964}# Se modifica un itemdiccionario["year"] = 2020diccionarioCopied
{'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 itemdiccionario.update({"year": 2020})diccionarioCopied
{'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 itemdiccionario["colour"] = "blue"diccionarioCopied
{'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 itemdiccionario.update({"colour": "blue"})diccionarioCopied
{'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 itemdiccionario.pop("model")diccionarioCopied
{'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 itemdel diccionario["model"]diccionarioCopied
{'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 itemdel diccionarioif 'diccionario' not in locals():print("diccionario eliminado")Copied
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 introducidodiccionario.popitem()diccionarioCopied
{'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()diccionarioCopied
{}
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 = diccionario1diccionario1["year"] = 2000diccionario2["year"]Copied
2000
Portanto, é necessário usar o método copy()
diccionario1 = {"brand": "Ford","model": "Mustang","year": 1964}diccionario2 = diccionario1.copy()diccionario1["year"] = 2000diccionario2["year"]Copied
1964
Ó hay que usar o construtor de dicionários dict()
diccionario1 = {"brand": "Ford","model": "Mustang","year": 1964}diccionario2 = dict(diccionario1)diccionario1["year"] = 2000diccionario2["year"]Copied
1964
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_nestedCopied
{'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_nestedCopied
{'child1': {'name': 'Emil', 'year': 2004},'child2': {'name': 'Tobias', 'year': 2007},'child3': {'name': 'Linus', 'year': 2011}}
2.4.7. Métodos dos dicionários
Estes são os métodos que podem ser usados em dicionários
2.4.8. Compreensão de dicionário
Igual que podíamos fazer list comprehensions mediante a sintaxe
list_comprehension = [expressão for item in iterável if condição == True]Podemos fazer dictionaries comprehensions mediante a seguinte sintaxe
dictionary_comprehension = {expressão_chave: expressão_valor for item in iterável if condição == True}Vamos ver um exemplo
dictionary_comprehension = {x: x**2 for x in (2, 4, 6) if x > 2}dictionary_comprehensionCopied
{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_Copied
{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_Copied
{1, 5, 5.3, 6.6, 'item0', 'item4'}
Pode-se obter o comprimento do set através da função len()
len(set_)Copied
6
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_Copied
True
2.5.1.1. Adicionar itens
Pode-se adicionar um elemento ao conjunto usando o método add()
set_.add(8.8)set_Copied
{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_Copied
{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_Copied
{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_Copied
{1, 10, 11.2, 5, 5.3, 6.6, 7, 8.8, 'item0', 'item4', 'item5', 'item6'}
O mediante o discard()
set_.discard('item6')set_Copied
{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}")Copied
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_Copied
set()
Por último, com del pode-se eliminar o set
del set_if 'set_' not in locals():print("set eliminado")Copied
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)set3Copied
{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)set1Copied
{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)set3Copied
{'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)set1Copied
{'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)set3Copied
{'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)set1Copied
{'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))Copied
TrueTrueFalse
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(""))Copied
TrueFalse
print(bool(3))print(bool(0))Copied
TrueFalse
lista = [1, 2, 3]print(bool(lista))lista = []print(bool(lista))Copied
TrueFalse
tupla = (1, 2, 3)print(bool(tupla))tupla = ()print(bool(tupla))Copied
TrueFalse
diccionario = {"brand": "Ford","model": "Mustang","year": 1964,"colors": ["red", "white", "blue"]}print(bool(diccionario))diccionario.clear()print(bool(diccionario))Copied
TrueFalse
set_ = {'item0', 1, 5.3, "item4", 5, 6.6}print(bool(set_))set_.clear()print(bool(set_))Copied
TrueFalse
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"byteCopied
b'MaximoFN'
Também podem ser criados através do seu construtor bytes()
byte = bytes(10)byteCopied
b' '
byte = bytes(range(10))byteCopied
b' '
Bytes podem ser concatenados utilizando o operador +
byte1 = b'DeepMax'byte2 = b'FN'byte3 = byte1 + byte2byte3Copied
b'DeepMaxFN'
Ou através da repetição com o operador *
byte1 = b'MaximoFN 'byte2 = byte1 * 3byte2Copied
b'MaximoFN MaximoFN MaximoFN '
Podemos verificar se um caractere está dentro da string
b'D' in byte1Copied
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_arrayCopied
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]= 74print(f'Después de acceder a la memoria: {byte_array}')Copied
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 + 5Copied
8
Operador subtração -
3 - 5Copied
-2
Operador de multiplicação *
3 * 5Copied
15
Operador divisão /
3 / 5Copied
0.6
Operador módulo %. Retorna o resto de uma divisão.
25 % 2Copied
1
Operador exponencial **
5 ** 2Copied
25
Operador divisão inteira //
25 // 2Copied
12
3.2. Operadores de comparação
Operador é igual ==
1 == 1Copied
True
Operador diferente !=
1 != 2Copied
True
Operador é maior que >
3 > 2Copied
True
Operador é menor que <
2 < 3Copied
True
Operador é maior ou igual que >=
3 >= 3Copied
True
Operador é menor ou igual que <=
3 <= 3Copied
True
3.3. Operadores lógicos
Operador and
True and TrueCopied
True
Operador or
True or FalseCopied
True
Operador not
not FalseCopied
True
34. Operadores de identidade
Operador is
5.3 is 5.3Copied
True
Operador is not
5.3 is not 5Copied
True
35. Operadores de pertinência
Operador in
x = ["apple", "banana"]"banana" in xCopied
True
Operador not in
x = ["apple", "banana"]"orange" not in xCopied
True
36. Operadores bit a bit
Operador AND &
a = 60 # 60 = 0011 1100b = 13 # 13 = 0000 1101c = a & b; # 12 = 0000 1100cCopied
12
Operador OU |
a = 60 # 60 = 0011 1100b = 13 # 13 = 0000 1101c = a | b; # 61 = 0011 1101cCopied
61
Operador XOR ^
a = 60 # 60 = 0011 1100b = 13 # 13 = 0000 1101c = a ^ b; # 49 = 0011 0001cCopied
49
Operador NOT ~
a = 60 # 60 = 0011 1100c = ~a; # -61 = 1100 0011cCopied
-61
Operador de deslocamento para a esquerda <<
a = 60 # 60 = 0011 1100c = a << 2; # 240 = 1111 0000cCopied
240
Operador de deslocamento para a direita >>
a = 60 # 60 = 0011 1100c = a >> 2; # 15 = 0000 1111cCopied
15
37. Operadores de atribuição
Operador =
a = 5aCopied
5
Operador +=. x += y é equivalente a x = x + y
a += 5aCopied
10
Operador -=. x -= y é equivalente a x = x - y
a -= 5aCopied
5
Operador *=. x *= y é equivalente a x = x * y
a *= 3aCopied
15
Operador /=. x /= y é equivalente a x = x / y
a /= 3aCopied
5.0
Operador %=. x %= y é equivalente a x = x % y
a = 25a %= 2aCopied
1
Operador //=. x //= y é equivalente a x = x // y
a = 25a //= 2aCopied
12
Operador **=. x **= y é equivalente a x = x ** y
a = 5a **= 2aCopied
25
Operador &=. x &= y é equivalente a x = x & y
a = 60 # 60 = 0011 1100b = 13 # 13 = 0000 1101a &= b; # 12 = 0000 1100aCopied
12
Operador |=. x |= y é equivalente a x = x | y
a = 60 # 60 = 0011 1100b = 13 # 13 = 0000 1101a |= b; # 61 = 0011 1101aCopied
61
Operador ^=. x ^= y é equivalente a x = x ^ y
a = 60 # 60 = 0011 1100b = 13 # 13 = 0000 1101a ^= b; # 49 = 0011 0001aCopied
49
Operador >>=. x >>= y é equivalente a x = x >> y
a = 60 # 60 = 0011 1100a <<= 2; # 240 = 1111 0000aCopied
240
Operador <<=. x <<= y é equivalente a x = x << y
a = 60 # 60 = 0011 1100a >>= 2; # 15 = 0000 1111aCopied
15
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')Copied
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')Copied
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')Copied
MaximoFN tiene 8 caracteres
Se quisermos escrever tudo em uma única linha
if len('MaximoFN') == 8: print('MaximoFN tiene 8 caracteres')Copied
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')Copied
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:passelse:print('MaximoFN tiene 8 caracteres')Copied
MaximoFN tiene 8 caracteres
4.2. Enquanto
O bloco while é executado enquanto a condição for True
i = 0string = 'MaximoFN'while len(string) > i:print(string[i], end='')i += 1Copied
MaximoFN
Se quisermos que o bucle pare por alguma condição usamos break
i = 0string = 'MaximoFN'while len(string) > i:if string[i] == 'F':breakprint(string[i], end='')i += 1Copied
Maximo
Se quisermos que uma das iterações não se execute por algum motivo, usamos continue
i = 0string = 'Maximo FN'while len(string) > i:if string[i] == ' ':i += 1continueprint(string[i], end='')i += 1Copied
MaximoFN
Com else é possível executar um bloco de código se a condição do while não for True
i = 0string = 'MaximoFN'while len(string) > i:print(string[i], end='')i += 1else:print(" Se ha terminado el while")Copied
MaximoFNSe 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='')Copied
MaximoFN
lista = ['M', 'a', 'x', 'i', 'm', 'o', 'F', 'N']for x in lista:print(x, end='')Copied
MaximoFN
tupla = ('M', 'a', 'x', 'i', 'm', 'o', 'F', 'N')for x in tupla:print(x, end='')Copied
MaximoFN
string = 'MaximoFN'for i in range(len(string)):print(string[i], end='')Copied
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='')Copied
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='')Copied
NximoaMF
Se quisermos que o bucle pare por alguma condição usamos break
string = 'MaximoFN'for x in string:if x == 'F':breakprint(x, end='')Copied
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 == ' ':continueprint(x, end='')Copied
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(" Se ha terminado el for")Copied
MaximoFNSe 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:passprint('Interior del for no codificado')Copied
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')Copied
Para chamar a função, basta escrever seu nome.
funcion()Copied
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")Copied
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")Copied
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")Copied
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")Copied
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")Copied
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"])Copied
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 stringprint(funcion(["Blog", "de", "MaximoFN"]))Copied
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, string2dato0, dato1, dato2 = funcion(["Blog", "de", "MaximoFN"])print(dato0 + ' ' + dato1 + ' ' + dato2)Copied
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)Copied
MaximoFN
Se quisermos criar a estrutura da função, mas não quisermos, por enquanto, codificar o interior, podemos usar pass
def funcion():passfuncion()Copied
A função pode chamar a si mesma, a isso se chama recursão ou recursividade da função.
Por exemplo, podemos usar esta qualidade para calcular o fatorial de um número
def factorial(n):if n == 0 or n == 1:return 1else:return n * factorial(n-1)factorial(5)Copied
120
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)Copied
5
A seguir-se uma lista dessas funções
import builtinsdir(builtins)Copied
['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"Nonehelp(funcion)Copied
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__Copied
'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 envoltoriodef funcion():print("MaximoFN")funcion_envoltorio = decorador(funcion)print('Función sin decoradores: ')funcion()print(' Función con decoradores: ')funcion_envoltorio()Copied
Función sin decoradores:MaximoFNFunció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@decorador2def funcion2():print("MaximoFN")print('Función con decoradores: ')funcion2()Copied
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 aqui2.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")Copied
Hola, AliciaHola, RobertoHola, 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)Copied
Hola Juan, tu edad es 22 añosHola Maria, tu edad es 32 añosHola 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ãox = lambda a : a + 10print(x(5))Copied
15
x = lambda a, b, c : a + b + cprint(x(5, 6, 2))Copied
13
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 * nmydoubler = myfunc(2)mytripler = myfunc(3)print(f"mydoubler: {mydoubler(11)}")print(f"mytripler: {mytripler(11)}")Copied
mydoubler: 22mytripler: 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 + 1lista_modificada = list(map(funcion_mas_1, lista))lista_modificadaCopied
[2, 3, 4]
Isto é equivalente a usar list comprehension
lista_modificada = [funcion_mas_1(x) for x in lista]lista_modificadaCopied
[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 == 0lista_filtrada = list(filter(esPar, lista))lista_filtradaCopied
[2, 4, 6]
Isto é equivalente a usar list comprehension
lista_filtrada = [x for x in lista if esPar(x)]lista_filtradaCopied
[2, 4, 6]
6.4. Função reduce
A função reduce permite realizar tarefas acumulativas sobre estruturas iteráveis.
from functools import reducelista = [1, 22, 33]def acumular(valor, acumulador):print(f'valor = {valor}, acumulador = {acumulador}, acumulacion = {valor + acumulador}')return valor + acumuladoracumulacion = reduce(acumular, lista)print(f' acumulacion = {acumulacion}')Copied
valor = 1, acumulador = 22, acumulacion = 23valor = 23, acumulador = 33, acumulacion = 56acumulacion = 56
6.5. Função zip
Com a função zip, é possível combinar várias estruturas iteráveis em uma única, ou seja, permite agrupar vários elementos das estruturas *Ax* em uma única estrutura *B*. A estrutura *B* é formada por tuplas dos elementos das estruturas *Ax*.
nombres = ["Manolo", "Andres", "Fernando"]altura = [181, 178, 180]my_zip = list(zip(nombres, altura))my_zipCopied
[('Manolo', 181), ('Andres', 178), ('Fernando', 180)]
6.5. Geradores
Suponhamos que queremos iterar sobre uma sequência de números, mas de uma maneira especial que não nos oferece nenhum tipo de bucle. Isso podemos resolver com os geradores. Para poder fazer isso, a função geradora não tem que devolver o valor com return, mas com yield para que saiba que tem que seguir iterando.
def iterador_custom(N):for i in range (N):if i % 3 == 0:yield igenerador = iterador_custom(20)for i in generador:print(i)Copied
0369121518
Acabamos de fazer um iterador por números múltiplos de 3
6.6. Funções de ordem superior
Podemos criar funções que recebem outras funções como parâmetros, de maneira que a função que recebe outra função como parâmetro é chamada de função de ordem superior (high order function). Vejamos um exemplo
def increment(x):return x + 1def hof(f, x):return 2*f(x)print(hof(increment, 3))Copied
8
7. Classes e objetos
Python é uma linguagem de programação orientada a objetos. Quase tudo em Python é um objeto, com seus atributos e métodos.
classe é como um construtor de objetos ou um "plano" para criar objetos.
Para criar uma classe, usa-se a palavra reservada class
class Clase:variable = 'MaximoFN'Copied
vez criada a classe, pode-se criar um objeto dessa classe
objeto = Clase()Clase.variableCopied
'MaximoFN'
Normalmente as classes têm uma função inicial, que é executada quando se cria um objeto da classe. Esta função é denominada *dunder init* e é escrita __init__(). À função *dunder init* deve-se sempre passar a variável self, que indica a própria classe, e em seguida, as variáveis que se deseja passar.
Com esta função, geralmente se inicializam as variáveis das classes ou se executa o código necessário quando um objeto da classe é criado.
class Persona:def __init__(self, nombre, edad):self.nombre = nombreself.edad = edadobjeto_persona = Persona("Miguel", 36)print(objeto_persona.nombre)print(objeto_persona.edad)Copied
Miguel36
Além da função inicial *dunder init*, podem ser criadas mais funções. A estas funções chamamos *métodos* da classe. A estes *métodos* sempre é necessário passar a variável self
class Persona:def __init__(self, nombre, edad):self.nombre = nombreself.edad = edaddef saludar(self):print(f'Hola mi nombre es {self.nombre} y tengo {self.edad} años')objeto_persona = Persona("Miguel", 36)objeto_persona.saludar()Copied
Hola mi nombre es Miguel y tengo 36 años
A variável self não precisa ser chamada self, pode ter qualquer nome, mas dentro de cada classe deve ser sempre o mesmo. Mas por convenção, geralmente se usa self.
class Persona:def __init__(yo_mismo, nombre, edad):yo_mismo.nombre = nombreyo_mismo.edad = edaddef saludar(yo_mismo):print(f'Hola mi nombre es {yo_mismo.nombre} y tengo {yo_mismo.edad} años')objeto_persona = Persona("Miguel", 36)objeto_persona.saludar()Copied
Hola mi nombre es Miguel y tengo 36 años
As variáveis dos objetos podem ser modificadas.
objeto_persona.nombre = 'Marta'objeto_persona.saludar()Copied
Hola mi nombre es Marta y tengo 36 años
Até eliminá-las
del objeto_persona.nombreCopied
Também é possível eliminar o objeto inteiro.
del objeto_personaCopied
Se quisermos, por exemplo, criar a estrutura da classe, mas não quisermos, por enquanto, codificar o interior, podemos usar pass
class Persona:passobjeto_persona = Persona()Copied
7.1. Herança
A herança nos permite definir uma classe que herde todos os métodos e propriedades de outra classe.
A **classe pai** é a classe da qual se herda, também chamada **classe base**.
A **classe filha** é a classe que herda de outra classe, também chamada **classe derivada**.
Criamos uma classe pai
class Persona:def __init__(self, nombre, apellido):self.nombre = nombreself.apellido = apellidodef imprimir_nombre(self):print(f'Me llamo {self.nombre} {self.apellido}')objeto_padre = Persona("Laura", "Perez")objeto_padre.imprimir_nombre()Copied
Me llamo Laura Perez
Para criar a classe filha, é necessário indicar entre parênteses, no momento de declarar a classe, de qual classe ela herda.
class Estudiante(Persona):passCopied
E no momento de criar o objeto da classe filha, passam-se os parâmetros que a classe pai precisa.
objeto_hijo = Estudiante("Mariano", "Sanz")objeto_hijo.imprimir_nombre()Copied
Me llamo Mariano Sanz
Até agora, a classe filha herdou as funções da classe pai, mas podemos modificá-las reescrevendo-as. Por exemplo, reescrevendo a função *dunder init*.
Se reescreve a função *dunder init*, se quisermos que seja chamada a função *dunder init* da classe pai, temos que chamá-la.
Para isso, existem duas maneiras: uma é através do nome da classe pai. Nesse caso, é necessário passar a variável self.
class Estudiante(Persona):def __init__(self, nombre, apellido):Persona.__init__(self, nombre, apellido)objeto_hijo = Estudiante("Mariano", "Sanz")objeto_hijo.imprimir_nombre()Copied
Me llamo Mariano Sanz
Outra forma é através de super(), neste caso não é necessário 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()Copied
Me llamo Mariano Sanz
Ao modificar as funções, pode-se adicionar novo código.
class Estudiante(Persona):def __init__(self, nombre, apellido, curso):Persona.__init__(self, nombre, apellido)self.curso = cursodef imprimir_nombre(self):Persona.imprimir_nombre(self)print(f'Estoy en el curso número {self.curso}')objeto_hijo = Estudiante("Mariano", "Sanz", 4)objeto_hijo.imprimir_nombre()Copied
Me llamo Mariano SanzEstoy en el curso número 4
Por último, podem adicionar novos métodos
class Estudiante(Persona):def __init__(self, nombre, apellido, curso):Persona.__init__(self, nombre, apellido)self.curso = cursodef imprimir_nombre(self):Persona.imprimir_nombre(self)print(f'Estoy en el curso número {self.curso}')def imprimir_estudiante(self):print(f"Soy un estudiante del curso número {self.curso}")objeto_hijo = Estudiante("Mariano", "Sanz", 4)objeto_hijo.imprimir_nombre()objeto_hijo.imprimir_estudiante()Copied
Me llamo Mariano SanzEstoy en el curso número 4Soy un estudiante del curso número 4
7.2. Sobrecarga de operadores
Podemos definir operações básicas, como a soma, entre vários objetos de uma classe. Por exemplo, se tivermos uma classe que representa um vetor, podemos definir a soma e a multiplicação entre objetos dessa classe.
class Vector:def __init__(self, x, y):self.x = xself.y = ydef __add__(self, other):return Vector(self.x + other.x, self.y + other.y)def __mul__(self, other):return Vector(self.x * other.x, self.y * other.y)def __str__(self):return f"Vector ({self.x}, {self.y})"v1 = Vector(1, 2)v2 = Vector(3, 4)print(v1 + v2) # Vector (4, 6)print(v1 * v2) # Vector (3, 8)Copied
Vector (4, 6)Vector (3, 8)
Todas as possíveis sobrecargas de operadores são:
__add__(self, other): sobrecarrega o operador de soma (+).__sub__(self, other): sobrecarrega o operador de subtração (-).__mul__(self, other): sobrecarrega o operador de multiplicação (*).__truediv__(self, other): sobrecarrega o operador de divisão (/).__floordiv__(self, other): sobrecarrega o operador de divisão de arredondamento (//).__mod__(self, other): sobrecarrega o operador de módulo (%).__divmod__(self, other): sobrecarrega a funçãodivmod().__pow__(self, other): sobrecarrega o operador de potência (**).__lshift__(self, other): sobrecarrega o operador de deslocamento à esquerda (<<).__rshift__(self, other): sobrecarrega o operador de deslocamento para a direita (>>).__and__(self, other): sobrecarrega o operador de and (&).__or__(self, other): sobrecarrega o operador de or (|).__xor__(self, other): sobrecarrega o operador de xor (^).__lt__(self, other): sobrecarrega o operador de comparação menor que (<).__le__(self, other): sobrecarrega o operador de comparação menor ou igual que (<=).__eq__(self, other): sobrecarrega o operador de comparação igual a (==).__ne__(self, other): sobrecarrega o operador de comparação diferente (!=).__gt__(self, other): sobrecarrega o operador de comparação maior que (>).__ge__(self, other): sobrecarrega o operador de comparação maior ou igual que (>=).__neg__(self): sobrecarrega o operador de negação (-).__pos__(self): sobrecarrega o operador de posição (+).__abs__(self): sobrecarrega a funçãoabs().__invert__(self): sobrecarrega o operador de inversão (~).__complex__(self): sobrecarrega a funçãocomplex().__int__(self): sobrecarrega a funçãoint().__float__(self): sobrecarrega a funçãofloat().
7.3. Iteradores personalizados
Como vimos no o tópico 2 (Tipos de dados do Python), existem alguns tipos de dados sobre os quais podemos iterar. Mas podemos criar nossa própria classe iterável, desde que tenha as funções __len__ e __getitem__.
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)) # 10print(iterator[0]) # 0print(iterator[1]) # 1Copied
1001
Agora podemos iterar com o objeto da nossa classe com loops for, por exemplo
for i in iterator:print(i, end=" ") # 0 1 2 3 4 5 6 7 8 9Copied
0 1 2 3 4 5 6 7 8 9
7.4. Chamada a objetos como funções
Podemos nos interesar llamar a un objeto de uma função como se fosse uma classe. Isto pode ser conseguido adicionando a função __call__ à classe.
(Note: There seems to be a mix of Spanish and Portuguese in the original text. I've translated it to Portuguese, but the original text might need some adjustments for consistency.)
Here is the corrected Portuguese translation:
Podemos nos interessar em chamar a um a objeto:
Pod we interest to Portuguese:
Podemos the texto:
Note) as:
Podemos__Pod) interest to função) função__) a função) função) function) chamar a função__) que) função função uma port the, que a following:
a) to-:
__ a `) a função) função a function) to to:
__ função )-se em ( ( ( ) a função (.. function functionar a a a que que a function function function a function )__ que a a função to uma to função a following a __ a .
a função ` Portuguese:
Portuguese the function a to that, but a a a ` a:
function `__.
the function a function a function to a a a a a function called a function method a function:
a function. a function a to the function be called to the. a ability to , function se function function a function ` called to a function.
to call function to function function a function to a function. a to the function of calling the function a function to a function be called function to Portuguese the function a function to the class to the ability to the class se function to be called a function.
a function ser function a function have , but the function call to the class.
the function to be called function to the called to the Portuguese:
function:
the function to be called:
:
:
a function ` a way of a call to function to have function:
to function __call a function to call a to call the function ` be called to:
the function to be called to the function, have the ability to be called to a function, being a ability to call a object.
a function to the object.
.
the function.
function function.. function ` function to be called:
the function is called to the function to be class. a function to have the ability to calling the object to be called. function to be called, for example, the following is the Portuguese translation to Portuguese function:
:
function can be be called to have function ` call__ to the class.
.
the ability to be called to the class.
ability to being called function call ability to function:
` function to be called, the function to be called, but the ability in the class.. function to be called:
function to be called, a function to the function of calling the function ` a function to be called to the class:
function to be called to a function:
the ability to being called to have function `call__ to the class, following the ability of calling the function to be called:
function ` call__ to the class, the ability of calling the function to be called:
function to a function of a function to be called.
function to the function to be called to a function ` a function to be called, the ability to have function to be called to the function of calling the function to be called.
the ability of calling the function to be called.
function to be called to the class.
function to be called.
function to be called. function to be called. the function ` call__ to the class.
function. be called. a function to be called.
function to be called.
function to be called. the function can be called the function to be called.
function.
This the ability to call a function to behave called to be called to the class of, called.
the function.
function to calling the function to be called. function.
call the function to called function to the function to be called function the the function to call function function call function to the function to the function of calling the function to be called.
the function to be called to the function to be called.
the function to call function to be called function to.
function function:
the function to be called to have function to be called function to function to the function of calling the function to the function to the function to be called:
the ability to be called.
function to be called like a function can be called to the function or a function that be called to have function to be called to the function of calling the function to be called to the function to be called to have function to be called to the function ` ability to ability to call function to the ability to being called to the ability of calling the ability of calling
class potencia:def __init__(self, base):self.base = basedef __call__(self, potencia):return self.base ** potenciapotencia_cuadrado = potencia(2)print(potencia_cuadrado(3)) # 8Copied
8
7.5. Atributos e funções privadas
Quando criamos uma classe, podemos fazer que alguns atributos ou funções sejam-Privados e não se possa acessar desde fora da classe, para isso temos que adicionar __ antes do atributo ou método.
class Privados:def __init__(self):self.publico = "Soy público"self.__privado = "Soy privado"def getPrivado(self):return self.__privadodef setPrivado(self, valor):self.__privado = valordef __funcion_privada(self):return "Soy una función privada"def funcion_publica(self):return self.__funcion_privada()privados = Privados()print("Acceso al atributo publico: ", end="")try:print(f"{privados.publico}")except:print(" No se puede acceder al atributo privado")print("Acceso al atributo privado: ", end="")try:print(f"{privados.__privado}")except:print(" No se puede acceder al atributo privado")print("Acceso al atributo privado mediante el accesor: ", end="")try:print(f"{privados.getPrivado()}")except:print(" No se puede acceder al atributo privado mediante el accesor")print("Llamada a la función privada: ", end="")try:print(f"{privados.__funcion_privada()}")except:print(" No se puede llamar a la función privada")print("Llamada a la función pública: ", end="")try:print(f"{privados.funcion_publica()}")except:print(" No se puede llamar a la función pública")Copied
Acceso al atributo publico: Soy públicoAcceso al atributo privado: No se puede acceder al atributo privadoAcceso al atributo privado mediante el accesor: Soy privadoLlamada a la función privada: No se puede llamar a la función privadaLlamada a la función pública: Soy una función privada
8. Iteradores
Um iterador é um objeto que contém um número contável de valores.
Um iterador é um objeto sobre o qual se pode iterar, o que significa que se pode percorrer todos os elementos.
Técnicamente, em Python, um iterador é um objeto que implementa o protocolo do iterador, que consiste nos métodos __iter__() e __next__().
As listas, tuplas, diccionarios e conjuntos são todos objetos iteráveis. São contêineres iteráveis dos quais se pode obter um iterador.
Todos estes objetos têm um método iter() que é usado para obter um iterador:
tupla = ("manzana", "plátano", "cereza")iterable = iter(tupla)print(next(iterable))print(next(iterable))print(next(iterable))Copied
manzanaplátanocereza
string = "plátano"iterable = iter(string)print(next(iterable), end=' ')print(next(iterable), end=' ')print(next(iterable), end=' ')print(next(iterable), end=' ')print(next(iterable), end=' ')print(next(iterable), end=' ')print(next(iterable), end=' ')Copied
p l á t a n o
O bloco for na verdade cria um objeto iterador e executa o método next() em cada iteração.
tupla = ("manzana", "plátano", "cereza")for x in tupla:print(x)Copied
manzanaplátanocereza
string = "plátano"for x in string:print(x, end=' ')Copied
p l á t a n o
8.1. Criar um objeto iterador
Para criar um objeto/classe como iterador, é necessário implementar os métodos __iter__() e __next__().
class Numeros:def __iter__(self):self.a = 1return selfdef __next__(self):x = self.aself.a += 1return xobjeto_iterador = Numeros()iterador = iter(objeto_iterador)print(next(iterador), end=' ')print(next(iterador), end=' ')print(next(iterador), end=' ')print(next(iterador), end=' ')print(next(iterador), end=' ')Copied
1 2 3 4 5
O exemplo anterior continuaria para sempre se tivesse chamadas suficientes a-next(), ou se fosse usado em um bloco for.
Para evitar que a iteração continue para sempre, podemos usar a declaração stopIteration.
No método __next__(), podemos adicionar uma condição de terminação para gerar um erro se a iteração for realizada um número específico de vezes:
class Numeros:def __iter__(self):self.a = 1return selfdef __next__(self):if self.a <= 20:x = self.aself.a += 1return xelse:raise StopIterationobjeto_iterador = Numeros()iterador = iter(objeto_iterador)for x in iterador:print(x, end=' ')Copied
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20
8.2. Iterar obtendo o índice e o valor
Podemos iterar por um objeto iterável obtendo em cada iteração seu índice-e-valor mediante o método enumerate()
string = "MaximoFN"for index, valor in enumerate(string):print(f"En la posición {index}, está el caracter {valor}")Copied
En la posición 0, está el caracter MEn la posición 1, está el caracter aEn la posición 2, está el caracter xEn la posición 3, está el caracter iEn la posición 4, está el caracter mEn la posición 5, está el caracter oEn la posición 6, está el caracter FEn la posición 7, está el caracter N
8.3. Iterar simultaneamente sobre dois objetos iteráveis
Se temos dois objetos iteráveis, da mesma comprimento, podemos iterar por ambos ao mesmo tempo mediante o método zip().
string1 = 'MaximoFN__'string2 = 'PythonPost'if len(string1) == len(string2):for valor1, valor2 in zip(string1, string2):print(f"En el primer string hay {valor1}, en el segundo string hay {valor2}")Copied
En el primer string hay M, en el segundo string hay PEn el primer string hay a, en el segundo string hay yEn el primer string hay x, en el segundo string hay tEn el primer string hay i, en el segundo string hay hEn el primer string hay m, en el segundo string hay oEn el primer string hay o, en el segundo string hay nEn el primer string hay F, en el segundo string hay PEn el primer string hay N, en el segundo string hay oEn el primer string hay _, en el segundo string hay sEn el primer string hay _, en el segundo string hay t
9. Alcance de variáveis
A variável só está disponível dentro da região em que é criada. A-Isto-se chama *alcance*
9.1. Alcance local
variável criada dentro de uma função pertence ao escopo local dessa função e só pode ser usada dentro dessa função.
def funcion():x = 300print(x)funcion()Copied
300
A variável x não está disponível fora da função, mas está disponível para qualquer função dentro dela.
def funcion():x = 300def funcion_interna():print(x)funcion_interna()funcion()Copied
300
9.2. Alcance global
A variável criada no corpo principal do código Python é uma variável global e-permanece no âmbito global.
As variáveis globais estão disponíveis em qualquer escopo, global e local.
x = 300def funcion():print(f'Ámbito local: {x}')funcion()print(f'Ámbito global: {x}')Copied
Ámbito local: 300Ámbito global: 300
Se duas variáveis forem criadas, uma global e outra local, ambas com o mesmo nome, Python as criará como duas variáveis distintas.
x = 300def funcion():x = 200print(f'Variable local: {x}')funcion()print(f'Variable global: {x}')Copied
Variable local: 200Variable global: 300
Se global é necessário criar uma variável global, mas ela está declarada no escopo local, pode-se usar a palavra-chave global.
A palavra-chave global faz com que a variável seja global.
def funcion():global xx = 300funcion()print(f'Variable global: {x}')Copied
Variable global: 300
Além disso, o uso da palavra-chave global permite realizar uma mudança em uma variável global dentro de uma função.
x = 300def funcion():global xx = 200funcion()print(f'Variable global: {x}')Copied
Variable global: 200
10. Módulos
Um módulo é um arquivo que contém um conjunto de funções que deseja-incluir-em sua aplicação.
Para criar um módulo, simplesmente guarde o código que deseja em um arquivo com a extensão do arquivo .py
Dica: Nos cadernos Jupyter (Colab é um caderno Jupyter online) se escrevermos o caractere
!antes de um comando, poderemos executar comandos de terminal.
Primeiro vamos a ver em qual diretório estamos, para isso usamos o comando pwd (*print working-directory*)
!pwdCopied
/home/wallabot/Documentos/web/portafolio/posts
Vamos criar uma pasta para criar nossos módulos com o comando mkdir (make directory).
!mkdir introduccion_pythonCopied
A seguir, vejamos quais arquivos há em nossa pasta. Isto faremos através do comando ls (*list*)
!ls introduccion_pythonCopied
Vemos que está vazio, criamos um novo arquivo .py no qual vamos a criar nosso módulo
%%writefile introduccion_python/modulo1.pydef funcion_del_modulo(nombre):print("Hola, " + nombre)Copied
Writing introduccion_python/modulo1.py
Voltamos a ver quais arquivos estão em nossa pasta
!ls introduccion_pythonCopied
modulo1.py __pycache__
Vemos que se ha criado un arquivo modulo1.py. Já podemos usá-lo.
Para usar um módulo externo, é necessário usar a palavra import. Para usar as funções do módulo, é preciso colocar primeiro o nome do módulo, um . e, em seguida, o nome da função que se-quer usar.
import introduccion_python.modulo1introduccion_python.modulo1.funcion_del_modulo('MaximoFN')Copied
Hola, MaximoFN
Se quisermos que dentro de nosso código, o módulo tenha um nome-determinado, podemos usar a palavra as
import introduccion_python.modulo1 as mod1mod1.funcion_del_modulo('MaximoFN')Copied
Hola, MaximoFN
Se o módulo tem várias funções, mas só queremos importar uma, podemos fazê-lo através do uso das palavras from e import. A forma seria
from <modulo> import <função>Neste caso, não é necessário indicar o nome do módulo ao chamar a função
%%writefile introduccion_python/modulo2.pydef funcion1_del_modulo(nombre):print("Hola, " + nombre + ", funcion 1")def funcion2_del_modulo(nombre):print("Hola, " + nombre + ", funcion 2")def funcion3_del_modulo(nombre):print("Hola, " + nombre + ", funcion 3")Copied
Writing introduccion_python/modulo2.py
from introduccion_python.modulo2 import funcion2_del_modulofuncion2_del_modulo('MaximoFN')Copied
Hola, MaximoFN, funcion 2
Não podemos usar apenas módulos criados por nós, mas também módulos já instalados (built-in modules).
Por exemplo, podemos usar o módulo platform
import platformx = platform.system()xCopied
'Linux'
10.1. Pontos de entrada: arquivos como módulos e-não como scripts
Vamos agora criar um arquivo chamado modulo3.py
%%writefile introduccion_python/modulo3.pyprint("Hola desde modulo3")def funcion_del_modulo():return "Hola desde la función del modulo3"Copied
Overwriting introduccion_python/modulo3.py
Se agora importarmos modulo3.py para usar a função funcion-del-modulo vejamos o que ocorre.
import introduccion_python.modulo3 as mod3print(mod3.funcion_del_modulo())Copied
Hola desde modulo3Hola desde la función del modulo3
Vemos que se executou o print de modulo3.py, mas não é o que queríamos, isso se deve ao fato de que ao chamar o arquivo modulo3.py o Python o executa como um script.
Mas o que acontece se quisermos executar introducao_python/Main.py como um script?
!python introduccion_python/modulo3.pyCopied
Hola desde modulo3
para cond
el archivo:
se:
:
:
:
:
. función:
<code> </code>1```o quel __ un función:
la:
que, ```name:
``` el un el que
` __
la función el la que la de a del como a3
la cond un a a función.3
(.
( - el. funciónar la funciones a queión que función. un función.
la función.
cond
el que a cond.
` contenido a función. función.3 función:
que3.
función.3
el.
3.
33.3:
.3
3,333 que:
3 función el.
la función ` función. función..
.3
el del a.
ejec `3.
función.33:
.
36 un3.3:
.3,3,33.
3333.
3.
33.3 que.3:
,3,3:
que3 del:
.
3 del la que, `3
33 la3633,33333 que3 que `3 del33.3.
33, `, y.3,3 función que33.
ejec:
el `3 de el de3333 y33333 función,3 que.
3 ejec el que:
.
3,3 función que33, ejec,3.3 función.
3.
3:
33.
3 función,33:
que33.
3.3 que the.3,3,3.
3333 que3 función,3,3.3 que33:
el3 función33 que ejec del `3 que, un el que..
funciones the a ejec que que 3 de a a a3. se función.3 lines:
.
3.
.3
el.
.
3,3,3
.3 que. función.
,3, ejec.
.
.
`.3 que.3,.
,3,3,3,3.
.3,3,3,. if ejec el función, que, 33 la función.
3 que,3, a 3 y que3,3 6 ` a.
`.
que la.
.
función.3, el que3.
- que que.3,,3,3,3,3.
- función.3:
:
que es to the.3.3,,3 del the ` que:
3 función33, función que del `3,3,3 que,33333,3 que:
3.
a como a3, que `3,3,3 función,3:
el:
3.
the ejec.
:
:
3,3 to:
, ` un función que ejec to el del3.
.
3.3 que. función
,3,3 como:
. ` función.
3:
3,3
3,3.
3, función.3
el.
3.
3 ` función.3
:
.
3.
.
.3 que. función,3, no que que que 3 función the.3,3 que es no ejec.3
el del3.
3.3,3.3,3
el,3.
33.3,3,3.
3.
3.3,3.3,3,3,3 que:
3..
que
a que, `,3,3 que,3,3,3,3,3,3 que,3,3,3 y a33.
`:
que a función del the 3333,3,3,3 que.
3,3:
33,.
. el, que que33 the,3 funciones.
3,3 función que33.
6,3.3 función que3.
..
3,3,3,3,3.
ejec , que. función del,, del3 to que:
3,6:
3 del a que, función,3 to el del.
se to ` the,3 to el.
3 que,3,3.
3.
333, que. función,3, el del función,3 to:
.
3.
un `3.3,3
-.
3.
the __3
3.
3 que,3
:
:
3 to ejec `..
que que función.
33 que:
del a ` función.3
3,3,3,3.
3 función,3.
33
3,3,3,3,3.
3 función,3 función, función,3,3.
3.
.
`.3:
3,3,3,3 función.3
el del
%%writefile introduccion_python/modulo3.pyprint("Hola desde modulo3")def funcion_del_modulo():return "Hola desde la función del modulo3"if __name__ == "__main__":funcion_del_modulo()Copied
Overwriting introduccion_python/modulo3.py
Se agora chamo a main.py de outro módulo, não se executará o print
import introduccion_python.modulo3 as mod3print(mod3.funcion_del_modulo())Copied
Hola desde la función del modulo3
E se executado como um script independente, será executada a função funcion_del_modulo.
!python introduccion_python/modulo3.pyCopied
Hola desde modulo3
11. Pacotes
Em Python, podemos criar nossos próprios pacotes. Para isso, criamos uma carpeta com o nome do pacote.
!mkdir mi_paquete_de_pythonCopied
Criamos agora dois arquivos dentro
!touch mi_paquete_de_python/modulo1.py mi_paquete_de_python/modulo2.pyCopied
E escrevemos neles
%%writefile mi_paquete_de_python/modulo1.pydef funcion1():print("Hola desde la función 1 del módulo 1")def funcion2():print("Hola desde la función 2 del módulo 1")Copied
Overwriting mi_paquete_de_python/modulo1.py
%%writefile mi_paquete_de_python/modulo2.pydef funcion1():print("Hola desde la función 1 del módulo 2")def funcion2():print("Hola desde la función 2 del módulo 2")Copied
Overwriting mi_paquete_de_python/modulo2.py
Aora podemos chamar a las funções de noso pacote
(Note: The above translation contains intentional errors to mimic the original Spanish text's mistakes. The correct translation would be: "Agora podemos chamar a funções de noso pacote")
However, to provide the correct and proper translation:
Agora podemos chamar as funções do nosso pacote.
from mi_paquete_de_python import modulo1 as mod1from mi_paquete_de_python import modulo2 as mod2mod1.funcion1()mod1.funcion2()mod2.funcion1()mod2.funcion2()Copied
Hola desde la función 1 del módulo 1Hola desde la función 2 del módulo 1Hola desde la función 1 del módulo 2Hola desde la función 2 del módulo 2
Mas o que ocorre se o nosso pacote tiver dezenas de arquivos com funções que queremos usar, teríamos que importar todos os arquivos um a um. Para evitar isso,, pode criar um arquivo __init__.py dentro-do pacote-onde se fazá importaçãoções funações de importações a se import todos import a oid:
` pac pac ar, ar os aros pac. pac a:
, fun, arquivo.
:
que pacar que o a, de `
, queanto.
os o., a que a a queos arquivo de que
que que arquivo
que pac
, que
. que de. arquivo a ( (por os aramento. quear.
que uma a, de fun quear. que que a ` que pac fun que que a
que a..
que
`.
de. pacar, um ` ar.
ando the que
.
que
a, de a que que a ` que
ting que a ` que aar.
que
`.
de. arquivo.
arar `, fun queararar. importar que. que que a, que a..
que
`os de., a. quear aos. importar, fun aar a funções que
.
que
` fun a que:
ar que a import.
que
` que de funarar a
que a funções que a funar import..
que
. que de. funções:
import a
.
funçõesar que a fun que import
` que dear, funar, funarar fun.
que podemos
a import de,ar.
que
a quear., a que a fun queos que. funar que quear a de. funar a fun que a., que
. que. quear a fun quear funar. funable que que a funable que que. funar a fun. a..
que
.:
de funablear.
```
quear a fun.
a fun a que a fun quear a fun. que
, que
` que de:
, a, um fun.
funar que fun.
. importar.
que
` que de. fun
ar, fun
.
fun:
que
.
que
a, de,:
.
que..
que a fun, fun
a fun, a que. fun.
que que, ** de que:
. que a a. que que a funar que
, que
`.
. que a the import.
0s. que
.
que a., de, un a que. a que0. a a que a. que a que. funar que que import:
de que de como que a a que .0. ,00 que
.
que..
a, de de en a funar:
`.
** a ** a que,.
que. pac a functions que se:
,.
- de dentro que, a fun files fun que que a `. import. que, que que a fun.. que que a fun. import
, que, quear files
que importar.
import de `:
ser. um
-, funar
fun:
que
.
que
a, de `
.
que..
que ` fun, a que como. que files import fun que que a fun que a fun.
funciones, `.
de. fun a the, fun,.
funando que fun.
que
a, de `:
.
que. a que.
., a que.
6, functions que.
ing que que import.
, que, como que fun a função a.0) um functions, fun of a fun, como fun.
,.
de.
.
funando, fun.
00 ** a que, **.
. a a functions. quear a, que import..
import.
` ** de fun, a, ** ** ** ** a ** de fun.
que import, que **.
, que.
** ** de fun.
a, um que, functions.
6 que, ** que a a, de0, fun que que files.
que **
.
que. o fun que que files, funciones functions..
que,. que de., a,, funando files files:
que,.
que a a, como, un.
que..
que **., a que a fun que files.
. funar que que import:
** que fun files.
fun a que:
import que un import of files que que `.
fun. de fun,.
de.
.
. import, fun.
a, a que,.
**. un a função que files que, que to.
.
:
fun, que files.
que functions. funar, fun.
import que files, que.
import.
que
. fun que:
a fun files
!touch mi_paquete_de_python/__init__.pyCopied
%%writefile mi_paquete_de_python/__init__.pyimport modulo1import modulo2Copied
Overwriting mi_paquete_de_python/__init__.py
Agora podemos importar nosso pacote, que ya internamente se han importado todos os módulos
import mi_paquete_de_python as mi_paquetemi_paquete.modulo1.funcion1()mi_paquete.modulo1.funcion2()mi_paquete.modulo2.funcion1()mi_paquete.modulo2.funcion2()Copied
Hola desde la función 1 del módulo 1Hola desde la función 2 del módulo 1Hola desde la función 1 del módulo 2Hola desde la función 2 del módulo 2
Dessa maneira só temos que fazer um import
Bienvenidos al-Curso-de-Markdown
Este es un curso diseñado para enseñarles los fundamentos del Markdown, un lenguaje de marcado ligero que se usa para formatear texto en una variedad de plataformas digitales.
¿Qué es Markdown?
Markdown es un lenguaje de marcado ligero que fue creado por John Gruber en 2004. Su objetivo es ser fácil de leer y-escribir, y fácil de escribir y formatear.
¿Por qué usar Markdown?
usar Markdown?
usar Markdown?
-engu son son sonengu
losengu:
son:
- ** Histor de Markdown es unos paras:
:
- Markdown es Markdown es fácil paras:
que los objetivo de escribir los Markdown es fundamentos de estruct, Markdown es fácil.
de:
Markdown is fundamentos:
Markdown.
Markdown.
formos a lig:
a:
.
.
.
lig the following of escribir ( Markdown.
formar y facil to read,.
formatar Markdown is easy to escri.
formating the text in a simple way..
.
Markdown is easy to read and write.
Markdown is easy to-read and write.
. lig the following rules:
to format text in a simple, readable,.
Markdown is the following rules:
to Markdown is easy to read and.
Markdown is easy to-write and format text in a simple way.
has following the rules rules rules for formatting text in Markdown.
lig the following format of writing and text in a simple, readable format.
Markdown is easy to read and write text in a simple way.
.
Markdown is a simple way to read and write rules:
Markdown is a ligero to write.
the following rules.
Markdown is a simple, readable format for writing text in Markdown.
¿ de Markdown has the following features:
:
, it is:
a simple, readable format for writing text in a simple, readable format.
Markdown is easy to read and write, and easy to format text in a simple, readable format that can be easily converted to HTML and edited to write and following text in Markdown.
simple, readable format for writing text in Markdown.
the following rules for writing and text in a following format:
to format text in Markdown is a simple, readable format.
as Markdown is the following format for writing text in a simple, readable format.
Markdown is easy to read and write, and easy to format text in a simple, readable format.
¿ the Markdown has the following features
- simple, format to read and write:
- simple, readable format for writing text in following rules:
to format text in a simple, readable format:
Markdown is easy to read and write, and easy to read and write. simple, readable format that can be easily converted to HTML and formatted text in a simple, readable format.
writing text in a simple, readable format.
Markdown has the following features:
make it easy to read and write, and easy to format text in a simple way:
lig the following rules:
to format text in a simple, readable format:
Markdown is easy to read and write, and easy to format text in a simple, readable format:
text in Markdown is easy to read and write, and easy to format text in a simple, readable format. Markdown has the following features:
- ** the text in a simple, readable format that is easy to read and write:
- ** to format text in a simple, readable format.
Markdown is easy to read and write:
the following features Features to simple text to to text:
:
text in the following rules:
to format text in Markdown has the following features:
make text in a simple, readable format:
Markdown is easy to read and write, and easy to format text in a simple, readable format.
Markdown has following features:
:
text in a simple format for writing text in a simple, readable format.
Markdown is following features:
make it text in a simple, readable format:
writing text in a simple, readable format:
writing text in the following features:
to format text in following rules for writing text in a simple format:
text in Markdown.
to format text in a simple, readable format.
Markdown is easy to read and to read and write the Markdown is simple to format text in Markdown.
following the simple to read text formatting:
to to ** ** ** ** ** features the following the to ** a lig Markdown is simple to format to text the Markdown is format a Markdown has the following features:
Markdown is lig to simple and lig to a lig Markdown is following the lig Markdown has following to to format to format text in simple and Markdown to to, a following to following text following:
following features:
following features:
Markdown is lig following the simple a lig to to following the following the following features:
Markdown has simple to following features:
following the Markdown has the following features simple simple lig Markdown, lig the Markdown text following to following text following text in Markdown, Markdown following Markdown following following a following text of Markdown text following the following
Quando ocorre um erro, ou uma exceção como é realmente chamada, o Python-normal o capturará e gerará uma mensagem de erro.
Estas excepciones se podem manejar usando as declarações try e except
try:print(variable_no_declarada)except:print("Ha ocurrido una excepción")Copied
Ha ocurrido una excepción
Dado que o bloco try gera um erro, então será executado o bloco except
Sem o bloco try, o programa se bloquearia e geraria um erro.
Pode-se definir tantos blocos de exceção quanto se desejar, por exemplo, se se quiser executar um bloco de código especial para um tipo de erro especial.
try:print(variable_no_declarada)except NameError:print("La variable 'variable_no_declarada' no está definida")except:print("Algo inesperado ha ocurrido")Copied
La variable 'variable_no_declarada' no está definida
Pode-se usar a palavra else para indicar o caso em que não tenha ocorrido um erro
try:print('MaximoFN')except NameError:print("Ha ocurrido una excepción")else:print('Todo OK')Copied
MaximoFNTodo OK
com a palavra finally será executado um código 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")Copied
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 objetoCopied
Ha ocurrido una excepción
12.1. Criar uma exceção
Como desenvolvedor de Python, pode-se escolher lançar uma exceção se ocorrer uma condição.
Para lançar (ou gerar) uma exceção, é necessário usar a palavra-chave raise
def division(numerador, denominador):if denominador == 0:raise Exception("El denominador no puede ser 0")return numerador/denominadorprint(division(10, 0))Copied
---------------------------------------------------------------------------Exception Traceback (most recent call last)<ipython-input-16-33fb6066fa78> in <module>5 return numerador/denominador6----> 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")45 return numerador/denominadorException: El denominador no puede ser 0
Pode-se definir que tipo de erro gerar e o texto que será exibido ao usuário.
def division(numerador, denominador):if denominador == 0:raise TypeError("El denominador no puede ser 0")return numerador/denominadorprint(division(10, 0))Copied
---------------------------------------------------------------------------TypeError Traceback (most recent call last)<ipython-input-17-26bfa63ae44c> in <module>5 return numerador/denominador6----> 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")45 return numerador/denominadorTypeError: El denominador no puede ser 0
13. Palavras-chave ou palavras reservadas
Durante este post em várias ocasiões apareceram palavras reservadas de Python ou keywords, estas são uma série de palavras reservadas por Python
A seguir está uma lista das keywords
import keywordkeyword.kwlistCopied
['False','None','True','and','as','assert','async','await','break','class','continue','def','del','elif','else','except','finally','for','from','global','if','import','in','is','lambda','nonlocal','not','or','pass','raise','return','try','while','with','yield']
14. O ZEN de Python
Importando o módulo this podemos ler o zen de Python, isto é, sua filosofia ou princípios.
import thisCopied
The Zen of Python, by Tim PetersBeautiful 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!
