382 lines
9.9 KiB
Markdown
382 lines
9.9 KiB
Markdown
# 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?
|
||
|
||
---
|
||
|
||
---
|
||
|
||
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.
|
||
|
||
---
|
||
|
||
---
|
||
|
||
## 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!
|