Linguagem de Programação

Prof. Dr. Gabriel Augusto da Silva

10/03/2023
 Funções dir()

dir() retorna uma lista dos nomes definidos

no namespace de um objeto.
 Funções
Um bloco de código que executa uma tarefa específica

Eles são úteis para organizar seu script, especialmente se

você precisar repetir ações (por exemplo, um cálculo
complexo) várias vezes.

Uma função pode ser acessada de diferentes partes de um

script ou mesmo de diferentes scripts.
 Para usar uma função, primeiro você deve defini-la e depois chamá-la

definição argumentos (opcional)

def MyFunction(arg1, arg2,…):

“documentation” opcional
<instructions>

MyFunction(3,5,…)

chamar
pode ou não incluir um
retorno
def triangle_area(b, h):
A = (b*h)/2.0
Corpo da função
return A

print triangle_area(2.28, 3.55)

def triangle_area(b, h):

return (b*h)/2.0

print triangle_area(2.28, 3.55)

 Observações gerais

•A instrução para definir uma função é def;

•Uma função deve ser definida e chamada usando

parênteses;

•O corpo de uma função é um bloco de código iniciado

por um caractere de dois pontos seguido por instruções
recuadas;

•A última instrução recuada marca o fim de uma definição

de função.
 Observações gerais

•Você pode inserir no corpo de uma função uma

string de documentação entre aspas. Esta string
pode ser recuperada usando o atributo __doc__ do
objeto de função

•Você pode passar argumentos para uma função

•Uma função pode ou não retornar um valor

 Exercício 1

1) Defina uma função com dois argumentos:

get_values(arg1, arg2)
que retorna a soma, a diferença e o produto de arg1 e
arg2.
def get_values(arg1, arg2):
s = arg1 + arg2
d = arg1 - arg2
p = arg1 * arg2
return s, d, p

print get_values(15, 8)
A instrução return sai de uma função, opcionalmente
retornando um valor para o chamador.

Uma instrução return sem argumentos é o mesmo

que retornar None.

O valor retornado pode ser atribuído a uma variável

>>> def j(x,y):

... return x + y
...
>>> s = j(1, 100)
>>> print s
101
>>>
 Argumentos de função
Todo objeto Python pode ser passado como argumento para uma
função.
Uma chamada de função também pode ser o argumento de uma
função.

>>> def increment(x):

... return x + 1
...
>>> def print_arg(y):
... print y
...
>>> print_arg(increment(5))
6
>>>
Vários parâmetros podem ser passados ​para uma função. Nesse caso, a
ordem dos argumentos no chamador deve ser exatamente a mesma da
definição da função.

>>> def print_funct(num, seq):

... print num, seq
... return
...
>>> print_funct(10, "ACCTGGCACAA")
10 ACCTGGCACAA
>>>
A sequência de argumentos passados ​para
uma função é uma tupla

As funções também retornam vários valores

na forma de tuplas.
 Tuplas

Uma tupla é uma sequência imutável de

objetos

Isso significa que, uma vez definido, você

não pode alterar/substituir seus elementos
 Tuplas

variabile = (item1, item2, item3,…)

Os parenteses são opcionais, ou seja, você pode

usar ou não:
Tupla = (1,2,3) or Tupla = 1,2,3

Uma tupla de um item deve ser escrita:

Tupla = (1,) or Tupla = 1,

>>> my_tuple = (1,2,3)
>>> my_tuple[0]
1
>>> my_tuple[:]
(1, 2, 3)
>>> my_tuple[2:]
(3, )
 MAS

>>> my_tuple[0] = 0 #re-assigning

(Forbidden)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: 'tuple' object does not support
item assignment
>>>
def f(a,b):
return a + b, a*b, a – b

sum, prod, diff = f(20, 2)

print sum

result = f(20, 2)
print result
Print result[0]
 É possível atribuir um nome aos argumentos de uma função. Neste
caso, a ordem não é importante

>>> def print_funct(num, seq):

... print num, seq
... return
...
>>> print_funct(seq = "ACCTGGCACAA", num = 10)
10 ACCTGGCACAA
>>>
 Exercícios

6) Escreva uma função que receba como

argumentos dois pontos [x1, y1, z1] e [x2, y2, z2]
e retorne a distância entre os dois pontos.
import math

def distance(p1, p2):

dist = math.sqrt((p1[0]-p2[0])**2 +
(p1[1]-p2[1])**2 +
(p1[2]-p2[2])**2)
return dist

p1 = (43.64, 30.72, 88.95)

p2 = (45.83, 31.11, 92.04)

print "Distance:", distance(p1, p2)

 Observações gerais

•Python usa namespaces dinâmicos: quando uma função é

chamada, seu namespace é criado automaticamente

•As variáveis ​definidas no corpo de uma função residem em

seu namespace local e não no namespace global do script
(ou módulo)

•Objetos locais podem se tornar globais usando a instrução

global

•Quando uma função é chamada, os nomes dos objetos

usados ​em seu corpo são pesquisados ​primeiro no
namespace da função e posteriormente, se não forem
encontrados no corpo da função, são pesquisados ​no
namespace global do script (módulo).
 >>> def f():
... x = 100
... return x
...
>>> print x
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
NameError: name 'x' is not defined
>>> f()
100
>>> print x
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
NameError: name 'x' is not defined
>>>

x é um nome local do namespace da função f() e não é reconhecido pela

instrução “print” no script principal, mesmo após a chamada da função
 >>> def g():
... global x
... x = 200
... return x
...
>>> print x
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
NameError: name 'x' is not defined
>>> g()
200
>>> print x
200
>>>

A variável x, definida no corpo da função g(), é tornada global usando a

instrução “global”, mas é reconhecida pela instrução “print” no script
principal somente após a chamada da função.
 >>> y = "ACCTGGCACAA"
>>> def h():
... print y
...
>>> h()
'ACCTGGCACAA'

y é reconhecido quando h() é chamado, pois é um nome global.

 O número de argumentos pode ser variável (ou seja, pode mudar de uma
chamada de função para outra); neste caso, você pode usar os símbolos * ou **.
1º caso (*args) => tupla de argumentos
2º caso (**args) => dicionário de argumentos
>>> def print_args(*args):
... print args
... return
...
>>> print_args(1,2,3,4,5)
(1, 2, 3, 4, 5)
>>> print_args("Hello world!")
(‘Hello world!’,)
>>> print_args(100, 200, "ACCTGGCACAA")
(100, 200, ‘ACCTGGCACAA’)
>>> def print_args2(**args):
... print args
... return
...
>>> print_args2(num = 100, num2 = 200, seq =
"ACCTGGCACAA")
{'num': 100, 'seq': 'ACCTGGCACAA', 'num2': 200}
Uma função que não recebe e não retorna
valores
Uma função que não recebe argumento, mas
retorna valores
Uma função que recebe argumento e retorna
valor