Funções em Python

Nesta parte do tutorial de programação em Python, falaremos sobre funções.

Uma função é um trecho de código em um programa. A função realiza uma tarefa específica. As vantagens
de usar funções são:

Reduzindo a duplicação de código

Decompondo problemas complexos em peças mais simples

Melhorando a clareza do código

Reutilização de código

Ocultação de informações

As funções em Python são cidadãos de primeira classe. Isso significa que as funções têm status igual aos outros
objetos em Python. Funções podem ser atribuídas a variáveis, armazenadas em coleções ou passadas como
argumentos. Isso traz flexibilidade adicional à linguagem.

Existem dois tipos básicos de funções. Funções embutidas e funções definidas pelo usuário. As embutidas
funções são parte da linguagem Python. Exemplos são:dir(), len()ouabs()O usuário
funções definidas são funções criadas com odefpalavra-chave.

Definindo funções
Uma função é criada com odefpalavra-chave. As declarações no bloco da função devem ser
indented.

def função():
passar

Odefa palavra-chave é seguida pelo nome da função com parênteses e dois pontos. O
declarações recuadas formam o corpo da função.

A função é executada posteriormente quando necessário. Dizemos que chamamos a função. Se chamarmos uma
função, as instruções dentro do corpo da função são executadas. Elas não são executadas até que o
a função é chamada.

minhafuncao()

Para chamar uma função, especificamos o nome da função com os parênteses.

#!/usr/bin/python

"""
O script [Link] mostra como trabalhar com
funções em Python.
author: Jan Bodnar
ZetCode, 2011
"""

def mostrarNomeDoModulo():
print __doc__

def obterArquivoModulo():
retornar __file__

a = showModuleName()
b = getModuleFile()

imprimir a, b

A string no topo do script é chamada de string de documentação. Ela documenta o atual

script. O arquivo no qual colocamos o código Python é chamado de amodule. Definimos duas funções. O
a primeira função imprimirá a docstring do módulo. A segunda faráretornaro caminho do nosso módulo.
A função pode ou não retornar um valor. Se não retornar explicitamente um valor, ela implicitamente
retornarNone. O__doc__ e__file__ são atributos de estado especiais. Note que existem dois
sublinhados de ambos os lados do atributo.

$ ./[Link]

O script [Link] mostra como trabalhar com

funções em Python.
author: Jan Bodnar
ZetCode, 2011

Nenhum ./[Link]

As definições de funções devem preceder seu uso. Caso contrário, o interpretador irá reclamar com um
NomeErro.

#!/usr/bin/python

def f1():
imprimir "f1()"

f1()
#f2()

def f2():
print "f2()"

No exemplo acima, temos duas definições de funções. Uma linha está comentada. Chamada de função
não pode estar à frente de sua definição.
#f2()

def f2():
imprimir "f2()"

We can call the f2()apenas após sua definição. Descomentando a linha obtivemos umNomeError.

Onde definir funções

Funções podem ser definidas dentro de um módulo, uma classe ou outra função. Função definida dentro de uma
a classe é chamada de umétodo.

#!/usr/bin/python

classe Algum:

@estático
def f():
imprimir "método f()"

def f():
imprimir "função f()"

def g():
def f():
print "f() função interna"
f()

Algum.f()
f()
g()

Neste exemplo, definimos uma função f() em todos os lugares possíveis.

classe Algum:

@estático
def f():
print "método f()"

Um método estático é definido com um decorador em uma classe Some.

def f():
print "função f()"

A função é definida em um módulo.

def g():
def f():
print "f() função interna"
f()
Aqui of()a função é definida dentro de outrag()função. É uma função interna.

Some.f()
f()
g()

O método estático é chamado especificando o nome da classe, o operador de ponto e o nome da função
com colchetes. Outras funções são chamadas usando seus nomes e colchetes.

$ ./[Link]
método f()
função f()
função interna f()

Esta é a saída.

Funções são objetos

Funções em Python são objetos. Elas podem ser manipuladas como outros objetos em Python. Portanto
funções são chamadas de cidadãos de primeira classe. Isso não é verdade em outras linguagens de OOP como Java ou C#.

#!/usr/bin/python

def f():
Esta função imprime uma mensagem
Hoje é um dia nublado

print isinstance(f, objeto)

imprimir id(f)

imprimir f.func_doc
imprimir f.nome_da_funcao

Neste script, mostramos que nossa função também é um objeto.

def f():
Esta função imprime uma mensagem
Hoje é um dia nublado

Nós definimos umf()função. Ela imprime uma mensagem no console. Tem uma string de documentação.

print isinstance(f, object)

The isinstance()a função verifica se of()a função é uma instância doobjetoTudo

objetos em Python herdam desta entidade base.

imprimir id(f)

Cada objeto em Python tem um ID único. Oid()a função retorna o id do objeto.

print f.func_doc
imprimir f.nome_funcao

Objetos podem ter atributos. Aqui imprimimos dois atributos da função.

$ ./[Link]
Verdadeiro
3077407212
Esta função imprime uma mensagem
f

Saída do programa.

Objetos podem ser armazenados em coleções e passados para funções.

#!/usr/bin/python

def f():
passar

def g():
passar

def h(f):
imprima id(f)

a = (f, g, h)

para i em a:
imprimir i

h(f)
h(g)

We define three functions. We place them in a tuple and pass them to a function.

a = (f, g, h)

para i em a:
imprimir i

Colocamos três objetos de função em uma tupla e a percorremos com um loop for.

h(f)
h(g)

Nós passamos of()eg()funções para oh()função.

$ ./[Link]
<função f em 0xb7664fb4>
<function g at 0xb766c1b4>
<function h at 0xb766c3ac>
3076935604
3076964788

Saída [Link].

Três tipos de funções

Olhando de um ponto de vista particular, podemos discernir três tipos de funções. Funções que
estão sempre disponíveis para uso, funções que estão contidas em módulos externos, que devem
ser importados e funções definidas por um programador com odefkeyword.

#!/usr/bin/python

da matemática importação raiz

def cubo(x):
retornar x * x * x

print abs(-1)
imprimir cubo(9)
imprimir sqrt(81)

Três tipos de funções estão presentes no código acima.

da matemática import sqrt

Oraiz()a função é importada do módulo math.

def cubo(x):
retornar x * x * x

A função cube() é uma função definida pelo usuário.

imprimir abs(-1)

Oabs()A função é uma função embutida prontamente acessível. Ela faz parte do núcleo da linguagem.

A palavra-chave return
Uma função é criada para realizar uma tarefa específica. Muitas vezes há um resultado de tal tarefa. Aretornar
a palavra-chave é usada para retornar valores de uma função. Uma função pode ou não retornar um valor. Se um
a função não tem uma palavra-chave de retorno, ela enviará umNenhumvalor.

#!/usr/bin/python

def mostrarMensagem(msg):
imprimir mensagem

def cubo(x):
retornar x * x * x

x = cubo(3)
imprimir x

showMessage("Computation finished.")
imprimir mostrarMensagem("Pronto.")

We have two functions defined. One uses the retornarpalavra-chave, um não.

def mostrarMensagem(msg):
imprimir mensagem

OmostrarMensagem()a função não retorna explicitamente um valor. Ela mostra uma mensagem na
console.

def cubo(x):
retornar x * x * x

As funções cube() computam uma expressão e retornam seu resultado com oretornarpalavra-chave.

x = cubo(3)

Nesta linha, chamamos ocubo()função. O resultado da computação docubo()função é

retornou e foi atribuído aoxvariable. It holds the result value now.

showMessage("Computation finished.")

Nós chamamos oshowMessage() função com uma mensagem como parâmetro. A mensagem é impressa em
o console. Não esperamos um valor desta função.

print showMessage("Ready.")

Este código produz duas linhas. Uma é uma mensagem impressa pelomostrarMensagem()function. The
outro é oNenhumvalor, que é implicitamente enviado por funções sem oretornardeclaração.

$ ./[Link]
27
Cálculo concluído.
Pronto.
Nenhum

Exemplo de saída.

Podemos enviar mais de um valor de uma função. Os objetos após oretornaras palavras-chave são
separados por vírgulas.

#!/usr/bin/python

n = [1, 2, 3, 4, 5]
def estatísticas(x):
mx = max(x)
mn = min(x)
ln = len(x)
sm = soma(x)

retornar mx, mn, ln, sm

mx, mn, ln, sm = estatísticas(n)

imprimir estatísticas(n)

imprimir mx, mn, ln, sm

Há uma definição de umestatísticas()função. Esta função retorna quatro valores.

return mx, mn, ln, sm

Oretornara palavra-chave envia de volta quatro números. Os números são separados por uma vírgula
personagem. Na verdade, enviamos uma tupla contendo esses quatro valores. Também poderíamos retornar uma lista
em vez de uma tupla.

mx, mn, ln, sm = estatísticas(n)

Os valores retornados são atribuídos a variáveis locais.

$ ./[Link]
(5, 1, 5, 15)
5 1 5 15

Saída.

Redefinição de função
Python é dinâmico por natureza. É possível redefinir uma função já definida.

#!/usr/bin/python

de tempo import gmtime, strftime

def mostrarMensagem(msg):
imprimir mensagem

mostrarMensagem("Pronto.")

def mostrarMensagem(msg):
imprimir strftime("%H:%M:%S", gmtime()),
imprimir msg

showMessage("Processing.")
Definimos ummostrarMensagem()função. Mais tarde, fornecemos uma nova definição da mesma função.

do tempo importar gmtime, strftime

Do módulo de tempo, importamos duas funções que são usadas para calcular a hora atual.

def mostrarMensagem(msg):
imprimir msg

Esta é a primeira definição de uma função. Ela apenas imprime uma mensagem no console.

def mostrarMensagem(msg):
print strftime("%H:%M:%S", gmtime()),
imprimir mensagem

Mais tarde no código fonte, estabelecemos uma nova definição domostrarMensagem()função. O

a mensagem é precedida por um carimbo de data/hora.

$ ./[Link]
Pronto.
23:49:33 Processando.

Saída do script.

Argumentos de função
A maioria das funções aceita argumentos. Argumentos são valores que são enviados para a função.
as funções processam os valores e, opcionalmente, retornam algum valor.

#!/usr/bin/python

def C2F(c):
retornar c * 9/5 + 32

imprimir C2F(100)
imprimir C2F(0)
imprimir C2F(30)

No nosso exemplo, convertemos a temperatura em Celsius para Fahrenheit. AC2F()função aceita um

argumento c, que é a temperatura em Celsius.

$ ./[Link]
212
32
86

Os argumentos nas funções Python podem ter valores implícitos. Um valor implícito é usado se nenhum
um valor é fornecido.

#!/usr/bin/python
def potência(x, y=2):
r = 1
para i em range(y):
r = r * x
retornar r

imprimir potência(3)
imprimir potência(3, 3)
print potencia(5, 5)

Aqui criamos uma função de potência. A função tem um argumento com um valor implícito. Podemos
chame a função com um ou dois argumentos.

$ ./[Link]
9
27
3125

Funções em Python podem especificar seus argumentos com uma palavra-chave. Isso significa que ao chamar um
função, especificamos tanto uma palavra-chave quanto um valor. Quando temos vários argumentos e eles são
usado sem palavras-chave, a ordem em que passamos esses argumentos é crucial. Se esperarmos um
nome, idade ou sexo em uma função sem palavras-chave, não podemos mudar sua ordem. Se usarmos
palavras-chave, nós podemos.

#!/usr/bin/python

def exibir(nome, idade, sexo):

imprimir "Nome: ", nome
idade: , idade
Sexo:

display("Lary", 43, "M")

display("Joan", 24, "F")

In this example, the order in which we specify the arguments is important. Otherwise, we get
resultados incorretos.

$ ./[Link]
Name: Lary
Age: 43
Sex: M
Name: Joan
Age: 24
Sex: F
#!/usr/bin/python

# [Link]

def exibir(nome, idade, sexo):

print "Nome: ", nome
idade: , idade
print "Sexo: ", sexo

display(age=43, name="Lary", sex="M")

display(name="Joan", age=24, sex="F")

Agora chamamos as funções com suas palavras-chave. A ordem pode ser alterada, embora não seja.
recomendado a fazer assim. Note que não podemos usar um argumento não-chave após um argumento-chave
argumento. Isso terminaria em um erro de sintaxe.

display("Joan", sex="F", age=24)

Este é um conceito jurídico. Um argumento não-chave pode ser seguido por argumentos de palavra-chave.

display(age=24, name="Joan", "F")

Isso terminará em um erro de sintaxe. Um argumento não-chave não pode seguir argumentos de palavras-chave.

Funções em Python podem até aceitar um número arbitrário de argumentos.

#!/usr/bin/python

def soma(*args):
A função retorna a soma
de todos os valores
r = 0
para i em args:
r += i
retornar r

print sum.__doc__
imprimir soma(1, 2, 3)
imprima soma(1, 2, 3, 4, 5)

Nós usamos o* operador para indicar que a função aceitará um número arbitrário de argumentos.
Osoma()a função retornará a soma de todos os argumentos. A primeira string no corpo da função é
chamada a string de documentação da função. Ela é usada para documentar a função. A string deve ser
in triple quotes.

$ ./[Link]
A função retorna a soma
de todos os valores
6
15

Nós também podemos usar o** construir em nossas funções. Nesse caso, a função aceitará um
dicionário. O dicionário tem um comprimento arbitrário. Podemos então normalmente analisar o dicionário, como
habitual.

#!/usr/bin/python
def mostrar(**detalhes):

para i em detalhes:
%s: %s

display(name="Lary", age=43, sex="M")

This example demonstrates such a case. We can provide arbitrary number of key-value
argumentos. A função lidará com todos eles.

$ ./[Link]
age: 43
name: Lary
sex: M

Passing by reference
Os parâmetros das funções são passados por referência. Algumas linguagens passam cópias dos objetos para
funções. Passar objetos por referência tem duas conclusões importantes. O processo é mais rápido do que
se cópias de objetos fossem passadas. Objetos mutáveis que são modificados em funções são permanentemente
mudou.

#!/usr/bin/python

n = [1, 2, 3, 4, 5]

imprimir "Lista original:", n

def f(x):
[Link]()
[Link]()
[Link](0, 0)
print "Dentro de f():", x

f(n)

imprima "Após a chamada da função:", n

No nosso exemplo, passamos uma lista de inteiros para uma função. O objeto é modificado dentro do corpo de
a função. Após chamar a função, o objeto original, a lista de inteiros é modificada.

def f(x):
[Link]()
[Link]()
[Link](0, 0)
imprimir "Dentro de f():", x

No corpo da função, trabalhamos com o objeto original. Não com uma cópia do objeto.
em muitas linguagens de programação, receberíamos uma cópia de um objeto por padrão.
$ ./[Link]
Original list: [1, 2, 3, 4, 5]
Dentro de f(): [0, 1, 2, 3]
Após a chamada da função: [0, 1, 2, 3]

Uma vez que a lista foi modificada, ela foi modificada para sempre.

Variáveis globais e locais

A seguir, vamos falar sobre como as variáveis são usadas em funções Python.

#!/usr/bin/python

name = "Jack"

def f():
name = "Robert"
imprimir "Dentro da função", nome

imprimir "Fora da função", nome

f()

Uma variável definida no corpo de uma função tem escopo local. Ela é válida apenas dentro do corpo do
função.

$ ./[Link]
Função externa Jack
Dentro da função Robert

Saída.

#!/usr/bin/python

name = "Jack"

def f():
imprimir "Dentro da função", nome

print "Fora da função", nome

f()

Por padrão, podemos obter o conteúdo de uma variável global dentro do corpo de uma função. Mas se nós
para mudar uma variável global em uma função, devemos usar oglobalpalavra-chave.

$ ./[Link]
Função externa Jack
Dentro da função Jack
#!/usr/bin/python

name = "Jack"

def f():
nome global
name = "Robert"
imprimir "Dentro da função", nome

imprimir "Fora da função", nome

f()
print "Fora da função", name

Agora, mudaremos o conteúdo de uma variável de nome global dentro de uma função.

nome global
name = "Robert"

Usando oglobalpalavra-chave, referenciamos a variável definida fora do corpo da função.

A variável recebe um novo valor.

$ ./[Link]
Função externa Jack
Dentro da função Robert
Função externa Robert

Funções anônimas
É possível criar funções anônimas em Python. Funções anônimas não têm um
nome. Com olambdapalavra-chave, pequenas funções anônimas podem ser criadas. Anônimas
as funções também são chamadas de funções lambda pelos programadores Python. Elas fazem parte do
paradigma funcional incorporado no Python.

As funções Lambda são restritas a uma única expressão. Elas podem ser usadas sempre que funções normais
funções podem ser usadas.

#!/usr/bin/python

y = 6

z = lambda x: x * y
imprimir z(8)

Este é um pequeno exemplo da função lambda.

z = lambda x: x * y

Olambdakeyword creates an anonymous function. The x is a parameter that is passed to the

função lambda. O parâmetro é seguido por um caractere de dois pontos. O código ao lado dos dois pontos é
a expressão que é executada quando a função lambda é chamada. A função lambda é
atribuído à variável z.

imprimir z(8)
A função lambda é executada. O número 8 é passado para a função anônima e ela
retorna 48 como o resultado. Note que z não é um nome para esta função. É apenas uma variável à qual
a função anônima foi atribuída.

$ ./[Link]
48

Saída do exemplo.

A função lambda pode ser usada elegantemente com outras partes funcionais da linguagem Python,
gostarmapa()oufiltrar()funções.

#!/usr/bin/python

cs = [-10, 0, 15, 30, 40]

ft = map(lambda t: (9.0/5)*t + 32, cs)

imprimir ft

No exemplo, temos uma lista de temperaturas em Celsius. Criamos uma nova lista contendo
temperaturas em fahrenheit.

ft = map(lambda t: (9.0/5)*t + 32, cs)

Omapa()a função aplica a função anônima a cada elemento da lista cs. Ela cria um
nova lista ft contendo as temperaturas em Fahrenheit calculadas.

$ ./[Link]
[14,0, 32,0, 59,0, 86,0, 104,0]

Exemplo de saída.

Este capítulo foi sobre funções em Python