Claudio Esperana

Python:
Python:
Funes
Funes
Abstrao
Abstrao
uma tcnica de programao que nos permite pensar
num problema em diversos nveis
A idia que quando estamos pensando num problema
macroscopicamente, no estamos preocupado com
mincias
Dividir para conquistar:

Um problema dividido em diversos sub-problemas

As solues dos sub-problemas so combinadas numa

soluo do problema maior
Programao Estruturada
Programao Estruturada
uma disciplina de programao que incorpora o
princpio de Dividir para Conquistar

(Programao Orientada a Objetos outra...)

Programas so divididos em sub-programas

Cada sub-programa invocado por meio de um

identificador e uma lista de entradas

Permite especificar como um problema pode ser resolvido em

geral

O mesmo sub-programa pode ser invocado para resolver

diversos problemas de mesma natureza mas com valores
especficos diferentes

Os resultados computados por um sub-programa pode ser

combinado com os de outros sub-programas
Definindo funes
Definindo funes
Em Python, sub-programas tm o nome de funes
Formato geral:
def nome (arg, arg, ... arg):
comando
. . .
comando
Onde:

nome o nome da funo

args so especificaes de argumentos da funo

Uma funo pode ter 0, 1 ou mais argumentos

comandos contm as instrues a ser executadas quando a

funo invocada
Resultado de funes
Resultado de funes
Uma funo tipicamente computa um ou mais valores
Para indicar o valor a ser devolvido como o resultado da
funo, usa-se o comando return que tem o formato
return expresso

onde a expresso opcional e designa o valor a ser retornado

Ao encontrar o comando return, a funo termina
imediatamente e o controle do programa volta ao ponto
onde a funo foi chamada
Se uma funo chega a seu fim sem nenhum valor de
retorno ter sido especificado, o valor de retorno None
Exemplo
Exemplo
>>> def f():
return
>>> print f()
None
>>> def f():
return "Oi"
>>> print f()
Oi
>>> def f(nome):
return "Oi, "+nome+"!"
>>> print f("Joao")
Oi, Joao!
Vari!eis lo"ais e globais
Vari!eis lo"ais e globais
Variveis definidas em funes so locais, isto , s podem
ser usadas nas funes em que foram definidas
Variveis definidas fora de funes so conhecidas como
variveis globais

possvel no cdigo de uma funo ler o contedo de uma

varivel global

Para alterar uma varivel global, ela precisa ser declarada

no corpo da funo usando o comando global
Exemplo
Exemplo
>>> def f():
print a
>>> a = 1
>>> f()
1
>>> def f():
a = 5
>>> f()
>>> print a
1
>>> def f():
global a
a = 5
>>> f()
>>> print a
5
Argumentos de funes
Argumentos de funes
Argumentos (ou parmetros) so como variveis que
recebem seus valores iniciais do chamador
Essas variveis, assim como outras definidas dentro da
funo so ditas locais, isto , s existem no lugar onde
foram definidas

Ao retornar ao ponto de chamada, as variveis locais so

descartadas
Se uma funo define n argumentos, valores para todos
eles devem ser passados pelo chamado

Exceo: argumentos com valores default

Exemplo
Exemplo
>>> def f(x):
return xx
>>> print f(1!)
1!!
>>> print x
""""
Name#rror: name $x$ i% not defined
>>> print f()
""""
&'pe#rror: f() ta(e% exa)tl' 1 argument (!
gi*en)
Argumentos
Argumentos
default
default
possvel dar valores default a argumentos

Se o chamador no especificar valores para esses

argumentos, os defaults so usados
Formato:
def nome (arg1=default1, ..., argN=defaultN)
Se apenas alguns argumentos tm default, esses devem
ser os ltimos

Se no fosse assim, haveria ambigidade na passagem de

argumentos
Exemplo
Exemplo
>>> def f(nome,%auda)ao="Oi",pontua)ao="!!"):
return %auda)ao+","+nome+pontua)ao
>>> print f("Joao")
Oi,Joao!!
>>> print f("Joao","+araben%")
+araben%,Joao!!
>>> print f("Joao",",-",""""")
,-,Joao"""
Passando argumentos "om nomes
Passando argumentos "om nomes
possvel passar os argumentos sem empregar a ordem
de definio desde que se nomeie cada valor passado com
o nome do argumento correspondente
Ex.:
>>> def f(nome,%auda)ao="Oi",pontua)ao="!!"):
return %auda)ao+","+nome+pontua)ao
>>> print f(%auda)ao=".aleu",nome="Joao")
.aleu,Joao!!
Alterando par#metros
Alterando par#metros
possvel alterar parmetros?

Sim e no

Como o parmetro uma varivel local, ele pode ser

alterado sem problemas

Entretanto, se um parmetro recebe um valor que vem de

uma varivel global, esta no alterada
Ex.:
>>> def f(x):
x = 5
>>> a = 1
>>> f (a)
>>> print a
1
Alterando par#metros
Alterando par#metros
Note que quando passamos uma varivel do tipo lista
como parmetro, estamos passando uma referncia para
um valor do tipo lista

Nesse caso, alterar o parmetro pode influenciar no valor

da varivel global

Na verdade, o valor da varivel do tipo lista uma

referncia que no muda

Este caso idntico a termos duas variveis se referindo ao

mesmo valor
Exemplo
Exemplo
>>> def f(x):
x/:0 = /50
>>> a = /10
>>> f(a)
>>> a
/50
>>> b = a
>>> b/:0 = /10
>>> a
/10
Do"umentando Funes
Do"umentando Funes
Ao invs de usar comentrios para descrever o que uma funo,
mais vantajoso usar docstrings

Uma constante string escrita logo aps o cabealho da funo

(comando def)

Permite o acesso documentao a partir do interpretador,

usando a notao funo . 22do)22
>>> def fat(n):
""" "3etorna o fatorial de n""
""" for i in range(n41,1,41): n=i
""" return n
"""
>>> fat(5)
65
>>> print fat"22do)22
3etorna o fatorial de n"
$ista de par#metros !ari!el
$ista de par#metros !ari!el
Se o ltimo argumento de uma definio de funo
comea com *, todos os valores passados, a partir daquele,
so postos numa tupla
Ex.:
>>> def imprime(nome,atributo%):
""" print nome,atributo%
"""
>>> imprime ($a$,1,6,$b$)
a (1, 6, $b$)
>>> def media(*alore%):
""" total=!"!
""" for x in *alore%: total+=x
""" return total7len(*alore%)
"""
>>> media(1,6,8,5)
6"5
$ista de par#metros !ari!el %&'
$ista de par#metros !ari!el %&'
Se o ltimo argumento de uma definio de funo
comea com **, todos os valores passados usando chaves,
a partir daquele, so postos num dicionrio
Ex.:
>>> def f(a,b,)):
print a, b, )
>>> f(1,6,8)
"""
&'pe#rror: f() ta(e% exa)tl' 6 argument% (8 gi*en)
>>> f(1,6,x=8)
1 6 9$x$: 8:
$ista de par#metros !ari!el %('
$ista de par#metros !ari!el %('
possvel passar os valores de uma tupla para preencher parmetros
posicionais de uma funo bastando para isso preced-la de *
Um dicionrio podem ser usado para preencher parmetros por chave
bastando para isso preced-lo de **
preciso tomar cuidado para no abusar!
Ex.:
>>> def f(a,b,),d):
print a,b,),d
>>> f(/1,6,8,5,50)
1 6 (8, 5, 5) 9:
>>> f(9"a":1,"b":6,")":8,"d":5:)
1 6 () 9$)$: 8, $d$: 5:
>>> f(1,6,8,9"d":1:)
1 6 (8,) 9$d$: 1:
>>> f(1,6,8,9"a":1:)
"""
&'pe#rror: f() got multiple *alue% for (e';ord argument $a$
Passando funes
Passando funes
Nomes de funes podem ser manipulados como variveis e
mesmo como argumentos de funes

Para saber se um nome se refere a uma funo, use o

predicado )allable()
Ex.:
>>> def f(g):
return g(5)
>>> def -(x):
return xx
>>> f(-)
65
>>> m = -
>>> )allable(m)
&rue
>>> f(m)
65
Es"opo
Es"opo
Escopo o nome que se d ao conjunto de nomes acessveis de
um determinado ponto de um programa

Tambm chamado de espao de nomes ou namespace

Um programa comea em um escopo (chamado escopo global)
enquanto que cada funo acrescenta um escopo prprio (local)

Mdulos e classes tambm definem escopos

Ao se fazer acesso a um nome, todos os escopos, do mais
interno para o mais externo, so consultados.

Isto explica por que definir uma varivel numa funo pode
fazer com que uma varivel global deixe de ser acessvel
Funo
Funo
vars
vars
%'
%'
O dicionrio obtido com a funo *ar%() pode ser
usado para ter acesso a todas as variveis definidas num
escopo. Ex.:
>>> *ar%()
9$22builtin%22$: <module $22builtin22$ (built4in)>,
$22name22$: $22main22$, $22do)22$: None:
>>> def f():
x = 1
print *ar%()
>>> *ar%()
9$f$: <fun)tion f at !xb=e1f5=)>, $22builtin%22$:
<module $22builtin22$ (built4in)>, $22name22$:
$22main22$, $22do)22$: None:
>>> f()
9$x$: 1:
Funes definidas em funes
Funes definidas em funes
Funes podem ser definidas dentro de funes
Se uma funo g definida dentro de uma funo f, ela
tem acesso ao seu prprio escopo (em primeiro lugar) e
tambm ao escopo de f
Ex.:
>>> def f(x):
def g('): return x'
return g(6)
>>> print f(5)
>
Funes definidas em funes %&'
Funes definidas em funes %&'
Observe que, se uma funo g foi definida dentro de outra
funo f, ento, se g armazenada numa varivel ou
transmitida para outra funo ela carrega com si os valores do
escopo de f (mas no o escopo global). Ex:
>>> x = 6
>>> def f('):
def g(?): return x'?
return g
>>> - = f(8)
>>> print -(1)
=
>>> x = 8
>>> print -(1)
@