Introdução Básica ao Python

Para começarmos a nossa jornada, você precisa preparar o seu ambiente de desenvolvimento. A ordem dos passos abaixo é importante para que tudo funcione corretamente.

1. Instalar a linguagem Python:Crucial: Marque a caixa ‘Add python.exe to PATH’ na primeira tela do instalador.

Acesse o site oficial python.org e baixe a versão mais recente para o seu sistema operacional. Marcar a caixa do PATH (ou “Adicionar ao caminho”) garante que o seu computador reconheça os comandos do Python em qualquer pasta.

2. Instalar um Editor de Código:

Nós precisamos de um programa para escrever nosso código com conforto. A recomendação padrão da indústria é o Visual Studio Code (VS Code). Ele é gratuito, leve e muito poderoso. Baixe e instale em code.visualstudio.com.

3. Instalar a extensão do Python no VS Code:

Abra o VS Code. No menu lateral esquerdo, clique no ícone de “Extensions” (quatro quadradinhos). Busque por “Python” e instale a extensão oficial criada pela Microsoft. Isso vai dar ao seu editor a capacidade de entender a sintaxe, sugerir correções e rodar o código facilmente.

4. Testar a instalação:

Ainda no VS Code, abra o terminal integrado clicando na barra superior em Terminal > New Terminal.

Digite o comando abaixo e aperte Enter:

python --version

Se aparecer a versão do Python que você instalou (ex: Python 3.12.x), seu ambiente está pronto!

1. Sintaxe Básica e Comentários

Em Python, você não precisa colocar ponto e vírgula (;) no final de cada linha. O principal comando para fazer o computador “falar” com você é o print(). Além disso, usamos o jogo da velha (#) para escrever comentários — textos que o computador ignora, mas que servem para explicar o código.

crie um arquivo chamado app.py, e escreva esse codigo, se tiver usando vscode,
vai ter esse icone de play clique nele ( vai esta escrito run python file ) e o codigo vai ser executado ou pode abrir o terminal e digital py app.py ( o nome do arquivo que voce colocou), pode ser qualquer coisa

# Isto é um comentário e será ignorado pelo Python
print("Olá, mundo!") # Imprime o texto na tela
Code language: Python (python)

Regra de Ouro do Python (Indentação): Diferente de outras linguagens que usam chaves {} para agrupar blocos de código, o Python usa espaços no início da linha (geralmente 4 espaços ou 1 “Tab”). Você verá isso na prática logo abaixo.

. Variáveis e Tipos de Dados

Variáveis são como “caixas” onde guardamos informações na memória. Em Python, você não precisa dizer qual é o tipo de dado da caixa antes de usá-la; o Python adivinha automaticamente.

Existem quatro tipos básicos essenciais:

• String (str): Textos. Sempre devem estar entre aspas simples ('...') ou duplas ("...").
• Integer (int): Números inteiros (sem casa decimal).
• Float (float): Números decimais. Atenção: usa-se ponto (.) em vez de vírgula.
• Boolean (bool): Valores lógicos, apenas True (Verdadeiro) ou False (Falso). Sempre com a primeira letra maiúscula.

nome = "Sistema Assistente"  # str (String)
versao = 2                   # int (Inteiro)
temperatura_cpu = 45.5       # float (Decimal)
ativo = True                 # bool (Booleano)

# Podemos misturar texto e variáveis usando o "f-string" (basta colocar um 'f' antes das aspas):
print(f"O assistente {nome} versão {versao} está ativo? {ativo}")
Code language: Python (python)

3. Condições (if, elif, else)

Condições permitem que o seu código tome decisões. Dependendo de uma validação ser verdadeira ou falsa, o programa segue um caminho diferente.

Para testar condições, usamos operadores de comparação:

• == (Igual a)
• != (Diferente de)
• > (Maior que) e >= (Maior ou igual a)
• < (Menor que) e <= (Menor ou igual a)

Veja como construímos a lógica:

idade = 20

# Observe os dois pontos (:) no final do 'if' e o espaço recuado (indentação) na linha de baixo!
if idade >= 18:
    print("Acesso liberado: Usuário é maior de idade.")
elif idade >= 16:
    # O 'elif' (else if) testa uma segunda condição caso a primeira seja falsa
    print("Acesso restrito: Necessita de autorização.")
else:
    # O 'else' captura qualquer coisa que não caiu nas opções anteriores
    print("Acesso negado: Usuário é menor de idade.")
Code language: PHP (php)

Seu primeiro desafio prático:

Crie um arquivo chamado desafio1.py no seu VS Code e tente resolver este problema:

1. Crie uma variável chamada nota e atribua a ela um valor de 0 a 10 (pode ser com casas decimais).
2. Crie uma estrutura de condição que verifique:
   • Se a nota for maior ou igual a 7.0, imprima "Aprovado".
   • Se a nota for maior ou igual a 5.0 e menor que 7.0, imprima "Recuperação".
   • Se for menor que 5.0, imprima "Reprovado".

(Dica extra: você pode usar a palavra and para juntar duas condições, por exemplo: if nota >= 5.0 and nota < 7.0:)

Solução:

nota = 10

if nota >= 7:
    print("Aprovado")
elif nota >= 5 and nota < 7:
    print("Recuperação")
else: print("Reprovado")
Code language: PHP (php)

Passo 2: Loops e Funções

Nesta etapa, você vai aprender a fazer o computador trabalhar por você repetindo tarefas (loops) e como criar seus próprios “mini-programas” reutilizáveis dentro do código (funções). Isso é exatamente o que fazemos quando criamos skills para um assistente inteligente: empacotamos uma lógica em uma função que o assistente pode chamar quando precisar.

1. Loops (Laços de Repetição)

Se você precisa executar o mesmo bloco de código várias vezes, você usa um loop. O Python tem dois principais: o for e o while.

O Loop for: É ideal quando você sabe exatamente quantas vezes quer repetir algo. Usamos muito com o comando range(), que gera uma sequência de números.

# Vai repetir 3 vezes (os números gerados serão 0, 1 e 2)
for numero in range(3):
    print(f"Testando o prompt, tentativa número {numero}")
Code language: PHP (php)

O Loop while: É usado quando você quer que algo se repita enquanto uma condição for verdadeira. Se a condição virar falsa, ele para.

bateria = 100

while bateria > 80:
    print(f"Bateria em {bateria}%. Sistema rodando...")
    # Diminuindo a bateria em 10 a cada ciclo
    bateria = bateria - 10 

print("Atenção: Bateria atingiu 80% ou menos. Entrando em economia de energia.")
Code language: PHP (php)

2. Funções (def)

Uma função é um bloco de código que tem um nome e que só é executado quando você o “chama”. Em vez de reescrever a mesma lógica de validação de interface ou de cálculo várias vezes, você cria uma função e a usa sempre que precisar.

Para criar uma função, usamos a palavra def (de define).

# 1. Construindo a função
def calcular_dobro(numero):
    resultado = numero * 2
    return resultado # O 'return' é a resposta que a função devolve para quem a chamou

# 2. Usando a função
valor_calculado = calcular_dobro(5)
print(f"O dobro de 5 é: {valor_calculado}")
Code language: PHP (php)

Você também pode criar funções que recebem múltiplos valores (parâmetros) ou que apenas executam uma ação sem usar o return:

def saudar_usuario(nome, cargo):
    # Esta função não tem 'return', ela apenas executa o print
    print(f"Olá {nome}, bem-vindo ao painel de {cargo}.")

saudar_usuario("Alex", "Design Engineer")
Code language: PHP (php)

Seu Desafio do Passo 2:

Crie um novo arquivo e tente resolver este problema construindo sua própria ferramenta:

1. Crie uma função chamada contagem_regressiva que receba um número como parâmetro (por exemplo, inicio).
2. Dentro dessa função, crie um loop while que imprima o número na tela e diminua 1 dele a cada repetição, até chegar a zero.
3. Quando o loop terminar (fora do loop, mas ainda dentro da função), faça a função imprimir a palavra "Lançamento!".
4. Chame a sua função passando o número 10 para testar.

Solução:

def contagem_regressiva(inicio = 0):
    while inicio >= 0:
        print(inicio)
        inicio -=1
    print("lançamento!")

contagem_regressiva(10)
Code language: PHP (php)

Outro exemplo de função:

def somar(*numeros):      # aceita N argumentos
    total = 0             # começa a soma em zero
    for n in numeros:     # percorre cada número recebido
        total += n        # acumula no total
    return total          # devolve o resultado

print(somar(1,2,3))        # 6
print(somar(10,20,30,40))  # 100
Code language: PHP (php)

Vale atentar que tem um * junto ao nome do paramentro.

O que é o * em *numeros

O * antes do nome do parâmetro faz o Python empacotar todos os argumentos posicionais em uma tupla. Isso se chama args (arguments variáveis).

Sem o *, a função aceitaria só um número fixo de argumentos:

def somar(a, b, c):   # obriga a passar exatamente 3
    return a + b + c

somar(1, 2, 3)        # ok
somar(10, 20, 30, 40) # erro: TypeError, foram passados 4 em vez de 3
Code language: PHP (php)

Com *numeros, a chamada somar(1, 2, 3) faz o Python montar isto por dentro:

numeros = (1, 2, 3)   # uma tuplaCode language: PHP (php)

E na segunda chamada, numeros = (10, 20, 30, 40). Por isso o for n in numeros funciona: você está percorrendo uma tupla comum.

Passo 3: Listas, Tuplas e Dicionários

Até agora, nossas variáveis guardavam um único valor. Mas e se você precisar guardar dezenas de restrições de um prompt ou as configurações de uma skill? É aqui que entram as coleções.

1. Listas (list)

Listas são coleções ordenadas e mutáveis (você pode adicionar, remover ou alterar os itens depois de criadas). São definidas por colchetes [].

# Criando uma lista de regras de design
regras_ui = ["evitar paleta roxa", "usar alto contraste", "manter sombras suaves"]

# Acessando itens pelo índice (a contagem sempre começa no zero!)
print(regras_ui[0]) # Imprime: evitar paleta roxa

# Adicionando um novo item ao final da lista
regras_ui.append("usar valores exatos de pixel")

# Removendo um item
regras_ui.remove("manter sombras suaves")

# Podemos usar o 'for' para percorrer a lista
for regra in regras_ui:
    print(f"Regra ativa: {regra}")
Code language: PHP (php)

2. Tuplas (tuple)

Tuplas são quase idênticas às listas, mas com uma diferença crucial: elas são imutáveis. Uma vez criadas, você não pode adicionar, remover ou alterar seus itens. São definidas por parênteses ().

Usamos tuplas para dados que não devem ser modificados acidentalmente pelo sistema durante a execução.

# Coordenadas de tela ou configurações fixas do modelo
resolucao_padrao = (1920, 1080)
modelo_base = ("gemini", 1.5)

print(f"Largura da tela: {resolucao_padrao[0]}px")
# resolucao_padrao[0] = 1024  -> Isso geraria um ERRO, pois tuplas não podem ser alteradas.
Code language: PHP (php)

3. Dicionários (dict)

Dicionários guardam informações em pares de chave e valor. Em vez de procurar um item pela sua posição numérica (índice 0, 1, 2…), você procura pelo nome da chave. São incrivelmente úteis para configurar agentes e estruturar dados de APIs. São definidos por chaves {}.

# Configurando uma skill para um assistente
skill_design = {
    "nome": "Especialista UX/UI",
    "framework": "antigravity",
    "temperatura": 0.3,
    "ativo": True
}

# Acessando um valor através da sua chave
print(skill_design["nome"]) # Imprime: Especialista UX/UI

# Modificando um valor existente
skill_design["temperatura"] = 0.5

# Adicionando um novo par de chave e valor
skill_design["limite_tokens"] = 2000

print(skill_design)
Code language: PHP (php)

Seu Desafio do Passo 3:

Vamos simular a configuração de um sistema. Crie um novo arquivo e faça o seguinte:

1. Crie um dicionário chamado perfil_assistente com as chaves "nome", "versao" e "funcao". Preencha com os valores que quiser.
2. Adicione uma nova chave a esse dicionário chamada "modulos" e coloque como valor uma lista contendo pelo menos três ferramentas (ex: ["pesquisa", "analise de codigo", "geracao de interface"]).
3. Faça um print que mostre o nome do assistente e, em seguida, faça um loop for que imprima cada um dos módulos que ele tem acesso.

Solução:

perfil_assistente = {
    "nome": "Rodrigo",
    "versao": 2,
    "funcao": "admin",
    "modulos": [
        "pesquisa", 
        "analise de dados", 
        "geracao de interface"
    ]
}
print(perfil_assistente["nome"])

for perfil in perfil_assistente["modulos"]:
    print(perfil)
Code language: PHP (php)

Passo 4: Classes e Objetos (Orientação a Objetos)

Até agora, usamos variáveis, dicionários e funções separadas. A Orientação a Objetos (OOP) é uma forma de programar que permite agrupar dados (variáveis) e comportamentos (funções) em um único pacote.

Imagine que você está construindo sistemas maiores, como agentes de IA ou skills de design para o Gemini. É muito mais fácil tratar esse agente como um “Objeto” que tem suas próprias configurações e ações.

• Classe (Class): É a “planta” ou o “molde”. Ela define como um objeto deve ser, mas não é o objeto em si.
• Objeto (Object): É a coisa real construída a partir do molde (uma instância).
• Atributos: São as variáveis que pertencem ao objeto (suas características).
• Métodos: São as funções que pertencem ao objeto (o que ele sabe fazer).

Veja como criamos o molde de um assistente especializado em interfaces e depois “damos vida” a ele:

# 1. Definindo a Classe (sempre com letra maiúscula por convenção)
class AssistenteDesign:
    
    # O método __init__ é o "construtor". Ele roda automaticamente quando criamos o objeto.
    # A palavra 'self' é obrigatória: ela significa "este próprio objeto".
    def __init__(self, nome, modelo_base):
        self.nome = nome                  # Atributo
        self.modelo = modelo_base         # Atributo
        self.regras_prompt = []           # Atributo (começa como uma lista vazia)

    # 2. Definindo Métodos (funções dentro da classe)
    def adicionar_regra(self, regra):
        self.regras_prompt.append(regra)
        print(f"[{self.nome}] Regra atualizada: {regra}")
        
    def exibir_configuracao(self):
        print(f"--- Configuração do {self.nome} ({self.modelo}) ---")
        for regra in self.regras_prompt:
            print(f"- {regra}")

# 3. Criando o Objeto (Instanciando a classe)
# Aqui estamos preenchendo os parâmetros 'nome' e 'modelo_base' do __init__
agente_ux = AssistenteDesign("UX_Expert", "gemini-1.5")

# 4. Usando o objeto
# Vamos adicionar regras de design para evitar interfaces genéricas
agente_ux.adicionar_regra("Proibido usar paletas genéricas roxas de IA")
agente_ux.adicionar_regra("Proibido textos com baixo contraste")
agente_ux.adicionar_regra("Usar valores exatos de pixel, sem aproximações")

# Chamando outro método do nosso objeto
agente_ux.exibir_configuracao()

Repare que ao usarmos self.nome, o método sabe exatamente o nome daquele assistente específico. Se você criasse um segundo objeto (agente_backend = AssistenteDesign(...)), um não misturaria as regras com o outro.

Seu Desafio do Passo 4: Vamos ver como você se sai criando a sua primeira classe.

1. Crie uma classe chamada Skill.
2. Crie o método __init__ recebendo o self, um nome_da_skill e uma versao. Salve esses valores em atributos (ex: self.nome e self.versao).
3. Crie um método chamado executar (não esqueça do self dentro dos parênteses dele) que apenas imprima uma mensagem dizendo: "Executando a skill [nome] na versão [versao]".
4. Fora da classe, crie um objeto dessa classe (instancie) passando um nome e uma versão à sua escolha.
5. Chame o método .executar() do seu objeto.

Solução:

class Skill:

    def __init__(self, nome_da_skill, versao):
        self.nome = nome_da_skill
        self.modelo = versao

    def executar(self):
        print(f"Executando a skill {self.nome} {self.modelo} ")

# FORA DA CLASSE (sem espaços no começo da linha)
# 1. Criamos o objeto chamando o NOME DA CLASSE:
agent_skill = Skill("design_ui", "Gemini")

# 2. Chamamos a função (método) DE DENTRO do objeto que acabamos de criar:
agent_skill.executar()

Com isso, nós fechamos a base de Orientação a Objetos. Se você rodar esse código no seu VS Code, vai ver exatamente a mensagem que planejou aparecer no terminal!

Podemos subir um pouco mais o nível com o seu próximo passo.

Passo 5: Decoradores e Lambda

Esses dois conceitos são recursos avançados do Python que permitem escrever códigos mais curtos e elegantes.

1. Funções Lambda (Funções Anônimas)

Se você precisa criar uma função muito simples, de uma linha só, que vai ser usada rapidamente e descartada, você usa a palavra lambda em vez do tradicional def.

Ela não tem nome próprio, recebe os parâmetros e já devolve (retorna) o resultado logo em seguida.

# Uma função tradicional:
def somar(a, b):
    return a + b

# A mesma função, feita com Lambda:
# Lê-se: "recebe 'a' e 'b', e retorna 'a + b'"
somar_lambda = lambda a, b: a + b

print(somar_lambda(5, 3)) # Imprime: 8
Code language: PHP (php)

2. Decoradores (@)

Sabe quando você precisa checar se um usuário tem permissão antes de rodar várias funções diferentes? Em vez de colocar o código de checagem dentro de todas elas, você usa um Decorador.

Um decorador é uma função que “abraça” outra função. Ele adiciona um comportamento antes ou depois dela rodar, usando o símbolo @.

# 1. Construindo o Decorador (o "envelope")
def log_de_execucao(funcao_original):
    def envelope():
        print(f"--> [SISTEMA] Iniciando a ferramenta...")
        funcao_original() # Aqui a função de verdade roda
        print(f"--> [SISTEMA] Ferramenta finalizada.")
    return envelope

# 2. Usando o Decorador
@log_de_execucao
def gerar_codigo_ui():
    print("Gerando botões e paleta de cores de alto contraste...")

@log_de_execucao
def analisar_banco_de_dados():
    print("Buscando informações do usuário...")

# 3. Testando
gerar_codigo_ui()
Code language: PHP (php)

Repare que quando chamamos gerar_codigo_ui(), o Python automaticamente roda o decorador primeiro, imprime as mensagens de sistema, e executa a função no meio.

Seu Desafio do Passo 5:

Vamos focar no lambda, que é muito prático no dia a dia.

1. Crie uma variável chamada multiplicar_por_dez.
2. Atribua a ela uma função lambda que receba um número (por exemplo, x) e retorne esse número multiplicado por 10 (o símbolo de multiplicação é o *).
3. Faça um print passando o número 5 para a sua função lambda.

Solução:

multiplicar_por_dez = lambda a: a * 10
print(multiplicar_por_dez(5))
Resultado : 50
Code language: PHP (php)

Se você chegou até aqui, e curtiu e quer saber mais sobre curso de python