Tutorial de Python Scipy

Nesta lição, veremos qual é o uso da Biblioteca Scipy em Python e como isso nos ajuda a trabalhar com equações e algoritmos matemáticos de maneira interativa. A coisa boa do pacote Scipy Python é que, se quisermos aulas ou construir páginas da web, o Scipy é totalmente compatível com o sistema como um todo e pode fornecer integração perfeita.

Como Scipy é código aberto, Possui uma comunidade muito ativa e vibrante de desenvolvedores, devido à qual há um número enorme de módulos presentes para uma grande quantidade de aplicações científicas e cálculos disponíveis com scipy. Algumas das operações matemáticas complexas que podem ser realizadas com Scipy são:

• Interpolação
• Integração
• Otimização
• Processamento de imagem
• Estatisticas
• Cálculos de função especial etc.

Scipy pode ser comparado à maioria das bibliotecas de comando e padrão como a biblioteca GSL para C ++ e Matlab. Como o Scipy é construído sobre o pacote Numpy, esses dois pacotes também podem ser integrados. Se você consegue pensar em uma operação matemática que precisa ser feita, verifique a biblioteca scipy antes de implementar esse módulo por conta própria, porque na maioria dos casos, o SCIPY tem todas as operações para você já implementado já.

Instale a biblioteca Scipy

Vamos instalar a biblioteca scipy antes de mudarmos para os exemplos e conceitos reais. Existem duas maneiras de instalar este pacote. Primeiro inclui o uso do Python Package Manager, PIP:

pip install scipy

A segunda maneira está relacionada a Anaconda, podemos instalar o pacote como:

CONDA INSTAL

Depois que a biblioteca estiver instalada, podemos importá -la como:

Importar Scipy

Finalmente, como usaremos o Numpy também (é recomendável que, para todas as operações Numpy, usemos o Numpy diretamente em vez de passar pelo pacote cipy):

importar numpy

É possível que, em alguns casos, também gostemos de plotar nossos resultados para os quais usaremos a Biblioteca Matplotlib. Execute a seguinte importação para essa biblioteca:

importar matplotlib

Estarei usando o gerente da Anaconda para todos os exemplos nesta lição. Vou lançar um notebook Jupyter para o mesmo:

Agora que estamos prontos com todas as declarações de importação para escrever algum código, vamos começar a mergulhar no pacote scipy com alguns exemplos práticos.

Trabalhando com equações polinomiais

Começaremos olhando para equações polinomiais simples. Existem duas maneiras pelas quais podemos integrar funções polinomiais em nosso programa. Podemos usar poli1d classe que utiliza coeficientes ou raízes de um polinômio para inicializar um polinômio. Vejamos um exemplo:

De Numpy Import Poly1D
primeiro_polynomial = poly1d ([3, 4, 7])
Imprimir (First_Polynomial)

Quando executamos este exemplo, veremos a seguinte saída:

Claramente, a representação polinomial da equação é impressa como a saída para que o resultado seja muito fácil de entender. Também podemos executar várias operações neste polinomial, como o quadrado, encontrar seu derivado ou até mesmo resolvê -lo por um valor de x. Vamos tentar fazer tudo isso no próximo exemplo:

Imprimir ("quadrado polinomial: \ n")
Print (First_Polynomial * First_Polynomial)
Print ("Derivado do Polinômio: \ N")
Imprimir (First_Polynomial.deriv ())
print ("Solução do polinômio: \ n")
Imprimir (First_polynomial (3))

Quando executamos este exemplo, veremos a seguinte saída:

Apenas quando eu estava pensando que isso é tudo o que poderíamos fazer com Scipy, lembrei -me de que podemos integrar um polinomial também. Vamos executar um exemplo final com polinômios:

print ("Integrando o polinômio: \ n")
Imprimir (First_Polynomial.integ (1))

O número inteiro que passamos diz ao pacote quantas vezes para integrar o polinomial:

Podemos simplesmente passar por outro número inteiro que informa ao pacote quantas vezes para integrar este polinomial.

Resolvendo equações lineares

É até possível resolver equações lineares com círculo e encontrar suas raízes, se elas existirem. Para resolver equações lineares, representamos o conjunto de equações como matrizes Numpy e sua solução como uma matriz Numpy separada. Vamos visualizá -lo com um exemplo em que fazemos o mesmo e utilizamos Linalg Pacote para encontrar as raízes das equações, aqui estão as equações que estaremos resolvendo:

1x + 5y = 6
3x + 7y = 9

Vamos resolver as equações acima:

De Scipy importar linalg
equação = np.Array ([[1, 5], [3, 7]]))
solução = np.Array ([[6], [9]])
raízes = linalg.Resolva (equação, solução)
Print ("Found the Roots:")
Impressão (raízes)
Print ("\ n DOT Product deve ser zero se as soluções estiverem corretas:")
Imprimir (equação.DOT (raízes) - Solução)

Quando executamos o programa acima, veremos que a equação do produto DOT fornece resultado zero, o que significa que as raízes que o programa encontrou estavam corretas:

Transformações de Fourier com Scipy

As transformações de Fourier nos ajudam a expressar uma função como componentes separados que compõem essa função e nos guia sobre a maneira como podemos recombinar esses componentes para obter a função original de volta.

Vejamos um exemplo simples de transformações de Fourier, onde traçamos a soma de dois cossenos usando a biblioteca Matplotlib:

de Scipy.fftpack importar fft
# Número de pontos de amostra
N = 500
# espaçamento de amostra
T = 1.0/800.0
x = np.Linspace (0.0, n*t, n)
y = np.cos (50.0 * 2.0* np.pi * x) + 0.5 * np.cos (80.0 * 2.0 * np.pi * x)
yf = fft (y)
xf = np.Linspace (0.0, 1.0/(2.0 * t), n // 2)
# matplotlib para fins de plotagem
importar matplotlib.pyplot como plt
plt.Lote (XF, 2.0/n * np.ABS (YF [0: N // 2])))
plt.título ('info')
plt.ylabel ('y eixo')
plt.xlabel ('x eixo')
plt.grade()
plt.mostrar()

Aqui, começamos a construir um espaço de amostra e uma equação de cosseno que transformamos e plotamos. Aqui está a saída do programa acima:

Este é um dos bons exemplos em que vemos Scipy sendo usado em uma equação matemática complexa para visualizar as coisas facilmente.

Vetores e matriz com scipy

Agora que sabemos muitas coisas das quais Scipy é capaz, podemos ter certeza de que o Scipy também pode funcionar com vetores e matrizes. As matrizes são uma parte importante da álgebra linear, pois as matrizes são algo que usamos para representar mapeamentos de vetores também.

Assim como olhamos para resolver equações lineares com scipy, podemos representar vetores com NP.variedade() funções. Vamos começar construindo uma matriz:

my_matrix = np.Matrix (NP.aleatório.aleatório ((3, 3)))
Imprimir (my_matrix)

Aqui está a saída do trecho acima:

Sempre que falamos sobre matrizes, sempre falamos sobre valores próprios e autovetores. Para colocar palavras simples, os vetores próprios são os vetores que, quando multiplicados com uma matriz, não mudam de direção, em oposição à maioria dos vetores. Isso significa que, mesmo quando você multiplica os autovetores com uma matriz, existe um valor (ou autovalor), que é um dos fatores da multiplicação. Isso significa:

Ax = λx.

Na equação acima, a é a matriz, λ é o autovalor e x é o vetor. Vamos escrever um snippet de código simples para encontrar os valores próprios para um determinado vetor:

la, vetor = linalg.Eig (my_matrix)
Imprimir (vetor [:, 0])
Imprimir (vetor [:, 1])
Imprimir (Linalg.EigVals (my_matrix))

Quando executamos este exemplo, veremos a seguinte saída:

Cálculo da matriz determinante

A próxima operação que realizaremos com Scipy é calcular o determinante de uma matriz bidimensional. Vamos reutilizar a matriz que usamos no último trecho de código aqui:

Linalg.det (my_matrix)

Quando executamos este exemplo, veremos a seguinte saída:

Conclusão

Nesta lição, analisamos muitos bons exemplos em que o Scipy pode nos ajudar, realizando cálculos matemáticos complexos para nós com uma API e pacotes fáceis de usar.