Biblioteca Padrão do Python

A biblioteca padrão já vem embutida na distribuição do Python, então na hora que você instala ele, a biblioteca já fica disponível para o uso. Ela é muito extensa, oferece uma ampla variedade de recursos.

Implementação

A biblioteca contém módulos internos (escritos em C) que fornecem acesso à funcionalidades do sistema, como I/O de arquivo, além de módulos escritos em Python, que fornecem soluções padronizadas para muitos problemas que ocorrem no dia a dia de quem trabalha com programação.

Portabilidade

Alguns desses módulos foram projetados explicitamente para incentivar e aprimorar a portabilidade dos programas Python, abstraindo as especificidades da plataforma em APIs neutras. Os instaladores do Python para a plataforma Windows geralmente incluem toda a biblioteca padrão e geralmente também incluem muitos componentes adicionais. Para sistemas operacionais do tipo Unix, o Python normalmente é fornecido como uma coleção de pacotes, portanto, pode ser necessário usar as ferramentas de empacotamento fornecidas com o sistema operacional para obter alguns ou todos os componentes opcionais.

Componentes, pacotes e frameworks adicionais

Além da biblioteca padrão, há uma coleção crescente de componentes (de programas e módulos individuais a pacotes e estruturas inteiras de desenvolvimento de aplicativos), disponíveis no Python Package Index.

Esse é o link para a página da documentação oficial da biblioteca padrão do python:

https://docs.python.org/3/library/

Alguns dos módulos mais importantes da biblioteca padrão do python: Matemática: math, cmath, decimal e random. regex: re, módulo de expressões regulares com funções muito poderosas para manipulação de texto. Sistema: os, io, sys, glob, logging, shutils e subprocess. Threads: threading. Persistência: pickle e cPickle. XML: xml.dom, xml.sax e elementTree. Configuração: ConfigParser e optparse. Tempo: time e datetime. Outros: traceback, types, json e timeit.

A princípio, abordaremos apenas alguns dos principais módulos da biblioteca padrão.

Obs. Para que as aulas não fiquem muito grandes, vamos dividir as aulas por módulos e nessa falaremos sobre o módulo math.

Módulo Math

Teoria dos números e representações em funções

O módulo math fornece acesso às funções matemáticas definidas em C. Essas funções não podem ser usadas com números complexo. Para números complexos use as funções com o mesmo nome do módulo cmath. As seguintes funções são fornecidas por este módulo.

Obs. Todos os valores de retorno são flutuantes, exceto quando explicitamente indicado o contrário.

  • math.ceil - retorna o teto de x.  
    • math.ceil(9.24) #Saída: 10
  • math.copysign(x, y) - retorna um float com a magnitude (valor absoluto) de x mas o sinal de y. 
    • math.copysign(2.0, -0.0) #Saída: -2.0
  • math.fabs (x) - retorna o valor absoluto de x. 
    • math.fabs(-9.24) # Saída: 9.24
  • math.factorial(x) - retorna o fatorial de x 
    • math.factorial(6) #Saída: 720
  • math.floor(x) - retorna o piso de x. 
    • 
math.floor(9.24) #Saída: 9
math.floor(-9.24) #Saída: -10
  • math.fmod(x, y) - retorna o resto da divisão de x por y. 
    • math.fmod(5, 3) #Saída: 2.0
  • math.frexp(x) - retorna a mantissa e o expoente do número inteiro fornecido. Do latim, mantissa significa a parte quebrada, ou o excedente do peso. Para a matemática, mantissa é a parte decimal de um logaritmo. Veja o exemplo. 
    • math.frexp(3) #Saída: (0.75, 2)
  • math.fsum(iterable) - retorna uma soma exata de valores de ponto flutuante no iterável. Evita a perda de precisão rastreando várias somas parciais intermediárias. É usada para encontrar soma entre algum intervalo ou um iterável. 
    • math.fsum(range(10)) # Saída: 45 = 1 + 2 + 3 + ... + 8 + 9
  • math.gcd(x,  y) - Retorna um valor inteiro, que é o GCD (Maior Divisor Comum), ou seja, o maior número inteiro que divide os dois números. 
    • math.gcd(10, 15) #Saída: 5
  • math.isclose(a, b, *, rel_tol=1e-09, abs_tol=0.0) - o método é usado para determinar se dois números de ponto flutuante têm valor próximo.
    • Parâmetros:
      • rel_tol: diferença máxima para ser considerada “próxima”, em relação à magnitude dos valores de entrada.
      • abs_tol: diferença máxima para ser considerada “fechado”, independentemente da magnitude dos valores de entrada.
      • rel_tol e abs_tol podem ser alterados usando o argumento de palavra-chave ou simplesmente fornecendo diretamente um valor, de acordo com suas posições na lista de parâmetros. Retorna True se a tiver valor próximo de b e False caso contrário.

    • OBS. Para que os valores sejam considerados próximos, a diferença entre eles deve ser menor que pelo menos uma das tolerâncias.

    • 
#imprimindo se dois valores estão próximos ou não
math.isclose(2.005, 2.005) #Saída: True
math.isclose(2.005, 2.004) #Saída: False
math.isclose(2.006, 2.005) #Saída: False
  • math.isfinite(x) - retorna True se x não for um infinito nem um NaN e False caso contrário. (Observe que 0,0 é considerado finito.) 
    • 
math.isfinite(5) #Saída: True
math.isfinite(float('nan')) #Saída: False
math.isfinite(-2.5) #Saída: True
math.isfinite(0.0) #Saída: True
  • math.isinf(x) - retorna True se x for um infinito positivo ou negativo e False caso contrário. 
    • 
math.isinf(float('-inf')) #Saída: True
math.isinf(float('nan')) #Saída: False
math.isinf(0.0) #Saída: False
  • math.nan(0.0) - retorna True se x for um NaN (não é um número) e False caso contrário. 
    • 
math.isnan(float('nan')) #Saída: True
math.isnan(math.pi) #Saída: False
  • math.ldexp(x, i) - retorna x * (2 ** i). Por examplo, se x = 3 e i = 4 então, math.ldexp(3, 4) = 3 * 16 = 48.0. É o inverso da função frexp(). 
    • 
math.ldexp(9, 3) #Saída: 72
math.ldexp(-5, 2) #Saída: -20
math.ldexp(3, 4) #Saída: 48.0
  • math.modf(x) - retorna as partes fracionárias e inteiras do número em uma tupla de dois itens. Ambas as partes têm o mesmo sinal que o número. A parte inteira é retornada como um float. 
    • 
math.modf(100.12) #Saída:(0.12000000000000455, 100.0)
math.modf(-100.72) #Saída: (-0.7199999999999989, -100.0)
math.modf(2) #Saída: (0.0, 2.0)
  • math.remainder(x, y) - retorna o resto no estilo IEEE 754 de x em relação a y. Para x finito e y finito diferente de zero, essa é a diferença x - n * y, em que n é o número inteiro mais próximo do valor exato do quociente x / y. Se x / y estiver exatamente na metade do caminho entre dois números inteiros consecutivos, o número par mais próximo será usado para n. O resto r = remainder(x, y), portanto, sempre satisfaz abs (r) <= 0.5 * abs (y). 
    • 
math.remainder(26,7) #Saída: -2.0
  • math.trunc(x) - retorna o valor real x truncado para um integral (geralmente um número inteiro). 
    • 
math.trunc(-3.5) #Saída: -3
math.trunc(3.5) #Saída: 3
 

Potência e funções logarítmicas

  • math.exp(x) - este método é usado para calcular a potência de e(Euler), ou seja, e ^ y ou podemos dizer exponencial de y. O valor de e é aproximadamente igual a 2.71828…Essa opção é mais precisa do que math.e ** x ou pow(math.e, x). 
    • 
math.exp(4) #Saída: 54.598150033144236
math.exp(1e-5) - 1  # fornece resultado preciso para 11 casas. Saída: 1.0000050000069649e-05
 
  • math.expm1(x) - retorna e(euler) elevado à potência x, menos 1. Aqui e é a base dos logaritmos naturais. Para x floats pequenos, a subtração em exp (x) - 1 pode resultar em uma perda significativa de precisão, a função expm1() fornece uma maneira de calcular essa quantidade com precisão total. 
    • 
math.expm1(4) #Saída: 53.598150033144236
math.expm1(1e-5) # Precisão total. Saída: 1.0000050000166667e-05
#Obs: 1e-5 é uma notação numérica científica, isso significa 1 × 10^-5. Em outras palavras, 0,00001.
 
  • math.log(x[, base]) - com um argumento, retorna o logaritmo natural de x (para a base e).Com dois argumentos, retorna o logaritmo de x para a base especificada, calculada como log (x) / log (base). 
    • 
#log de 14 na base e
math.log(14) #Saída: 2.6390573296152584
#log de 14 na base 5
math.log(14, 5) #Saída: 1.6397385131955606
 
  • math.log1p(x) - retorna o logaritmo natural de 1 + x (base e). O resultado é calculado de maneira precisa para x próximo a zero. 
    • 
math.log1p(21) #Saída: 3.091042453358316
 
  • math.log2(x) - retorna o logaritmo de x na base 2. Isso geralmente é mais preciso que o math.log (x, 2). 
    • 
math.log2(14) #Saída: 3.807354922057604
 
  • math.log10(x) - retorna o logaritmo de x na base 10. Isso geralmente é mais preciso que math.log (x, 10). 
    • 
math.log10(14) #log de 14 na base 10. Saída: 1.146128035678238
 
  • math.pow(x, y)) - retorna x elevado à potência y. Em particular, pow (1.0, x) e pow (x, 0.0) sempre retornam 1.0, mesmo quando x é zero ou NaN. Se x e y são finitos, x é negativo e y não é um número inteiro, então pow (x, y) é indefinido e gera ValueError.Diferentemente do operador interno **, math.pow () converte os dois argumentos no tipo float. Use ** ou a função pow () integrada para calcular potências inteiras exatas. 
    • 
math.pow(2,3) #2^3. Saída: 8.0
 
  • math.sqrt(x) - retorna a raiz quadrada de x. 
    • 
math.sqrt(81) #Saída: 9.0
 

Funções trigonométricas

  • math.acos(x) - retorna o arco cosseno de x, em radianos.. 
    • 
math.acos(1) #Saída: 0.0
math.acos(-1) #Saída: 3.141592653589793
 
  • math.asin(x) - retorna o arco seno de x, em radianos.. 
    • 
math.asin(0.5) #Saída: 0.5235987755982989
 
  • math.atan(x) - retorna o arco tangente de x, em radianos. 
    • 
math.atan(0.5) #Saída: 0.4636476090008061
 
  • math.atan2(y, x) - retorna a tangente do arco de x, em radianos. Retorna atan (y / x), em radianos. O resultado está entre -pi e pi. O vetor no plano da origem ao ponto (x, y) faz esse ângulo com o eixo X positivo. O ponto do atan2 () é que os sinais de ambas as entradas são conhecidos, para que possa calcular o quadrante correto para o ângulo. Por exemplo, atan (1) e atan2 (1, 1) são ambos pi / 4, mas atan2 (-1, -1) é -3 * pi / 4. 
    • 
math.atan2(1, 1) #Saída: 0.7853981633974483
math.atan2(-1, -1) #Saída: -2.356194490192345
 
  • math.cos(x) - retorna o cosseno de x radianos. 
    • 
math.cos(1.047197551) #Saída: 0.5000000001702586
 
  • math.hypot(x, y) - retorna a norma euclidiana, sqrt (x * x + y * y). Este é o comprimento do vetor da origem ao ponto (x, y). 
    • 
math.hypot(3, 4) #Saída: 5.0
 
  • math.sin(x) - retorna o seno de x radianos. 
    • 
a = math.pi / 6
math.sin(a) #Saída: 0.49999999999999994
 
  • math.tan(x) - a tangente de x radianos. 
    • 
a = math.pi / 6
math.tan(a) #Saída: 0.5773502691896257
 

Funções hiperbólicas

Funções hiperbólicas são análogas a funções trigonométricas, só que baseadas em hipérboles em vez de círculos.
  • math.acosh(x) - retorna o cosseno hiperbólico inverso de x. 
    • 
math.acosh(2) #Saída: 1.3169578969248166
 
  • math.asinh(x) - retorna o seno hiperbólico inverso de x. 
    • 
math.asinh(2) #Saída: 1.4436354751788103
 
  • math.atanh(x) - retorna a tangente hiperbólica inversa de x. 
    • 
math.atanh(.99) #Saída: 2.6466524123622457
 
  • math.cosh(x) - retorna o cosseno hiperbólico de x. 
    • 
math.cosh(1.5)  #Saída: 2.352409615243247
 
  • math.sinh(x) - retorna o seno hiperbólico de x. 
    • 
math.sinh(1.5)  #Saída: 2.1292794550948173
  • math.tanh(x) - retorna a tangente hiperbólica de x. 
    • 
math.tanh(1.5) #Saída: 0.9051482536448664

Funções especiais

  • math.erf(x) - retorna a função de erro em x. A função erf () pode ser usada para calcular funções estatísticas tradicionais, como a distribuição normal padrão cumulativa. Note que erf(-x) == -erf(x). 
    • 
print('{:^5}  {:7}'.format('x', 'erf(x)'))
print('{:-^5}  {:-^7}'.format('', ''))
for x in [ -3, -2, -1, -0.5, -0.25, 0, 0.25, 0.5, 1, 2, 3 ]:
    print('{:5.2f}  {:7.4f}'.format(x, math.erf(x)))
#Saída:
# x    erf(x)
#-----  -------
#-3.00  -1.0000
#-2.00  -0.9953
#-1.00  -0.8427
#-0.50  -0.5205
#-0.25  -0.2763
# 0.00   0.0000
# 0.25   0.2763
# 0.50   0.5205
# 1.00   0.8427
# 2.00   0.9953
# 3.00   1.0000
 
  • math.erfc(x) - função de erro complementar em x. A função de erro complementar é definida como 1.0 - erf (x). É usado para grandes valores de x em que a subtração de um(1) pode causar perda de significância. 
    • 
print('{:^5} {:7}'.format('x', 'erfc(x)')) 
print('{:-^5} {:-^7}'.format('', '')) 
for x in [ -3, -2, -1, -0.5, -0.25, 0, 0.25, 0.5, 1, 2, 3 ]: 
    print('{:5.2f} {:7.4f}'.format(x, math.erfc(x)))
#Saída:
# x    erf(x)
#-----  -------
#-3.00  2.0000
#-2.00  1.9953
#-1.00  1.8427
#-0.50  1.5205
#-0.25  1.2763
# 0.00  1.0000
# 0.25  0.7237
# 0.50  0.4795
# 1.00  0.1573
# 2.00  0.0047
# 3.00  0.0000
  • math.gamma(x) - retorna a função Gamma em x. Em matemática, a função gamma é uma extensão comumente usada da função fatorial para números complexos. A função gamma é definida para todos os números complexos, exceto os números inteiros não positivos. Para qualquer número inteiro positivo. 
    • 
# inicializa o argumento 
gamma_var = 6
# Imprime o valor gama. 
print ("O valor gama do argumento fornecido é: : " + str(math.gamma(gamma_var))) 
#Saída: O valor gama do argumento fornecido é: : 120.0
  • math.lgamma(x) - retorna o logaritmo natural do valor absoluto da função Gamma em x. 
    • 
math.tanh(1.5)  #Saída: 0.9051482536448664

Constantes

  • math.pi - constante matemática π = 3,141592… 
    • 
math.pi  #Saída: 3.141592653589793
  • math.e - A constante matemática e = 2,718281… 
    • 
math.e  #Saída: 2.718281828459045
  • math.tau - A constante matemática τ = 6.283185… Tau é uma constante de círculo igual a 2π, a razão entre a circunferência de um círculo e seu raio. 
    • 
math.tau  #Saída: 6.283185307179586
  • math.inf - um infinito positivo de ponto flutuante. (Para infinito negativo, use -math.inf. Equivalente à saída de float ('inf'). 
    • 
math.inf  #Saída: inf
  • math.nan - um valor de ponto flutuante "não é um número" (NaN). Equivalente à saída de float ('nan'). 
    • 
math.nan  #Saída: nan

Ficamos por aqui, nos vemos na próxima aula.  🖖

Se gostarem do conteúdo dêem um joinha 👍 na página do Código Fluente no Facebook

Esse é o link do código fluente no Pinterest

Meus links de afiliados:

Hostinger

Digital Ocean

One.com

Obrigado, até e bons estudos. ;)