CSE 111: Programação com Funções

def pagamento(amt, ar, y, ppy):
    """Calcula e retorna o valor do pagamento
    para um empréstimo com uma taxa de juros anual fixa.
    """
    r = ar / ppy
    n = y * ppy
    p = amt * r / (1 - (1 + r) ** -n)
    return round(p, 2)

def test_pagamento():
    """Verifique se a função de pagamento funciona corretamente."""
    assert pagamento(10_000, 0.07, 4, 12) == 239.46
    assert pagamento(80_000, 0.04, 15, 4) == 1779.56

def prefixo(s1, s2):
    """Retorne o prefixo, se houver, que aparece em
    s1 e s2. Em outras palavras, retorne uma string dos
    caracteres que aparecem no início em s1
    e s2. Por exemplo, se s1 é "inconcebível" e s2
    é "inconveniente", esta função retornará "incon".
    """
    s1 = s1.lower()
    s2 = s2.lower()
    i = 0
    limite = min(len(s1), len(s2))
    while i < limite:
        if s1[i] != s2[i]:
            break
        i += 1
    return s1[0:i]

def test_prefixo():
    """Verifique se a função de prefixo funciona corretamente."""
    assert prefixo("", "") == ""
    assert prefixo("", "correto") == ""
    assert prefixo("claro", "") == ""
    assert prefixo("feliz", "engraçado") == ""
    assert prefixo("catedral", "catálogo") == "cat"
    assert prefixo("dogmático", "dogma") == "dogm"
    assert prefixo("jovial", "juventude") == "j"
    assert prefixo("insensato", "ingrato") == "in"
    assert prefixo("desdenhoso", "desagradavel") == "des"

def get_int(prompt, min, max):
    """Solicite ao usuário um número inteiro, verifique se é
    entre min e max, inclusive, e retorne o inteiro.
    """
    feito = False
    while not feito:
        try:
            texto = input(prompt)
            numero = int(texto)
            if numero < min:
                print("Entrada inválida: "
                    f"o número deve ser {min} ou maior.")
            elif numero > max:
                print("Entrada inválida: "
                    f"o número deve ser {max} ou menor.")
            else:
                feito = True
        except ValueError as err_de_valor:
            print(f"Inteiro inválido: {texto}. Por favor, tente novamente.")
    return numero

from io import StringIO
import re
import sys
def test_get_int(monkeypatch):
    """Verifique se a função get_int funciona corretamente."""
    stdin = StringIO("1r\n-3\n12\n8")
    stdout = StringIO()
    monkeypatch.setattr(sys, "stdin", stdin)
    monkeypatch.setattr(sys, "stdout", stdout)
    min = 1
    max = 10
    prompt = f"Digite um inteiro entre {min} e {max}: "
    num = get_int(prompt, min, max)
    monkeypatch.undo()
    pattern = prompt + "\\s*" \
        + "Inteiro inválido: 1r\\. Por favor, tente novamente\\.\\s*" \
        + prompt + "\\s*" \
        + f"Entrada inválida: o número deve ser {min} ou maior\\.\\s*" \
        + prompt + "\\s*" \
        + f"Entrada inválida: o número deve ser {max} ou menor\\.\\s*" \
        + prompt + "\\s*"
    saida = stdout.getvalue()
    assert re.compile(pattern).match(saida) != None
    assert num == 8

"""
Para testar um programa que recebe a entrada do usuário de uma
interface gráfica do usuário, separe as funções de eventos
(aqueles que são executados quando um usuário digita um valor em um campo
de texto) em duas funções. Mova os cálculos para fora da
função de evento e coloque-os em uma função de cálculo que leva
parâmetros, executa um cálculo e retorna um resultado.
Em seguida, escreva uma função de teste para a nova função de cálculo.
"""
# Esta função é chamada toda
# vez que o usuário solta uma tecla.
def calc(evento):
    try:
        # Obtenha a entrada do usuário.
        l = txtLargura.get()
        r = txtRazao.get()
        d = txtDiam.get()
        # Calcule o volume do pneu.
        v = volume_pneu(l, r, d)
        # Exiba os resultados para o usuário.
        lblResult.config(text=f"{v:.1}")
    except ValueError:
        # Quando o usuário apaga todos os dígitos de uma só vez
        # dos campos de texto, remova os rótulos dos resultados.
            lblResult.config(text="")
def volume_pneu(largura, razao, diametro):
    """Calcule e retorne o volume aproximado de um pneu."""
    vol = (math.pi * largura * largura * razao *
            (largura * razao + 2540 * diametro)) / 10_000_000
    return vol

def test_volume_pneu():
    """Verifique se a função volume_pneu funciona corretamente."""
    assert volume_pneu(185, 60, 14) == approx(30101,58, 0,01)
    assert volume_pneu(205, 60, 15) == approx(39924.49, 0.01)

def escrever_arquivo(nomedoarquivo, linhas):
    """Crie um arquivo e escreva linhas de texto nele.
    Parametro
        linhas: uma lista de strings.
    Retorno: nada
    """
    with open(nomedoarquivo, "wt", encoding="utf-8") as arquivodesaida:
        for texto in linhas:
            print(texto, file=arquivodesaida)

import os
def test_escrever_arquivo():
    """Verifique se a função escrever_arquivo funciona corretamente."""
    linhas = [
    "Acautelai-vos, porém, dos falsos profetas, que vêm a vós vestidos como ovelhas",
    "mas interiormente são lobos devoradores. Por",
    "seus frutos os conhecereis. Porventura colhem-se uvas",
    "dos espinheiros ou figos dos abrolhos? Assim, toda árvore boa produz",
    "bons frutos, e toda árvore má produz",
    "frutos maus. Não pode a árvore boa dar maus",
    "frutos, nem a árvore má dar frutos bons.",
    "Toda árvore que não dá bom fruto corta-se",
    "e lança-se no fogo. E assim,",
    "pelos seus frutos os conhecereis."
    ]
    nomedoarquivo = "frutas.txt"
    # Chame a função escrever_arquivo para
    # escrever um arquivo chamado frutas.txt.
    escrever_arquivo(nomedoarquivo, linhas)
    # Leia o conteúdo do arquivo frutas.txt.
    with open(nomedoarquivo, "rt", encoding="utf-8") as arquivodeentrada:
        # Leia todos os caracteres do arquivo em uma string.
        string = arquivodeentrada.read()
    # Divida a string em uma lista de strings chamada
    # escritos. Cada linha de texto do arquivo de texto
    # será armazenada em seu próprio elemento na lista.
    escritos = string.splitlines()
    # Exclua o arquivo frutas.txt.
    os.remove(nomedoarquivo)
    # Verifique se gravar_arquivo está correto
    # corretamente o arquivo frutas.txt.
    assert linhas == escritos

def ler_arquivo(nomedoarquivo):
    """Lê e retorna o conteúdo
    de um arquivo de texto como uma lista de strings.
    """
    linhas = None
    with open(nomedoarquivo, "rt", encoding="utf-8") as arquivodeentrada:
        # Leia todos os caracteres do arquivo em uma string.
        string = arquivodeentrada.read()
    # Divida a string em uma lista de strings chamada
    # linhas. Cada linha de texto do arquivo de texto
    # será armazenada em seu próprio elemento na lista.
    linhas = string.splitlines()
    return linhas

import os
def test_ler_arquivo():
    """Verifique se a função ler_arquivo funciona corretamente."""
    # Escreva um arquivo de exemplo com três linhas
    nomedoarquivo = "linhas.txt"
    linhas = ["primeira", "segunda", "terceira"]
    with open(nomedoarquivo, "wt", encoding="utf-8") as arquivodesaida:
        print(*linhas, sep="\n", file=arquivodesaida)
    # Chame ler_arquivo para ler o arquivo de exemplo.
    ler = ler_arquivo(nomedoarquivo)
    # Exclua o arquivo linhas.txt.
    os.remove(nomedoarquivo)
    # Verifique se ler_arquivo leu o arquivo corretamente.
    assert ler == linhas

def filtro_de_medidor(df, numero_de_medidor):
    """Retorne um novo DataFrame que contenha apenas as linhas
    onde a coluna numeroDoMedidor é igual ao parâmetro
    numero_de_medidor.
    Parâmetros
        df: O DataFrame que esta função filtrará.
        numero_de_medidor: df será filtrado para que todas as linhas
            no novo DataFrame tenham esse número de medidor.
    Retorno: Um novo DataFrame.
    """
    filtro = (df["numeroDoMedidor"] == numero_de_medidor)
    df_filtrado = df[filtro]
    return df_filtrado

import pandas as pd
def test_filtro_de_medidor():
    """Verifique se a função filtro_de_medidor
    funciona corretamente.
    """
    # Leia o arquivo agua.csv e converta a
    # coluna lerData de uma string para datetime64.
    df = pd.read_csv(NOMEDOARQUIVO, parse_dates=["lerData"])
    # Chame a função filtro_de_medidor.
    num_medidor = "M4103"
    df_filtrado = filtro_de_medidor(df, num_medidor)
    # Verifique se o data frame
    # filtrado contém pelo menos uma linha.
    assert len(df_filtrado.index) > 0
    # Verifique se todos os números dos medidores no
    # data frame filtrado são o número correto.
    for valor in df_filtrado["numeroDoMedidor"]:
        assert valor == num_medidor