python - real - ¿Cómo hacer que los gráficos matplotlib parezcan R por defecto?

matplotlib python

Question

¿Hay alguna manera de hacer que matplotlib comporte de manera idéntica a R, o casi como R, en términos de trazar los valores predeterminados? Por ejemplo, R trata sus ejes de forma muy diferente a matplotlib . El siguiente histograma

tiene "ejes flotantes" con marcas hacia afuera, de modo que no hay matplotlib internas (a diferencia de matplotlib ) y los ejes no se cruzan "cerca" del origen. Además, el histograma puede "propagarse" a valores que no están marcados por la marca, por ejemplo, el eje x termina en 3, pero los histogramas se extienden un poco más allá. ¿Cómo se puede lograr esto automáticamente para todos los histogramas en matplotlib ?

Pregunta relacionada: los diagramas de dispersión y los diagramas de línea tienen diferentes ajustes de ejes predeterminados en R, por ejemplo:

No hay tics internos otra vez y las garrapatas miran hacia afuera. Además, las garrapatas comienzan ligeramente después del punto de origen (donde los ejes yyx se cruzan en la parte inferior izquierda de los ejes) y las garrapatas terminan ligeramente antes de que los ejes terminen. De esta forma, las etiquetas del tick del eje x más bajo y el tick del eje y más bajo no se pueden cruzar realmente, porque hay un espacio entre ellos y esto da a las gráficas un aspecto limpio muy elegante. Tenga en cuenta que también hay mucho más espacio entre las etiquetas de los ejes y las marcas mismas.

Además, de manera predeterminada no hay tics en los ejes xoyy no etiquetados, lo que significa que el eje y a la izquierda que está paralelo al eje y etiquetado a la derecha no tiene tics, y lo mismo para el eje x, nuevamente eliminando el desorden de las parcelas.

¿Hay alguna manera de hacer que matplotlib luzca así? ¿Y, en general, mirar por defecto tanto como los gráficos R por defecto? Me gusta mucho matplotlib pero creo que el comportamiento de trazado predeterminado R / out-of-the-box realmente ha mejorado las cosas y su configuración predeterminada rara vez lleva a superposición de etiquetas de ticks, clutter o datos comprimidos, por lo que me gustaría que los valores predeterminados tanto como sea posible.

Answer 1

Editar 1 año después:

Con seaborn , el siguiente ejemplo se convierte en:

import numpy as np
import matplotlib.pyplot as plt
import seaborn
seaborn.set(style=''ticks'')
# Data to be represented
X = np.random.randn(256)

# Actual plotting
fig = plt.figure(figsize=(8,6), dpi=72, facecolor="white")
axes = plt.subplot(111)
heights, positions, patches = axes.hist(X, color=''white'')
seaborn.despine(ax=axes, offset=10, trim=True)
fig.tight_layout()
plt.show()

Bastante dang fácil.

Publicación original:

Esta publicación en el blog es la mejor que he visto hasta ahora. http://messymind.net/making-matplotlib-look-like-ggplot/

No se centra en los gráficos R estándar, como puede ver en la mayoría de los ejemplos de tipo "cómo empezar". En cambio, trata de emular el estilo de ggplot2, que parece ser casi universalmente anunciado como elegante y bien diseñado.

Para obtener los lomos del eje como se ve en la gráfica de barra, intente seguir uno de los primeros ejemplos aquí: http://www.loria.fr/~rougier/coding/gallery/

Por último, para obtener las marcas de eje apuntando hacia afuera, puede editar sus archivos matplotlibrc para decir xtick.direction : out y ytick.direction : out .

Combinando estos conceptos juntos obtenemos algo como esto:

import numpy as np
import matplotlib
import matplotlib.pyplot as plt
# Data to be represented
X = np.random.randn(256)

# Actual plotting
fig = plt.figure(figsize=(8,6), dpi=72, facecolor="white")
axes = plt.subplot(111)
heights, positions, patches = axes.hist(X, color=''white'')

axes.spines[''right''].set_color(''none'')
axes.spines[''top''].set_color(''none'')
axes.xaxis.set_ticks_position(''bottom'')

# was: axes.spines[''bottom''].set_position((''data'',1.1*X.min()))
axes.spines[''bottom''].set_position((''axes'', -0.05))
axes.yaxis.set_ticks_position(''left'')
axes.spines[''left''].set_position((''axes'', -0.05))

axes.set_xlim([np.floor(positions.min()), np.ceil(positions.max())])
axes.set_ylim([0,70])
axes.xaxis.grid(False)
axes.yaxis.grid(False)
fig.tight_layout()
plt.show()

La posición de las espinas se puede especificar de varias maneras. Si ejecuta el código anterior en IPython, puede hacer axes.spines[''bottom''].set_position? para ver todas tus opciones

Así que sí. No es exactamente trivial, pero puedes acercarte.

Answer 2

# # # # # #

EDIT 14/10/2013: para más información, ggplot ahora se ha implementado para python (basado en matplotlib).

Vea este blog o vaya directamente a la página de github del proyecto para obtener más información y ejemplos.

# # # # # #

Que yo sepa, no hay una solución incorporada en matplotlib que le otorgue a sus figuras una apariencia similar a la de R.

Algunos paquetes, como mpltools , agregan soporte para hojas de estilo usando los parámetros rc de Matplotlib, y pueden ayudarlo a obtener un aspecto ggplot (vea el estilo ggplot para ver un ejemplo).

Sin embargo, dado que todo puede modificarse en matplotlib, podría ser más fácil para usted desarrollar directamente sus propias funciones para lograr exactamente lo que desea. A modo de ejemplo, a continuación se muestra un fragmento que le permitirá personalizar fácilmente los ejes de cualquier gráfico de matplotlib.

def customaxis(ax, c_left=''k'', c_bottom=''k'', c_right=''none'', c_top=''none'',
               lw=3, size=20, pad=8):

    for c_spine, spine in zip([c_left, c_bottom, c_right, c_top],
                              [''left'', ''bottom'', ''right'', ''top'']):
        if c_spine != ''none'':
            ax.spines[spine].set_color(c_spine)
            ax.spines[spine].set_linewidth(lw)
        else:
            ax.spines[spine].set_color(''none'')
    if (c_bottom == ''none'') & (c_top == ''none''): # no bottom and no top
        ax.xaxis.set_ticks_position(''none'')
    elif (c_bottom != ''none'') & (c_top != ''none''): # bottom and top
        ax.tick_params(axis=''x'', direction=''out'', width=lw, length=7,
                      color=c_bottom, labelsize=size, pad=pad)
    elif (c_bottom != ''none'') & (c_top == ''none''): # bottom but not top
        ax.xaxis.set_ticks_position(''bottom'')
        ax.tick_params(axis=''x'', direction=''out'', width=lw, length=7,
                       color=c_bottom, labelsize=size, pad=pad)
    elif (c_bottom == ''none'') & (c_top != ''none''): # no bottom but top
        ax.xaxis.set_ticks_position(''top'')
        ax.tick_params(axis=''x'', direction=''out'', width=lw, length=7,
                       color=c_top, labelsize=size, pad=pad)
    if (c_left == ''none'') & (c_right == ''none''): # no left and no right
        ax.yaxis.set_ticks_position(''none'')
    elif (c_left != ''none'') & (c_right != ''none''): # left and right
        ax.tick_params(axis=''y'', direction=''out'', width=lw, length=7,
                       color=c_left, labelsize=size, pad=pad)
    elif (c_left != ''none'') & (c_right == ''none''): # left but not right
        ax.yaxis.set_ticks_position(''left'')
        ax.tick_params(axis=''y'', direction=''out'', width=lw, length=7,
                       color=c_left, labelsize=size, pad=pad)
    elif (c_left == ''none'') & (c_right != ''none''): # no left but right
        ax.yaxis.set_ticks_position(''right'')
        ax.tick_params(axis=''y'', direction=''out'', width=lw, length=7,
                       color=c_right, labelsize=size, pad=pad)

EDITAR: para espinas no conmovedoras, vea la función a continuación que induce un desplazamiento de 10 pts de las espinas (tomado de este ejemplo en el sitio web de matplotlib).

def adjust_spines(ax,spines):
    for loc, spine in ax.spines.items():
        if loc in spines:
            spine.set_position((''outward'',10)) # outward by 10 points
            spine.set_smart_bounds(True)
        else:
            spine.set_color(''none'') # don''t draw spine

Por ejemplo, el código y las dos gráficas siguientes le muestran la salida predeterminada de matplotib (a la izquierda) y la salida cuando se llaman las funciones (a la derecha):

import numpy as np
import matplotlib.pyplot as plt

fig,(ax1,ax2) = plt.subplots(figsize=(8,5), ncols=2)
ax1.plot(np.random.rand(20), np.random.rand(20), ''ok'')
ax2.plot(np.random.rand(20), np.random.rand(20), ''ok'')

customaxis(ax2) # remove top and right spines, ticks out
adjust_spines(ax2, [''left'', ''bottom'']) # non touching spines

plt.show()

Por supuesto, tomará tiempo para que descubras qué parámetros deben modificarse en matplotlib para que tus gráficos se vean exactamente como los R, pero no estoy seguro de que haya otras opciones ahora.

Answer 3

Aquí hay una publicación de blog que quizás le interese leer:

Trazado para Pandas GSoC2012

http://pandasplotting.blogspot.com/

Decidió intentar implementar una interfaz de trazado tipo ggplot2 ... Aún no estoy seguro de qué cantidad de la funcionalidad de ggplot2 implementar ...

El autor bifurcó los pandas y creó lo que parece una gran cantidad de gramática estilo ggplot2 para los pandas.

plot = rplot.RPlot(tips_data, x=''total_bill'', y=''tip'')
plot.add(rplot.TrellisGrid([''sex'', ''smoker'']))
plot.add(rplot.GeomHistogram())
plot.render(plt.gcf())

El tenedor de los pandas está aquí: https://github.com/orbitfold/pandas

Parece que la carne del código para hacer que los gráficos con influencia R se encuentren en un archivo llamado rplot.py que se puede encontrar en una rama en el repositorio.

class GeomScatter(Layer):
    """
    An efficient scatter plot, use this instead of GeomPoint for speed.
    """

class GeomHistogram(Layer):
    """
    An efficient histogram, use this instead of GeomBar for speed.
    """

Enlace a la sucursal:

https://github.com/orbitfold/pandas/blob/rplot/pandas/tools/rplot.py

Pensé que esto era realmente genial, pero no puedo entender si este proyecto se mantiene o no. El último compromiso fue hace un tiempo.

Answer 4

La biblioteca de visualización de Seaborn puede hacer eso. Por ejemplo, para reproducir el estilo del uso del histograma R:

sns.despine(offset=10, trim=True)

como en https://seaborn.pydata.org/tutorial/aesthetics.html#removing-axes-spines

Para reproducir el estilo de la representación de dispersión R use:

sns.set_style("ticks")

como se muestra en https://seaborn.pydata.org/tutorial/aesthetics.html#seaborn-figure-styles

Answer 5

Verificaría Bokeh que tiene como objetivo "proporcionar un convincente equivalente Python de ggplot en R". Ejemplo here

EDITAR: También echa un vistazo a Seaborn , que intenta reproducir el estilo visual y la sintaxis de ggplot2.

Answer 6

matplotlib> = 1.4 styles suport (y ggplot-style es build in):

In [1]: import matplotlib as mpl

In [2]: import matplotlib.pyplot as plt

In [3]: import numpy as np

In [4]: mpl.style.available
Out[4]: [u''dark_background'', u''grayscale'', u''ggplot'']

In [5]: mpl.style.use(''ggplot'')

In [6]: plt.hist(np.random.randn(100000))
Out[6]: 
...

Answer 7

El ajuste de spines en matplotlibrc explica por qué no es posible editar los valores predeterminados de Matplotlib para producir histogramas de estilo R. Para diagramas de dispersión, búfer de eje de datos de estilo R en matplotlib e In matplotlib, ¿cómo se dibujan tics de eje tipo R que apuntan hacia afuera desde los ejes? muestra algunos valores predeterminados que se pueden cambiar para dar un aspecto más R-Ish. Basándose en algunas de las otras respuestas, la siguiente función hace un trabajo decente al imitar el estilo del histograma de R, suponiendo que ha llamado a hist() en su instancia de Axes con facecolor=''none'' .

def Rify(axes):
    ''''''
    Produce R-style Axes properties
    ''''''
    xticks = axes.get_xticks() 
    yticks = axes.get_yticks()

    #remove right and upper spines
    axes.spines[''right''].set_color(''none'') 
    axes.spines[''top''].set_color(''none'')

    #make the background transparent
    axes.set_axis_bgcolor(''none'')

    #allow space between bottom and left spines and Axes
    axes.spines[''bottom''].set_position((''axes'', -0.05))
    axes.spines[''left''].set_position((''axes'', -0.05))

    #allow plot to extend beyond spines
    axes.spines[''bottom''].set_bounds(xticks[0], xticks[-2])
    axes.spines[''left''].set_bounds(yticks[0], yticks[-2])

    #set tick parameters to be more R-like
    axes.tick_params(direction=''out'', top=False, right=False, length=10, pad=12, width=1, labelsize=''medium'')

    #set x and y ticks to include all but the last tick
    axes.set_xticks(xticks[:-1])
    axes.set_yticks(yticks[:-1])

    return axes

Answer 8

import matplotlib.pyplot as plt plt.style.use(''ggplot'')

hacer algo trama aquí, y disfrutarlo