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!
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__”.
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 é?
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: 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
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)
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!
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?
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!
Para acessar outras publicações de Python, clique aqui!
Posts mais recentes de Python
Posts mais recentes da Hashtag Treinamentos
Expert em conteúdos da Hashtag Treinamentos. Auxilia na criação de conteúdos de variados temas voltados para aqueles que acompanham nossos canais.