Simplificando Python: Um Guia para Instruções e Controle de Fluxo

#Python

Olá, jovens padawans e curiosos programadores! Hoje, vamos nos aventurar na galáxia fascinante das instruções em Python. Você já se perguntou como o computador compreende os seus comandos quando você escreve um código? Bem, é aí que as instruções entram em ação!

Pense nas instruções como poderosos feitiços que você lança para que o seu computador realize tarefas. Algumas são simples, como contar até dez, enquanto outras são mais complexas, como calcular quantos sóis existem nas profundezas do espaço.

Neste artigo, desvendaremos o mistério das instruções Python, explicando o que são e como funcionam.

Vamos começar nossa jornada pela galáxia das instruções Python e descobrir como elas podem ser usadas para realizar feitos incríveis.

Estão prontos?

Que a Força esteja com vocês! 🚀

Instruções no Python são, comandos são. Computador, diga a ele o que fazer, nós fazemos.

Como dar ordens a um jovem aprendiz, simples ou complexas elas podem ser.

Divididas, estão, em compostas e simples, para clareza e compreensão, buscamos.

A filosofia Jedi, sigo eu, no caminho da facilidade e compreensão, guiando os padawans na jornada da programação. Hmm.

Instruções compostas são como um plano detalhado, uma missão, onde várias ordens simples se unem para realizar uma tarefa complexa.

Neste exemplo, nós, Stormtroopers, utilizamos a instrução if para verificar se a idade é menor que 18. Se essa condição for verdadeira, obedecemos à ordem e emitimos o relatório "Você é menor de idade."

No entanto, se a idade não for menor que 18, executamos uma ação diferente, e assim dizemos "Você é maior de idade."

Como bons soldados, seguimos rigorosamente as ordens, seja qual for o resultado da condição. Nossa lealdade está na execução das instruções dadas, sem questionar.

idade = 20


if idade < 18:
  print("Você é menor de idade.")
else:
  print("Você é maior de idade.")

#Instrução composta
idade = 25

if idade < 18:
  print("Você é menor de idade.")
elif idade >= 18 and idade < 65:
  print("Você é adulto.")
else:
  print("Você é um idoso.")

Pode ter quantos elif for necessários.
and é para ligar condições.
No exemplo do código a idade precisa ser 18 ou maior E(and) ter idade menor que 65
Também existe o operador lógico OR

# Lógica do OR
idade = 70 # uma idade aleatória

if idade >= 18 or idade < 65:
  print("Você é adulto.")
elif idade >66:
  print("Você é um idoso.")

A idade é maior ou igual 18 anos ou pode ser menor que 65
Entenda o OR como tanto faz.
é maior que 18?
Ok passa.
é menor que 65?
Ok passa.
Por isso que mesmo a a idade sendo 70 e tendo o teste lógico para isso, ele não irá, pois cumpriu a condição.
Porem agora vamos para um código aonde o OR é usado de forma correta.

# Pedir ao usuário para inserir o dia e o mês de nascimento
dia = int(input("Digite o dia de nascimento (1-31): "))

# fatorando o código
## int é para dizermos que o dado digitado é um numero, se fosse numero com casa decimal deveria ser float
## input("Mensagem a ser mostrada na tela") esse comando permite escrever o que você espera

mes = int(input("Digite o mês de nascimento (1-12): "))

# Determinar o signo do zodíaco com base na data
if (mes == 3 and 21 <= dia <= 31) or (mes == 4 and 1 <= dia <= 19):
  signo = "Áries"

elif (mes == 4 and 20 <= dia <= 30) or (mes == 5 and 1 <= dia <= 20):
  signo = "Touro"

elif (mes == 5 and 21 <= dia <= 31) or (mes == 6 and 1 <= dia <= 20):
  signo = "Gêmeos"

elif (mes == 6 and 21 <= dia <= 30) or (mes == 7 and 1 <= dia <= 22):
  signo = "Câncer"

elif (mes == 7 and 23 <= dia <= 31) or (mes == 8 and 1 <= dia <= 22):
  signo = "Leão"

elif (mes == 8 and 23 <= dia <= 31) or (mes == 9 and 1 <= dia <= 22):
  signo = "Virgem"

elif (mes == 9 and 23 <= dia <= 30) or (mes == 10 and 1 <= dia <= 22):
  signo = "Libra"

elif (mes == 10 and 23 <= dia <= 31) or (mes == 11 and 1 <= dia <= 21):
  signo = "Escorpião"

elif (mes == 11 and 22 <= dia <= 30) or (mes == 12 and 1 <= dia <= 21):
  signo = "Sagitário"

elif (mes == 12 and 22 <= dia <= 31) or (mes == 1 and 1 <= dia <= 19):
  signo = "Capricórnio"

elif (mes == 1 and 20 <= dia <= 31) or (mes == 2 and 1 <= dia <= 18):
  signo = "Aquário"
else:
  signo = "Peixes"


# Exibir o signo do zodíaco
print(f"Seu signo do zodíaco é: {signo}")

No exemplo acima temos o uso perfeito do AND e OR.

Vamos supor 29 de maio

elif (mes == 5 and 21 <= dia <= 31) or (mes == 6 and 1 <= dia <= 20):

Usamos 2 condições pois as pessoas de gêmeos podem ser Gêmeos de (21 de maio a 20 de junho)
1 condição MES == 5
Sim está.
O dia está entre 21 a 31?
Sim está.
Mês é TRUE AND DIA É TRUE
Nesse caso nem precisamos testar a 2ª condição, pois a primeira já foi verdadeira.
Nesse momento que é útil o OR, pois eu espero que pelo menos 1 das 2 sejam verdadeiras.
Mas e se fosse de junho?
Vamos supor dia 10 de junho
(mes == 5 and 21 <= dia <=31)
False, pois mes não é 5 e sim 6
Já pode ignorar toda a condição pois temos a clausura AND, basta 1 item falso para ser negado a condição.
(mes == 6 and 1<= dia <=20)
True pois o mês é 6
o dia é 10 e estra em dentro do limite 1 a 20
Achamos a condição correta
Imprimimos a mensagem na tela

Expressões, são. Contas matemáticas, assim como, que o Python, resolve.

Por exemplo, 2 + 3, é uma instrução de expressão que resulta em 5. É como fazer uma soma.

resultado = 2 + 3

print(resultado)  # Isso vai mostrar 5 na tela

Código de Instruções de Atribuição

A atribuição é quando você dá um nome a um valor.

Por exemplo, idade = 10 atribui o valor 10 à variável "idade". É como etiquetar algo.

idade = 10
print(idade)  # Isso vai mostrar 10 na tela

Neste exemplo, a instrução while é nossa aliada. Repetimos a ação de imprimir o valor atual do contador enquanto o contador for menor que 5. Este comando fará a contagem de 0 a 4, como ordenado.

A disciplina é nossa força, e o while é nossa ferramenta para seguir ordens até que a missão seja cumprida.

contador = 0 # While não tem contador e nem incremento, então precisamos definir uma variavel fora da função

while contador < 5:
  print(contador)
  contador += 1 # Por não ter auto-incremento precisamos definir a regra.
                # contador += 1 é a mesma coisa que contador = contador+1
                # A vantagem é de reduzir código e ficar mais legivel

Verifica, tu deves, se a condição é verdadeira. Se a verdade for, o programa segue seu curso normal. Contudo, se a falsidade for, o Python, impiedosamente, interrompe sua execução e evoca uma exceção, a temível "AssertionError".

É como se o seu fiel assistente de construção dissesse: "Espere aí, algo está errado com esses blocos!".

Lembra-se, jovem aprendiz, que o poder das verificações é essencial para a segurança e a estabilidade do seu código.

assert 5 == 5 # Isso não mostra nada, porque está correto

Vantagens

Identificar erros no código mais rapidamente.
Verificação em tempo de execução.
Colegas de desenvolvimento e os testes agradecem.
É importante usar o "assert" com sabedoria. Geralmente, ele é mais adequado para verificar condições críticas que NUNCA deveriam ser falsas. Use-o com moderação para garantir que seu código seja confiável e seguro.

Função para calcular a média de uma lista de números

def calcular_media(numeros):
  # Verifica se a lista não está vazia
  assert len(numeros) > 0, "A lista de números não pode estar vazia"
  
  # Calcula a média
  soma = sum(numeros)
  media = soma / len(numeros)
  
  return media

# Lista de números
numeros = [10, 15, 20, 25, 30]

# Calcula a média e imprime o resultado
try:
  media = calcular_media(numeros)
  print(f"A média dos números é: {media}")
except AssertionError as e:
  print(f"Erro: {e}")

"Raaargh! O for em Python é como uma ferramenta muito útil que permite percorrer uma lista de coisas, uma por uma. Raaargh! É como quando estamos na Millennium Falcon e precisamos verificar todos os sistemas para garantir que eles estejam funcionando corretamente. Raaargh!

Então, imagine que você tem uma lista de amigos, raaargh. Com o for, você pode cumprimentar cada um deles individualmente, um após o outro, raaargh. É uma maneira eficiente de lidar com tarefas repetitivas e garantir que tudo seja coberto, raaargh!

O for funciona assim: você define uma coleção de coisas, como uma lista, raaargh. Então, para cada item na lista, o for executa um bloco de código específico, raaargh. É uma ótima maneira de automatizar tarefas e poupar tempo, raaargh!"

Bleep-boop! (Tradução: Pass é útil quando... zumbido ...não quer fazer nada. Bleep-bloop. Por exemplo, pode-se escrever pass quando... zumbido ...não tem código pronto.

O pass é útil quando... bip-bip ...está desenvolvendo código e... zumbido agudo ...ainda não tem a lógica pronta para... zumbido ...uma parte específica.

Ele age como um espaço reservado... bip-boop ...permitindo que escreva a estrutura geral... zumbido ...do código sem a implementação detalhada."

Vantagens

Isso é especialmente útil em situações em que você planeja voltar mais tarde e preencher o bloco com lógica real.
É importante ter cuidado ao usar o pass para não deixar partes importantes do código sem implementação.
Pode parecer obvio mas caso não se atente a corrigir futuramente poderá ocorrer:
Comportamentos inesperados
Erros mais tarde.
Use o pass temporariamente, como um lembrete de que algo precisa ser feito, e não esqueça de voltar para preencher a lógica quando estiver pronto.

lista_numeros = [1, 2, 3, 4, 5]

for numero in lista_numeros:
# o in é palavra em inglês que significa "em" ou seja numero em lista_numero, sim assim percorremos a lista.

  verificar_impar(numero)
  if numero == 1:
      print("1 não é primo")
  elif numero == 2:
      print("2 é primo")
  elif numero == 3:
      pass  # Aqui não fazemos nada, apenas seguimos adiante
  # Não sabemos como implementar o código.
  # Para não ocorrer atrasos ou para testar a aplicação, usamos o pass.
  # Assim o código prossegue.
  # Útil quando queremos ver o resultado ao aplicativo mas sem denvolver a lógica de uma parte
  # especifica
  
  elif numero == 4:
      print("4 não é  primo")
# Continuar com outras operações após o loop
print("Continuando com outras operações...")

Del é usado para apagar algo que não é mais necessário.

A instrução del em Python é uma ferramenta poderosa usada para extinguir uma referência a um objeto, algo que pode ser útil em certas circunstâncias. No entanto, ela deve ser manipulada com a devida precaução, assim como o Lado Negro da Força.

Aqui estão alguns momentos em que a instrução del pode se mostrar valiosa:

Libertação da Memória: Quando não existe mais utilidade para um objeto de considerável envergadura, tal como uma lista excessivamente longa ou uma estrutura de dados intricada, a aplicação de del concede a liberação do espaço de memória que antes ocupavam. O Python então, sem piedade, o recicla.

minha_lista = [1, 2, 3, 4, 5] 
del minha_lista  # Libera a memória ocupada por minha_lista

Eliminação de Elementos de Listas: Com o poder do del, você pode erradicar elementos específicos de uma lista. Nada escapará ao seu controle, e a lista será reconfigurada de acordo com sua vontade.

minha_lista = [1, 2, 3, 4, 5]
del minha_lista[2]  # Remove o elemento de índice 2 (o número 3)

Extinção de Variáveis Indesejadas: Em certas ocasiões, pode ser que deseje eliminar variáveis que perderam seu propósito em seu programa. Com o "del", essas variáveis serão erradicadas, deixando nenhum vestígio de sua existência.

variavel_temporaria = "Não preciso mais disso"
del variavel_temporaria

Se ousar tentar usar a variável após convocar o del, receberá o terrível erro conhecido como NameError, pois a variável não tem mais lugar neste mundo, nem mesmo uma sombra de sua existência.

Exemplo:

minha_variavel = 42
print(minha_variavel)  # Isso funciona bem e imprime 42

del minha_variavel
print(minha_variavel)  # Isso resultará em um erro NameError, pois a variável não existe mais

Em suma, a instrução del é poderosa, capaz de liberar memória e erradicar elementos específicos de listas. No entanto, sua utilização deve ser realizada com a máxima cautela, pois pode resultar em erros quando se tenta acessar uma variável após sua eliminação.

Se o seu desejo for "reiniciar" uma variável, é aconselhável atribuir-lhe um novo valor, em vez de recorrer ao del. O caminho da prudência é sábio, pois evita as armadilhas ocultas.

"A instrução del é um poder que concede controle absoluto, mas seu uso imprudente pode resultar em caos.

Domine-o com precisão, ou enfrente as consequências sombrias."

Grrrr-aaaaah! (Tradução: Esse é um padrão bem comum, quase toda função possui um return que permite à função devolver um dado.)

def dobrar(numero):
  return numero * 2

resultado = dobrar(5)
print(resultado)  # Isso mostra 10, o dobro de 5

Yield é uma técnica usada em funções especiais conhecidas como geradores. Esses geradores têm a habilidade de produzir valores um de cada vez, à medida que são necessários.

Agora, permita-me mostrar-lhe o caminho para criar um gerador que revela a misteriosa sequência de números Fibonacci, onde cada número é a soma dos dois anteriores (por exemplo, 0, 1, 1, 2, 3, 5, 8, 13, ...).

Aqui está como você pode manifestar essa magia usando yield de forma clara:

def gerar_fibonacci(maximo):
  a, b = 0, 1  # Inicializamos os dois primeiros números da sequência Fibonacci
  while a < maximo:
      yield a  # Produzimos o próximo número da sequência
      a, b = b, a + b  # Calculamos os próximos números da sequência

# Usando o gerador para obter os números de Fibonacci menores que 100
for numero in gerar_fibonacci(100):
  print(numero)

Este é um exemplo perfeito de como a técnica do yield pode ser utilizada para criar geradores eficientes. Vamos desvendar os mistérios do funcionamento deste código:

Inicializamos as variáveis "a" e "b" como 0 e 1.
Que representam os dois primeiros números na sequência de Fibonacci.
Entramos em um loop while que continua enquanto o valor de "a" for menor que o valor máximo especificado (100 neste caso).
Dentro do loop, utilizamos o yield a para produzir o valor atual de "a" como parte da sequência.
Isso permite que a sequência de Fibonacci seja gerada passo a passo, à medida que os valores são necessários.
Em seguida, atualizamos as variáveis "a" e "b" para os próximos números na sequência de Fibonacci.
"a" se torna "b"
"b" se torna a soma de "a" e "b".
Isso nos permite calcular os próximos números na sequência.
O loop continua produzindo números de Fibonacci até que "a" seja maior ou igual a 100, conforme especificado.

Quando você executa o código, ele imprimirá a sequência de números de Fibonacci menores que 100. O uso do yield permite que você produza esses números sob demanda, sem a necessidade de armazenar todos eles em memória de uma vez, tornando-o eficiente em termos de uso de recursos.

Que a sabedoria dos números Fibonacci esteja sempre ao seu lado!

Raise é usada para erros levantar, mmm.

Por exemplo, raise ValueError("Isso está errado") mostra um erro se algo está errado.

A instrução raise no Python é, usada para exceções levantar quando uma condição de erro ou situação excepcional no seu código ocorre. É, uma maneira de notificar que algo inesperado aconteceu e, adequada, permite que você erros maneje.

def dividir(a, b):
  if b == 0:
      raise ValueError("Não podemos dividir por zero!")
  return a / b

A função acima verifica, mmm, se b é igual a zero. Se b for zero, a função usa raise para levantar uma exceção do tipo ValueError com a mensagem "Não podemos dividir por zero!". Isso indica claramente que uma divisão por zero não é permitida e fornece uma mensagem de erro descritiva.

Aqui estão algumas situações em que a instrução raise é útil, jovem padawan:

Identificação de Erros Específicos:
O raise pode ser usado para indicar erros específicos no seu código, tornando mais fácil para os desenvolvedores entenderem o que deu errado.
No exemplo, usamos ValueError para indicar uma divisão por zero, mas você pode criar exceções personalizadas para casos mais complexos.
Gestão de Erros:
Quando você levanta uma exceção com raise, pode capturá-la (usando try e except) e lidar com o erro de maneira apropriada.
Isso permite que você tome medidas alternativas, registre erros ou forneça informações adicionais ao usuário, em vez de simplesmente permitir que o programa quebre.
Melhor Documentação:
O uso de exceções levantadas com raise ajuda a documentar seu código de maneira eficaz.
Outros desenvolvedores (ou você mesmo no futuro) podem entender as condições de erro e como lidar com elas.
Proteção de Integridade dos Dados:
Em casos onde uma operação pode afetar a integridade dos dados (por exemplo, em um banco de dados), você pode usar raise para garantir que a operação não seja realizada se algo estiver errado.

Portanto, a instrução raise não apenas torna as mensagens de erro mais claras, mas também desempenha um papel crucial na detecção e no tratamento de erros em seu código, tornando-o mais resistente e confiável. É uma prática recomendada em programação defensiva. Que a Força esteja com você em suas explorações em Python.

Break é usado para dar o fora de um loop, sabia? É como quando você está encurralado num labirinto, e de repente, você encontra a saída e sai em disparada. Essa é a jogada do break.

for i in range(5):# Percorre até o numero 5
if i == 3: 
  break # Isso faz com que o loop pare quando i é igual a 3 
print(i) # Isso mostra 0, 1, 2

O break é como a Millennium Falcon saindo da velocidade da luz. Podemos usá-lo quando uma condição é cumprida, seja um sucesso ou um erro.

Por exemplo, em um sistema de sorteio, ele continua sorteando até que o número escolhido finalmente saia.

Ou imagine que estamos navegando pelo menu de opções da Millennium Falcon. Quando finalmente selecionamos a opção de sair, o break nos permite sair imediatamente e encerrar o processo.

É a chave para escapar de situações quando precisamos seguir em frente, não importa se é para sair triunfante ou simplesmente para dar um passo para o lado.

Continue é como quando estamos em uma jornada, enfrentando um caminho difícil, e de repente, encontramos uma bifurcação. Uma placa aponta para a direita, e sabemos que é a direção certa.

Usamos o continue para seguir em frente, ignorando as distrações e obstáculos, e avançar para a próxima etapa da nossa jornada, que é como pular para a próxima volta de um loop. É a chave para manter o nosso caminho claro e avançar em direção ao nosso objetivo.

for i in range(5): 
if i == 2: continue # Isso faz com que o loop pule a vez quando i é igual a 2 
  print(i) # Isso mostra 0, 1, 3, 4

Vamos usar break e continue para controlar o fluxo, seguir em frente, e enfrentar os desafios com sabedoria, como os Jedi fazem.

while True:
  entrada = input("Digite um número positivo: ")  # Solicita ao usuário que insira um valor.
  numero = int(entrada)  # Converte a entrada em um número inteiro.

  if numero <= 0:  # Verifica se o número é menor ou igual a zero.
      print("Número inválido. Tente novamente.")  # Exibe uma mensagem de erro.
      continue  # O comando 'continue' faz o loop recomeçar, solicitando uma nova entrada.

  break  # Se o número for válido (maior que zero), sai do loop.

print(f"Você digitou um número positivo: {numero}")  # Exibe o número positivo inserido pelo usuário.

Se removermos o continue, cairemos no break que encerrará o código. No entanto, se não tivermos o break, o código continuará rodando.

Mas, lembre-se, há uma maneira de fazer isso sem usar o continue

while True:
  entrada = input("Digite um número positivo: ")  # Solicita ao usuário que insira um valor.
  numero = int(entrada)  # Converte a entrada em um número inteiro.

  if numero > 0:  # Verifica se o número é maior que zero.
      print("Número válido.\n")  # Exibe uma mensagem indicando que o número é válido.
      break  # Sai do loop, pois o número é válido.

  else:
      print("Número inválido.\n")  # Exibe uma mensagem de erro, pois o número não é válido.


print(f"Você digitou um número positivo: {numero}")  # Exibe o número positivo inserido pelo usuário.

Os dois códigos, mesmo considerando o cenário de desempenho, têm um impacto insignificante, mesmo com grandes volumes de dados, como o Big Data.

#FicaDica

A preocupação principal, jovem padawan, é a qualidade e a legibilidade do código. Elas são as bases de um verdadeiro mestre programador.

Bip-beep-boop! (Tradução: Import é usado para trazer coisas de outros lugares.

Existem muitos pacotes úteis em Python que já facilitam o trabalho e são otimizados. Não perca tempo reinventando a roda, jovem programador, mas sim, compreenda o conceito e utilize essas ferramentas sabiamente. Bip-boop!

import math # Isso traz funções matemáticas que podemos usar

raiz_quadrada = math.sqrt(16)

print(raiz_quadrada) # Isso mostra 4.0

#FicaDica

Aprender a calcular a raiz quadrada manualmente pode ajudá-lo a compreender como o código é elaborado, pois você pode fazê-lo no papel, com uma caneta, ou até mesmo mentalmente.

Agora, falando sobre a palavra-chave Global, ela é utilizada para tornar uma variável acessível em qualquer parte do código. É como compartilhar um brinquedo com todos, permitindo que todos possam brincar com ele em qualquer lugar do parquinho do código.

É uma maneira de garantir que todos os droides no parquinho do código possam interagir com essa variável, não importando onde estejam.

def minha_funcao():
  global variavel_compartilhada
  variavel_compartilhada = 42

minha_funcao()
print(variavel_compartilhada)  # Isso mostra 42

#FicaDica

Utilize variáveis globais apenas em situações de extrema necessidade, uma vez que elas podem tornar o código menos modular e mais difícil de entender. Imagine um programa com 5000 linhas de código, onde você tem uma variável global dentro de uma função? Isso certamente complicaria as coisas.

Quando precisar usar variáveis globais:

Armazene apenas informações que precisam ser compartilhadas em todo o programa e não podem ser facilmente passadas como argumentos.
Escolha nomes descritivos para as variáveis globais para tornar o propósito delas claro.
Isso melhora a legibilidade do código.
Forneça documentação clara sobre o uso, propósito e quaisquer regras que devem ser seguidas ao modificar variáveis globais em seu código.
A documentação é fundamental para garantir que outros desenvolvedores entendam e utilizem as variáveis globais adequadamente

Nonlocal é usado quando funções dentro de funções você tem. Como segredos compartilhados com sua família, mas não com os amigos.

Funções dentro de uma função são chamadas de:

Funções internas.
Funções aninhadas.
Funções locais.

Um exemplo simples para ilustrar:

# Exemplo simples
def externa(): contador = 0 

          def interna(): 
              nonlocal contador 
              contador += 1 
              print(contador) 
          return interna 

funcao = externa() 
funcao() # Isso mostra 1 
funcao() # Isso mostra 2

Em vez de ter um if-else ou qualquer outra estrutura que você possa imaginar, podemos usar funções dentro de funções, como no exemplo abaixo.

# Exemplo avançado

def estoque_inicial():
  estoque = 0

  def adicionar_item(qtd):
      nonlocal estoque
      estoque += qtd

  def vender_item(qtd):
      nonlocal estoque
      if estoque >= qtd:
          estoque -= qtd
          print(f"Vendido {qtd} item(s). Estoque restante: {estoque}")
      else:
          print("Estoque insuficiente.")


  def verificar_estoque():
      nonlocal estoque
      print(f"Estoque atual: {estoque}")

  return adicionar_item, vender_item, verificar_estoque


# Criar instância do controle de estoque
controle_estoque = estoque_inicial()

# Adicionar e verificar estoque
controle_estoque[0](20)  # Adiciona 20 itens ao estoque
controle_estoque[2]()     # Verifica o estoque atual

# Vender itens e verificar estoque
controle_estoque[1](10)  # Vende 10 itens
controle_estoque[2]()    # Verifica o estoque atual

Talvez você tenha adotado uma abordagem diferente e obtido o resultado esperado, o que levanta a questão: por que usar funções locais quando posso seguir o meu próprio caminho?

#FicaDica

Utilizar funções dentro de uma função (funções aninhadas) oferece várias vantagens em comparação com o uso de estruturas de controle, como if-else, match ou variáveis globais. Eis algumas das vantagens:

Encapsulamento e Modularidade:
Permitindo que você envolva a lógica relacionada em unidades autônomas e modulares.
As funções internas facilitam a compreensão e a manutenção do código, pois cada função interna realiza uma tarefa específica.
Reusabilidade:
Elas podem ser reutilizadas em várias partes do código.
Se você precisar realizar a mesma tarefa em diferentes lugares, basta chamar a função interna em vez de repetir o código.
Controle de Escopo:
Funções internas têm seu próprio escopo e não contaminam o escopo global com variáveis.
Isso ajuda a evitar conflitos de nomes de variáveis e facilita o gerenciamento do estado do programa.
Clareza e Legibilidade:
Funções aninhadas tornam o código mais claro e legível, especialmente quando você tem lógica complexa que pode ser dividida em partes menores e nomeadas.
Compartilhamento de Estado:
Elas podem compartilhar o estado comum usando argumentos e valores de retorno, em vez de depender de variáveis globais.
É uma prática geralmente mais segura e organizada.
Isolamento de Erros:
Funções internas podem isolar erros em partes específicas do código, facilitando a identificação e solução de problemas.
Privacidade de Função:
As funções internas não são visíveis fora da função pai.
O que significa que elas não poluem o espaço de nomes global, evitando conflitos de nomes de função com outras partes do código.
Evita Efeito Colateral:
Usar funções internas com variáveis locais reduz o risco de efeitos colaterais não intencionais.
Tornando o código mais previsível e seguro.
Melhora a Legibilidade:
Permite que você nomeie as partes do código de forma descritiva.
Tornando mais fácil entender o propósito de cada parte do código e melhorando a legibilidade geral.
Reutilização de Código:
Elas podem ser reutilizadas dentro da função pai ou em outras partes do código.
Promovendo a reutilização de código e reduzindo a duplicação.

Embora estruturas de controle, como if-else e match, possam ser usadas para realizar tarefas semelhantes, geralmente não proporcionam a mesma clareza, modularidade e facilidade de manutenção que as funções aninhadas.

Além disso, as funções aninhadas podem ser usadas em conjunto com estruturas de controle para criar códigos mais organizados e legíveis.

Resumindo, a vantagem de usar funções aninhadas está na organização do código, modularidade, clareza e facilidade de manutenção. Elas são especialmente úteis quando você precisa dividir a lógica em partes menores e reutilizáveis.

O uso de estruturas de controle não substitui completamente essa abordagem e geralmente é combinado com funções aninhadas para criar código mais eficiente e legível.

Jovem padawan, permita-me explicar o comando try e except com uma analogia digna da Força. Imagine que você é um cavaleiro Jedi, pronto para enfrentar desafios em seu treinamento. Você está prestes a atravessar um campo minado, onde cada mina representa um possível erro em seu código.

Aqui está o código como uma jornada épica:

try:
  # Este é o seu campo minado - o código que pode explodir em erros.
  navegar_no_campo_minado()

except ErroDeLadoNegro as e:
  # Este é o seu sabre de luz, preparado para lidar com os erros.
  use_o_sabre_de_luz(e)

except OutroErro as e:
  # Outro sabre de luz para outro tipo de erro.
  use_o_sabre_de_luz(e)

else:
  # Quando você passa pelo campo minado com sucesso.
  confiança_e_força()

finally:
  # Este é o seu escudo Jedi, sempre executado, não importa o que aconteça.
  mantenha_seu_escudo()

Aqui está como a analogia se aplica:

O 'try' é como você avança corajosamente no campo minado, pronto para enfrentar qualquer explosão.
Os 'except' são como seus sabres de luz, cada um especializado em lidar com um tipo de erro. Eles são ativados quando ocorre um erro específico.
O 'else' é o momento em que você navegou com sucesso pelo campo minado sem erros, confiante e forte.
O 'finally' é o seu escudo Jedi, que sempre será levantado, mesmo depois de enfrentar os desafios.

Abaixo tem o código que demonstra o uso do bloco try e except em conjunto com um loop while. O programa permite ao usuário realizar divisões entre dois números, com a capacidade de sair digitando o número místico 42.

def dividir(a, b):
  try:
      resultado = a / b
      return resultado
  except ZeroDivisionError:
      print("Erro: Divisão por zero não é permitida!")
      return None

while True:
  num1 = float(input("Digite o 1ª numero (digite 42 para sair): \n"))
  
  if num1 == 42:
      print("Esse é o numero que responde a pergunta sobre o que é a questão fundamental da vida, o universo e tudo mais")
      break
  
  num2 = float(input("Digite o 2ª numero: \n"))
  
  resultado = dividir(num1, num2)

  if resultado is not None:
      print(f"\nO resultado da divisão é: {resultado}\n")
  else:
      print("\nNão foi possível realizar a divisão.\n")

Definimos uma função dividir(a, b) que tenta realizar a divisão de a por b dentro de um bloco try.
Se a divisão for bem-sucedida, o resultado é retornado.
Se ocorrer uma exceção ZeroDivisionError, o bloco except é acionado, exibindo uma mensagem de erro.
Usamos um loop while True para criar um loop infinito.
Que continuará pedindo ao usuário para inserir números até que o número 42 seja inserido como numerador.
Pedimos ao usuário para inserir o numerador (num1) e verificamos se ele é igual a 42 para sair do programa.
Enquanto exibimos uma observação enigmática sobre o significado da vida, do universo e tudo mais.
Se o numerador não for 42, pedimos ao usuário para inserir o divisor (num2).
Chamamos a função dividir para realizar a divisão e exibimos o resultado ou uma mensagem de erro, conforme necessário.

Este programa demonstra como usar o try e except para lidar com exceções, permitindo que o programa continue a funcionar mesmo quando ocorrem erros, e como usar um loop para repetir uma tarefa até que uma condição seja atendida, neste caso, a saída com o número 42."

Lembre-se, jovem padawan, o try e except são suas ferramentas para lidar com erros e garantir que sua jornada de programação siga em frente, não importa quais obstáculos possam surgir."

A instrução match é, uma adição nova e poderosa ao Python, ela é. Correspondência de padrões, permite que você faça. Como um jedi, os padrões você define, e a força do Python, ela usa para ver se o padrão corresponde.

Em Python 3.10, essa funcionalidade foi introduzida. Com match, você pode fazer coincidir padrões em seu código de maneira clara e concisa. Um poderoso aliado na busca por informações específicas em seus dados, é.

Exemplo, vou dar:

def verificar_planeta(planeta):
  match planeta:
      case "Tatooine":
          print("Desértico, o planeta é.")
      case "Endor":
          print("Floresta, o planeta é.")
      case _:
          print("Nenhum padrão correspondido.")

planeta = "Tatooine"
verificar_planeta(planeta)

Neste exemplo, match usamos para verificar o planeta. Se o planeta for igual a "Tatooine", sabemos que encontramos um deserto. Se for "Endor", um planeta florestal é. Para outros casos, o 'caso padrão' _ usamos.

Com match, seu código mais legível e expressivo se tornará. Padrões você definirá, e o Python, a busca por eles realizará. Uma ferramenta valiosa para os cavaleiros Jedi do código é a instrução match."

"A jornada chegou ao fim, jovem padawan da programação. Que a Força esteja com você em seus futuros códigos e que a sabedoria da programação guie seus passos. Até o próximo material, que promete mais aventuras na galáxia do Python.

Este artigo foi uma colaboração entre jovem padawan Abilio, o mestre Felipe Aguiar e eu GPT. Esperamos que tenha sido uma leitura cativante, com uma abordagem descontraída ao estilo Star Wars. Se tiver feedback ou sugestões, não hesite em compartilhar. E que a programação seja sempre fascinante em sua jornada!"

Que a Força esteja com você! 🌟🚀

Curtiu esse conteúdo ? Ele foi gerador por inteligência artificial, mas foi revisado por alguém 100% Humano, e se quiser se conectar comigo, me siga no Linkedin.

Fontes de produção:

imagens geradas por: gerada pela lexica.art

Conteúdo gerado por: ChatGPT com revisões humanas

Imagem do Pixabay C-3PO by Gerhard Janson

Uso de cores com o auxilio da minha mãe Rose

Imperador Palpatine tipo de licensa: Atribuição-CompartilhaIgual 4.0 Internacional (CC BY-SA 4.0) da Creative Commons;

#PythonBeginner #CodingFun #LearnToCode