Tamanho da bandeja no Matplotlib (histograma)

Estou usando o matplotlib para fazer um histograma.

Existe alguma maneira de definir manualmente o tamanho dos compartimentos em oposição ao número de compartimentos?

Na verdade, é bem fácil: em vez do número de posições, você pode fornecer uma lista com os limites da posição. Eles também podem ser distribuídos de forma desigual:

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

Se você apenas deseja distribuí-los igualmente, basta usar o range:

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

Adicionado à resposta original

A linha acima funciona apenas para datanúmeros inteiros. Como o macrocosme aponta, para carros alegóricos você pode usar:

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

Para os compartimentos N, as bordas da bandeja são especificadas pela lista de valores N + 1, onde o primeiro N fornece as bordas inferiores da bandeja e o +1 fornece a borda superior da última bandeja.

Código:

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)

Observe que o linspace produz uma matriz de min_edge a max_edge dividida em valores N + 1 ou N bins

Eu acho que a maneira mais fácil seria calcular o mínimo e o máximo dos dados que você possui e depois calcular L = max - min. Em seguida, você divide Lpela largura desejada da lixeira (suponho que isso seja o que você quer dizer com tamanho da lixeira) e usa o teto desse valor como o número de lixeiras.

Eu gosto que as coisas aconteçam automaticamente e que as caixas caiam em valores "agradáveis". O seguinte parece funcionar muito bem.

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()

O resultado possui compartimentos em intervalos agradáveis ​​de tamanho de compartimento.

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

Eu uso quantis para fazer caixas uniformes e ajustadas à amostra:

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')

Eu tive o mesmo problema do OP (acho!), Mas não consegui fazê-lo funcionar da maneira especificada pela Lastalda. Não sei se interpretei a pergunta corretamente, mas encontrei outra solução (provavelmente é uma maneira muito ruim de fazer isso).

Foi assim que eu fiz:

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

O que cria isso:

Portanto, o primeiro parâmetro basicamente 'inicializa' a lixeira - estou criando especificamente um número que está entre o intervalo que eu defini no parâmetro bins.

Para demonstrar isso, observe a matriz no primeiro parâmetro ([1,11,21,31,41]) e a matriz 'bin' no segundo parâmetro ([0,10,20,30,40,50]) :

• O número 1 (da primeira matriz) fica entre 0 e 10 (na matriz 'bandejas')
• O número 11 (da primeira matriz) fica entre 11 e 20 (na matriz 'caixas')
• O número 21 (da primeira matriz) fica entre 21 e 30 (na matriz 'bandejas'), etc.

Então, eu estou usando o parâmetro 'pesos' para definir o tamanho de cada caixa. Esta é a matriz usada para o parâmetro de pesos: [10,1,40,33,6].

Portanto, o compartimento de 0 a 10 recebe o valor 10, o compartimento de 11 a 20 recebe o valor de 1, o compartimento de 21 a 30 recebe o valor de 40 etc.

Para um histograma com valores x inteiros, acabei usando

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

O deslocamento de 0,5 centraliza os compartimentos nos valores do eixo x. A plt.xtickschamada adiciona uma marca para cada número inteiro.