hist package

class hist.BaseHist(arg: dict[str, Any], /, *, data: ndarray[tuple[Any, ...], dtype[Any]] | None = ..., metadata: Any = ..., label: str | None = ..., name: str | None = ...)

class hist.BaseHist(arg: Self | Histogram[S], /, *, data: ndarray[tuple[Any, ...], dtype[Any]] | None = ..., metadata: Any = ..., label: str | None = ..., name: str | None = ...)

class hist.BaseHist(*axes: AxisProtocol | tuple[int, float, float] | Storage | str, storage: S = ..., metadata: Any = ..., data: ndarray[tuple[Any, ...], dtype[Any]] | None = ..., label: str | None = ..., name: str | None = ...)

Bases: Histogram[S], Generic[S]

property T: Self

density() → ndarray[tuple[Any, ...], dtype[Any]]

Density NumPy array.

fill(*args: Any, weight: Any | None = None, sample: Any | None = None, threads: int | None = None, **kwargs: Any) → Self

Insert data into the histogram using names and indices, return a Hist object.

fill_flattened(*args: Any, weight: Any | None = None, sample: Any | None = None, threads: int | None = None, **kwargs: Any) → Self

classmethod from_columns(data: Mapping[str, Any], axes: Sequence[str | AxisProtocol], *, weight: str | None = None, storage: Storage = Double()) → Self

integrate(name: int | str, i_or_list: list[str | int], j: InnerIndexing | None = None) → Self

integrate(name: int | str, i_or_list: InnerIndexing | None = None, j: InnerIndexing | None = None) → IntHists | int

integrate(name: int | str, i_or_list: InnerIndexing | None = None, j: InnerIndexing | None = None) → FloatHists | float

integrate(name: int | str, i_or_list: InnerIndexing | None = None, j: InnerIndexing | None = None) → ListHists | list[float]

integrate(name: int | str, i_or_list: InnerIndexing | None = None, j: InnerIndexing | None = None) → WeightHists | WeightedSum

integrate(name: int | str, i_or_list: InnerIndexing | None = None, j: InnerIndexing | None = None) → MeanHists | Mean

integrate(name: int | str, i_or_list: InnerIndexing | None = None, j: InnerIndexing | None = None) → WeightedMeanHists | WeightedMean

integrate(name: int | str, i_or_list: InnerIndexing | None = None, j: InnerIndexing | None = None) → Self | int | float | list[float] | Any

plot(*args: Any, overlay: str | None = None, **kwargs: Any) → Hist1DArtists | Hist2DArtists

Plot method for BaseHist object.

plot1d(*, ax: matplotlib.axes.Axes | None = None, overlay: str | int | None = None, legend: bool = True, **kwargs: Any) → Hist1DArtists

Plot1d method for BaseHist object.

Parameters:

• ax (matplotlib.axes.Axes, optional) – Axes to plot on. If None, uses current axes or creates new ones.

• overlay (str or int, optional) – Name or index of the axis to overlay. If None, automatically selects the first discrete axis for multi-dimensional histograms.

• legend (bool, default True) – Whether to automatically add a legend when plotting stacked categories. The legend title is set from the axis label if available.

• **kwargs (Any) – Additional keyword arguments passed to the underlying plot functions.

Returns:

The matplotlib artists created by the plot.

Return type:

Hist1DArtists

plot2d(*, ax: matplotlib.axes.Axes | None = None, **kwargs: Any) → Hist2DArtists

Plot2d method for BaseHist object.

plot2d_full(*, ax_dict: dict[str, matplotlib.axes.Axes] | None = None, **kwargs: Any) → tuple[Hist2DArtists, Hist1DArtists, Hist1DArtists]

Plot2d_full method for BaseHist object.

Pass a dict of axes to ax_dict, otherwise, the current figure will be used.

plot_pie(*, ax: matplotlib.axes.Axes | None = None, **kwargs: Any) → Any

plot_pull(func: Callable[[np.typing.NDArray[Any]], np.typing.NDArray[Any]] | str, *, ax_dict: dict[str, matplotlib.axes.Axes] | None = None, **kwargs: Any) → tuple[FitResultArtists, RatiolikeArtists]

plot_pull method for BaseHist object.

Return a tuple of artists following a structure of (main_ax_artists, subplot_ax_artists)

plot_ratio(other: hist.BaseHist[Any] | Callable[[np.typing.NDArray[Any]], np.typing.NDArray[Any]] | str, *, ax_dict: dict[str, matplotlib.axes.Axes] | None = None, **kwargs: Any) → tuple[MainAxisArtists, RatiolikeArtists]

plot_ratio method for BaseHist object.

Return a tuple of artists following a structure of (main_ax_artists, subplot_ax_artists)

profile(axis: int | str) → Self

Returns a profile (Mean/WeightedMean) histogram from a normal histogram with N-1 axes. The axis given is profiled over and removed from the final histogram.

project(*args: int | str) → Self

Projection of axis idx.

show(**kwargs: Any) → Any

Pretty print histograms to the console.

sort(axis: int | str, key: Callable[[int], SupportsLessThan] | Callable[[str], SupportsLessThan] | None = None, reverse: bool = False) → Self

Sort a categorical axis.

stack(axis: int | str) → Stack[S]

Returns a stack from a normal histogram axes.

class hist.Hist(arg: dict[str, Any], /, *, data: ndarray[tuple[Any, ...], dtype[Any]] | None = ..., metadata: Any = ..., label: str | None = ..., name: str | None = ...)

class hist.Hist(arg: Self | Histogram[S], /, *, data: ndarray[tuple[Any, ...], dtype[Any]] | None = ..., metadata: Any = ..., label: str | None = ..., name: str | None = ...)

class hist.Hist(*axes: AxisProtocol | tuple[int, float, float] | Storage | str, storage: S = ..., metadata: Any = ..., data: ndarray[tuple[Any, ...], dtype[Any]] | None = ..., label: str | None = ..., name: str | None = ...)

Bases: BaseHist[S], Generic[S]

class hist.NamedHist(*args: Any, **kwargs: Any)

Bases: BaseHist[S], Generic[S]

fill(weight: Any | None = None, sample: Any | None = None, threads: int | None = None, **kwargs: Any) → Self

Insert data into the histogram using names and return a NamedHist object. NamedHist could only be filled by names.

fill_flattened(obj: Any = None, *, weight: Any | None = None, sample: Any | None = None, threads: int | None = None, **kwargs: Any) → Self

project(*args: int | str) → Self

Projection of axis idx.

class hist.Stack(*args: BaseHist[S])

Bases: Generic[S]

property axes: NamedAxesTuple

classmethod from_dict(d: Mapping[str, BaseHist[S]]) → Self

Create a Stack from a dictionary of histograms. The keys of the dictionary are used as names.

classmethod from_iter(iterable: Iterable[BaseHist[S]]) → Self

Create a Stack from an iterable of histograms.

plot(*, ax: mpl.axes.Axes | None = None, **kwargs: Any) → Any

Plot method for Stack object.

project(*args: int | str) → Self

Project the Stack onto a new axes.

show(**kwargs: object) → Any

Pretty print the stacked histograms to the console.

class hist.loc(value: str | float, offset: int = 0)

Bases: Locator

value

class hist.rebin(factor_or_axis: int | PlottableAxis | None = None, /, *, factor: int | None = None, groups: Sequence[int] | None = None, edges: Sequence[int | float] | None = None, axis: PlottableAxis | None = None)

Bases: object

axis

axis_mapping(axis: PlottableAxis) → tuple[Sequence[int], PlottableAxis | None]

edges

factor

group_mapping(axis: PlottableAxis) → Sequence[int]

groups

hist.sum(iterable, /, start=0)

Return the sum of a ‘start’ value (default: 0) plus an iterable of numbers

When the iterable is empty, return the start value. This function is intended specifically for use with numeric values and may reject non-numeric types.

Subpackages

• hist.axis package
  • ArrayTuple
    • ArrayTuple.broadcast()
  • AxesMixin
    • AxesMixin.label
    • AxesMixin.name
  • AxisProtocol
    • AxisProtocol.label
    • AxisProtocol.name
  • Boolean
  • IntCategory
  • Integer
  • NamedAxesTuple
    • NamedAxesTuple.label
    • NamedAxesTuple.name
  • Regular
  • StrCategory
  • Variable
  • Submodules
    • hist.axis.transform module
      • AxisTransform
      • Function
      • Pow
• hist.dask package
  • Hist
  • NamedHist
  • Submodules
    • hist.dask.hist module
      • Hist
    • hist.dask.namedhist module
      • NamedHist

Submodules

• hist.accumulators module
  • Mean
    • Mean.count
    • Mean.fill()
    • Mean.value
    • Mean.variance
  • Sum
    • Sum.fill()
    • Sum.value
  • WeightedMean
    • WeightedMean.fill()
    • WeightedMean.sum_of_weights
    • WeightedMean.sum_of_weights_squared
    • WeightedMean.value
    • WeightedMean.variance
  • WeightedSum
    • WeightedSum.fill()
    • WeightedSum.value
    • WeightedSum.variance
• hist.axestuple module
  • ArrayTuple
    • ArrayTuple.broadcast()
  • AxesTuple
    • AxesTuple.bin()
    • AxesTuple.centers
    • AxesTuple.edges
    • AxesTuple.extent
    • AxesTuple.index()
    • AxesTuple.size
    • AxesTuple.value()
    • AxesTuple.widths
  • NamedAxesTuple
    • NamedAxesTuple.label
    • NamedAxesTuple.name
• hist.basehist module
  • BaseHist
    • BaseHist.T
    • BaseHist.density()
    • BaseHist.fill()
    • BaseHist.fill_flattened()
    • BaseHist.from_columns()
    • BaseHist.integrate()
    • BaseHist.plot()
    • BaseHist.plot1d()
    • BaseHist.plot2d()
    • BaseHist.plot2d_full()
    • BaseHist.plot_pie()
    • BaseHist.plot_pull()
    • BaseHist.plot_ratio()
    • BaseHist.profile()
    • BaseHist.project()
    • BaseHist.show()
    • BaseHist.sort()
    • BaseHist.stack()
  • SupportsLessThan
  • process_mistaken_quick_construct()
• hist.classichist module
  • main()
• hist.hist module
  • Hist
• hist.intervals module
  • clopper_pearson_interval()
  • poisson_interval()
  • ratio_uncertainty()
• hist.namedhist module
  • NamedHist
    • NamedHist.fill()
    • NamedHist.fill_flattened()
    • NamedHist.project()
• hist.numpy module
  • histogram()
  • histogram2d()
  • histogramdd()
• hist.plot module
  • hist2dplot()
  • histplot()
  • plot2d_full()
  • plot_pie()
  • plot_pull_array()
  • plot_ratio_array()
  • plot_stack()
• hist.quick_construct module
  • ConstructProxy
    • ConstructProxy.AtomicInt64()
    • ConstructProxy.Double()
    • ConstructProxy.Int64()
    • ConstructProxy.Mean()
    • ConstructProxy.MultiCell()
    • ConstructProxy.Unlimited()
    • ConstructProxy.Weight()
    • ConstructProxy.WeightedMean()
  • MetaConstructor
    • MetaConstructor.new
  • QuickConstruct
    • QuickConstruct.Bool()
    • QuickConstruct.Boolean()
    • QuickConstruct.Func()
    • QuickConstruct.Int()
    • QuickConstruct.IntCat()
    • QuickConstruct.IntCategory()
    • QuickConstruct.Integer()
    • QuickConstruct.Log()
    • QuickConstruct.Pow()
    • QuickConstruct.Reg()
    • QuickConstruct.Regular()
    • QuickConstruct.Sqrt()
    • QuickConstruct.StrCat()
    • QuickConstruct.StrCategory()
    • QuickConstruct.Var()
    • QuickConstruct.Variable()
    • QuickConstruct.axes
    • QuickConstruct.hist_class
• hist.stack module
  • Stack
    • Stack.axes
    • Stack.from_dict()
    • Stack.from_iter()
    • Stack.plot()
    • Stack.project()
    • Stack.show()
• hist.storage module
  • AtomicInt64
    • AtomicInt64.accumulator
  • Double
    • Double.accumulator
  • Int64
    • Int64.accumulator
  • Mean
    • Mean.accumulator
  • MultiCell
    • MultiCell.accumulator
  • Storage
    • Storage.accumulator
  • Unlimited
    • Unlimited.accumulator
  • Weight
    • Weight.accumulator
  • WeightedMean
    • WeightedMean.accumulator
• hist.svgplots module
  • html_hist()
  • make_ax_text()
  • make_text()
  • svg_hist_1d()
  • svg_hist_1d_c()
  • svg_hist_2d()
• hist.svgutils module
  • SupportsStr
  • XML
    • XML.name
    • XML.start
  • circle
  • div
  • ellipse
  • g
  • html
  • line
  • p
  • polygon
  • polyline
  • rect
    • rect.pad()
  • svg
  • text
• hist.tag module
  • Locator
    • Locator.NAME
    • Locator.offset
  • at
    • at.value
  • loc
    • loc.value
  • rebin
    • rebin.axis
    • rebin.axis_mapping()
    • rebin.edges
    • rebin.factor
    • rebin.group_mapping()
    • rebin.groups
  • sum()
• hist.version module