PyPlot.jl
v2.11.5
Este módulo fornece uma interface Julia para a biblioteca de plotagem Matplotlib do Python e, especificamente, para o módulo matplotlib.pyplot .
PyPlot usa o pacote Julia PyCall para chamar Matplotlib diretamente de Julia com pouca ou nenhuma sobrecarga (arrays são passados sem fazer uma cópia). (Veja também PythonPlot.jl para uma versão do PyPlot.jl usando o pacote alternativo PythonCall.jl.)
Este pacote aproveita a API de E/S multimídia do Julia para exibir gráficos em qualquer backend gráfico do Julia, inclusive como gráficos embutidos no IJulia. Alternativamente, você pode usar um back-end gráfico Matplotlib baseado em Python para suportar zoom de plotagem interativo, etc.
(Este pacote PyPlot substitui um pacote anterior de mesmo nome de Junfeng Li, que usava PyPlot em um soquete ZeroMQ com IPython.)
Você precisará ter a biblioteca Python Matplotlib instalada em sua máquina para usar o PyPlot. Você pode fazer plotagem inline com IJulia, que não requer um back-end GUI, ou usar os back-ends Qt, wx ou GTK+ do Matplotlib conforme descrito abaixo.
Depois que o Matplotlib estiver instalado, você pode simplesmente usar Pkg.add("PyPlot") em Julia para instalar o PyPlot e suas dependências.
Se você configurar o PyCall para usar o pacote Conda.jl para instalar uma distribuição Julia Python privada (não no sistema PATH ) (via Miniconda), o PyPlot instalará automaticamente o Matplotlib conforme necessário.
Se você estiver instalando PyCall e PyPlot pela primeira vez, basta fazer ENV["PYTHON"]="" antes de executar Pkg.add("PyPlot") . Caso contrário, você pode reconfigurar o PyCall para usar o Conda via:
ENV [ " PYTHON " ] = " "
Pkg . build ( " PyCall " ) Na próxima vez que você importar PyPlot , ele dirá ao Conda para instalar o Matplotlib.
No MacOS, você deve instalar o XQuartz para MacOS 10.9 ou posterior ou instalar a distribuição Anaconda Python para obter um PyPlot totalmente funcional.
MacOS 10.9 vem com Python e Matplotlib, mas esta versão do Matplotlib tem como padrão o backend Cocoa GUI, que não é suportado pelo PyPlot. Ele também possui um backend Tk, que é suportado, mas o backend Tk não funciona a menos que você instale o XQuartz.
Alternativamente, você pode instalar a distribuição Anaconda Python (que também inclui ipython e outras dependências IJulia).
Caso contrário, você pode usar o gerenciador de pacotes 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 (Você pode querer adicionar os dois comandos export ao seu arquivo ~/.profile para que eles sejam executados automaticamente sempre que você iniciar um shell.)
Depois que Matplotlib e PyPlot estiverem instalados e você estiver usando um ambiente Julia com capacidade gráfica, como IJulia, você pode simplesmente digitar using PyPlot e começar a chamar funções na API matplotlib.pyplot. Por exemplo:
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 " ) Em geral, todos os argumentos, incluindo argumentos de palavras-chave, são exatamente iguais aos do Python. (Com traduções menores, é claro, por exemplo, Julia usa true e nothing em vez de True e None do Python.)
A API matplotlib.pyplot completa é extensa demais para ser descrita aqui; consulte a documentação matplotlib.pyplot para obter mais informações. O número da versão do Matplotlib é retornado por PyPlot.version .
Somente a API matplotlib.pyplot atualmente documentada é exportada. Para usar outras funções no módulo, você também pode chamar matplotlib.pyplot.foo(...) como plt.foo(...) . Por exemplo, plt.plot(x, y) também funciona. (E o PyObject bruto para os módulos matplotlib também pode ser acessado como PyPlot.matplotlib .)
Matplotlib é um tanto inconsistente quanto à capitalização: possui contour3D mas bar3d , etc. PyPlot renomeia todas essas funções para usar D maiúsculo (por exemplo, tem hist2D , bar3D e assim por diante).
Você também deve qualificar explicitamente algumas funções internas das funções Julia. Em particular, PyPlot.xcorr , PyPlot.axes e PyPlot.isinteractive devem ser usados para acessar matplotlib.pyplot.xcorr etc.
Se você deseja acessar todas as funções do PyPlot exclusivamente através de plt.somefunction(...) , como é convencional em Python, você pode import PyPlot; const plt = PyPlot em vez de using PyPlot .
Você pode obter a figura atual como um objeto Figure (um wrapper em torno de matplotlib.pyplot.Figure ) chamando gcf() .
O tipo Figure suporta a API de E/S multimídia de Julia, então você pode usar display(fig) para mostrar um fig::PyFigure e show(io, mime, fig) (ou writemime em Julia 0.4) para gravá-lo em um determinado tipo mime string (por exemplo "image/png" ou "application/pdf" ) que é suportada pelo backend Matplotlib.
Se você usar PyPlot a partir de um prompt Julia interativo, como o prompt de linha de comando Julia ou um bloco de notas IJulia, os gráficos aparecerão imediatamente após uma função de plotagem ( plot etc.) ser avaliada.
No entanto, se você usar o PyPlot a partir de um script Julia que é executado de forma não interativa (por exemplo, julia myscript.jl ), então o Matplotlib será executado no modo não interativo: uma janela de plotagem não será aberta até que você execute show() (equivalente a plt.show() nos exemplos Python).
PyPlot pode usar qualquer backend gráfico Julia capaz de exibir imagens PNG, SVG ou PDF, como o ambiente IJulia. Para usar um backend diferente, basta chamar pushdisplay com o Display desejado; consulte a API de exibição multimídia Julia para obter mais detalhes.
Por outro lado, você pode querer usar um dos back-ends do Python Matplotlib para abrir uma janela interativa para cada gráfico (para zoom interativo, panorâmica, etc.). Você pode fazer isso a qualquer momento executando:
pygui ( true ) para ativar a GUI baseada em Python (se possível) para plotagens subsequentes, enquanto pygui(false) retornará ao backend Julia. Mesmo quando uma GUI Python está em execução, você pode exibir a figura atual com o backend Julia executando display(gcf()) .
Se nenhum back-end gráfico Julia estiver disponível quando o PyPlot for importado, então pygui(true) será o padrão.
Apenas os backends GUI Python Tk, wxWidgets, GTK+ (versão 2 ou 3) e Qt (versão 4 ou 5; por meio de PyQt5, PyQt4 ou PySide) são suportados pelo PyPlot. (Obviamente, você deve ter instalado um desses kits de ferramentas para Python primeiro.) Por padrão, o PyPlot escolhe um deles quando é inicializado (com base no que você instalou), mas você pode forçar a escolha de um kit de ferramentas específico importando o Módulo PyCall e usando sua função pygui para definir um backend Python antes de importar o PyPlot:
using PyCall
pygui (gui)
using PyPlot onde gui pode atualmente ser um de :tk , :gtk3 , :gtk , :qt5 , :qt4 , :qt , ou :wx . Você também pode definir um padrão por meio do parâmetro Matplotlib rcParams['backend'] em seu arquivo matplotlibrc.
O módulo PyPlot também exporta algumas funções e tipos baseados nos módulos matplotlib.colors e matplotlib.cm para simplificar o gerenciamento de mapas de cores (que são usados para atribuir valores às cores em vários tipos de plotagem). Em particular:
ColorMap : um wrapper em torno do tipo matplotlib.colors.Colormap. Os seguintes construtores são fornecidos:
ColorMap{T<:Colorant}(name::String, c::AbstractVector{T}, n=256, gamma=1.0) constrói um mapa de cores n componentes interpolando linearmente as cores na matriz c de Colorant s (do pacote ColorTypes.jl). Se você deseja que um name seja construído automaticamente, chame ColorMap(c, n=256, gamma=1.0) em vez disso. Alternativamente, em vez de passar uma matriz de cores, você pode passar uma matriz de 3 ou 4 colunas de componentes RGB ou RGBA, respectivamente (semelhante a ListedColorMap em Matplotlib).
Mapas de cores ainda mais gerais podem ser definidos passando matrizes de tuplas (x,y0,y1) para os componentes vermelho, verde, azul e (opcionalmente) alfa, conforme definido pelo construtor 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) retorna um mapa de cores existente (registrado), equivalente a matplotlib.pyplot.get_cmap( name ).
Os objetos matplotlib.colors.Colormap retornados pelas funções Python são automaticamente convertidos para o tipo ColorMap .
get_cmap(name::String) ou get_cmap(name::String, lut::Integer) chame a função matplotlib.pyplot.get_cmap.
register_cmap(c::ColorMap) ou register_cmap(name::String, c::ColorMap) chamam a função matplotlib.colormap.register.
get_cmaps() retorna um Vector{ColorMap} dos mapas de cores atualmente registrados.
Observe que, dado um ambiente de exibição com suporte a SVG como IJulia, os objetos ColorMap e Vector{ColorMap} são exibidos graficamente; tente get_cmaps() !
O pacote PyPlot também importa funções do kit de ferramentas mplot3d do Matplotlib. Ao contrário do Matplotlib, no entanto, você pode criar gráficos 3D diretamente sem primeiro criar um objeto Axes3d, simplesmente chamando um de: bar3D , contour3D , contourf3D , plot3D , plot_surface , plot_trisurf , plot_wireframe ou scatter3D (bem como text2D , text3D ), exatamente como os métodos nomeados correspondentemente de Axes3d. Também exportamos os sinônimos do tipo Matlab surf para plot_surface (ou plot_trisurf para argumentos de array 1d) e mesh para plot_wireframe . Por exemplo, você pode fazer:
surf ( rand ( 30 , 40 ))para traçar uma malha de superfície aleatória de 30×40.
Você também pode criar explicitamente uma subtrama com eixos 3d por meio de, por exemplo, subplot(111, projection="3d") , exatamente como em Matplotlib, mas primeiro você deve chamar a função using3D() para garantir que mplot3d seja carregado (isso acontece automaticamente para plot3D etc.). O construtor Axes3D e o módulo art3D também são exportados.
Matplotlib permite que você use equações LaTeX em rótulos de gráficos, títulos e assim por diante, simplesmente colocando as equações em cifrões ( $ ... $ ) dentro da string. No entanto, digitar equações LaTeX em literais de string Julia é estranho porque o escape é necessário para evitar que Julia interprete os cifrões e as barras invertidas; por exemplo, a equação LaTeX $alpha + beta$ seria a string literal "$\alpha + \beta$" em Julia.
Para simplificar isso, PyPlot usa o pacote LaTeXStrings para fornecer um novo tipo LaTeXString que pode ser construído via L"...." sem escapar de barras invertidas ou cifrões. Por exemplo, pode-se simplesmente escrever L"$alpha + beta$" para a equação acima mencionada e, assim, você pode fazer coisas como:
title ( L " Plot of $ G amma_3(x)$ " ) Se sua string contém apenas equações, você pode omitir os cifrões, por exemplo L"alpha + beta" , e eles serão adicionados automaticamente. Como benefício adicional, um LaTeXString é automaticamente exibido como uma equação renderizada em IJulia. Veja o pacote LaTeXStrings para mais informações.
Por padrão, os gráficos em IJulia são enviados para o notebook como imagens PNG. Opcionalmente, você pode dizer ao PyPlot para exibir gráficos no navegador como imagens SVG, que têm a vantagem de serem independentes de resolução (para que sejam exibidas sem pixelização em altas resoluções, por exemplo, se você converter um notebook IJulia em PDF), por correndo:
PyPlot . svg ( true ) Este não é o padrão porque os gráficos SVG no navegador são muito mais lentos para serem exibidos (especialmente para gráficos complexos) e podem ser exibidos de forma imprecisa em alguns navegadores com suporte SVG com erros. O método PyPlot.svg() retorna se a exibição SVG está habilitada no momento.
Observe que isso é totalmente independente da exportação manual de gráficos para SVG ou qualquer outro formato. Independentemente de o PyPlot usar SVG para exibição no navegador, você pode exportar um gráfico para SVG a qualquer momento usando o comando matplotlib savefig, por exemplo, savefig("plot.svg") .
Você pode alterar o dicionário rcParams que o Matplotlib usa para parâmetros globais seguindo este exemplo:
rcParams = PyPlot . PyDict (PyPlot . matplotlib. " rcParams " )
rcParams[ " font.size " ] = 15 (Se você usasse PyPlot.matplotlib.rcParams , PyCall faria uma cópia do dicionário para que o Python rcParams não fosse modificado.)
Este módulo foi escrito por Steven G. Johnson.
