Tudo em blocos: trabalhando com funções#

O que você saberá se você ler todo este capítulo?#

  1. Que as funções são formas de criarmos pedaços de código que podemos reaproveitar em diferentes momentos do nosso algoritmo.

  2. Que as funções permitem e facilitam a reusabilidade, refatoração, organização e limpeza do nosso código.

  3. Que você já estava usando funções – provavelmente, sem saber.

  4. Além disso, que existem também outras funções já disponíveis em Python.

  5. E, finalmente, que você também pode criar as suas próprias funções.

De uma receita para várias receitas de culinária#

Até o momento tentei conectar conceitos de algoritmos com receitas de bolo. Vamos continuar assim, mas agora vamos avançar mais um passo em complexidade. Por isso, preste bastante atenção nas explicações, beleza?

Imagem contendo vários doces do tipo brigadeiro.
Créditos: Frank Holleman no Unsplash

Pensemos que a sua receita de bolo fez muito sucesso e que, agora, você foi contratado para escrever um livro de várias receitas. Legal, né? Bom, vamos supor que você começou a trabalhar assim:

  1. Primeiro, você escreveu uma receita de bolo de chocolate, que é uma receita na qual você domina muito bem. Você descreveu os ingredientes, o modo de preparo e o resultado esperado.

  2. Depois, você escreveu uma receita de brownie. Você percebeu que um ou outro ingrediente também tinha na receita de bolo de chocolate, mas continuou escrevendo mesmo assim. Por isso, descreveu os ingredientes, modo de preparo, e o resultado esperado.

  3. Depois, você fez a mesma coisa com uma torta de limão, um bolo de cenoura, uma torta de maçã, uma torta holandesa, um bolo de baunilha com cobertura de chocolate, e assim sucessivamente.

  4. Na sua centésima receita, você estava de saco cheio: você percebeu que o processo de fazer os mesmos passos (descrever os ingredientes, modo de preparo e o resultado esperado) era um processo chato.

  5. Pior: como você se cansou, percebeu que aquelas receitas que você fez durante o final de noite ou na madrugada tinham algumas pequenas falhas porque você esqueceu de copiar e colar alguma instrução de outra receita. Como o processo era tão mecânico (fazer 100 vezes coisas parecidas), isso acabou acontecendo algumas vezes.

  6. Você também percebeu que algumas coisas eram exatamente iguais entre as receitas. O passo-a-passo de como fazer a cobertura, por exemplo, era o mesmo texto copiado e colado umas vinte vezes entre diferentes receitas.

  7. Você quase teve um ataque de raiva quando percebeu que esse passo-a-passo de como fazer a cobertura tinha um erro de digitação. Por isso, você teve que olhar receita a receita para corrigir isso, e pelo menos vinte vezes.

Por isso, você teve o seguinte pensamento:

💭 Puxa, seria legal se tivesse um jeito de escrever lá no começo do livro algo como “Instruções para fazer a cobertura”, e aí depois no livro e no meio das receitas eu só referenciaria a página contendo estas instruções quando precisasse.

Bom, em programação isto também é possível com o uso de funções. Vamos lá?

Funções#

As funções são usadas em linguagem de programação (como o Python) para agrupar instruções que realizam uma determinada tarefa e que podem ser reutilizadas em diferentes partes do código. Elas permitem que você crie uma sequência de ações que podem ser executadas repetidamente sem precisar reescrever todo o código a cada vez que a tarefa precisa ser executada.

Por exemplo, imagine que você tenha que executar uma tarefa que envolve diversas etapas, como fazer a cobertura de um bolo (já falamos sobre isso, não é?). Cada etapa pode ser vista como uma função separada, como misturar os ingredientes, bater a massa, levar ao forno, etc. Ao criar funções separadas para cada uma dessas tarefas, você pode reutilizá-las em outras receitas de bolo sem precisar escrever as mesmas coisas novamente.

Além disso, as funções ajudam a tornar o código mais organizado e legível, facilitando a manutenção e o desenvolvimento de novas funcionalidades. Por exemplo, se você precisar corrigir um erro em uma função, pode fazê-lo sem afetar o restante do código. Quer outra analogia? Vamos começar a tratar o seu código como sendo uma receita de bolo (isto é: uma sequência de passos) para vários blocos de Lego, onde cada bloco possui uma função específica. Você poderá trabalhar, organizar e encaixar os blocos como quiser. Em Python, diria que podemos organizar as funções assim:

  1. Quem criou a função?

    • Funções que já são inclusas no Python por padrão (built-in);

    • Funções que outras empresas ou desenvolvedores fizeram, e que estão disponíveis para você usar (em bibliotecas, que poderemos ver depois se este livro realmente se tornar de alguma forma popular e precisar ampliá-lo);

    • Funções que você irá criar para o seu próprio código.

  2. Como podemos usar a função?

    • Função sem entrada e sem retorno;

    • Função sem entrada e com retorno;

    • Função com entrada e sem retorno;

    • Função com entrada e com retorno.

Ah, e antes que me esqueça: usar funções é uma das maneiras de melhorarmos o código pela refatoração.

A refatoração é importante porque torna o código mais limpo, fácil de entender e manter, evitando problemas como bugs e falhas no sistema, além de facilitar a adição de novas funcionalidades. A refatoração pode envolver a modificação de nomes de variáveis, extração de trechos de código em funções separadas, eliminação de código redundante, melhoria do desempenho e otimização do código em geral.

Vou te contar um segredo à meia-noite#

E se eu te disser que você já está usando funções? Veja o código abaixo:

# Solicita que o usuário digite um número em formato de string
num_string = input("Digite um número: ")

# Converte a string para um número de ponto flutuante (float)
num_float = float(num_string)

# Formata o número em uma string com duas casas decimais
num_formatado = "{:.2f}".format(num_float)

# Imprime o número formatado na tela
print("O número digitado foi: {}".format(num_formatado))

É um código que pede para que um usuário digite um número com quantas casas decimais o usuário quiser e que, no final, mostra este número arredondado com duas casas decimais, certo? Agora, observe o seguinte: as palavras-chave input, float e print sempre estão com uma cor diferente, e sempre depois delas temos um abre-e-fecha parênteses. Curioso, né?

Agora, vamos voltar um passo:

  1. Percebe que input(), float() e print() sempre funcionam do mesmo jeito independentemente do código? Quer dizer: não importa se você está estudando loops, if/else ou qualquer outra coisa.

    • Se você chama no seu código um print(), a sua expectativa é a de que uma mensagem seja mostrada ao usuário, não é? Você não sabe que mágica existe dentro deste print() e nem como ele funciona: é uma caixa-preta em que você só dá um texto para ele e, como resultado, aquilo é mostrado na tela, né?

    • A mesma coisa é o input(): como o Python se conecta ao seu sistema operacional e ao seu teclado para ler o que o usuário digita? Como ele traduz o movimento de uma pessoa de apertar um botão para um texto que aparece na tela e dentro do Python? É uma outra caixa-preta: não sabemos como, mas sabemos que tem uma entrada esperada (uma mensagem que você pode querer mostrar ao usuário) e uma saída esperada (um texto que o usuário digitou).

    • O float(), a mesma coisa: ele faz outra mágica dentro de outra caixa-preta em que a entrada é um texto e a saída é aquele texto convertido em um número decimal.

  2. A mesma lógica de caixa-preta é usada pelo format. Ele também possui um abre-e-fecha parênteses. Ele não tem uma cor diferente, mas é porque ele está sendo chamado de uma forma diferente depois da string (sempre a sintaxe é "texto entre aspas duplas" seguido de .format()). Ele é chamado desse jeito (depois de uma string) porque ele atua sobre um objeto do tipo str (ou seja, uma string). O nome bonito para funções assim é métodos, mas veremos mais sobre isso depois.

  3. Veja que funções assim (e outras que você também já viu, como int(), range() e str()) sempre seguem alguns padrões:

    • As funções sempre são seguidas por um abre-e-fecha parênteses (como range(10) e print("Oi")).

    • As funções sempre fazem alguma ação. “Chamamos” o print() para mostrar algo na tela. “Chamamos” o input() para ler algo que o usuário digitou. “Chamamos” o int() para converter um número que está em formato de texto para um inteiro.

    • Se as variáveis são como os ingredientes de uma receita de bolo, as funções são como pequenas receitas (ou passo-a-passo) que repetiremos algumas vezes ao longo do caminho. São, de certa forma, pequenos algoritmos.

Funções que já vem de brinde para você#

Quer outro segredo? Saber ler documentações é o que te trará uma boa vantagem competitiva para o futuro. É neste sentido que eu te apresento a documentação oficial do Python. Ler a documentação oficial de um software é uma habilidade essencial para programadores iniciantes e experientes. A documentação descreve o propósito e a funcionalidade de cada elemento de um código, tornando mais fácil entender como usá-lo e solucionar possíveis erros. Além disso, a documentação oficial também inclui exemplos e amostras de código que podem ser utilizados como modelos para soluções específicas.

Ah, saber ler e interpretar estas documentações também é um jeito bem legal de aprender boas práticas de programação e descobrir recursos ocultos que podem simplificar tarefas complexas. Os desenvolvedores de bibliotecas e linguagens de programação trabalham continuamente para atualizar suas documentações com novas funcionalidades e recursos, portanto, manter-se atualizado sobre as novidades pode aprimorar a sua capacidade de auto-desenvolvimento.

A documentação oficial é uma fonte de informação confiável e essencial para as pessoas de todos os níveis de habilidade e experiência. É bem mais confiável do que este livro que você está lendo, bem mais confiável do que qualquer outro livro e curso pela internet também. Afinal de contas, é a fonte oficial e que é atualizada sempre.

Bom - voltando ao link que eu coloquei acima. Você pode ver que é uma página com as funções que já vem por padrão no Python. Como elas já vem inclusas, o nome em inglês para isso é built-in functions. Você verá que além do print(), input(), format(), range(), int(), float() e str() existem várias outras como, por exemplo:

  • abs(): calcula o valor absoluto de um número. Teste abs(-50.4), por exemplo.

  • len(): calcula a quantidade de caracteres em uma string ou o total de elementos de uma sequência de valores. Teste len([5, 900, 1, -2]), por exemplo.

  • max(): calcula o maior valor que existe em uma sequência de valores. Teste max([5, 900, 1, -2]), por exemplo.

  • min(): calcula o menor valor que existe em uma sequência de valores. Teste max([5, 900, 1, -2]), por exemplo.

  • open(): serve para abrir arquivos. Veremos isso em breve, mas você poderá usar essa função para ler o conteúdo de arquivos como textos, músicas e imagens.

  • pow(): você poderá calcular exponenciais. Vamos supor que você queira calcular \(34^5\) em Python. Uma alternativa seria fazer 34 ** 5. Outra seria fazer pow(34, 5).

  • reversed(): serve para reverter a ordem de uma sequência. Se você fizer reversed([5, 900, 1, -2]) você terá um iterador para ver esses itens de trás pra frente.

    • Iterador: é um iterador é como se fosse uma “lista inteligente” que o programa usa para acessar uma série de valores. Como uma analogia, vamos supor que você tem uma caixa cheia de doces, mas não pode ver tudo o que tem dentro dessa caixa de uma vez só. O iterador seria como a sua mão, que pode pegar um doce de cada vez e mostrar para você.

  • round(): arredonda um número para a quantidade de casas pré-determinadas (segundo parâmetro). Se você não informar um segundo parâmetro, ele arrendondará para um número inteiro. Teste round(90.5949) e veja a diferença para round(90.5949, 1), round(90.5949, 3) e round(90.5949, 10), por exemplo.

  • sorted(): serve para ordenar os elementos de uma sequência, do menor para o maior.

  • sum(): calcula a soma total de uma sequência de valores. Teste sum([5, 900, 1, -2]), por exemplo.

Ah, um comentário sobre o reversed() (isso também se aplica ao range()): algumas funções retornam iteradores. Veja o código abaixo e, logo em seguida, os resultados:

elementos = [5, 900, 1, -2]
print(f'Os elementos invertidos são {reversed(elementos)}.')
print(f'Os elementos invertidos são {list(reversed(elementos))}.')
print(f'Os elementos ordenados são {sorted(elementos)}.')

print('\nUsando loop para mostrar os elementos invertidos:')
for i in reversed(elementos):
    print(i)

print('\nUsando loop para mostrar os elementos ordenados:')
for i in sorted(elementos):
    print(i)

Os elementos invertidos são <list_reverseiterator object at 0x000002107ABA7490>.
Os elementos invertidos são [-2, 1, 900, 5].
Os elementos ordenados são [-2, 1, 5, 900].

Usando loop para mostrar os elementos invertidos:
-2
1
900
5

Usando loop para mostrar os elementos ordenados:
-2
1
5
900

Veja que o primeiro resultado do print() não foi a sequência de elementos, mas sim um <list_reverseiterator object>. Pensando na analogia da mão da caixa de doces, esta é a mão. Para ver o que tem dentro desta sequência invertida é possível usar a função list(), que converte para uma sequência do tipo lista. Veja que o segundo print() já deu o resultado esperado. Trouxe isto para você porque você pode ver alguma coisa assim quando estiver testando algumas funções como o range() ou reversed().

Outras funções#

Também existem outras funções que também já existem no Python como, por exemplo:

E, além disso, existem bibliotecas feitas por outras pessoas e empresas com funções específicas como, por exemplo:

Assim que você tiver mais experiência em Python você naturalmente começará a usar esses módulos e bibliotecas extras para criar algoritmos mais complexos. Compartilho isso aqui para que você saiba a direção que você seguirá, mas antes disso é legal que você saiba como criar as suas próprias funções. Vamos lá?

Criando a sua própria função#

Para criar uma função em Python, basta usar a palavra-chave def, seguida pelo nome da função que explique de forma simples o que ela faz e, depois, o código. Por exemplo:

def saudar_usuario():
    print("Olá! Tudo bem por aí?")

Veja a estrutura: primeiro, defini a função com a palavra-chave def (entendeu? Definir -> def). Depois que defini a função, dei um nome que mostrasse o que ela deve fazer. Este nome não pode ter acentos ou espaços, e deve sempre estar em minúsculas. Se for usar mais de uma palavra, separe-as com underscores (_). Depois, continuei com um abre-e-fecha parênteses (toda função tem isso, e vamos explorar isso em seguida) e os dois-pontos. Esses dois-pontos servem para que o Python entenda que logo depois disso teremos o código de dentro da função. No caso, somente mostraríamos uma mensagem para o usuário chamada “Olá! Tudo bem por aí?”.

Agora, o que acontece se você chamar esta função cinco vezes?

saudar_usuario()
saudar_usuario()
saudar_usuario()
saudar_usuario()
saudar_usuario()

A resposta é simples: a lógica da função será executada cinco vezes. Neste caso, significa que a mensagem será mostrada cinco vezes na tela.

Um outro exemplo#

Agora, teste este código:

def somar(a, b):
    resultado = a + b
    return resultado

soma = somar(2, 5)
print(soma)

soma = somar(5, 2)
print(soma)

soma = somar(1000, -20)
print(soma)

Este código define uma função chamada somar, que recebe dois argumentos: a e b. Dentro da função, os argumentos são somados e o resultado é armazenado na variável resultado. Em seguida, a função retorna o valor de resultado. Lembra que o funcionamento de uma função é uma caixa-preta? Todo o resto do seu código não tem a mínima noção do que esta função (isto é, as três primeiras linhas do código acima) fazem.

Fora da função, temos três chamadas à função somar() com diferentes valores de a e b. Na primeira chamada, a é igual a 2 e b é igual a 5, resultando em uma soma de 7. Na segunda chamada, os valores de a e b são invertidos, mas ainda resultam em uma soma de 7. Na terceira chamada, a é igual a 1000 e b é igual a -20, resultando em uma soma de 980.

O resultado de cada chamada à função é armazenado na variável soma, que é impressa na tela usando a função print(). Assim, a saída do programa será:

7
7
980

Este exemplo ilustra como as funções podem ser usadas para reutilizar o código e simplificar a sua leitura e manutenção. Em vez de repetir o código da soma em cada uma das chamadas, podemos definir uma função para realizar a operação e chamá-la várias vezes com diferentes argumentos. Isso torna o código mais legível e fácil de modificar, se necessário.

Com isso, vamos pensar em algumas formas diferentes de construirmos funções:

Função com parâmetros e com retorno#

O tipo de função mais comum é a que possui parâmetros (ou argumentos) de entrada e que retornam algo. Afinal, se falamos que uma função é como se fosse um pequeno pedaço de algoritmo e se também falamos que um algoritmo possui uma entrada e uma saída, a expectativa é a de que usemos as funções para produzir algo (uma saída) a partir de algo que entreguemos para a função (uma entrada).

Exemplo com fatorial#

Teste o seguinte código:

def calcular_fatorial(numero):
    fatorial = 1
    for i in range(1, numero+1):
        fatorial *= i
        
    return fatorial

a = 5
resultado = calcular_fatorial(a)
print(resultado)

b = 3
resultado = calcular_fatorial(b)
print(resultado)

Nesse exemplo, a função recebe o argumento numero para calcular o fatorial. Este numero é um parâmetro de entrada que a função receberá para calcular o fatorial. Veja que este numero é usado somente dentro da função: em nenhum outro momento precisaríamos criar uma variável com este nome fora da função. O mesmo vale para a variável fatorial: ela só existe dentro da função. Ah, e no final, a função retrna o fatorial calculado como um único valor de retorno.

Uma prova disso é que ao chamarmos a função com calcular_fatorial(a) e calcular_fatorial(b) usamos as variáveis a e b, e nada de numero, não é? Então, vale uma informação importante:

💡 As variáveis e parâmetros que existem dentro de uma função nascem e morrem dentro dela, e não existem fora dela.

Um outro exemplo com dois parâmetros de entrada#

A real é que é possível termos vários parâmetros de entrada. Imagine um caso em que precisemos calcular a área de um triângulo. Para tal, precisamos de dois parâmetros: base e altura. Teste a função abaixo:

def calcular_area_triangulo(base, altura):
    area = (base * altura) / 2
    return area

Neste exemplo, a função calcular_area_triangulo (percebe que esse nome é bem sugestivo?) recebe os argumentos base e altura para calcular a área de um triângulo. A função retorna a área calculada como um valor de retorno. Um teste dessa função seria:

resultado = calcular_area_triangulo(10, 5)
print(resultado)

Percebeu que em nenhum momento criamos as variáveis base, altura e area fora da função? Elas não existem em nenhum momento dessas duas linhas acima. Isto reforça o que falei anteriormente sobre as funções serem caixas-pretas para o código: as variáveis, funções e afins que acontecem dentro daquela função ficam dentro daquela função somente. Quer uma analogia? Vamos supor que você está fazendo um pedido para um restaurante. Você não sabe quantas pessoas trabalham na cozinha e nem quantas pessoas efetivamente fizeram o seu alimento. Você não sabe quanto tempo demorou, e nem a ordem que fizeram o preparo. Não sabe a marca dos ingredientes, também. Tudo o que você tem é o seu pedido como entrada (análogo a esses parâmetros de entrada) e o seu prato pronto como saída (análogo ao retorno).

E lá vem mais outro exemplo#

E dá para combinar if/elif/else ou um for/while em uma função? É claro! Olha só:

def eh_par(numero):
    if numero % 2 == 0:
        par = True
    else:
        par = False
        
    return par

resultado = eh_par(10)
print(resultado)

Nesse exemplo, a função eh_par() (já que não posso usar acentos para chamar de é_par() recebe o argumento numero para verificar se este valor é par ou não. A função retorna True se o número é par e False caso contrário. Percebeu como tem um if e else na função?

Também poderíamos deixar o código ainda mais enxuto o reescrevendo assim:

def eh_par(numero):
    if numero % 2 == 0:
        return True
    else:
        return False

resultado = eh_par(10)
print(resultado)

Esse código faz exatamente a mesma coisa do exemplo anterior. A diferença é que coloquei o return (que retorna de volta um valor ao algoritmo principal) para estar dentro do if e do else. Assim, não precisaria mais daquela variável par. Como uma analogia, imagine um fast-food com drive-thru: você pode retirar a sua comida em dois lugares diferentes - tanto na janelinha que é disponível para pessoas que fazem os pedidos dentro de um carro, tanto no balcão dentro do restaurante.

Um outro exemplo retornando dois valores#

Tá, e se eu quisesse retornar mais de um valor ao mesmo tempo? Digamos que eu queira modificar aquela função que calcula a área de um triângulo para também retornar a área de um retângulo. Como seria? Simples!

def calcular_areas(base, altura):
    area_triangulo = (base * altura) / 2
    area_retangulo = base * altura
    return area_triangulo, area_retangulo

triangulo, retangulo = calcular_areas(10, 5)
print(f'A área do retângulo é {retangulo}')
print(f'A área do triângulo é {triangulo}')

Consegue perceber que agora a nossa função calcular_area_triangulo foi modificada para se tornar calcular_areas? Agora, o return possui dois valores: o primeiro é a área do triângulo. Depois, a área do retângulo. Veja também que a antepenúltima linha do código armazena esses dois valores em duas variáveis chamadas triangulo e retangulo. Cada uma delas armazenará um dos dois valores do return seguindo a mesma ordem.

O que acha de modificar esta função para ter um terceiro ou quarto return?

Função sem parâmetros e com retorno#

Agora, não é obrigatório usarmos os parâmetros de entrada em cada função. Veja só:

def mostrar_nome_idade_exemplo():
    return "Fulano de Tal", 42
    
nome, idade = mostrar_nome_idade_exemplo()

Esta seria uma função que retorna um exemplo de nome e idade. Veja que não precisamos dar nenhum parâmetro de entrada: depois do def e do nome da função, temos os parênteses abrindo e fechando sem nada dentro. Isto significa que a função não precisa de nada externo para funcionar: ela retorna um nome e idade de exemplo para você sempre que precisar, e ela é “independente” para fazer isto.

Função com parâmetros e sem retorno#

Da mesma forma, o return também não é obrigatório para cada função. Veja só:

def eh_par(numero):
    if numero % 2 == 0:
        print(numero, "é um número par")
    else:
        print(numero, "não é um número par")
        
eh_par(10)

Perceba que adaptamos aquela função eh_par para não retornar nada. No lugar, ela somente mostrará algo na tela com o print(). Nesses casos em que não há um return poderemos chamar a função de forma direta. Lembra que antes precisávamos ter uma linha chamada resultado = eh_par(10) para poder guardar o resultado em uma variável? No exemplo acima, isto não é mais necessário.

Isto posto, é importante que você saiba que o mais comum é usarmos um return. Imagine o seguinte: e se quiséssemos usar o resultado dessa função em um if? Ou, e se quiséssemos montar uma frase diferente na tela? Nestes casos, a falta de um return não permitiria cenários desse tipo. Como uma analogia, a função é um restaurante. Você faz o seu pedido no restaurante e só pode comer dentro do restaurante e seguindo todas as regras de lá. Pegar o que restou para comer em casa? Não pode. Pedir para delivery? Esquece. Só pode comer de um jeito, e é do jeito deles, e não o seu.

Função sem parâmetros e sem retorno#

É bem difícil termos funções assim. É como se fosse um restaurante em que servem só um único prato e de um único jeito. Sem adaptações, e sem espaço para discussão. E, ainda, só pode comer lá dentro. Existe um caso útil para funções assim: mostrar menus na tela:

def mostrar_menu():
    print("Olá! Digite uma opção do menu. Em seguida, aperte Enter.")
    print("1 - Listar todos os cadastros.")
    print("2 - Fazer um novo cadastro.")
    print("3 - Remover um cadastro já existente.")
    print("4 - Modificar um cadastro já existente.")
    print("9 - Ajuda.")
    print("0 - Sair.")
    
mostrar_menu()

Veja que o código acima não possui nenhuma interação: não tem nenhum parâmetro de entrada e, por isso, esta função sempre mostrará as mesmas mensagens do mesmo jeito e na mesma ordenação. Também não retorna nada: não interage com o usuário e não cria nenhum valor que seria útil para manipular no algoritmo. Só mostra mensagens, e é isso.

Exercícios#

Neste momento eu espero que você já tenha entendido como funciona (de maneira geral) o for e o while. O que acha de colocar a mão na massa e experimentar?

  1. Crie uma função que recebe três notas. Ela deve retornar a média dessas notas para o usuário.

    • Exemplo: a função deve receber as notas 8.5, 9.0 e 7.1. Ela deve retornar aproximadamente 8.2.

  2. Escreva uma função que recebe como parâmetro uma temperatura em graus Celsius. Ela deve retornar a temperatura convertida para graus Fahrenheit.

    • Exemplo: a função deve receber como parâmetro o valor 0 (referindo-se à temperatura em graus Celsius). Ela deve retornar o valor -32 (que é a mesma temperatura convertida para a escala Fahrenheit).

  3. Adapte o código abaixo para que tenha uma função chamada verificar_primo em que recebe um parâmetro de entrada chamado numero e retorna True se ele for primo e False se não for primo.

num = int(input("Digite um número: "))
primo = True

for i in range(2, num):
    if num % i == 0:
        primo = False
        break

if primo:
    print(num, "é um número primo")
else:
    print(num, "não é um número primo")

  1. Adapte o código abaixo para que tenha uma função chamada verificar_palindromo em que recebe um parâmetro de entrada chamado palavra e retorna True se ele for palíndromo e False se não for palíndromo.

palavra = input("Digite uma palavra: ")
i = 0
j = len(palavra) - 1
palindromo = True

while i < j:
    if palavra[i] != palavra[j]:
        palindromo = False
        break
    i += 1
    j -= 1

if palindromo:
    print(palavra, "é um palíndromo")
else:
    print(palavra, "não é um palíndromo")

  1. Adapte o código que você fez no exercício 4 para que a função seja chamada dentro de um for. O for deve repetir cinco vezes. A cada iteração você deve pedir para que o usuário digite uma palavra. Com isso, testaremos se cinco palavras diferentes são ou não palíndromos.

    • Não se assuste: este aqui é um pouco mais complexo, mas é mais simples do que parece. Se não souber como começar, veja primeiro a resolução e, depois, tente fazer por conta própria.

Respostas#

1. Crie uma função que recebe três notas. Ela deve retornar a média dessas notas para o usuário.

def calcular_media(nota1, nota2, nota3):
    media = (nota1 + nota2 + nota3) / 3
    return media
    
resultado = calcular_media(8.5, 9.0, 7.1)
print(resultado)

O código acima define uma função chamada calcular_media que recebe três parâmetros: nota1, nota2 e nota3. Esses parâmetros são utilizados na função para calcular a média entre as três notas, armazenada na variável media. Em seguida, a função retorna a média calculada.

Fora da função, a média é calculada chamando a função calcular_media e passando três valores como argumentos: 8.5, 9.0 e 7.1. O resultado retornado pela função é armazenado na variável resultado. Por fim, o resultado é mostrado na tela utilizando a função print.

2. Escreva uma função que recebe como parâmetro uma temperatura em graus Celsius. Ela deve retornar a temperatura convertida para graus Fahrenheit.

def celsius_para_fahrenheit(temp_celsius):
    temp_fahrenheit = (temp_celsius * 9/5) + 32
    return temp_fahrenheit

temperatura = 0
print("A temperatura em Fahrenheit é:", celsius_para_fahrenheit(temperatura))

A função é definida com o nome celsius_para_fahrenheit e tem um parâmetro de entrada temp_celsius que representa a temperatura em graus Celsius.

Dentro da função, a temperatura em Celsius é convertida para Fahrenheit utilizando a fórmula de conversão: temp_fahrenheit = (temp_celsius * 9/5) + 32. Em seguida, a temperatura em Fahrenheit é retornada pela função com o uso da palavra-chave return.

Fora da função, a variável temperatura é inicializada com o valor 0, e em seguida a função celsius_para_fahrenheit é chamada com esse valor como argumento. O resultado da função é então impresso na tela utilizando a função print.

3. Adapte o código para que tenha uma função chamada verificar_primo em que recebe um parâmetro de entrada chamado numero e retorna True se ele for primo e False se não for primo.

def verificar_primo(numero):
    primo = True

    for i in range(2, num):
        if num % i == 0:
            primo = False
            break
            
    return primo

num = int(input("Digite um número: "))
if verificar_primo(num):
    print(num, "é um número primo")
else:
    print(num, "não é um número primo")

O código permanece bem parecido com o que estava no exemplo. A diferença é que o bloco de código responsável por determinar se um número era ou não primo encontra-se dentro da função chamada verificar_primo. Dentro dela existe toda a lógica necessária para determinar se numero é ou não primo.

Veja que o int(input("Digite um número")) está fora da função. Isto acontece porque a tarefa desta função é verificar se um número é primo ou não, como o próprio nome já diz. Como a tarefa dela não é a de solicitar números ao usuário, o int(input()) fica do lado de fora. Além disso, ela precisa de um numero para funcionar. Por isso, precisamos tê-lo em mãos antes de entrar na função.

4. Adapte o código para que tenha uma função chamada verificar_palindromo em que recebe um parâmetro de entrada chamado palavra e retorna True se ele for palíndromo e False se não for palíndromo.

def verificar_palindromo(palavra):
    i = 0
    j = len(palavra) - 1
    palindromo = True

    while i < j:
        if palavra[i] != palavra[j]:
            palindromo = False
            break
        i += 1
        j -= 1
        
    return palindromo

palavra_teste = input("Digite uma palavra: ")
eh_palindromo = verificar_palindromo(palavra_teste)

if eh_palindromo:
    print(palavra_teste, "é um palíndromo")
else:
    print(palavra_teste, "não é um palíndromo")

Aqui, a mesma lógica do exercício anterior se aplica: colocamos dentro da função o mínimo necessário para que ela funcione com o parâmetro de entrada fornecido (no caso, uma palavra). Como precisamos da palavra antes de começar, o input() que solicita uma palavra do usuário acontece fora da função. Além disso, com o resultado em mãos (e armazenado na variável eh_palindromo) conseguimos mostrar uma frase na tela. Perceba que chamei a variável com este nome (e não de palindromo) para não te confundir e, ainda, para deixar claro que as variáveis dentro de uma função não são as mesmas que estão fora.

5. Adapte o código que você fez no exercício 4 para que a função seja chamada dentro de um for. O for deve repetir cinco vezes. A cada iteração você deve pedir para que o usuário digite uma palavra. Com isso, testaremos se cinco palavras diferentes são ou não palíndromos.

def verificar_palindromo(palavra):
    i = 0
    j = len(palavra) - 1
    palindromo = True

    while i < j:
        if palavra[i] != palavra[j]:
            palindromo = False
            break
        i += 1
        j -= 1

    return palindromo

for i in range(5):
    palavra_teste = input("Digite uma palavra: ")
    eh_palindromo = verificar_palindromo(palavra_teste)

    if eh_palindromo:
        print(palavra_teste, "é um palíndromo")
    else:
        print(palavra_teste, "não é um palíndromo")

A única mudança que de fato houve foi a adição do for i in range(5):, e adicionei uma indentação em todas as linhas que vieram depois para colocá-las dentro do for. E só. Veja que conseguimos chamar esta função diferentes vezes e ela teve o mesmo funcionamento esperado (isto é, verificar se uma palavra é ou não um palíndromo) para diferentes palavras. Igualzinho quando esperamos que o print() funcione da mesma forma para frases diferentes ou quando esperamos que o input() também tenha a mesma serventia independentemente do lugar em que estamos o usando. Entende agora o objetivo por trás deste reuso das funções?

Referências bibliográficas#