Data Science do zero: Primeiras regras com o Python


def multiply(x, y): return



Baixar 5.26 Mb.
Pdf preview
Página32/75
Encontro24.07.2022
Tamanho5.26 Mb.
#24344
1   ...   28   29   30   31   32   33   34   35   ...   75
Data Science do zero - Primeiras regras
def multiply(x, y): return x * y
products = map(multiply, [1, 2], [4, 5]) # [1 * 4, 2 * 5] = [4, 10]
Igualmente,
filter
faz o trabalho de uma compreensão de lista
if
:
def is_even(x):
"""True se x for par, False se x for ímpar"""
return x % 2 == 0
x_evens = [x for x in xs if is_even(x)] # [2, 4]
x_evens = filter(is_even, xs) # igual ao de cima
list_evener = partial(filter, is_even) # função que filtra a lista
x_evens = list_evener(xs) # novamente [2, 4]
reduce
combina os dois primeiros elementos de uma lista, então esse resultado
com o terceiro e esse resultado com o quarto; e assim por diante, produzindo um
único resultado:
x_product = reduce(multiply, xs) # = 1 * 2 * 3 * 4 = 24
list_product = partial(reduce, multiply) # função que reduz uma lista
x_product = list_product(xs) # novamente = 24
Enumeração (enumerate)
Com alguma frequência, você vai querer iterar por uma lista e usar seus


elementos e seus índices:
# não é Pythonic
for i in range(len(documents)):
document = documents[i]
do_something(i, document)
# também não é Pythonic
i = 0
for document in documents:
do_something(i, document)
i += 1
A solução Pythonic é
enumerate
(enumerar), que produz tuplas (
index, element
):
for i, document in enumerate(documents):
do_something(i, document)
Da mesma forma, se apenas quisermos os índices:
for i in range(len(documents)): do_something(i) # não é Pythonic
for i, _ in enumerate(documents): do_something(i) # Pythonic
Usaremos isso bastante.
Descompactação de Zip e Argumentos
Com uma certa frequência, precisaremos
zip
(compactar) duas ou mais listas
juntas.
zip
transforma listas múltiplas em uma única lista de tuplas de elementos
correspondentes:
list1 = ['a', 'b', 'c']
list2 = [1, 2, 3]
zip(list1, list2) # é [('a', 1), ('b', 2), ('c', 3)]
Se as listas são de tamanhos diferentes,
zip
para assim que a primeira lista acaba.
Você também pode descompactar uma lista usando um truque curioso:
pairs = [('a', 1), ('b', 2), ('c', 3)]
letters, numbers = zip(*pairs)
O asterisco desempenha a descompactação de argumento, que usa os elementos
de
pairs
como argumentos individuais para
zip
. Dá no mesmo se você chamasse:
zip(('a', 1), ('b', 2), ('c', 3))
que retorna
[(‘a’, ’b’, ’c’), (‘1’, ’2’, ’3’)].
Você pode usar a descompactação de argumento com qualquer função:



Baixar 5.26 Mb.

Compartilhe com seus amigos:
1   ...   28   29   30   31   32   33   34   35   ...   75




©historiapt.info 2022
enviar mensagem

    Página principal