DEV Community: Luiz Braga

O que estudar Python me ensinou sobre lógica de programação

Luiz Braga — Fri, 04 Sep 2026 14:58:28 +0000

Quando comecei a estudar Python, pensei que aprender programação seria principalmente aprender comandos.

Variáveis, "if", "for", "while", funções, listas...

Com o tempo, percebi que essas coisas são apenas ferramentas.

O principal aprendizado estava acontecendo antes mesmo de escrever o código: eu estava começando a aprender como pensar em um problema de maneira lógica.

O código começa antes do código

Imagine que precisamos criar um programa simples que diga se um aluno foi aprovado.

Podemos escrever algo assim:

nota = 8

if nota >= 7:
print("Aprovado")
else:
print("Reprovado")

O código é pequeno.

Mas existe uma lógica por trás dele:

Existe uma informação de entrada: a nota.
Existe uma regra: notas maiores ou iguais a 7 representam aprovação.
Existe uma decisão.
Dependendo da decisão, o programa apresenta um resultado diferente.

Isso me fez perceber que o "if" não é apenas uma palavra reservada do Python.

Ele representa uma pergunta:

«Uma determinada condição é verdadeira?»

Se for, execute uma ação.

Caso contrário, execute outra.

Essa ideia aparece em praticamente qualquer sistema.

Programar é transformar regras em instruções

Outro exemplo:

idade = 20
tem_carteira = True

if idade >= 18 and tem_carteira:
print("Pode dirigir")
else:
print("Não pode dirigir")

Aqui existem duas condições.

Não basta ter 18 anos.

Também é necessário possuir uma carteira de habilitação.

Quando comecei a trabalhar com operadores como "and", "or" e "not", comecei também a perceber como regras do mundo real podem ser transformadas em expressões lógicas.

O computador não "entende" o que queremos.

Precisamos definir exatamente quais condições representam cada situação.

Loops me ensinaram a identificar padrões

Considere:

for numero in range(1, 6):
print(numero)

O resultado será:

1
2
3
4
5

É um exemplo simples, mas existe uma ideia importante nele.

Quando alguma tarefa precisa ser realizada várias vezes seguindo o mesmo padrão, provavelmente não precisamos escrever a mesma instrução repetidamente.

Podemos criar uma repetição.

Antes:

print(1)
print(2)
print(3)
print(4)
print(5)

Depois:

for numero in range(1, 6):
print(numero)

Python começou a me ensinar a procurar padrões dentro dos problemas.

Sempre que vejo algo se repetindo, começo a pensar:

"Será que isso pode virar um loop?"

Funções me ensinaram a dividir problemas

Outro aprendizado importante veio com funções.

def calcular_media(nota1, nota2):
return (nota1 + nota2) / 2

Em vez de colocar todo o comportamento do programa em um único lugar, podemos separar responsabilidades.

Uma função pode receber informações, executar uma tarefa específica e devolver um resultado.

Isso mudou bastante a maneira como comecei a enxergar problemas maiores.

Suponha que precisamos criar um sistema escolar.

Pensar no sistema inteiro de uma vez pode parecer complicado.

Mas podemos dividir:

cadastrar aluno;
cadastrar professor;
registrar notas;
calcular médias;
verificar aprovação;
exibir informações.

Cada problema menor pode virar uma parte do programa.

E várias partes menores podem formar um sistema maior.

Aprendi que resolver o problema vem antes de escolher a sintaxe

Às vezes sabemos a sintaxe de Python, mas mesmo assim ficamos olhando para a tela sem saber como começar.

Comecei a perceber que, nesses casos, o problema muitas vezes não é Python.

É a lógica.

Uma técnica que comecei a considerar útil é escrever o problema em português antes de programar.

Por exemplo:

«Quero descobrir o maior número de uma lista.»

Posso pensar:

Pegar um número inicial como maior.
Comparar os outros números com ele.
Se encontrar um número maior, atualizar o valor.
Continuar até terminar a lista.
Mostrar o maior número encontrado.

Só depois podemos transformar isso em Python:

numeros = [4, 9, 2, 15, 7]

maior = numeros[0]

for numero in numeros:
if numero > maior:
maior = numero

print(maior)

A sintaxe apenas representa uma solução que já havia sido organizada logicamente.

Bugs também ensinam lógica

Uma parte inevitável de estudar programação é encontrar erros.

No começo, um erro parece simplesmente significar:

"Meu código não funciona."

Depois comecei a enxergar de outra forma.

Um bug geralmente significa que existe uma diferença entre:

aquilo que eu queria que acontecesse;
aquilo que minha lógica determinou;
e aquilo que o computador realmente executou.

Por isso, debugar também é um exercício de raciocínio.

Precisamos perguntar:

Qual valor essa variável possui agora?
Essa condição realmente será verdadeira?
Quantas vezes esse loop será executado?
Essa função está retornando aquilo que eu esperava?
Em que ponto o comportamento começa a ficar diferente do esperado?

Essas perguntas ajudam muito mais do que simplesmente modificar linhas aleatoriamente até o programa funcionar.

O maior aprendizado até agora

Python tem uma sintaxe relativamente simples, o que permite dedicar mais atenção ao raciocínio por trás do programa.

E talvez essa seja uma das coisas mais importantes que estudar Python está me ensinando.

Programação não é apenas escrever código.

É pegar um problema e transformá-lo em etapas suficientemente claras para que um computador consiga executá-las.

Hoje, quando encontro um exercício novo, tento não começar perguntando:

«"Qual código eu preciso escrever?"»

Primeiro tento perguntar:

«"Qual é a lógica necessária para resolver esse problema?"»

Porque, quando a lógica está clara, escrever o código geralmente se torna muito mais fácil.

Ainda estou no começo da minha jornada com programação, mas essa mudança na forma de pensar provavelmente será útil muito além de Python.

As linguagens podem mudar.

A lógica continua.

Do zero ao primeiro passo na programação: o que aprendi estudando Python

Luiz Braga — Sat, 29 Aug 2026 19:55:10 +0000

Começar a estudar programação do zero pode ser intimidador.

Antes de começar a aprender de forma estruturada, eu tinha uma visão relativamente simples sobre programação: imaginava que programar era aprender comandos, escrever códigos e fazer programas funcionarem. Depois dos primeiros estudos, percebi que a realidade é um pouco diferente.

Programar não é apenas conhecer uma linguagem. É aprender a analisar problemas, organizar informações e construir soluções passo a passo.

Neste artigo, quero compartilhar como foi meu primeiro contato estruturado com Python, algumas dificuldades que encontrei e os principais aprendizados que tive durante esse início.

Por que comecei a estudar programação

Escolhi a área de tecnologia porque quero construir uma carreira em Ciência da Computação e entender melhor como os sistemas e tecnologias que usamos todos os dias funcionam.

Dentro dessa jornada, tenho interesse em áreas como desenvolvimento de software, backend, dados e, futuramente, Machine Learning.

Mas antes de chegar a assuntos mais avançados, percebi que precisava começar pela base.

Python foi uma escolha interessante para esse início porque possui uma sintaxe relativamente simples e é utilizada em diferentes áreas da tecnologia, desde desenvolvimento web até automação, análise de dados e inteligência artificial.

Mesmo assim, aprender uma linguagem não significa apenas conhecer sua sintaxe. Era necessário desenvolver algo que eu ainda não tinha experiência: lógica de programação.

Meu primeiro contato estruturado com Python

Comecei estudando os conceitos fundamentais da linguagem.

Alguns dos primeiros assuntos foram:

Variáveis
Tipos de dados
Entrada de dados com input()
Conversão de valores com int() e float()
Saída de dados com print()
Operadores matemáticos
Estruturas condicionais com if, elif e else
Estruturas de repetição
Manipulação básica de strings

No começo, muitos desses conceitos pareciam independentes. Eu conseguia entender o que cada comando fazia isoladamente, mas ainda precisava aprender a combiná-los para resolver problemas.

Por exemplo, aprender que uma variável pode armazenar um valor é simples:

idade = 19

Mas depois surge uma pergunta mais importante: como usar essa informação para tomar uma decisão?

idade = 19

if idade >= 18:
    print("Maior de idade")
else:
    print("Menor de idade")

Nesse momento, comecei a perceber que programação funciona como uma sequência de decisões e instruções.

O computador não entende o que queremos apenas porque explicamos um problema. Precisamos transformar esse problema em etapas claras.

As dificuldades que encontrei

Uma das principais dificuldades no início foi entender a lógica por trás do código.

Às vezes, eu conseguia acompanhar uma explicação e entender o resultado final, mas quando precisava começar um exercício sozinho, surgia a pergunta:

"Por onde eu começo?"

Essa foi uma das primeiras lições importantes.

Saber os comandos não é suficiente. É necessário entender o problema antes de tentar escrever o código.

Outra dificuldade foi encontrar conceitos que pareciam pequenos, mas tinham uma função importante.

Por exemplo, operadores, formatação de textos, conversão de tipos e estruturas condicionais podem parecer detalhes isolados. Porém, quando começamos a criar programas um pouco maiores, percebemos que esses elementos precisam trabalhar juntos.

Também percebi que é normal não entender um conceito imediatamente.

Em programação, muitas vezes um assunto só começa a fazer sentido depois que você o utiliza várias vezes em situações diferentes.

O que comecei a aprender sobre lógica de programação

A principal mudança no meu aprendizado não foi apenas aprender Python.

Foi começar a pensar em problemas de uma forma diferente.

Quando aparece uma tarefa, em vez de procurar imediatamente por um código pronto, comecei a tentar dividir o problema.

Por exemplo:

Quais informações eu preciso receber?
Quais dados preciso armazenar?
Existe algum cálculo?
Preciso tomar uma decisão?
O programa precisa repetir alguma ação?
Qual resultado deve ser mostrado?

Essa forma de pensar transforma um problema grande em várias partes menores.

Por exemplo, imagine um programa simples que recebe duas notas e informa se uma pessoa foi aprovada.

Antes de escrever qualquer código, podemos pensar:

Precisamos receber duas notas.
Precisamos calcular a média.
Precisamos comparar a média com uma condição.
Precisamos mostrar o resultado.

Depois disso, o código se torna uma consequência da lógica:

nota1 = float(input("Digite a primeira nota: "))
nota2 = float(input("Digite a segunda nota: "))

media = (nota1 + nota2) / 2

if media >= 7:
    print("Aprovado")
else:
    print("Reprovado")

Ainda estou no início desse processo, mas esse tipo de raciocínio foi uma das mudanças mais importantes que percebi.

Por que a prática é tão importante

Uma coisa que percebi rapidamente é que assistir aulas não é suficiente.

Uma aula pode fazer um conceito parecer simples. Mas a verdadeira dificuldade aparece quando você fecha a aula e tenta resolver um problema sozinho.

É nesse momento que surgem perguntas como:

Qual variável eu preciso criar?
Qual tipo de dado devo usar?
Preciso de uma condição?
Preciso repetir alguma operação?
Por que meu código está dando um resultado diferente do esperado?

E, principalmente:

Como corrigir um erro?

A prática não serve apenas para repetir o que foi ensinado.

Ela serve para descobrir o que você realmente entendeu.

Quando consigo resolver um problema sozinho, mesmo que o código não fique perfeito, isso mostra que comecei a transformar o conhecimento teórico em raciocínio prático.

Também comecei a entender que errar faz parte do processo.

Um erro no código não significa necessariamente que eu não sei programar. Muitas vezes, significa apenas que existe alguma parte da lógica que preciso revisar.

O que Python está me ensinando além de Python

Mesmo estando nos primeiros passos, percebi que estudar programação envolve habilidades que vão além de aprender uma linguagem.

Estou aprendendo a:

Dividir problemas complexos em partes menores.
Ler e interpretar erros.
Ter mais paciência durante a resolução de problemas.
Testar diferentes soluções.
Revisar conceitos quando algo não está claro.
Evitar tentar memorizar tudo sem entender o contexto.

Essas habilidades provavelmente serão úteis independentemente da linguagem ou área que eu escolher no futuro.

A linguagem pode mudar, mas a necessidade de entender problemas e construir soluções continua.

Meus próximos passos

Finalizar essa primeira etapa com Python não significa que o aprendizado terminou.

Na verdade, significa que agora tenho uma base para continuar avançando.

Meus próximos passos envolvem continuar fortalecendo meus conhecimentos em programação e lógica, além de aprender ferramentas importantes para o desenvolvimento de software, como Git e GitHub.

Também quero continuar explorando áreas da tecnologia enquanto avanço na faculdade e construo experiência prática.

No longo prazo, tenho interesse em desenvolvimento backend, dados e Machine Learning. Mas aprendi que não adianta tentar pular diretamente para as partes mais avançadas sem construir uma base sólida.

Por enquanto, meu foco é continuar aprendendo um passo de cada vez.

Conclusão

Começar a aprender programação foi menos sobre descobrir uma linguagem e mais sobre começar a desenvolver uma nova forma de pensar.

Python foi meu primeiro contato estruturado com esse processo. Durante os estudos, encontrei dificuldades, erros e momentos em que precisei voltar para revisar conceitos.

Mas isso também me mostrou algo importante: aprender programação não é uma corrida para saber tudo.

É um processo de construir conhecimento gradualmente.

Ainda estou no início da jornada, mas já consigo perceber uma diferença entre apenas olhar para um problema e começar a pensar:

Como eu poderia transformar isso em uma solução?

Para mim, esse foi o primeiro passo real na programação.

HI!

Luiz Braga — Thu, 20 Aug 2026 11:06:51 +0000

i'm Computer Science student. i'm from Brazil, learning Python, HTML, CSS3 and Git/GitHub. i study at Centro Universitário de João Pessoa (UNIPÊ). i'm looking for Software Enginner, Back-End or Data level entry