Aprendendo Python - Parte 1
Tags: python, webdev, programming, tutorial
Published: 2023-11-14 12:22:08

Aprender uma linguagem nova é, ao mesmo tempo, desafiador, estimulante e cansativo. Principalmente quando você está acostumado a trabalhar muito tempo em uma determinada linguagem, como é meu caso com o JavaScript.

Por isso decidi documentar meu progresso no aprendizado de novas tecnologias.

Para começar, não sou um expert em JavaScript. Mas adoro compartilhar tudo que sei. Por isso tenho esse blog. E como meus conhecimentos de JS já eram satisfatórios quando decidi escrever esses artigos, pensei em fazer o caminho inverso com uma nova linguagem. A escolhida da vez foi a Python.

## Porque Python

Eu sempre quis aprender Python. Já vi alguma coisa na faculdade, mas nada interessante. Só a lógica básica mesmo, o que vou reproduzir neste artigo. Além de ser uma linguagem popular atualmente, com ela posso investir em outra área que tenho olhado há algum tempo: data science. 

E, como disse atualmente, Python está no auge. Nesse ano (2023) ela está em segundo lugar nas linguagens mais populares do Github, atrás apenas do JavaScript.

Por isso, bora aprender esse trem.

## Sobre a Python

Sempre considerei interessante contextualizar um pouco o conhecimento. Acho legal saber como as coisas surgiram e etc. Se você não gosta, só pular para as explicações iniciais, na seção **Primeiros passos com Python**, mais abaixo.

A linguagem Python foi criada por Guido van Rossum, e teve seu primeiro lançamento em 1991. O Python se tornou tão popular porque, além de ser usada para desenvolvimento web, também é usada para scrpits de sistema, desenvolvimento de software e matemática. 

### Vantagens de utilizar a Python:

- como no Node.js, você pode criar um servidor para criar aplicações;
- conexão com bancos de dados, criando e modificando arquivos;
- pode ser usado para lidar com big data e realizar matemática complexa;
- para prototipagem rápida ou para desenvolvimento de software pronto para produção.

### Motivos para utilizar a Python

Python é uma linguagem de programação versátil e amplamente utilizada, conhecida por sua compatibilidade com diversas plataformas, incluindo Windows, Mac, Linux e Raspberry Pi. Essa característica torna Python uma escolha ideal para desenvolvedores que trabalham em ambientes de computação variados. Além disso, Python se destaca por sua sintaxe simples e intuitiva, que se assemelha à língua inglesa. Essa simplicidade facilita o aprendizado e a leitura do código, tornando Python uma opção popular tanto para programadores iniciantes quanto para os mais experientes.

- [MongoDB Descomplicado: O Guia Definitivo para Iniciantes em MongoDB](https://dev.to/rodrigozan/mongodb-descomplicado-o-guia-definitivo-para-iniciantes-em-mongodb-4o5) 

Outro aspecto notável do Python é sua eficiência em termos de escrita de código. Os desenvolvedores podem expressar conceitos complexos em menos linhas de código em comparação com outras linguagens de programação, o que aumenta a produtividade e reduz o tempo necessário para o desenvolvimento de software. Python opera em um sistema de interpretação, permitindo que o código seja executado imediatamente após ser escrito. Isso facilita a prototipagem rápida, um recurso valioso em ambientes de desenvolvimento ágil. Além disso, Python é extremamente flexível, suportando programação procedural, orientada a objetos e funcional, o que permite aos desenvolvedores escolher a abordagem mais adequada para cada projeto.

## Sobre tipagem

Para a galera que fica na dúvida sobre a tipagem do Python...

A linguagem Python é frequentemente descrita como uma linguagem de tipagem dinâmica. Porém, é importante esclarecer que ela também é fortemente tipada. 

Certo, confundiu tudo aqui, imagino.

Vamos melhorar essa resposta.

Isso significa que, embora Python não exija que você declare explicitamente os tipos de dados das variáveis no momento da sua criação (uma característica da tipagem dinâmica), ela não permite operações que são incompatíveis com os tipos de dados envolvidos, o que é uma característica de linguagens fortemente tipadas.

Por exemplo, em Python, você não pode concatenar diretamente uma string e um número sem uma conversão explícita, pois são tipos de dados diferentes. Isso demonstra a natureza de tipagem forte da linguagem, onde o tipo de cada valor é importante e é mantido de forma rigorosa durante a execução do programa.

## Primeiros passos com Python

Agora que estamos devidamente contextualizados, vamos codar. Caso você não queira baixar a linguagem na sua máquina, pode seguir esse básico tutorial utilizando o Docker ou o site [Online Python](https://www.online-python.com/), onde é possível rodar código da linguagem direto no navegador.

### Rodando Python no Docker

Para utilizar Python no Docker, rode o comando `docker run -it --name estudos-de-python -vC:\\endereço-da-pasta-onde-estarão-seus-arquivos:/app -p8080 python`. Troque _C:\\endereço-da-pasta-onde-estarão-seus-arquivos_ pelo caminho da sua máquina onde você quer salvar seus arquivos python. A escolha da porta é de preferência pessoal. Ah sim! _estudos-de-python_ é uma sugestão de nome para seu container docker. Fique a vontade para escolher o nome que quiser.

### Hello World

Só para seguir a convenção mundial, vamos criar o famoso _hello world_. 

Dentro do seu ambiente Python, crie o arquivo _hello-world.py_ (_py_ é a extensão usada para arquivos **Python**).

No arquivo _hello-world.py_, vamos printar o texto Hello World_ usando o método *print*, do **Python**:

```python
print('Hello World')
```

Se você rodar o comando python _hello-world.py_, verá escrito no terminal a string _Hello World_.

### Variáveis

Vamos melhorar nosso código, adicionando o texto _Hello World_ à uma variável do tipo _String_.

Se você prestou atenção no texto introdutório, já sabe que não declaramos o tipo da variável em sua criação. Também não temos uma palavra reservada, como _var_ ou _const_ para declarar que aquele dado é uma variável. Precisamos apenas escrever o nome da variável e atribuir a ela o devido valor. 

No nosso exemplo, podemos escrever:

```python
text = 'Hello World'
print(text)
```

Para melhorar a legibilidade do código, podemos mudar o nome da variável, declarando qual a sua intenção, e comentar o código:

```python
# usamos # (hashtag, jogo da velha, sustenido...) para criar comentários em Python
welcome = 'Hello World' # a variável welcome deixa claro que o texto se trata de uma mensagem de boas vindas
print(welcome) # a função print imprime no terminal a mensagem atribuída à variável welcome
```

### Operadores

Como todas as linguagens, a Python possui operadores que facilitam (e muito) o desenvolvimento:

- Aritméticos: +, -, *, /, % (módulo), ** (potência)
- Comparação: ==, !=, >, <, >=, <=
- Lógicos: and, or, not

### Identação

Antes de entrarmos nas estruturas, acho válido comentar sobre a identação da linguagem.

A indentação em Python é mais do que apenas uma questão de estilo de codificação; é uma parte fundamental da sintaxe da linguagem. Em Python, a indentação é usada para definir blocos de código. Isso é diferente de muitas outras linguagens de programação, onde chaves `{}` ou palavras-chave específicas são usadas para esse propósito.

Aqui estão alguns pontos importantes sobre a indentação em Python:

**Blocos de Código:** Em Python, blocos de código sob estruturas de controle como `if`, `for`, `while`, e definições de funções (`def`) e classes (`class`) são definidos pela indentação. Todo o código dentro de um bloco deve ser indentado uniformemente.

**Consistência:** A quantidade de espaço usado para a indentação é flexível, mas deve ser consistente em todo o bloco. O padrão mais comum é usar quatro espaços por nível de indentação, e esta é a convenção recomendada pela PEP 8 (o guia de estilo para Python).

**Indentação vs. Tabs:** Embora você possa usar tabs para indentação, é altamente recomendado usar espaços, e nunca misturar tabs e espaços no mesmo bloco de código, pois isso pode levar a erros que são difíceis de diagnosticar.

**Erros de Indentação:** Se um bloco de código não estiver corretamente indentado, Python lançará um `IndentationError`. Isso ajuda a manter a legibilidade e a uniformidade do código.

**Exemplo de Indentação:**

Não precisa se preocupar em entender as questões de estrutura condicional e de repetição. Esse exemplo é apenas para você visualizar a importância da identação na linguagem Python.

```python
def minha_funcao():
    for i in range(5):
        if i > 2:
            print("Maior que 2")
        else:
            print("Menor ou igual a 2")
```

Neste exemplo, o corpo da função `minha_funcao`, o loop `for`, e as estruturas condicionais `if` e `else` têm suas próprias indentações para indicar quais linhas de código pertencem a cada bloco.

A indentação é uma parte crucial da sintaxe Python e ajuda a tornar o código Python legível e organizado. Ao seguir as convenções de indentação, os programadores podem evitar erros comuns e tornar seu código mais acessível para outros desenvolvedores.

### Estruturas Condicionais

Estruturas condicionais são um conceito fundamental na programação, usadas para executar diferentes ações com base em diferentes condições. Em outras palavras, elas permitem que um programa tome decisões e siga caminhos diferentes de execução dependendo de certos critérios ou condições.

Aqui estão os elementos principais das estruturas condicionais:

1. **If:** Esta é a estrutura condicional mais básica. Ela permite que o programa execute um bloco de código apenas se uma determinada condição for verdadeira. Por exemplo, em Python, você pode ter algo como `if x > 0:`, onde o código subsequente é executado somente se `x` for maior que zero.

```python
if idade > 18:
    print("Adulto")
```

1. **Else:** Frequentemente usada em conjunto com `if`, a cláusula `else` especifica um bloco de código a ser executado se a condição `if` for falsa. Por exemplo, `if x > 0:` seguido de `else:` - o bloco de código sob `else` é executado se `x` não for maior que zero.

```python
if idade > 18:
    print("Adulto")
else:
    print("Menor de idade")
```

2. **Elif (Else If):** Usada para verificar múltiplas condições, uma após a outra. Se a condição do `if` for falsa, o programa verifica a condição do `elif`, e assim por diante. Isso permite criar uma cadeia de verificações de condições.

```python
if x > 10:
    print("x é maior que 10")
elif x > 5:
    print("x é maior que 5 mas não maior que 10")
else:
    print("x é 5 ou menor")
```

4. **Switch Case:** Alguns idiomas oferecem uma estrutura `switch case`, que é uma maneira de simplificar uma série de `if-else` quando todas as condições dependem do valor de uma única variável. Python não tem uma estrutura `switch case` nativa, mas o mesmo comportamento pode ser simulado com uma série de `if-elif-else`.

As estruturas condicionais são essenciais para a lógica de programação, permitindo que os programas sejam dinâmicos e reativos a diferentes entradas e situações.

```python
def case1(): # a palavra reservada 'def' é usada em Python para definir uma função
    return "Caso 1"

def case2():
    return "Caso 2"

def default():
    return "Caso padrão"

switch = {
    1: case1,
    2: case2
}

# Usando o 'switch'
case = switch.get(x, default)()
print(case)

```

### Estrutura de Repetição - Loops

As estruturas de repetição são cruciais em toda linguagem de programação. No Python não seria diferente.

Também conhecidas como laços ou loops, as estruturas de repetição são fundamentais na programação, pois permitem que um bloco de código seja executado repetidamente sob certas condições. Em Python, as principais estruturas de repetição são o `for` e o `while`.

1. **For Loop:** O loop `for` é usado para iterar sobre uma sequência (que pode ser uma lista, uma tupla, um dicionário, um conjunto ou uma string). Com cada iteração, o loop acessa o próximo item na sequência. O `for` é frequentemente usado quando o número de iterações é conhecido ou definido por uma coleção.

   Exemplo em Python:
   ```python
   for i in range(5):
       print(i)
   ```
   Este código imprimirá os números de 0 a 4. A função `range(5)` gera uma sequência de números de 0 a 4, e o loop `for` itera sobre essa sequência.

2. **While Loop:** O loop `while` executa um conjunto de instruções enquanto uma condição é verdadeira. Diferente do `for`, o `while` é usado quando o número de iterações não é necessariamente conhecido de antemão; o loop continuará a executar até que a condição especificada se torne falsa.

   Exemplo em Python:
   ```python
   i = 0
   while i < 5:
       print(i)
       i += 1
   ```
Este código também imprimirá os números de 0 a 4. O loop continua a executar enquanto `i` for menor que 5.

Ambos os tipos de loops são essenciais para tarefas que requerem repetição, como processamento de dados, execução de cálculos repetitivos, automação de tarefas, entre outros. É importante gerenciar cuidadosamente as condições de loop para evitar loops infinitos, onde o loop nunca atinge uma condição de término.

### Funções

Em Python, funções são blocos de código que são projetados para realizar uma tarefa específica e podem ser reutilizados em diferentes partes do programa. As funções ajudam a tornar o código mais modular, organizado e manutenível. Elas são definidas usando a palavra-chave `def`, seguida pelo nome da função e parênteses, que podem conter parâmetros.

Aqui estão alguns pontos-chave sobre funções em Python:

**Definição de Função** 

Para criar uma função, você usa a palavra-chave `def`, seguida do nome da função e parênteses. Os parâmetros da função são especificados dentro dos parênteses. O corpo da função começa na linha seguinte e deve ser indentado.

   ```python
   def minha_funcao():
       print("Olá, esta é minha função!")
   ```

**Parâmetros e Argumentos** 

As funções podem ter parâmetros, que são variáveis listadas entre os parênteses na definição da função. Quando você chama a função, você fornece valores, chamados argumentos, para esses parâmetros.

   ```python
   def saudacao(nome):
       print(f"Olá, {nome}!")

   saudacao("Alice")  # Chama a função com o argumento "Alice"
   ```

**Retorno de Valores** 

Uma função pode retornar um valor usando a palavra-chave `return`. O valor retornado pode ser resultado de uma operação, uma expressão ou qualquer objeto Python. Após a execução do `return`, a função é encerrada.

   ```python
   def somar(a, b):
       return a + b

   resultado = somar(5, 3)
   print(resultado)  # Imprime 8
   ```

**Escopo de Variáveis** 

As variáveis definidas dentro de uma função têm escopo local, ou seja, elas só podem ser acessadas dentro da função. Variáveis definidas fora de todas as funções têm escopo global e podem ser acessadas em qualquer lugar do programa.

**Funções Anônimas (Lambda)** 

Python também suporta a criação de funções anônimas (ou expressões lambda), que são funções pequenas e sem nome, definidas com a palavra-chave `lambda`.

   ```python
   multiplicar = lambda x, y: x * y
   print(multiplicar(2, 3))  # Imprime 6
   ```

As funções são uma parte crucial da programação em Python, permitindo a reutilização de código, a organização lógica e a manutenção mais fácil do código.

## Conclusão

Como vimos, apesar de suas particulariedades, entender Python não é muito complexo.

É claro que, ao se aprofundar na linguagem, será necessário gastar tempo estudando. Vimos apenas uma pequena introdução do Python. 

Eu vou seguir estudando e compartilhando meu conhecimento aqui com vocês. Me digam aí o que acham.