Aula 19 – Python – Biblioteca Padrão – Módulo math
Aula 19 – Python – Biblioteca Padrão – Módulo math
Python – módulo math do python
Que fazer esse curso com certificação?
Acesse:
https://workover.com.br/python-codigo-fluente
Voltar para página principal do blog
Todas as aulas desse curso
Aula 18 Aula 20
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
Automatize tarefas do dia a dia com python:
Curso Python Bot
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ãomath.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
- Parâmetros:
- 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. 🖖
Voltar para página principal do blog
Todas as aulas desse curso
Aula 18 Aula 20
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. 😉
Category: Algoritmo - Linguagem de Programação, Python
