Funções em Python

No pyhton temos as funções embutidas (built-in functions) que são funções pré-definidas pelo Python, já vêm prontas para uso (falaremos sobre isso no final desta página), temos as funções importadas que são as funções que acessamos a partir de módulos usando import e temos as funções que podemos criar.

Criar funções são extremamente importantes quando estamos programando.

Em Python, primeiro utilizaremos:

1. def, toda vez que você iniciar a criação de uma função nova

2. depois do def será o nome que queremos atribuir a função para na hora que você for chamar a função, chamará pelo nome.

3. Inserir os parâmetros da função. No exemplo abaixo, quero somar um número com o outro, mas se fosse uma soma ou qualquer outra coisa que necessitasse mais parâmetros, eu iria continuar inserindo dentro do parênteses.

4. soma é o nome que estou dando a ação que python irá executar dentro da função (2ª imagem abaixo). Poderia ser qualquer nome, mas para ficar mais fácil de ler o código, coloquei soma e inseri o que Python irá fazer com os parâmetros que criei, por isso adicionei o +.

5. return para que ao executar a função retorne o resultado da soma

Após os passos acima, nossa função estará pronta e podemos chamá-la a qualquer momento.

Função Python simplificada

A forma mais simplificada de escrever uma função, sem armazenar o resultado em uma variável:

O return dentro da função, não é obrigatório mas se eu quiser fazer alguma coisa com o resultado da função, utilizo o return, caso contrário, posso inserir diretamente um print como no exemplo abaixo:

def nome (nomeuser):
    print(f"Olá {nomeuser} seja bem vindo(a)! ")
nome('amanda')

Saída: Olá amanda seja bem vindo(a)!

def verifica_par(num):
    if num % 2 != 0:
        print("O número é ímpar")
    else:
        print("O número é par")

verifica_par(4)
verifica_par(5)

Saída: O número é par

O número é ímpar

 Função Python armazenando resultado em uma variável

Para armazenar o resultado de uma função em uma variável, pode ser útil se você pretende adicionar mais operações ou manipulações antes de retornar o valor final.

Definindo o tipo de dados de parâmetros e resultado da função

Em Python, você pode especificar o tipo de dado esperado como parâmetro e o tipo de dado retornado pela função usando type hints . No entanto, Python não força esses tipos (diferentes de linguagens como Java ou C++), então eles servem apenas como documentação e para ferramentas de análise de código.

Parâmetros opcionais e valores padrão

Tratamento de exceções try-except

O try-except em Python é usado para solucionar problemas (erros) que possam ocorrer durante a execução do código, evitando que o programa seja interrompido. Ao colocar uma operação no bloco try, você está dizendo: "Tente executar este código. Se algo der errado, execute o bloco exceptem vez de interrupção o programa."

try:

# Código que pode gerar uma exceção

except TipoDeExcecao:

# Código a ser executado se a exceção ocorrer

Principais tipos de exceções:

ZeroDivisionError : ocorre quando você tenta dividir por zero.

ValueError : ocorre quando você tenta converter uma variável para um tipo inadequado.

TypeError : ocorre quando você usa um tipo inadequado para uma operação ou função.

IndexError : ocorre quando você tenta acessar um índice inexistente em uma lista

KeyError : ocorre quando você tenta acessar uma chave inexistente em um dicionário.

FileNotFoundError : ocorre quando você tenta abrir um arquivo que não existe.

AttributeError : ocorre quando você tenta acessar um atributo ou método que não existe em um objeto.

Tratando várias exceções

Usando else e finally com try-except

else: executa um bloco de código se nenhuma exceção ocorrer no bloco try.

finally: executa um bloco de código sempre , independentemente de uma exceção ocorrer ou não. É útil para liberar recursos, como fechar arquivos ou conexões.

Função Python com três parâmetros

Veja que no exemplo abaixo, para a minha função funcionar, precisa de três parâmetros. Os parâmetros estão definidos dentro dos parênteses neste caso como num1, num2 e num3.

def multiplicar(num1, num2, num3):
    mult = num1 * num2 +num3
    return mult


numero1 = 4
numero2 = 6
numero3 = 3

resultado = multiplicar(numero1,numero2, numero3)

print(resultado)

Função com While (condição de parada)

Função com For (repetição para contagem)

Função lambda

A principal forma de criar funções inline(definida e usada no mesmo lugar, geralmente como uma função curta) em Python é utilizando lambda. Uma função lambda é uma função anônima e de uma única linha, usada para operações curtas e rápidas sendo usadas quando você precisa de funções simples e rápidas, geralmente de uma única linha, sem a formalidade do def.

As funções lambda em Python são limitadas a expressões únicas, então não podemos usar for ou while diretamente dentro delas ou if e else com várias linhas, no entanto, podemos contornar essa limitação usando compreensão de listas ou funções embutidas como map() e filter().

Estrutura básica da função lambda: lambda  argumento: expressão

Função lambda com if (operador ternário)

Lambda permite if-else, mas não suporta múltiplas linhas.

Operador ternário em Python é uma forma compacta de escrever em uma única linha.

Primeiro vem o argumento (parâmetro) que no exemplo abaixo é o x e depois vem a expressão com as condições do if.

# Verifica se um número é positivo, negativo ou zero

verificar_numero = lambda x: "Positivo" if x > 0 else "Negativo" if x < 0 else "Zero"

print(verificar_numero(5))   # Saída: Positivo
print(verificar_numero(-3))  # Saída: Negativo
print(verificar_numero(0))   # Saída: Zero

Algumas funções embutidas:

Função map()

map() aplica uma função a cada item de um iterável (como lista, tupla, etc), retornando um map object (precisa converter para lista ou tupla para ver o resultado)

map(função, iterável)

iterável: Qualquer objeto que pode ser percorrido item por item

numeros = [1,2,3,4]
dobro = map(lambda x: x * 2, numeros)

print(list(dobro))

# Saída: [2, 4, 6, 8]

list(map(str.upper, ['python', 'java']))  

# ['PYTHON', 'JAVA']

Função zip()

Junta dois ou mais iteráveis par a par, agrupando elementos na mesma posição.

Trunca para o menor tamanho dos iteráveis.

nomes = ['Ana', 'João']
idades = [25, 30]
resultado = list(zip(nomes, idades))
print(resultado)  

#Saída [('Ana', 25), ('João', 30)]

Função dir()

Mostra os atributos e métodos disponíveis para um objeto.

É muito útil para explorar objetos.

print(dir([]))

# saída:
['__add__', '__class__', '__class_getitem__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getstate__', '__gt__', '__hash__', '__iadd__', '__imul__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__rmul__', '__setattr__', '__setitem__', '__sizeof__', '__str__', '__subclasshook__', 'append', 'clear', 'copy', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort']

print(dir("amanda"))

# saída:
['__add__', '__class__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getnewargs__', '__getstate__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mod__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__rmod__', '__rmul__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'capitalize', 'casefold', 'center', 'count', 'encode', 'endswith', 'expandtabs', 'find', 'format', 'format_map', 'index', 'isalnum', 'isalpha', 'isascii', 'isdecimal', 'isdigit', 'isidentifier', 'islower', 'isnumeric', 'isprintable', 'isspace', 'istitle', 'isupper', 'join', 'ljust', 'lower', 'lstrip', 'maketrans', 'partition', 'removeprefix', 'removesuffix', 'replace', 'rfind', 'rindex', 'rjust', 'rpartition', 'rsplit', 'rstrip', 'split', 'splitlines', 'startswith', 'strip', 'swapcase', 'title', 'translate', 'upper', 'zfill']

No exemplo acima, como "Amanda" é uma string, a função dir() retorna todas as funções e propriedades do tipo string como 'upper', 'lowe', 'replace', etc.

Função lambda utilizando o for

O lambda não permite for diretamente, mas podemos usar map() para aplicar a função a uma lista.

# Elevar ao quadrado cada número de uma lista
numeros = [1, 2, 3, 4, 5]
quadrados = list(map(lambda x: x**2, numeros))

print(quadrados)  # Saída: [1, 4, 9, 16, 25]

Outra forma de fazer a mesma coisa usando compreensão de listas:

quadrados = [x**2 for x in numeros]
print(quadrados)  # Saída: [1, 4, 9, 16, 25]

compreensão de listas ou list comprehension é utilizada para criar uma nova lista com base em um iterável, podendo aplicar condições e transformações. Você pode usar o operador ternário dentro da compeensão de lista.

Lambda com filter() (substituindo for e if)

Podemos usar filter() para filtrar elementos iteráveis de uma lista com base em uma condição(Função que retorna True ou False)

filter(função, iterável)

# Filtrar números pares de uma lista
numeros = [1, 2, 3, 4, 5, 6]
pares = list(filter(lambda x: x % 2 == 0, numeros))

print(pares)  # Saída: [2, 4, 6]

função enumerate()

Gera tuplas com índice e valor (útil em loops)

enumerate(iterável)

nomes = ['Amanda', 'Ana', 'João']

for i, nome in enumerate(nomes):
    print(i, nome)

# Saída

0 Amanda
1 Ana
2 João

função sorted()

Ordena qualquer iterável (sem alterar o original)

sorted(iterável)

numeros = [4, 2, 9, 1]
print(sorted(numeros))  

# saída [1, 2, 4, 9]

função len()

Obter o tamanho de uma string, lista, etc

len(objeto)

print(len("Amanda"))  

# Saída: 6

função range()

Gera uma sequência de números

range(início, parada[, step])

for i in range(1, 5):
 print(i) 

 # saída: 1 2 3 4

Duas maneiras de chamar a função range():

1. A função range() recebe um parâmetro o qual indica a quantidade N de números a serem gerados, onde N deve ser maior que 0.

   
   

range (<quantidade_de_números_a_serem_gerados>)

Exemplo prático:

 list(range(3))

Saída: [0, 1, 2]

for valor in range(1, 6):

      print(valor)

A saída será os números começando em 1 e terminando em 5.

1

2

3

4

5

2. A segunda maneira de executar a função range possui três parâmetros mas o último é opcional. O nome <início_da_faixa> determina o primeiro número que deve ser gerado na faixa. <incremento> que é opcional e quando não especificado assume o valor padrão que é 1, indica a razão (positiva ou negativa) da PA. O parâmetro <fim_da_faixa> esta associado a razão da sequência. Quando o incremento for positivo, o último número da sequência correspondente a <fim_da_faixa> - <incremento>. No caso do incremento for negativo, o último número da sequência é calculado desta forma: <fim_da_faixa> + <incremento> * (-1),

range (<início_da_faixa>, <fim_da_faixa> [,<incremento>])

Exemplo prático:

list(range(10, 16)) Saída: Incremento  = 1: [10, 11, 12, 13, 14, 15]

list(range(10, 16, 2))  Saída: Incremento = 2: [10, 12, 14]

list(range(16, 10, -1))  Saída: Incremento  = -1 : [16, 15, 14, 13, 12, 11]

list(range(16, 10, -2))  Saída: Incremento = -2 : [16, 14, 12]

função sum()

Soma os elementos

sum(interável)

print(sum([10,20,30))

# saída: 60

função any()

Se algum item for True.

any(interável)

print(any{[0, False, 1]))

# saída: True (1 é True)

função all()

Se todos forem True.

print(all{]1, True, 'amanda'])) # True
print(all([1,0,2])) # False (0 é False)

função isinstance()

Verifica o tipo de um objeto

isinstance(objeto, tipo)

print(isinstance("abc", str)) # True
print(isinstance(5, float)) # False

função input()

Lê entrada do usuário

nome = input("digite alguma coisa: ")

função print()

Exibe informações na tela

print("Amanda")

função open()

Abre um arquivo para leitura

with open('arquivo.txt', 'r') as f:
    conteudo = f.read()
    print(conteudo)

max e min()

Maior e menor valor

print(max([10, 5, 3]))  # 10
print(min([10, 5, 3]))  # 3

round()

round(numero, qnt_digitos)

print(round(3.14159, 2))  # 3.14

abs()

valor absoluto, remove o sinal.

print(abs(-10))     # Saída: 10

id()

mostra o endereço de um objeto na memória

help()

mostra a documentação de algo.

Exemplo: hel(str.upper)

eval()

Executa uma string como código Python

expressao = "2 + 5 * 3"
print(eval(expressao))  

# Saída: 17

list()

Converte para lista

texto = "ABC"
print(list(texto))  # Saída: ['A', 'B', 'C']

numeros = (1, 2, 3)
print(list(numeros))  # Saída: [1, 2, 3]

set()

Cria um conjunto, removendo duplicadas.

numeros = [1, 2, 2, 3, 3, 3]
print(set(numeros))  # Saída: {1, 2, 3}

tuple()

Converte para tupla (imutável, não conseguiremos mais alterar os valores no decorrer do script)

lista = [10, 20, 30]
print(tuple(lista))  # Saída: (10, 20, 30)

Nome	Sintaxe	Descrição
abs	abs(x)	Retorna o valor absoluto de um número.
all	all(iterable)	Retorna True se todos os elementos do iterável forem verdadeiros.
any	any(iterable)	Retorna True se qualquer elemento do iterável for verdadeiro.
ascii	ascii(obj)	Retorna a versão ASCII de um objeto.
bin	bin(x)	Converte um número inteiro para uma string binária.
bool	bool(x)	Converte um valor para booleano.
breakpoint	breakpoint()	Insere um ponto de parada para depuração.
bytearray	bytearray([source[, encoding[, errors]]])	Retorna um novo array de bytes.
bytes	bytes([source[, encoding[, errors]]])	Retorna um novo objeto bytes.
callable	callable(object)	Retorna True se o objeto pode ser chamado como função.
chr	chr(i)	Converte um número inteiro em um caractere.
classmethod	classmethod(func)	Converte um método em um método de classe.
compile	compile(source, filename, mode)	Compila código fonte para um objeto de código.
complex	complex([real[, imag]])	Retorna um número complexo.
delattr	delattr(object, name)	Remove um atributo de um objeto.
dict	dict(**kwargs)	Cria um dicionário.
dir	dir([object])	Retorna os atributos e métodos válidos de um objeto.
divmod	divmod(a, b)	Retorna uma tupla com o quociente e o resto da divisão.
enumerate	enumerate(iterable, start=0)	Retorna um iterador enumerado.
eval	eval(expression[, globals[, locals]])	Executa uma expressão Python.
exec	exec(object[, globals[, locals]])	Executa código Python dinamicamente.
filter	filter(function, iterable)	Filtra elementos usando uma função.
float	float(x)	Converte um número ou string para ponto flutuante.
format	format(value[, format_spec])	Formata um valor.
frozenset	frozenset([iterable])	Retorna um conjunto imutável.
getattr	getattr(object, name[, default])	Retorna o valor de um atributo.
globals	globals()	Retorna um dicionário com variáveis globais.
hasattr	hasattr(object, name)	Retorna True se o objeto tem o atributo.
hash	hash(object)	Retorna o valor hash de um objeto.
help	help([object])	Invoca o sistema de ajuda.
hex	hex(x)	Converte um número para hexadecimal.
id	id(object)	Retorna o identificador único de um objeto.
input	input([prompt])	Lê entrada do usuário.
int	int(x=0)	Converte para número inteiro.
isinstance	isinstance(object, classinfo)	Verifica se objeto é instância de uma classe.
issubclass	issubclass(class, classinfo)	Verifica se é subclasse de outra classe.
iter	iter(object[, sentinel])	Retorna um iterador.
len	len(s)	Retorna o comprimento de um objeto.
list	list([iterable])	Cria uma lista.
locals	locals()	Retorna um dicionário de variáveis locais.
map	map(function, iterable)	Aplica uma função a todos os itens do iterável.
max	max(iterable)	Retorna o maior item.
memoryview	memoryview(obj)	Retorna uma visão de memória de um objeto.
min	min(iterable)	Retorna o menor item.
next	next(iterator[, default])	Retorna o próximo item de um iterador.
object	object()	Retorna um novo objeto base.
oct	oct(x)	Converte número para octal.
open	open(file, mode='r')	Abre um arquivo.
ord	ord(c)	Retorna o código Unicode de um caractere.
pow	pow(x, y[, z])	Potência: x elevado a y.
print	print(*objects, sep=' ', end='\n')	Imprime objetos.
property	property(fget=None, fset=None, fdel=None)	Cria um atributo gerenciado.
range	range(start, stop[, step])	Gera uma sequência de números.
repr	repr(object)	Retorna a representação string de um objeto.
reversed	reversed(seq)	Retorna um iterador invertido.
round	round(number[, ndigits])	Arredonda um número.
set	set([iterable])	Cria um conjunto.
setattr	setattr(object, name, value)	Define um atributo.
slice	slice(start, stop[, step])	Cria um objeto slice.
sorted	sorted(iterable[, key[, reverse]])	Retorna uma lista ordenada.
str	str(object='')	Converte para string.
sum	sum(iterable[, start])	Soma os itens de um iterável.
super	super([type[, object]])	Chama métodos da superclasse.
tuple	tuple([iterable])	Cria uma tupla.
type	type(object)	Retorna o tipo de um objeto.
zip	zip(*iterables)	Combina elementos em tuplas.