Aula 19 – Python – Biblioteca Padrão – Módulo math

More videos
Views
   

Aula 19 – Python – Biblioteca Padrão – Módulo math

Python - módulo math do python

Python – módulo math do python

Aula anterior

Próxima aula

Página principal

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

Seguindo 😉

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 , 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.  🖖

Aula anterior

Próxima aula

Página principal

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. 😉

 

 

 

 

 

 

 

(Visited 28 times, 1 visits today)
About The Author
-

You may use these HTML tags and attributes: <a href="" title=""> <abbr title=""> <acronym title=""> <b> <blockquote cite=""> <cite> <code> <del datetime=""> <em> <i> <q cite=""> <s> <strike> <strong>