Tutoriel Python Scipy

Dans cette leçon, nous verrons quelle est l'utilisation de la bibliothèque Scipy à Python et comment elle nous aide à travailler avec des équations et des algorithmes mathématiques de manière interactive. La bonne chose à propos de Scipy Python Package est que si nous voulons des cours ou construire des pages Web, Scipy est entièrement compatible avec le système dans son ensemble et peut fournir une intégration transparente.

Comme Scipy est open source, Il a une communauté de développeurs très active et dynamique en raison duquel il existe un nombre énorme de modules présents pour une grande quantité d'applications scientifiques et de calculs disponibles avec Scipy. Certaines des opérations mathématiques complexes qui peuvent être effectuées avec Scipy sont:

• Interpolation
• L'intégration
• Optimisation
• Traitement d'image
• Statistiques
• Calculs de fonctions spéciales, etc.

Scipy peut être comparé à la plupart des bibliothèques de commande et standard comme la bibliothèque GSL pour C ++ et Matlab. Comme Scipy est construit sur le package Numpy, ces deux packages peuvent également être intégrés complètement. Si vous pouvez penser à une opération mathématique qui doit être effectuée, assurez-vous de vérifier la bibliothèque Scipy avant de mettre en œuvre ce module par vous-même, car dans la plupart des cas, Scipy a toutes les opérations pour vous déjà implémentées entièrement implémentées.

Installer la bibliothèque Scipy

Installons la bibliothèque Scipy avant de passer aux exemples et concepts réels. Il existe deux façons d'installer ce package. Le premier comprend l'utilisation du gestionnaire de packages Python, PIP:

pip install scipy

La deuxième voie concerne Anaconda, nous pouvons installer le package comme:

Conda Install -C Anaconda Scipy

Une fois la bibliothèque installée, nous pouvons l'importer comme:

importer scipy

Enfin, comme nous utiliserons également Numpy (il est recommandé que pour toutes les opérations Numpy, nous utilisons Numpy directement au lieu de passer par le package Scipy):

Importer Numpy

Il est possible que dans certains cas, nous aimerions également tracer nos résultats pour lesquels nous utiliserons la bibliothèque Matplotlib. Effectuez l'importation suivante pour cette bibliothèque:

Importer Matplotlib

J'utiliserai le directeur d'Anaconda pour tous les exemples de cette leçon. Je lancerai un cahier Jupyter pour le même:

Maintenant que nous sommes prêts avec toutes les déclarations d'importation pour écrire du code, commençons à plonger dans le package Scipy avec quelques exemples pratiques.

Travailler avec des équations polynomiales

Nous allons commencer par regarder des équations polynomiales simples. Il y a deux façons avec lesquelles nous pouvons intégrer les fonctions polynomiales dans notre programme. Nous pouvons utiliser poly1d classe qui utilise des coefficients ou les racines d'un polynôme pour initialiser un polynôme. Regardons un exemple:

de Numpy Import Poly1d
first_polynomial = poly1d ([3, 4, 7])
imprimer (first_polynomial)

Lorsque nous exécutons cet exemple, nous verrons la sortie suivante:

De toute évidence, la représentation polynomiale de l'équation est imprimée en tant que sortie afin que le résultat soit assez facile à comprendre. Nous pouvons également effectuer diverses opérations sur ce polynôme, comme le carré, trouver sa dérivée ou même le résoudre pour une valeur de x. Essayons de faire tout cela dans l'exemple suivant:

Print ("Polynomial Square: \ n")
print (first_polynomial * first_polynomial)
print ("Dérivé du polynôme: \ n")
imprimer (first_polynomial.Deriv ())
Print ("Résolution du polynôme: \ n")
print (first_polynomial (3))

Lorsque nous exécutons cet exemple, nous verrons la sortie suivante:

Juste au moment où je pensais que c'est tout ce que nous pouvions faire avec Scipy, je me suis souvenu que nous pouvons également intégrer un polynôme. Exécutons un dernier exemple avec les polynômes:

Print ("Intégration du polynôme: \ n")
imprimer (first_polynomial.INTEG (1))

L'entier que nous passons indique le package combien de fois pour intégrer le polynôme:

Nous pouvons simplement passer un autre entier qui indique au paquet combien de fois pour intégrer ce polynôme.

Résolution d'équations linéaires

Il est même possible de résoudre les équations linéaires avec Scipy et de trouver leurs racines, si elles existent. Pour résoudre les équations linéaires, nous représentons l'ensemble des équations comme des tableaux numpy et leur solution comme des tableaux numpy distincts. Visualisons-le avec un exemple où nous faisons de même et utilisons linalg Package Pour trouver les racines des équations, voici les équations que nous résoudrons:

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

Résolvons les équations ci-dessus:

de Scipy Import Linalg
équation = np.Array ([[1, 5], [3, 7]])
solution = np.Array ([[6], [9]))
Racines = Linalg.résoudre (équation, solution)
Imprimer ("Found the Roots:")
imprimer (racines)
Imprimer ("\ n Dot Le produit doit être nul si les solutions sont correctes:")
imprimer (équation.point (racines) - solution)

Lorsque nous exécutons le programme ci-dessus, nous verrons que l'équation du produit DOT ne donne aucun résultat, ce qui signifie que les racines que le programme a trouvées étaient correctes:

Transformations de Fourier avec Scipy

Les transformations de Fourier nous aident à exprimer une fonction en tant que composants distincts qui composent cette fonction et nous guident sur la façon dont nous pouvons recombiner ces composants pour récupérer la fonction d'origine.

Regardons un exemple simple de transformations de Fourier où nous tracons la somme de deux cosinus en utilisant la bibliothèque Matplotlib:

de Scipy.FFTPACK IMPORT FFT
# Nombre de points d'échantillonnage
N = 500
# Espacement des échantillons
T = 1.0/800.0
x = np.lispace (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.lispace (0.0, 1.0 / (2.0 * t), n // 2)
# Matplotlib à des fins de traçage
Importer Matplotlib.pypllot comme plt
PLT.Terrain (XF, 2.0 / n * np.abs (yf [0: n // 2]))
PLT.titre ('info')
PLT.ylabel ('axe y)
PLT.xlabel ('x axe')
PLT.grille()
PLT.montrer()

Ici, nous avons commencé par construire un espace d'échantillon et une équation de cosinus que nous avons ensuite transformé et tracé. Voici la sortie du programme ci-dessus:

C'est l'un des bons exemple où nous voyons Scipy être utilisé dans une équation mathématique complexe pour visualiser facilement les choses.

Vecteurs et matrice avec scipy

Maintenant que nous savons beaucoup de choses dont Scipy est capable, nous pouvons être sûrs que Scipy peut également travailler avec des vecteurs et une matrice. Les matrices sont une partie importante de l'algèbre linéaire car les matrices sont quelque chose que nous utilisons pour représenter également les mappages vectoriels.

Tout comme nous avons cherché à résoudre des équations linéaires avec Scipy, nous pouvons représenter des vecteurs avec NP.déployer() les fonctions. Commençons par construire une matrice:

my_matrix = np.matrice (np.aléatoire.aléatoire ((3, 3)))
imprimer (my_matrix)

Voici la sortie de l'extrait ci-dessus:

Chaque fois que nous parlons de matrices, nous parlons toujours des valeurs propres et des vecteurs propres. Pour mettre des mots simples, les vecteurs propres sont les vecteurs qui, lorsqu'ils sont multipliés par une matrice, ne changent pas leur direction, par opposition à la plupart des vecteurs. Cela signifie que même lorsque vous multipliez un vecteurs propres avec une matrice, il existe une valeur (ou une valeur propre) qui est l'un des facteurs de la multiplication. Ça signifie:

Hache = λx.

Dans l'équation ci-dessus, a est la matrice, λ est la valeur propre et x est le vecteur. Écrivons un extrait de code simple pour trouver les valeurs propres pour un vecteur donné:

LA, vector = linalg.eig (my_matrix)
imprimer (vecteur [:, 0])
imprimer (vecteur [:, 1])
Imprimer (Linalg.eigvals (my_matrix))

Lorsque nous exécutons cet exemple, nous verrons la sortie suivante:

Calcul du déterminant de la matrice

La prochaine opération que nous effectuerons avec Scipy est de calculer le déterminant d'une matrice bidimensionnelle. Nous réutiliserons la matrice que nous avons utilisée dans le dernier extrait de code ici:

linalg.DET (MY_MATRIX)

Lorsque nous exécutons cet exemple, nous verrons la sortie suivante:

Conclusion

Dans cette leçon, nous avons examiné de nombreux bons exemples où Scipy peut nous aider en effectuant des calculs mathématiques complexes pour nous avec une API et des packages faciles à utiliser.