10 funções básicas do Python incrivelmente úteis

Quem trabalha com Python sabe que essa linguagem é boa por causa de seu vasto ecossistema. Pode-se até dizer que a linguagem de programação não se destacaria em nada de especial, se não por seus maravilhosos pacotes que agregam novas funções às principais.



NumPy é um exemplo. As ferramentas de matriz também são boas no Python básico, mas usar o NumPy melhora as coisas muitas vezes. Além disso, essa linguagem possui alguns recursos interessantes que a tornam ainda mais funcional. Ao usar esses recursos, você pode reduzir o número de dependências, liberar tempo e simplificar o próprio processo de desenvolvimento. Vamos ver quais são essas possibilidades.



A propósito, Alexey Nekrasov, o líder do departamento de Python da MTS e o diretor de programa do departamento de Python da Skillbox, acrescentou seus conselhos sobre algumas funções. Para deixar claro onde se encontra a tradução e onde se encontram os comentários, iremos destacar este último com o texto.

# 1 lambda

Certa vez, escrevi um artigo inteiro sobre por que lambda torna Python a linguagem de programação ideal para computação estatística. Graças a esse recurso, as operações matemáticas podem ser aplicadas a quase todos os tipos de dados, não usando funções inteiras, mas avaliando expressões.



Permite que as definições sejam introduzidas globalmente, bem como sintaxe e metodologia do tipo funcional, em uma linguagem que ainda possui uma estrutura de classes.



Tudo isso permite economizar tempo ao escrever o programa, economizar recursos e tornar o código mais conciso. Além disso, lambda permite que você use métodos como apply () para aplicar rapidamente expressões a todos os subconjuntos de seus dados. Para um cientista de dados, e não apenas para representantes dessa profissão, essas oportunidades são extremamente úteis.



A sintaxe é a seguinte. Começamos com o valor de retorno da expressão lambda, seguido pela variável que gostaríamos de fornecer como um argumento posicional. Depois disso, realizamos a operação usando este argumento como uma variável:

mean = lambda x : sum(x) / len(x)
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
    

Agora podemos fazer a chamada, assim como com qualquer outro método em Python:

x = [5, 10, 15, 20]
print(mean(x))
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
    

Comentário de Alexey:



Cuidado com lambda para não prejudicar a legibilidade do código. Aqui estão algumas dicas:

Do PEP8. Sempre use a instrução def em vez do operador de atribuição, que vincula a expressão lambda diretamente a um identificador:



Correto:

def f (x): return 2 * x
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
    

Errado:

f = lambda x: 2 * x
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
    

Se o comprimento da expressão lambda for superior a 40 caracteres, provavelmente você colocou muita lógica em uma linha de código e ela se tornou ilegível. Você não deve fazer isso, é melhor colocá-lo em uma função separada.

# 2: Shutil

O módulo Shutil é uma das ferramentas mais subestimadas no arsenal Python. Ele está incluído na biblioteca padrão e pode ser importado como qualquer outro módulo no idioma:

import shutil
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
    

O que o shutil faz? Na verdade, é uma interface de alto nível para a linguagem de programação Python com relação ao sistema de arquivos do seu sistema operacional. Essas chamadas geralmente são feitas usando o módulo os; não se esqueça do shutil. Você provavelmente teve que mover um arquivo de um diretório para outro usando um script, o que fez um trabalho muito tedioso, certo?



O Shutil resolve esses problemas clássicos de arquivo e tabela de alocação com uma solução de alto nível. Esta é a chave para economizar tempo e acelerar as operações de arquivo. Aqui estão alguns exemplos de chamadas de alto nível fornecidas pelo shutil.

import shutil
shutil.copyfile('mydatabase.db', 'archive.db')
shutil.move('/src/High.py', '/packages/High')
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
    

# 3: glob

Glob pode não ser tão incrível quanto o shutil, além de não ser nem perto de lambda em termos de utilidade. Mas é insubstituível em alguns casos. Este módulo é usado para localizar diretórios para curingas. Isso significa que pode ser usado para agregar dados sobre arquivos em seu PC e suas extensões. O módulo é importado sem problemas:

import glob
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
    

Não tenho certeza se este módulo tem mais funcionalidade, mas glob () é o que é necessário para realizar pesquisas de arquivo. A pesquisa usa sintaxe Unix, ou seja, Essa. *, / etc.

glob.glob('*.ipynb')
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
    

Esta string retorna todos os nomes de arquivo que correspondem à consulta especificada. A função pode ser usada para agregação de dados e simplesmente para trabalhar com arquivos.

# 4: argparse

Este módulo fornece um método robusto e profundo para analisar argumentos de linha de comando. Muitas ferramentas de desenvolvimento usam esse conceito, e você pode trabalhar com tudo isso usando a linha de comando do Unix. Um ótimo exemplo é o Python Gunicorn, que lida com argumentos de linha de comando passados. Para começar a trabalhar com um módulo, você precisa importá-lo.

import argparse
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
    

Então, para poder trabalhar com ele, construímos um novo tipo, este será o analisador de argumentos:

parser = argparse.ArgumentParser(prog = 'top',
description = 'Show top lines from the file')
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
    

Agora estamos adicionando novos argumentos ao nosso analisador. Nesse caso, criamos um argumento que pode ser passado para determinar o número de linhas que queremos gerar para cada arquivo:

parser.add_argument('-l', '--lines', type=int, default=10)
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
    

Vários argumentos de palavra-chave foram adicionados aqui, um dos quais fornecerá o tipo de dados que é passado para aquele argumento e o outro fornecerá um valor padrão quando o arquivo for chamado sem este argumento. Agora podemos obter os argumentos chamando a função parse_args () em nosso novo tipo de analisador de argumento:

args = parser.parse_args()
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
    

Agora podemos chamar esse arquivo Python para compilar e também fornecer facilmente as opções necessárias do Bash.

python top.py --lines=5 examplefile.txt
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
    

Não é preciso dizer que isso pode ser útil. Tenho usado muito este módulo ao trabalhar com o Crontab. Ele pode executar scripts com carimbos de data / hora específicos do Unix. Além disso, esse script também pode ser usado para supervisores que executam comandos Bash sem a intervenção do usuário como um trabalhador.

# 5: importação re

Outro módulo altamente subestimado. O módulo re é usado para analisar strings usando expressões regulares e oferece mais opções para trabalhar com strings em Python. Quantas vezes você já tomou decisões algorítmicas com base em funções que estão em uma classe de string como str.split ()? Mas pare de aguentar! Afinal, as expressões regulares são muito mais simples e fáceis de usar!

import re
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
    

O módulo re, ao contrário de alguns dos outros nesta lista, fornece não uma, mas muitas funções extremamente úteis. Eles são especialmente relevantes para trabalhar com grandes quantidades de dados, o que é importante para cientistas de dados. Dois exemplos para começar são as funções sub () e findall ().

import re
re.findall(r'\bf[a-z]*', 'which foot or hand fell fastest')
['foot', 'fell', 'fastest']
re.sub(r'(\b[a-z]+) \1', r'\1', 'cat in the the hat')
'cat in the hat'
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
    

:



regex :

• re.compile. re.compile ( ) regex.
• re.compile regex.
• re.VERBOSE. re.compile re.VERBOSE ( ) regex . .

:

pattern = '^M{0,3}(CM|CD|D?C{0,3})(XC|XL|L?X{0,3})(IX|IV|V?I{0,3})$'
re.search(pattern, 'MDLV')
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
    

pattern = '''
    ^                   # beginning of string
    M{0,3}              # thousands - 0 to 3 Ms
    (CM|CD|D?C{0,3})    # hundreds - 900 (CM), 400 (CD), 0-300 (0 to 3 Cs),
                        #            or 500-800 (D, followed by 0 to 3 Cs)
    (XC|XL|L?X{0,3})    # tens - 90 (XC), 40 (XL), 0-30 (0 to 3 Xs),
                        #        or 50-80 (L, followed by 0 to 3 Xs)
    (IX|IV|V?I{0,3})    # ones - 9 (IX), 4 (IV), 0-3 (0 to 3 Is),
                        #        or 5-8 (V, followed by 0 to 3 Is)
    $                   # end of string
    '''
re.search(pattern, 'M', re.VERBOSE)
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
    

• python raw string regex.
• Grupos de captura nomeados para todos os grupos de captura se houver mais de um (? P ...). (mesmo se houver apenas uma captura, também é melhor usar)
  
  regex101.com é um ótimo site para depurar e verificar regex
  
  

# 6: Matemática

Este não é o maior módulo da história, mas geralmente é útil. O módulo matemático dá acesso a tudo, desde sin e cos até logaritmos. Tudo isso é extremamente importante ao trabalhar com algoritmos.

import math
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
    

Um módulo certamente pode economizar algum tempo, tornando as operações matemáticas disponíveis sem dependências. Neste exemplo, demonstrarei a função log (), mas se você se aprofundar no módulo, um mundo inteiro se abrirá.

import math
math.log(1024, 2)
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
    

Nº 7: Estatísticas

Outro módulo extremamente útil para cálculos estatísticos. Dá acesso a estatísticas básicas - não tão profundas como no caso do SCiPy, mas pode ser suficiente para a análise de dados. O alias deste módulo é st, em alguns casos stc ou sts. Mas, atenção - não scs, este é um alias para Scipy.stats.

import statistics as st
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
    

Este módulo oferece muitos recursos úteis que vale a pena conferir! A grande vantagem deste pacote é que ele não possui dependências. Vamos dar uma olhada em algumas operações estatísticas básicas de uso geral:

import statistics as st
st.mean(data)
st.median(data)
 
st.variance(data)
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
    

# 8: urllib

Se muitos dos outros módulos desta lista não forem bem conhecidos, o urlib é uma exceção. Vamos importar!

import urllib
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
    

O frasco pode ser usado em vez disso, pois é mais funcional. Mas, para a maioria das funções básicas, os recursos da biblioteca padrão são suficientes, o que torna possível não se preocupar com dependências. Claro, se recursos adicionais são necessários, neste caso, vale a pena prestar atenção em outra coisa. Mas se estamos falando sobre uma solicitação HTTP, o urlib fará o que for necessário.

from urllib.request import urlopen
 
data = null
with urlopen('http://example_url/') as response: data = response
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
    

O módulo urlib é algo que eu recomendo altamente aprender mais.

# 9: data e hora

Outro ótimo exemplo de ferramenta bastante comum na computação científica é o tipo de data e hora. Muitas vezes, os dados têm carimbos de hora. Às vezes, eles são até mesmo uma função preditiva usada para treinar o modelo. Este módulo é frequentemente usado com o alias dt:

import datetime as dt
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
    

Agora podemos criar tipos de data e hora e trabalhar com a sintaxe típica de data e hora com propriedades incluindo ano, mês e dia. Isso é extremamente útil para reformatar, analisar e trabalhar com seções específicas de datas em seus dados. Vamos dar uma olhada em alguns dos principais recursos deste pacote:

import datetime as dt
now = dt.date.today()
print(now.year)
print(now.month)
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
    

# 10: zlib

O último contribuidor para esta lista é o módulo zlib. É uma solução de compactação de dados versátil usando a linguagem de programação Python. O módulo é extremamente útil ao trabalhar com pacotes.

import zlib
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
    

As funções mais importantes aqui são compress () e decompress ().

h = " Hello, it is me, you're friend Emmett!"print(len(h))
t = zlib.compress(h)
print(len(t))
z = decompress(t)
print(len(z))
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
    

Como conclusão, direi que programar em Python às vezes parece difícil devido ao grande número de dependências. E a biblioteca de linguagem padrão permite que você se livre parcialmente deste problema. Além disso, as ferramentas padrão do Python podem economizar tempo, reduzir a quantidade de código e torná-lo mais legível.