Dimensione del contenitore in Matplotlib (istogramma)

Sto usando matplotlib per creare un istogramma.

Esiste un modo per impostare manualmente la dimensione dei contenitori anziché il numero di contenitori?

In realtà, è abbastanza semplice: al posto del numero di bin è possibile fornire un elenco con i limiti del cestino. Possono anche essere distribuiti in modo diseguale:

plt.hist(data, bins=[0, 10, 20, 30, 40, 50, 100])

Se li vuoi distribuire equamente, puoi semplicemente usare range:

plt.hist(data, bins=range(min(data), max(data) + binwidth, binwidth))

Aggiunto alla risposta originale

La riga sopra funziona solo per datanumeri interi. Come sottolinea il macrocosmo , per i float puoi usare:

import numpy as np
plt.hist(data, bins=np.arange(min(data), max(data) + binwidth, binwidth))

Per i bin N, i bordi del contenitore sono specificati dall'elenco dei valori N + 1 in cui il primo N indica i bordi del contenitore inferiore e il +1 indica il bordo superiore dell'ultimo cestino.

Codice:

from numpy import np; from pylab import *

bin_size = 0.1; min_edge = 0; max_edge = 2.5
N = (max_edge-min_edge)/bin_size; Nplus1 = N + 1
bin_list = np.linspace(min_edge, max_edge, Nplus1)

Nota che linspace produce un array da min_edge a max_edge suddiviso in valori N + 1 o N bin

Immagino che il modo più semplice sarebbe calcolare il minimo e il massimo dei dati che hai, quindi calcolare L = max - min. Quindi dividi Lper la larghezza del cestino desiderata (suppongo che questo sia ciò che intendi per dimensione del cestino) e usi il soffitto di questo valore come numero di bin.

Mi piace che le cose accadano automaticamente e che i cassonetti cadano su valori "carini". Quanto segue sembra funzionare abbastanza bene.

import numpy as np
import numpy.random as random
import matplotlib.pyplot as plt
def compute_histogram_bins(data, desired_bin_size):
    min_val = np.min(data)
    max_val = np.max(data)
    min_boundary = -1.0 * (min_val % desired_bin_size - min_val)
    max_boundary = max_val - max_val % desired_bin_size + desired_bin_size
    n_bins = int((max_boundary - min_boundary) / desired_bin_size) + 1
    bins = np.linspace(min_boundary, max_boundary, n_bins)
    return bins

if __name__ == '__main__':
    data = np.random.random_sample(100) * 123.34 - 67.23
    bins = compute_histogram_bins(data, 10.0)
    print(bins)
    plt.hist(data, bins=bins)
    plt.xlabel('Value')
    plt.ylabel('Counts')
    plt.title('Compute Bins Example')
    plt.grid(True)
    plt.show()

Il risultato ha bin su intervalli piacevoli delle dimensioni del cestino.

[-70. -60. -50. -40. -30. -20. -10.   0.  10.  20.  30.  40.  50.  60.]

Uso i quantili per uniformare i contenitori e adattarli al campione:

bins=df['Generosity'].quantile([0,.05,0.1,0.15,0.20,0.25,0.3,0.35,0.40,0.45,0.5,0.55,0.6,0.65,0.70,0.75,0.80,0.85,0.90,0.95,1]).to_list()

plt.hist(df['Generosity'], bins=bins, normed=True, alpha=0.5, histtype='stepfilled', color='steelblue', edgecolor='none')

Ho avuto lo stesso problema di OP (penso!), Ma non sono riuscito a farlo funzionare nel modo specificato da Lastalda. Non so se ho interpretato correttamente la domanda, ma ho trovato un'altra soluzione (probabilmente è comunque un modo molto brutto di farlo).

Questo è stato il modo in cui l'ho fatto:

plt.hist([1,11,21,31,41], bins=[0,10,20,30,40,50], weights=[10,1,40,33,6]);

Che crea questo:

Quindi il primo parametro fondamentalmente "inizializza" il cestino - Sto specificatamente creando un numero compreso nell'intervallo impostato nel parametro bin.

Per dimostrarlo, guarda l'array nel primo parametro ([1,11,21,31,41]) e l'array 'bin' nel secondo parametro ([0,10,20,30,40,50]) :

• Il numero 1 (dal primo array) è compreso tra 0 e 10 (nell'array 'bins')
• Il numero 11 (dal primo array) è compreso tra 11 e 20 (nell'array 'bin')
• Il numero 21 (dal primo array) è compreso tra 21 e 30 (nell'array 'bin'), ecc.

Quindi sto usando il parametro 'pesi' per definire la dimensione di ogni cestino. Questa è la matrice utilizzata per il parametro weights: [10,1,40,33,6].

Quindi al cestino da 0 a 10 viene assegnato il valore 10, al cestino da 11 a 20 viene assegnato il valore 1, al cestino da 21 a 30 viene assegnato il valore 40, ecc.

Per un istogramma con valori x interi ho finito per usare

plt.hist(data, np.arange(min(data)-0.5, max(data)+0.5))
plt.xticks(range(min(data), max(data)))

L'offset di 0,5 centra i bin sui valori dell'asse x. La plt.xtickschiamata aggiunge un segno di spunta per ogni numero intero.