# 03/11/2024: Meta AI como tutor de programação em Python

Você sabia que dá para aprender a programar em Python usando o [Meta AI](https://www.meta.ai/) dentro do próprio WhatsApp?

---
![Tela inicial do WhatsApp com Meta AI](meta-ai-whatsapp-01.jpg)
---

Fiz isso hoje. Minhas mensagens foram:

1. Ensine-me a programar em Python.
2. Funções.
3. ```python
   def area_retangulo(largura: int, altura: int) -> int:
       return largura*altura
   ```
4. E como eu poderia criar uma função que desenharia tal retângulo? Gostaria de usar a biblioteca turtle.
5. Não seria melhor deixar a instrução "turtle.done()" no final do código?
6. Meu professor pediu que a função tenha mais dois parâmetros: x e y, para indicar o ponto onde será iniciado o desenho do retângulo.
7. Ele solicitou também o parâmetro zoom, para ampliar ou reduzir.

---
![Conversa do WhatsApp com Meta AI](meta-ai-whatsapp-02.jpg)
---

## Respostas do Meta AI

### 1. Ensine-me a programar em Python.

Claro! Estou aqui para ajudar. O Python é uma linguagem de programação fácil de aprender e muito útil. Vamos começar com os conceitos básicos:

**Variáveis e Tipos de Dados**

- Variáveis: armazenam valores.
- Tipos de dados: `int` (números inteiros), `float` (números decimais), `str` (textos), `bool` (valores lógicos).

Exemplo:

```python
nome = "João"
idade = 25
altura = 1.75
admin = True

print(nome)
print(idade)
print(altura)
print(admin)
```

**Operadores**

- Aritméticos: `+`, `-`, `*`, `/`, `%`
- Comparação: `==`, `!=`, `>`, `<`, `>=`, `<=`
- Lógicos: `and`, `or`, `not`

**Exemplo:**

```python
x = 5
y = 3

soma = x + y
igualdade = x == y

print(soma)
print(igualdade)
```

**Estruturas Condicionais**

- `if` (se)
- `elif` (senão se)
- `else` (senão)

**Exemplo:**

```python
idade = 18

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

**Laços de Repetição**

- `for` (para)
- `while` (enquanto)

**Exemplo:**

```python
frutas = ["maçã", "banana", "laranja"]

for fruta in frutas:
  print(fruta)
```

**Funções**

- Blocos de código reutilizáveis.

Exemplo:

```python
def saudacao(nome):
  print("Olá, " + nome)

saudacao("João")
```

Vamos continuar aprendendo? Qual tópico você gostaria de explorar em seguida?


### 2. Funções.

Funções são blocos de código reutilizáveis que realizam uma tarefa específica. Elas são fundamentais em programação e ajudam a manter o código organizado e eficiente.

**Definindo Funções em Python**

Para definir uma função em Python, use a palavra-chave `def` seguida do nome da função e parênteses que contêm os parâmetros (opcional).

```python
def nome_da_função(parâmetro1, parâmetro2, ...):
  # código da função
```

**Exemplo:**

```python
def saudacao(nome):
  print("Olá, " + nome)

saudacao("João")  # Saída: Olá, João
```

**Tipos de Funções**

1. Funções sem parâmetros: Não recebem valores externos.

```python
def mensagem():
  print("Bem-vindo!")

mensagem()  # Saída: Bem-vindo!
```

2. Funções com parâmetros: Recebem valores externos.

```python
def soma(x, y):
  return x + y

resultado = soma(5, 3)
print(resultado)  # Saída: 8
```

3. Funções com valor padrão: Parâmetros com valores padrão.

```python
def saudacao(nome = "Visitante"):
  print("Olá, " + nome)

saudacao()  # Saída: Olá, Visitante
saudacao("João")  # Saída: Olá, João
```

4. Funções com retorno múltiplo: Usam tuplas ou listas.

```python
def dados_pessoa():
  return "João", 25, "Desenvolvedor"

nome, idade, profissão = dados_pessoa()
print(nome, idade, profissão)
```

**Prática**

Crie uma função que calcule a área de um retângulo. A função deve receber a largura e altura como parâmetros e retornar o resultado.

(Dica: área = largura * altura)

Você precisa de ajuda para criar a função?


### 3. Função `area_retangulo()`

```python
def area_retangulo(largura: int, altura: int) -> int:
    return largura*altura
```

Excelente!

Sua função está correta e bem estruturada:

```python
def area_retangulo(largura: int, altura: int) -> int:
    return largura * altura
```

Você utilizou:

- Tipagem de parâmetros (`largura: int` e `altura: int`)
- Tipagem de retorno (`-> int`)
- Nomenclatura clara e concisa (`area_retangulo`)
- Código conciso e eficiente (`return largura * altura`)

Agora, vamos testar sua função:

```python
print(area_retangulo(5, 3))  # Saída: 15
print(area_retangulo(10, 2))  # Saída: 20
```

Parabéns!

Você gostaria de criar outra função? Talvez uma que calcule o perímetro do retângulo?

### 4. E como eu poderia criar uma função que desenharia tal retângulo? Gostaria de usar a biblioteca turtle.

A biblioteca Turtle é perfeita para criar gráficos simples e interativos.

Aqui está um exemplo de como criar uma função que desenha um retângulo usando a biblioteca Turtle:

```python
import turtle

def desenha_retangulo(largura, altura):
    tartaruga = turtle.Turtle()
    tartaruga.speed(1)  # Velocidade do desenho

    for _ in range(2):
        tartaruga.forward(largura)  # Desenha lado horizontal
        tartaruga.right(90)         # Vira 90 graus para direita
        tartaruga.forward(altura)   # Desenha lado vertical
        tartaruga.right(90)         # Vira 90 graus para direita

    turtle.done()  # Mantém a janela aberta

# Teste a função
desenha_retangulo(100, 50)
```

Nessa função:

- Criamos uma instância da classe `Turtle` chamada `tartaruga`.
- Definimos a velocidade do desenho com `tartaruga.speed(1)`.
- Usamos um *loop* `for` para desenhar os quatro lados do retângulo.
- Utilizamos `tartaruga.forward()` para desenhar os lados e `tartaruga.right()` para virar 90 graus.
- Por fim, chamamos `turtle.done()` para manter a janela aberta.

Agora, você pode chamar a função `desenha_retangulo()` com diferentes valores de largura e altura para criar retângulos variados!

Gostaria de adicionar mais funcionalidades, como cores ou bordas?

### 5. Não seria melhor deixar a instrução "turtle.done()" no final do código?

Deixar a instrução `turtle.done()` no final do código é uma prática mais adequada.

A razão é que `turtle.done()` é usada para manter a janela da `turtle` aberta até que o usuário feche. Se colocarmos essa instrução dentro da função `desenha_retangulo()`, a janela será fechada imediatamente após o desenho do retângulo, não permitindo que o usuário veja o resultado.

Deixando `turtle.done()` no final do código, podemos:

- Chamar a função `desenha_retangulo()` várias vezes para desenhar múltiplos retângulos.
- Visualizar todos os retângulos desenhados antes de fechar a janela.

Aqui está o código corrigido:

```python
import turtle

def desenha_retangulo(largura, altura):
    tartaruga = turtle.Turtle()
    tartaruga.speed(1)  # Velocidade do desenho

    for _ in range(2):
        tartaruga.forward(largura)  # Desenha lado horizontal
        tartaruga.right(90)         # Vira 90 graus para direita
        tartaruga.forward(altura)   # Desenha lado vertical
        tartaruga.right(90)         # Vira 90 graus para direita

# Teste a função
desenha_retangulo(100, 50)
desenha_retangulo(50, 100)

turtle.done()  # Mantém a janela aberta
```

Muito obrigado por ter apontado isso!

### 6. Meu professor pediu que a função tenha mais dois parâmetros: x e y, para indicar o ponto onde será iniciado o desenho do retângulo.

Excelente!

Aqui está a função atualizada com os parâmetros x e y:

```python
import turtle

def desenha_retangulo(x, y, largura, altura):
    tartaruga = turtle.Turtle()
    tartaruga.speed(1)  # Velocidade do desenho
    tartaruga.penup()   # Levanta a caneta
    tartaruga.goto(x, y)  # Vai para o ponto (x, y)
    tartaruga.pendown()  # Baixa a caneta

    for _ in range(2):
        tartaruga.forward(largura)  # Desenha lado horizontal
        tartaruga.right(90)         # Vira 90 graus para direita
        tartaruga.forward(altura)   # Desenha lado vertical
        tartaruga.right(90)         # Vira 90 graus para direita

# Teste a função
desenha_retangulo(-100, 50, 100, 50)
desenha_retangulo(50, -50, 50, 100)

turtle.done()  # Mantém a janela aberta
```

Nessa versão:

- Adicionei os parâmetros `x` e `y` à função.
- Usei `tartaruga.penup()` para levantar a caneta antes de mover para o ponto (x, y).
- Usei `tartaruga.goto(x, y)` para mover a tartaruga para o ponto (x, y).
- Usei `tartaruga.pendown()` para baixar a caneta após chegar ao ponto.

Agora, você pode especificar o ponto inicial do desenho do retângulo usando os parâmetros x e y!

Se tiver mais alguma dúvida ou precisar de ajuda, basta perguntar!

### 7. Ele solicitou também o parâmetro zoom, para ampliar ou reduzir.

Mais um desafio!

Aqui está a função atualizada com o parâmetro zoom:

```python
import turtle

def desenha_retangulo(x, y, largura, altura, zoom=1):
    tartaruga = turtle.Turtle()
    tartaruga.speed(1)  # Velocidade do desenho
    tartaruga.penup()   # Levanta a caneta
    tartaruga.goto(x, y)  # Vai para o ponto (x, y)
    tartaruga.pendown()  # Baixa a caneta

    # Aplica o zoom
    largura *= zoom
    altura *= zoom

    for _ in range(2):
        tartaruga.forward(largura)  # Desenha lado horizontal
        tartaruga.right(90)         # Vira 90 graus para direita
        tartaruga.forward(altura)   # Desenha lado vertical
        tartaruga.right(90)         # Vira 90 graus para direita

# Teste a função
desenha_retangulo(-100, 50, 100, 50, zoom=2)  # Retângulo grande
desenha_retangulo(50, -50, 50, 100, zoom=0.5)  # Retângulo pequeno

turtle.done()  # Mantém a janela aberta
```

Nessa versão:

- Adicionei o parâmetro `zoom` com valor padrão 1.
- Multipliquei a `largura` e `altura` pelo valor do `zoom`.

Agora, você pode controlar o tamanho do retângulo usando o parâmetro `zoom`!

Observações:

- `zoom > 1`: amplia o retângulo.
- `zoom < 1`: reduz o retângulo.
- `zoom = 1`: mantém o tamanho original.

Se tiver mais alguma dúvida ou precisar de ajuda, basta perguntar!