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 * , os 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 ** , os 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)
@
Formas
Formas
lambda
lambda
So pequenas funes sem nome
Tipicamente criadas para serem passadas para outras
funes
Historicamente, so relacionadas com o estilo funcional
de programar (LISP)
Em Python, funes lambda esto restritas a retornar
unicamente uma expresso
Formato: lambda arg,...arg: expresso
Exemplo:
>>> f = lambda x: 6xx+1
>>> f(1)
8
>>> f(8)
1@
Formas
Formas
lambda
lambda
So pequenas funes sem nome
Tipicamente criadas para serem passadas para outras
funes
Historicamente, so relacionadas com o estilo funcional
de programar (LISP)
Em Python, funes lambda esto restritas a retornar
unicamente uma expresso
Formato: lambda arg,...arg: expresso
Exemplo:
>>> f = lambda x: 6xx+1
>>> f(1)
8
>>> f(8)
1@
Programao Fun"ional ) filter
Programao Fun"ional ) filter
Alm de formas lambda, Python prov algumas ferramentas
clssicas usadas em programao funcional
filter (funo, seqncia)
Retorna outra seqncia com os elementos x de seqncia tais
que funo(x) verdadeiro
Se seqncia uma tupla ou string, o resultado tambm uma
tupla ou string, caso contrrio, o resultado uma lista
Exemplos:
>>> filter (lambda x: xA6==!, /1,6,8,5,5,=,1,@@@0)
/6, 5, =0
>>> filter (lambda x: %tr(x)==x, /1,6,8,$ab)$,50)
/$ab)$]
>>> filter (lambda ): ) not in $aeiou$, ")on%oante%")
$)n%nt%$
Programao Fun"ional ) map
Programao Fun"ional ) map
map (funo, seqncia)
retorna outra seqncia cujos elementos y
i
so computados
por funo(x
i
) onde x
i
so os elementos de seqncia
Exemplos:
>>> map(lambda x: x+1, /1,6,8,50)
/6, 8, 5, 50
>>> def f(x):
if xA6==!: return xx
el%e: return x
>>> map (f, /1,6,8,50)
/1, 5, 8, 1=0
Programao Fun"ional ) redu"e
Programao Fun"ional ) redu"e
redu)e (funo, seqncia [,inicializador])
Retorna o valor acumulado obtdo aplicando a funo
binria funo a pares consecutivos de elementos em
seqncia
Ex.: redu)e(f,/a,b,),d0) equivalente a
f(f(f(a,b),)),d)
Se o argumento opcional inicializador especificado, ele
determina um valor a ser considerado antes dos elementos
da seqncia
Ex.: redu)e(f,/a,b,),d0,!) equivalente a
f(f(f(f(!,a),b),)),d)
Exemplo
Exemplo
>>> redu)e (lambda a,b: a+b, /1,6,8,5,50)
15
>>> redu)e (lambda a,b: a+b, /0)
&ra)eba)( (mo%t re)ent )all la%t):
Bile "<p'%-ellC@>", line 1, in D
redu)e (lambda a,b: a+b, /0)
&'pe#rror: redu)e() of empt' %eEuen)e ;it- no
initial *alue
>>> redu)e (lambda a,b: a+b, /0, !)
!