Python para Iniciantes
Carregando, aguarde alguns segundos.

3 - Funções

O Python é uma linguagem de programação versátil e poderosa, e uma das razões para isso é a presença de várias funções integradas (built-in functions) que facilitam tarefas comuns, além das funções de outras bibliotecas e frameworks que podem ser instalados, além das funções declaradas por você em seus programas.

As Funções de conversão de tipo permitem que você converta valores de um tipo para outro.

  • int(): Converte um valor para um número inteiro.
  • float(): Converte um valor para um número de ponto flutuante.
  • str(): Converte um valor para uma string.
  • bool(): Converte um valor para um booleano. 
num_int = int("42")
num_float = float("3.14")
string_num = str(123)
boolean = bool(1)
print(f"num_int: {num_int} ({type(num_int)})")
print(f"num_float: {num_float} ({type(num_float)})")
print(f"string_num: {string_num} ({type(string_num)})")
print(f"boolean: {boolean} ({type(boolean)})")

As Funções de sequência permitem que você determine o comprimento de uma sequência e o valor mínimo e o valor máximo de uma sequência.

  • len(): Retorna o comprimento de uma sequência (string, lista, etc.).
  • max(): Retorna o elemento de valor máximo em uma sequência.
  • min(): Retorna o elemento de valor mínimo em uma sequência. 
tamanho = len("Python")
maximo = max([3, 1, 4, 1, 5, 9, 2])
minimo = min((5, 2, 8, 1, 7))
print(f"Tamanho: {tamanho}")
print(f"Máximo: {maximo}")
print(f"Mínimo: {minimo}")

As Funções de entrada/saída permitem que você imprima valores na saída padrão e que você leia valores de entrada do usuário.

  • input(): Lê uma linha de entrada do usuário.
  • print(): Imprime valores na saída padrão. 
print("Alô,, Mundo!")
entrada_usuario = input("Digite algo: ")
Alô,, Mundo!
Digite algo: _

As funções matemáticas permitem que você execute operações matemáticas com números.

  • abs(): Retorna o valor absoluto de um número.
  • pow(): Retorna a potência de um número.
  • round(): Arredonda um número para o inteiro mais próximo. 
valor_absoluto = abs(-42)
potencia = pow(2, 3)
arredondamento = round(3.14159, 2)
print(f"Valor absoluto: {valor_absoluto}")
print(f"Potência: {potencia}")
print(f"Arredondamento: {arredondamento}")

As funções de controle de fluxo permitem que você determine o fluxo de execução de um programa.

  • range(): Gera uma sequência de números.
  • len(): Retorna o comprimento de uma sequência. 
faixa = range(5)
print(f"Faixa: {faixa}")
for i in faixa:
    print(i)

lista = [1, 2, 3, 4, 5]
tamanho = len(lista)
print(f"Lista: {lista}")
print(f"Tamanho: {tamanho}")

As funções de manipulação de listas permitem que você manipule sequências de dados.

  • sorted(): Retorna uma nova lista ordenada.
  • sum(): Retorna a soma dos elementos em uma sequência. 
numeros = [3, 1, 4, 1, 5, 9, 2]
numeros_ordenados = sorted(numeros)
soma_numeros = sum(numeros)
print(f"Lista: {numeros}")
print(f"Lista ordenada: {numeros_ordenados}")
print(f"Soma dos itens: {soma_numeros}")

Essas são apenas algumas das muitas funções integradas disponíveis no Python, parte integrante da linguagem que fornece funcionalidades essenciais para uma ampla variedade de tarefas.

Além das funções integradas do Python, prontas para uso, novas funções podem ser incluidas no código.

As funções são blocos nomeados de instruções que executam uma tarefa especifica, recebendo dados de entrada e retornando dados de saida.

No Python, as funções são declaradas com um cabeçalho na primeira linha, iniciado pela palavra-chave def, seguida do nome da função e argumentos (opcionais) entre parênteses, e dois pontos (:) para encerrar o cabeçalho.

A partir da linha de baixo, com uma indentação qualquer, geralmente quatro espaços, as instruções de código da função devem ser escritas, com as linhas de indentação correspondentes e retornando com a instrução return seguida dos dados de saida.

Se não houver return, o Python retornará quando a última instrução do bloco identado for executada. 

def imprime_nada():
    print("Nada 1") # instrução da função
    print("Nada 2") # instrução da função
    print("Nada 3") # última instrução da função

A função é chamada pelo nome e parênteses, pois a função não recebe argumentos. 

imprime_nada()

Se não houver a instrução return na função, o Python retorna None.

Na programação procedural, existe uma diferenciação entre funções e procedimentos, pois enquanto funções executam tarefas e retornam valores usando a instrução return, procedimentos executam tarefas e não retornam valores e são encerrados sem a instrução return ou com a instrução return sem dados de saída.

O Python retorna automaticamente None para um procedimento não finalizado com instrução return ou com a instrução return sem dados de saída, implicando ao procedimento um comportamento de função.

Assim sendo, procedimentos e funções serão referidos simplemente como funções, retornando ou não dados de saida. 

def imprimir_numero(x):
    print(x)

print(imprimir_numero(10))

No exemplo acima, a função imprimir_numero() imprime um número e encerra a execução da função sem retornar algum valor.

Assim sendo, é retornado automaticamente o valor None impresso na tela.

As funções permitem que tarefas repetitivas, com as mesmas instruções, mas usando diferentes valores, possam ser encapsuladas em um único bloco que pode ser reutilizado com argumentos diferentes. 

def soma(x, y):
    return x + y

print(soma(10, 5))
print(soma(12.5, 5.3))
print(
    soma(
        soma(
            soma(13, 3),
            soma(14.5, 6.3)
        ), 
        soma(
            soma(10, 5),
            soma(12.5, 5.3)
        )
    )
)

As funções são fundamentais para organização da programação, permitindo o reaproveitamento de código e facilitando a escrita e manutenção de programas.

No contexto da programação, uma função é uma sequência nomeada de instruções que executa uma operação de computação.

Ao definir uma função, você especifica o nome para a função em conjunto com os argumentos que serão utilizados na função, e a sequência de instruções.

Depois, pode “chamar” (invocar) a função pelo nome.

Neste capítulo, veremos as funções integradas e como declarar novas funções no Python.

Veremos o uso dos argumentos na função, permitindo trabalhar com diferentes dados de entrada.

Também veremos como as funções podem retornar valores, fornecendo resultados necessários ao restante do programa.

3.1 - Declaração

As funções são blocos de intruções que realizam uma tarefa específica e podem ser chamadas pelo nome para executar essa tarefa sempre que necessário.

Usam argumentos como dados de entrada de qualquer tipo e podem retornar um ou mais valores como resultado.

Em Python, definimos funções declarando um cabeçalho na primeira linha, seguido do corpo da função nas linhas seguintes.

O cabeçalho é declarado com a palavra-reservada def, seguida do nome da função e parênteses, que podem conter opcionalmente um ou mais argumentos, e dois pontos para indicar o termino do cabeçalho.

O corpo são as instruções no bloco declarado a seguir ao cabeçalho, contendo instruções usando a mesma indentação.

A palavra-reservada return causa o retorno para fora da função e permite retornar um ou mais valores como dados de saida. 

def saudacao(nome):
    s = f"Olá, {nome}! Bem-vindo(a) à nossa função."
    return s

Neste exemplo, função nomeada saudacao recebe o argumento nome, contendo duas linhas de código com o mesmo alinhamento, usando a instrução return para retorna o valor da variável local s, contendo uma saudação personalizada.

Uma função é executada usando o nome da função, seguido de parênteses contendo os argumentos necessários, se houver.

Na função saudacao() passamos apenas o argumento nome. 

nome_pessoa = "Pedro"
mensagem = saudacao(nome_pessoa)
print(mensagem)

Neste exemplo, atribuimos "Pedro" ao valor da variável nome_pessoa e chamamos a função saudacao() usando esta variável como argumento.

O resultado da função é atribuindo na variável mensagem e a variável é exibida na tela.

3.2 - Argumentos

Os argumentos são os dados de entrada fornecidos para uma função, usando nomes para os argumentos, declarados sequencialmente, separados por vírgula, na ordem desejada.

A função soma() a seguir recebe dois argumentos a e b com os valores utilizados na soma. 

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

Chamamos a função pelo nome e com os argumentos numéricos obrigatórios entre parênteses, na ordem em que foram definidos. 

a = 2
b = 3
s = soma(a,b)
print(f"A soma de {a} + {b} = {s}")

No caso da soma a ordem entre os operandos não altera o resultado. 

a = 10
b = 20

s = soma(a,b)
print(f"A soma de {b} / {a} = {s}")

s = soma(b,a)
print(f"A soma de {b} / {a} = {s}")

No caso da divisão a ordem dos operandos nos argumentos altera o resultado. 

def divisao(a,b):
    return a / b

a = 10
b = 20

s = divisao(a,b)
print(f"A divisão de {a} / {b} = {s}")

s = divisao(b,a)
print(f"A divisão de {b} / {a} = {s}")

Os argumentos são obrigatórios, e a ausência de argumentos fará com que o programa apresente erro. 

s = soma(10)

Os argumentos além aos declarados fará com que o programa também apresente erro. 

s = soma(10,20,30)

Os argumentos, além de serem posicionais, são nomeados. Assim, podem ser acessados pelo nome em conjunto com o valor, na chamada da função, permitindo que a ordem dos argumentos seja alterada, com os valores em conjunto com os respectivos nomes de argumento.

Para chamar uma função com os argumentos nomeados, use o nome da função seguido de parênteses '(' e ')', contendo os argumentos nomeados e seus respectivos valores, separados por igual '='. 

def calcular_potencia(base, expoente):
    return base ** expoente

resultado1 = calcular_potencia(2, 3)                # Chama a função usando argumentos posicionais
resultado2 = calcular_potencia(expoente=3, base=2)  # Chama a função usando argumentos nomeados

print("Argumentos posicionais: ", resultado1)
print("Argumentos nomeados: ", resultado2)

Neste exemplo, a função calcular_potencia() é chamada tanto com os argumentos na ordem posicional na atribuição da variável resultado1 quanto com argumentos nomeados na atribuição da variável resultado2.

3.2.1 - Argumentos Nome-Valor

Chamaremos aqui de argumentos nome-valor aos argumentos nomeados declarados juntos a um valor-padrão e que, não sendo usados na chamada da função, utilizam este valor-padrão ao serem utilizados na função.

Você pode chamar uma função fornecendo os argumentos pelo nome, o que permite que você altere a ordem dos argumentos.

Os argumentos nome-valor são declarados no cabeçalho da função usando o nome do argumento seguido do sinal de atribuição igual '=' e do valor-padrão, permitindo que os argumentos sejam omitidos na chamada da função.

Os argumentos nome-valor não declarados na chamada da função utilizam o valor-padrão definido. 

def saudacao(nome="usuário"):
    return f"Olá, {nome}! Bem-vindo(a) à nossa função."
print("Sem argumento: ", saudacao())
print("Com argumento: ", saudacao("Rosana"))

Neste exemplo, definimos o valor-padrão "usuário" para o argumento nome na função saudacao. Se o argumento não for fornecido, o este valor-padrão será utilizado.

3.2.2 - Argumentos Arbitrários

Você pode definir funções que aceitam um número arbitrário de argumentos usando os símbolos * e **.

O argumento arbitrário *args permite passar um número arbitrário de argumentos posicionais em forma de tupla.

O argumento arbitrário **kwargs permite passar um número arbitrário de argumentos nomeados em forma de dicionário. 

def somar_numeros(*args):
    resultado = sum(args)
    return resultado

def imprimir_info(**kwargs):
    for chave, valor in kwargs.items():
        print(f"{chave}: {valor}")

print(somar_numeros(1, 2, 3, 4))

imprimir_info(nome="Pedro", idade=29, cidade="BH")

Neste exemplo, a função somar_numeros() aceita um número arbitrário de argumentos posicionais, enquanto a função imprimir_info() aceita um número arbitrário de argumentos nomeados.

Também, podem ser mesclados os argumentos *args e **kwargs para definir funções que aceitam argumentos posicionais. 

def argumentos_arbitrarios(*args, **kwargs):
    print("*args:", args)
    print("**kwargs:", kwargs)

argumentos_arbitrarios(1, 2, 3, 4, nome="Pedro", idade=29, cidade="BH")

3.3 - Lambda

As funções lambda são funções anônimas que podem ter apenas uma expressão. Elas são úteis para criar pequenas funções que serão usadas apenas uma vez. 

dobro = lambda x: x * 2
print(dobro(5))

Neste exemplo, criamos uma função lambda que retorna o dobro de um número.

3.3.1 - Retornando Funções de Outras Funções

Em Python, você pode retornar funções de outras funções, denominadas como funções de ordem superior. 

def criar_funcao(sinal):
    if sinal == "+":
        return lambda x, y: x + y
    elif sinal == "-":
        return lambda x, y: x - y

adicao = criar_funcao("+")
subtracao = criar_funcao("-")

print(adicao(3, 5))      # Saída: 8
print(subtracao(10, 6))  # Saída: 4

Neste exemplo, a função criar_funcao retorna uma função lambda dependendo do sinal fornecido.

3.4 - Recursão

A recursão é um conceito em programação onde uma função chama a si mesma para resolver um problema.

No caso da recursão, a solução de um problema é dividida em subproblemas menores, e a função é chamada repetidamente até que o problema seja resolvido para o caso base.

Um exemplo clássico de recursão é a implementação da função fatorial. O fatorial de um número n é o produto de todos os números inteiros de 1 a n, e é denotado por:

n!=n×(n−1)×(n−2)×…×2×1

A implementação recursiva em Python para calcular o fatorial pode ser feita da seguinte maneira: 

def fatorial(n):
    # Caso base: fatorial de 0 ou 1 é 1
    if n == 0 or n == 1:
        return 1
    else:
        # Chamada recursiva para calcular fatorial
        return n * fatorial(n - 1)

O fatorial de 5 = 5 x 4 x 3 x 2 x 1 = 120. 

resultado = fatorial(5)
print("O fatorial de 5 é:", resultado)

Neste exemplo, a função fatorial chama a si mesma com um argumento reduzido em n−1 até atingir o caso base, onde n é igual a 0 ou 1.

No caso base, a função retorna 1, pois o fatorial de 0 ou 1 é 1. Caso contrário, a função retorna n multiplicado pelo fatorial do número anterior (n−1).

É importante notar que, embora a recursão seja uma abordagem elegante para resolver certos tipos de problemas, ela também pode ter limitações em termos de uso de memória e desempenho.

Em alguns casos, é possível reescrever uma função recursiva para uma versão iterativa (usando laços de repetição), o que pode ser mais eficiente em termos de recursos.

Um exemplo mais complexo e matematicamente interessante para ilustrar a recursão é a sequência de Fibonacci.

A sequência de Fibonacci é uma sequência de números onde cada número é a soma dos dois anteriores.

A sequência começa geralmente com 0 e 1. Matematicamente, é definida por:

0 se n = 0

1 se n = 1

F(n) = F(n-1) + F(n-2) se n > 1

Aqui está uma implementação recursiva em Python para calcular o n-ésimo termo da sequência de Fibonacci: 

def fibonacci(n):
    if n == 0:
        return 0
    elif n == 1:
        return 1
    else:
        return fibonacci(n - 1) + fibonacci(n - 2)

Exemplo de uso: 

termo_10 = fibonacci(10)
print("O 10º termo da sequência de Fibonacci é:", termo_10)

Neste exemplo, a função fibonacci chama a si mesma duas vezes, uma vez para n−1 e outra vez para n−2 até atingir os casos-base (n=0 e n=1). A soma dos resultados das chamadas recursivas é retornada.

Embora a recursão seja uma maneira elegante de expressar a solução para a sequência de Fibonacci, ela pode ser ineficiente para valores grandes de n devido à quantidade substancial de chamadas de função repetidas.

Nesses casos, é comum usar técnicas de memorização (armazenamento em cache dos resultados de chamadas anteriores) ou abordagens iterativas para otimizar o desempenho.

Lembre-se de que a recursão é uma ferramenta poderosa, mas deve ser usada com cuidado para evitar estouros de pilha (stack overflow) e garantir um bom desempenho em casos de uso prático.

3.5 - Conclusão

Os recursos avançados das funções em Python oferecem uma poderosa flexibilidade para programação de um código conciso, legível e eficiente.

Os argumentos permitem a entrada de dados paras funções, e os argumentos arbitrários permitem que você lide com diferentes quantidades de dados de entrada.

As funções lambda são úteis para criar funções pequenas e rápidas, e retornar funções de outras funções é uma técnica poderosa para criar abstrações e tornar o código mais modular e reutilizável.

Arduino
Coautor
Betobyte
Autor
Autores
||| Áreas ||| Estatística ||| Python ||| Projetos ||| Dicas & Truques ||| Quantum ||| Python para Iniciantes || Python para Iniciantes || Python Básico || Matplotlib || Numpy || Seaborn || Pandas || Django || Estatística para Cientistas de Dados || Python com ML Básico || Python com ML Básico || Aulas | Introdução (Instalação, variáveis e tipos de dados, operações, formatação e comentários.) | Coleções (Listas, Tuplas, Conjuntos e Dicionários.) | Funções e Módulos (Declaração, argumentos, retorno, recursão, funções lambda.) | Estruturas de Controle (Controle Condicional (if/elif/else, match) e Controle de repetição (for, while).) | Classes (Classes, Herança e Polimorfismo.) | Bibliotecas e Frameworks (Pacotes integrados, instalados e personalizados.) | Manipulação de Arquivos (Manipulação de Arquivos) | Bancos de Dados SQL (MySQL, SQLite e PostgreSQL.) | Capítulo 9 (APIs e Web Scraping) | Capítulo 10 (Projetos Práticos) | Considerações finais () |