Funções:
são blocos de código identificados por um nome, que podem receber parâmetros pré-determinados. No Python, as funções:
- Podem retornar ou não objetos (como as procedures).
- Aceitam 'Doc Strings'.
- Aceitam parâmetros opcionais (com defaults). Se não for passado o parâmetro será igual ao default definido na função.
- Aceitam que os parâmetros sejam passados com nome. Neste caso, a ordem em que os parâmetros foram passados não importa.
- Tem namespace próprio (escopo local), e por isso podem ofuscar definições de escopo global.
- Podem ter suas propriedades alteradas (geralmente por decoradores).
Sintaxe:
def func(parametro1, parametro2=padrao):
"""Doc String
"""
<bloco de código>
return valor (opcional)
Os parâmetros com default devem ficar após os que não tem default.
Exemplo de procedimento (sem retorno e sem parâmetros):
def imprime_endereco():
print('Rua: silva messias')
print('nº: 556')
print('bairro: Conceição')
#chama a procedure
imprime_endereco()
#Rua: silva messias
#nº: 556
#bairro: Conceição
Exemplo de procedimento (sem retorno e com parâmetros):
def sum(a, b):
print ("Soma de 2 Valores")
c = a + b
print ("Se a é " + str(a) + " e b é " + str(b) + " então a soma deles é " + str(c))
# chama procedure com parâmetros
sum(10, 14)
#Soma de 2 Valores
#Se a é 10 e b é 14 então a soma deles é 24
Exemplo de função (fatorial com recursão):
def fatorial(num):if num <= 1:
return 1
else:
return num * fatorial(num-1)
# Testa fatorial()
print(fatorial(5))
#120
def fatorial(n):
n = n if n > 1 else 1
j = 1
for i in range(1, n + 1):
j = j * i
return j
# Executa função
for i in range(1, 6):
print (i, '->', fatorial(i))
#1 -> 1
#2 -> 2
#3 -> 6
#4 -> 24
#5 -> 120
Exemplo (série de Fibonacci com recursão):
def fib(n):
"""Fibonacci:
fib(n) = fib(n - 1) + fib(n - 2) se n > 1
fib(n) = 1 se n <= 1
"""
if n > 1:
return fib(n - 1) + fib(n - 2)
else:
return 1
# Mostrar Fibonacci de 1 a 5
for i in [1, 2, 3, 4, 5]:
print(i, '=>', fib(i))
#1 => 1
#2 => 2
#3 => 3
#4 => 5
#5 => 8
Exemplo (série de Fibonacci sem recursão):
def fib(n):
"""Fibonacci:
fib(n) = fib(n - 1) + fib(n - 2) se n > 1
fib(n) = 1 se n <= 1
"""
# Dois primeiros valores
l = [1, 1]
# Calculando os outros
for i in range(2, n + 1):
l.append(l[i -1] + l[i - 2])
return l[n]
# Mostrar Fibonacci de 1 a 5
for i in [1, 2, 3, 4, 5]:
print (i, '=>', fib(i))
#1 => 1
#2 => 2
#3 => 3
#4 => 5
#5 => 8
- Os argumentos com padrão devem vir por último, depois dos argumentos sem padrão.
- O valor do padrão para um parâmetro é calculado quando a função é definida.
- Os argumentos passados sem identificador são recebidos pela função na forma de uma lista.
- Os argumentos passados com identificador são recebidos pela função na forma de um dicionário.
- Os parâmetros passados com identificador na chamada da função devem vir no fim da lista de parâmetros.
# *args - argumentos sem nome (lista)
# **kargs - argumentos com nome (dicionário)
def func(*args, **kargs):
print (args)
print (kargs)
func('peso', 10, unidade='k')
#('peso', 10)
#{'unidade': 'k'}
--------------------------------------------------------------------
Função built-in eval():
Avalia código (fonte ou objeto) retornando o valor.
A função também interpreta uma string como um código.
Exemplo:
print eval('12. / 2 + 3.3')
#9.3
eval('print(10)')
#10
Com isso é possível montar código para ser passado para o interpretador durante a execução de um programa. Esse recurso deve ser usado com cuidado, pois código montados a partir de entradas do sistema abrir brechas de segurança.
--------------------------------------------------------------------
Pedindo Ajuda no Python:
Comando dir():
Exemplo (no terminal):
>>> my_list=[]
>>> dir(my_list)
['__add__', '__class__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__gt__', '__hash__', '__iadd__', '__imul__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__rmul__', '__setattr__', '__setitem__', '__sizeof__', '__str__', '__subclasshook__', 'append', 'clear', 'copy', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort']
>>> dir(my_list)[0:5]
['__add__', '__class__', '__contains__', '__delattr__', '__delitem__']
Comando help():
Exemplo (no terminal):
>>> help(list)
Help on class list in module builtins:
class list(object)
| list() -> new empty list
| list(iterable) -> new list initialized from iterable's items
|
| Methods defined here:
|
| __add__(self, value, /)
| Return self+value.
...
Outro exemplo:
>>> help(my_list.append) ou help(list.append)
Help on built-in function append:
append(...) method of builtins.list instance
L.append(object) -> None -- append object to end
Mais um exemplo:
>>>help(string.split)
...
Ajuda on-line:
A documentação do Python também está disponível em: http://www.python.org/doc/
--------------------------------------------------------------------
PyDOC:PyDOC é a ferramenta de documentação do Python. Ela pode ser utilizada tanto para acessar a documentação dos módulos que acompanham o Python, quanto a documentação dos módulos de terceiros.
O módulo PyDOC gera automaticamente documentação dos módulos do Python. A documentação pode ser apresentada como páginas de texto no console, em um navegador Web ou arquivos HTML.
Para módulos, classes, funções e métodos, a documentação exibida é derivada da docstring (isto é, o atributo __doc__) do objeto e recursivamente de seus membros documentáveis. Se não houver docstring, o PyDOC tenta obter uma descrição do bloco de linhas de comentário logo acima da definição da classe, função ou método no arquivo de origem, ou na parte superior do módulo.
Para executar o PyDOC num terminal DOS/Windows:
Exemplo:
python -m pydoc os
Obs.: A função help() chama o sistema de ajuda no interpretador interativo, que usa o PyDOC para gerar sua documentação como texto no console.
--------------------------------------------------------------------
Nenhum comentário:
Postar um comentário