Praticando Python: funções

Praticando o uso de funções em Python - Funções em Python

Boas-vindas! Meu nome é Laís Urano, sou instrutora na escola de Programação da Alura, e irei te acompanhar ao longo dessa jornada de aprendizagem.

Audiodescrição: Laís se descreve como uma mulher parda, de olhos castanho-escuros, sobrancelhas castanho-escuras, e cabelo cacheado longo, castanho-escuro, volumoso e com mechas azuis abaixo das orelhas. Ela veste uma camiseta vermelha, está com um cordão prata no pescoço, usa batom vermelho na boca, delineado preto nos olhos, esmalte azul nas unhas, e está sentada em uma cadeira rosa e branca em frente a um microfone branco redondo apoiado em um suporte preto. Ao fundo, há uma parede clara iluminada em gradiente azul e verde.

Funções, lambdas e closures

O que são funções?

Quando desenvolvemos um projeto, é comum repetirmos o mesmo código várias vezes, o que pode se tornar um problema, especialmente para a manutenção.

Para resolver isso, utilizamos uma estrutura simples chamada funções. Funções são blocos de código reutilizáveis que executam tarefas específicas.

Para criar uma função em Python, utilizamos a sintaxe definida pela palavra-chave def, seguida do nome da função (nome_da_função()). Entre parênteses, passamos os parâmetros da função, que podem ser obrigatórios ou opcionais.

Em seguida, usamos dois-pontos (:) para abrir o escopo e fazemos uma indentação para incluir o bloco de código da função, que pode ou não retornar um valor.

def nome_da_função(parâmetros):
    # Bloco de código da função
    return valor_opcional

O que são parâmetros?

As funções podem variar a depender do contexto. Por exemplo: no trecho de código abaixo, temos a função ola_mundo() que recebe um nome entre parênteses.

def ola_mundo(nome):
    return f"Olá, {nome}!"

Nesse caso, nome é um parâmetro, que são variáveis declaradas no momento da criação da função, podendo ser obrigatórios ou opcionais. Isso torna o código mais flexível, pois podemos alterá-los sem modificar o código. Nesta função, retornamos uma f-string com "Olá, " seguido do nome.

Para chamar a função, basta usar o nome da função (ola_mundo()) e, entre parênteses, passar o parâmetro, que também pode ser chamado de argumento.

Os argumentos são passados quando o parâmetro é obrigatório. Por exemplo: ao chamar a função com print(ola_mundo("Laís")), recebemos a saída "Olá, Laís!".

def ola_mundo(nome):
    return f"Olá, {nome}!"

print(ola_mundo("Laís"))

Funções simples

Conforme dito anteriormente, as funções podem assumir várias formas diferentes.

O primeiro tipo são as funções simples, criadas e personalizadas pela própria pessoa desenvolvedora para realizar tarefas específicas. No exemplo abaixo, temos uma função somar() que recebe dois parâmetros: a e b. No escopo da função, há uma variável chamada soma que armazena a soma de a e b. Ao final, ela retorna o valor da soma, ou seja, return soma.

def somar(a, b):
    soma = a + b
    return soma

Esse bloco de execução e as variáveis criadas em uma função são locais, ou seja, só existem dentro dela. Para trabalhar com eles fora da função, será necessário criar outra variável.

Função com parâmetros padrão

Funções também podem ter parâmetros padrão. Por exemplo: na função cumprimentar() exibida abaixo, o parâmetro nome assume o valor padrão "Visitante".

def cumprimentar(nome = "Visitante"):
    print(f"Olá, {nome}!")

cumprimentar() # Saída: Olá, Visitante!
cumprimentar("Jade") # Saída: Olá, Jade!

Observe que, se não passarmos nenhum parâmetro ao chamar a função, ela assume o valor padrão e retorna "Olá, Visitante!". Podemos alterar esse valor passando outro parâmetro, como cumprimentar("Jade"), por exemplo, que retorna o texto "Olá, Jade!".

Funções built-in

Além disso, temos as funções built-in, que podem ser utilizadas diretamente, sem necessidade de importação ou definição. Existem funções built-in para manipulação, conversão e criação de tipos, além de funções matemáticas e para elementos iteráveis.

Em relação à interação, as funções built-in mais conhecidas são:

Método	Conceito	Exemplo	Saída
`print()`	Exibe valores no console.	`print("Olá, mundo!")`	Olá, mundo!
`input()`	Lê uma entrada do usuário como string.	`nome = input("Digite: ")`	Digite: Júnior

Quanto às funções de manipulação, podemos destacar:

Método	Conceito	Exemplo	Saída
`type()`	Retorna o tipo de um objeto.	`type(10)`	`<class 'int'>`
`isinstance()`	Verifica se um objeto pertence a um tipo específico ou a uma tupla de tipos. Retorna `True` se for do tipo indicado, caso contrário, retorna `False`.	`isinstance(10.5, int)` `isinstance("Python", (int, str))`	`False` `True`
`len()`	Retorna o tamanho de uma string, lista ou tupla.	`len("Python")`	6

Já para as funções de conversão e criação de tipos, temos:

Método	Conceito	Exemplo	Saída
`str()`	Converte um valor para string.	`str(123)`	"123"
`int()`	Converte um valor para inteiro.	`int("10")`	10
`float()`	Converte um valor para decimal.	`float("3.14")`	3.14
`bool()`	Converte um valor para `True` ou `False`.	`bool(1)`	`True`
`list()`	Converte um iterável para lista.	`list("abc")`	`["a", "b", "c"]`
`dict()`	Cria um dicionário.	`dict(nome = "Ana")`	`{"nome": "Ana"}`
`set()`	Cria um conjunto.	`set([1, 2, 3])`	`{1, 2, 3, 4}`

Em relação às funções matemáticas, temos a seguinte tabela:

Método	Conceito	Exemplo	Saída
`abs()`	Retorna o valor absoluto de um número	`abs(-10)`	10
`round()`	Arredonda um número.	`round(3.1415, 2)`	3.14
`max()`	Retorna o maior valor entre os fornecidos.	`max(3, 5, 1)`	5
`min()`	Retorna o menor valor entre os fornecidos.	`min(3, 5, 1)`	1
`sum()`	Retorna a soma de uma lista de números.	`sum([1, 2, 3])`	6

Por fim, temos as funções built-in que trabalham com elementos iteráveis:

Método	Conceito	Exemplo	Saída
`filter(operação, iterável)`	Filtra elementos de um iterável com base em uma condição.	`list(filter(lambda x : x > 2, [1, 2, 3, 4]))`	`[3, 4]`
`map(função, iterável)`	Aplica uma função a cada elemento de um iterável.	`list(map(lambda x : x * 2, [1, 2, 3]))`	`[2, 4, 6]`
`zip(iterável, iterável2, …)`	Une dois ou mais iteráveis, criando pares de elementos correspondentes.	`list(zip([1, 2, 3], ["a", "b", "c"]))`	`[(1, "a"), (2, "b"), (3, "c")]`
`sorted(iterável, key=função, reverse=bool)`	Retorna uma nova lista ordenada a partir de um iterável. Pode receber um argumento `key` para personalizar a ordenação.	`sorted([3, 1, 4, 2])`	`[1, 2, 3, 4]`
`reversed(iterável)`	Retorna um iterador com os elementos de um iterável na ordem inversa.	`list(reversed([1, 2, 3]))`	`[3, 2, 1]`

Para conhecer todas as funções built-in, consulte a documentação oficial do Python.

Funções recursivas

As funções recursivas são aquelas que chamam a si mesmas para resolver problemas repetitivos. Além disso, elas precisam de uma condição de parada. Um exemplo é a função fatorial() abaixo, que recebe um valor n. Se n for igual a 0, retornamos o valor 1, pois zero fatorial é 1. A função principal retorna n * fatorial(n - 1). Ao calcular o fatorial de 5, a função retorna 120.

def fatorial(n):
    if n == 0:
        return 1
    return n * fatorial(n - 1)

print(fatorial(5)) # Saída: 120

Esse tipo de função é usado para resolver problemas que podem ser divididos em subproblemas menores, como cálculos matemáticos e algoritmos de estrutura de dados.

Funções anônimas (lambda)

Existem também as funções anônimas, ou funções lambda, que são pequenas e sem nome, podendo ter múltiplos argumentos, mas apenas uma expressão. A sintaxe utiliza lambda no lugar de def, seguido dos argumentos, dois-pontos e a expressão. Elas são úteis para operações simples ou dentro de outras funções. Por exemplo: soma = lambda a, b: a + b define uma função que soma a e b.

# Sintaxe
lambda argumentos: expressão

soma = lambda a, b: a + b
print(soma(3, 5)) # Saída: 8

Observação: outra aplicação possível para a função lambda é em conjunto com a função map(), que aplica uma função a cada elemento de um iterável.

Funções dentro de funções (closure)

Funções dentro de funções, ou closures, são funções internas que lembram o ambiente em que foram criadas, mesmo após executar a função externa. Um exemplo é a função multiplicador() exibida abaixo, que recebe um valor n entre parênteses e retorna a função interna multiplica(), que utiliza n. Ao chamar triplo = multiplicador(3) e triplo(5), obtemos 15.

def multiplicador(n): # Função externa
    def multiplica(x): # Closure
        return x * n
    return multiplica # Retorna a função interna

triplo = multiplicador(3)
valor = triplo(5)
print(valor) # Saída: 15

Closures são úteis para encapsular lógicas e variáveis específicas sem criar variáveis globais. Outro exemplo de aplicação dessas funções é o gerador de saudações personalizadas abaixo:

def criar_saudacao(saudacao):
    def saudar(nome):
        return f"{saudacao}, {nome}!"
    return saudar

bom_dia = criar_saudacao("Bom dia")
boa_noite = criar_saudacao("Boa noite")
print(bom_dia("Vini")) # Saída: Bom dia, Vini!
print(boa_noite("Ana")) # Saída: Boa noite, Ana!

A função externa criar_saudacao() recebe uma saudacao, enquanto a função interna saudar() retorna a saudacao seguida do nome. Dessa forma, conseguimos criar saudações como "Bom dia" e "Boa noite", além de utilizá-las com diferentes nomes.

Conclusão

Caso você tenha dúvidas ou interesse em discutir sobre o conteúdo do curso com outras pessoas estudantes, conte com o apoio do fórum e da nossa comunidade no Discord.

Compartilhe seu progresso nas redes sociais com a hashtag #AprendizadoAlura.

Nos encontramos em uma próxima oportunidade!

Sobre o curso Praticando Python: funções

O curso Praticando Python: funções possui 11 minutos de vídeos, em um total de 14 atividades. Gostou? Conheça nossos outros cursos de Python em Programação, ou leia nossos artigos de Programação.

Matricule-se e comece a estudar com a gente hoje! Conheça outros tópicos abordados durante o curso:

Praticando o uso de funções em Python