Úvod

Matplotlib je Python knihovna pro vytváření 2D grafů. Ačkoliv má svůj původ v emulaci příkazů v prostředí MATLAB®, je od tohoto prostředí nezávislá a je používána tzv. Pythonic (využívající jazyk Python v plném rozsahu) objektově orientovaným způsobem. Přestože je Matplotlib primárně napsán v čistém Pythonu, ve velkém využívá NumPy a další rozšíření pro co nejlepší interpretaci i rozsáhlých polí.

Matplotlib je navržen s myšlenkou, aby byl schopen vytvářet jednoduché grafy již po zadání jednoho nebo několika málo příkazů. Zobrazení histogramu vašich dat funguje i bez instance objektů, volání metod, nastavení vlastností apod.

Při vytváření vykreslovacího balíčku pro Python byla snaha o dosažení těchto požadavků:

Matplotlib je mnohými lidmi využíván v mnohých souvislostech. Někteří jim chtějí automaticky generovat PostScript soubory, někteří nasazují Matplotlib na server webové aplikace ke generování PNG výstupů do dynamicky generovaných webových stránek a další jej používají interaktivně z interpreteru příkazů v Tkinteru na Windows.

Proč?

Může se stát, že narazíte na někoho, kdo vám použití Matplotlib nedoporučí s odvoláním, že kancelářské balíky Office a iWork poskytují stejnou funkcionalitu. Existuje tedy důvod Matplotlib používat? Nepochybně ano...

Instalace

Matplotlib lze nainstalovat několika způsoby, ten nejlepší bude záviset na tom, jaký operační systém používáte, co už máte nainstalováno a jak chcete Matplotlib využívat. Aby jsme se vyhnuli procházením všech detailů (a případných komplikací), nejjednodušší věc, kterou uděláte je, že použijete jednu z distribucí Pythonu, ve které už je Matplotlib přibalený. The Enthought Python Distribution (EPD) pro Windows, OS X nebo Redhat je výborná volba, která jednoduše funguje out of the box. Další skvělou alternativou pro uživatele Windows je Python (x,y), který bývá velmi často aktualizováván. Oba balíčky zahrnují Matplotlib, Pylab a mnoho dalších užitečných nástrojů. Matplotlib je také součástí většiny hlavních Linuxových distribucí. Takže pokud používáte Linux, ve vašem správci balíčků bude Matplotlob jistě k nalezení.

Ruční instalace předpřipravených balíčků

Všeobecné pokyny

Pro některé nemusí být Python balíčky zmíněné výše nutně volbou. Nevadí, obvykle je velmi snadné získat vlastní funkční instalaci. Prvně budete muset zjistit, jestli máte na svém zařízení nainstalovaný Python. Jestli ne, nainstalujte jej. Stáhněte oficiální sestavení Pythonu. Uživatelé OS X čtěte zde Jaký Python pro OS X?.

Jakmile Python zprovozníte, nainstalujte si NumPy. NumPy nabízí velmi dobrou interpretaci datových struktur polí, matematických funkcí a je nezbytný pro použití Matplotlib. Zkuste si jak jste s instalací pokročili:

Zjištění verze NumPy
import numpy
print numpy.version.version

Matplotlib vyžaduje NumPy verze 1.1 nebo větší. Ačkoliv to není požadavek k použití Matplotlib, důrazně vám doporučujeme nainstalovat si IPython, což je interaktivní matplotlib-aware interpreter.

Následně instalujte Matplotlib. Zde naleznete spustitelné binární soubory pro OS X a Windows. Vyhledejte nejnovější vydání balíčku Matplotlib, vyberte vaši verzi Pythonu (např.: 2.5, 2.6 nebo 2.7) a vaši platformu (Mac OS X nebo Win32). Pokud se vyskytnou nějaké potíže, prosím zkontrolujte nejčastější kladené otázky v sekci instalace, vyhledejte problém na Google anebo získejte podporu zde na SourceForge.

S Debian/Ubuntu Linuxem stačí provést:

sudo apt-get install python-matplotlib

Instrukce pro instalaci souborů v OS X naleznete v sekci instalace na OS X.

Jakmile nainstalujete IPython, NumPy i Matplotlib, použijte „Pylab“ mód v iPythonu k získání MATLAB-like prostředí, které zvládne většinu konfigurace za vás a instalace bude dříve funkční:

Histogram
Python 2.7.2 (default, Jun 12 2011, 15:08:59) [MSC v.1500 32 bit (Intel)]
Type "copyright", "credits" or "license" for more information.

IPython 0.10.2 -- An enhanced Interactive Python.
?         -> Introduction and overview of IPython's features.
%quickref -> Quick reference.
help      -> Python's own help system.
object?   -> Details about 'object'. ?object also works, ?? prints more.

  Welcome to pylab, a matplotlib-based Python environment.
  For more information, type 'help(pylab)'.

In [1]: x = randn(10000)

In [2]: hist(x, 100)

Důležité je poznamenat, že během testování Matplotlib instalace z interaktivní Python konzole mohou vzkniknout potíže spojené s uživatelskými nástrojovými sadami a nastavením, které jsou diskutovány v sekci použití Matplotlib v interpreteru.

Instalace na Windows

Jestliže ještě nemáte Python nainstalován, zvažte použití Enthought Python, který obsahuje SciPy, NumPy, wxPython a jiné předinstalované užitečné baličky. Standartní instalace Pythonu vyžaduje mimo Matplotlib i nainstalovaný NumPy. Některé operační systémy potřebují knihovnu msvcp71.dll. Ve staženém archivu bude požadovaná knihovna, kterou vybalíte do C:\\Windows\System32.

Instalace ze zdrojových kódů

Jestli vás zaujalo přispění do vývoje Matplotlib, používání nejnovějšího vydání nebo máte jen rádi si vše vytvářet sami, není tak těžké si sestavit Matplotlib ze zdrojového kódu. Ze SourceForge stáhněte nejnovější vydání tar.gz, případně zjistěte jak na Instalace z Github jestli chcete vyvíjet Matplotlib nebo sehnat jeho nejnovější opravenou (bugfixed) verzi.

Jakmile se spokojíte s požadavky instalace níže (hlavně Pythonu, NumPy, LibPng a FreeType), můžete si Matplotlib sestavit:

cd matplotlib
python setup.py build
python setup.py install

Pro přizpůsobení postupu sestavení si stáhněte soubor setup.cfg související s setup.py. Například jaký standartní backend (zahrnuje komponenty, které zpracovávají výstup informací z frontendu) si přejete používat, zda jsou některé z volitelných knihoven Matplotlib nainstalovány apod. Tento soubor bude zejména užitečný do těchto sestavení Matplotlib.

Pokud máte nainstalované všechny požadavky (dependencies / součásti nutné ke zprovoznění Matplotlib) v nestandartních umístěních a potřebujete Matplotlib upozornit, kde se nacházející, editujte soubor setupext.py a přidejte adresář do basedir vstupu slovníku pro sys.platform. Například, pokud se hlavička nějaké požadované knihovny nachází v /some/path/include/someheader.h, vložte cestu /some/path do basedir seznamu vaší platformy.

Požadavky pro sestavení

Uvedené externí balíčky jsou ty, které budete potřebovat instalovat před instalací samotného Matplotlib. Uživatelé Windows potřebují pouze dvě z nich (Python a NumPy), jelikož ostatní jsou zabudovány do Matplotlib Windows instalátoru dostupného ke stažení ze SourceForge webu. Pokud sestavujete na OS X, shlédněte sekci Sestavení na OS X. Jestli na Linuxu instalujete požadavky skrz správce balíčků, je možné, že bude třeba navíc instalovat i balíčky pro vývoj (poohlédněte se po předponě “-dev“ v názvu balíčku).

Na Debian/Ubuntu získáte všechny požadavky Matplotlib zadáním:

sudo apt-get build-dep python-matplotlib

Na Fedora/RedHat získáte všechny požadavky Matplotlib instalací yum-builddep a poté zadáním:

su -c "yum-builddep python-matplotlib"

Tento proces zajistí instalaci všech požadavků, které vám ulehčí sestavení Matplotlib ze zdrojového kódu.

Python 2.4 (nebo novější, kromě Pythonu 3!)
    Matplotlib vyžaduje Python 2.4 nebo novější (stáhnout)

NumPy 1.1 (nebo novější)
    Podpora matic pro Python (stáhnout)

LibPng 1.2 (nebo novější)
    Knihovna pro načtení a uložení souborů PNG (stáhnout). LibPng vyžaduje zlib, který mohou uživatelé Windows ignorovat.

Free Type 1.4 (nebo novější)
    Knihovna pro čtení souborů TTF, kterou mohou uživatelé Windows také ignorovat.

Volitelné

Uvedené volitelné balíčky si můžete doinstalovat pro použití Matplotlib s rozhraním nástrojové sady. Zjistěte Co je Backend? pro více detailů, například jaké možnosti nabízejí.

Tk 8.3 nebo novější
    TCL/Tk widget knihovna používaná TkAgg backendem.

PyQt 3.1 nebo novější
    Qt3 widget knihovny pro QtAgg backend.

PyQt 4.0 nebo novější
    Qt4 widget knihovna pro Qt4Agg backend.

PyGTK 2.4 nebo novější
    Python wrappery do widget knihovny GTK pro použití s GTA nebo GTKAgg backendy.

wxPython 2.8 nebo novější
    Python wrappery do widget knihovny wx pro použití s WX nebo WXAgg backendy.

pyFLTK 1.0 nebo novější
    Python wrappery do widget knihovny FLTK pro použití s FLTKAgg backendy.

Požadované knihovny dodávané s Matplotlib

AGG 2.4
    Antigrain C + + vykreslování. Matplotlib spojuje oproti AGG šablonám zdroj staticky, takže neovlivní absolutně nic ve vašem systému mimo Matplotlib.

pytz 2007g nebo novější
    Manipulace s časovými pásmem v Pythonu, Matplotlib ve výchozím nastavení instaluje pytz, jestliže není nainstalován. K jejímu přepsání a vyhnutí se instalace pytz použijte zmiňovaný soubor setup.cfg.

dateutil 1.1 nebo novější
    Rozšíření pro manipulaci s časovými údaji. Matplotlib jej automaticky instaluje, dá se nahradit znovu díky souboru setup.cfg.

Sestavení na OSX

Proces sestavení se na OS X komplikuje na různých místech – požadavky LibPng a FreeType (darwinports, fink, /usr/X11R6), odlišná architektura (např.: x86, PPC, Universal) a odlišná verze OS X (např.: 10.4, 10.5). Doporučujeme si sestavit Matplotlib následujícím způsobem: získejte zdroj z tarball nebo git repozitáře a následujte instrukce v README.osx.

Pyplot tutoriál

matplotlib.pyplot je submodul poskytující procedurální přístup k vysokoúrovňovým kreslícím funkcím, díky kterému Matplotlib pracuje podobně jako MATLAB. Každá Pyplot funkce provádí nějakou změnu obrazce: např.: vytvoří obrazec, kreslící plochu v obrazci, vykreslí čáru do kreslící plochy, popíše graf atp. matplotlib.pyplot sleduje obrazec a vykreslovací oblast, jeho funkce jsou zaměřeny na aktuální osy.

Vykreslení jednoduché křivky
import matplotlib.pyplot as plt
plt.plot([1,2,3,4])
plt.ylabel('Osa Y')
plt.xlabel('Osa X')
plt.show()

Možná se divíte, proč je rozmezí osy x 0-2 a osy y od 1-3. Při poskytnutí seznamu nebo pole příkazu plot() Matplotlib předpokládá, že se jedná o posloupnost hodnot osy y a tudiž pro vás automaticky vygeneruje hodnotu osy x. Poněvadž Python začíná rozsah číslem 0, výchozí vektor x má tu samou délku, jako y, ale začínající 0. Proto jsou údaje z x [0, 1, 2].

plot () je univerzální příkaz beroucí libovolný počet argumentů. Například, pro vykreslení x oproti y, využijte příkazu:

Vykreslení křivky pomocí souřadnic bodu obou os
plt.plot([1,2,3,4], [1,4,9,16])

Pro každou dvojici argumentů x a y existuje volitelný, třetí argument – formátovací řetězec udávající barvu a typ čáry v grafu. Písmena a symboly z tohoto řetězce mají původ v MATLAB, takže zadání řetězce pro nastavení barvy provedete do řetězce stylu čáry. Výchozí formátovací řetězec je „b-“, který vystylizuje čáru modře. Například, k vykreslení příkladu výše zadejte:

Styl čáry pomocí formátovacího řetězce
import matplotlib.pyplot as plt
plt.plot([1,2,3,4], [1,4,9,16], 'ro')
plt.axis([0, 6, 0, 20])
plt.show()

Podívejte se na dokumentaci k plot() pro kompletní seznam stylů čar a formátovacích řetězců. Příkaz axis() v příkladu výše si bere seznam argumentů [xmin, ymax, ymin, ymax] a specifikuje výřez z několika bodů.

Kdyby byl Matplotlib limitován v práci se seznamy, byl by při numerickém vypracování docela k ničemu. Ale hlavně, pro pole budete používat NumPy. Všechny posloupnosti jsou totiž interně převáděny do NumPy polí. Příklad níže znázorňuje a vykresluje několik čar s odlišným formátem stylu jedním příkazem pomocí matice.

Vykreslení několika čar současně
import numpy as np
import matplotlib.pyplot as plt
 
# vzorky po 200ms intervalech
t = np.arange(0., 5., 0.2)
 
# pomlčky červeně, čtverečky modře a trojúhelníčky zeleně
plt.plot(t, t, 'r--', t, t**2, 'bs', t, t**3, 'g^')
plt.show()

Nastavení vlastnosti čar

Čárám toho lze mnoho nastavit skrz atributy: tloušťka čáry, přerušovaná čára, vyhlazení, atd. Podívejte se na matplotlib.lines.Line2D. Existuje několik způsobů jak atributy nastavit:

Užitím klíčových slov:

plt.plot(x, y, linewidth=2.0)

Užitím nastavovací metody instance Line2D. Funkce plot vrací seznam čar: např line1, line2 = plot(x1,y1,x2,x2). Níže je uvedena pouze jedna, takže se jedná o seznam délky 1. Pro získání prvního prvku seznamu použijte line, = plot(x, y, 'o'):

line, = plt.plot(x, y, '-')
line.set_antialiased(False) # vypnutí vyhlazení

Užitím příkazu setp(). Příklad níže používá MATLAB-like příkazu pro nastavení několika vlastností seznamu čar. Funguje transparentně se seznamem objektů nebo jako samostatně. Takže použijte buď Python klíčových slov nebo MATLAB-like řetězci/dvojici hodnot:

lines = plt.plot(x1, y1, x2, y2)
# klíčová slova
plt.setp(lines, color='r', linewidth=2.0)
# MATLAB-like styl
plt.setp(lines, 'color', 'r', 'linewidth', 2.0)

Prohlédněte si dostupné vlastnosti Line2D.

Vlastnost Typ hodnoty
alpha
desetinné číslo
animated
[True | False]
antialiased nebo aa
[True | False]
clip_box
instance třídy matplotlib.transform.Bbox
clip_on
[True | False]
clip_path
instance třídy Path/Transform, Patch
color nebo c
jakkákoliv Matplotlib barva
contains
volající se funkce
dash_capstyle
[‘butt’ | ‘round’ | ‘projecting’]
dash_joinstyle
[‘miter’ | ‘round’ | ‘bevel’]
dashes
on/off v bodech (pt)
data
(np.array xdata, np.array ydata)
figure
instance matplotlib.figure.Figure
label
jakýkoliv řetězec
linestyle nebo ls
[ ‘-‘ | ‘–’ | ‘-.’ | ‘:’ | ‘steps’ | ...]
linewidth nebo lw
desetinné číslo v bodech (pt)
lod
[True | False]
marker
[ ‘+’ | ‘,’ | ‘.’ | ‘1’ | ‘2’ | ‘3’ | ‘4’]
markeredgecolor nebo mec
jakákoliv Matplotlib barva
markeredgewidth nebo mew
desetinné číslo v bodech (pt)
markerfacecolor nebo mfc
jakákoliv Matplotlib barva
markersize nebo ms
desetinné číslo
markevery
nic (none) | celé číslo | (startind, stride)
picker
použití v interaktivním výběru čáry
pickradius
radius v bodech (pt)
solid_capstyle
[‘butt’ | ‘round’ | ‘projecting’]
solid_joinstyle
[‘miter’ | ‘round’ | ‘bevel’]
transform
instance třídy matplotlib.transforms.Transform
visible
[True | False]
xdata
np.array
ydata
np.array
zorder
jakékoliv číslo

Pro získání seznamu nastavitelných vlastností čar, zavolejte funkci setp() a předejte ji čáru/čáry jako argument:

In [1]: lines = plt.plot([1,2,3])

In [2]: plt.setp(lines)
  agg_filter: unknown
  alpha: float (0.0 transparent through 1.0 opaque)         
  animated: [True | False]         
  antialiased or aa: [True | False]
  ...a spousta dalších vlastností

Práce s několika grafy a osami

Všechny vykreslovací příkazy se vztahují na aktuální osy. Funkce gca() vrací aktuální osy a funkce gcf() vrací aktuální graf. Níže je skript vytvářející 2 podgrafy:

Podgrafy
import numpy as np
import matplotlib.pyplot as plt

def f(t):
    return np.exp(-t) * np.cos(2*np.pi*t)

t1 = np.arange(0.0, 5.0, 0.1)
t2 = np.arange(0.0, 5.0, 0.02)

plt.figure(1)
plt.subplot(211)
plt.plot(t1, f(t1), 'bo', t2, f(t2), 'k')

plt.subplot(212)
plt.plot(t2, np.cos(2*np.pi*t2), 'r--')
plt.show()

Příkaz figure() je zde volitelný, protože figure(1) se vždy vytváří automaticky, stejně jako subplot(111), pokud se však nestane, že ručně specifikujete osy. Příkaz subplot() specifikuje numrows, numcols a fignum, přičemž rozsah hodnot fignum sahá od 1 do numrows*numcols. Čárky v příkazu subplot() jsou volitelné jestliže numrows*numcols<10. Takže subplot(211) je identický se subplot(2,1,1). Vytvářejte libovolný počet podgrafů a os. Příkaz axes() umožňuje specifikovat pozici os axes([left, bottom, width, height]) kde všechny hodnoty jsou v nepatrných (0 až 1) souřadnicích.

Můžete vytvářet několik grafů užitím několika volání figure() se stále se zvyšujícím číslem grafu. Samozřejmě, že každá z nich může obsahovat tolik os a podgrafů kolik si jen přejete:

import matplotlib.pyplot as plt
plt.figure(1)                # první obrazec
plt.subplot(211)             # první obrazec v prvním grafu
plt.plot([1,2,3])
plt.subplot(212)             # druhý obrazec v prvním grafu
plt.plot([4,5,6])


plt.figure(2)                # druhý obrazec
plt.plot([4,5,6])            # automaticky vytváří subplot(111)

plt.figure(1)                
plt.subplot(211)             # vytvoření subplot(211) do figure1

Vymazání grafu lze dosáhnout pomocí clf() a os pomocí cla().

Z hlediska paměti je nutné používat příkazu close() pro vyčistění grafů z paměti. Zavření okna grafu opravdu nestačí.

Práce s textem

Příkaz text() může být použit na přidání textu kamkoliv a xlabel(), ylabel() a title() na uvedené místo (podívejte se na Text introduction)

IQ histogram a příklad práce s textem
import numpy as np
import matplotlib.pyplot as plt

mu, sigma = 100, 15
x = mu + sigma * np.random.randn(10000)

# histogram dat
n, bins, patches = plt.hist(x, 50, normed=1, facecolor='g', alpha=0.75)


plt.xlabel('Chytrost')
plt.ylabel('Pravdepodobnost')
plt.title('IQ histogram')
plt.text(60, .025, r'$\mu=100,\ \sigma=15$')
plt.axis([40, 160, 0, 0.03])
plt.grid(True)
plt.show()

Všechny příkazy text() vrací instanci matplotlib.text.Text. Stejně jako s řádky výše, upravovat vlastnosti předáním klíčových argumentu do funkcí textu nebo užitím setp():

t = plt.xlabel('moje data', fontsize=14, color='red')

Více informací naleznete detailnějí v Text properties and layout.

Matematické výrazy v textu

Matplotlib akceptuje výrazy TeX rovnic v jakémkoliv textovém výrazu. tyto výrazy ohraničte znakem dolaru:

plt.title(r'$\sigma_i=15$')

Písmeno r před řetězcem je důležité - značí, že se jedná o raw řetězec. Matplotlib obsahuje vestavěný TeX parser a přichází s vlastními matematickými fonty.

Poznámky

Užitím jednoduchého příkazu text() umístěte text do libovolného umístění na osách. Metoda annotate() poskytuje pomocnou funkcionalitu ve formě poznámek. Tu umisťujeme pomocí argumentu xy a umístěním pomocí xytext. Oba argumenty představují dvojici souřadnic (x,y).

Vložení poznámky/anotace do grafu
import numpy as np
import matplotlib.pyplot as plt

ax = plt.subplot(111)

t = np.arange(0.0, 5.0, 0.01)
s = np.cos(2*np.pi*t)
line, = plt.plot(t, s, lw=2)

plt.annotate('Maximum', xy=(2, 1), xytext=(3, 1.5),
            arrowprops=dict(facecolor='black', shrink=0.05),
            )

plt.ylim(-2,2)
plt.show()

V tomto příkladě, obojí umístění xy (špička šipky) a xytext (umístění textu) jsou v údajích souřadnich. Existuje mnoho různých dalších souřadnicových systémů na výběr - v tom případě shlédněte Annotating text a Annotating Axes pro více informací.

Navigace

Navigation

Okno zobrazující obrazce obsahuje navigační lištu. Prozkoumejte význam těchto tlačítek.

Navigation - HomeNavigation - BackNavigation - Forward
Tlačítka vpřed a zpřed
Podobná těm co jsou ve webových prohlížečích. Nemají význam dokud nepřejdete jinam pomocí tlačítek pan/zoom. Ty použijte pro výběr nového pohledu obrazce.

Navigation - Pan/Zoom
Tlačítko pan/zoom
Toto tlačítko má dva režimy: pan a zoom (čili posun a přiblížení). Lze se díky nim dostat a prohlédnout chtěné souřadnice obrazce. Stiskem 'x' nebo 'y' při posouvání budete omezeni na posun pouze po souřadnici, jejichž klávesu držíte. Totéž pro přibližování, klávesami 'x', 'y' nebo 'CONTROL' přinutíte přiblížování zaměřit se na osu x, osu y nebo zachovat poměr stran.

S polárními grafy [Polární soustava souřadnic je taková soustava souřadnic v rovině, u které jedna souřadnice udává vzdálenost bodu od počátku souřadnic, druhá souřadnice udává úhel spojnice tohoto bodu a počátku od zvolené osy ležící v rovině (nejčastěji jí odpovídá osa kartézských souřadnic)] se toto tlačítko chová odlišně. Štítky poloměru os lze přetáhnout levým tlačítkem myši. Rozsah poloměru může být přiblížen a oddálen pravým tlačítkem myši

Navigation - Zoom to rectangle
Tlačítko Zoom-to-rectangle
Aktivujte tlačítko, najeďte myší kamkoliv nad osy a stiskněte levé tlačítko myši. Přetáhněte myš při držení tlačítka 'na novou pozici' a uvolněte. Limity pohledu na osy bude přiblížen na vámi definovanou obdélníkovou plochu.

Navigation - Subplots
Tlačítko Subplot-configuration
Použijte tento nástroj na konfiguraci parametrů podgrafu: levá, pravá, horní a dolní mezera mezi řádky a mezera mezi sloupci.

Navigation - Save
Tlačítko Uložit
Pro uložení souboru do PNG, EPS, SVG nebo PDF.

Navigační klávesové zkratky

Následující tabulka obsahuje všechny výchozí klávesy, které lze přenastavit pomocí souboru matplotlibrc (#keymap.*)

Příkaz
Klávesová zkratka
Home/Reset/Domů
h, r nebo Home
Zpět
c, šipka doleva nebo backspace
Vpřed
v nebo šipka doprava
Pan/Zoom
p
Zoom-to-rectangle
o
Uložit
s
Přepínání mezi módem na celou obrazovku
f
Přinutit pan/zoom k pohybu na ose x
držte x
Přinutit pan/zoom k pohybu na ose y
držte y
Zachovat poměr stran
držte CONTROL
Přepínání mezi zobrazením mřížky
g
Přepínání měřítka osy x (log/linear)
L nebo k
Přepínání měřítka osy y (log/linear) I

Přizpůsobení Matplotlib

Soubor matplotlibrc

Matplotlib používá tento subor pro úpravu všech druhů vlastností nazývaných rc nastavení nebo rc parametry. Nastavujte vlastnosti Matplotlib jako například: velikost obrazce a dpi, tloušťka čar, barva a styl, vlastnosti textu a fontu atd. Maplotlib hledá a čte soubor matplotlibrc z třech umístění, v následujícím pořadí:

  1. matplotlibrc v aktuálním pracovním adresáři, obvykle pro specifikace, kterou nechcete používat všude a vždy
  2. .matplotlib/matplotlibrc, pro uživatelské výchozí úpravy. Podívejte se to adresáře .matplotlib
  3. INSTALL/matplotlib/mpl-data/matplotlibrc, kde INSTALL je něco jako /usr/lib/python2.7/site-packages na Linuxu a zřejmě C:\Python27\Lib\site-packages na Windows. Po každé instalaci Matplotlib je tento soubor přepisován, takže pro uložení vaších úprav jej přesuňte do adresáře .matplotlib.

Pro zobrazení momentálně aktivního souboru matplotlibrc, zadejte následující:

import matplotlib
matplotlib.matplotlib_fname()

Dynamické nastavení rc Je možné také měnit rc nastavení interaktivně, přímo z interpreteru. Všechno rc nastavení je uloženo ve formě matplotlib.rcParams proměnných, globálních pro balíček Matplotlib.rcParams mohou být přímo modifikovány, například:

import matplotlib as mpl
mpl.rcParams['lines.linewidth'] = 2
mpl.rcParams['lines.color'] = 'r'

Matplotlib také poskytuje několik výhodných funkcí pro modifikaci rc nastavení. Příkaz matplotlib.rc() může být používán pro modifikaci několika nastavení v jediném volání, hromadně, použitím klíčových argumentů:

import matplotlib as mpl
mpl.rc('lines', linewidth=2, color='r')

Příkaz matplotlib.rcdefaults() obnoví nastavení Matplotlib do původních hodnot.

Existuje určitý stupeň validace, když se nastavují hodnoty rcParams, podívejte se na matplotlib.rcsetup pro více informací.

Ukázka souboru matplotlibrc (pro manipulaci se souborem a nastavením je nutná alespoň základní znalost angličtiny).

Použití Matplotlib v interpreteru Pythonu

Normálně Matplotlib odkládá vykreslování do ukončení skriptu, protože vykreslování je docela náročná operace a vy byste přece nechtěli aktualizovávat graf pokaždé, když se změní byť jen jediná jeho vlastnost. Děje se tak tedyjen, když dojde ke změně všech vlastností.

Ale při práci s interpreterem to obvykle vyžadujete (například při změně xlabel()). To se může jevit jako jednoduché, ve skutečnosti tomu tak, ale není, protože Matplotlib je GUI aplikací. Existují ovšem různé triky, které zajistí aplikaci v interpreteru bezchybnou funkčnost.

Ipython jako záchrana

Naštěstí, Ipython, vylepšený interaktivní interpreter Pythonu vyřeší všechny tyto problémy. Funguje tzv. matplotlib aware, když jej zapnete v módu Pylab.

Python 2.7.2 (default, Jun 12 2011, 15:08:59) [MSC v.1500 32 bit (Intel)]
Type "copyright", "credits" or "license" for more information.

IPython 0.10.2 -- An enhanced Interactive Python.
?         -> Introduction and overview of IPython's features.
%quickref -> Quick reference.
help      -> Python's own help system.
object?   -> Details about 'object'. ?object also works, ?? prints more.

  Welcome to pylab, a matplotlib-based Python environment.
  For more information, type 'help(pylab)'.

In [1]: x = randn(10000)

In [2]: hist(x, 100)

Zavolejte figure() a obrazec se vám zobrazí do okna, zavolejte plot() a vaše data se objeví v okně obrazce.

Všimněte si, že v příkladu výše jsme neimportovali z Matplotlib absolutně nic, protože v Pylab módu je vše automaticky importováno pomocí Ipythonu. Ten vás vezme do interaktivního módu, kde každý Pyplot příkaz vyvolá aktualizaci obrazce.

Ostatní interpretery Pythonu

Pokud nemůžete využívat Ipythonu a přesto chcete pracovat s interaktivním interpreterem, například plain-ole standard Python interaktivním interpreteru nebo interpreterem ve vašem IDE, budete muset pochopit co znamená pojem Matplotlib backend.

S TkAgg backendem využívající nástroje prostředí Tkinter můžete využít Matplotlib z libovolného Python interpreteru. Prostě v souboru matplotlibrc nastavte "backend : TkAgg" a "interactive : True" a poté zadejte:

>>> from pylab import *
>>> plot([1,2,3])
>>> xlabel('Test')

Nezapomeňte si uvědomit, že vykreslování z tohoto módu může trvat trochu déle.

Ovládání interaktivních aktualizací

Vlastnost interactive kontroluje zda plocha obrazce je vykreslována při zadání každého příkazu Pyplot. Jestliže má nastavenou hodnotu False, poté je obrazec aktualizován pouze při každém příkazu plot, při explicitním volání funkce draw(). Při hodnotě True, všechny příkazy Pyplot začínají kreslit.

Prostředí Pyplot poskytuje 4 příkazy užitečné pro ovládání interakce.

isinteractive()
    vrací nastavení interaktivity - True|False
ion()
    zapne interkativní mód
ioff()
    vypne interkativní mód
draw()
    znovu překreslí obrazec

Při práci s velkým obrazcem, který je náročný ve vyobrazení můžete chtít dočasně vypnout interaktivní mód Matplotlib abyste předešli problémům s výkonem:

>>> # vytváříte náročný obrazec
>>> ioff()      # vypnutí překreslování
>>> title('A co ted?')
>>> xticklabels(fontsize=20, color='green')
>>> draw()      # vykreslení
>>> savefig('hotovo', dpi=300)
>>> close()
>>> ion()      # zapnutí překreslování
>>> plot(rand(20), mfc='g', mec='r', ms=40, mew=4, ls='--', lw=3)

Práce s textem

Základní příkazy pro práci s textem

Příkazy textu v akci
# -*- coding: utf-8 -*-
import matplotlib.pyplot as plt

fig = plt.figure()
fig.suptitle('tucny horni titul', fontsize=14, fontweight='bold')

ax = fig.add_subplot(111)
fig.subplots_adjust(top=0.85)
ax.set_title('titul os')

ax.set_xlabel('popis osy x')
ax.set_ylabel('popis osy y')

ax.text(3, 8, 'ohraniceny text souradnic s kurzivou', style='italic',
        bbox={'facecolor':'red', 'alpha':0.5, 'pad':10})

ax.text(2, 6, r'rovnice: $E=mc^2$', fontsize=15)

ax.text(3, 2, unicode('unicode test: Institut f\374r Festk\366rperphysik', 'latin-1'))

ax.text(0.95, 0.01, 'barevny text souradnic os',
        verticalalignment='bottom', horizontalalignment='right',
        transform=ax.transAxes,
        color='green', fontsize=15)


ax.plot([2], [1], 'o')
ax.annotate('poznamka', xy=(2, 1), xytext=(3, 4),
            arrowprops=dict(facecolor='black', shrink=0.05))

ax.axis([0, 10, 0, 10])

plt.show()

Vlastnosti textu a rozvržení

Instance třídy matplotlib.text.Text nabízí různé vlastnosti ke konfiguraci přes argumenty do příkazů text (např.: title(), xlabel() a text()).

Vlastnost Typ hodnoty
alpha desetinné číslo
backgroundcolor jakákoliv Matplotlib barva
bbox vlastnosti obdelníkové plochy obrazce
clip_box instance třídy matplotlib.transform.Bbox
clip_on [True | False]
clip_path instance třídy Path/Transform, Patch
color jakákoliv Matplotlib barva
family [ ‘serif’ | ‘sans-serif’ | ‘cursive’ | ‘fantasy’ | ‘monospace’ ]
fontproperties instance třídy matplotlib.font_manager.FontProperties
horizontalalignment nebo ha [ ‘center’ | ‘right’ | ‘left’ ]
label jakýkoliv řetězec
linespacing desetinné číslo
multialignment [‘left’ | ‘right’ | ‘center’ ]
name nebo fontname string eg, [‘Sans’ | ‘Courier’ | ‘Helvetica’ ...]
picker [None|float|boolean|callable]
position (x,y)
rotation [ angle in degrees ‘vertical’ | ‘horizontal’
size nebo fontsize [ size in points | relative size eg ‘smaller’, ‘x-large’ ]
style nebo fontstyle [ ‘normal’ | ‘italic’ | ‘oblique’]
text řetězec nebo cokoliv tisknutelného s "%s"
transform instance třídy matplotlib.transform
variant [ ‘normal’ | ‘small-caps’ ]
verticalalignment nebo va [ ‘center’ | ‘top’ | ‘bottom’ | ‘baseline’ ]
visible [True | False]
weight nebo fontweight [ ‘normal’ | ‘bold’ | ‘heavy’ | ‘light’ | ‘ultrabold’ | ‘ultralight’]
x desetinné číslo
y desetinné číslo
zorder jakékoliv číslo

Vlastnosti textu v akci
import matplotlib.pyplot as plt
import matplotlib.patches as patches

# sestavení obdelníkové plochy
left, width = .25, .5
bottom, height = .25, .5
right = left + width
top = bottom + height

fig = plt.figure()
ax = fig.add_axes([0,0,1,1])

# souřadnice os - 0,0 znamená dole vlevo a 1,1 nahoře vpravo
p = patches.Rectangle(
    (left, bottom), width, height,
    fill=False, transform=ax.transAxes, clip_on=False
    )

ax.add_patch(p)

ax.text(left, bottom, 'left top',
        horizontalalignment='left',
        verticalalignment='top',
        transform=ax.transAxes)

ax.text(left, bottom, 'left bottom',
        horizontalalignment='left',
        verticalalignment='bottom',
        transform=ax.transAxes)

ax.text(right, top, 'right bottom',
        horizontalalignment='right',
        verticalalignment='bottom',
        transform=ax.transAxes)

ax.text(right, top, 'right top',
        horizontalalignment='right',
        verticalalignment='top',
        transform=ax.transAxes)

ax.text(right, bottom, 'center top',
        horizontalalignment='center',
        verticalalignment='top',
        transform=ax.transAxes)

ax.text(left, 0.5*(bottom+top), 'right center',
        horizontalalignment='right',
        verticalalignment='center',
        rotation='vertical',
        transform=ax.transAxes)

ax.text(left, 0.5*(bottom+top), 'left center',
        horizontalalignment='left',
        verticalalignment='center',
        rotation='vertical',
        transform=ax.transAxes)

ax.text(0.5*(left+right), 0.5*(bottom+top), 'middle',
        horizontalalignment='center',
        verticalalignment='center',
        fontsize=20, color='red',
        transform=ax.transAxes)

ax.text(right, 0.5*(bottom+top), 'centered',
        horizontalalignment='center',
        verticalalignment='center',
        rotation='vertical',
        transform=ax.transAxes)

ax.text(left, top, 'rotated\nwith newlines',
        horizontalalignment='center',
        verticalalignment='center',
        rotation=45,
        transform=ax.transAxes)

ax.set_axis_off()
plt.show()

Zápis matematických výrazů

Matplotlib zajistí například místo

# plain text
plt.title('alpha > beta')

zobrazení “alpha > beta”

# matematický text
plt.title(r'$\alpha > \beta$')

grafičtější výstup math-1

Mathtext by měl být umístěn mezi znaky dolaru ($). K snadnému zobrazení peněžních hodnot (např.: "$100.00") za přítomnosti značky dolaru v samotném řetězci budou zobrazeny doslovně se značkou dolaru. Jedná se o menší změnu z TeX, kde by dolarová značka zapsaná ne-matematickým textem měla být vynechána ('$').

Zatímco se syntaxe uvnitř dvojice dolarů ($) snaží být TeX-like, mimo ně se tak nestává. Konkrétně, znaky jako

# $ % & ~ _ ^ \ { } \( \) \[ \]

mají v TeX speciální význam mimo matematický mód. Proto se budou chovat jinak a záviset na rcParam text.usetex. Pro více informací shlédněte usetex tutorial.

Horní a dolní index

Používají se pro ně symboly '_' a '^'.

r'$\alpha_i > \beta_i$'
math-e2db32b4d0

Některé symboly automaticky vkládají index pod nebo nad subjekt. Například, suma math-ccea9f4e30 od nuly do nekonečna:

r'$\sum_{i=0}^\infty x_i$'
math-a3ca6be911

Frakce, zlomky and složená čísla

Ty mohou být vytvořeny pomocí příkazů frac{}{}, \binom{}{} a \stackrel{}{}

r'$\frac{3}{4} \binom{3}{4} \stackrel{3}{4}$'

vytvoří
math-3025afbc71
Pro frakce

r'$\frac{5 - \frac{1}{x}}{4}$'

vytvoří
math-2e885fe67f
Pro správné umístění a vytvoření závorek použijte \left a \right následovně

r'$\left(\frac{5 - \frac{1}{x}}{4}\right)$'

math-9d267a8c3c

Odmocniny

Ty vytvářejte pomocí příkazu \sqrt[]{}

r'$\sqrt{2}$'

math-f151e9b6c6
a pro třetí a vyšší odmocniny

r'$\sqrt[3]{x}$'

math-6b6cc30aef

Fonty

Matematické symboly jsou vždy kurzívou, to lze změnit pomocí rcParam mathtext.default, pro zápis "sin" ve fontu Roman:

r'$s(t) = \mathcal{A}\mathrm{sin}(2 \omega t)$'

nebo ekvivalentním zkráceným zápisem

r'$s(t) = \mathcal{A}\sin(2 \omega t)$'
math-c8056d47b3

Následující proměnné "s" a "t" jsou kurzívou (výchozí), "sin" je ve fontu Roman a amplituda "A" ve fontu calligraphy. Všimněte si, že amplituda "A" je namačkaná na "sin". Jednoduchým příkazem vytvoříte mezi nimi mezeru:

s(t) = \mathcal{A}\/\sin(2 \omega t)
math-44f45b7160

Výběr z fontů je následovný:

Příkaz Výsledek
\mathrm{Roman}
\mathit{Italic}
\mathtt{Typewriter}
\mathcal{CALLIGRAPHY}


Při použití fontů STIX, máte ještě na výběr:

Příkaz Výsledek
\mathbb{blackboard}
\mathrm{\mathbb{blackboard}}
\mathfrak{Fraktur}
\mathsf{sansserif}
\mathrm{\mathsf{sansserif}}
\mathcircled{circled}


Na výběr je také z tzv. globální "sady fontů", z které si lze vybírat pomocí parametru mathtext.fontset v souboru matplotlibrc.

cm: Computer Modern (TeX)

stix: STIX

stixsans: STIX sans-serif

Navíc, můžete využít \mathdefault{...} nebo jeho alisasu \mathregular{...} pro běžný text (regular) mimo mathtext. Existuje pro to řada omezení, asi největší, že daleko méně symbolů bude k dispozici, ale bude to užitečné zejména při kombinaci matematických výrazů s klasickým textem grafu.

Vlastní fonty

Mathtext taktéž podporuje způsob použití vlastních fontů. Ten je, ale velmi složitý, experimentální a pouze pro trpělivé povahy. Nastavením rcParam mathtext.fontset na 'custom' můžete nastavit parametry, které kontrolují který soubor fontu použít na matematické znaky.

Parametr Odpovídá
mathtext.it \mathit{} nebo výchozí kurzíva
mathtext.rm \mathrm{} Roman (upright)
mathtext.tt \mathtt{} Typewriter (monospace)
mathtext.bf \mathbf{} tučná kurzíva
mathtext.cal \mathcal{} calligraphic
mathtext.sf \mathsf{} sans-serif

Fonty by měly být zobrazovány Unicode, aby bylo schopno zobrazit každý z ne-latiských znaků, jako například z řečtiny. Pro použití matematického symbolu, který není obsažen ve vašem fontu, nastavte rcParam mathtext.fallback_to_cm na 'True', tím pádem se použije znak ze základního fontu.

Znaménka

Příkaz pro znaménka by měl mít přednost před symbolem, který ho obsahuje. Máte na výbět z delší a kratší formy zápisu:

Příkaz Výsledek
\acute a
\'a
\bar a
\breve a
\ddot a
\"a
\dot a
\.a
\grave a
\`a
\hat a
\^a
\tilde a
\~a
\vec a
\overline{abc}


Máme tu navíc ještě dvě speciální znaménka, která se umí přizpůsobit šířce:

Příkaz Výsledek
\widehat{xyz}
\widetilde{xyz}


Problémy s přebývající tečkou nad malými písmeny 'j' a 'i' lze vyřešit pomocí příkazu /imath následovně:

r"$\hat i\ \ \hat \imath$"
math-80117b16d3

Symboly

Malá řecká písmena

\alpha \beta \chi \delta \digamma
\epsilon \eta \gamma \iota \kappa
\lambda \mu \nu \omega \phi
\pi \psi \rho \sigma \tau
\theta \upsilon \varepsilon \varkappa \varphi
\varpi \varrho \varsigma \vartheta \xi
\zeta        


Velká řecká písmena

\Delta \Gamma \Lambda \Omega \Phi \Pi
\Psi \Sigma \Theta \Upsilon \Xi \mho
\nabla          


Hebrejština

\aleph \beth \daleth \gimel


Oddělovače

/ [ \Downarrow \Uparrow \Vert \backslash
\downarrow \langle \lceil \lfloor \llcorner \lrcorner
\rangle \rceil \rfloor \ulcorner \uparrow \urcorner
\vert \{ \| \} ] |


Velké symboly

\bigcap \bigcup \bigodot \bigoplus \bigotimes
\biguplus \bigvee \bigwedge \coprod \int
\oint \prod \sum    


Standartní názvy funkcí

\Pr \arccos \arcsin \arctan
\arg \cos \cosh \cot
\coth \csc \deg \det
\dim \exp \gcd \hom
\inf \ker \lg \lim
\liminf \limsup \ln \log
\max \min \sec \sin
\sinh \sup \tan \tanh


Binární operace a relační symboly

\Bumpeq \Cap \Cup
\Doteq \Join \Subset
\Supset \Vdash \Vvdash
\approx \approxeq \ast
\asymp \backepsilon \backsim
\backsimeq \barwedge \because
\between \bigcirc \bigtriangledown
\bigtriangleup \blacktriangleleft \blacktriangleright
\bot \bowtie \boxdot
\boxminus \boxplus \boxtimes
\bullet \bumpeq \cap
\cdot \circ \circeq
\coloneq \cong \cup
\curlyeqprec \curlyeqsucc \curlyvee
\curlywedge \dag \dashv
\ddag \diamond \div
\divideontimes \doteq \doteqdot
\dotplus \doublebarwedge \eqcirc
\eqcolon \eqsim \eqslantgtr
\eqslantless \equiv \fallingdotseq
\frown \geq \geqq
\geqslant \gg \ggg
\gnapprox \gneqq \gnsim
\gtrapprox \gtrdot \gtreqless
\gtreqqless \gtrless \gtrsim
\in \intercal \leftthreetimes
\leq \leqq \leqslant
\lessapprox \lessdot \lesseqgtr
\lesseqqgtr \lessgtr \lesssim
\ll \lll \lnapprox
\lneqq \lnsim \ltimes
\mid \models \mp
\nVDash \nVdash \napprox
\ncong \ne \neq
\neq \nequiv \ngeq
\ngtr \ni \nleq
\nless \nmid \notin
\nparallel \nprec \nsim
\nsubset \nsubseteq \nsucc
\nsupset \nsupseteq \ntriangleleft
\ntrianglelefteq \ntriangleright \ntrianglerighteq
\nvDash \nvdash \odot
\ominus \oplus \oslash
\otimes \parallel \perp
\pitchfork \pm \prec
\precapprox \preccurlyeq \preceq
\precnapprox \precnsim \precsim
\propto \rightthreetimes \risingdotseq
\rtimes \sim \simeq
\slash \smile \sqcap
\sqcup \sqsubset \sqsubset
\sqsubseteq \sqsupset \sqsupset
\sqsupseteq \star \subset
\subseteq \subseteqq \subsetneq
\subsetneqq \succ \succapprox
\succcurlyeq \succeq \succnapprox
\succnsim \succsim \supset
\supseteq \supseteqq \supsetneq
\supsetneqq \therefore \times
\top \triangleleft \trianglelefteq
\triangleq \triangleright \trianglerighteq
\uplus \vDash \varpropto
\vartriangleleft \vartriangleright \vdash
\vee \veebar \wedge
\wr    


Symboly šipek

\Downarrow \Leftarrow
\Leftrightarrow \Lleftarrow
\Longleftarrow \Longleftrightarrow
\Longrightarrow \Lsh
\Nearrow \Nwarrow
\Rightarrow \Rrightarrow
\Rsh \Searrow
\Swarrow \Uparrow
\Updownarrow \circlearrowleft
\circlearrowright \curvearrowleft
\curvearrowright \dashleftarrow
\dashrightarrow \downarrow
\downdownarrows \downharpoonleft
\downharpoonright \hookleftarrow
\hookrightarrow \leadsto
\leftarrow \leftarrowtail
\leftharpoondown \leftharpoonup
\leftleftarrows \leftrightarrow
\leftrightarrows \leftrightharpoons
\leftrightsquigarrow \leftsquigarrow
\longleftarrow \longleftrightarrow
\longmapsto \longrightarrow
\looparrowleft \looparrowright
\mapsto \multimap
\nLeftarrow \nLeftrightarrow
\nRightarrow \nearrow
\nleftarrow \nleftrightarrow
\nrightarrow \nwarrow
\rightarrow \rightarrowtail
\rightharpoondown \rightharpoonup
\rightleftarrows \rightleftarrows
\rightleftharpoons \rightleftharpoons
\rightrightarrows \rightrightarrows
\rightsquigarrow \searrow
\swarrow \to
\twoheadleftarrow \twoheadrightarrow
\uparrow \updownarrow
\updownarrow \upharpoonleft
\upharpoonright \upuparrows


Ostatní symboly

\$ \AA \Finv
\Game \Im \P
\Re \S \angle
\backprime \bigstar \blacksquare
\blacktriangle \blacktriangledown \cdots
\checkmark \circledR \circledS
\clubsuit \complement \copyright
\ddots \diamondsuit \ell
\emptyset \eth \exists
\flat \forall \hbar
\heartsuit \hslash \iiint
\iint \iint \imath
\infty \jmath \ldots
\measuredangle \natural \neg
\nexists \oiiint \partial
\prime \sharp \spadesuit
\sphericalangle \ss \triangledown
\varnothing \vartriangle \vdots
\wp \yen  


Může se stát, že narazíte na nepojmenovaný symbol (běžné u fontů STIX), můžete použít znaků Unicode:

ur'$\u23ce$'
Ukázka symbolů
import numpy as np
import matplotlib.pyplot as plt
t = np.arange(0.0, 2.0, 0.01)
s = np.sin(2*np.pi*t)

plt.plot(t,s)
plt.title(r'$\alpha_i > \beta_i$', fontsize=20)
plt.text(1, -0.6, r'$\sum_{i=0}^\infty x_i$', fontsize=20)
plt.text(0.6, 0.6, r'$\mathcal{A}\mathrm{sin}(2 \omega t)$',
         fontsize=20)
plt.xlabel('t (s)')
plt.ylabel('V (mV)')
plt.show()

Vykreslování textu LaTeX

Matplotlib umožňuje použít LaTeX pro práci s veškerým textem nákresu. Je dostupný s následujícími backendy:

Dá se aktivovat rc nastavením "text.usetex : True". Sice je manipulace s ním pomalejší, než se samotným Matplotlib, jedná se o velmi flexibilní řešení, protože máte k dispozici jiné balíčky LaTeX (balíčky fontu, matematické balíčky, atd.).

Podpora LaTeX vyžaduje funkční instalaci, dvipng (možná zahrnuto v instalaci LaTeX) a Ghostscript (doporučen je GPL Ghostscript 8.60 nebo starší). Spustitelné soubory požadavků by měli být umístěny v PATH (seznam adresářů prohledávaných pro nalezení spustitelných programů).

Existuje několik cest ke změně rc nastavení. Následující příklad se souborem matplotlibrc:

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

text.usetex        : true

Načte se první validní (existující) rodina fontů. Pokud nic nespicifikujete, bude použit výchozí font Computer Modern. Ostatní fonty pocházejí od Adobe. Times a Palatino mají svůj vlastní matematický font, zatímco ostatní Adobe serif fonty využívají fontu Computer Modern. Shlédněte dokumentaci pro PSNFSS pro více informací.

Pro práci s LaTeX a fontem Helvetica jako výchozím bez nutnosti editace matplotlibrc zkuste:

from matplotlib import rc # importování hodnot z matplotlibrc
rc('font',**{'family':'sans-serif','sans-serif':['Helvetica']})
## pokud se vám zalíbil Palatino nebo jakýkoliv jiný font
#rc('font',**{'family':'serif','serif':['Palatino']))
rc('text', usetex=True)

Obrázky

Zaprvé, potřebujete přístup k funkci imshow().

$ipython -pylab

Tento příkaz vám ji plně a přímo zpřístupní.

Můžete také zkusit následující postup, kterému budete zřejmě rozumět víc.

In [1]: import matplotlib.pyplot as plt
In [2]: import matplotlib.image as mpimg
In [3]: import numpy as np

Doporučuje se ovšem metoda první, při té lze vynechat "plt" a "mpimg" prefix.

Nativně, Matplotlib podporuje PNG obrázky a pro vykreslení obrázkových dat je tu Python Image Library.

Obrázek jako Numpy pole

Sledujte jakým způsobem pomocí funkce imshow() a pole Numpy vykreslit obrázek:

In [4]: img=mpimg.imread('lion.png') # načtení obrázku
In [5]: imgplot = plt.imshow(img) # vykreslení obrázku

Barevná schémata

Ty lze využít na vylepšení kontrastu a celkové vizualizace obrázkových dat. Měňte jimi obrázky na jednokanálové (R/G/B), stupně šedi, atd.

In [6]: lum_img = img[:,:,0] # tzv. single-channel (R/G/B)
In [7]: imgplot = mpimg.imshow(lum_img) # nulová hodnota modré složky
In [8]: imgplot.set_cmap('hot') # změna colormap/LUT (lookup table) na složku 'hot'
In [9]: imgplot.set_cmap('spectral') # změna colormap/LUT (lookup table) na složku 'spectral'
In [10]: plt.colorbar() # zobrazí paletu hodnoty barev
In [11]: plt.hist(lum_img.flatten(), 256, range=(0.0,1.0), fc='k', ec='k') # histogram
In [12]: imgplot.set_clim=(0.0,0.7) # přiblížení na určité hodnoty histogramu
Colormap spektrum s kódem na jeho vykreslení
import numpy as np
import matplotlib.pyplot as plt

a = np.linspace(0, 1, 256).reshape(1,-1)
a = np.vstack((a,a))

maps = sorted(m for m in plt.cm.datad if not m.endswith("_r"))
nmaps = len(maps) + 1

fig = plt.figure(figsize=(5,10))
fig.subplots_adjust(top=0.99, bottom=0.01, left=0.2, right=0.99)
for i,m in enumerate(maps):
    ax = plt.subplot(nmaps, 1, i+1)
    plt.axis("off")
    plt.imshow(a, aspect='auto', cmap=plt.get_cmap(m), origin='lower')
    pos = list(ax.get_position().bounds)
    fig.text(pos[0] - 0.01, pos[1], m, fontsize=10, horizontalalignment='right')

plt.show()

Interpolační schémata

Interpolace vypočítává jaká barva nebo hodnota pixelu by se na nějakém místě mohla nacházet. Interpolací se tedy rozumí způsob jakým se vyplní místo. Tento jev jste mohli zaznamenat například na čtverečkovaných (pixelated) obrázcích.

In [13]: import Image
In [14]: img = Image.open('lion.png')    # otevře obrázek jako objekt PIL
In [15]: rsize = img.resize((img.size[0]/10,img.size[1]/10)) # změnit velikost pomocí PIL
In [16]: rsizeArr = np.asarray(rsize)  # navrácení pole
In [17]: imgplot = mpimg.imshow(rsizeArr) # výchozí bilineární interpolace
In [18]: imgplot.set_interpolation('nearest') # vezme hodnotu nejbližšího pixelu
In [19]: imgplot.set_interpolation('bicubic') # chybějící místo rozmaže

Artist tutoriál

Existují tři vrsty v API Matplotlib. matplotlib.backend_bases. FigureCanvas je oblast, do které se zakresluje obrazec, matplotlib.backend_bases. Renderer je objekt, který ví jak se kreslí FigureCanvas a matplotlib.artist.Artist je objekt, který ví jak používat renderer na vykreslování na canvas. Artist ovládá všechny konstrukce, které vytvářejí obrazce, text a čáry. Typický uživatel stráví 95% času prací s ním.

Existují dva typy: primitiva a kontejnery. Primitiva reprezentují standartní grafický objekt, který my chceme nakreslit: Line2D, Rectangle, Text, AxesImage, atd. a kontejnery jsou místa kam se vkládají (Axis, Axes a Figure).

import matplotlib.pyplot as plt
fig = plt.figure()
ax = fig.add_subplot(2,1,1) # dvě řady, jeden sloupec, první graf

Třída Axes je z celého API Matplotlib nejpoužívanější. To protože Axes je vykreslovací plocha, do které se vkládají objekty. Také má mnoho speciálních pomocních metod (plot(), text(), hist(), imshow()) pro vytváření nejběžnějších grafických primitiv (Line2D, Text, Rectangle, Image). Tyto pomocné metody si berou vaše data (např.: pole Numpy a řetězce), vytváří instance Artist primitiv tak, jak je potřeba (např.: Line2D), přidávají je do příslušných kontejnerů a vykreslí. Pokud chcete vytvářet Axes do libovolného umístění, prostě užijte funkci metody add_axes(), která si bere seznam hodnot [doleva, dolů, šířka, výška] od 0 do 1:

fig2 = plt.figure()
ax2 = fig2.add_axes([0.15, 0.1, 0.7, 0.3])

Pokračujeme s naší ukázkou:

import numpy as np
t = np.arange(0.0, 1.0, 0.01)
s = np.sin(2*np.pi*t)
line, = ax.plot(t, s, color='blue', lw=2)

V tomto případě, ax je Axes instance vytvořená voláním fig.add_subplot, a když zavoláte ax.plot, tak vám vytvoří instanci Line2D a přidá ji do seznamu Axes.line. V interaktivním režimu (níže) si můžete prohlédnout, že seznam Axes.lines má délku jedna a obsahuje to samá, co vrací volání line, = ax.plot...

In [101]: ax.lines[0]
Out[101]: <matplotlib.lines.line2d instance="" at="" 0x19a95710="">

In [102]: line
Out[102]: <matplotlib.lines.line2d instance="" at="" 0x19a95710="">

Pokud provedete další volání ax.plot, poté se objekty dodatečně přidají na seznam. Pro jejich pozdější smazání jednoduše zavolejte:

del ax.lines[0]
ax.lines.remove(line)  # jednu nebo druhou z nich, nikoliv obě!

Axes rovněž nabízejí pomocnou metodu na konfiguraci a dekorování označení os x a y, označení a popisů os:

xtext = ax.set_xlabel('my xdata') # vrací instanci Text
ytext = ax.set_ylabel('my xdata')

Při volání ax.set_xlabel přeskakujete informaci instance Text z XAxis. Každá instance Axes obsahuje instanci XAxis a YAxis, které mají na starosti layout a vykreslování zmiňovaných věcí. Zkuste vytvořit obrazec níže.

import numpy as np
import matplotlib.pyplot as plt

fig = plt.figure()
fig.subplots_adjust(top=0.8)
ax1 = fig.add_subplot(211)
ax1.set_ylabel('volty')
ax1.set_title('sinusovka')

t = np.arange(0.0, 1.0, 0.01)
s = np.sin(2*np.pi*t)
line, = ax1.plot(t, s, color='blue', lw=2)

ax2 = fig.add_axes([0.15, 0.1, 0.7, 0.3])
n, bins, patches = ax2.hist(np.random.randn(1000), 50,
    facecolor='yellow', edgecolor='yellow')
ax2.set_xlabel('cas (s)')
plt.show()

Přizpůsobení objektů

Každý element obrazce je reprezentován díky Artist a každý z nich má rozsáhlý seznam vlastností díky kterým se dá konfigurovat.

Vlastnost Popis
alpha průhlednost - rozmezí 0-1
animated logická hodnota umožňující animované vykreslování
axes Artist osy, pravděpodobně None
clip_box ohraničovací rámeček
clip_on zjišťuje, zda je povolen rámeček
clip_path zjišťuje, k čemu je rámeček připnut
contains funkce pro otestování zda artist obsahuje výběr
figure instance obrazce Artist, pravděpodobně None
label textové označení
picker objekt Pythonu pro výběr objektu
transform transformace
visible logická hodnota ovlivňující zda by Artist měl být vykreslen
zorder číslo určující pořadí vykreslení


Ukázka stylu nastavení:

a = o.get_alpha() # getter (získává)
o.set_alpha(0.5*a) # setter (nastavuje)
o.set(alpha=0.5, zorder=2) # multi-setter

Interaktivní procházení Artist vlastností probíhá funkce matplotlib.artist.getp() (jendoduše getp() v Pylab módu) následovně:

In [149]: matplotlib.artist.getp(fig.patch)
    alpha = 1.0
    animated = False
    antialiased or aa = True
    axes = None
    clip_box = None
    clip_on = False
    clip_path = None
    contains = None
    edgecolor or ec = w
    facecolor or fc = 0.75
    figure = Figure(8.125x6.125)
    fill = 1
    hatch = None
    height = 1
    label =
    linewidth or lw = 1.0
    picker = None
    transform = <affine object="" at="" 0x134cca84="";>
    verts = ((0, 0), (0, 1), (1, 1), (1, 0))
    visible = True
    width = 1
    window_extent = <bbox object="" at="" 0x134acbcc="";>
    x = 0
    y = 0
    zorder = 1

Pro detailnější pochopení kontejnerů objektu, obrazce, os/y přejděte celý Artist tutorial.

Změna umístění podgrafu pomocí GridSpec

GridSpec
    Určuje geometrii soustavy kam se umístí podgraf. Je nutné ji nastavit počet řádků a sloupců.

SubplotSpec
    Určuje pozici podgrafu pro GridSpec.

subplot2grid
    Pomocná funkce podobná "pyplot.subplot", která ale uživá indexování od 0 a povoluje podgrafu zabírat více buněk.

Ukázka subplot2grid
ax = plt.subplot2grid((2,2),(0, 0)) # poskytnutí geometrie soustavy
ax = plt.subplot(2,2,1) # a její ekvivalentní zápis

# vytvoření podgrafu v rozsahu několika buněk
ax1 = plt.subplot2grid((3,3), (0,0), colspan=3)
ax2 = plt.subplot2grid((3,3), (1,0), colspan=2)
ax3 = plt.subplot2grid((3,3), (1, 2), rowspan=2)
ax4 = plt.subplot2grid((3,3), (2, 0))
ax5 = plt.subplot2grid((3,3), (2, 1))
Ukázka GridSpec a SubplotSpec
ax = plt.subplot2grid((2,2),(0, 0))
# je ekvivalentní s následujícím kódem
import matplotlib.gridspec as gridspec
gs = gridspec.GridSpec(2, 2)
ax = plt.subplot(gs[0, 0])

# vytvoření podgrafu v rozsahu několika buněk
gs = gridspec.GridSpec(3, 3)
ax1 = plt.subplot(gs[0, :])
ax2 = plt.subplot(gs[1,:-1])
ax3 = plt.subplot(gs[1:, -1])
ax4 = plt.subplot(gs[-1,0])
ax5 = plt.subplot(gs[-1,-2])
GridSpec layout
gs1 = gridspec.GridSpec(3, 3)
gs1.update(left=0.05, right=0.48, wspace=0.05)
ax1 = plt.subplot(gs1[:-1, :])
ax2 = plt.subplot(gs1[-1, :-1])
ax3 = plt.subplot(gs1[-1, -1])

gs2 = gridspec.GridSpec(3, 3)
gs2.update(left=0.55, right=0.98, hspace=0.05)
ax4 = plt.subplot(gs2[:, :-1])
ax5 = plt.subplot(gs2[:-1, -1])
ax6 = plt.subplot(gs2[-1, -1])
GridSpec pomocí SubplotSpec

Ve výchozím nastavení vytvoří GridSpec buňky stejně velké. Můžete však nastavit výšku a šířku řádkům a sloupcům v rámci jejich relativních poměrů.

gs0 = gridspec.GridSpec(1, 2)

gs00 = gridspec.GridSpecFromSubplotSpec(3, 3, subplot_spec=gs0[0])
gs01 = gridspec.GridSpecFromSubplotSpec(3, 3, subplot_spec=gs0[1])
GridSpec s různou velikostí buňky
gs = gridspec.GridSpec(2, 2, width_ratios=[1,2], height_ratios=[4,1])

ax1 = plt.subplot(gs[0])
ax2 = plt.subplot(gs[1])
ax3 = plt.subplot(gs[2])
ax4 = plt.subplot(gs[3])

Uspořádání layoutu

Jedná se o velice užitečnou věc. Funkce tight_layout() automaticky přizpůsobuje parametry podgrafu tak, že se bez problémů vlezou do oblasti vyobrazení. Jedná se ovšem také o experimentální funkci a může se stát, že nebude fungovat vždy. Všímá si rozsahů titulů a popisů os. Záleží ovšem také na vašem nastavení mezer a odstupů mezi grafem, popisem os a okraji. Jestliže je však nemáte dostatečně velké a nějaký prvek obrazce se zobrazuje nekorektně, vše co potřebujete je zavolat:

plt.tight_layout()
plt.tight_layout(pad=0.4, w_pad=0.5, h_pad=1.0) # nastavte odstup přesně 

# funguje i s GridSpec (nastavte například i parametr rect - (0,0,1,1) je výchozí)
gs1.tight_layout(fig, rect=[0.5, 0, 1, 1], h_pad=0.5)

Legenda

Funkce legend() umí vytvořit legendu velmi snadno:

p1, = plot([1,2,3])
p2, = plot([3,2,1])
p3, = plot([2,3,1])
legend([p2, p1], ["line 2", "line 1"])

Pozice legendy

Tu určíte pomocí argumentu loc řetězcem nebo zadáním příslušného čísla.

Řetězec Číslo
nahoře vpravo
1
nahoře vlevo
2
dole vlevo
3
dole vpravo
4
vpravo 5
levý střed
6
pravý střed
7
dolní střed
8
horní střed
9
střed 10

Jestli máte zájem na osamostatnění legendy do jejího vlastního bboxu, pokuste se o nápravu pomocí argumentu bbox_to_anchor, kterému předáte buď seznam čtyř nebo dvou (desetinných) čísel, čili seznamu (x, y, šířka, výška bboxu) nebo (x, y with width=height=0).

Zjistěte jak to ve skutečnosti vypadá včetně ukázky již zmíněného parametru loc:

from matplotlib.pyplot import *

subplot(211)
plot([1,2,3], label="test1")
plot([3,2,1], label="test2")
legend(bbox_to_anchor=(0., 1.02, 1., .102), loc=3,
       ncol=2, mode="expand", borderaxespad=0.)

subplot(223)
plot([1,2,3], label="test1")
plot([3,2,1], label="test2")
legend(bbox_to_anchor=(1.05, 1), loc=2, borderaxespad=0.)


show()

Multi-legenda

Může se stát, že budete potřebovat legendu rozdělit.

from matplotlib.pyplot import *

p1, = plot([1,2,3], label="test1")
p2, = plot([3,2,1], label="test2")

l1 = legend([p1], ["Label 1"], loc=1)
l2 = legend([p2], ["Label 2"], loc=4)
# přidá smazanou instanci, která se odstraní po druhém volání příkazu legend
gca().add_artist(l1)

show()

Legenda složitějších grafů

import matplotlib.pyplot as plt

ax = plt.subplot(311)

b1 = ax.bar([0, 1, 2], [0.2, 0.3, 0.1], width=0.4,
            label="test 1", align="center")

b2 = ax.bar([0.5, 1.5, 2.5], [0.3, 0.2, 0.2], color="red", width=0.4,
            label="test 2", align="center")

ax.legend()

ax = plt.subplot(312)

err1 = ax.errorbar([0, 1, 2], [2, 3, 1], xerr=0.4, fmt="s",
                   label="test 3")
err2 = ax.errorbar([0, 1, 2], [3, 2, 4], yerr=0.3, fmt="o",
                   label="test 4")
err3 = ax.errorbar([0, 1, 2], [1, 1, 3], xerr=0.4, yerr=0.3, fmt="^",
                   label="test 5")

ax.legend()

ax = plt.subplot(313)

ll = ax.stem([0.3, 1.5, 2.7], [1, 3.6, 2.7], label="test 6")

ax.legend()

plt.show()

Události

Matplotlib pracuje s 6 uživatelskými prostředími (wxpython, tkinter, qt, gtk, fltk a macosx) a aby podporovali funkce jako posun nebo přiblížení obrazce, je developerům nápomocno mít API pro interakci s obrazcem skrz stisktnutí tlačítka nebo pohyb myší, díky kterým není nutné opakovat specifickou část kódu napříč odlišnými uživatelskými prostředími.

Připojení událostí

Pro jejich příjem budete potřebovat napsat callback funkci a propojit ji s tzv. správcem událostí. Začněme s prvním příkladem, který tiskne umístění kliknutí myši, a která klávesa byla stisknuta:

fig = plt.figure()
ax = fig.add_subplot(111)
ax.plot(np.random.rand(10))

def onclick(event):
    print 'button=%d, x=%d, y=%d, xdata=%f, ydata=%f'%(
        event.button, event.x, event.y, event.xdata, event.ydata)

cid = fig.canvas.mpl_connect('button_press_event', onclick)

Zobrazí se vám prázdná obdelníková plocha.
Levý klik myší - button=1, x=375, y=209, xdata=5.352823, ydata=0.435417
Pravý klik myší - button=3, x=358, y=263, xdata=5.044355, ydata=0.547917

Zastavení události:

fig.canvas.mpl_disconnect(cid)

Přehled událostí, třídy instancí vám posílané, když nastane daná událost a její popis:

Event name Class and description
‘button_press_event’ MouseEvent - zmáčknuté tlačítko myši
‘button_release_event’ MouseEvent - uvolněné tlačítko myší
‘draw_event’ DrawEvent - kreslení
‘key_press_event’ KeyEvent - zmáčknuté tlačítko
‘key_release_event’ KeyEvent - uvolněné tlačítko
‘motion_notify_event’ MouseEvent - pohyb myši
‘pick_event’ PickEvent - canvas objekt vybrán
‘resize_event’ ResizeEvent - změna velikosti canvas obrazce
‘scroll_event’ MouseEvent - rolovací tlačítko myší roluje
‘figure_enter_event’ LocationEvent - vstup myši na nový obrazec
‘figure_leave_event’ LocationEvent - opuštění myši z obrazce
‘axes_enter_event’ LocationEvent - vstup myši na nové osy
‘axes_leave_event’ LocationEvent - opuštění myši z os

Atributy událostí

Všechny Matplotlib události dědí z matplotlib.backend_bases.Event základní třídy, které ukládají atributy:

name
    jméno události
canvas
    instance FigureCanvas generující událost
guiEvent
    GUI událost, která spustila událost Matplotlib

Nejběžnější události, které jsou denním chlebem při zpracovávání událostí jsou události stisku/uvolnění klávesy, kliknutí/uvolnění myši a události pohybu. KeyEvent a MouseEvent třídy, které těmito událostmi manipulují pochází z LocationEvent, který má následující atributy:

x
    pozice x - počet pixelů k levému okraji canvas
y
    pozice y - počet pixelů k dolnímu okraji canvas
inaxes
    instance Axes - jestli je myš nad osami
xdata
    x souřadnice myši
ydata
    x souřadnice myši

Podívejte se na příklad, kde každé kliknutí myši způsobí vytvoření úsečky:

from matplotlib import pyplot as plt

class LineBuilder:
    def __init__(self, line):
        self.line = line
        self.xs = list(line.get_xdata())
        self.ys = list(line.get_ydata())
        self.cid = line.figure.canvas.mpl_connect('button_press_event', self)

    def __call__(self, event):
        print 'click', event
        if event.inaxes!=self.line.axes: return
        self.xs.append(event.xdata)
        self.ys.append(event.ydata)
        self.line.set_data(self.xs, self.ys)
        self.line.figure.canvas.draw()

fig = plt.figure()
ax = fig.add_subplot(111)
ax.set_title('Kliknutim vytvorite usecku')
line, = ax.plot([0], [0])  # empty line
linebuilder = LineBuilder(line)

plt.show()

Pro více příkladů si přečtěte Event handling and picking.

Path tutoriál

Základ pro všechny objekty matplotlib.patch tvoří cesty (paths), které podporují standartní skladbu příkazů moveto, lineto, curveto pro jednoduché vykreslení a složení obrysů skládajících se z různých úseček a čar. Například pro vykreslení čtverce od (0,0) do (1,1) je třeba napsat:

import matplotlib.pyplot as plt
from matplotlib.path import Path
import matplotlib.patches as patches

verts = [
    (0., 0.), # doleva, dolů
    (0., 1.), # doleva, nahoru
    (1., 1.), # doprava, nahoru
    (1., 0.), # doprava, dolů
    (0., 0.), # vynecháno
    ]

codes = [Path.MOVETO,
         Path.LINETO,
         Path.LINETO,
         Path.LINETO,
         Path.CLOSEPOLY,
         ]

path = Path(verts, codes)

fig = plt.figure()
ax = fig.add_subplot(111)
patch = patches.PathPatch(path, facecolor='red', lw=2)
ax.add_patch(patch)
ax.set_xlim(-2,2)
ax.set_ylim(-2,2)
plt.show()

Kódy cest:

Kód Vrcholy Popis
STOP 1 (vynecháno) Značka na konci celé cesty (není nutná a je ignorována).
MOVETO 1 Přesunutí pera na daný vrchol.
LINETO 1 Nakreslení čáry z aktuální pozice na daný vrchol.
CURVE3 2 (1 kontrolní bod, 1 koncový bod) Nakreslení kvadratické Bézierovy křivky z aktuální pozice, v daném kontrolním, k danému koncového bodu.
CURVE4 3 (2 kontrolní body, 1 koncový bod) Nakreslení kubické Bézierovy křivky z aktuální pozice, v daném kontrolním, k danému koncovému bodu.
CLOSEPOLY 1 (samotný bod vynechán) Nakreslení úsečky do počátečního bodu aktuální křivky.


Příklad Bézierovy křivky (některé z komponentů cest vyžadují několik vrcholů ke specifikaci):

import matplotlib.pyplot as plt
from matplotlib.path import Path
import matplotlib.patches as patches

verts = [
    (0., 0.),  # P0
    (0.2, 1.), # P1
    (1., 0.8), # P2
    (0.8, 0.), # P3
    ]

codes = [Path.MOVETO,
         Path.CURVE4,
         Path.CURVE4,
         Path.CURVE4,
         ]

path = Path(verts, codes)

fig = plt.figure()
ax = fig.add_subplot(111)
patch = patches.PathPatch(path, facecolor='none', lw=2)
ax.add_patch(patch)

xs, ys = zip(*verts)
ax.plot(xs, ys, 'x--', lw=2, color='black', ms=10)

ax.text(-0.05, -0.05, 'P0')
ax.text(0.15, 1.05, 'P1')
ax.text(1.05, 0.85, 'P2')
ax.text(0.85, -0.05, 'P3')

ax.set_xlim(-0.1, 1.1)
ax.set_ylim(-0.1, 1.1)
plt.show()

Složené cesty

Všechna jednoduchá Matplotlib primitiva (obdélník, kruh, mnohoúhelník, atd.) jsou impelemtována v rámci jednoduchých cest. Vykreslení funkcí jako hist() a bar(), které vytvářejí mnoho z nich, mohou být impementovány mnohem efektivněji díky složeným cestám.

import numpy as np

import matplotlib.pyplot as plt
import matplotlib.patches as patches
import matplotlib.path as path

fig = plt.figure()
ax = fig.add_subplot(111)

# vytvoříme nějaká náhodná čísla pro výpočet histogramu
data = np.random.randn(1000)
n, bins = np.histogram(data, 100)

# dostaneme rohy obdélníku pro histogram
# vše z levých, dolních, atd. polí níže má len(n)
# n je pole čísel pro každý pruh histogramu
left = np.array(bins[:-1])
right = np.array(bins[1:])
bottom = np.zeros(len(left))
top = bottom + n
nrects = len(left)

# začínáme s konstruováním složené cesty
# pro každý obdelník je nutných 5 cest
# 1-MOVETO, 3-LINETO, 1-CLOSEPOLY
nverts = nrects*(1+3+1)
verts = np.zeros((nverts, 2))
codes = np.ones(nverts, int) * path.Path.LINETO
codes[0::5] = path.Path.MOVETO
codes[4::5] = path.Path.CLOSEPOLY
verts[0::5,0] = left
verts[0::5,1] = bottom
verts[1::5,0] = left
verts[1::5,1] = top
verts[2::5,0] = right
verts[2::5,1] = top
verts[3::5,0] = right
verts[3::5,1] = bottom

# vytvoření cesty, připojení ji k PathPatch a přidání na osy
barpath = path.Path(verts, codes)
patch = patches.PathPatch(barpath, facecolor='green', edgecolor='yellow', alpha=0.5)
ax.add_patch(patch)

ax.set_xlim(left[0], right[-1])
ax.set_ylim(bottom.min(), top.max())

plt.show()

Licence

Licenční ujednání pro Matplotlib si můžete přečíst v článku License agreement for Matplotlib.

Kredity

Matplotlib byl napsán Johnem Hunterem a zde si můžete prohlédnout seznam developerů nebo speciální věnování.

Toto je neoficiální volný překladem oficiálního uživatelského manuálu Matplotlib. Přeložil Petr Němeček.