# Aula 2 - Introdução aos elementos do Python

Passada a introdução teórica, podemos nos aprofundar em uma parte introdutória mais prática do Python, com algumas linhas de código. Nessa aula, veremos:

- Operações básicas no Python: adição, subtração, multiplicação, divisão, potenciação, e módulo aritmético;
- Operações de lógica e comparação;
- Tipos de dados em Python: *strings*, *integers*, e *floats*;
- Sequências em Python: listas e tuplas;
- Dicionários.

## Operações básicas em Python

Como foi dito na aula anterior, uma das coisas mais básicas para fazer com a linguagem Python é usá-la como uma "calculadora científica", fazendo operações matemáticas básicas com uma linha de código somente. Aqui estão alguns exemplos:

**Python**:

```python
2 + 2 #Adição (veja 'NOTA 1' para entender o papel do '#')
```

**Output**:

```python
4
```

**Python**:

```python
5 - 8 #Subtração
```

**Output**:

```python
3
```

**Python**:

```python
6 * 2 #Multiplicação
```

**Output**:

```python
12
```

**Python**:

```python
50 / 5 #Divisão
```

**Output**:

```python
10
```

**Python**:

```python
2 ** 2 #Potenciação
```

**Output**:

```python
4
```

**Python**:

```python
13 % 5 #Módulo aritmético (para entender do que se trata, veja 'NOTA 2')
```

**Output**:

```python
3
```

## Operações de lógica, comparação, e identidade

Nós podemos também utilizar operadores de lógica e comparação (`<, >, ==, !=, <=, >=`) em uma só linha de código em Python:

**Python**:

```python
3 > 4
```

**Output**:

```python
False
```

**Python**:

```python
6 == 6
```

**Output**:

```python
True
```

Além disso, podemos escrever operações de identidade (`and, or, not`) e obter resultados:

**Python**:

```python
True and True
```

**Output**:

```python
True
```

**Python**:

```python
True and False
```

**Output**:

```python
False
```

Estes resultados obtidos (`True` e `False`) são dados que chamamos de booleanos (`boolean`). Inclusive, é sobre os tipos de dados que falaremos em seguida.

## Tipos de dados em Python

Uma das coisas que também está entre as mais básicas no Python é a associação de valores à variáveis. Isso quer dizer que, quando introduzimos dados em um ambiente ou notebook, devemos nomeá-los, para que possamos identificá-los ao trabalhar com funções e bibliotecas. Essa associação é feita usando o operador de atribuição `=`. Um detalhe: não confunda esse operador com o de comparação `==`.

Por exemplo:

**Python**:

```python
texto = "Exemplo de texto"  # Um exemplo de linha (string)
numero = 42  # Um exemplo de número inteiro (integer)
pi_valor = 3.1415  # Um exemplo de número decimal (float)
```

Junto do exemplo está uma exposição de alguns tipos de dados que podemos utilizar em Python:

- Linhas (`string`): são sequências de caracteres, que podem ser letras, números (quando dentro de aspas), pontuações e até emojis (🤔);
- Números inteiros (`integer`): números inteiros que podem ser utilizados em funções e operações;
- Números decimais (`float`): números separados por pontos, que também podem ser utilizados em funções ou operações.
- Dados booleanos (`boolean`): são dados que retornam após operações lógicas ou de comparação. Basicamente, apontam se uma operação como as citadas é procedente ou não, verdadeira ou falsa. Também podem se referir a um dado ausente ou presente num dado dataframe ou dataset. No Python, os dados booleanos aparecem como `True` ou `False`.

Tudo que está em Python possui um tipo, e é importante sempre ter em mente quais são os tipos de dados que estão sendo utilizados, para evitar erros de interpretação ou incompatibilidades. Para descobrir qual o tipo de um objeto, lançamos mão da função `type()`.

**Python**:

```python
type(texto)
```

**Output**:

```python
<class 'str'>
```

Nós podemos ver o valor de alguma coisa usando a função `print()`.

**Python**:

```python
texto_novo = 'Um outro exemplo de texto'
print(texto_novo)
```

**Output**:

```python
Um outro exemplo de texto
```

## Sequências em Python: Listas e tuplas

Nesta parte da aula, veremos como lidar com uma sequência ordenada de elementos. Temos dois casos a cobrir: listas e tuplas.

- Listas: são sequências simples de elementos, separados por vírgulas. Criamos uma lista usando colchetes (`[]`).

  **Python**:

  ```python
  lista = [1, 2, 3, 4]
  ```

  Em uma sequência ordenada como essa, cada elemento é acessível por meio de um índice. Importante notar que, em Python, os índices sempre iniciam em 0, em vez de 1. Ou seja, para acessar o primeiro elemento, é necessário chamar o número 0. 

  **Python**:

  ```python
  lista[0]
  ```

  **Output**:

  ```python
  1
  ```

- Tuplas: também são sequência simples de elementos, tais como as listas; a diferença é que, nesse caso, os elementos dentro de uma tupla são imutáveis (não podem ser mudados após sua criação). Criamos uma tupla usando parênteses.

  **Python**:

  ```python
  tupla = (1, 2, 3, 4)
  outra_tupla = ('um', 'dois', 'três', 'quatro')
  ```

## Dicionários

Em Python, consideramos como dicionários os objetos que possuem um par de outros objetos em seu interior. Também funcionam como as listas e tuplas, mas, em vez de terem índices, são organizados por chaves - é como se fosse uma etiqueta única ou um nome do objeto.

Para entender como funciona:

```python
ordem = {'um': 'primeiro', 'dois': 'segundo'}
```

Perceba que os objetos `'um`' e `'primeiro'`estão separados por dois pontos (`:`). É assim que se formam os dicionários: para o objeto `'um'`é atribuído outro objeto, o `'primeiro'`, e assim sucessivamente. Para localizarmos um objeto dentro de uma lista, o procedimento é parecido com a lista:

**Python**:

```python
ordem['um']
```

**Output**:

```python
'primeiro'
```

-----

Nesta aula, foram apresentados alguns elementos essenciais na linguagem Python que você precisará ter em mente ao programar. Continuaremos a introdução em um próximo post da série, onde será mostrado um conteúdo referente a funções.

Até a próxima aula e, caso queira, já vá deixando um feedback! 😁

-----
## NOTAS:

(**NOTA 1**: Na linguagem Python, é permitido fazer comentários dentro de linhas de código. Para tanto, basta adicionar o sinal `#` antes de escrever. Tais comentários não serão consideradas pelo programa interpretador ao ler o código.)

(**NOTA 2**: Como foi mencionado antes, em vez de ser um símbolo de porcentagem, em Python o símbolo `%` representa uma operação aritmética distinta, o [**módulo**](https://www.freecodecamp.org/news/the-python-modulo-operator-what-does-the-symbol-mean-in-python-solved/). Basicamente, o módulo representa **o resto de uma divisão**.
Exemplo: no caso acima, quando chamada a linha `13 % 5`, estamos efetuando a divisão de `13` por `5`; o quociente dessa divisão é `5`, enquanto que o resto (que é o que aparece no output) é `3`. Você pode ver mais sobre isso clicando [aqui](http://excript.com/python/modulo-da-divisao-python.html) e [aqui](https://www.learnpython.org/pt/Operadores_b%C3%A1sicos))

-----
## **Para ler mais:**

- [Documentação do Python - Usando o Python como uma calculadora](https://docs.python.org/pt-br/3/tutorial/introduction.html#using-python-as-a-calculator)
- [Criando coleções - DevMedia](https://www.devmedia.com.br/colecoes-no-python-listas-tuplas-e-dicionarios/40678)
- [Documentação do Python - Estruturas de dados](https://docs.python.org/pt-br/3/tutorial/datastructures.html)
- [Basic elements of Python - GeoPython](https://geo-python-site.readthedocs.io/en/latest/notebooks/L2/Python-basic-elements.html)
- [Python Basics - Astro Users](https://users.astro.ufl.edu/~warner/prog/python.html)

## **Literatura recomendada**

- *Basic Core Python Programming*, de Meenu Kohli ([Library Genesis](http://libgen.rs/book/index.php?md5=CDE2BCEA2E13C41D0D9CC160BF9E3C4B))
- *Coding Python*, de Michael e Eric Scratch
- *Curso Intensivo de Python*, de Eric Matthes ([Library Genesis](http://libgen.rs/book/index.php?md5=1C13103D7B9B54DDD8EFAC70ACA10DA1))
- *Data Science do Zero: Primeiras Regras com Python*, de Joel Grus ([Library Genesis](http://libgen.rs/book/index.php?md5=EE6D1DFB6DDF4F53391557E3E0C97000))