Python: Dicas e Truques.
Tags: python, programming, beginners
Published: 2019-11-23 23:01:00

---
title: Python: Dicas e Truques.
published: true
description: Apenas mais um post sobre pequenas dicas e truques para você usar no seu dia a dia.
tags: python, programming, beginners
cover-image: 
series: Dicas e Truques.
---

A ideia deste post é ser o ponto de partida para a série - Python: Dicas e Truques -, onde eu possa compartilhar conteúdos relativos a Python que possam agregar a quem ler. 

Como esse é meu primeiro post no dev.to, seguindo a tradição, vou fazer uma breve apresentação sobre mim aqui.

Me chamo João Rezende, tenho 23 anos e escrevo de Florianópolis/SC. Tenho contato com desenvolvimento há cerca de 3 anos, trabalhando efetivamente como um desenvolvedor há 2 anos.

Tenho grande interesse por backend, onde possuo um carinho maior por Python, JavaScript (principais ferramentas do meu dia a dia) e Golang, que tenho estudado como um hobby.

Vamos às dicas e truques:

## 1. Troca de valores entre variáveis:
```python
x, y = 1, 2
x, y = y, x

print(x)
>>> 2
print(y)
>>> 1
```

## 2. Comparação encadeada:
```python
x = 10

print(5 < x < 15)
>>> True
print(1 < x < 9)
>>> False
```

## 3. Atribuição de múltiplos valores:
```python
x, y, z = 10, 20, 30

print(x, y, z)
>>> 10 20 30
```

## 4. Atribuição de múltiplos valores com empacotamento de listas:
```python
x, *y, z = 10, 20, 30, 40, 50

print(x, y, z)
>>> 10 [20, 30, 40] 50
```

## 5. Remover valores repetidos em uma lista:
```python
x = [1, 2, 2, 3, 3, 4, 5]
y = list(set(x))

print(y)
>>> [1, 2, 3, 4, 5]
```

## 6. Agrupamento de dicionários por desempacotamento:
```python
x = {'a': 1, 'b': 2}
y = {'c': 3, 'd': 4}
z = {**x, **z}

print(z)
>>> {'a': 1, 'b': 2, 'c': 3, 'd': 4}
```

## 7. Agrupamento de elementos de sequências arbitrárias:
```python
x = [1, 2, 3]
y = ('a', 'b', 'c')
z = zip(x, y)

print(z)
>>> <zip at 0x2168c952d48>
print(list(z))
>>> [(1, 'a'), (2, 'b'), (3, 'c')]
```

## 8. Converter duas listas em um dicionário:
```python
x = ['a', 'b', 'c']
y = [1, 2, 3]
z = dict(zip(x, y))

print(z)
>>> {'a': 1, 'b': 2, 'c': 3}
```

## 9. Iterar por uma sequência mantendo controle de índice:
```python
for index, item in enumerate(['a', 'b', 'c']):
    print('indice em lista:', index, 'item:', item)

>>> indice em lista: 0 item: a
>>> indice em lista: 1 item: b
>>> indice em lista: 2 item: c
```

## 10. Simulando switch-case statements com dictionary dispatch:
```python
def switch_simul(op, x=1 ,y=2):
	return {
		'add' : lambda: x + y,
		'sub' : lambda: x - y,
		'mul' : lambda: x * y,
		'div' : lambda: x / y,
	}.get(op, lambda: None)()

print(switch_simul('add'))
>>> 3
print(switch_simul('sub'))
>>> -1
```

## 11. Operações em lista (list comprehension, map, filter):

Python oferece uma maneira concisa de expressar for loops, chamada **list comprehension**.

For loop convencional:

```python
multiplied_nums = []
for num in [1, 2, 3]:
    multiplied_nums.append(num*2)

print(a)
>>> [2, 4, 6]
```
Mesma expressão, utilizando list comprehension:

```python
multiplied_nums = [num * 2 for num in [1, 2, 3]]

print(a)
>>> [2, 4, 6]
```
Map:

```python
mult_by_2 = lambda x: x * 2, [1, 2,3]
vals = map(fn, [1, 2, 3])

print(list(vals))
>>> [2, 4, 6]
```

Equivalente a map, via list comprehension:
```python
mult_by_2 = lambda x: x * 2
a = [mult_by_2(x) for x in [1, 2, 3]]

print(a)
>>> [2, 4, 6]
```

Filter:
```python
less_than_three = lambda x: x < 3
filtered_nums = filter(less_than_three, [1, 2, 3, 4])

print(list(a))
>>> [1, 2]
```

Equivalente a filter, com list comprehension:
````python
filtered_nums = [x for x in [1, 2, 3, 4] if x < 3]

print(a)
>>> [1, 2]
```

# Bônus! Algumas ferramentas úteis:
## howdoi
[howdoi](https://github.com/gleitz/howdoi), uma ferramenta de linha de comando para quando você está preso em um problema e não quer abrir o browser para consultar o stackoverflow:

```python
pip install howdoi
```

faça qualquer pergunta, como uma pesquisa no google:

```python
howdoi copy list in python
>>> new_list = old_list.copy()

howdoi lambda in python
>>> lambda arguments: manipulate(arguments)
```


## wemake-python-styleguide
[wemake-python-styleguide](https://github.com/wemake-services/wemake-python-styleguide) é plugin de flake8, uma ferramenta de análise estática de código.


```python
pip install wemake-python-styleguide
```

```python
// module.py
import requests

r = requests.get('https://api.github.com')

print(r.status_code)
```
para utilizar o linter basta invocá-lo por seu nome, passando seu módulo como argumento:

```python
flake8 module.py
>>> module.py:1:1: D100 Missing docstring in public module
>>> module.py:3:1: WPS111 Found too short name: r
>>> module.py:5:1: T001 print found.
>>> module.py:5:21: W292 no newline at end of file
```

## funcy
[funcy](https://github.com/Suor/funcy) é uma coleção de ferramentas baseadas no paradigma funcional, inspirada na linguagem de programação Clojure.

```python
pip install funcy
```
algumas das inúmeras utilidades que podemos encontrar aqui no [cheatsheet](https://funcy.readthedocs.io/en/stable/cheatsheet.html) deles:
````python
from funcy import flatten, compact 

nested_list = [1, 2, 3, [4, 5, 6], [[7, 8], [9, 10]]] // lista aninhada

print(list(flatten(nested_list)))
>>> [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] // lista plana

mylist = [1, '', True, False]

print(compact(mylist)) // compact remove valores nao-verdadeiros (falsy values)
>>> [1, True]
```

****

Aguardo seu feedback. :)

Desde já, agradeço!