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
Top comments (0)