Funções

Lembre-se de que é importante sempre verificar se suas funções estão devolvendo algum valor. O que o código abaixo imprime?

def soma1(A, B):
    C = A + B

def soma2(A, B):
    return A + B

A = 1
B = 2

print("Soma 1a:", soma1(A, B))

C = soma1(A,B)
print("Soma 1b:",C)

print("Soma 2a:", soma2(A, B))

D = soma2(A,B)
print("Soma 2b:", D)

Produtos de primos:

a) Escreva uma função que decida se um número é produto de dois números ímpares. Se for, a função deverá devolver esses dois números, do contrário, deverá devolver None.

b) Escreva uma função que decida se um número é produto de quatro números ímpares. Se for, a função deverá retornar os números em variáveis passadas por referência. Tente utilizar a função anterior.
Escreva uma função que computa a potência $a^b$ para valores $a$ (float) e $b$ (int) passados por parâmetro (não use bibliotecas como math ou operador de exponenciação **). Use a função anterior e crie um programa que imprima todas as potências: $2^0, 2^2, \dots, 3^0, 3^1, \dots, 10^{10}$.
Escreva uma função que computa o fatorial de um número inteiro $n$ passado por parâmetro. Use a função anterior e crie um programa que imprima os valores de $n!$ para $n = 1, 2, \dots, 20$.
Escreva uma função que receba um número inteiro e imprima o mês correspondente ao número. Por exemplo, 2 corresponde à “fevereiro”. A função deve mostrar uma mensagem de erro caso o número recebido não faça sentido.
Faça uma função que inverta os elementos de uma lista. Sua função não deve usar outras listas além da recebida como parâmetro.
Escreva uma função que receba um número arábico inteiro e imprima o corresponde número em romano. Por exemplo, para 5 a saída desejada é 'V'. A função deve ser capaz de gerar o número romano para os 50 primeiros inteiros. Uma mensagem de erro deve ser mostrada caso um número fora dessa faixa seja recebido.
Escreva uma função que receba um número inteiro. Esta função deve verificar se tal número é primo. No caso positivo, a função deve retornar True, caso contrário, False.
Casamento de padrões: dadas duas sequências de caracteres, uma chamada texto e outra chamada padrao, faça uma função que verifique se existe uma ocorrência de padrao no texto. Caso exista uma ocorrência, a função retorna a posição inicial do texto onde ocorre o padrão, caso contrário, retorna -1.
Crie uma função que calcule e retorne o número de arranjos de $n$ elementos $p$ a $p$. A fórmula do arranjo é a seguinte:

$$ A^n_p = \frac{n!}{(n-p)!} $$

Obs.: Devem ser feitas duas funções, uma que use uma função para calcula o fatorial e uma que não use. Responda: Para você é melhor refazer o código ou utilizar uma função já existente?
Faça uma função que calcule a aproximação para a integral:

$$ \int_0^x e^{-u^2} = x - \frac{x^3}{3 \cdot 1!} + \frac{x^5}{5 \cdot 2!} - \frac{x^7}{7 \cdot 3!} + \dots $$

Sua função deverá ter a seguinte definição:
```
def aprox_int(x, cte):
```
onde x é um float e o mesmo x da fórmula acima e cte é um valor inteiro utilizado como critério de parada da aproximação, isto é, sua função deverá interromper o cálculo quando o i-ésimo termo, em valor absoluto, ficar menor que cte.
Escreva uma função que computa a potência $a^b$ para valores $a$ (double) e $b$ (int) passados por parâmetro (não use bibliotecas como math.h). Use a função anterior e crie um programa que imprima todas as potências:

$$ 2^0,2^1,...,2^{10},3^0,...,3^{10},...,10^{10}. $$
Escreva uma função que recebe um número inteiro $n$ passado por parâmetro e devolve o maior número primo que é menor ou igual a $n$.
Escreva uma função que recebe um número ponto flutuante $n$ passado por parâmetro e devolve a raiz quadrada de $n$. Use o método de Newton, encontrando o zero da função: $f(x) = x^2 - n$.
Escreva uma função chamada teste que recebe um valor inteiro positivo $n$ como parâmetro. Sua função deve retornar um valor inteiro $b$ tal que $b^k= n$ para algum inteiro $k$, e $b$ seja o menor possível.
Escreva uma função chamada teste que recebe um valor inteiro $n$ (positivo ou negativo) como parâmetro. Sua função deve imprimir todos os valores $a$ e $b$ (inclusive negativos) tais que $a*b= n$.
Notas:

a) Escreva uma função que leia do teclado o número de questões de uma prova e o valor de cada uma das questões. A função deve retornar a nota da prova.

b) Escreva uma função que receba como parâmetro um número de provas e leia do teclado o número de questões e os valores das questões de cada prova. A função deve retornar a média das provas.

c) Escreva um programa que leia do teclado um número de provas dadas em um semestre, o número de alunos matriculados e o número de questões e os valores das questões da cada prova de cada aluno. O programa deve imprimir a razão entre a média das notas dos alunos que tiraram pelo menos 5 e a média das notas dos alunos que tiraram abaixo de 5.
As vezes em python, por facilidade ou legibilidade, precisamos nomear as variáveis que estamos passando. Veja esse exemplo e indique a saída.
```
def divisao(v1, v2):
    return v1/v2

print(divisao(3,4))
print(divisao(v2 = 3, v1 = 4))
```
Em vários momentos, precisamos retornar vários valores distintos. É possível fazer isso de várias maneiras. Uma delas é usando o que chamamos de tupla, veja o exemplo abaixo. Podemos devolver qualquer tipo de estrutura.
```
 def funcao():
     texto = "dois"
     numero = 2
     return texto, numero

 tupla = funcao()
 print(tupla[1])

 texto, numero = funcao()
 print(texto)
```
Faça uma função que leia uma lista de $n$ inteiros (com repetição) e retorne uma tupla $(a, m)$, em que $A$ é o número com maior número de repetições e $m$ o número de repetições desse elemento.
O resultado de uma função pode ser utilizado em uma expressão, inclusive como parâmetros para outras funções. Analise o código abaixo e faça um teste de mesa, i.e., simule usando papel. Qual o resultado impresso?
```
def soma(A,B):
    return A + B

print(soma(1, soma(2, soma(3, 4))))
```

Função como parâmetro

Em Python, uma função é uma variável e pode ser inclusive passada como parâmetro. Veja o exemplo abaixo

def media_aritmetica(a, b):
    return (a + b) / 2

def calcular_medias(provas, exercicios, funcao):

    finais = []
    n = len(provas)
    for i in len(n):
        nota_final = funcao(provas[i], exercicios[i])
        finais.append(nota_final)

    return finais

def main():
    provas = [3.5, 7.5, 10]
    exercicios = [7.0, 6.0, 9.8]

    finais = calcular_medias(provas, exercicios, media_aritmetica)

    print(finais)

Modifique o programa, de forma a utilizar a média geométrica, ao invés da média aritmética.

Escreva uma função que recebe um intervalo $[a,b]$ e uma função real $f$ passada por parâmetro e devolva uma aproximação da raiz da a equação $f(x) = 0$. Essa função passada recebe um número de ponto flutuante e devolve outro número. Suponha que a função que ela calcula é contínua e que existe uma única raiz para nesse intervalo. Uma aproximação da raiz é qualquer número $x'$ tal que $|x - x'| < \epsilon$ para $\epsilon$ escolhido (digamos, $10^{-6}$).
Modificando o comportamento de funções:

a) Escreva uma função que devolve 1 se uma palavra termina com s, e 0 caso contrário.

b) Escreva uma função que conta o número de palavras que terminam com $s$ em um texto.

c) Reescreva uma função que conta o número de palavras terminadas com $s$ em um texto, mas use a primeira função como rotina. Você pode redefinir a assinatura da primeira função para torná-la mais conveniente.

d) Reescreva a função anterior para que ela conte as palavras de interesse. As palavras de interesse são identificadas por uma função indicadora passada por parâmetro (isso é, uma função que devolve True se for de interesse, e False caso contrário).

Escopo e visibilidade

Algo muito importante em python é entender como funções modificam listas e outras estruturas. Veja o código abaixo e determine o que é impresso. Depois, teste no computador. O resultado deu diferente do que esperado?
```
def mudaVar(variavel):
    variavel = 5

def mudaLista(lista):
    lista.append(5)

A = 3
B = [3]
mudaVar(A)
mudaLista(B)
print(A)
print(B)
```
Uma parte importante de programação é controlar a visibilidade, isso é, o que cada uma das funções “enxerga”. Isso é particularmente importante quando trabalhamos com vários arquivos. Para isso, temos alguns modificadores, que são palavras chaves especiais como global (nunca use essa palavra na prática). Fazer declarações de funções e variáveis com esses modificadores pode implicar em maneiras diferentes da organização da memória.

lib.py:
```
a = 21
def f1():
    print(a)
    global c
    c = 77;
    print(c)
    return

def f3():
    f2(1,2)
    print(c)
    return

def f2(a, b):
    print(a + b)
    f1()
    print(c)
    return

def f4():
    c = 14
    print(c)
    f3()
    print(c)
    return
```
main.py:
```
import lib

def main():
    e = 3
    lib.f4()
    print(lib.c)
    return

 main()
```
a) Para cada função, descreva as variáveis visíveis e funções visíveis. Diga quais variáveis são locais ou não.

b) Faça um desenho da organização da memória no momento em que a função f2 estiver executando.

c) Como você faria para contar o número de vezes que uma função é chamada em um programa?

Considere o código em Python abaixo:

i = 10
j = 20

def main():
    p = 10
    ra = 5
    for i in range(3):
        k = soma1(ra, p)
        ra = soma2(k)
        print(ra, k)

def soma1(q, c):
   return q + i + c

def soma2(ra):
   k = j
   ra = ra + k
   return ra

main()

a) Determine quais são as variáveis locais e globais deste programa, identificando a que função pertence cada variável local.

b) Mostre o que será impresso na tela do computador quando este programa for executado.