<jupyter_start><jupyter_text>2 - Criando Funções Se tivéssemos apenas um conjunto de dados para analisar,provavelmente seria mais rápido carregar o arquivo em uma planilhae usar isso para traçar algumas estatísticas simples.Mas temos doze arquivos para verificar, e pode ter mais no futuro.Nesta lição,aprenderemos a escrever uma funçãopara que possamos repetir várias operações com um único comando.  Objetivos* Definir uma função que tem parâmetros.* Retornar um valor de uma função.* Definir os valores padrão para os parâmetros da função.  Definindo uma Função Vamos começar definindo uma função `fahr_to_kelvin` que converte as temperaturas de Fahrenheit para Kelvin:<jupyter_code>def fahr_to_kelvin(temp = 100):
    return ((temp - 32) * (5/9)) + 273.15

fahr_to_kelvin()<jupyter_output><empty_output><jupyter_text>A definição de uma funçao começa com a palavra `def`,que é seguida pelo nome da função e uma lista entre parênteses de nomes de parâmetros.O [corpo](http://swcarpentry.github.io/python-novice-inflammation-2.7/reference.htmlfunction-body) da função&mdash;as declarações que são executadas quando ela é executada&mdash; é recuada abaixo da linha de definição, tipicamente por quatro espaços.Quando chamamos a função,os valores que passamos para ela são atribuídos a essas variáveispara que possamos usá-las dentro da função.Dentro da função, usamos uma [declaração de retorno](http://swcarpentry.github.io/python-novice-inflammation-2.7/reference.htmlreturn-statement) para enviar o resultado de volta para quem a chamou.Vamos tentar executar nossa função.Chamar nossa própria função não é diferente de chamar qualquer outra função:<jupyter_code>print ('freezing point of water:', fahr_to_kelvin(32))
print ('boiling point of water:', fahr_to_kelvin(212))<jupyter_output><empty_output><jupyter_text>Funções compostas Agora que vimos como transformar Fahrenheit em Kelvin,é fácil transformar Kelvin em Celsius:<jupyter_code>def kelvin_to_celsius(temp):
    return temp - 273.15

print ('absolute zero in Celsius:', kelvin_to_celsius(0.0))<jupyter_output>absolute zero in Celsius: -273.15<jupyter_text>E a conversão de Fahrenheit para Celsius?Podemos escrever a fórmula, mas não precisamos.Em vez disto,podemos [compor](http://swcarpentry.github.io/python-novice-inflammation-2.7/reference.htmlfunction-composition) as duas funções que já criamos:<jupyter_code>def fahr_to_celsius(temp):
    return kelvin_to_celsius(
        fahr_to_kelvin(temp)
    ), "Mateus", 10, "Hello"

print ('freezing point of water in Celsius:', fahr_to_celsius(332.0))<jupyter_output>freezing point of water in Celsius: (166.66666666666669, 'Mateus', 10, 'Hello')<jupyter_text>Este é nosso primeiro vislumbre de como os programas maiores são criados:definimos operações básicas,Em seguida, combine-os em pedaços sempre grandes para obter o efeito que queremos.As funções da vida real geralmente serão maiores do que as mostradas aqui &mdash; normalmente, meia dúzia a algumas dúzias de linhas &mdash;mas elas nunca devem ser muito mais longas do que isso,ou a próxima pessoa que lê seu código pode não ser capaz de entender o que está acontecendo.  Exercícios 1. Em Python "adicionando" duas cadeias produz sua concatenção:     `'a' + 'b'` é `' ab'`.     Escreva uma função chamada `fence` que recebe dois parâmetros chamados `original` e `embrulho`     e retorna uma nova string que possui o caractere do embrulho no início e no final do original. Exemplo:    ~~~python    print (fence('name', '*'))    *name*    ~~~1. Se a variável `s` se refere a uma string,     então `s [0]` é o primeiro caracter da string     e `s [-1]` é o último.     Escreva uma função chamada `outer`     que retorna uma string composta apenas do primeiro e último caracter de sua entrada. Exemplo:    ~~~python    print (outer('helium'))    hm    ~~~<jupyter_code>def fence(name, obj = '*'):
    return obj + name + obj

def outer(name):
    return name[0] + name[-1]

print(fence("Mateus",'#'))
print(outer("helium"))<jupyter_output>#Mateus#
hm<jupyter_text>Definindo Valores Padrão Passamos os parâmetros às funções de duas maneiras:diretamente, como em `span(data)`,e pelo nome, como em `numpy.loadtxt (fname = 'something.csv', delimiter = ',')`.De fato, podemos passar o nome do arquivo para `loadtxt` sem o `fname = `:<jupyter_code>import numpy as np
np.loadtxt('data/inflammation-01.csv', delimiter=',')<jupyter_output><empty_output><jupyter_text>mas ainda precisamos dizer `delimiter =`:<jupyter_code>np.loadtxt('data/inflammation-01.csv', delimiter=',')<jupyter_output><empty_output><jupyter_text>Para entender o que está acontecendo,e tornar nossas próprias funções mais fáceis de usar,vamos redefinir nossa função `center` como esta:<jupyter_code>def center(data, desired=0.0):
    '''Return a new array containing the original data centered around the desired value (0 by default).
    Example: center([1, 2, 3], 0) => [-1, 0, 1]'''
    return (data - data.mean()) + desired<jupyter_output><empty_output><jupyter_text>A principal mudança é que o segundo parâmetro agora é escrito `desired = 0,0` em vez de apenas `desired`.Se chamarmos a função com dois argumentos,funciona como aconteceu antes:<jupyter_code>test_data = np.zeros((2, 2))
print (center(test_data, 3))<jupyter_output>[[3. 3.]
 [3. 3.]]<jupyter_text>Mas também podemos chamá-la com apenas um parâmetro,no caso em que `desired` é atribuído automaticamente [o valor padrão](http://swcarpentry.github.io/python-novice-inflammation-2.7/reference.htmlfunction-composition) de 0.0:<jupyter_code>more_data = 5 + np.zeros((2, 2))
print ('data before centering:', more_data)
print ('centered data:', center(more_data))<jupyter_output>data before centering: [[5. 5.]
 [5. 5.]]
centered data: [[0. 0.]
 [0. 0.]]<jupyter_text>Isso é útil:se geralmente queremos que uma função funcione de um jeito,mas ocasionalmente precisa dele para fazer outra coisa,podemos permitir que as pessoas passem um parâmetro quando precisammas fornecem um padrão para tornar o caso normal mais fácil.O exemplo abaixo mostra como Python corresponde aos valores aos parâmetros:<jupyter_code>def display(a=1, b=2, c=3):
    print ('a:', a, 'b:', b, 'c:', c)

print ('no parameters:')
display()
print ('one parameter:')
display(55)
print ('two parameters:')
display(55, 66)



###################################################################<jupyter_output>no parameters:
a: 1 b: 2 c: 3
one parameter:
a: 55 b: 2 c: 3
two parameters:
a: 55 b: 66 c: 3<jupyter_text>Como mostra este exemplo,os parâmetros são combinados da esquerda para a direita,e aqueles que não receberam um valor explicitamente obtêm seu valor padrão.Podemos substituir esse comportamento ao nomear o valor conforme o passamos:<jupyter_code>print ('only setting the value of c')
display(c=77)<jupyter_output>only setting the value of c
a: 1 b: 2 c: 77<jupyter_text>Com isso em mãos,Vejamos a ajuda para `numpy.loadtxt`:<jupyter_code>help(np.loadtxt)<jupyter_output>Help on function loadtxt in module numpy.lib.npyio:

loadtxt(fname, dtype=<class 'float'>, comments='#', delimiter=None, converters=None, skiprows=0, usecols=None, unpack=False, ndmin=0, encoding='bytes')
    Load data from a text file.
    
    Each row in the text file must have the same number of values.
    
    Parameters
    ----------
    fname : file, str, or pathlib.Path
        File, filename, or generator to read.  If the filename extension is
        ``.gz`` or ``.bz2``, the file is first decompressed. Note that
        generators should return byte strings for Python 3k.
    dtype : data-type, optional
        Data-type of the resulting array; default: float.  If this is a
        structured data-type, the resulting array will be 1-dimensional, and
        each row will be interpreted as an element of the array.  In this
        case, the number of columns used must match the number of fields in
        the data-type.
    comments : str or sequence of str, optional
       [...]
{'fraction_non_alphanumeric': 0.10360870111907457, 'fraction_numerical': 0.01722620394819565, 'mean_word_length': 4.980451127819549, 'pattern_counts': {'":': 0, '<': 46, '<?xml version=': 0, '>': 47, 'https://': 0, 'lorem ipsum': 0, 'www.': 0, 'xml': 0}, 'pii_count': 0, 'substrings_counts': 1, 'word_list_counts': {'cursed_substrings.json': 0, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
{'chain_length': '13', 'dir': 'jupyter-structured-clean-dedup', 'id': '469300', 'license': 'MIT', 'n_tokens_mistral': 2884, 'n_tokens_neox': 2726, 'n_words': 921, 'path': 'Aulas/1/02-funcoes.ipynb', 'repo_name': 'tomazrvb/Visao.Computacional', 'size': '7953'}