Conceitos Importantes em Python que Todo Programador Precisa Saber

Você quer se tornar um programador em Python? Então, conheça quais são os conceitos importantes em Python que todo programador precisa saber!

Caso prefira esse conteúdo no formato de vídeo-aula, assista ao vídeo abaixo ou acesse o nosso canal do YouTube!

Conceitos Importantes em Python que Todo Programador Precisa Saber

Python é uma das linguagens de programação mais utilizadas por sua simplicidade e versatilidade. No entanto, para dominar Python, é importante entender alguns conceitos fundamentais.

Nesta aula, vou te mostrar quatro conceitos essenciais em Python que todo programador precisa saber.

Falaremos sobre objetos, tipos de parâmetros e argumentos em funções, estruturas de dados mutáveis e imutáveis, e a estrutura if __name__ == “__main__”.

Os quatro conceitos que sustentam o Python são: tudo é objeto, ou seja, variáveis, strings e funções têm métodos e atributos; os tipos de parâmetros em funções (posicionais, nomeados, padrão, *args e **kwargs); a diferença entre dados mutáveis e imutáveis; e a estrutura if __name__ == “__main__”, que define o que roda ao executar o arquivo direto.

Tudo em Python é um Objeto

Em Python, tudo é um objeto! Isso significa que cada elemento em Python, como variáveis, strings, números, listas, dicionários, e até mesmo funções, é um objeto Python com atributos e métodos associados a ele.

As classes em Python são modelos que definem o tipo de um objeto e especificam quais atributos e métodos ele possui.

Por exemplo, uma string é um objeto da classe str. Isso nos permite usar métodos específicos para manipular strings, como o método .capitalize().

nome = "lira"
print(nome.capitalize())

Isso também se aplica a bibliotecas. Quando importamos uma biblioteca como Pandas, podemos utilizar seus métodos da mesma forma.

import pandas as pd
pd.read_csv()

Esse conceito é fundamental para entender a orientação a objetos em Python, permitindo-nos acessar métodos e atributos de qualquer objeto usando a notação objeto.método ou objeto.atributo, como vimos com o .capitalize().

Isso nos permite realizar operações mais complexas com facilidade, apenas acessando um método ou atributo de um objeto.

Essa também é a base para a orientação a objetos em Python, onde podemos definir nossos próprios objetos personalizados e manipulá-los conforme necessário.

Para saber mais sobre Programação Orientada a Objetos, veja: Orientação a Objetos em Python – O que é?

Tipos de Parâmetros e Argumentos em Funções

Outro conceito importante em Python é a flexibilidade dos tipos de parâmetros e argumentos que podemos definir e passar para as funções.

As funções ajudam a organizar e reutilizar blocos de código que executam tarefas específicas, facilitando a manutenção e o gerenciamento do código.

Ao construir uma função, podemos definir os parâmetros necessários para seu funcionamento.

Parâmetros são as variáveis listadas no cabeçalho da função. Quando chamamos essa função, passamos argumentos, que são os valores atribuídos aos parâmetros durante a execução.

Uma função pode ou não precisar de parâmetros, dependendo do seu propósito.

Existem cinco tipos principais de parâmetros e argumentos que podemos utilizar: posicionais (positional), nomeados ou de palavra-chave (keyword), padrão (default), variáveis (*args), e palavras-chave variáveis (**kwargs).

Parâmetros Posicionais: Positional Parameters – Positional Arguments

Os parâmetros posicionais são os mais comuns. Nesse tipo de parâmetro, a ordem dos argumentos é crucial para o funcionamento correto da função.

Vamos definir uma função para calcular o imposto. Caso a taxa de imposto seja maior que 100%, a função retornará uma mensagem de erro.

def calcular_imposto(faturamento, taxa_imposto):
    if taxa_imposto > 1:
        return "Impossível, imposto é maior do que 100%"
    return faturamento * taxa_imposto

Note que, ao chamar a função, devemos passar os argumentos na mesma ordem em que os parâmetros foram definidos. Caso contrário, a função não funcionará como o esperado.

Argumentos na ordem correta:

print(calcular_imposto(1000, 0.3))

Argumentos na ordem incorreta:

print(calcular_imposto(0.3, 1000))

Parâmetros Nomeados: Keyword Parameters – Keyword Arguments:

Os parâmetros nomeados permitem passar argumentos especificando explicitamente o nome do parâmetro, o que nos dá flexibilidade para alterar a ordem em que os argumentos são fornecidos.

Vamos usar a função calcular_imposto como exemplo, passando os argumentos nomeados (keyword arguments).

print(calcular_imposto(taxa_imposto=0.2, faturamento=2500))

Também podemos misturar argumentos posicionais e nomeados, mas os posicionais devem sempre vir antes dos nomeados. Por exemplo:

print(calcular_imposto(2500, taxa_imposto=0.3))

Entretanto, não podemos inverter essa ordem:

print(calcular_imposto(faturamento=2500, 0.3))

Nesse caso, ocorre um erro de sintaxe SyntaxError, já que os argumentos posicionais não podem vir depois dos argumentos nomeados.

Parâmetros Padrão: Default Parameters – Default Arguments:

Python permite definir valores padrão para os parâmetros. Se um argumento não for passado na chamada da função, o valor padrão será usado.

Veja o exemplo abaixo, onde definimos um valor padrão de 0.2 para o parâmetro taxa_imposto.

def calcular_imposto(faturamento, taxa_imposto=0.2):
    if taxa_imposto > 1:
        return "Impossível, imposto é maior do que 100%"
    return faturamento * taxa_imposto

Aqui, se você não passar o argumento taxa_imposto, o valor padrão de 0.2 será utilizado.

print(calcular_imposto(2000))

Uma característica importante dos parâmetros padrão é que eles podem ser tratados como parâmetros nomeados, o que permite alterar a ordem em que eles são passados durante a chamada da função.

Vamos expandir nossa função para incluir um parâmetro desconto, também com um valor padrão.

def calcular_imposto(faturamento, taxa_imposto=0.2, desconto=0.1):
    if taxa_imposto > 1:
        return "Impossível, imposto é maior do que 100%"
    return faturamento * (taxa_imposto - desconto)

Agora, tanto taxa_imposto quanto desconto têm valores padrão, permitindo que você escolha quais argumentos deseja passar ao chamar a função.

Chamando a função com apenas o argumento de posição:

print(calcular_imposto(1000))

Chamando a função com argumentos nomeados e alterando a ordem dos parâmetros:

print(calcular_imposto(1000, desconto=0.2, taxa_imposto=0.4))

Dessa forma, a função se torna mais flexível ao lidar com valores padrão, permitindo que você omita ou sobrescreva argumentos conforme necessário.

Parâmetros Variáveis: *args e **kwargs:

Os parâmetros *args e **kwargs são usados quando não sabemos exatamente quantos argumentos serão passados para a função. Eles permitem que uma função receba múltiplos parâmetros sem precisar especificá-los de forma explícita.

A diferença entre os dois está no tipo de argumentos que aceitam:

• *args aceita múltiplos argumentos posicionais.
• **kwargs aceita múltiplos argumentos nomeados (ou de palavra-chave).

*args: Múltiplos Argumentos Posicionais

Usamos o parâmetro *args quando queremos que a função possa receber uma quantidade indefinida de argumentos posicionais. Esses argumentos são armazenados em uma tupla, o que permite iterar sobre eles ou acessá-los por índice.

Por exemplo, se tivermos várias taxas de imposto, podemos usar *args para lidar com todas elas.

def calcular_imposto(faturamento, *args):
    taxa_imposto = 0
    for imposto in args:
        taxa_imposto += imposto
    if taxa_imposto > 1:
        return "Impossível, imposto é maior do que 100%"
    return faturamento * taxa_imposto

Aqui, *args permite que a função receba várias taxas de imposto. A função itera sobre elas e as soma para calcular o total.

Assim, quando chamamos essa função podemos passar quantas taxas forem necessárias para o cálculo final, respeitando a posição dos argumentos: primeiro o faturamento e depois as taxas de impostos.

print(calcular_imposto(1000, 0.2, 0.3, 0.05))

Aqui, a função soma as taxas de 0.2, 0.3 e 0.05, resultando em um total de 0.55, que é aplicado ao faturamento de 1000.

**kwargs: Múltiplos Argumentos Nomeados

Semelhante ao *args, o **kwargs permite que uma função receba múltiplos argumentos nomeados. Esses argumentos são armazenados em um dicionário, acessíveis por suas chaves (nomes dos parâmetros)

Dessa forma é possível usar os kwargs para modificar ou atribuir outras funcionalidades dentro da função.

Podemos modificar nossa função para incluir um desconto como argumento nomeado:

def calcular_imposto(faturamento, taxa_imposto, **kwargs):
    if "desconto" in kwargs:
        taxa_imposto -= kwargs["desconto"]
    return faturamento * taxa_imposto

Aqui, a função verifica se o argumento desconto foi passado. Se foi, o desconto é subtraído da taxa de imposto.

print(calcular_imposto(7000, 0.25, desconto=0.15))

Caso o desconto não seja passado, a função aplica a taxa de imposto normalmente.

print(calcular_imposto(7000, 0.25))

Também é possível combinar o uso de *args e **kwargs na mesma função. Para saber mais, veja nossa aula: Args e Kwargs em Python – Aprenda de Uma Vez por Todas

Estruturas de Dados Mutáveis e Imutáveis

O terceiro conceito essencial em Python que você precisa dominar é a diferença entre estruturas de dados mutáveis e imutáveis.

Estruturas de dados imutáveis são aquelas que não podem ter seu valor original modificado após a criação. Exemplos de objetos imutáveis incluem strings, tuplas e números (int ou float).

Qualquer tentativa de modificar diretamente esses objetos resultará em um erro (para strings e tuplas) ou criará um novo objeto (para números).

nome = "lira"
nome[0] = "b"
print(nome)

Quando usamos o método capitalize(), por exemplo, em uma string, conseguimos exibir a string com a primeira letra maiúscula, mas a string original permanece imutável.

nome = "lira"
print(nome.capitalize())
print(nome)

Para “modificar” um objeto imutável, criamos um novo objeto através da reatribuição da variável, o que cria uma nova versão da variável armazenando o novo objeto.

nome = "lira"
nome = nome.capitalize()
print(nome)

Na prática, o Python cria um novo objeto string com o resultado do método capitalize() e o armazena na variável nome. A string original “lira” permanece imutável na memória.

Estruturas de dados mutáveis, por outro lado, são aquelas que podem ser alteradas após sua criação. Isso inclui listas e dicionários em Python. Por exemplo, você pode modificar ou adicionar itens a uma lista sem problemas.

salarios = [1000, 1500, 2000]
salarios[0] = 1300
salarios.append(5000)
print(salarios)

Um ponto de atenção ao trabalhar com objetos mutáveis é que, ao criar uma referência a um objeto mutável, como uma lista, qualquer alteração feita em uma das referências afetará todas as outras. Veja o exemplo:

lista1 = [1000, 2000]
lista2 = lista1

lista2.append(3000)

print("Lista 1:", lista1)
print("Lista 2:", lista2)

Isso ocorre porque ambos os objetos (lista1 e lista2) apontam para o mesmo local na memória. Para evitar isso, podemos usar o método copy() para criar uma cópia do objeto.

lista1 = [1000, 2000]
lista2 = lista1.copy()

lista2.append(3000)

print("Lista 1:", lista1)
print("Lista 2:", lista2)

Com objetos imutáveis, isso não é um problema:

tupla1 = (1000, 2000)
tupla2 = tupla1

tupla2 = (1000, 2000, 3000)

print("Tupla 1:", tupla1)
print("Tupla 2:", tupla2)

Objetos Mutáveis e Imutáveis em Funções:

É importante entender como objetos mutáveis e imutáveis se comportam quando passados para funções.

Quando um objeto mutável, como uma lista, é passado para uma função, qualquer modificação feita nesse objeto dentro da função é refletida fora dela, pois a função manipula diretamente o objeto original.

def multiplicar_salarios(lista_salarios, fator):
    for i, salario in enumerate(lista_salarios):
        lista_salarios[i] = salario * fator

salarios = [1000, 1500, 2000]
print("Antes da função:", salarios)
multiplicar_salarios(salarios, 2)
print("Depois da função:", salarios)

Se você executar essa função novamente, ela considerará a lista já modificada pela primeira chamada.

multiplicar_salarios(salarios, 3)
print("Depois da 2ª chamada da função:", salarios)

Para manter os dados originais inalterados, você pode usar uma cópia da lista dentro da função ou um objeto imutável como uma tupla.

Com tuplas, você precisa criar uma nova tupla com os valores modificados, que será retornada pela função.

def multiplicar_salarios(tupla_salarios, fator):
    nova_tupla = tuple(salario * fator for salario in tupla_salarios)
    return nova_tupla

Ao chamar a função, a tupla original salarios permanece inalterada. Para exibir a nova tupla com os valores modificados, é necessário atribuir o retorno da função multiplicar_salarios a uma nova variável.

salarios = (1000, 1500, 2000)
print("Antes da função:", salarios)
novos_salarios = multiplicar_salarios(salarios, 2)
print("Salários depois da função:", salarios)
print("Novos salários depois da função:", novos_salarios)

A tupla salarios original só seria “modificada” através do processo de reatribuição.

def multiplicar_salarios(tupla_salarios, fator):
    nova_tupla = tuple(salario * fator for salario in tupla_salarios)
    return nova_tupla
salarios = (1000, 1500, 2000)
salarios = multiplicar_salarios(salarios, 2)
print(salarios)

Estrutura if __name__ == “__main__”

O quarto e último conceito fundamental que vamos abordar nesta aula é a estrutura if __name__ == “__main__”.

Caso prefira esse conteúdo no formato de vídeo-aula, assista ao vídeo abaixo ou acesse o nosso canal do YouTube!

Python Impressionador

Você vai aprender a linguagem de Programação que mais cresce no Mundo para fazer automações incríveis, desenvolver sites, fazer análises de dados, trabalhar com Ciência de Dados, Inteligência Artificial, mesmo que você nunca tenha tido nenhum contato com Programação na vida.

Começar agora

O que você aprende neste vídeo

Resposta rápida: A aula fecha três conceitos de Python: por que listas são mutáveis mas tuplas, strings e números não (var = valor recria a variável; só um método como .append() edita no lugar); a diferença entre argumento posicional, de palavra-chave e opcional numa função; e o papel do bloco if __name__ == "__main__": ao importar um arquivo.

Neste vídeo (24 min):

• 1:15 - Criação da variável faturamento = 1500: o Python decide o tipo sozinho pelo valor atribuído (inteiro, float ou string)
• 3:05 - Reatribuir com faturamento = faturamento * 2 não edita a variável: ela é recriada com o novo valor, por isso inteiros, floats e strings são imutáveis
• 5:00 - Comparação entre tupla e lista com os mesmos valores: t_vendas[0] = 275 dá erro porque a tupla é imutável, e o mesmo comando na lista funciona
• 7:20 - Um .replace() numa string só funciona se o resultado for reatribuído à variável; sozinho, ele não altera o texto original
• 8:50 - Já l_vendas.append(1500) edita a lista original direto, sem precisar de reatribuição: é o sinal de que aquele item é mutável
• 11:15 - Segundo conceito: uma função sem parâmetro, como calcular_imposto(), sempre roda igual; parâmetros permitem passar preço e taxa
• 13:10 - Argumentos posicionais têm que respeitar a ordem da criação da função: trocar preço e taxa de lugar não dá erro, mas calcula errado
• 15:00 - Argumentos de palavra-chave (taxa=0.2, preco=1500) resolvem a ordem, mas um argumento posicional não pode vir depois de um argumento nomeado
• 17:00 - Um valor padrão no parâmetro (=None) o torna opcional: a função roda mesmo sem que ele seja passado
• 18:50 - Terceiro conceito: ao importar um arquivo Python, o interpretador executa o arquivo inteiro de cima a baixo, inclusive testes soltos no meio do código
• 21:00 - O bloco if __name__ == "__main__": só roda quando o arquivo é executado diretamente, nunca quando é importado por outro arquivo

Trechos do vídeo:

• Toda vez que você escreve variável = valor, você não está editando a variável, está recriando ela e substituindo o valor: é por isso que inteiros, floats, strings e tuplas contam como imutáveis
• Um comando que edita o item original direto na linha, sem reatribuição, como lista.append(x), é sinal de que aquele tipo é mutável; quando precisa reatribuir para valer, é imutável
• Argumento de palavra-chave nunca pode vir antes de um argumento posicional na chamada da função: a ordem certa é primeiro os posicionais, depois os nomeados
• O bloco if __name__ == "__main__": só executa quando o arquivo roda diretamente; ao ser importado por outro código, essa parte fica de fora

Para receber por e-mail o(s) arquivo(s) utilizados na aula, preencha:

Não vamos te encaminhar nenhum tipo de SPAM! A Hashtag Treinamentos é uma empresa preocupada com a proteção de seus dados e realiza o tratamento de acordo com a Lei Geral de Proteção de Dados (Lei n. 13.709/18). Qualquer dúvida, nos contate.

A variável especial __name__ é utilizada para determinar se um arquivo Python está sendo executado diretamente ou se está sendo importado por outro código.

Se o arquivo estiver sendo executado diretamente, o código dentro do bloco condicional if __name__ == “__main__”: será executado; caso contrário, esse código não será executado.

Vamos ver um exemplo prático. Considere o seguinte código no arquivo chamado imposto.py.

def calcular_imposto(valor, taxa):
    imposto = valor * taxa
    return imposto
if __name__ == "__main__":
    print(calcular_imposto(1000, 0.2))

Quando você executa esse código diretamente no arquivo imposto.py, o print da função calcular_imposto será exibido.

No entanto, se você importar esse código para outro arquivo Python, como um arquivo main.py, o print não será executado, e você terá acesso à função calcular_imposto normalmente.

import imposto
print("Vamos calcular o imposto!")
print(imposto.calcular_imposto(1000, 0.5))

Se não houvesse a estrutura if __name__ == “__main__”:, o print no arquivo imposto.py também seria exibido ao executar o main.py, o que não é desejável. Veja como ficaria sem a estrutura if __name__ == “__main__”:.

Arquivo imposto.py:

def calcular_imposto(valor, taxa):
    imposto = valor * taxa
    return imposto
print(calcular_imposto(1000, 0.2))

Arquivo main.py:

import imposto
print("Vamos calcular o imposto!")
print(imposto.calcular_imposto(1000, 0.5))

Essa estrutura é muito útil para importar um script Python como módulo em outro arquivo, separando o que pode e o que não pode ser executado quando o arquivo é importado. Isso é especialmente importante para testes dentro do script.

Para saber mais a fundo sobre o uso dessa estrutura, confira a nossa aula: if name main no Python, o que Significa Isso?

Perguntas frequentes

Conclusão – Conceitos Importantes em Python que Todo Programador Precisa Saber

Esses são conceitos importantes em Python que todo programador precisa saber e dominar. São fundamentais para que você possa compreender melhor essa linguagem de programação e se tornar um programador profissional.

Compreender cada um deles permitirá que você escreva códigos mais eficientes, reutilizáveis, claros e bem estruturados. Dedique tempo e estudo para entender esses conceitos a fundo.

Se você deseja se aprofundar ainda mais em Python e construir projetos reais voltados para o mercado de trabalho, confira o nosso Curso Completo Python Impressionador!

Hashtag Treinamentos

Para acessar outras publicações de Python, clique aqui!

Posts mais recentes de Python

• 
  Curso Básico de Python: Saia do Zero em 10 Aulas Grátis18 de setembro de 2026
  Aprenda com o curso básico de Python gratuito da Hashtag: 10 aulas práticas, exercícios e projetos reais para sair do zero em programação.
• 
  Agentes RAG com Python: como criar um assistente de IA17 de setembro de 2026
  Aprenda a criar Agentes RAG com Python do zero: LangChain, FAISS e OpenAI para montar um assistente de IA que responde com base nos seus documentos.
• 
  25 Tipos de Gráficos em Python: Guia Completo com Código26 de agosto de 2026
  Aprenda a criar os principais tipos de gráficos em Python com Plotly: barras, pizza, mapas e mais, com código pronto para copiar e usar.

Posts mais recentes da Hashtag Treinamentos

• 
  Planilha de Controle de Notas Fiscais no Excel [Grátis]2 de outubro de 2026
  Baixe a planilha de controle de notas fiscais no Excel grátis: calcule ISS e retenções, veja o que está em aberto e gere a cobrança de cada nota de serviço.
• 
  Qual IA usar na empresa: ChatGPT, Claude ou Perplexity?2 de outubro de 2026
  Qual IA usar na empresa: veja as diferenças entre ChatGPT, Claude e Perplexity e quando cada um rende mais em cada área da sua equipe.
• 
  Apostilas Gratuitas em PDF: Excel, Power BI, Python e IA30 de setembro de 2026
  Baixe apostilas gratuitas em PDF de Excel, Power BI, Python, Claude e agentes de IA, com exercícios e gabarito. Escolha a sua e comece hoje.