Funções

As funções são peças reutilizáveis de programas. Eles permitem que você dê um nome para um bloco de declarações, permitindo que você execute esse bloco usando o nome especificado em qualquer lugar em seu programa e em qualquer número de vezes. Isso é conhecido como calling a função. Nós já usamos muitas funções internas, como len e range.

O conceito de função é provavelmente a bloco de construção mais importante de qualquer software não trivial (em qualquer linguagem de programação), então exploraremos vários aspectos das funções neste capítulo.

As funções são definidas usando a palavra-chave def. Depois que esta palavra-chave vem identificar nome para a função, seguido por um par de parênteses que podem incluir alguns nomes de variáveis, e pelo cólon final que termina a linha. Em seguida, segue o bloco de instruções que fazem parte desta função. Um exemplo mostrará que isso é realmente muito simples:

Exemplo (salvar como function1.py):

def say_hello():
    # block belonging to the function
    print('hello world')
# End of function

say_hello()  # call the function
say_hello()  # call the function again

Saída:

$ python function1.py
hello world
hello world

Como funciona

Definimos uma função chamada say_hello usando a sintaxe como explicado acima. Esta função não possui parâmetros e, portanto, não há variáveis declaradas nos parênteses. Parâmetros para funções são apenas entradas para a função, para que possamos passar em valores diferentes e recuperar os resultados correspondentes.

Observe que podemos chamar a mesma função duas vezes, o que significa que não precisamos escrever o mesmo código novamente.

Parâmetros de função

Uma função pode levar parâmetros, que são valores que você fornece à função para que a função possa fazer algo que utiliza esses valores. Esses parâmetros são exatamente como variáveis, exceto que os valores dessas variáveis são definidos quando chamamos a função e já são atribuídos valores quando a função é executada.

Os parâmetros são especificados no par de parênteses na definição da função, separados por vírgulas. Quando chamamos a função, fornecemos os valores da mesma maneira. Observe a terminologia usada - os nomes dados na definição da função são chamados parâmetros enquanto os valores que você fornece na chamada de função são chamados argumentos.

Exemplo (salvar como function_param.py):

def print_max(a, b):
    if a > b:
        print(a, 'is maximum')
    elif a == b:
        print(a, 'is equal to', b)
    else:
        print(b, 'is maximum')

# directly pass literal values
print_max(3, 4)

x = 5
y = 7

# pass variables as arguments
print_max(x, y)

Saída:

$ python function_param.py
4 is maximum
7 is maximum

Como funciona

Aqui, definimos uma função chamada print_max que usa dois parâmetros chamados a e b. Descobrimos o número maior usando um simples if..else declaração e, em seguida, imprima o maior número.

A primeira vez que chamamos a função print_max, Nós fornecemos diretamente os números como argumentos. No segundo caso, chamamos a função com variáveis como argumentos. print_max(x, y) causa o valor do argumento x para ser atribuído ao parâmetro a e o valor do argumento y para ser atribuído ao parâmetro b. A função print_max funciona da mesma maneira em ambos os casos.

Variáveis Locais

Quando você declara variáveis dentro de uma definição de função, elas não estão relacionadas de nenhuma maneira a outras variáveis com os mesmos nomes usados fora da função - ou seja, nomes de variáveis são local para a função. Isso é chamado de scope da variável. Todas as variáveis têm o escopo do bloco que são declarados a partir do ponto de definição do nome.

Exemplo (salvar como function_local.py):

x = 50


def func(x):
    print('x is', x)
    x = 2
    print('Changed local x to', x)


func(x)
print('x is still', x)

Saída:

$ python function_local.py
x is 50
Changed local x to 2
x is still 50

Como funciona

A primeira vez que imprimimos o value do nome x Com a primeira linha no corpo da função, o Python usa o valor do parâmetro declarado no bloco principal, acima da definição da função.

Em seguida, nós atribuímos o valor 2 to x. O nome x é local para nossa função. Então, quando mudamos o valor de x na função, o x definido no bloco principal permanece inalterado.

Com o último print declaração, mostramos o valor de x como definido no bloco principal, confirmando assim que na verdade não é afetado pela atribuição local dentro da função anteriormente chamada.

A declaração global

Se você deseja atribuir um valor a um nome definido no nível superior do programa (ou seja, não dentro de qualquer tipo de escopo, como funções ou classes), então você deve dizer ao Python que o nome não é local, mas é global. Fazemos isso usando a declaração global. É impossível atribuir um valor a uma variável definida fora de uma função sem a global declaração.

Você pode usar os valores de tais variáveis definidas fora da função (assumindo que não há nenhuma variável com o mesmo nome dentro da função). No entanto, isso não é encorajado e deve ser evitado, uma vez que não fica claro para o leitor do programa como a definição daquela variável. Usando o global A declaração torna claro que a variável é definida em um bloco mais externo.

Exemplo (salvar como function_global.py):

x = 50


def func():
    global x

    print('x is', x)
    x = 2
    print('Changed global x to', x)


func()
print('Value of x is', x)

Saída:

$ python function_global.py
x is 50
Changed global x to 2
Value of x is 2

Como funciona

A declaração global é usado para declarar que x é uma variável global - portanto, quando atribuímos um valor para x dentro da função, essa mudança é refletida quando usamos o valor de x no bloco principal.

Você pode especificar mais de uma variável global usando a mesma declaração global ou seja, global x, y, z.

Valores de argumento padrão

Para algumas funções, você pode querer fazer alguns parâmetros opcionais e use valores padrão no caso de o usuário não desejar fornecer valores para eles. Isso é feito com a ajuda de valores de argumento padrão. Você pode especificar valores de argumento padrão para os parâmetros anexando ao nome do parâmetro na definição da função o operador de atribuição (=) seguido pelo valor padrão.

Observe que o valor padrão do argumento deve ser uma constante. Mais precisamente, o valor padrão do argumento deve ser imutável - isso é explicado em detalhes em capítulos posteriores. Por enquanto, lembre-se disso.

Exemplo (salvar como function_default.py):

def say(message, times=1):
    print(message * times)

say('Hello')
say('World', 5)

Saída:

$ python function_default.py
Hello
WorldWorldWorldWorldWorld

Como funciona

A função chamada say é usado para imprimir uma string quantas vezes for especificado. Se não fornecemos um valor, então, por padrão, a cadeia é impressa apenas uma vez. Conseguimos isso especificando um valor de argumento padrão de 1 ao parametro times.

No primeiro uso do say, Nós fornecemos apenas a string e ela imprime a string uma vez. No segundo uso de say, nós fornecemos a string e um argumento 5 afirmando que queremos dizer a mensagem string 5 vezes.

CUIDADO

Apenas os parâmetros que estão no final da lista de parâmetros podem ser dados valores de argumento padrão, isto é, você não pode ter um parâmetro com um valor de argumento padrão que precede um parâmetro sem um valor de argumento padrão na lista de parâmetros da função.

Isso ocorre porque os valores são atribuídos aos parâmetros por posição. Por exemplo,def func(a, b=5) é válido, mas def func(a=5, b) não é válido.

Argumentos de palavras-chave

Se você tem algumas funções com muitos parâmetros e você deseja especificar apenas alguns deles, então você pode dar valores para esses parâmetros, nomeando-os - isso é chamado argumentos de palavras-chave - usamos o nome (palavra-chave) ao invés da posição (que usamos o tempo todo) para especificar os argumentos para a função.

Existem duas vantagens - uma, usar a função é mais fácil, pois não precisamos nos preocupar com a ordem dos argumentos. Dois, podemos dar valores apenas aos parâmetros aos quais queremos, desde que os outros parâmetros tenham valores padrão de argumento.

Exemplo (salvar como function_keyword.py):

def func(a, b=5, c=10):
    print('a is', a, 'and b is', b, 'and c is', c)

func(3, 7)
func(25, c=24)
func(c=50, a=100)

Saida:

$ python function_keyword.py
a is 3 and b is 7 and c is 10
a is 25 and b is 5 and c is 24
a is 100 and b is 5 and c is 50

Como Funciona

A função chamada func tem um parâmetro sem um valor de argumento padrão, seguido por dois parâmetros com valores de argumento padrão.

No primeiro uso, func(3, 7), o parametro a obtém o valor 3, o parametro b obtem o valor 7 e c obtém o valor padrão de 10.

No segundo uso func(25, c=24), a variável a Obtém o valor de 25 devido à posição do argumento. Então, o parâmetro c obtém o valor de 24 devido à nomeação, ou seja, argumentos de palavras-chave. A variável b Obtém o valor padrão de 5.

No terceiro uso func(c=50, a=100), usamos argumentos de palavras-chave para todos os valores especificados. Observe que estamos especificando o valor do parâmetro c antes disso para a apesar de a é definido antes c na definição da função.

Parâmetros VarArgs

Às vezes você pode querer definir uma função que pode levar qualquer número de parâmetros, isto é, variaveis numeros de argumentos, isso pode ser alcançado usando as estrelas (salve como function_varargs.py):

def total(a=5, *numbers, **phonebook):
    print('a', a)

    #iterate through all the items in tuple
    for single_item in numbers:
        print('single_item', single_item)

    #iterate through all the items in dictionary    
    for first_part, second_part in phonebook.items():
        print(first_part,second_part)

print(total(10,1,2,3,Jack=1123,John=2231,Inge=1560))

Saida:

$ python function_varargs.py
a 10
single_item 1
single_item 2
single_item 3
Inge 1560
John 2231
Jack 1123
None

Como funciona

Quando declaramos um parâmetro estrelado como *param, v'.

Da mesma forma, quando declaramos um parâmetro de estrela dupla, como **param, então todos os argumentos de palavras-chave desse ponto até o final são coletados como um dicionário chamado 'param'.

Vamos explorar tuplas e dicionários em um capítulo posterior.

A declaração return

A declaração return é usado para retornar de uma função, isto é, sair da função. Nós podemos opcionalmente devolver um valor da função também.

Exemplo (salvar como function_return.py):

def maximum(x, y):
    if x > y:
        return x
    elif x == y:
        return 'The numbers are equal'
    else:
        return y

print(maximum(2, 3))

Saída:

$ python function_return.py
3

Como funciona

A função maximum retorna o máximo dos parâmetros, neste caso os números fornecidos à função. Ele usa um simples if..else declaração para encontrar o maior valor e, em seguida, retorna aquele valor.

Observe que um return declaração sem valor é equivalente a return None. None é um tipo especial em Python que representa o nada. Por exemplo, ele é usado para indicar que uma variável não tem valor se tiver um valor de None.

Toda função contém, implicitamente, uma return None declaração no final, a menos que tenha escrito o seu próprio return declaração. Você pode ver isso executando print(some_function()) onde a função some_function não usa o return declaração como:

def some_function():
    pass

A declaração pass é usado em Python para indicar um bloco vazio de declarações.

DICA: existe uma função interna chamada max que já implementa a funcionalidade "encontrar o máximo", então use essa função incorporada sempre que possível.

DocStrings

Python possui um recurso nítido chamado cadeias de documentação, geralmente referido pelo seu nome mais curto docstrings. As DocStrings são uma ferramenta importante que você deve usar, uma vez que ajuda a documentar melhor o programa e facilita a compreensão. Surpreendentemente, podemos obter o docstring de volta, dizer uma função, quando o programa realmente está sendo executado pelo seu nome mais curto!

Exemplo (salvar como function_docstring.py):

def print_max(x, y):
    '''Prints the maximum of two numbers.

    The two values must be integers.'''
    # convert to integers, if possible
    x = int(x)
    y = int(y)

    if x > y:
        print(x, 'is maximum')
    else:
        print(y, 'is maximum')

print_max(3, 5)
print(print_max.__doc__)

Output:

$ python function_docstring.py
5 is maximum
Prints the maximum of two numbers.

    The two values must be integers.

Como funciona

Uma string na primeira linha lógica de uma função é a docstring para essa função. Observe que DocStrings também se aplica a modulos e classes nos quais aprenderemos nos capítulos respectivos.

A convenção seguida por um docstring é uma string de várias linhas onde a primeira linha começa com uma letra maiúscula e termina com um ponto. Então a segunda linha está em branco, seguida de qualquer explicação detalhada a partir da terceira linha. Tu es fortemente aconselhado para seguir esta convenção para todos os seus docstrings para todas as suas funções não triviais.

Podemos acessar o docstring do print_max função usando o __doc__ (observe o double underscores) atributo (nome pertencente a) da função. Basta lembrar que Python trata tudo como um objeto e isso inclui funções. Vamos aprender mais sobre objetos no capítulo sobre classes.

Se você usou help() Em Python, então você já viu o uso de docstrings! O que faz é apenas buscar o __doc__ atributo dessa função e exibe-o de forma limpa para você. Você pode experimentá-lo na função acima - basta incluir help(print_max) no seu programa. Lembre-se de pressionar o botão q para sair help.

Ferramentas automatizadas podem recuperar a documentação do seu programa dessa maneira. Portanto, eu fortemente recomendo que você usa docstrings para qualquer função não trivial que você escreva. O pydoc O comando que vem com a sua distribuição Python funciona de forma semelhante a help() usando docstrings.

Resumo

Vimos tantos aspectos das funções, mas observamos que ainda não cobrimos todos os aspectos. No entanto, já cobrimos a maior parte do que você usará em relação às funções do Python em uma base diária.

Em seguida, veremos como usar, além de criar módulos Python.