PyPlot.jl
v2.11.5
Ce module fournit une interface Julia à la bibliothèque de traçage Matplotlib de Python, et spécifiquement au module matplotlib.pyplot .
PyPlot utilise le package Julia PyCall pour appeler Matplotlib directement depuis Julia avec peu ou pas de surcharge (les tableaux sont transmis sans faire de copie). (Voir également PythonPlot.jl pour une version de PyPlot.jl utilisant le package alternatif PythonCall.jl.)
Ce package tire parti de l'API d'E/S multimédia de Julia pour afficher des tracés dans n'importe quel backend graphique Julia, y compris sous forme de graphiques en ligne dans IJulia. Vous pouvez également utiliser un backend graphique Matplotlib basé sur Python pour prendre en charge le zoom interactif sur le tracé, etc.
(Ce package PyPlot remplace un package antérieur du même nom de Junfeng Li, qui utilisait PyPlot sur un socket ZeroMQ avec IPython.)
Vous devrez installer la bibliothèque Python Matplotlib sur votre machine pour pouvoir utiliser PyPlot. Vous pouvez soit effectuer un traçage en ligne avec IJulia, qui ne nécessite pas de backend GUI, soit utiliser les backends Qt, wx ou GTK+ de Matplotlib comme décrit ci-dessous.
Une fois Matplotlib installé, vous pouvez simplement utiliser Pkg.add("PyPlot") dans Julia pour installer PyPlot et ses dépendances.
Si vous configurez PyCall pour utiliser le package Conda.jl pour installer une distribution Julia Python privée (pas dans le système PATH ) (via Miniconda), alors PyPlot installera automatiquement Matplotlib si nécessaire.
Si vous installez PyCall et PyPlot pour la première fois, faites simplement ENV["PYTHON"]="" avant d'exécuter Pkg.add("PyPlot") . Sinon, vous pouvez reconfigurer PyCall pour utiliser Conda via :
ENV [ " PYTHON " ] = " "
Pkg . build ( " PyCall " ) La prochaine fois que vous importerez PyPlot , il dira à Conda d'installer Matplotlib.
Sous MacOS, vous devez soit installer XQuartz pour MacOS 10.9 ou version ultérieure, soit installer la distribution Anaconda Python afin d'obtenir un PyPlot entièrement fonctionnel.
MacOS 10.9 est livré avec Python et Matplotlib, mais cette version de Matplotlib utilise par défaut le backend Cocoa GUI, qui n'est pas pris en charge par PyPlot. Il dispose également d'un backend Tk, qui est pris en charge, mais le backend Tk ne fonctionne que si vous installez XQuartz.
Alternativement, vous pouvez installer la distribution Anaconda Python (qui inclut également ipython et d'autres dépendances IJulia).
Sinon, vous pouvez utiliser le gestionnaire de packages Homebrew :
brew install python gcc freetype pyqt
brew link --force freetype
export PATH= " /usr/local/bin: $PATH "
export PYTHONPATH= " /usr/local/lib/python2.7: $PYTHONPATH "
pip install numpy scipy matplotlib (Vous souhaiterez peut-être ajouter les deux commandes export à votre fichier ~/.profile afin qu'elles soient automatiquement exécutées chaque fois que vous démarrez un shell.)
Une fois Matplotlib et PyPlot installés et que vous utilisez un environnement Julia compatible graphique tel que IJulia, vous pouvez simplement taper using PyPlot et commencer à appeler des fonctions dans l'API matplotlib.pyplot. Par exemple:
using PyPlot
# use x = linspace(0,2*pi,1000) in Julia 0.6
x = range ( 0 ; stop = 2 * pi , length = 1000 ); y = sin .( 3 * x + 4 * cos .( 2 * x));
plot (x, y, color = " red " , linewidth = 2.0 , linestyle = " -- " )
title ( " A sinusoidally modulated sinusoid " ) En général, tous les arguments, y compris les arguments de mots-clés, sont exactement les mêmes qu'en Python. (Avec des traductions mineures, bien sûr, par exemple Julia utilise true et nothing au lieu de True et None de Python.)
L'API matplotlib.pyplot complète est beaucoup trop étendue pour être décrite ici ; consultez la documentation matplotlib.pyplot pour plus d'informations. Le numéro de version de Matplotlib est renvoyé par PyPlot.version .
Seule l'API matplotlib.pyplot actuellement documentée est exportée. Pour utiliser d'autres fonctions du module, vous pouvez également appeler matplotlib.pyplot.foo(...) comme plt.foo(...) . Par exemple, plt.plot(x, y) fonctionne également. (Et le PyObject brut pour les modules matplotlib est également accessible en tant que PyPlot.matplotlib .)
Matplotlib est quelque peu incohérent en termes de majuscules : il a contour3D mais bar3d , etc. PyPlot renomme toutes ces fonctions pour utiliser un D majuscule (par exemple, il a hist2D , bar3D , etc.).
Vous devez également qualifier explicitement certaines fonctions intégrées aux fonctions Julia. En particulier, PyPlot.xcorr , PyPlot.axes et PyPlot.isinteractive doivent être utilisés pour accéder à matplotlib.pyplot.xcorr etc.
Si vous souhaitez accéder à toutes les fonctions PyPlot exclusivement via plt.somefunction(...) , comme c'est conventionnel en Python, vous pouvez import PyPlot; const plt = PyPlot au lieu using PyPlot .
Vous pouvez obtenir la figure actuelle sous forme d'objet Figure (un wrapper autour de matplotlib.pyplot.Figure ) en appelant gcf() .
Le type Figure prend en charge l'API d'E/S multimédia de Julia, vous pouvez donc utiliser display(fig) pour afficher un fig::PyFigure et show(io, mime, fig) (ou writemime dans Julia 0.4) pour l'écrire dans un type mime donné. chaîne (par exemple "image/png" ou "application/pdf" ) prise en charge par le backend Matplotlib.
Si vous utilisez PyPlot à partir d'une invite Julia interactive, telle que l'invite de ligne de commande Julia ou un bloc-notes IJulia, les tracés apparaissent immédiatement après l'évaluation d'une fonction de traçage ( plot etc.).
Cependant, si vous utilisez PyPlot à partir d'un script Julia exécuté de manière non interactive (par exemple julia myscript.jl ), alors Matplotlib est exécuté en mode non interactif : une fenêtre de tracé ne s'ouvre que lorsque vous exécutez show() (équivalent à plt.show() dans les exemples Python).
PyPlot peut utiliser n'importe quel backend graphique Julia capable d'afficher des images PNG, SVG ou PDF, tel que l'environnement IJulia. Pour utiliser un autre backend, appelez simplement pushdisplay avec le Display souhaité ; voir l'API d'affichage multimédia Julia pour plus de détails.
D'un autre côté, vous souhaiterez peut-être utiliser l'un des backends Python Matplotlib pour ouvrir une fenêtre interactive pour chaque tracé (pour un zoom, un panoramique, etc. interactifs). Vous pouvez le faire à tout moment en exécutant :
pygui ( true ) pour activer l'interface graphique basée sur Python (si possible) pour les tracés suivants, tandis que pygui(false) reviendra au backend Julia. Même lorsqu'une interface graphique Python est en cours d'exécution, vous pouvez afficher la figure actuelle avec le backend Julia en exécutant display(gcf()) .
Si aucun backend graphique Julia n'est disponible lorsque PyPlot est importé, alors pygui(true) est la valeur par défaut.
Seuls les backends Tk, wxWidgets, GTK+ (version 2 ou 3) et Qt (version 4 ou 5 ; via PyQt5, PyQt4 ou PySide), Python GUI sont pris en charge par PyPlot. (Évidemment, vous devez d'abord avoir installé l'un de ces kits d'outils pour Python.) Par défaut, PyPlot en sélectionne un au démarrage (en fonction de ce que vous avez installé), mais vous pouvez forcer le choix d'un kit d'outils spécifique en important le Module PyCall et en utilisant sa fonction pygui pour définir un backend Python avant d' importer PyPlot :
using PyCall
pygui (gui)
using PyPlot où gui peut actuellement être l'un des :tk , :gtk3 , :gtk , :qt5 , :qt4 , :qt , ou :wx . Vous pouvez également définir une valeur par défaut via le paramètre Matplotlib rcParams['backend'] dans votre fichier matplotlibrc.
Le module PyPlot exporte également certaines fonctions et types basés sur les modules matplotlib.colors et matplotlib.cm pour simplifier la gestion des cartes de couleurs (qui sont utilisées pour attribuer des valeurs aux couleurs dans différents types de tracé). En particulier:
ColorMap : un wrapper autour du type matplotlib.colors.Colormap. Les constructeurs suivants sont fournis :
ColorMap{T<:Colorant}(name::String, c::AbstractVector{T}, n=256, gamma=1.0) construit une palette de couleurs n composants en interpolant linéairement les couleurs dans le tableau c de Colorant s (à partir du ColorTypes.jl). Si vous souhaitez qu'un name soit construit automatiquement, appelez plutôt ColorMap(c, n=256, gamma=1.0) . Alternativement, au lieu de transmettre un tableau de couleurs, vous pouvez transmettre respectivement une matrice à 3 ou 4 colonnes de composants RVB ou RGBA (similaire à ListedColorMap dans Matplotlib).
Des cartes de couleurs encore plus générales peuvent être définies en passant des tableaux de tuples (x, y0, y1) pour les composants rouge, vert, bleu et (éventuellement) alpha, tels que définis par le constructeur matplotlib.colors.LinearSegmentedColormap, via : ColorMap{T<:Real}(name::String, r::AbstractVector{(T,T,T)}, g::AbstractVector{(T,T,T)}, b::AbstractVector{(T,T,T)}, n=256, gamma=1.0) ou ColorMap{T<:Real}(name::String, r::AbstractVector{(T,T,T)}, g::AbstractVector{(T,T,T)}, b::AbstractVector{(T,T,T)}, alpha::AbstractVector{(T,T,T)}, n=256, gamma=1.0)
ColorMap(name::String) renvoie une palette de couleurs existante (enregistrée), équivalente à matplotlib.pyplot.get_cmap( name ).
Les objets matplotlib.colors.Colormap renvoyés par les fonctions Python sont automatiquement convertis en type ColorMap .
get_cmap(name::String) ou get_cmap(name::String, lut::Integer) appellent la fonction matplotlib.pyplot.get_cmap.
register_cmap(c::ColorMap) ou register_cmap(name::String, c::ColorMap) appelle la fonction matplotlib.colormap.register.
get_cmaps() renvoie un Vector{ColorMap} des palettes de couleurs actuellement enregistrées.
Notez que, étant donné un environnement d'affichage prenant en charge SVG comme IJulia, les objets ColorMap et Vector{ColorMap} sont affichés graphiquement ; essayez get_cmaps() !
Le package PyPlot importe également des fonctions de la boîte à outils mplot3d de Matplotlib. Contrairement à Matplotlib, cependant, vous pouvez créer des tracés 3D directement sans créer au préalable un objet Axes3d, simplement en appelant l'un des éléments suivants : bar3D , contour3D , contourf3D , plot3D , plot_surface , plot_trisurf , plot_wireframe ou scatter3D (ainsi que text2D , text3D ), exactement comme les méthodes nommées en conséquence d'Axes3d. Nous exportons également les synonymes de type Matlab surf pour plot_surface (ou plot_trisurf pour les arguments de tableau 1D) et mesh pour plot_wireframe . Par exemple, vous pouvez faire :
surf ( rand ( 30 , 40 ))pour tracer un maillage de surface aléatoire de 30 × 40.
Vous pouvez également créer explicitement un sous-tracé avec des axes 3D via, par exemple, subplot(111, projection="3d") , exactement comme dans Matplotlib, mais vous devez d'abord appeler la fonction using3D() pour vous assurer que mplot3d est chargé (cela se produit automatiquement pour plot3D etc.). Le constructeur Axes3D et le module art3D sont également exportés.
Matplotlib vous permet d'utiliser des équations LaTeX dans les étiquettes de tracé, les titres, etc. simplement en plaçant les équations entre des signes dollar ( $ ... $ ) dans la chaîne. Cependant, taper des équations LaTeX dans des chaînes littérales de Julia est délicat car l'échappement est nécessaire pour empêcher Julia d'interpréter elle-même les signes dollar et les barres obliques inverses ; par exemple, l'équation LaTeX $alpha + beta$ serait la chaîne littérale "$\alpha + \beta$" dans Julia.
Pour simplifier cela, PyPlot utilise le package LaTeXStrings pour fournir un nouveau type LaTeXString qui peut être construit via L"...." sans échapper aux barres obliques inverses ou aux signes dollar. Par exemple, on peut simplement écrire L"$alpha + beta$" pour l'équation mentionnée ci-dessus, et ainsi on peut faire des choses comme :
title ( L " Plot of $ G amma_3(x)$ " ) Si votre chaîne ne contient que des équations, vous pouvez omettre les signes dollar, par exemple L"alpha + beta" , et ils seront ajoutés automatiquement. Comme avantage supplémentaire, un LaTeXString est automatiquement affiché sous forme d'équation rendue dans IJulia. Voir le package LaTeXStrings pour plus d'informations.
Par défaut, les tracés dans IJulia sont envoyés au bloc-notes sous forme d'images PNG. En option, vous pouvez demander à PyPlot d'afficher les tracés dans le navigateur sous forme d'images SVG, qui ont l'avantage d'être indépendantes de la résolution (afin qu'elles s'affichent sans pixellisation en haute résolution, par exemple si vous convertissez un cahier IJulia en PDF), en en cours d'exécution:
PyPlot . svg ( true ) Ce n'est pas la valeur par défaut car les tracés SVG dans le navigateur sont beaucoup plus lents à afficher (en particulier pour les tracés complexes) et peuvent s'afficher de manière inexacte dans certains navigateurs avec une prise en charge boguée de SVG. La méthode PyPlot.svg() renvoie si l'affichage SVG est actuellement activé.
Notez que ceci est entièrement distinct de l’exportation manuelle de tracés vers SVG ou tout autre format. Que PyPlot utilise ou non SVG pour l'affichage du navigateur, vous pouvez exporter un tracé vers SVG à tout moment en utilisant la commande savefig de Matplotlib, par exemple savefig("plot.svg") .
Vous pouvez muter le dictionnaire rcParams que Matplotlib utilise pour les paramètres globaux en suivant cet exemple :
rcParams = PyPlot . PyDict (PyPlot . matplotlib. " rcParams " )
rcParams[ " font.size " ] = 15 (Si vous utilisiez plutôt PyPlot.matplotlib.rcParams , PyCall ferait une copie du dictionnaire afin que les rcParams Python ne soient pas modifiés.)
Ce module a été écrit par Steven G. Johnson.
