From 8e9010da411fdd869cc20f0d8b897ece6c0ab823 Mon Sep 17 00:00:00 2001
From: Rodolfo Viana <25807981+rodolfo-viana@users.noreply.github.com>
Date: Wed, 6 Mar 2024 10:06:10 -0300
Subject: [PATCH] Fixed order
---
content/aulas/intro-py/index.md | 274 +++++++++++++++++---------------
1 file changed, 143 insertions(+), 131 deletions(-)
diff --git a/content/aulas/intro-py/index.md b/content/aulas/intro-py/index.md
index c30b70f..022ccf1 100644
--- a/content/aulas/intro-py/index.md
+++ b/content/aulas/intro-py/index.md
@@ -781,7 +781,7 @@ Aqui, `operacao_1` ainda depende de `condicao_1` ser `True` para ser executada.
Desenhando,
-
+
Vamos ver isso na prática:
@@ -849,7 +849,7 @@ Em português seria algo como "se `condicao_1` for `True`, execute `operacao_1`;
Desenhando,
-
+
Vejamos um exemplo —primeiro, com dois salários; depois, com um salário:
@@ -941,7 +941,7 @@ Ou seja, em português seria algo como "se `condicao_1` for `True`, realize `ope
Desenhando,
-
+
O exemplo das temperaturas ficaria assim:
@@ -1050,7 +1050,7 @@ No código acima, o bloco dentro de `while` (a operação de adição e a impres
Desenhando,
-
+
{{< warning >}}
Cuidado ao usar `while`! Como dissemos, ele executa uma operação __enquanto__ uma condição for `True`. Se a condição for `True` para sempre, o código será executado até o seu computador travar. Um exemplo de condição infinita:
@@ -1375,7 +1375,7 @@ print(f"{nome} tem {idade} anos.")
Muitas vezes, porém, precisamos armazenar mais de um valor numa variável. Por exemplo, as contas do mês:
```py
-# Como eu posso colocar todas as contas distintas numa variável única?
+# como eu posso colocar todas as contas distintas numa variável única?
aluguel = 1400
luz = 110
agua = 90
@@ -1398,7 +1398,7 @@ internet = 100
gas = 25
cartao = 800
-contas = [aluguel, luz, agua, internet, gas, cartao] # Aqui eu crio uma lista
+contas = [aluguel, luz, agua, internet, gas, cartao] # aqui eu crio uma lista
print(contas)
print(type(contas))
@@ -1432,9 +1432,9 @@ print(mix)
...fazer lista de listas...
```py
-lista1 = [1, 2, 3] # Uma lista
-lista2 = [4, 5, 6] # Outra lista
-listona = [lista1, lista2] # Uma lista com as duas listas
+lista1 = [1, 2, 3] # lista 1
+lista2 = [4, 5, 6] # lista 2
+listona = [lista1, lista2] # lista com as duas listas
print(listona)
```
```textfile
@@ -1451,14 +1451,19 @@ print(listona2)
[1, 2, 3, 4, 5, 6]
```
-Para acessar cada elemento da lista, é preciso usar a posição do elemento dentro de colchetes (`[` e `]`).
+Para acessar cada elemento da lista, é preciso usar a posição do elemento dentro de colchetes (`[` e `]`) e a posição (índice) do elemento na lista. Assim:
+
+```
+lista[indice_elemento]
+```
{{< warning >}}
Mas lembre-se: __Python começa a contagem no índice 0__ (ou seja, o primeiro elemento é 0, o segundo é 1, o terceiro é 2...).
```py
linguagens = ["Python", "SQL", "Javascript", "C++", "Java", "HTML"]
-# Índice 0 1 2 3 4 5
+# índice 0 1 2 3 4 5
+
print(f"A linguagem na terceira posição é {linguagens[2]}")
print(f"A linguagem na quarta posição é {linguagens[3]}")
print(f"A linguagem na primeira posição é {linguagens[0]}")
@@ -1474,13 +1479,17 @@ A indexação permite, inclusive, realizar cálculos:
```py
lista = [3.14, 2.09, 8.21, -7,55]
-print(lista[1] * lista[3]) # Ou seja, 2.09 * -7.55
+print(lista[1] * lista[3]) # ou seja, 2.09 * -7.55
```
```textfile
-14.629999999999999
```
-É possível, ainda, acessar múltiplos elementos passando o índice de começo e de fim (mas preste atenção: __o resultado exclui o último item__). Funciona assim: `[onde começa:onde termina + 1]`
+É possível, ainda, acessar múltiplos elementos passando o índice de começo e de fim (mas preste atenção: __o resultado exclui o último item__). Funciona assim:
+
+```
+lista[indice_inicio:indice_fim+1]
+```
```py
linguagens = ["Python", "SQL", "Javascript", "C++", "Java", "HTML"]
@@ -1500,7 +1509,7 @@ exemplo = [["vermelho", "amarelo", "azul"], ["verde", "roxo", "preto"]]
Neste caso, temos duas listas dentro de uma lista. O desenho é assim:
-
+
A variável exemplo tem dois elementos. Cada elemento é uma lista. Então, se eu chamar isso...
@@ -1510,7 +1519,7 @@ exemplo[1] # o segundo item da variável `exemplo`
...terei como retorno isso:
-```
+```textfile
["verde", "roxo", "preto"] # uma lista
```
@@ -1554,7 +1563,7 @@ True
nome = "Claudio"
lista_nomes = ["Renato", "Ana", "Fernanda"]
-if nome not in lista_nomes: # "Se o nome não estiver na lista..."
+if nome not in lista_nomes: # "se o nome não estiver na lista..."
print(f"O nome {nome} não está na lista.")
else:
print(f"O nome {nome} está na lista.")
@@ -1565,8 +1574,8 @@ O nome Claudio não está na lista.
As listas são __mutáveis__: posso adicionar e excluir elementos, mostrar em ordem reversa etc. com algumas funções:
-- `.append(x)` para adicionar um elemento `x`
-- `.pop(i)` para tirar da lista um elemento de índice i e mostrar esse elemento
+- `.append(x)` para adicionar um elemento `x` à lista
+- `.pop(i)` para tirar da lista um elemento de índice `i` e mostrar esse elemento
- `.remove(x)` para excluir um elemento `x`
- `.reverse()` para inverter a ordem dos elementos
- `.sort()` para organizar os elementos do menor ao maior (ou do maior ao menor, se usar `reverse=True`)
@@ -1666,7 +1675,7 @@ Daí a importância de tuplas: __elas são úteis quando precisamos nos certific
cores = ["amarelo", "verde", "azul", "vermelho"]
print(f"Temos {type(cores)}, o que permite que eu altere seus elementos: {cores}")
-cores = tuple(cores) # converto a lista para tupla
+cores = tuple(cores) # converto a lista `cores` para tupla
print(f"Agora temos {type(cores)}, impossibilitando alterações: {cores}")
```
```textfile
@@ -1720,7 +1729,11 @@ Cell In[21], line 1
TypeError: 'set' object is not subscriptable
```
-Com essas peculiaridades, é comum haver conversões de listas para conjuntos e, de novo, para listas: imagine que temos uma lista com 30 valores, e queremos (1) reordená-los do maior para o menor, (2) excluindo valores duplicados, e (3) encontrar os valores que estão nas posições 3 a 5.
+Com essas peculiaridades, é comum haver conversões de listas para conjuntos e, de novo, para listas: imagine que temos uma lista com 30 valores, e queremos
+
+1. reordená-los do maior para o menor,
+2. excluindo valores duplicados, e
+3. encontrar os valores que estão nas posições 3 a 5.
Sabemos que exclusão de duplicatas pode ser feita com conjuntos, e não com listas; sabemos que reordenação e indexação podem ser executadas com listas, e não com conjuntos. Então...
@@ -1765,116 +1778,6 @@ nums = list(set(nums))
```
{{< /warning >}}
{{< /expandable >}}
-{{< expandable label="Coleções de dados: dicionário" level="2" >}}
-anteriormente vimos três coleções de dados: __lista__, __tupla__ e __conjunto__. Apenas para recapitular suas características:
-
-| lista | tupla | conjunto |
-| :-: | :-: | :-: |
-| exemplo: `x = [1, 2, 3, 4]` | exemplo: `y = (1, 2, 3, 4)` | exemplo: `z = {1, 2, 3, 4}` |
-| uso de `[` e `]` | uso de `(` e `)` | uso de `{` e `}` |
-| `list()` para lista vazia ou conversão | `tuple()` para tupla vazia ou conversão | `set()` para conjunto vazio ou conversão |
-| aceita itens repetidos | aceita itens repetidos | aceita itens repetidos, mas retorna itens únicos |
-| é mutável | é imutável | é imutável |
-| aceita métodos para manipulação | não aceita métodos para manipulação | não aceita métodos para manipulação |
-| itens acessados a partir da posição | itens acessados a partir da posição | itens inacessíveis a partir da posição |
-
-Além dessas três coleções, há outra muito importante: dicionário. Ao contrário das demais, um dicionário não tem apenas valor, mas também tem chave. Aliás, os itens de um dicionário são `sempre em pares chave-valor.` Por exemplo:
-
-```py
-prof = {"nome": "Rodolfo"}
-```
-
-Repare na sintaxe de um dicionário: `{chave: valor}`. Portanto, um dicionário é feito de `{` e `}`, além de `:`, que é o que separa a chave —no exemplo, `"nome"`— do valor —`"Rodolfo"`. Para criá-lo eu também posso usar a função `dict()`. Vamos ver um exemplo:
-
-```py
-curso = {"instituicao": "IDP"}
-print(curso)
-print(type(curso))
-```
-```textfile
-{'instituicao': 'IDP'}
-
-```
-
-Isso muda bastante a forma de trabalharmos com coleções: se antes o usual era ter listas ou tuplas com dados de um mesmo tipo...
-
-```py
-frutas = ["maçã", "laranja", "banana"]
-precos = [1.45, 2.07, 3.99]
-```
-...agora podemos ter uma coleção com diversos tipos de dados...
-
-```py
-frutas = {"produto": "maçã", "preco": 1.45} # a vírgula separa os pares chave-valor
-```
-...ou até mesmo uma coleção de coleções, como lista de dicionários (algo bem comum, aliás).
-```py
-frutas = [
- {"produto": "maçã", "preco": 1.45},
- {"produto": "laranja", "preco": 2.07},
- {"produto": "banana", "preco": 3.99}
-]
-```
-
-Vou fazer o meu perfil usando dicionário e os mais variados tipos de dados:
-
-```py
-prof = {
- "nome": "Rodolfo",
- "sobrenome": "Viana",
- "idade": 43,
- "domicilio": "Marília, SP",
- "tem_pet": True,
- "qtde_pet": 1,
- "nome_pet": "Pitoco",
- "peso_pet": 11.5
-}
-
-print(prof)
-print(f"Tenho {len(prof)} elementos numa única variável!")
-```
-```textfile
-{'nome': 'Rodolfo', 'sobrenome': 'Viana', 'idade': 43, 'domicilio': 'Marília, SP', 'tem_pet': True, 'qtde_pet': 1, 'nome_pet': 'Pitoco', 'peso_pet': 11.5}
-Tenho 8 elementos numa única variável!
-```
-
-Mas agora que temos a estrutura chave-valor, como localizar um valor? Ou adicionar outro? Simples: basta usar a chave entre `[]`!
-
-```py
-print(prof) # tenho o dicionário todo...
-print(prof["tem_pet"]) #... e aqui, apenas o valor da chave "tem_pet"
-```
-```textfile
-{'nome': 'Rodolfo', 'sobrenome': 'Viana', 'idade': 43, 'domicilio': 'Marília, SP', 'tem_pet': True, 'qtde_pet': 1, 'nome_pet': 'Pitoco', 'peso_pet': 11.5}
-True
-```
-```py
-print(f'{prof["nome"]} tem {prof["idade"]} anos e mora em {prof["domicilio"]}')
-```
-```textfile
-Rodolfo tem 43 anos e mora em Marília, SP
-```
-Para adicionar um par chave-valor que não existe, funciona assim:
-
-```
-variavel["novachave"] = "novovalor"
-```
-Vamos ver na prática:
-
-```py
-print(prof) # repare que não tenho chave "signo"...
-prof["signo"] = "Peixes" # ...mas eu a adiciono, e com o valor "Peixes"...
-print(prof) # e o dicionário é atualizado
-```
-```textfile
-{'nome': 'Rodolfo', 'sobrenome': 'Viana', 'idade': 43,
-'domicilio': 'Marília, SP', 'tem_pet': True, 'qtde_pet': 1,
-'nome_pet': 'Pitoco', 'peso_pet': 11.5}
-{'nome': 'Rodolfo', 'sobrenome': 'Viana', 'idade': 43,
-'domicilio': 'Marília, SP', 'tem_pet': True, 'qtde_pet': 1,
-'nome_pet': 'Pitoco', 'peso_pet': 11.5, 'signo': 'Peixes'}
-```
-{{< /expandable >}}
{{< expandable label="Iteração com `for` - parte 1" level="2" >}}
Agora que conhecemos coleções de dados, podemos imaginar:
@@ -1890,7 +1793,7 @@ for elemento in colecao:
```
Seria como dizer em português: "para cada elemento de `colecao`, faça determinada `operacao`". Em desenho,
-
+
Por exemplo, quero aumentar os preços da minha loja em 15% —e aqui, vamos usar também a função `round(x, quantidade_de_casas_decimais)`, que arredonda o valor de `x` estabelecendo determinada quantidade de casas decimais:
@@ -2014,6 +1917,115 @@ for row in bike_limpo['IDADE']:
Aqui, o estudo na íntegra: [2019-06-28-od_bicicleta](https://github.com/rodolfo-viana/ddj_stuff/blob/main/ipynb/2019-06-28-od_bicicleta.ipynb).
{{< /expandable >}}
+{{< expandable label="Coleções de dados: dicionário" level="2" >}}
+Anteriormente vimos três coleções de dados: __lista__, __tupla__ e __conjunto__. Apenas para recapitular suas características:
+
+| lista | tupla | conjunto |
+| :-: | :-: | :-: |
+| exemplo: `x = [1, 2, 3, 4]` | exemplo: `y = (1, 2, 3, 4)` | exemplo: `z = {1, 2, 3, 4}` |
+| uso de `[` e `]` | uso de `(` e `)` | uso de `{` e `}` |
+| `list()` para lista vazia ou conversão | `tuple()` para tupla vazia ou conversão | `set()` para conjunto vazio ou conversão |
+| aceita itens repetidos | aceita itens repetidos | aceita itens repetidos, mas retorna itens únicos |
+| é mutável | é imutável | é imutável |
+| aceita métodos para manipulação | não aceita métodos para manipulação | não aceita métodos para manipulação |
+| itens acessados a partir da posição | itens acessados a partir da posição | itens inacessíveis a partir da posição |
+
+Além dessas três coleções, há outra muito importante: __dicionário__. Ao contrário das demais, um dicionário não tem apenas valor, mas também tem chave. Aliás, os itens de um dicionário são `sempre em pares chave-valor.` Por exemplo:
+
+```py
+prof = {"nome": "Rodolfo"}
+```
+
+Repare na sintaxe de um dicionário: `{chave: valor}`. Portanto, um dicionário é feito de `{` e `}`, além de `:`, que é o que separa a chave —no exemplo, `"nome"`— do valor —`"Rodolfo"`. Para criá-lo eu também posso usar a função `dict()`. Vamos ver um exemplo:
+
+```py
+curso = {"instituicao": "IDP"}
+print(curso)
+print(type(curso))
+```
+```textfile
+{'instituicao': 'IDP'}
+
+```
+
+Isso muda bastante a forma de trabalharmos com coleções: se antes o usual era ter listas ou tuplas com dados de um mesmo tipo...
+
+```py
+frutas = ["maçã", "laranja", "banana"]
+precos = [1.45, 2.07, 3.99]
+```
+...agora podemos ter uma coleção com diversos tipos de dados...
+
+```py
+frutas = {"produto": "maçã", "preco": 1.45} # a vírgula separa os pares chave-valor
+```
+...ou até mesmo uma coleção de coleções, como lista de dicionários (algo bem comum, aliás).
+```py
+frutas = [
+ {"produto": "maçã", "preco": 1.45},
+ {"produto": "laranja", "preco": 2.07},
+ {"produto": "banana", "preco": 3.99}
+]
+```
+
+Vou fazer o meu perfil usando dicionário e os mais variados tipos de dados:
+
+```py
+prof = {
+ "nome": "Rodolfo",
+ "sobrenome": "Viana",
+ "idade": 43,
+ "domicilio": "Marília, SP",
+ "tem_pet": True,
+ "qtde_pet": 1,
+ "nome_pet": "Pitoco",
+ "peso_pet": 11.5
+}
+
+print(prof)
+print(f"Tenho {len(prof)} elementos numa única variável!")
+```
+```textfile
+{'nome': 'Rodolfo', 'sobrenome': 'Viana', 'idade': 43, 'domicilio': 'Marília, SP', 'tem_pet': True, 'qtde_pet': 1, 'nome_pet': 'Pitoco', 'peso_pet': 11.5}
+Tenho 8 elementos numa única variável!
+```
+
+Mas agora que temos a estrutura chave-valor, como localizar um valor? Ou adicionar outro? Simples: basta usar a chave entre `[]`!
+
+```py
+print(prof) # tenho o dicionário todo...
+print(prof["tem_pet"]) #... e aqui, apenas o valor da chave "tem_pet"
+```
+```textfile
+{'nome': 'Rodolfo', 'sobrenome': 'Viana', 'idade': 43, 'domicilio': 'Marília, SP', 'tem_pet': True, 'qtde_pet': 1, 'nome_pet': 'Pitoco', 'peso_pet': 11.5}
+True
+```
+```py
+print(f'{prof["nome"]} tem {prof["idade"]} anos e mora em {prof["domicilio"]}')
+```
+```textfile
+Rodolfo tem 43 anos e mora em Marília, SP
+```
+Para adicionar um par chave-valor que não existe, funciona assim:
+
+```
+variavel[novachave] = novovalor
+```
+Vamos ver na prática:
+
+```py
+print(prof) # repare que não tenho chave "signo"...
+prof["signo"] = "Peixes" # ...mas eu a adiciono, e com o valor "Peixes"...
+print(prof) # e o dicionário é atualizado
+```
+```textfile
+{'nome': 'Rodolfo', 'sobrenome': 'Viana', 'idade': 43, 'domicilio': 'Marília, SP',
+'tem_pet': True, 'qtde_pet': 1, 'nome_pet': 'Pitoco', 'peso_pet': 11.5}
+{'nome': 'Rodolfo', 'sobrenome': 'Viana', 'idade': 43, 'domicilio': 'Marília, SP',
+'tem_pet': True, 'qtde_pet': 1, 'nome_pet': 'Pitoco', 'peso_pet': 11.5,
+'signo': 'Peixes'}
+```
+{{< /expandable >}}
{{< expandable label="Iteração com `for` - parte 2" level="2" >}}
Anteriormente vimos como `for` loop funciona com listas, tuplas... Recapitulando:
+
+
+
+
+
+