Funções em Python

Este artigo explica as funções no Python.

YouTube Video

Funções em Python

As funções em Python são um recurso essencial para definir blocos reutilizáveis de código, permitindo que você organize e simplifique seu programa chamando-as conforme necessário. O uso de funções pode melhorar a legibilidade do código e aderir ao princípio DRY (Don’t Repeat Yourself, evite escrever o mesmo código várias vezes).

Definindo Funções

As funções são definidas usando a palavra-chave def. A sintaxe básica é a seguinte:.

1def function_name(arg1, arg2, ..., argN):
2    """docstring (A brief description of the function)"""
3    processing
4    return return_value

Por exemplo, para definir uma função que soma dois números, você escreveria:.

1def add(x, y):
2    """A function that adds two numbers and returns the result"""
3    return x + y

Chamando Funções

Uma função definida pode ser chamada e usada da seguinte forma:.

1result = add(3, 4)
2print(result)  # Output: 7

Componentes de uma Função

1. Nome da Função: O nome da função, usado para chamá-la.

2. Argumentos (Parâmetros): Nomes de variáveis que recebem dados passados durante a chamada. Você pode definir zero ou mais argumentos.

3. String de Documentação (Docstring): Uma string usada para descrever o propósito e o uso de uma função. Opcional.

4. Corpo da Função: Um bloco indentado onde são escritas as instruções que a função executa.

5. Valor de Retorno: O valor retornado ao chamador usando a instrução return. Se return for omitido, None será retornado por padrão.

Tipos de Argumentos

Em Python, existem vários tipos de argumentos.

1. Argumentos Posicionais: A forma padrão de passar argumentos para funções.
2. Argumentos Padrão: Argumentos com valores padrão que podem ser omitidos durante a chamada.

1def greet(name, message="Hello"):
2    print(f"{message}, {name}")
3
4greet("Alice")  # "Hello, Alice"
5greet("Bob", "Good morning")  # "Good morning, Bob"

3. Argumentos de Comprimento Variável: *args para receber vários argumentos posicionais como uma tupla, e **kwargs para recebê-los como um dicionário.

1def func(*args, **kwargs):
2    print("args:", args)
3    print("kwargs:", kwargs)
4
5func(1, 2, 3, a=4, b=5)
6# Output:
7# args: (1, 2, 3)
8# kwargs: {'a': 4, 'b': 5}

Ao usar funções corretamente, você pode escrever programas em Python de forma mais eficaz e eficiente.

Funções Lambda em Python

Em Python, funções lambda são usadas para definir funções anônimas e concisas. Ao contrário das funções definidas com a palavra-chave def, lambda permite criar funções curtas de uma única linha. Aqui, explicaremos as funções lambda em Python em detalhes.

Noções Básicas sobre Funções lambda

Funções lambda, também chamadas de funções anônimas, são usadas para definir funções temporárias que não possuem nome, como o próprio nome sugere. A sintaxe básica é a seguinte:.

1lambda arguments: expression

• arguments: Especifique os argumentos da função. Vários argumentos podem ser especificados, separados por vírgulas.
• expression: Esta é uma expressão avaliada com base nos argumentos. O resultado da expressão se torna o valor de retorno da função.

Por exemplo, o código a seguir define e executa uma função lambda que soma dois números.

1add = lambda x, y: x + y
2print(add(5, 3))  # Output: 8

Neste exemplo, lambda x, y: x + y é uma função lambda que recebe dois argumentos, x e y, e retorna a soma deles.

Casos de Uso de Funções lambda

Funções lambda são úteis em situações onde você precisa definir uma função simples no momento. Elas são particularmente comuns nos seguintes casos:.

1. Quando Passadas como Argumentos para Funções

   • É útil em funções de ordem superior (funções que recebem outras funções como argumentos) ao passar funções curtas e temporárias.

2. Ao Especificar Chaves para Ordenar Listas

   • Elas são úteis para especificar critérios de ordenação (chaves) em funções como sort() ou sorted().

Exemplo de Uso em Funções de Ordem Superior

Exemplos típicos de funções de ordem superior incluem map(), filter() e reduce(). Essas funções recebem outras funções como argumentos e as aplicam a sequências, como listas.

1numbers = [1, 2, 3, 4, 5]
2squared = list(map(lambda x: x ** 2, numbers))
3print(squared)  # Output: [1, 4, 9, 16, 25]

Neste exemplo, uma função lambda é passada para a função map() para elevar ao quadrado cada número em uma lista.

Exemplos de uso de ordenação de listas

A função lambda pode, às vezes, ser usada para especificar uma chave personalizada ao ordenar uma lista. Por exemplo, o código a seguir ordena uma lista de tuplas com base no segundo elemento.

1pairs = [(1, 'one'), (2, 'two'), (3, 'three'), (4, 'four')]
2pairs.sort(key=lambda pair: pair[1])
3print(pairs)
4# Output: [(4, 'four'), (1, 'one'), (3, 'three'), (2, 'two')]

Neste exemplo, uma função lambda é usada para ordenar as tuplas com base no seu segundo elemento (uma string).

filter() e lambda

A função filter() é usada para filtrar elementos em uma lista (ou outro iterável) com base em uma condição dada.

1numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9]
2even_numbers = list(filter(lambda x: x % 2 == 0, numbers))
3print(even_numbers)  # Output: [2, 4, 6, 8]

Neste exemplo, os números pares de uma lista são filtrados para criar uma nova lista.

lambda e reduce()

A função reduce() é usada para reduzir uma lista a um único valor. Ela pode ser implementada facilmente usando uma função lambda.

1from functools import reduce
2
3numbers = [1, 2, 3, 4, 5]
4product = reduce(lambda x, y: x * y, numbers)
5print(product)  # Output: 120

Neste exemplo, todos os elementos da lista são multiplicados para produzir um resultado.

Evite usar funções lambda complexas

A vantagem das funções lambda é sua brevidade, mas elas ficam mais difíceis de ler quando usadas para implementar lógica complexa. Portanto, é adequado usá-las para operações simples que possam ser expressas em uma única linha. Para operações complexas, definir uma função com def é mais legível e fácil de manter.

Por exemplo, você deve evitar usar funções lambda complexas como a mostrada abaixo.

1# Complex and hard-to-read lambda function
2complex_func = lambda x, y: (x * 2 + y) if x > y else (x + y * 2)

Neste caso, é melhor usar uma função definida com def, como mostrado abaixo.

1def complex_func(x, y):
2    if x > y:
3        return x * 2 + y
4    else:
5        return x + y * 2

Conclusão

As funções lambda do Python são uma ferramenta conveniente para definir funções temporárias e curtas. Elas são frequentemente usadas em funções de ordem superior ou operações de listas para definir condições específicas de forma concisa. No entanto, as funções lambda devem ser limitadas a tarefas simples, preferindo funções definidas com def para lógicas complexas.

Você pode acompanhar o artigo acima usando o Visual Studio Code em nosso canal do YouTube. Por favor, confira também o canal do YouTube.

YouTube Video