Tutorial de Python Scipy

En esta lección, veremos cuál es el uso de la biblioteca Scipy en Python y cómo nos ayuda a trabajar con ecuaciones y algoritmos matemáticos de manera interactiva. Lo bueno del paquete Scipy Python es que si queremos clases o construimos páginas web, Scipy es totalmente compatible con el sistema en su conjunto y puede proporcionar una integración perfecta.

Como Scipy es de código abierto, Tiene una comunidad de desarrolladores muy activa y vibrante debido a la cual hay una enorme cantidad de módulos presentes para una gran cantidad de aplicaciones y cálculos científicos disponibles con SciPy. Algunas de las complejas operaciones matemáticas que se pueden realizar con Scipy son:

• Interpolación
• Integración
• Mejoramiento
• Procesamiento de imágenes
• Estadísticas
• Cálculos de funciones especiales, etc.

Scipy se puede comparar con la mayoría de las bibliotecas de comando y estándar como la biblioteca GSL para C ++ y Matlab. Como Scipy se construye sobre el paquete Numpy, estos dos paquetes también se pueden integrar por completo. Si puede pensar en una operación matemática que debe hacerse, asegúrese de verificar la biblioteca SciPy antes de implementar ese módulo por su cuenta porque en la mayoría de los casos, Scipy tiene todas las operaciones para usted ya implementadas completamente.

Instalar biblioteca Scipy

Instalemos la biblioteca Scipy antes de pasar a los ejemplos y conceptos reales. Hay dos formas de instalar este paquete. El primero incluye usar el Administrador de paquetes de Python, PIP:

PIP Instalar Scipy

La segunda forma se relaciona con Anaconda, podemos instalar el paquete como:

Conda install -c anaconda scipy

Una vez que se instala la biblioteca, podemos importarla como:

importación

Finalmente, como también usaremos Numpy (se recomienda que para todas las operaciones Numpy, usemos Numpy directamente en lugar de pasar por el paquete Scipy):

importar numpy

Es posible que en algunos casos, también nos gustaría trazar nuestros resultados para los cuales usaremos la biblioteca Matplotlib. Realice la siguiente importación para esa biblioteca:

Importar matplotlib

Usaré el Administrador de Anaconda para todos los ejemplos de esta lección. Lanzaré un cuaderno Jupyter para lo mismo:

Ahora que estamos listos con todas las declaraciones de importación para escribir algún código, comencemos a sumergirnos en el paquete Scipy con algunos ejemplos prácticos.

Trabajar con ecuaciones polinomiales

Comenzaremos mirando ecuaciones polinomiales simples. Hay dos formas con las que podemos integrar funciones polinomiales en nuestro programa. Podemos hacer uso de poli1d clase que utiliza coeficientes o las raíces de un polinomio para inicializar un polinomio. Veamos un ejemplo:

de Numpy Import Poly1d
First_Polynomial = Poly1d ([3, 4, 7])
Imprimir (First_Polynomial)

Cuando ejecutemos este ejemplo, veremos la siguiente salida:

Claramente, la representación polinomial de la ecuación se imprime como salida para que el resultado sea bastante fácil de entender. Podemos realizar varias operaciones en este polinomio, como el cuadrado, encontrar su derivado o incluso resolverlo para un valor de x. Intentemos hacer todo esto en el siguiente ejemplo:

Imprimir ("Polinomio cuadrado: \ n")
print (First_Polynomial * First_Polynomial)
Imprimir ("Derivado del polinomio: \ n")
Imprimir (First_Polynomial.deriv ())
Imprimir ("Resolver el polinomio: \ n")
Imprimir (First_Polynomial (3))

Cuando ejecutemos este ejemplo, veremos la siguiente salida:

Justo cuando pensaba que esto es todo lo que pudimos hacer con Scipy, recordé que también podemos integrar un polinomio. Ejecutemos un último ejemplo con polinomios:

imprimir ("integrando el polinomio: \ n")
Imprimir (First_Polynomial.Integ (1))

El entero que pasamos le dice al paquete cuántas veces para integrar el polinomio:

Simplemente podemos pasar otro número entero que le indique el paquete cuántas veces para integrar este polinomio.

Resolver ecuaciones lineales

Incluso es posible resolver ecuaciones lineales con Scipy y encontrar sus raíces, si existen. Para resolver ecuaciones lineales, representamos el conjunto de ecuaciones como matrices numpy y su solución como matrices numpy separadas. Vamos a visualizarlo con un ejemplo en el que hacemos lo mismo y hacemos uso de linalg Paquete Para encontrar las raíces de las ecuaciones, aquí están las ecuaciones que resolveremos:

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

Resolvamos las ecuaciones anteriores:

de scipy import linalg
ecuación = NP.Array ([[1, 5], [3, 7]])
Solución = NP.Array ([[6], [9]])
raíces = linalg.resolver (ecuación, solución)
Imprimir ("Encontré las raíces:")
Imprimir (raíces)
Imprimir ("\ n Dot El producto debe ser cero si las soluciones son correctas:")
imprimir (ecuación.Dot (raíces) - Solución)

Cuando ejecutemos el programa anterior, veremos que la ecuación del producto DOT da un resultado cero, lo que significa que las raíces que el programa encontró eran correctas:

Transformaciones de Fourier con Scipy

Las transformaciones de Fourier nos ayudan a expresar una función como componentes separados que componen esa función y nos guía sobre la forma en que podemos recombinar esos componentes para recuperar la función original.

Veamos un ejemplo simple de transformaciones de Fourier donde trazamos la suma de dos cosenos usando la biblioteca matplotlib:

De Scipy.fftpack import fft
# Número de puntos de muestra
N = 500
# espaciado de muestra
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 trazar fines
Importar matplotlib.Pyplot como PLT
PLT.Parcela (XF, 2.0/n * np.ABS (YF [0: N // 2]))
PLT.Título ('Info')
PLT.Ylabel ('y eje')
PLT.xlabel ('x eje')
PLT.red()
PLT.espectáculo()

Aquí, comenzamos construyendo un espacio de muestra y una ecuación de coseno que luego transformamos y trazamos. Aquí está el resultado del programa anterior:

Este es uno de los buen ejemplo en el que vemos que Scipy se usa en una ecuación matemática compleja para visualizar las cosas fácilmente.

Vectores y matriz con Scipy

Ahora que sabemos muchas cosas de las que Scipy es capaz, podemos estar seguros de que Scipy también puede funcionar con vectores y matriz. Las matrices son una parte importante del álgebra lineal, ya que las matrices es algo que usamos para representar mapeos vectoriales también.

Al igual que miramos resolver ecuaciones lineales con Scipy, podemos representar vectores con notario público.formación() funciones. Comencemos por construir una matriz:

my_matrix = np.matriz (NP.aleatorio.aleatorio ((3, 3)))
imprimir (my_matrix)

Aquí está la salida del fragmento anterior:

Cada vez que hablamos de matrices, siempre hablamos de valores propios y vectores propios. Para poner en palabras simples, los vectores propios son los vectores que, cuando se multiplican con una matriz, no cambian su dirección, en lugar de la mayoría de los vectores. Esto significa que incluso cuando multiplica un vectores propios con una matriz, existe un valor (o valor propio) que es uno de los factores de la multiplicación. Esto significa:

Ax = λx.

En la ecuación anterior, a es la matriz, λ es el valor propio y x es el vector. Escribamos un fragmento de código simple para encontrar los valores propios para un vector dado:

la, vector = linalg.eig (my_matrix)
Impresión (vector [:, 0])
Impresión (vector [:, 1])
imprimir (linalg.Eigvals (my_matrix))

Cuando ejecutemos este ejemplo, veremos la siguiente salida:

Matriz calculador determinante

La siguiente operación que llevaremos a cabo con SciPy es calcular el determinante de una matriz bidimensional. Reutilizaremos la matriz que usamos en el último fragmento de código aquí:

linalg.det (my_matrix)

Cuando ejecutemos este ejemplo, veremos la siguiente salida:

Conclusión

En esta lección, observamos muchos buenos ejemplos en los que Scipy puede ayudarnos llevando a cabo cálculos matemáticos complejos para nosotros con una API y paquetes fáciles de usar.