Clase 11: Visualización
Para graficar datos y funciones vamos a usar la biblioteca Matplotlib. Vamos a empezar discutiendo algunas de las características más generales del trabajo con esta biblioteca y mostrar algún ejemplo relativamente sencillo. Matplotlib está dividido en tres partes o capas conceptualmente bien delimitadas:
Una parte es la que hace el trabajo más básico creando y administrando cada objeto que forma parte del gráfico (líneas, texto, figuras, etc) así como sus relaciones,
Una segunda parte que permite un uso simple de las funciones anteriores: una interfaz con el usuario. Un ejemplo es el submódulo pyplot.
Una tercera componente que se encarga de presentar la figura en el formato adecuado. Esto es lo que se llama el Backend y se encarga de mostrar la figura en los distintos sistemas de ventanas, o en formatos de archivos correspondientes. Algunos ejemplos de backend son: PS (copias PostScript®), SVG (Scalable Vector Graphics), Agg (salida PNG de muy buena calidad), Cairo (png, pdf, ps, svg), GTK (interactivo, permite integrar matplotlib con aplicaciones Gtk+, que usa GNOME), PDF, WxWidgets (interactivo), Qt (interactivo).
Nosotros vamos a concentrarnos principalmente en aprender a utilizar pyplot
import numpy as np
import matplotlib.pyplot as plt
from pathlib import Path
Interactividad
Trabajo con ventanas emergentes
Podemos trabajar en forma interactiva con gráficos desde una terminal de
Ipython
import matplotlib.pyplot as plt # o equivalentemente:
# from matplotlib import pyplot as plt
plt.plot([0,1,4,9,16,25])
El comando (la función) plot() crea el gráfico pero no lo muestra.
Lo hacemos explícitamente con el comando show()
plt.show()
Vemos que es muy simple graficar datos.
Algunas cosas a notar:
Se abre una ventana
Se bloquea la terminal (no podemos dar nuevos comandos)
Si pasamos el mouse sobre el gráfico nos muestra las coordenadas.
Además del gráfico hay una barra de herramientas: .. image:: figuras/matplotlib_toolbar.png
- De derecha
a izquierda tenemos:
Grabar: Este botón abre una ventana para guardar el gráfico en alguno de los formatos disponibles.
Configuración de subplots: Permite modificar el tamaño y posición de cada gráfico en la ventana.
Agrandar (zoom) a rectángulo:
Si elegimos una región mientras apretamos el botón izquierdo, esta será la nueva región visible ocupando toda la ventana.
Si elegimos una región mientras apretamos el botón derecho, pone toda la vista actual en esta región.
Desplazar y agrandar (Pan and zoom): Este botón cumple dos funciones diferentes:
Con el botón izquierdo desplaza la vista.
Con el botón derecho la vista se agrandará achicará en los ejes horizontal y vertical en una cantidad proporcional al movimiento.
Si se oprime las teclas
xoylas dos funciones quedan restringidas al eje correspondiente.Home, Back, Forward son botones que nos llevan a la vista original, una vista hacia atrás o hacia adelante respectivamente
Si ocurre, como en este caso, que proveemos sólo una lista de datos, la
función plot() la interpreta como los valores correspondientes al
eje vertical (eje y), y toma el índice del dato para la variable
independiente (eje x). Si queremos dar valores explícitamente para el
eje x debemos pasarlos como primer argumento.
plt.plot([0,1,2,3,4,5],[0,1,4,9,16,25])
plt.show()
Como vemos, para que muestre la ventana debemos hacer un llamado
explícito a la función show(). Esto es así porque muchas veces
queremos realizar más de una operación sobre un gráfico antes de
mostrarlo. Sin embargo, hay varias alternativas respecto a la
interactividad de matplotlib (e ipython) que permiten adecuarla a
nuestro flujo de trabajo. La manera más común en una terminal es
utilizando las función ion() (interactive on) para hacerlo
interactivo y la función ioff() para no interactivo.
plt.ion() # Prendemos el modo interactivo
plt.plot([0,1,2,3,4,5],[0,1,4,9,16,25])
En el modo interactivo no sólo plot() tiene implícito el comando
show() sino que podemos seguir ingresando comandos con el gráfico
abierto.
Trabajo sobre notebooks
Para trabajar en ipython notebooks suele ser conveniente realizar los gráficos dentro de la misma página donde realizamos los cálculos
import matplotlib.pyplot as plt
plt.plot([1,2,3,4,5,6],[0,1,4,9,16,25])
[<matplotlib.lines.Line2D at 0x7fc0e86e2fd0>]
En la práctica vamos a usar siempre Matplotlib junto con Numpy.
fdatos = Path().cwd() / 'data/ej_oscil_aten_err.dat'
Gráficos simples
El paquete Matplotlib permite visualizar datos guardados en un archivo con unas pocas líneas
x, y, yexp = np.loadtxt(fdatos, unpack=True)
plt.plot(x, y)
[<matplotlib.lines.Line2D at 0x7fc0e844ed50>]
Como vemos, es la curva que graficamos la clase anterior.
Si miramos el archivo vamos a ver que tiene una columna más que
corresponde a los valores medidos. En consecuencia le asignamos esta
tercera columna a una variable adicional yexp al leerlo.
# Graficamos las segunda y tercera columnas como función de la primera
plt.plot(x,yexp, x,y)
[<matplotlib.lines.Line2D at 0x7fc0e84c5310>,
<matplotlib.lines.Line2D at 0x7fc0e84c5450>]
Formato de las curvas
En los gráficos anteriores usamos la función plot() en sus formas
más simples.
plot(y)
plot(x,y)
plot(x1,y1, x2, y2)
dando a la función plot() la información mínima necesaria para
graficar los datos. Usualmente queremos poder elegir cómo vamos a
graficar nuestros datos.
Líneas, símbolos y colores
La forma más simple de elegir el modo de graficación de la curva es a través de un tercer argumento. Este argumento, que aparece inmediatamente después de los datos (x e y), permite controlar el tipo de línea o símbolo utilizado en la graficación. En el caso de la línea sólida se puede especificar con un guión (‘-’) o simplemente no poner nada, ya que línea sólida es el símbolo por defecto. Las dos especificaciones anteriores son equivalentes. También se puede elegir el color, o el símbolo a utilizar con este argumento:
plot(x,y,'g-')
plot(x,y,'ro')
plot(x,y,'r-o')
Para obtener círculos usamos una especificación que corresponde a ‘o’. Además podemos poner en este argumento el color. En este caso elegimos graficar en color “rojo (r), con una línea (-) + círculos (o)”.
Con esta idea modificamos el gráfico anterior
plt.plot(x,y,'-', x,yexp, 'ro')
[<matplotlib.lines.Line2D at 0x7fc0e855c190>,
<matplotlib.lines.Line2D at 0x7fc0e855c2d0>]
Para graficar más de una curva, en este formato simple, podemos ponerlo
todo en la misma función plot() en la forma
plot(x1, y1, [formato], x2, y2, [formato2]) pero muchas veces es más
legible separar los llamados a la función, una para cada curva.
plt.plot(x,y, '-')
plt.plot(x,yexp, 'or')
[<matplotlib.lines.Line2D at 0x7fc0e85f7110>]
Al separar los llamados a la función plot() obtenemos un código más
claro, principalmente cuando agregamos opciones de formato.
Los siguientes caracteres pueden utilizarse para controlar el símbolo de graficación:
Símbolo |
Descripción |
Símbolo |
Descripción |
|---|---|---|---|
‘-’ |
solid line style |
‘1’ |
tri down marker |
‘–’ |
dashed line style |
‘2’ |
tri up marker |
‘-.’ |
dash-dot line style |
‘3’ |
tri left marker |
‘:’ |
dotted line style |
‘4’ |
tri right marker |
‘.’ |
point marker |
‘s’ |
square marker |
‘,’ |
pixel marker |
‘p’ |
pentagon marker |
‘o’ |
circle marker |
‘*’ |
star marker |
‘v’ |
triangle down marker |
‘h’ |
hexagon1 marker |
‘^’ |
triangle up marker |
‘H’ |
hexagon2 marker |
‘<’ |
triangle left marker |
‘+’ |
plus marker |
‘>’ |
triangle right marker |
‘x’ |
x marker |
‘|’ |
vline marker |
‘D’ |
diamond marker |
‘_’ |
hline marker |
‘d’ |
thin diamond marker |
Los colores también pueden elegirse usando los siguientes caracteres:
Letra |
Color |
|---|---|
‘b’ |
blue |
‘g’ |
green |
‘r’ |
red |
‘c’ |
cyan |
‘m’ |
magenta |
‘y’ |
yellow |
‘k’ |
black |
‘w’ |
white |
Por ejemplo, utilizando:
plt.plot(x, y1, 'gs', x, y2, '-k^', x, y3, '--r' )
obtenemos: .. image:: figuras/simple_varios.png
La función plot() acepta un número variable de argumentos. Veamos lo
que dice la documentación
Signature: plt.plot(*args, **kwargs)
Docstring:
Plot y versus x as lines and/or markers.
Call signatures::
plot([x], y, [fmt], data=None, **kwargs)
plot([x], y, [fmt], [x2], y2, [fmt2], ..., **kwargs)
En particular, podemos usar los argumentos keywords (pares nombre-valor) para cambiar el modo en que se grafican los datos. Algunos de los más comunes son:
Argumento |
Valor |
|---|---|
linestyle |
{‘-’, ‘–’, ‘-.’, ‘:’, ’’, …} |
linewidth |
número real |
color |
un color |
marker |
{‘o’, ‘s’, ‘d’, ….} |
markersize |
número real |
markeredgecolor |
color |
markerfacecolor |
color |
markevery |
número entero |
plt.plot(x,y,linewidth=1)
plt.plot(x,yexp, 'o', color='red', markersize=2)
[<matplotlib.lines.Line2D at 0x7fc0e834df90>]
plt.plot(x,y,linewidth=5)
plt.plot(x,yexp, 'o', color='green', markersize=8)
[<matplotlib.lines.Line2D at 0x7fc0e81e0e10>]
plt.plot(x,y,linewidth=5, linestyle='dashed')
plt.plot(x,yexp, 'o', color='red', markersize=8, markeredgecolor='black',markevery=6)
[<matplotlib.lines.Line2D at 0x7fc0e8243c50>]
Ejercicios 11 (a)
Realizar un programa para visualizar la función
\[f(x,n,w) = x^n |\sin(w x)|\]El programa debe realizar el gráfico para \(w=10\), con cuatro curvas para \(n=1,2,3,4\), similar al que se muestra en la siguiente figura
Adecuación de los gráficos
Veamos un ejemplo de un gráfico completo, con modificaciones para que sea más útil/atractivo …
import numpy as np
import matplotlib.pyplot as plt
from pathlib import Path
fdatos = Path().cwd() / 'data/ej_oscil_aten_err.dat'
foname = fdatos.with_name('ej_plot_osc')
print(fdatos)
/home/fiol/Clases/IntPython/clases-python/clases/data/ej_oscil_aten_err.dat
print(foname)
/home/fiol/Clases/IntPython/clases-python/clases/data/ej_plot_osc
x, y, yexp = np.loadtxt(fdatos, unpack=True)
plt.plot(x,1+y, '-b', label="teoría")
plt.plot(x,1+yexp, 'or', label="medición")
plt.legend(loc="best", title="Mis datos")
plt.xlabel('Tiempo (micro-segundos)')
plt.ylabel("Voltaje (mV)")
plt.title("Medición de ayer")
plt.axvline(x=1, color='gray')
plt.axhline(color='gray')
plt.xlim((1.e-1,3))
plt.xscale('log')
plt.yscale('log')
plt.ylim((0.6, 1.4))
plt.savefig(foname.with_suffix('.png'))
plt.savefig(foname.with_suffix('.pdf'))
Nombres de ejes y leyendas
Vamos ahora a agregar nombres a los ejes y a las curvas.
Para agregar nombres a las curvas, tenemos que agregar un label, en
este caso en el mismo comando plot(), y luego mostrarlo con
`legend()
plt.plot(x,y, '-b', label="teoría")
plt.plot(x,yexp, 'or', label="medición")
#plt.legend()
plt.legend(loc="lower right", title="Mis datos")
<matplotlib.legend.Legend at 0x7fe35adb8190>
Para agregar nombres a los ejes usamos xlabel y ylabel:
plt.plot(x,yexp, 'or', label="medición")
plt.plot(x,y, '-b', label="teoría")
plt.legend(loc="lower right", title="Mis datos")
plt.xlabel('Tiempo (micro-segundos)')
plt.ylabel("Voltaje (mV)");
Los títulos a la figura se pueden agregar con title
Acá además agregamos una línea vertical y una horizontal.
plt.plot(x,y, '-b', label="teoría")
plt.plot(x,yexp, 'or', label="medición")
plt.legend(loc="lower right", title="Mis datos")
plt.xlabel('Tiempo (micro-segundos)')
plt.ylabel("Voltaje (mV)")
plt.title("Medición de ayer")
plt.axvline(x=1, color='gray')
plt.axhline(color='gray')
<matplotlib.lines.Line2D at 0x7fe35ad06990>
Límites de graficación (vista)
Para cambiar los límites de graficación se puede usar las funciones
xlim para el eje horizontal y ylim para el vertical
plt.plot(x,y, '-b', label="teoría")
plt.plot(x,yexp, 'or', label="medición")
plt.legend(loc="lower right", title="Mis datos")
plt.xlabel('Tiempo (micro-segundos)')
plt.ylabel("Voltaje (mV)")
plt.title("Medición de ayer")
plt.axvline(x=1, color='gray')
plt.axhline(color='gray')
plt.xlim((0,2.5))
plt.ylim((-0.4, 0.32))
(-0.4, 0.32)
Escalas
Para pasar a escala logarítmica usamos xscale o yscale
plt.plot(x,y, '-b', label="teoría")
plt.plot(x,yexp, 'or', label="medición")
plt.legend(loc="best", title="Mis datos")
plt.xlabel('Tiempo (micro-segundos)')
plt.ylabel("Voltaje (mV)")
plt.xlim((1.e-1,3))
plt.xscale('log')
plt.ylim((-0.4, 0.32))
(-0.4, 0.32)
Líneas verticales y horizontales
plt.plot(x,y, '-b', label="teoría")
plt.plot(x,yexp, 'or', label="medición")
plt.legend(loc="best", title="Mis datos")
plt.xlabel('Tiempo (micro-segundos)')
plt.ylabel("Voltaje (mV)")
plt.title("Medición de ayer")
plt.axvline(x=1, color='gray')
plt.axhline(color='gray')
plt.grid(which='both')
plt.xlim((1.e-1,3))
plt.xscale('log')
plt.ylim((-0.4, 0.32))
(-0.4, 0.32)
Inclusión de ecuaciones
Para incluir ecuaciones se puede utilizar la notación de LaTeX para
parte del texto. Si utilizamos una expresión encerrada entre los
símbolos $, matplotlib interpreta que está escrito en (un
subconjunto) de LaTeX.
Matplotlib tiene un procesador de símbolos interno para mostrar la notación en LaTeX que reconoce los elementos más comunes, o puede elegirse utilizar un procesador LaTeX externo.
plt.plot(x,y, '-b', label=r"$\frac{\sin(x^2)}{[2 + \cos (x)]^2}$")
plt.plot(x,yexp, 'or', label="$\mathrm{Medición}$")
plt.legend(loc="best", title="Mis datos", fontsize='x-large')
plt.xlabel(r'Tiempo ($\mu$-segundos)', fontsize='x-large')
plt.ylabel("Voltaje (mV)", fontsize='x-large')
plt.title("Medición de ayer")
plt.axvline(x=1, color='gray')
plt.axhline(color='gray')
plt.grid(which='both')
plt.xlim((1.e-1,3))
plt.xscale('log')
plt.ylim((-0.4, 0.32))
<>:2: SyntaxWarning: invalid escape sequence 'm'
<>:2: SyntaxWarning: invalid escape sequence 'm'
/tmp/ipykernel_6610/3688865428.py:2: SyntaxWarning: invalid escape sequence 'm'
plt.plot(x,yexp, 'or', label="$mathrm{Medición}$")
(-0.4, 0.32)
Exportar las figuras
Para guardar las figuras en alguno de los formatos disponibles
utilizamos la función savefig().
plt.plot(x,y, '-b', label=r"$\frac{\sin(x^2)}{[2 + \cos (x)]^2}$")
plt.plot(x,yexp, 'or', label=r"$\mathrm{Medición}$")
plt.legend(loc="best", title="Mis datos", fontsize='x-large')
plt.xlabel(r'Tiempo ($\mu$-segundos)', fontsize='x-large')
plt.ylabel("Voltaje (mV)", fontsize='x-large')
plt.title("Medición de ayer")
plt.axvline(x=1, color='gray')
plt.axhline(color='gray')
plt.grid(which='both')
plt.xlim((1.e-1,3))
plt.xscale('log')
plt.ylim((-0.4, 0.32))
plt.savefig(foname.with_suffix('.png'))
plt.savefig(foname.with_suffix('.pdf'))
print(foname)
/home/fiol/Clases/IntPython/clases-python/clases/data/ej_plot_osc
print(foname.with_suffix('.png'))
/home/fiol/Clases/IntPython/clases-python/clases/data/ej_plot_osc.png
plt.savefig?
[0;31mSignature:[0m [0mplt[0m[0;34m.[0m[0msavefig[0m[0;34m([0m[0;34m*[0m[0margs[0m[0;34m,[0m [0;34m**[0m[0mkwargs[0m[0;34m)[0m [0;34m->[0m [0;34m'None'[0m[0;34m[0m[0;34m[0m[0m
[0;31mDocstring:[0m
Save the current figure as an image or vector graphic to a file.
Call signature::
savefig(fname, , transparent=None, dpi='figure', format=None,
metadata=None, bbox_inches=None, pad_inches=0.1,
facecolor='auto', edgecolor='auto', backend=None,
**kwargs
)
The available output formats depend on the backend being used.
Parameters
----------
fname : str or path-like or binary file-like
A path, or a Python file-like object, or
possibly some backend-dependent object such as
`matplotlib.backends.backend_pdf.PdfPages`.
If *format is set, it determines the output format, and the file
is saved as fname. Note that fname is used verbatim, and there
is no attempt to make the extension, if any, of fname match
format, and no extension is appended.
If format is not set, then the format is inferred from the
extension of fname, if there is one. If format is not
set and fname has no extension, then the file is saved with
:rc:`savefig.format` and the appropriate extension is appended to
fname.
Other Parameters
----------------
transparent : bool, default: :rc:`savefig.transparent`
If True, the Axes patches will all be transparent; the
Figure patch will also be transparent unless facecolor
and/or edgecolor are specified via kwargs.
If False has no effect and the color of the Axes and
Figure patches are unchanged (unless the Figure patch
is specified via the facecolor and/or edgecolor keyword
arguments in which case those colors are used).
The transparency of these patches will be restored to their
original values upon exit of this function.
This is useful, for example, for displaying
a plot on top of a colored background on a web page.
dpi : float or 'figure', default: :rc:`savefig.dpi`
The resolution in dots per inch. If 'figure', use the figure's
dpi value.
format : str
The file format, e.g. 'png', 'pdf', 'svg', ... The behavior when
this is unset is documented under fname.
metadata : dict, optional
Key/value pairs to store in the image metadata. The supported keys
and defaults depend on the image format and backend:
- 'png' with Agg backend: See the parameter metadata of
~.FigureCanvasAgg.print_png.
- 'pdf' with pdf backend: See the parameter metadata of
~.backend_pdf.PdfPages.
- 'svg' with svg backend: See the parameter metadata of
~.FigureCanvasSVG.print_svg.
- 'eps' and 'ps' with PS backend: Only 'Creator' is supported.
Not supported for 'pgf', 'raw', and 'rgba' as those formats do not support
embedding metadata.
Does not currently support 'jpg', 'tiff', or 'webp', but may include
embedding EXIF metadata in the future.
bbox_inches : str or .Bbox, default: :rc:`savefig.bbox`
Bounding box in inches: only the given portion of the figure is
saved. If 'tight', try to figure out the tight bbox of the figure.
pad_inches : float or 'layout', default: :rc:`savefig.pad_inches`
Amount of padding in inches around the figure when bbox_inches is
'tight'. If 'layout' use the padding from the constrained or
compressed layout engine; ignored if one of those engines is not in
use.
facecolor : :mpltype:`color` or 'auto', default: :rc:`savefig.facecolor`
The facecolor of the figure. If 'auto', use the current figure
facecolor.
edgecolor : :mpltype:`color` or 'auto', default: :rc:`savefig.edgecolor`
The edgecolor of the figure. If 'auto', use the current figure
edgecolor.
backend : str, optional
Use a non-default backend to render the file, e.g. to render a
png file with the "cairo" backend rather than the default "agg",
or a pdf file with the "pgf" backend rather than the default
"pdf". Note that the default backend is normally sufficient. See
the-builtin-backends for a list of valid backends for each
file format. Custom backends can be referenced as "module://...".
orientation : {'landscape', 'portrait'}
Currently only supported by the postscript backend.
papertype : str
One of 'letter', 'legal', 'executive', 'ledger', 'a0' through
'a10', 'b0' through 'b10'. Only supported for postscript
output.
bbox_extra_artists : list of ~matplotlib.artist.Artist, optional
A list of extra artists that will be considered when the
tight bbox is calculated.
pil_kwargs : dict, optional
Additional keyword arguments that are passed to
PIL.Image.Image.save when saving the figure.
Notes
-----
.. note::
This is the pyplot wrapper for .Figure.savefig.
[0;31mFile:[0m /usr/lib64/python3.13/site-packages/matplotlib/pyplot.py
[0;31mType:[0m function
Dos gráficos en la misma figura
Hay varias funciones que permiten poner más de un gráfico en la misma
figura. Veamos un ejemplo utilizando la función subplots()
# %load scripts/ejemplo_08_5.py
#! /usr/bin/ipython3
""" Script realizado durante la clase 9. Dos figuras """
from pathlib import Path
import numpy as np
import matplotlib.pyplot as plt
plt.ion()
#fname = 'ej_oscil_aten_err'
# Levantamos los datos
#pardir = Path("..")
#datfile = pardir / f'data/{fname}.dat'
fname = fdatos.name
x1, y1, y2 = np.loadtxt(fdatos, unpack=True)
# Vamos a graficar sólo algunos valores (uno de cada 5)
x = x1[3:-10:5]
y = y1[3:-10:5]
yexp = y2[3:-10:5]
# Ejemplo de barras de error que dependen del eje x
error = 0.05 + 0.3 * np.abs(y)
fig, (ax0, ax1) = plt.subplots(nrows=2, sharex=True)
ax0.errorbar(x, yexp, yerr=error, fmt='-o')
ax1.plot(x, 2 * (yexp - y) / (yexp + y), 'or', markersize=8)
# Límites de graficación y títulos
ax0.set_title('Datos con error variable')
ax1.set_title('Error relativo')
ax0.set_ylabel('Voltaje (mV)', fontsize='x-large')
ax1.set_xlabel(r'Tiempo ($\mu$-seg)', fontsize='x-large')
ax1.set_ylabel('Error relativo', fontsize='x-large')
ax1.set_xlim((0, 3))
# Guardamos el resultado
plt.savefig(f'{fname}.png', dpi=150)
# %load scripts/ejemplo_08_5.py
#! /usr/bin/ipython3
""" Script realizado durante la clase 9. Dos figuras """
from pathlib import Path
import numpy as np
import matplotlib.pyplot as plt
plt.ion()
fname = 'ej_oscil_aten_err'
# Levantamos los datos
pardir = Path("..")
datfile = pardir / f'data/{fname}.dat'
x1, y1, y2 = np.loadtxt(datfile, unpack=True)
# Vamos a graficar sólo algunos valores (uno de cada 5)
x = x1[3:-10:5]
y = y1[3:-10:5]
yexp = y2[3:-10:5]
# Ejemplo de barras de error que dependen del eje x
error = 0.05 + 0.3 * np.abs(y)
fig, (ax0, ax1) = plt.subplots(figsize=(10,4), nrows=1, ncols=2)
ax0.errorbar(x, yexp, yerr=error, fmt='-o')
ax1.plot(x, 2 * (yexp - y) / (yexp + y), 'or', markersize=8)
# Límites de graficación y títulos
ax0.set_title('Datos con error variable')
ax1.set_title('Error relativo')
ax0.set_ylabel('Voltaje (mV)', fontsize='x-large')
ax1.set_xlabel(r'Tiempo ($\mu$-seg)', fontsize='x-large')
ax1.set_ylabel('Error relativo', fontsize='x-large')
ax1.set_xlim((0, 3))
# Guardamos el resultado
plt.savefig(f'{fname}_B.png', dpi=150)
En este ejemplo utilizamos un enfoque diferente al utilizado
anteriormente. Matplotlib presenta también una interface orientada a
objetos. La función subplots() devuelve un par fig, axis que son
dos objetos utilizados para representar la figura y un eje. Los
métodos de estos objetos presentan funcionalidad similar a las funciones
del módulo pyplot.
Ejercicios 11 (b)
Para la función definida a trozos:
\[\begin{split}f(x) = \begin{cases} f_{1}(x) = x^{2}/8 & - \pi < x \le \pi/2 \\ f_{2}(x) = -0.3 x & \pi/2 < x < \pi \\ f_{3}(x) = -(x - 2 \pi)^{2}/6 & \pi \le x \le 5 \pi/2 \\ f_{4}(x) = (x - 2 \pi)/5 & 5 \pi/2 < x \le 3 \pi \end{cases}\end{split}\]realizar la siguiente figura de la manera más fiel posible.
Pistas: Buscar información sobre
plt.text(),plt.fill_between()y sobreplt.xticksyplt.yticks.Rehacer la siguiente figura:
.
Personalizando el modo de visualización
Matplotlib da la posibilidad de modificar el estilo de la graficación en distintas “etapas”.
Archivo de configuración
Cuando uno carga el módulo busca un archivo de configuración llamado
matplotlibrc
Primero busca un archivo de configuración en el directorio de trabajo también lo lee. En cada caso sobreescribe las variables.
Si la variable
MATPLOTLIBRCexiste (para el usuario), busca el archivo$MATPLOTLIBRC/matplotlibrcLuego lee un archivo de configuración global del usuario, que dependiendo del sistema operativo puede ser: * En Linux,
.config/matplotlib/matplotlibrc(o en$XDG_CONFIG_HOME/matplotlib/matplotlibrcsi la variableXDG_CONFIG_HOMEexiste) * En otras plataformas puede estar en algún lugar como:C:\Documents and Settings\USUARIO\.matplotlibFinalmente lee el archivo global de la instalación,
INSTALL/matplotlib/mpl-data/matplotlibrc, donde INSTALL se refiere al lugar de instalación
En cualquier caso, podemos obtener el directorio y archivo de configuración con las funciones:
import matplotlib
matplotlib.get_configdir()
'/home/fiol/Trabajos/utils/libraries/matplotlib'
matplotlib.matplotlib_fname()
'/usr/share/matplotlib/mpl-data/matplotlibrc'
!head -n 120 '/usr/share/matplotlib/mpl-data/matplotlibrc'
#### MATPLOTLIBRC FORMAT ## NOTE FOR END USERS: DO NOT EDIT THIS FILE! ## ## This is a sample Matplotlib configuration file - you can find a copy ## of it on your system in site-packages/matplotlib/mpl-data/matplotlibrc ## (relative to your Python installation location). ## DO NOT EDIT IT! ## ## If you wish to change your default style, copy this file to one of the ## following locations: ## Unix/Linux: ## $HOME/.config/matplotlib/matplotlibrc OR ## $XDG_CONFIG_HOME/matplotlib/matplotlibrc (if $XDG_CONFIG_HOME is set) ## Other platforms: ## $HOME/.matplotlib/matplotlibrc ## and edit that copy. ## ## See https://matplotlib.org/stable/users/explain/customizing.html#customizing-with-matplotlibrc-files ## for more details on the paths which are checked for the configuration file. ## ## Blank lines, or lines starting with a comment symbol, are ignored, as are ## trailing comments. Other lines must have the format: ## key: val # optional comment ## ## Formatting: Use PEP8-like style (as enforced in the rest of the codebase). ## All lines start with an additional '#', so that removing all leading '#'s ## yields a valid style file. ## ## Colors: for the color values below, you can either use ## - a Matplotlib color string, such as r, k, or b ## - an RGB tuple, such as (1.0, 0.5, 0.0) ## - a double-quoted hex string, such as "#ff00ff". ## The unquoted string ff00ff is also supported for backward ## compatibility, but is discouraged. ## - a scalar grayscale intensity such as 0.75 ## - a legal html color name, e.g., red, blue, darkslategray ## ## String values may optionally be enclosed in double quotes, which allows ## using the comment character # in the string. ## ## This file (and other style files) must be encoded as utf-8. ## ## Matplotlib configuration are currently divided into following parts: ## - BACKENDS ## - LINES ## - PATCHES ## - HATCHES ## - BOXPLOT ## - FONT ## - TEXT ## - LaTeX ## - AXES ## - DATES ## - TICKS ## - GRIDS ## - LEGEND ## - FIGURE ## - IMAGES ## - CONTOUR PLOTS ## - ERRORBAR PLOTS ## - HISTOGRAM PLOTS ## - SCATTER PLOTS ## - AGG RENDERING ## - PATHS ## - SAVING FIGURES ## - INTERACTIVE KEYMAPS ## - ANIMATION ##### CONFIGURATION BEGINS HERE ## *********************************************************************** ## * BACKENDS * ## *********************************************************************** ## The default backend. If you omit this parameter, the first working ## backend from the following list is used: ## MacOSX QtAgg Gtk4Agg Gtk3Agg TkAgg WxAgg Agg ## Other choices include: ## QtCairo GTK4Cairo GTK3Cairo TkCairo WxCairo Cairo ## Qt5Agg Qt5Cairo Wx # deprecated. ## PS PDF SVG Template ## You can also deploy your own backend outside of Matplotlib by referring to ## the module name (which must be in the PYTHONPATH) as 'module://my_backend'. ##backend: Agg ## The port to use for the web server in the WebAgg backend. #webagg.port: 8988 ## The address on which the WebAgg web server should be reachable #webagg.address: 127.0.0.1 ## If webagg.port is unavailable, a number of other random ports will ## be tried until one that is available is found. #webagg.port_retries: 50 ## When True, open the web browser to the plot that is shown #webagg.open_in_browser: True ## If you are running pyplot inside a GUI and your backend choice ## conflicts, we will automatically try to find a compatible one for ## you if backend_fallback is True #backend_fallback: True #interactive: False #figure.hooks: # list of dotted.module.name:dotted.callable.name #toolbar: toolbar2 # {None, toolbar2, toolmanager} #timezone: UTC # a pytz timezone string, e.g., US/Central or Europe/Paris ## *********************************************************************** ## * LINES * ## *********************************************************************** ## See https://matplotlib.org/stable/api/artist_api.html#module-matplotlib.lines ## for more information on line properties. #lines.linewidth: 1.5 # line width in points #lines.linestyle: - # solid line #lines.color: C0 # has no affect on plot(); see axes.prop_cycle #lines.marker: None # the default marker #lines.markerfacecolor: auto # the default marker face color
Hojas de estilo
Matplotlib ha incorporado en los últimos años un paquete que permite
cambiar estilos fácilmente utilizando los mismos nombres para los
parámetros que hay en el archivo de configuración matplotlibrc.
Este paquete tiene pre-definidos unos pocos estilos, entre ellos varios que emulan otros paquetes o programas. Veamos un ejemplo:
import numpy as np
import matplotlib.pyplot as plt
fdatos = 'data/ej_oscil_aten_err.dat'
x, y, yexp = np.loadtxt(fdatos, unpack=True)
plt.plot(x,y, x, 0.9*y)
[<matplotlib.lines.Line2D at 0x7f145f62fb10>,
<matplotlib.lines.Line2D at 0x7f145f62fc50>]
with plt.style.context('ggplot'):
plt.plot(x,y, x,0.9*y)
with plt.style.context('grayscale'):
plt.plot(x,y, x,0.9*y)
with plt.style.context('fivethirtyeight'):
plt.plot(x,y, x,0.9*y)
Los estilos disponibles están guardados en la variable available
(una lista)
plt.style.available
['Solarize_Light2',
'_classic_test_patch',
'_mpl-gallery',
'_mpl-gallery-nogrid',
'bmh',
'classic',
'dark_background',
'darker',
'fast',
'fivethirtyeight',
'ggplot',
'grayscale',
'latex',
'mate1',
'paper',
'presentation',
'seaborn-v0_8',
'seaborn-v0_8-bright',
'seaborn-v0_8-colorblind',
'seaborn-v0_8-dark',
'seaborn-v0_8-dark-palette',
'seaborn-v0_8-darkgrid',
'seaborn-v0_8-deep',
'seaborn-v0_8-muted',
'seaborn-v0_8-notebook',
'seaborn-v0_8-paper',
'seaborn-v0_8-pastel',
'seaborn-v0_8-poster',
'seaborn-v0_8-talk',
'seaborn-v0_8-ticks',
'seaborn-v0_8-white',
'seaborn-v0_8-whitegrid',
'tableau-colorblind10']
Combinando estilos
Los estilos pueden combinarse. En este caso, debe pasarse una lista de strings con los nombres de los estilos a aplicar. Se aplican en forma secuencial. Si dos estilos definen diferentes valores para una variable, el posterior sobreescribe los valores previos.
with plt.style.context(['fivethirtyeight','grayscale']):
plt.plot(x,y, x,0.9*y)
with plt.style.context(['grayscale','fivethirtyeight']):
plt.plot(x,y, x,0.9*y)
Creación de estilos propios
Podemos crear estilos propios, modificando los defaults con una sintaxis similar a la del archivo de configuración. Por ejemplo creemos un archivo ‘estilo_test’ con algunos parámetros
!echo "lines.linewidth : 5" > estilo_test
!echo "xtick.labelsize: 24" >> estilo_test
#!cat estilo_test
plt.plot(x,y)
[<matplotlib.lines.Line2D at 0x7f145e943c50>]
%pwd
'/home/fiol/Clases/IntPython/clases-python/clases'
plt.style.available
['Solarize_Light2',
'_classic_test_patch',
'_mpl-gallery',
'_mpl-gallery-nogrid',
'bmh',
'classic',
'dark_background',
'darker',
'fast',
'fivethirtyeight',
'ggplot',
'grayscale',
'latex',
'mate1',
'paper',
'presentation',
'seaborn-v0_8',
'seaborn-v0_8-bright',
'seaborn-v0_8-colorblind',
'seaborn-v0_8-dark',
'seaborn-v0_8-dark-palette',
'seaborn-v0_8-darkgrid',
'seaborn-v0_8-deep',
'seaborn-v0_8-muted',
'seaborn-v0_8-notebook',
'seaborn-v0_8-paper',
'seaborn-v0_8-pastel',
'seaborn-v0_8-poster',
'seaborn-v0_8-talk',
'seaborn-v0_8-ticks',
'seaborn-v0_8-white',
'seaborn-v0_8-whitegrid',
'tableau-colorblind10']
with plt.style.context('estilo_test'):
plt.plot(x,y)
with plt.style.context('darker'):
plt.plot(x,y,'C1')
with plt.style.context('presentation'):
plt.plot(x,y,'g')
Para encontrar el lugar donde guardar las hojas de estilo podemos utilizar las funciones de matplotib:
matplotlib.get_configdir()
'/home/fiol/Trabajos/utils/libraries/matplotlib'
ls -1 /home/fiol/Trabajos/utils/libraries/matplotlib
[0m[01;32mmatplotlibrc_working[0m*
[01;34mstylelib[0m/
ls -1 /home/fiol/Trabajos/utils/libraries/matplotlib/stylelib
darker.mplstyle
latex.mplstyle
mate1.mplstyle
paper.mplstyle
presentation.mplstyle
!ls -1 /home/fiol/.config/matplotlib/stylelib/
!cat /home/fiol/.config/matplotlib/stylelib/latex.mplstyle
# -- mode: Conf[Colon] -- # Use LaTeX for formulas # fonts font.family : serif font.serif : Times, Palatino, New Century Schoolbook, Bookman, Computer Modern Roman font.sans-serif : Helvetica, Avant Garde, Computer Modern Sans Serif font.cursive : Zapf Chancery font.monospace : Courier, Computer Modern Typewriter # Para usar fonts tipo latex mathtext.fontset: cm mathtext.rm : serif # # Use LaTeX # text.usetex : true
Modificación de parámetros dentro de programas
Podemos cambiar directamente los parámetros dentro de nuestros programas
modificando el diccionario matplotlib.rcParams
import matplotlib as mpl
mpl.rcParams
RcParams({'_internal.classic_mode': False,
'agg.path.chunksize': 0,
'animation.bitrate': -1,
'animation.codec': 'h264',
'animation.convert_args': ['-layers', 'OptimizePlus'],
'animation.convert_path': 'convert',
'animation.embed_limit': 20.0,
'animation.ffmpeg_args': [],
'animation.ffmpeg_path': 'ffmpeg',
'animation.frame_format': 'png',
'animation.html': 'none',
'animation.writer': 'ffmpeg',
'axes.autolimit_mode': 'data',
'axes.axisbelow': 'line',
'axes.edgecolor': 'black',
'axes.facecolor': 'white',
'axes.formatter.limits': [-5, 6],
'axes.formatter.min_exponent': 0,
'axes.formatter.offset_threshold': 4,
'axes.formatter.use_locale': False,
'axes.formatter.use_mathtext': False,
'axes.formatter.useoffset': True,
'axes.grid': False,
'axes.grid.axis': 'both',
'axes.grid.which': 'major',
'axes.labelcolor': 'black',
'axes.labelpad': 4.0,
'axes.labelsize': 'medium',
'axes.labelweight': 'normal',
'axes.linewidth': 0.8,
'axes.prop_cycle': cycler('color', ['#1f77b4', '#ff7f0e', '#2ca02c', '#d62728', '#9467bd', '#8c564b', '#e377c2', '#7f7f7f', '#bcbd22', '#17becf']),
'axes.spines.bottom': True,
'axes.spines.left': True,
'axes.spines.right': True,
'axes.spines.top': True,
'axes.titlecolor': 'auto',
'axes.titlelocation': 'center',
'axes.titlepad': 6.0,
'axes.titlesize': 'large',
'axes.titleweight': 'normal',
'axes.titley': None,
'axes.unicode_minus': True,
'axes.xmargin': 0.05,
'axes.ymargin': 0.05,
'axes.zmargin': 0.05,
'axes3d.automargin': False,
'axes3d.grid': True,
'axes3d.xaxis.panecolor': (0.95, 0.95, 0.95, 0.5),
'axes3d.yaxis.panecolor': (0.9, 0.9, 0.9, 0.5),
'axes3d.zaxis.panecolor': (0.925, 0.925, 0.925, 0.5),
'backend': 'module://matplotlib_inline.backend_inline',
'backend_fallback': True,
'boxplot.bootstrap': None,
'boxplot.boxprops.color': 'black',
'boxplot.boxprops.linestyle': '-',
'boxplot.boxprops.linewidth': 1.0,
'boxplot.capprops.color': 'black',
'boxplot.capprops.linestyle': '-',
'boxplot.capprops.linewidth': 1.0,
'boxplot.flierprops.color': 'black',
'boxplot.flierprops.linestyle': 'none',
'boxplot.flierprops.linewidth': 1.0,
'boxplot.flierprops.marker': 'o',
'boxplot.flierprops.markeredgecolor': 'black',
'boxplot.flierprops.markeredgewidth': 1.0,
'boxplot.flierprops.markerfacecolor': 'none',
'boxplot.flierprops.markersize': 6.0,
'boxplot.meanline': False,
'boxplot.meanprops.color': 'C2',
'boxplot.meanprops.linestyle': '--',
'boxplot.meanprops.linewidth': 1.0,
'boxplot.meanprops.marker': '^',
'boxplot.meanprops.markeredgecolor': 'C2',
'boxplot.meanprops.markerfacecolor': 'C2',
'boxplot.meanprops.markersize': 6.0,
'boxplot.medianprops.color': 'C1',
'boxplot.medianprops.linestyle': '-',
'boxplot.medianprops.linewidth': 1.0,
'boxplot.notch': False,
'boxplot.patchartist': False,
'boxplot.showbox': True,
'boxplot.showcaps': True,
'boxplot.showfliers': True,
'boxplot.showmeans': False,
'boxplot.vertical': True,
'boxplot.whiskerprops.color': 'black',
'boxplot.whiskerprops.linestyle': '-',
'boxplot.whiskerprops.linewidth': 1.0,
'boxplot.whiskers': 1.5,
'contour.algorithm': 'mpl2014',
'contour.corner_mask': True,
'contour.linewidth': None,
'contour.negative_linestyle': 'dashed',
'date.autoformatter.day': '%Y-%m-%d',
'date.autoformatter.hour': '%m-%d %H',
'date.autoformatter.microsecond': '%M:%S.%f',
'date.autoformatter.minute': '%d %H:%M',
'date.autoformatter.month': '%Y-%m',
'date.autoformatter.second': '%H:%M:%S',
'date.autoformatter.year': '%Y',
'date.converter': 'auto',
'date.epoch': '1970-01-01T00:00:00',
'date.interval_multiples': True,
'docstring.hardcopy': False,
'errorbar.capsize': 0.0,
'figure.autolayout': False,
'figure.constrained_layout.h_pad': 0.04167,
'figure.constrained_layout.hspace': 0.02,
'figure.constrained_layout.use': False,
'figure.constrained_layout.w_pad': 0.04167,
'figure.constrained_layout.wspace': 0.02,
'figure.dpi': 100.0,
'figure.edgecolor': 'white',
'figure.facecolor': 'white',
'figure.figsize': [6.4, 4.8],
'figure.frameon': True,
'figure.hooks': [],
'figure.labelsize': 'large',
'figure.labelweight': 'normal',
'figure.max_open_warning': 20,
'figure.raise_window': True,
'figure.subplot.bottom': 0.11,
'figure.subplot.hspace': 0.2,
'figure.subplot.left': 0.125,
'figure.subplot.right': 0.9,
'figure.subplot.top': 0.88,
'figure.subplot.wspace': 0.2,
'figure.titlesize': 'large',
'figure.titleweight': 'normal',
'font.cursive': ['Apple Chancery',
'Textile',
'Zapf Chancery',
'Sand',
'Script MT',
'Felipa',
'Comic Neue',
'Comic Sans MS',
'cursive'],
'font.family': ['sans-serif'],
'font.fantasy': ['Chicago',
'Charcoal',
'Impact',
'Western',
'xkcd script',
'fantasy'],
'font.monospace': ['DejaVu Sans Mono',
'Bitstream Vera Sans Mono',
'Computer Modern Typewriter',
'Andale Mono',
'Nimbus Mono L',
'Courier New',
'Courier',
'Fixed',
'Terminal',
'monospace'],
'font.sans-serif': ['DejaVu Sans',
'Bitstream Vera Sans',
'Computer Modern Sans Serif',
'Lucida Grande',
'Verdana',
'Geneva',
'Lucid',
'Arial',
'Helvetica',
'Avant Garde',
'sans-serif'],
'font.serif': ['DejaVu Serif',
'Bitstream Vera Serif',
'Computer Modern Roman',
'New Century Schoolbook',
'Century Schoolbook L',
'Utopia',
'ITC Bookman',
'Bookman',
'Nimbus Roman No9 L',
'Times New Roman',
'Times',
'Palatino',
'Charter',
'serif'],
'font.size': 10.0,
'font.stretch': 'normal',
'font.style': 'normal',
'font.variant': 'normal',
'font.weight': 'normal',
'grid.alpha': 1.0,
'grid.color': '#b0b0b0',
'grid.linestyle': '-',
'grid.linewidth': 0.8,
'hatch.color': 'black',
'hatch.linewidth': 1.0,
'hist.bins': 10,
'image.aspect': 'equal',
'image.cmap': 'viridis',
'image.composite_image': True,
'image.interpolation': 'antialiased',
'image.interpolation_stage': 'data',
'image.lut': 256,
'image.origin': 'upper',
'image.resample': True,
'interactive': True,
'keymap.back': ['left', 'c', 'backspace', 'MouseButton.BACK'],
'keymap.copy': ['ctrl+c', 'cmd+c'],
'keymap.forward': ['right', 'v', 'MouseButton.FORWARD'],
'keymap.fullscreen': ['f', 'ctrl+f'],
'keymap.grid': ['g'],
'keymap.grid_minor': ['G'],
'keymap.help': ['f1'],
'keymap.home': ['h', 'r', 'home'],
'keymap.pan': ['p'],
'keymap.quit': ['ctrl+w', 'cmd+w', 'q'],
'keymap.quit_all': [],
'keymap.save': ['s', 'ctrl+s'],
'keymap.xscale': ['k', 'L'],
'keymap.yscale': ['l'],
'keymap.zoom': ['o'],
'legend.borderaxespad': 0.5,
'legend.borderpad': 0.4,
'legend.columnspacing': 2.0,
'legend.edgecolor': '0.8',
'legend.facecolor': 'inherit',
'legend.fancybox': True,
'legend.fontsize': 'medium',
'legend.framealpha': 0.8,
'legend.frameon': True,
'legend.handleheight': 0.7,
'legend.handlelength': 2.0,
'legend.handletextpad': 0.8,
'legend.labelcolor': 'None',
'legend.labelspacing': 0.5,
'legend.loc': 'best',
'legend.markerscale': 1.0,
'legend.numpoints': 1,
'legend.scatterpoints': 1,
'legend.shadow': False,
'legend.title_fontsize': None,
'lines.antialiased': True,
'lines.color': 'C0',
'lines.dash_capstyle': <CapStyle.butt: 'butt'>,
'lines.dash_joinstyle': <JoinStyle.round: 'round'>,
'lines.dashdot_pattern': [6.4, 1.6, 1.0, 1.6],
'lines.dashed_pattern': [3.7, 1.6],
'lines.dotted_pattern': [1.0, 1.65],
'lines.linestyle': '-',
'lines.linewidth': 1.5,
'lines.marker': 'None',
'lines.markeredgecolor': 'auto',
'lines.markeredgewidth': 1.0,
'lines.markerfacecolor': 'auto',
'lines.markersize': 6.0,
'lines.scale_dashes': True,
'lines.solid_capstyle': <CapStyle.projecting: 'projecting'>,
'lines.solid_joinstyle': <JoinStyle.round: 'round'>,
'macosx.window_mode': 'system',
'markers.fillstyle': 'full',
'mathtext.bf': 'sans:bold',
'mathtext.bfit': 'sans:italic:bold',
'mathtext.cal': 'cursive',
'mathtext.default': 'it',
'mathtext.fallback': 'cm',
'mathtext.fontset': 'dejavusans',
'mathtext.it': 'sans:italic',
'mathtext.rm': 'sans',
'mathtext.sf': 'sans',
'mathtext.tt': 'monospace',
'patch.antialiased': True,
'patch.edgecolor': 'black',
'patch.facecolor': 'C0',
'patch.force_edgecolor': False,
'patch.linewidth': 1.0,
'path.effects': [],
'path.simplify': True,
'path.simplify_threshold': 0.111111111111,
'path.sketch': None,
'path.snap': True,
'pcolor.shading': 'auto',
'pcolormesh.snap': True,
'pdf.compression': 6,
'pdf.fonttype': 3,
'pdf.inheritcolor': False,
'pdf.use14corefonts': False,
'pgf.preamble': '',
'pgf.rcfonts': True,
'pgf.texsystem': 'xelatex',
'polaraxes.grid': True,
'ps.distiller.res': 6000,
'ps.fonttype': 3,
'ps.papersize': 'letter',
'ps.useafm': False,
'ps.usedistiller': None,
'savefig.bbox': None,
'savefig.directory': '~',
'savefig.dpi': 'figure',
'savefig.edgecolor': 'auto',
'savefig.facecolor': 'auto',
'savefig.format': 'png',
'savefig.orientation': 'portrait',
'savefig.pad_inches': 0.1,
'savefig.transparent': False,
'scatter.edgecolors': 'face',
'scatter.marker': 'o',
'svg.fonttype': 'path',
'svg.hashsalt': None,
'svg.image_inline': True,
'text.antialiased': True,
'text.color': 'black',
'text.hinting': 'force_autohint',
'text.hinting_factor': 8,
'text.kerning_factor': 0,
'text.latex.preamble': '',
'text.parse_math': True,
'text.usetex': False,
'timezone': 'UTC',
'tk.window_focus': False,
'toolbar': 'toolbar2',
'webagg.address': '127.0.0.1',
'webagg.open_in_browser': True,
'webagg.port': 8988,
'webagg.port_retries': 50,
'xaxis.labellocation': 'center',
'xtick.alignment': 'center',
'xtick.bottom': True,
'xtick.color': 'black',
'xtick.direction': 'out',
'xtick.labelbottom': True,
'xtick.labelcolor': 'inherit',
'xtick.labelsize': 'medium',
'xtick.labeltop': False,
'xtick.major.bottom': True,
'xtick.major.pad': 3.5,
'xtick.major.size': 3.5,
'xtick.major.top': True,
'xtick.major.width': 0.8,
'xtick.minor.bottom': True,
'xtick.minor.ndivs': 'auto',
'xtick.minor.pad': 3.4,
'xtick.minor.size': 2.0,
'xtick.minor.top': True,
'xtick.minor.visible': False,
'xtick.minor.width': 0.6,
'xtick.top': False,
'yaxis.labellocation': 'center',
'ytick.alignment': 'center_baseline',
'ytick.color': 'black',
'ytick.direction': 'out',
'ytick.labelcolor': 'inherit',
'ytick.labelleft': True,
'ytick.labelright': False,
'ytick.labelsize': 'medium',
'ytick.left': True,
'ytick.major.left': True,
'ytick.major.pad': 3.5,
'ytick.major.right': True,
'ytick.major.size': 3.5,
'ytick.major.width': 0.8,
'ytick.minor.left': True,
'ytick.minor.ndivs': 'auto',
'ytick.minor.pad': 3.4,
'ytick.minor.right': True,
'ytick.minor.size': 2.0,
'ytick.minor.visible': False,
'ytick.minor.width': 0.6,
'ytick.right': False})
# Plot con valores default
plt.plot(x,y)
[<matplotlib.lines.Line2D at 0x7f145e703890>]
# Modificamos el valor default de ancho de línea
mpl.rcParams['lines.linewidth'] = 7
plt.plot(x,y)
[<matplotlib.lines.Line2D at 0x7f145f62fd90>]
# El nuevo valor default podemos sobreescribirlo para este plot particular
plt.plot(x,y, lw=3)
[<matplotlib.lines.Line2D at 0x7f145edbbc50>]
# Sin embargo, el nuevo valor default no es modificado
plt.plot(x,y)
[<matplotlib.lines.Line2D at 0x7f145f225a90>]
plt.style.use('grayscale')
plt.plot(x,y)
[<matplotlib.lines.Line2D at 0x7f145ea9f890>]
Ejercicios 11 (c)
Notando que la curva en color negro corresponde a la suma de las dos curvas en rojo, rehacer la siguiente figura:
Crear una hoja de estilo que permita hacer gráficos adecuados para posters y presentaciones. Debe modificar los tamaños para hacerlos legibles a mayores distancias (sugerencia 16pt). El tamaño de la letra de los nombres de ejes y en las leyendas debe ser mayor también. Las líneas deben ser más gruesas (sugerencia: ~4), los símbolos de mayor tamaño (sugerencia ~10).