Funções em Python - #16

Introdução

Uma função é um miniprograma dentro de um programa. É uma estrutura da linguagem que possibilita uma melhor organização de seu programa e facilita a resolução de problemas mais complexos, através delas podemos resolver partes específicas do problema.

Outra vantagem do uso de funções é a possiblidade de reutilização do código, podemos por exemplo, criar uma biblioteca de funções e utilizá-las em nossos programas, sem a necessidade de reescrever a mesma funcionalidade.

Neste capítulo iremos aprender a usar outras funções disponíveis na linguagem como também a criar as nossas próprias funções.

Função bool()

A função bool() retorna True ou False ao receber um parâmetro.

Se o valor é numérico, ele retornará False se o parâmetro é igual a zero.

Para strings, listas e dicionários vazios, o retorno também será False. Como também para o valor None.

#função bool() em ação
>>> bool(-2)
True
>>> bool(0)
False
>>> bool(0)
False
>>> bool(-2)
True
>>> bool(0.00)
False
>>> bool(3.14)
True
>>> bool(None)
False
>>> bool('casa')
True
>>> bool('')
False
>>> bool(' ')
True
>>> bool([])
False
>>> bool([1])
True

Função abs()

A função abs( ) retorna o valor absoluto de um número. O valor sem sinal.

#função abs() em ação
>>> abs(-20)
20
>>> abs(20)
20
>>> abs(-5.433)
5.433
>>> abs(0)
0

Usando módulos

As funções em Python são organizadas em módulos. Cada módulo possui um conjunto de funções relacionadas, que podem ser utilizadas em nossos programas.

Antes de utilizarmos funções de um módulo, precisamos importar o módulo através da instrução import.

Instrução import

Por exemplo, se quisermos gerar 3 números inteiros de forma randômica ou aleatória, entre 1 e 11 com a função randint():

#Algoritmo - gerando 3 números inteiros aleatórios
import random
for i in range(3):
    print(random.randint(1, 10))

Na linha 01 temos que importar o módulo random que contém a função randint( ).

Na linha 03 fazemos a chamada do método, utilizando o nome do módulo e o nome da função, concatenados com um ponto (“.”) .

#Execução - gerando 3 números inteiros aleatórios 
10
7
4

Instrução from - import

Uma alternativa na sintaxe import é utilizar a palavra reservada from e o asterisco (“*”):

#Algoritmo - gerando 3 números inteiros aleatórios versão 2
from random import *
for i in range(3):
    print(randint(1, 10))

Com a sintaxe da linha 01, não é necessário utilizar o prefixo random. para executar o método randint( ). Podemos interpretar a instrução from random import * como, “do (módulo) random, importe tudo”. O asterisco em computação, geralmente, representa “tudo”, “todos”.

Ou podemos especificar quais funções importar com a mesma sintaxe.

#Algoritmo - gerando 3 números inteiros aleatórios versão 3
from random import randint
for i in range(3):
    print(randint(1, 10))

Usando alias

Podemos utilizar um “apelido” ou alias no nome das funções importadas.

#Algoritmo - gerando 3 números inteiros aleatórios versão 4
from random import randint as rand
for i in range(3):
    print(rand(1, 10))

Também é permitido o uso de alias em nome de módulo.

#Algoritmo - gerando 3 números inteiros aleatórios versão 5
import random as r
for i in range(3):
    print(r.randint(1, 10))

Mútiplos imports

Finalmente, para importarmos múltiplos módulos em um programa, basta separarmos os nomes por vírgula.

#Múltiplos imports
import random, math, sys

Módulo time

Função asctime( )

A função asctime( ) retorna a data e horário atual como uma string.

#Usando função asctime()
>>> import time
>>> print(time.asctime())
Mon Apr 11 10:49:25 2022

Também podemos usar a asctime( ) para gerar uma data e hora de uma string. Para isso, temos que fornecer uma tupla com 9 valores: o ano, dia, hora, minutos, segundos, dia da semana (0 é Segunda-Feira, 1 é Terça-Feira, …, 6 - Domingo), dia do ano (pode colocar ZERO), horário de verão (1 - SIM, 0 - NÃO).

Veja alguns exemplos.

#Usando função asctime() com tuplas
>>> import time

>>> t = (2021, 12, 25, 10, 00, 30, 2, 0, 0)
>>> print(time.asctime(t))
Wed Dec 25 10:00:30 2021

>>> t = (2007, 7, 31, 15, 10, 45, 2, 0, 0)
>>> print(time.asctime(t))
Wed Jul 31 15:10:45 2007

Função time( )

A função time() retorna a quantidade de segundos desde 01-Janeiro-1970 00:00:00 AM.

#Usando função time()
>>> import time
>>> print(time.time())
1649667539.7314017

É bastante utilizado quando você quer saber o tempo de execução de um programa ou trecho de código.

#Algoritmo - tempoSomar.py
import time

def somar(n):
    soma = 0
    for i in range(n):
        soma += i
    return soma

n = input("Digite quantidade de numeros para somar: ")
inicio = time.time()
print(somar(int(n)))
fim = time.time()
print("Tempo de execução: ", fim - inicio, " segundos")

Capturamos o tempo antes de executar a função somar( ) na linha 10. E após a execução capturamos novamente o tempo.

Na linha 13 imprimimos a diferença no tempo de execução da função.

#Execução - tempoSomar.py
Digite quantidade de numeros para somar: 100000
4999950000
Tempo de execução:  0.003997802734375  segundos

Função localtime( )

A função localtime() retorna um tupla com 9 valores locais: ano, mês, dia, hora, minutos, segundos, dia do ano e se é horário de verão.

#Usando função localtime()
>>> import time

>>> time.localtime()
time.struct_time(tm_year=2022, tm_mon=4, tm_mday=11, tm_hour=11, tm_min=18, tm_sec=48, tm_wday=0, tm_yday=101, tm_isdst=1)

>>> t = time.localtime()
>>> print("Minutos ", t[4])
Minutos  18
>>> print("Dia do ano ", t[7])
Dia do ano  101

Módulo copy

Função copy( )

A função copy() cria uma cópia de uma lista ou dicionário, criando uma cópia distinta, alterando uma lista ou dicionário não afetará a outra.

#Usando função copy()
>>> import copy
>>> lista_original = ["asa", "aviao"]
>>> lista_copia = copy.copy(lista_original)
>>> lista_copia.append("arara")
>>> lista_original
['asa', 'aviao']
>>> lista_copia
['asa', 'aviao', 'arara']

Função deepcopy

A função deepcopy() é semelhante à função copy(), mas aplicado quando os elementos da lista ou do dicionário são outras listas ou dicionários.

#Algoritmo - deepcopyAcao.py
import copy

turma_original = [
    {'nome': 'Ana', 'nota': 7.5},
    {'nome': 'Bia', 'nota': 8.5}
]

turma_copia = copy.deepcopy(turma_original)
turma_copia.pop()

print(turma_original)
print(turma_copia)

#Execução - deepcopyAcao.py
[{'nome': 'Ana', 'nota': 7.5}, {'nome': 'Bia', 'nota': 8.5}]
[{'nome': 'Ana', 'nota': 7.5}]

Módulo random

Função random.choice()

A função choice() retorna um elemento aleatório da lista.

#Usando função choice()
>>> import random
>>> lista_cor = ["preto", "branco", "vermelho"]

>>> random.choice(lista_cor)
'preto'
>>> random.choice(lista_cor)
'preto'
>>> random.choice(lista_cor)
'vermelho'
>>> random.choice(lista_cor)
'branco'
>>> random.choice(lista_cor)
'branco'

Função random.shuffle()

A função shuffe() reordena os itens de uma lista.

#Usando função shuffle()
>>> import random
>>> lista_cor = ["preto", "branco", "vermelho"]

>>> random.shuffle(lista_cor)
>>> print(lista_cor)
['vermelho', 'preto', 'branco']

>>> random.shuffle(lista_cor)
>>> print(lista_cor)
['branco', 'vermelho', 'preto']

Módulo pprint

Função pprint()

A função prprint() imprime um dicionário ordenando suas chaves.

#Algoritmo - countCharPPrint.py
import pprint 

texto = input("Digite um texto: ")
count = {}
for letra in texto:
    count.setdefault(letra, 0)
    count[letra] += 1

pprint.pprint(count)

#Execução - countCharPPrint.py
Digite um texto: abacaxi de morango
{' ': 2,
 'a': 4,
 'b': 1,
 'c': 1,
 'd': 1,
 'e': 1,
 'g': 1,
 'i': 1,
 'm': 1,
 'n': 1,
 'o': 2,
 'r': 1,
 'x': 1}

Função pformat()

A função pformat() é semelhante ao pprint() mas ao invés de imprimir na tela, ele retorna uma string com as chaves do dicionários ordenadas.

#Algoritmo - countCharPformat.py
import pprint 

texto = input("Digite um texto: ")
count = {}
for letra in texto:
    count.setdefault(letra, 0)
    count[letra] += 1

saida = pprint.pformat(count)
print(saida)

#Execução - countCharPformat.py
Digite um texto: bananada
{'a': 4, 'b': 1, 'd': 1, 'n': 2}

Módulo sys

Função sys.exit( )

A função sys.exit( ) é usada para terminar a execução de um programa imediatamente.

É bastante utilizado quando queremos implementar a saída de um programa após o usuário digitar alguma string definida para terminar a execução do sistema. Por exemplo, enquanto o usuário não digitar sair, o código abaixo continuará executando:

#Algoritmo - digite sair para terminar o programa
import sys
while True:
    print("Programa executando.")
    print("Digite 'sair' para terminar:")
    comando = input()
    if comando == 'sair':
        sys.exit()

No algoritmo acima, importamos o módulo sys (linha 01) para podermos utilizar a função exit( ) na linha07.

Criamos um laço while infinito, nas linhas 02 a 07, que em cada iteração vai imprimir “Programa executando” e solicitar para que o usuário digite “sair” para terminar o programa.

O valor digitado pelo usuário na linha 05 será armazenado na variável comando e na linha 06, se o valor for igual à “sair”, a função exit( ) será executada e o programa finalizado. Senão uma nova iteração será executada, repetindo o ciclo.

#Execução - digite sair para terminar o programa 
Programa executando.
Digite 'sair' para terminar:
teste
Programa executando.
Digite 'sair' para terminar:
nao
Programa executando.
Digite 'sair' para terminar:
quit
Programa executando.
Digite 'sair' para terminar:
sair

Criando funções

Uma função é um pequeno algoritmo que resolve um problema específico, dentro do seu programa. Sua sintaxe é bem simples.

#Sintaxe funções
def <nome_função>(<parâmetros>):
    instruções

Implemente a função abaixo que imprime uma mensagem na tela.

#Algoritmo - ola.py
def ola():
    print("Minha funcao em Python")

ola()

A função está definida (def) na linha 01, com o nome ola. É uma função simples que imprime “Minha funcao em Python”.

Executamos uma função usando seu nome e parênteses, como ilustrado na linha 04.

#Execução - ola.py 
Minha funcao em Python

Parâmetros de função (entrada)

Se quisermos fornecer valores de entrada para uma função, definimos entre os parênteses os parâmetros. Implemente o exemplo, que verifica se um número é par.

#Algoritmo - ehPar.py
def isEven(number):
    if (number % 2 == 0):
        print(f"{number} eh par")
    else:
        print(f"{number} nao eh par")

isEven(4)
isEven(9)
isEven(2124)

Na linha 01 definimos a assinatura da função isEven. A assinatura do método é representado pelo nome do método e os parâmetros de entrada.

Nas linhas 07, 08 e 09, chamamos a função isEven() com diferentes argumentos: 4, 9, 2124. Chamamos de argumento o valor do parâmetro de um método.

#Execução - ehPar.py 
4 eh par
9 nao eh par
2124 eh par

Instrução return (saída)

Uma função pode retornar valor através do uso da instrução return. Se uma instrução return é executada, a função é encerrada.

Observe a função abaixo que executa uma operação aritmética e retorna o valor calculado.

#Algoritmo - calcula.py
def calcula(x, y, op):
    if op == '+':
        return x + y    
    elif op == '-':
        return x - y
    elif op == '*':
        return x * y
    elif op == '/':
        return x / y
    else:
        return 'Operacao invalida'

comando = ""
while comando != "sair":
    comando = input("Calcular (S-sim)? (Digite 'sair' para encerrar.): ")
    if comando == "sair":
        print("Saindo...")
    else:
        x = int(input("Digite o primeiro numero: "))
        y = int(input("Digite o segundo numero: "))
        op = input("Digite a operacao (+, -, *, /): ")
        print(calcula(x, y, op))

Nas linhas 01 a 11 temos uma função que calcula uma operação (op) entre dois números x e y. Os três parâmetros da função.

Para cada operação executada, há uma cláusula return, linhas 03, 05, 07, 09, 11. Se o usuário selecionar a multiplicação, pela cláusula condicional, a linha 07 será executada e encerrará a função.

#Execução - calcula.py 
Calcular (S-sim)? (Digite 'sair' para encerrar.): s
Digite o primeiro numero: 12
Digite o segundo numero: 2
Digite a operacao (+, -, *, /): /
6.0
Calcular (S-sim)? (Digite 'sair' para encerrar.): s
Digite o primeiro numero: 33
Digite o segundo numero: 11
Digite a operacao (+, -, *, /): *
363
Calcular (S-sim)? (Digite 'sair' para encerrar.): sair
Saindo...

No jargão da computação, as funções que não retornam valores são denominadas procedimentos.

Em Python uma função que não retorna um valor explicitamente com o return, implicitamente retona None.

#Algoritmo - ehPar.py modificado
def isEven(number):
    if (number % 2 == 0):
        print(f"{number} eh par")
    else:
        print(f"{number} nao eh par")

num = isEven(4)
print(num)

A função isEven() não retorna valor, logo o valor da linha 07 será None.

#Execução - ehPar.py modificado
4 eh par
None

Escopo de variáveis

Escopo de variável é a região do código em que uma variável existe e pode ser utilizada. Em Python temos o escopo local e o global.

Variável local é uma variável criada dentro de uma função, seu escopo é local, ela existirá somente dentro da função.

Variável global são as variáveis definidas fora de funções, possuem escopo global, podem ser utilizadas em qualquer local do código.

Desta forma, tenha em mente:

• Dentro de uma função podemos usar variáveis locais e ler variáveis globais.
• Variáveis locais não podem ser usadas fora da função.
• Podemos ter variáveis locais e globais com o mesmo nome. Dentro de uma função as variáveis locais tem maior prioridade de uso.

Experimente os seguintes programas e entenda o escopo das variáveis.

#Algoritmo - escopoGlobal.py
def imprime():
    print(contador)

contador = 10
imprime()

A variável da linha 04, pode ser acessada dentro do método imprime().

#Execução - escopoGlobal.py
10

Não podemos acessar uma variável local fora do método.

#Algoritmo - escopoLocalErro.py
def imprime():
    contador = 10

imprime()
print(contador)

Neste exemplo a variável contador é local (linha 02) e não pode ser acessada fora do escopo do método, como na linha 05.

#Execução - escopoLocalErro.py
Traceback (most recent call last):
  File "c:\Python\codes\escopoLocalErro.py", line 5, in <module>
    print(contador)
NameError: name 'contador' is not defined

Variáveis de diferentes escopos mas com mesmo nome possuem a prioridade de localização, se chamadas dentro de uma função, a variável local será acessada.

#Algoritmo - localEGlobal.py
def imprime():
    contador = 10
    print("valor em contador na funcao:", contador)

contador = 5
imprime()
print("valor em contador no escopo global:", contador)

Do exemplo anterior temos a variável contador definida na linha 02 e na linha 05.

#Execução - localEGlobal.py
valor em contador na funcao: 10
valor em contador no escopo global: 5

Palavra global

A palavra reservada global é aplicada na definição de variáveis de escopo global e permitem que o seu valor possa ser alterado dentro de funções.

#Sintaxe - global
global <nome_variavel>

Execute o código abaixo em seu ambiente.

#Algoritmo - usoGlobal.py
def incrementa(incremento):
    global contador
    contador = 10
    contador += incremento

incrementa(5)
print("valor em contador depois da função:", contador)

Nas linha 02 definimos a variável contador como global. Isto nos permite utilizá-lo em qualquer parte do código, inclusive fora da função como na linha 07 . A função incrementa( ) recebe como parâmetro um valor incremento que será adicionado ao contador.

#Execução - usoGlobal.py
valor em contador depois da função: 15

Pilha de execução

Funções podem ter como instruções a chamada para outras funções. A linguagem Python consegue memorizar a execução das funções através de uma estrutura denominada pilha de execução.

Veja o exemplo abaixo, para efeitos didáticos.

#Algoritmo - multiplasFuncoes.py
def funcaoA():
    print("Funcao A")

def funcaoB():
    print("Funcao B")
    funcaoA()

def funcaoC():
    print("Funcao C")
    funcaoB()
    print("Pilha de chamadas")

def main():
    funcaoC()

print("Inicio")
main()
print("Fim")

Temos 4 funções no algoritmo: funcaoA() (linha 01), funcaoB() (linha 04), funcaoC() (linha 08), main() (linha 13).

A funcaoA() imprime uma mensagem na tela, a funcaoB() além de imprimir uma mensagem, chama a funcaoA(). A funcaoC() além de imprimir uma mensagem, executa a funcaoB() e então imprime “Pilha de chamadas”.

Na execução do algoritmo, chamamos a main() (linha 17) que simplesmente executa a funcaoC().

#Execução - multiplasFuncoes.py
Inicio
Funcao C
Funcao B
Funcao A
Pilha de chamadas
Fim

A linguagem cria uma pilha de chamadas, ilustrado abaixo, primeiro chamamos a função main() no Passo 1, que executa a funcaoC() (Passo 2) e coloca no topo da pilha.

A funcaoC() invoca a funcaoB() (Passo 3) que por sua vez chama a funcaoA( ) (Passo 4), sendo colocados no topo da pilha em cada passo. Dos passos 5 ao passo 7, a linguagem executa os métodos do topo da pilha, primeiro a funcaoA( ), depois a funcaoB( ) e finalmente a funcaoC( ) e main( ), respectivamente.

Pilha de execução
			funcaoA()
		funcaoB()	funcaoB()	funcaoB()
	funcaoC()	funcaoC()	funcaoC()	funcaoC()	funcaoC()
main()	main()	main()	main()	main()	main()	main()
Passo 1	Passo 2	Passo 3	Passo 4	Passo 5	Passo 6	Passo 7

Função recursiva

Uma função é chamada recursiva quando ela invoca a si própria em seu bloco de instrução.

Para implementarmos uma função recursiva, é importante definirmos:

• O ponto de parada, ou caso base: condição que a função não chamará a sua execução recursiva.
• Execução recursiva: condição da execução recursiva.

Criar funções recursivas exige um pouco de experiência na programação, não se assuste se você não consegue neste momento implementar funções recursivas ou entender completamente os exemplos abaixo. Mas é importante saber que toda função recursiva pode ser escrita em uma forma não recursiva.

Nosso primeiro exemplo é implementar a operação da multiplicação mult( ), de números positivos, como função recursiva.

Uma multiplicação de x * y pode ser implementada como a soma de x por y vezes ou soma de y por x vezes. Por exemplo: 3 * 2 = 3 + 3 ou 3 * 2 = 2 + 2 + 2.

Como função recursiva, o caso base da multiplicação: qualquer número multiplicado por ZERO é ZERO, mult(x, 0) = 0.

Como execução recursiva: mult(x, y) = x + mult(x, y-1).

#Algoritmo - multRecursivo.py
def mult(x, y):
    if y == 0:
        return 0
    else:
        return x + mult(x, y - 1)

print(mult(5, 3))
print(mult(2, 0))
print(mult(4, 8))

Nas linhas 01-05 temos a função mult(x, y) recebendo 2 parâmetros, e nas linhas 02-03 a condição base ou de parada e na linha 05 a chamada recursiva.

Para a execução mult(5, 3) sua pilha de execução ficará como abaixo.

Pilha de execução recursiva
			mult(5,0)
		mult(5,1)	mult(5,1)	mult(5,1)
	mult(5,2)	mult(5,2)	mult(5,2)	mult(5,2)	mult(5,2)
mult(5,3)	mult(5,3)	mult(5,3)	mult(5,3)	mult(5,3)	mult(5,3)	mult(5,3)
Passo 1	Passo 2	Passo 3	Passo 4	Passo 5	Passo 6	Passo 7

#Execução - multRecursivo.py
15
0
32

Agora é a sua vez!

Implemente o cálculo do fatorial de um número, positivo, de forma recursiva. O fatorial de um número é definido como: fatorial(n) = n * (n-1) * (n-2) * 1. Por exemplo: fatorial(5) = 5 * 4 * 3 * 2 * 1 = 120 fatorial(3) = 3 * 2 * 1 = 6 fatorial(1) = 1 Identifique o caso base e a chamada recursiva.

Criando seus próprios módulos

Criar seus próprios módulos é bem simples, da mesma forma como outros programas em Python, você precisa salvar as suas funções em um arquivo .py.

Vamos implementar o seguinte exemplo!

• implementar um módulo com 3 funções:
  • implementar uma função que gera uma lista de números randômicos, em um intervalo.
  • implementar uma função que verifica se um número é par.
  • implementar uma função que verifica se um número é primo.
• criar um programa que solicite ao usuário a quantidade de números que quer gerar e verificar se é um número par e se é primo.

Para fins didáticos, salvei as funções em um módulo chamado meuModulo.

#Arquivo - meuModulo.py
import random

def isEven(n):
    if n % 2 == 0:
        return True
    else:
        return False

def isPrime(n):
    if n == 1:
        return False
    elif n == 2:
        return True
    else:
        for i in range(2, n):
            if n % i == 0:
                return False
        return True

def generateRandomList(n, max = 100):
    lista = []
    for i in range(n):
        lista.append(random.randint(1, max))
    return lista

Em meuModulo.py temos 3 funções:

• isEven: verifica se um número é par, definido nas linhas 03 a 07.
• isPrime: verifica se um número é primo, ou seja, ele é divisível somente por 1 e por ele mesmo (linhas 09 a 18).
• generateRandomList: gera uma lista de tamanho n, entre os valores 1 e max. _O parâmetro _max é opcional, tem como valor padrão 100. É necessário importar o módulo random (linha 01).

Para usarmos o nosso módulo, aplicamos a sintaxe import, como dos exemplos anteriores.

#Arquivo - usoMeuModulo.py
import meuModulo

def processa(lista):
    for i in lista:
        if meuModulo.isPrime(i):
            print(i, "é primo")

        if meuModulo.isEven(i):
            print(i, "é par")
        else:
            print(i, "é impar")

n = input("Digite quantidade de numeros a serem gerados: ")
lista = meuModulo.generateRandomList(int(n))
processa(lista)

Em nosso programa importamos o meuModulo (linha 01) e utilizamos suas funções nas linhas 05, 08, 14.

#Execução - usoMeuModulo.py
Digite quantidade de numeros a serem gerados: 5
46 é par
4 é par
10 é par
15 é impar
37 é primo
37 é impar

Outros recursos das funções

Argumentos nomeados

Vamos criar uma função que recebe o nome e a idade de uma pessoa, e imprime estas informações.

#Algoritmo - nomeIdade.py
def informacoes(nome, idade):
    print("Nome: ", nome)
    print("Idade: ", idade)

informacoes("João", 20)
informacoes("Maria", 25)

#passando parametros pela posicao
informacoes(45, "Zezim")

Nas linhas 05 e 06 chamamos a função informacoes(nome, idade) com os parâmetros na posição esperada.

Como a função não executa nenhuma operação numérica com a idade, podemos cometer um erro e mudar a ordem dos parâmetros, como na linha 09.

O código ainda irá executar.

#Execução - nomeIdade.py
Nome:  João
Idade:  20 
Nome:  Maria
Idade:  25
Nome:  45
Idade:  Zezim

A forma como estamos passando os argumentos é denominada posicional. A posição do parâmetro determina o argumento associado.

Python fornece outra forma de enviar os argumentos para uma função, usando o nome do parâmetro e o valor de argumento na forma chave-valor. É o denominado argumento nomeado.

Modifique o código acima e execute-o novamente.

#Algoritmo - nomeIdade.py modificado
def informacoes(nome, idade):
    print("Nome: ", nome)
    print("Idade: ", idade)

informacoes(nome = "Maria", idade = 25)
informacoes(idade = 45, nome = "Zezim")

Nas linhas 05 e 06 estamos indicando o nome do parâmetro e o argumento associado. Desta forma os valores serão tratados corretamente na execução da função.

#Execução - nomeIdade.py modificado
Nome:  Maria
Idade:  25
Nome:  Zezim
Idade:  45

Parâmetros opcionais

Podemos definir um valor padrão para os parâmetros de uma função, desta forma não é obrigado fornecer valores na execução da função.

Modifique o código nomeIdade.py novamente e observe a sintaxe de valor padrão.

#Algoritmo - nomeIdade.py com valor padrão
def informacoes(nome, idade = 10):
    print("Nome: ", nome)
    print("Idade: ", idade)

informacoes("Maria")

Na linha 01 a idade possui um valor padão de 10, não é mais obrigatório fornecer a idade na chamada da função, como ilustrado na linha 05.

#Execução - nomeIdade.py com valor padrão
Nome:  Maria
Idade:  10

Podemos inclusive deixar todos os parâmetros com valores padrões.

#Algoritmo - nomeIdade.py todos os parâmetros com valores
def informacoes(nome = "Jose", idade = 10):
    print("Nome: ", nome)
    print("Idade: ", idade)

informacoes("Maria")
informacoes(20)
informacoes()

Observe a flexibilidade de usar parâmetros opcionais, nas linhas 05, 06 , 07.

#Execução - nomeIdade.py todos os parâmetros com valores
Nome:  Maria
Idade:  10
Nome:  20
Idade:  10
Nome:  Jose
Idade:  10

Número de argumentos indefinidos

Podemos criar funções sem definir a quantidade de parâmetros, através da sintaxe abaixo.

#Sintaxe - parâmetros indefinidos
def <funcao>(*<nome_parametro>):

O parâmetro é interpretado como uma tupla. Implemente o exemplo seguinte.

#Algoritmo - parametrosIndefinidos.py
def imprime(* mensagem):
    print("Executando o metodo: imprime")
    print(mensagem)
    for m in mensagem:
        print(m)
    print("Fim do metodo: imprime")

imprime("Ola", "Mundo")
imprime("Python")
imprime("Python", "Java", "C++")
imprime()

Na linha 01 definimos mensagem como um parâmetro que recebe múltiplos valores, e nas linhas 08 a 11 utilizamos a função com uma quantidade variada de parâmetros.

#Execução - parametrosIndefinidos.py
Executando o metodo: imprime
('Ola', 'Mundo')
Ola
Mundo
Fim do metodo: imprime

Executando o metodo: imprime
('Python',)
Python
Fim do metodo: imprime

Executando o metodo: imprime
('Python', 'Java', 'C++')
Python
Java
C++
Fim do metodo: imprime

Executando o metodo: imprime
()
Fim do metodo: imprime

Se utilizarmos “” em vez de somente “*”, o parâmetro **será interpretado como um dicionário e poderá ter seus valores modificados. Você deve chamar a função com o formato chave-valor.

#Sintaxe - parâmetros indefinidos como dicionário
def <funcao>(**<nome_parametro>):

#Algoritmo - parametrosIndefinidosDic.py
def criarpessoa(nome, idade, **informacoes):
    informacoes["nome"] = nome
    informacoes["idade"] = idade
    return informacoes

pessoa = criarpessoa("Maria", 25, cidade = "São Paulo", estado = "SP")
print(pessoa)

A função criarpessoa() utiliza a sintaxe **informacoes como parâmetro, desta forma, dentro da função ele será interpretado como um dicionário.

#Execução - parametrosIndefinidosDic.py
{'cidade': 'São Paulo', 'estado': 'SP', 'nome': 'Maria', 'idade': 25}

Erros comuns

Cuidado ao salvar o nome de seus programas e utilizar o nome de um módulo da linguagem. Como por exemplo random.py.

Se você importar o módulo random, o interpretador utilizará o programa que você criou em vez de usar o módulo random da linguagem.

Tome cuidado com os tipos de dados usados como parâmetros e forneça valores corretos, caso contrário teremos um erro no código.

#Algoritmo - ehPar.py usando valores não numéricos
def isEven(number):
    if (number % 2 == 0):
        print(f"{number} eh par")
    else:
        print(f"{number} nao eh par")

isEven("4")

#Execução - ehPar.py usando valores não numéricos
Traceback (most recent call last):
  File "c:\Dropbox\Youtube\Python\codes\ehPar.py", line 7, in <module>
    isEven("4")
  File "c:\Dropbox\Youtube\Python\codes\ehPar.py", line 2, in isEven
    if (number % 2 == 0):
TypeError: not all arguments converted during string formatting

Como desenvolvedor, ao implementar funções recursivas, seja cauteloso em garantir que a pilha de chamadas chegará no caso base, senão teremos uma pilha infinita de execução. Pense de forma análoga à criação de um loop, implementando a condição de parada.

Teremos uma execução infinita se executarmos o mult( ) com valor negativo.

#Algoritmo - multRecursivo.py
def mult(x, y):
    if y == 0:
        return 0
    else:
        return x + mult(x, y - 1)

print(mult(2, -1))

#Execução - multRecursivo.py em loop infinito
Traceback (most recent call last):
  File "c:\Python\codes\multRecursiva.py", line 7, in <module>
    print(mult(2, -1))
  File "c:\Python\codes\multRecursiva.py", line 5, in mult
    return x + mult(x, y - 1)
  File "c:\Python\codes\multRecursiva.py", line 5, in mult
    return x + mult(x, y - 1)
  File "c:\Python\codes\multRecursiva.py", line 5, in mult
    return x + mult(x, y - 1)
  [Previous line repeated 995 more times]
  File "c:\Python\codes\multRecursiva.py", line 2, in mult
    if y == 0:
RecursionError: maximum recursion depth exceeded in comparison

Lembre-se que variáveis locais não podem ser acessadas fora da função onde foram definidas.

#Algoritmo - escopoLocalErro.py
def imprime():
    contador = 10

imprime()
print(contador)

#Execução - escopoLocalErro.py
Traceback (most recent call last):
  File "c:\Python\codes\escopoLocalErro.py", line 5, in <module>
    print(contador)
NameError: name 'contador' is not defined

E não podemos alterar o valor de variáveis globais que não são explicitamente marcadas com a palavra global.

#Algoritmo - globalErro.py
def imprime():
    contador += 100
    print(contador)

contador = 10
imprime()

#Execução - globalErro.py
Traceback (most recent call last):
  File "c:\Python\codes\escopoGlobal.py", line 6, in <module>
    imprime()
  File "c:\Python\codes\escopoGlobal.py", line 2, in imprime
    contador += 100
UnboundLocalError: local variable 'contador' referenced before assignment

Os parâmetros opcionais devem sempre ser definidos após os parâmetros obrigatórios. O código abaixo não executa.

#Algoritmo - erro no uso de parâmetros opcionais
def informacoes(nome = "Jose", idade):
    print("Nome: ", nome)
    print("Idade: ", idade)

informacoes("Maria", 20)

#Execução - erro no uso de parâmetros opcionais
  File "c:\codes\nomeIdade.py", line 1
    def informacoes(nome = "Jose", idade):
                                   ^^^^^
SyntaxError: non-default argument follows default argument