Drukowanie za pomocą matplotlib

Pytania do rozmowy kwalifikacyjnej na temat projektowania systemu może być tak nieograniczona, że ​​trudno jest określić właściwy sposób przygotowania. Teraz jestem w stanie złamać rundy projektowe Amazon, Microsoft i Adobe po zakupie ta książka. Codziennie poprawiaj jeden pytanie projektowe i obiecuję, że możesz złamać cały projekt.

Co to jest matplotlib?

Python język programowania i jego rozszerzenie matematyczne NumPy posiada własną bibliotekę do kreślenia o nazwie matplotlib. Zapewnia zorientowane obiektowo API, za pomocą którego można osadzać wykresy w aplikacjach przy użyciu zestawów narzędzi GUI ogólnego przeznaczenia, takich jak Tkinter, wxPython, Qt lub GTK+. John D. Hunter pierwotnie napisał Matplotlib, ale zmarł w 2012 roku w wieku 44 lat. Od tego czasu jest to aktywna społeczność programistów utrzymywana przez wielu innych.

Jak już powiedziano: „Obraz jest wart więcej niż tysiąc słów” Python ma tę bibliotekę wizualizacji o nazwie matplotlib do dwuwymiarowego kreślenia tablic. Dzięki matplotlib możesz wykonać kilka wykresów, takich jak linia, słupek, punkt rozproszenia, histogram itp.

Matplotlib to gigantyczna biblioteka, a uzyskanie właściwej fabuły odbywa się metodą prób i błędów. Generowanie podstawowego wykresu jest łatwiejsze, ale posiadanie polecenia nad biblioteką matplotlib jest dość trudne.

Ten samouczek jest przeznaczony dla początkujących i średniozaawansowanych z mieszanką teorii i przykładów. Zamierzamy omówić:

  • pyplot i pylab
  • kluczowe koncepcje matplotlib
  • plt.podwykresy()
  • wizualizacja tablic za pomocą matplotlib
  • kreślenie z pandami i matplotlib

Dlaczego matplotlib jest mylący:

Mimo że istnieje ogromna dokumentacja dotycząca biblioteki matplotlib, nauka matplotlib nie jest łatwa ze względu na następujące czynniki:

  • Jak już wspomniano, sama biblioteka jest dość duża z dużymi liniami kodu.
  • matplotlib ma kilka interfejsów i może być zintegrowany z kilkoma różnymi backendami. Backend zajmuje się nie tylko wewnętrzną strukturą wykresów, ale także sposobem ich wyświetlania.
  • Mimo że dokumentacja jest obszerna, jest nieaktualna. Starsze przykłady wciąż krążą wokół rozwijającej się biblioteki.

Nauczmy się podstawowych koncepcji projektu matplotlib, zanim przejdziemy do przykładów.

Pylab:

Pyplot to moduł Matplotlib, za pomocą którego można uzyskać interfejs podobny do MATLAB. Jedną z zalet MATLAB jest to, że ma on zastosowanie na całym świecie. W przeciwieństwie do Pythona import nie jest intensywnie używany w MATLAB. Większość funkcji MATLAB jest łatwo dostępna dla użytkowników na najwyższym poziomie.

Pylab łączy klasy i funkcje z matplotlib i NumPy. Osoby, które znają MATLAB, mogą łatwo dostosować się do Pylab, ponieważ nie ma dużej potrzeby korzystania z importu. Po prostu dodając tę ​​jedną linię

from pylab import *

dawni użytkownicy MATLAB mogą wywoływać plot() lub array(), tak jak robią to w MATLAB.

Ale użytkownicy Pythona wiedzą, że używanie import * to zła praktyka kodowania, ponieważ importuje wszystko do przestrzeni nazw. W rezultacie możesz niepotrzebnie nadpisać wbudowane elementy Pythona. I trudno jest znaleźć błędy. Dlatego MATLAB radzi, aby nie używać importu * w swoich samouczkach. Zamiast importować, musimy użyć %matplotlib do integracji IPythona.

Kod źródłowy Pylab faktycznie maskuje wiele potencjalnie konfliktowych importów. Na przykład, używając python –pylab w terminalu lub linii poleceńlub %pylab faktycznie wywołuje 'from pylab import *' pod maską.

Mimo że matplotlib wyraźnie odradza używanie pylab, nadal istnieje. Zamiast pylab możemy użyć pyplot. pyplot sprawia, że ​​matplotlib działa jak MATLAB z kolekcją funkcji stylu poleceń.

import matplotlib.pyplot as plt

Hierarchia matplotlib:

Hierarchia obiektów jest jedną z głównych koncepcji matplotlib. Jeśli przeszedłeś już przez jakiś inny samouczek matplotlib, być może natknąłeś się na ten wiersz:

plt.plot([1, 2, 3])

Wygląda jak prosty jednowierszowy kod, ale w rzeczywistości jest to drabina zagnieżdżonych obiektów Pythona. Pod każdym wykresem istnieje struktura obiektów matplotlib.

W ramach projektu Postać obiekt jest kontenerem najwyższego poziomu dla wszystkich elementów wykresu, zawiera wiele osi. Osie różnią się od osi. ten Osie to obiekt, który przechowuje kilka obiektów, takich jak XAxis, Yaxis i możemy tworzyć wykresy, wywołując jego metody.

Na całym obrazie Figure jest pojemnikiem przypominającym pudełko, który zawiera wiele osi. W hierarchii znajdują się mniejsze obiekty, takie jak znaczniki, pojedyncze wiersze, legendy i pola tekstowe znajdujące się poniżej osi. Od znaczników i etykiet każdy element wykresu jest obiektem Pythona.

szpilka

Powyższy wykres jest przykładem hierarchii matplotlib. Nie musisz się martwić, jeśli nie znasz tego, omówimy w naszym samouczku.

Jeśli nie masz zainstalowanego programu matplotlib, zainstaluj go za pomocą poniższego polecenia w samouczku.

pip install matplotlib

Wykonaj poniższy kod:

import matplotlib.pyplot as plt

figure,_=plt.subplots()
print(type(figure))

plt.subplots() zwraca krotkę zawierającą 2 obiekty. Na razie zajmijmy się tylko pierwszym obiektem krotki, czyli obiektem Figure. Możemy pobrać pierwszy tik osi y pierwszego obiektu osi, drążąc hierarchię figury.

import matplotlib.pyplot as plt

figure,_=plt.subplots()

# To get first axes of figure
first_axes=figure.axes[0]

# yaxis of first axes object
yaxis=first_axes.yaxis

# first tick of the yaxis of the first axes
first_tick_of_yaxis=yaxis.get_major_ticks()[0]
print(type(first_tick_of_yaxis))

Rysunek zawiera listę osi. A każda oś ma oś x i oś y, każda z nich ma wiele głównych kleszczy.

import matplotlib.pyplot as plt

figure,_=plt.subplots()

axes=figure.axes
print(type(axes))

matplotlib nazywa to anatomią figur, a nie hierarchią figur. Anatomię ilustracji postaci można znaleźć w oficjalnej dokumentacji matplotlib.

szpilka

Podejście stanowe vs bezstanowe:

Przed przejściem do wizualizacji musimy zrozumieć różnicę między interfejsem stanowym lub stanowym a bezstanowym lub zorientowanym obiektowo.

Możemy zaimportować moduł pyplot z matplotlib i nazwać go jako plt, wpisując poniższe polecenie.

import matplotlib.pyplot as plt

Wszystkie funkcje pyplot, na przykład plt.plot() odnoszą się do istniejącej figury i osi. Jeśli nie ma istniejących figur i osi, tworzy nową. Jak wspomniano w dokumentacji matplotlib, „[Z pyplot] proste funkcje są używane do dodawania elementów wykresu (linii, obrazów, tekstu itp.) do bieżących osi w bieżącym rysunku”.

Różnica między interfejsem stanowym a bezstanowym:

Użytkownicy ex-MATLAB twierdzą, że „plt.plot() jest interfejsem opartym na stanie/maszynie stanu, który niejawnie śledzi bieżącą liczbę.

  • plt.plot() i inne funkcje pyplot na najwyższym poziomie tworzą stanowe wywołania interfejsu. Ponieważ plt.plot() odnosi się do bieżącej figury i osi, w danym momencie można manipulować tylko jedną figurą i osiami. Nie musimy nawet się do tego wyraźnie odwoływać.
  • W podejściu zorientowanym obiektowo wykonujemy powyższe operacje jawnie i bierzemy odwołania do obiektów do zmiennych i możemy bezpośrednio modyfikować obiekty bazowe, wywołując metody obiektu Axes. Obiekt Axes reprezentuje sam wykres.

Oto przykład interfejsu stanowego:

pl.wykres()

Otrzymujemy aktualny obiekt Axes. gca() jest tutaj funkcją, a nie metodą:

topór=plt.gca()

W pyplot większość funkcji istnieje również jako metody klasy matplotlib.axes.Axes. Wywołanie metody gca na bieżącym rysunku:

gcf().gca(**kwargs)

# matplotlib/pyplot.py
>>> def plot(*args, **kwargs):
...     ax = plt.gca()
...     return ax.plot(*args, **kwargs)

>>> def gca(**kwargs):
...     """This returns current axes of the current figure."""
...     return plt.gcf().gca(**kwargs)

plt.plot() zwraca bieżące osie bieżącej figury. Interfejs stanowy niejawnie śledzi wykres, do którego chce się odwoływać.

W podejściu zorientowanym obiektowo istnieją odpowiednie metody pobierające i ustawiające.

Przykłady: ax.set_title(), ax.get_title()

Wywołanie plt.title() i gca().set_title() robi to samo. Oto, co robi:

  • gca() zwraca bieżące osie
  • Metoda ustawiająca set_title() ustawia tytuł dla aktualnych osi. Tutaj nie wspominamy wyraźnie o żadnym obiekcie osi.

Podobnie wszystkie funkcje najwyższego poziomu plt.grid(), plt.ylabels(), plt.legend() itd. mają tę samą strukturę przypisywania bieżących osi za pomocą gca() i wywołują metodę bieżących osi.

plt.podwykres():

Gdy wykres staje się złożony, przydatne jest podejście obiektowe. Zróbmy trochę kreślenia, aby zrozumieć te koncepcje.

Dzięki plt.subplots() w zorientowanej obiektowo możemy stworzyć figurę z pojedynczymi osiami. To jedyne miejsce, w którym tworzymy Figurę i Osie z podejściem obiektowym.

figure,axes=plt.subplots()

plt.sublpots() zwraca pojedynczą figurę i pojedynczy obiekt AxesSubplot.

>>> type(figure)
<class 'matplotlib.figure.Figure'>
>>> type(axes)
<class 'matplotlib.axes._subplots.AxesSubplot'>

Wywołując plt.subplots() nie wywołujemy żadnych argumentów. ten domyślne argumenty są nrows=1 i ncols=1.

Ponieważ mamy obiekt AxesSubplot, możemy wywołać jego metody podobnie do sposobu, w jaki wywołujemy funkcje pyplot.

Skumulowany wykres warstwowy:

Zobaczmy przykład skumulowanego wykresu warstwowego trzech szeregów czasowych.

Zainstaluj numpy, wpisując poniższe polecenie w swoim terminalu.

pip install numpy

Poniższy kod generuje wykres:

import matplotlib.pyplot as plt
import numpy as np

range=np.arange(50)
rnd=np.random.randint(0,10,size=(3,range.size))
years=1950+range
figure,axes=plt.subplots(figsize=(5,3))
axes.stackplot(years, range + rnd, labels=['Eastasia', 'Eurasia', 'Oceania'])
axes.set_title('Combined debt growth over time')
axes.legend(loc='upper left')
axes.set_ylabel('Total debt')
axes.set_xlim(xmin=years[0],xmax=years[-1])
figure.tight_layout()

plt.show()

Oto wyjaśnienie powyższego kodu:

  • np.arange(50): tworzy tablicę 1d o długości 50 z numery w zakresie od 1 do 50
  • random.randint(): funkcja zwraca tablicę o określonym kształcie i wypełnia losowymi liczbami z zakresu od niskiego do wysokiego. Najwyższy limit jest wyłączny. W naszym przypadku najniższy limit to 0, najwyższy limit to 10, a rozmiar to (3, range.size). Wynikiem będzie tablica 2d o rozmiarze 3*50, wypełniona liczbami od 0 do 10 (nie włącznie).
  • Możemy określić szerokość i wysokość figury w jednostce „cale” za pomocą atrybutu figsize, .
  • stackplot(): Wyświetla każdą część załadowaną na siebie i jak każda część przyczynia się do tworzenia kompletnej figury. Wyświetla różne sekcje danych i działa jak wykres kołowy. Ma etykietę x, etykietę y i tytuł, w którym możemy przedstawiać różne części różnymi kolorami.
  • set_title(): Jak sama nazwa wskazuje, ta metoda ustawiająca ustawia tytuł.
  • legend(): Obszar opisujący elementy wykresu.
  • set_ylabel: ustawia etykietę na osi y.
  • set_xlim: Ustawia limit dla osi X.
  • tight_layout: Aby nadać określone wypełnienie, automatycznie dostosowuje parametry podwykresu.
  • show: Pokazuje wykres.

Tutaj zapisujemy obiekt Axes do zmiennych osi. Wywołując bezpośrednio metody osi, tworzymy skumulowany wykres warstwowy, ustawiamy tytuł, dodajemy legendę i ustawiamy etykietę osi y. To jest przykład podejścia obiektowego. Oto wykres wyjściowy:

szpilka

Wykres punktowy i histogram:

Zobaczmy jeszcze jeden przykład, w którym figura zawiera wiele osi. Tutaj wykreślimy dwie skorelowane tablice wylosowane z dyskretnego rozkładu jednolitego.

import matplotlib.pyplot as plt
import numpy as np

x = np.random.randint(low=1, high=11, size=50)
y = x + np.random.randint(1, 5, size=x.size)
data = np.column_stack((x, y))
figure, (axes1, axes2) = plt.subplots(nrows=1, ncols=2,figsize=(8, 4))
axes1.scatter(x=x, y=y, marker='o', c='r', edgecolor='b')
axes1.set_title('Scatter: x versus y')
axes1.set_xlabel('x')
axes1.set_ylabel('y')
axes2.hist(data, bins=np.arange(data.min(), data.max()),label=('x', 'y'))
axes2.legend(loc=(0.65, 0.8))
axes2.set_title('Frequencies of x and y')
axes2.yaxis.tick_right()
plt.show()

Kod wykonuje następujące czynności:

  • Tutaj przekazujemy parametry do funkcji subplots(), która tworzy podwykresy z pojedynczą figurą i dwiema osiami.
  • Zmienne x i y są jednowymiarową tablicą wypełnioną liczbami losowymi.
  • Osobno zajmujemy się obiektami osi. Tworzymy wykres punktowy z jednym obiektem osi i histogram z obiektem z innymi osiami.
  • tick_right(): Funkcja pokazuje punkty na osi koordynowanej po prawej stronie.

Przy podejściu stanowym trudno jest indywidualnie obsługiwać obie osie obiektów. Wykres wyjściowy będzie wyglądał następująco:

szpilka

Argument znacznika w funkcji scatter określa styl znacznika, który można zmienić zgodnie z własnymi życzeniami. Tutaj zmieniamy znacznik na 's'.

axes1.scatter(x=x, y=y, marker='s', c='r', edgecolor='b')

A umieszczenie tekstu wewnątrz znaku dolara zmienia tekst na kursywę.

axes1.set_title('$Scatter$: x versus y')
axes2.set_title('$Frequencies$ $of$ x $and$ y')

Wynik będzie wyglądał następująco:szpilka

Jak widzieliśmy wcześniej, z samej figury możemy uzyskać obiekty osi.

>>> figure.axes[0] is axes1 and figure.axes[1] is axes2
True

m*n siatka osi obiektów:

Możemy również stworzyć figurę zawierającą obiekty osi w siatce m*n. Jednym z takich przykładów jest:

figure,axes=plt.subplots(nrows=2,ncols=2,figsize=(7,7))

Jeśli zaznaczysz typ osi, nie będzie to już AxesSubplot. Zamiast tego jest to tablica numpy.

>>> type(axes)
<class 'numpy.ndarray'>
>>> axes
array([[<matplotlib.axes._subplots.AxesSubplot object at 0x0A4BBAD0>,
        <matplotlib.axes._subplots.AxesSubplot object at 0x0D44F2B0>],
       [<matplotlib.axes._subplots.AxesSubplot object at 0x0D4700F0>,
        <matplotlib.axes._subplots.AxesSubplot object at 0x0D4952D0>]],
      dtype=object)
>>> axes.shape
(2, 2)

Tablica Numpy jest tylko kontenerem. Na każdym z obiektów Axes musimy wywołać metody kreślenia. Możemy użyć metody flatten, aby przekonwertować tablicę 2d Numpy na 4 obiekty do typu AxesSubplot.

axes1,axes2,axes3,axes4=axes.flatten()
>>> type(axes1)
<class 'matplotlib.axes._subplots.AxesSubplot'>

Jest na to alternatywny sposób. Ale poprzednia metoda jest elastyczna.

((axes1,axes2),(axes3,axes4))=axes

>>> type(axes1)
<class 'matplotlib.axes._subplots.AxesSubplot'>

Zaawansowane funkcje pobocznych:

Rozumiem, aby zrozumieć niektóre zaawansowane funkcje wykresu podrzędnego na przykładzie. Korzystając z bibliotek Pythona io, urllib i tarfile, wydobędziemy dane makroekonomiczne dotyczące Kalifornii ze skompresowanego archiwum tar.

import numpy as np
from io import BytesIO
import tarfile
from urllib.request import urlopen

url='https://www.dcc.fc.up.pt/~ltorgo/Regression/cal_housing.tgz'
bytesio_object=BytesIO(urlopen(url).read())
file_path = 'CaliforniaHousing/cal_housing.data'
with tarfile.open(mode='r', fileobj=bytesio_object) as archive:
    housing = np.loadtxt(archive.extractfile(file_path), delimiter=',')

Zmienna url to adres URL zawierający dane. Powyższy kod wyodrębnia dane z pliku i przechowuje je w tablicy numpy.

Ustalmy wartość przeciętnego domu, populację obszaru i wiek przeciętnego domu.

>>> avarage_home_value=housing[:,-1]
>>> population,age=housing[:,[4,7]].T

Atrybut T to nic innego jak transpozycja tablicy.

Napiszmy jeszcze jedną funkcję, która działa jak „tytuł na wykresie”, umieszczając pole tekstowe wewnątrz wykresu.

def add_titlebox(axes, text):
    axes.text(.55,.8,text,horizontalalignment='center',
        transform=ax.transAxes,bbox=dict(facecolor='white',alpha=0.6),
        fontsize=12.5)
    return axes

Możemy dostosować poboczny wykres za pomocą modułu gridspec matplotlib. Możemy wchodzić w interakcję z modułem gridspec za pomocą funkcji subplot2grid() pyplot. Oto układ, który zamierzamy stworzyć:

szpilka

Tutaj mamy siatkę 3*2. ax1 przyczynia się do podwójnej wysokości i szerokości ax2 i ax3.

szpilka

Do funkcji subplot2grid() przekazujemy (wiersz, kolumnę) jako argument, który jest niczym innym jak położeniem obiektu osi w siatce.

gridsize=(3,2)
figure=plt.figure(figsize=(12,8))
ax1=plt.subplot2grid(gridsize, (0, 0), colspan=2, rowspan=2)
ax2 = plt.subplot2grid(gridsize, (2, 0))
ax3 = plt.subplot2grid(gridsize, (2, 1))

Teraz możemy zająć się każdą z osi indywidualnie.

ax1.set_title("Value of home as a function of age of home and population of area")
scatter=ax1.scatter(x=age,y=population,c=average_home_value,cmap='RdYlGn')
plt.colorbar(scatter,ax=ax1,format='$%d')
ax1.set_yscale('log')
ax2.hist(age,bins='auto')
ax3.hist(population,bins='auto',log=True)

add_titlebox(ax2,'Histogram: Age of the home')
add_titlebox(ax3, 'Histogram: Area population (log scl.)')

plt.show()

Metoda colorbar dodaje pasek kolorów do wykresu. Jest wywoływany bezpośrednio na figurze, a nie na osiach. Pobiera ax1.scatter() jako argument, który odwzorowuje średnią wartość home na ColorMap.

szpilka

Gdy poruszamy się w górę iw dół wzdłuż osi y, nie ma dużego zróżnicowania w kolorze. Wskazuje, że wiek domu odgrywa większą rolę w określaniu wartości domu.

Figura:

Figurkę można stworzyć na dwa sposoby:

  • Wywołanie plt.subplots()
  • Wywołanie plt.figure() tworzy figurę bez osi. Nie jest to często używane.

Za każdym razem, gdy możemy stworzyć nową figurę, matplotlib przechowuje ją w pamięci. Widzieliśmy koncepcję bieżącej figury i bieżących osi w interfejsie stanowym. Bieżąca figura i aktualne osie są ostatnio utworzone i możemy użyć wbudowanej funkcji id(), aby pokazać adres obiektu w pamięci.

>>> figure1,axes1=plt.subplots()

>>> id(figure1)
162617520
>>> id(plt.gcf())
162617520

>>> figure2,axes2=plt.subplots()

>>> id(figure2)
203096944
#plt.gcf() returns the current figure
>>> id(figure2)==id(plt.gcf())
True
>>>

Ostatnia utworzona figura to figura bieżąca. Obie te figury znajdują się w pamięci, a do każdej uzyskuje się dostęp za pomocą odpowiedniego identyfikatora. Podobnie jak w stylu MATLAB, indeksowanie zaczyna się od 1.

>>> plt.get_fignums()
[1, 2]

Mapując plt.figure() do każdego z fignum, możemy uzyskać liczbę.

>>> def get_all_figures():
...     return [plt.figure(i) for i in plt.get_fignums()]

>>> get_all_figures()

[<Figure size 640x480 with 1 Axes>,
 <Figure size 640x480 with 1 Axes>]

Kiedy otwierasz wiele plików, aby uniknąć błędu pamięci, musisz je zamknąć. plt.close() zamyka bieżącą figurę, plt.close('all') zamyka wszystko, a plt.close(num) zamyka figurę o numerze num.

>>> plt.close('all')
>>> get_all_figures()
[]

imshow() i matshow():

Metody imshow() i matshow() są najczęściej używanymi metodami. matshow() jest opakowaniem wokół imshow(). Są one używane do wizualizacji tablicy numerycznej jako kolorowej siatki.

Za pomocą Numpy stwórzmy dwie określone siatki.

array1=np.diag(np.arange(2,12))[::-1]
array1[np.diag_indices_from(array1[::-1])] = np.arange(2, 12)
array2 = np.arange(array1.size).reshape(array1.shape)

Teraz możemy przedstawić tablice array1 i array2 w formacie obrazu. Korzystając ze słownika, wyłączymy tiki i wszystkie etykiety osi, a wynik przekażemy do metody tick_params().

sides=('top','bottom','left','right')
nolabels={s: False for s in sides}
nolabels.update({'label%s' %s:False for s in sides})
>>> nolabels
{'top': False, 'bottom': False, 'left': False, 'right': False, 'labeltop': False, 'labelbottom': False, 
'labelleft': False, 'labelright': False}

Teraz wyłączymy siatkę za pomocą menedżer kontekstu a na każdej osi nazwiemy matshow(). Na koniec umieścimy pasek kolorów, który jest technicznie nowymi osiami na figurze.

from mpl_toolkits.axes_grid1.axes_divider import make_axes_locatable

with plt.rc_context(rc={'axes.grid': False}):
    figure, (axes1, axes2) = plt.subplots(1, 2, figsize=(8, 4))
    axes1.matshow(array1)
    image=axes2.matshow(array2,cmap='RdYlGn_r')
    for axes in (axes1,axes2):
        axes.tick_params(axis='both',which='both',**nolabels)
    for i,j in zip(*array1.nonzero()):
        axes1.text(j,i,array1[i,j],color='white',ha='center',va='center')

    divider=make_axes_locatable(axes2)
    cax=divider.append_axes("right",size='5%',pad=0)
    plt.colorbar(image,cax=cax,ax=[axes1,axes2])
    figure.suptitle('Heatmaps with "Axes matshow"',fontsize=16)

    plt.show()

szpilka

Rysowanie z pandami:

Pandy przychodzą ze swoimi metodami kreślenia. Metody kreślenia pandy są otokami wokół istniejących wywołań matplotlib.

Na przykład metoda plot(), której używamy Pandy w serii i DataFrame, jest tylko opakowaniem wokół plt.plot(). Jak już wiemy, że plt.plot() niejawnie odnosi się do aktualnej figury i osi, Pandy postępują dokładnie tak samo. Innym przykładem jest to, że jeśli indeks Pandas Dataframe zawiera datę, wówczas Pandas wywołuje metodę gcf().autofmt_xdate() w celu pobrania bieżącej figury, a także automatycznie formatuje oś X.

Zrozummy te koncepcje z kilkoma przykładami kodu. Najpierw zainstaluj pandy za pomocą pip.

pip install pandas
import matplotlib.pyplot as plt
import pandas as pd
import numpy as np

series=pd.Series(np.arange(5),index=list('abcde'))
axes=series.plot()

Teraz stworzyliśmy AxesSubplot w Pandas. Sprawdź typ, aby się tego upewnić.

>>> type(axes)
<class 'matplotlib.axes._subplots.AxesSubplot'>
>>> id(axes)==id(plt.gca())
True

Pandy z matplotlib:

Lepiej jest zrozumieć wewnętrzną architekturę, mieszając metody kreślenia Pand z wywołaniami matplotlib. Zobaczymy przykład, w którym wykreślamy średnia ruchoma szeroko obserwowanych finansowych szeregów czasowych. Stworzymy serię Pand i wywołamy na tym metodę plot(). Następnie dostosujemy go za pomocą jego osi utworzonych przez plt.gca() w matplotlib.

import matplotlib.transforms as mtransforms

url = 'https://fred.stlouisfed.org/graph/fredgraph.csv?id=VIXCLS'
vix = pd.read_csv(url, index_col=0, parse_dates=True, na_values='.',infer_datetime_format=True,squeeze=True).dropna()
mean_average=vix.rolling('90d').mean()
state = pd.cut(mean_average, bins=[-np.inf, 14, 18, 24, np.inf],labels=range(4))
cmap = plt.get_cmap('RdYlGn_r')
mean_average.plot(color='black', linewidth=1.5, marker='', figsize=(8, 4),label='VIX 90d MA')
axes = plt.gca()
axes.set_xlabel('')
axes.set_ylabel('90d moving average: CBOE VIX')
axes.set_title('Volatility Regime State')
axes.grid(False)
axes.legend(loc='upper center')
axes.set_xlim(xmin=mean_average.index[0], xmax=mean_average.index[-1])
trans = mtransforms.blended_transform_factory(axes.transData, axes.transAxes)
for i, color in enumerate(cmap([0.2, 0.4, 0.6, 0.8])):
    axes.fill_between(mean_average.index, 0, 1, where=state==i,facecolor=color, transform=trans)
axes.axhline(vix.mean(), linestyle='dashed', color='xkcd:dark grey',alpha=0.6, label='Full-period mean', marker='')

plt.show()

Wyjaśnienie kodu:

  • Czytanie Plik CSV ze wspomnianego adresu URL i konwertując go do serii Pandas, zapisując do zmiennej vix.
  • Funkcja rolling() jest używana głównie w danych szeregów czasowych. Możemy wykonać obliczenia okna toczącego się za pomocą funkcji Rolling(). W bardzo prostych słowach wykonujemy operacje matematyczne na oknie o rozmiarze n na raz. Rozmiar okna oznacza liczbę obserwacji użytych do obliczenia statystyki. Jeśli okno ma rozmiar n oznacza n kolejnych wartości na raz. Tutaj wykonujemy średnią operację na vix nad każdym oknem.
  • Funkcja wycinania służy do segmentacji i sortowania danych na segmenty.
  • Wywołujemy funkcję plot() i wyraźnie odwołujemy się do bieżących osi.
  • Drugi blok kodu tworzy bloki wypełnione kolorami, które odpowiadają każdemu segmentowi state.cmap([0.2,04,0.6,0.8]). Oznacza to, że „Dla kolorów na 20., 40., 60. i 80. percentylu ' wzdłuż widma ColorMaps, zdobądź nam sekwencję RGBA”. Aby zmapować każdy kolor RGBA z powrotem do stanu, używana jest funkcja enumerate().

szpilka

Tematy dodatkowe:

Konfiguracja i stylizacja:

W matplotlib możesz skonfigurować styl na różnych wykresach w jednolity sposób. Można to zrobić na dwa sposoby.

  • Dostosuj plik matplotlibrc.
  • Zmień parametry konfiguracyjne ze skryptu .py lub interaktywnie.

Plik matplotlibrc to plik tekstowy zawierający dostosowane ustawienia użytkownika i można go zapamiętywać między sesjami.

Możemy również interaktywnie zmieniać parametry konfiguracyjne, jak wspomniano wcześniej. Ponieważ zaimportowaliśmy matplotlib.pyplot jako plt, możemy uzyskać dostęp do rcParams.

>>> [attr for attr in dir(plt) if attr.startswith('rc')]
['rc', 'rcParams', 'rcParamsDefault', 'rcParamsOrig', 'rc_context', 'rcdefaults', 'rcsetup']

Obiekty zaczynające się od „rc” są środkiem interakcji z ustawieniami i stylami wydruku.

plt.rcdefaults() zastępuje parametry rc wartościami domyślnymi wymienionymi w reParamsDefault. Zastępuje to wszystko, co dostosowałeś.

plt.rc() służy do interaktywnego ustawiania parametrów.

plt.rcParams() jest obiektem podobnym do słownika. Dostosowane zmiany w plikach matplotlibrc są tutaj odzwierciedlone. Możesz również zmienić ten obiekt bezpośrednio.

# changing rc
plt.rc('lines', linewidth=2, color='g')

#Changing rcParams
plt.rcParams['lines.linewidth'] = 2
plt.rcParams['lines.color'] = 'r'

Aby wyświetlić dostępne style:

>>> plt.style.available
['Solarize_Light2', '_classic_test_patch', 'bmh', 'classic', 'dark_background', 'fast', 'fivethirtyeight', 'ggplot',
 'grayscale', 'seaborn', 'seaborn-bright', 'seaborn-colorblind', 'seaborn-dark', 'seaborn-dark-palette', 'seaborn-darkgrid',
 'seaborn-deep', 'seaborn-muted', 'seaborn-notebook', 'seaborn-paper', 'seaborn-pastel', 'seaborn-poster', 'seaborn-talk', 
 'seaborn-ticks', 'seaborn-white', 'seaborn-whitegrid', 'tableau-colorblind10']

Aby ustawić styl:

plt.style.use('fivethirtyeight')

Tryb interaktywny:

Jak już wspomniano, matplotlib współdziała z różnymi backendami. Backend wykonuje główną pracę przy renderowaniu wykresu. Niektóre backendy są interaktywne i wskazują użytkownika za każdym razem, gdy zostaną zmienione.

Możesz sprawdzić jego status poprzez:

>>> plt.rcParams['interactive']
False

Możesz to również włączyć/wyłączyć:

>>> plt.ion()
>>> plt.rcParams['interactive']
True
>>> plt.ioff()
>>> plt.rcParams['interactive']
False

Zastosowanie tego trybu interaktywnego to:

  • Użyliśmy plt.show() do wyświetlenia wykresu. Nie potrzebujemy tej funkcji, jeśli tryb interaktywny jest włączony i będzie aktualizowany w miarę odwoływania się do nich.
  • plt.show() jest potrzebne do wyświetlenia wykresu, jeśli tryb interaktywny jest wyłączony, a plt.draw() do aktualizacji wykresu.

Przykład z włączonym trybem interaktywnym:

plt.ion()
array = np.arange(-4, 5)
array1 = array ** 2
array2 = 10 / (array ** 2 + 1)
figure, axes = plt.subplots()
axes.plot(array, array1, 'rx', array, array2, 'b+', linestyle='solid')
axes.fill_between(array, array1, array2, where=array2>array1, interpolate=True,color='green', alpha=0.3)
legend = axes.legend(['array1', 'array2'], loc='upper center', shadow=True)
legend.get_frame().set_facecolor('#ffb19a')

szpilka

Wywiady dotyczące projektowania systemu pękania
Translate »