Dado este exercício: (de codewars.com)

Crie uma função que retorne o quadrado de cada dígito de um número.

Por exemplo, ao inserir a função o número 702 deve retornar 4904, pois o quadrado de 7 é 49, o quadrado de 0 é 0 e o quadrado de 2 é 4. Se a função receber zero ela deverá retornar 0.

O desafio subjacente deste exercício é percorrer um número inteiro dígito por dígito e retornar um resultado como outro número inteiro.

Como tudo em programação, é possível resolver este exercício de várias maneiras. Primeiro, vamos resolver usando propriedades de manipulação de números em Python, depois explicarei outra forma mais avançada ?.

def square_digits(num):
    if num == 0:
        return 0
    result = ""
    while num > 0:
        num_sqr = (num % 10) ** 2 
        num = num // 10
        result = str(num_sqr)   result 
    return int(result)

Neste código, primeiro avaliamos se um 0 é recebido para retornar um 0, conforme indicado na instrução. Em seguida, inicializamos a variável result como uma string vazia, criamos um loop while com a condição num > 0. Definimos a variável num_sqr, que é o quadrado de cada dígito recebido. Com num % 10 obtemos o último dígito do número recebido e depois elevamos ao quadrado com **2.

• Usar num % 10 é um método comum para extrair o último dígito de um número.

• A expressão num = num // 10 remove o último dígito do número, avançando através de cada dígito.

Outra maneira de resolver isso é converter o número em uma string e percorrer essa string com um loop for:

def square_digits(num):
    result = ""
    for digit in str(num):
        result  = str(int(digit)**2)
    return int(result)

Esse código é mais otimizado, tem menos linhas e o percurso é muito bem compreendido, não sendo necessário avaliar se recebe 0. Em Python é possível percorrer uma string caractere por caractere com um loop for . Usamos essa funcionalidade para percorrer o número recebido, convertendo-o com str(num) em uma string. Criamos a variável resultado como uma string vazia, à qual será concatenado um caractere que é o resultado do dígito convertido para um número inteiro e elevado a 2, tudo convertido para uma string. Em seguida, retornamos o resultado convertido em um número inteiro.

• Concatenar strings dentro de um loop pode ser menos eficiente em termos de desempenho para números muito grandes, mas é perfeitamente aceitável para a maioria dos casos de uso.

*Uma maneira mais avançada e "elegante" * é usar o Generator Understanding e o .join motodo. Apresento o código primeiro e vamos decompô-lo explicando esses termos.

def square_digits(num):
    return int(''.join(str(int(digit)**2) for digit in str(num)))

Este primeiro código não é muito legível se você não conhece os conceitos
que compõem tudo.

A expressão str(int(digit)**2) para digit in str(num) é um _generator _(Generator Expression) que itera sobre cada dígito na representação de string do número num.
Para cada dígito, ele o converte em um número inteiro (int(dígito)), eleva-o ao quadrado (**2) e depois o converte novamente em uma string (str(...)). Então, com ''.join(...), você pega uma sequência (neste caso, o gerador) e concatena todos os elementos em uma única string. Aqui, todos os dígitos quadrados são combinados em uma única string sem qualquer separador (porque a string entre aspas simples está vazia '').

Como vemos, as diferentes formas de resolver um exercício demonstram os níveis de conhecimento de uma língua. Todas as soluções estarão corretas se passarem nos testes, mas algumas são mais eficientes e legíveis do que outras. A escolha da abordagem depende do contexto e do que é priorizado em cada caso:

• Legibilidade: É crucial quando outros desenvolvedores vão ler e manter seu código. Código claro e fácil de entender reduz a chance de erros e facilita sua manutenção. ?

• Eficiência: é importante ao trabalhar com grandes volumes de dados ou em aplicativos onde o desempenho é crítico. Um código mais otimizado pode fazer uma grande diferença na velocidade e no consumo de recursos. ?

• Simplicidade: Para casos onde a prioridade é resolver o problema de forma rápida e direta, como em protótipos ou exercícios didáticos. A simplicidade geralmente facilita a depuração e o teste de código. ?

Ao desenvolver é importante encontrar um equilíbrio entre estas considerações, adaptando a solução às necessidades específicas do projeto ou tarefa.