matplotlib.pyplot.plot #

matplotlib.pyplot. plot ( * args , scalex = True , scaley = True , data = None , ** kwargs ) [fonte] #

Traccia y contro x come linee e/o marcatori.

Firme di chiamata:

plot([x], y, [fmt], *, data=None, **kwargs)
plot([x], y, [fmt], [x2], y2, [fmt2], ..., **kwargs)

Le coordinate dei punti o nodi lineari sono date da x , y .

Il parametro facoltativo fmt è un modo conveniente per definire la formattazione di base come colore, marcatore e stile di linea. È una notazione di stringa di scelta rapida descritta nella sezione Note di seguito.

>>> plot(x, y)        # plot x and y using default line style and color
>>> plot(x, y, 'bo')  # plot x and y using blue circle markers
>>> plot(y)           # plot y using x as index array 0..N-1
>>> plot(y, 'r+')     # ditto, but with red plusses

È possibile utilizzare Line2Dle proprietà come argomenti di parole chiave per un maggiore controllo sull'aspetto. Le proprietà della linea e fmt possono essere combinate. Le seguenti due chiamate producono risultati identici:

>>> plot(x, y, 'go--', linewidth=2, markersize=12)
>>> plot(x, y, color='green', marker='o', linestyle='dashed',
...      linewidth=2, markersize=12)

In caso di conflitto con fmt , gli argomenti delle parole chiave hanno la precedenza.

Tracciare dati etichettati

C'è un modo conveniente per tracciare oggetti con dati etichettati (cioè dati a cui si può accedere tramite index obj['y']). Invece di fornire i dati in x e y , puoi fornire l'oggetto nel parametro data e dare solo le etichette per x e y :

>>> plot('xlabel', 'ylabel', data=obj)

Tutti gli oggetti indicizzabili sono supportati. Questo potrebbe essere ad esempio un dict, un pandas.DataFrameo un array numpy strutturato.

Tracciare più insiemi di dati

Esistono vari modi per tracciare più insiemi di dati.

Il modo più semplice è chiamare plotpiù volte. Esempio:
```
>>> plot(x1, y1, 'bo')
>>> plot(x2, y2, 'go')
```
Se x e/o y sono array 2D, verrà disegnato un set di dati separato per ogni colonna. Se sia x che y sono 2D, devono avere la stessa forma. Se solo uno di essi è 2D con forma (N, m) l'altro deve avere lunghezza N e verrà utilizzato per ogni set di dati m.

Esempio:
```
>>> x = [1, 2, 3]
>>> y = np.array([[1, 2], [3, 4], [5, 6]])
>>> plot(x, y)
```
è equivalente a:
```
>>> for col in range(y.shape[1]):
...     plot(x, y[:, col])
```
Il terzo modo consiste nello specificare più insiemi di gruppi [x] , y , [fmt] :
```
>>> plot(x1, y1, 'g^', x2, y2, 'g-')
```
In questo caso, qualsiasi argomento di parola chiave aggiuntivo si applica a tutti i set di dati. Anche questa sintassi non può essere combinata con il parametro data .

Per impostazione predefinita, a ciascuna linea viene assegnato uno stile diverso specificato da un "ciclo di stile". I parametri di proprietà fmt e line sono necessari solo se si desidera deviazioni esplicite da questi valori predefiniti. In alternativa, puoi anche cambiare il ciclo di stile usando rcParams["axes.prop_cycle"](default: ).cycler('color', ['#1f77b4', '#ff7f0e', '#2ca02c', '#d62728', '#9467bd', '#8c564b', '#e377c2', '#7f7f7f', '#bcbd22', '#17becf'])

Parametri :

x, y tipo array o scalare

Le coordinate orizzontali/verticali dei punti dati. x i valori sono facoltativi e il valore predefinito è range(len(y)).

Comunemente, questi parametri sono array 1D.

Possono anche essere scalari o bidimensionali (in tal caso, le colonne rappresentano insiemi di dati separati).

Questi argomenti non possono essere passati come parole chiave.

fmt str, facoltativo

Una stringa di formato, ad esempio 'ro' per i cerchi rossi. Vedere la sezione Note per una descrizione completa delle stringhe di formato.

Le stringhe di formato sono solo un'abbreviazione per impostare rapidamente le proprietà di base della linea. Tutto questo e molto altro può anche essere controllato da argomenti di parole chiave.

Questo argomento non può essere passato come parola chiave.

oggetto indicizzabile dei dati , facoltativo

Un oggetto con dati etichettati. Se fornito, fornire i nomi delle etichette da tracciare in x e y .

Nota

Tecnicamente c'è una leggera ambiguità nelle chiamate in cui la seconda etichetta è un fmt valido . potrebbe essere o . In tali casi, viene scelta la prima interpretazione, ma viene emesso un avvertimento. È possibile sopprimere l'avviso aggiungendo una stringa di formato vuota .plot('n', 'o', data=obj)plt(x, y)plt(y, fmt)plot('n', 'o', '', data=obj)

Resi :

lista diLine2D: Un elenco di linee che rappresentano i dati tracciati.

Altri parametri :

scalex, scaley bool, predefinito: vero

Questi parametri determinano se i limiti della vista sono adattati ai limiti dei dati. I valori vengono trasmessi a autoscale_view.

**proprietà kwargs Line2D, facoltativo

I kwargs sono usati per specificare proprietà come un'etichetta di riga (per le legende automatiche), larghezza di riga, antialiasing, colore del contrassegno. Esempio:

>>> plot([1, 2, 3], [1, 2, 3], 'go-', label='line 1', linewidth=2)
>>> plot([1, 2, 3], [1, 4, 9], 'rs', label='line 2')

Se specifichi più righe con una chiamata di trama, i kwargs si applicano a tutte quelle righe. Nel caso in cui l'oggetto etichetta sia iterabile, ogni elemento viene utilizzato come etichette per ogni insieme di dati.

Ecco un elenco delle Line2Dproprietà disponibili:

Proprietà	Descrizione
`agg_filter`	una funzione di filtro, che accetta un array float (m, n, 3) e un valore dpi e restituisce un array (m, n, 3) e due offset dall'angolo in basso a sinistra dell'immagine
`alpha`	scalare o Nessuno
`animated`	bool
`antialiased`o aa	bool
`clip_box`	`Bbox`
`clip_on`	bool
`clip_path`	Patch o (Percorso, Trasforma) o Nessuno
`color`o c	colore
`dash_capstyle`	`CapStyle`o {'culo', 'sporgente', 'rotondo'}
`dash_joinstyle`	`JoinStyle`o {'mitre', 'round', 'bevel'}
`dashes`	sequenza di float (on/off inchiostro in punti) o (Nessuno, Nessuno)
`data`	(2, N) o due array 1D
`drawstyle`o ds	{'default', 'steps', 'steps-pre', 'steps-mid', 'steps-post'}, default: 'default'
`figure`	`Figure`
`fillstyle`	{'completo', 'sinistra', 'destra', 'basso', 'alto', 'nessuno'}
`gapcolor`	colore o Nessuno
`gid`	str
`in_layout`	bool
`label`	oggetto
`linestyle`o ls	{'-', '--', '-.', ':', '', (offset, on-off-seq), ...}
`linewidth`o lw	galleggiante
`marker`	stringa di stile marcatore, `Path`o`MarkerStyle`
`markeredgecolor`o mecc	colore
`markeredgewidth`o miagolare	galleggiante
`markerfacecolor`o mfc	colore
`markerfacecoloralt`o mfcalt	colore
`markersize`o ms	galleggiante
`markevery`	Nessuno o int o (int, int) o slice o lista[int] o float o (float, float) o lista[bool]
`mouseover`	bool
`path_effects`	`AbstractPathEffect`
`picker`	float o callable[[Artista, Evento], tuple[bool, dict]]
`pickradius`	sconosciuto
`rasterized`	bool
`sketch_params`	(scala: float, lunghezza: float, casualità: float)
`snap`	bool o Nessuno
`solid_capstyle`	`CapStyle`o {'culo', 'sporgente', 'rotondo'}
`solid_joinstyle`	`JoinStyle`o {'mitre', 'round', 'bevel'}
`transform`	sconosciuto
`url`	str
`visible`	bool
`xdata`	matrice 1D
`ydata`	matrice 1D
`zorder`	galleggiante

Guarda anche

scatter: Grafico a dispersione XY con marcatori di dimensioni e/o colori variabili (a volte chiamato anche grafico a bolle).

Appunti

Formato stringhe

Una stringa di formato è composta da una parte per colore, indicatore e linea:

fmt = '[marker][line][color]'

Ciascuno di essi è facoltativo. Se non fornito, viene utilizzato il valore del ciclo di stile. Eccezione: se lineviene fornito, ma no marker, i dati saranno una riga senza marcatori.

[color][marker][line]Sono supportate anche altre combinazioni come , ma si noti che la loro analisi potrebbe essere ambigua.

Marcatori

carattere	descrizione
`'.'`	segnapunti
`','`	indicatore di pixel
`'o'`	marcatore circolare
`'v'`	marcatore triangolo_giù
`'^'`	marcatore triangolo_su
`'<'`	marcatore triangolo_sinistra
`'>'`	marcatore triangolo_destra
`'1'`	marcatore tri_down
`'2'`	marcatore tri_up
`'3'`	marcatore tri_sinistra
`'4'`	marcatore tri_right
`'8'`	indicatore di ottagono
`'s'`	marcatore quadrato
`'p'`	indicatore del pentagono
`'P'`	marcatore più (pieno).
`'*'`	segnaposto a stella
`'h'`	marcatore esagonale1
`'H'`	marcatore esagonale2
`'+'`	più marcatore
`'x'`	x pennarello
`'X'`	x marcatore (pieno).
`'D'`	pennarello diamantato
`'d'`	pennarello thin_diamond
`'\|'`	marcatore vline
`'_'`	marcatore hline

Stili di linea

carattere	descrizione
`'-'`	stile di linea continua
`'--'`	stile linea tratteggiata
`'-.'`	stile linea tratteggiata
`':'`	stile linea tratteggiata

Esempi di stringhe di formato:

'b'    # blue markers with default shape
'or'   # red circles
'-g'   # green solid line
'--'   # dashed line with default color
'^k:'  # black triangle_up markers connected by a dotted line

Colori

Le abbreviazioni dei colori supportate sono i codici a lettera singola

carattere	colore
`'b'`	blu
`'g'`	verde
`'r'`	rosso
`'c'`	ciano
`'m'`	magenta
`'y'`	giallo
`'k'`	Nero
`'w'`	bianca

e i 'CN'colori che indicizzano nel ciclo di proprietà predefinito.

Se il colore è l'unica parte della stringa di formato, è possibile utilizzare in aggiunta qualsiasi matplotlib.colorsspecifica, ad esempio nomi completi ( 'green') o stringhe esadecimali ( '#008000').

Esempi che utilizzano `matplotlib.pyplot.plot`#

Tracciare valori mascherati e NaN

Scatter mascherato

Dimostrazione di scale

Dimostrazione del passo

Sottoclassi di figure personalizzate

Gestione di più figure in pyplot

Asse condiviso

Molteplici sottotrame

Controllo dello stile del testo e delle etichette utilizzando un dizionario

Posizionamento del titolo

Linee infinite

plot() stringa di formato

Pyplot testo matematico

Pyplot Semplice

Pyplot Tre

Pyplot Due sottotrame

Delfini

Foglio di stile Solarized Light

Afferrare il fotogramma

Rapporto sulle coordinate

Imposta e ottieni proprietà

transforms.offset_copy

Zorder Demo

Scala personalizzata

Posizionamento dei segni di spunta della data utilizzando le regole di ricorrenza

Etichette di spunta personalizzate rotanti

Responsabile degli strumenti

Esercitazione Pyplot

Personalizzazione di Matplotlib con fogli di stile e rcParams

Guida Rapida

Guida agli effetti del percorso

matplotlib.pyplot.plot #

Esempi che utilizzano matplotlib.pyplot.plot#

Esempi che utilizzano `matplotlib.pyplot.plot`#