MhUSrSSKJr SSKJrJrJrJr SSKr SSK J r J r J r SSKJrJrJrJrJrJr SSKJrJrJr SSKJr SS KJr SS KJrJrJ r SSK!J"s J#r$ SS K%J&r& \(aSS K'J(r(J)r) SSS jjr*SSSjjr+SSjr,SSSjjr-SSjr.S Sjr/S!S"Sjjr0S#Sjr1S$Sjr2S%Sjr3S&Sjr4g)'z, Quantilization functions and related stuff ) annotations) TYPE_CHECKINGAnyCallableLiteralN) Timedelta Timestamplib)ensure_platform_int is_bool_dtype is_integer is_list_likeis_numeric_dtype is_scalar)CategoricalDtypeDatetimeTZDtypeExtensionDtype) ABCSeries)isna) CategoricalIndex IntervalIndex) dtype_to_unit)DtypeObjIntervalLeftRightc tUn [U5n [U 5up[R"U5(d [ XU5nOY[ U[ 5(aUR(a [S5eO'[U5nUR(d [S5e[U UUUUUUUS9up[XXI5$)a Bin values into discrete intervals. Use `cut` when you need to segment and sort data values into bins. This function is also useful for going from a continuous variable to a categorical variable. For example, `cut` could convert ages to groups of age ranges. Supports binning into an equal number of bins, or a pre-specified array of bins. Parameters ---------- x : array-like The input array to be binned. Must be 1-dimensional. bins : int, sequence of scalars, or IntervalIndex The criteria to bin by. * int : Defines the number of equal-width bins in the range of `x`. The range of `x` is extended by .1% on each side to include the minimum and maximum values of `x`. * sequence of scalars : Defines the bin edges allowing for non-uniform width. No extension of the range of `x` is done. * IntervalIndex : Defines the exact bins to be used. Note that IntervalIndex for `bins` must be non-overlapping. right : bool, default True Indicates whether `bins` includes the rightmost edge or not. If ``right == True`` (the default), then the `bins` ``[1, 2, 3, 4]`` indicate (1,2], (2,3], (3,4]. This argument is ignored when `bins` is an IntervalIndex. labels : array or False, default None Specifies the labels for the returned bins. Must be the same length as the resulting bins. If False, returns only integer indicators of the bins. This affects the type of the output container (see below). This argument is ignored when `bins` is an IntervalIndex. If True, raises an error. When `ordered=False`, labels must be provided. retbins : bool, default False Whether to return the bins or not. Useful when bins is provided as a scalar. precision : int, default 3 The precision at which to store and display the bins labels. include_lowest : bool, default False Whether the first interval should be left-inclusive or not. duplicates : {default 'raise', 'drop'}, optional If bin edges are not unique, raise ValueError or drop non-uniques. ordered : bool, default True Whether the labels are ordered or not. Applies to returned types Categorical and Series (with Categorical dtype). If True, the resulting categorical will be ordered. If False, the resulting categorical will be unordered (labels must be provided). Returns ------- out : Categorical, Series, or ndarray An array-like object representing the respective bin for each value of `x`. The type depends on the value of `labels`. * None (default) : returns a Series for Series `x` or a Categorical for all other inputs. The values stored within are Interval dtype. * sequence of scalars : returns a Series for Series `x` or a Categorical for all other inputs. The values stored within are whatever the type in the sequence is. * False : returns an ndarray of integers. bins : numpy.ndarray or IntervalIndex. The computed or specified bins. Only returned when `retbins=True`. For scalar or sequence `bins`, this is an ndarray with the computed bins. If set `duplicates=drop`, `bins` will drop non-unique bin. For an IntervalIndex `bins`, this is equal to `bins`. See Also -------- qcut : Discretize variable into equal-sized buckets based on rank or based on sample quantiles. Categorical : Array type for storing data that come from a fixed set of values. Series : One-dimensional array with axis labels (including time series). IntervalIndex : Immutable Index implementing an ordered, sliceable set. Notes ----- Any NA values will be NA in the result. Out of bounds values will be NA in the resulting Series or Categorical object. Reference :ref:`the user guide ` for more examples. Examples -------- Discretize into three equal-sized bins. >>> pd.cut(np.array([1, 7, 5, 4, 6, 3]), 3) ... # doctest: +ELLIPSIS [(0.994, 3.0], (5.0, 7.0], (3.0, 5.0], (3.0, 5.0], (5.0, 7.0], ... Categories (3, interval[float64, right]): [(0.994, 3.0] < (3.0, 5.0] ... >>> pd.cut(np.array([1, 7, 5, 4, 6, 3]), 3, retbins=True) ... # doctest: +ELLIPSIS ([(0.994, 3.0], (5.0, 7.0], (3.0, 5.0], (3.0, 5.0], (5.0, 7.0], ... Categories (3, interval[float64, right]): [(0.994, 3.0] < (3.0, 5.0] ... array([0.994, 3. , 5. , 7. ])) Discovers the same bins, but assign them specific labels. Notice that the returned Categorical's categories are `labels` and is ordered. >>> pd.cut(np.array([1, 7, 5, 4, 6, 3]), ... 3, labels=["bad", "medium", "good"]) ['bad', 'good', 'medium', 'medium', 'good', 'bad'] Categories (3, object): ['bad' < 'medium' < 'good'] ``ordered=False`` will result in unordered categories when labels are passed. This parameter can be used to allow non-unique labels: >>> pd.cut(np.array([1, 7, 5, 4, 6, 3]), 3, ... labels=["B", "A", "B"], ordered=False) ['B', 'B', 'A', 'A', 'B', 'B'] Categories (2, object): ['A', 'B'] ``labels=False`` implies you just want the bins back. >>> pd.cut([0, 1, 1, 2], bins=4, labels=False) array([0, 1, 1, 3]) Passing a Series as an input returns a Series with categorical dtype: >>> s = pd.Series(np.array([2, 4, 6, 8, 10]), ... index=['a', 'b', 'c', 'd', 'e']) >>> pd.cut(s, 3) ... # doctest: +ELLIPSIS a (1.992, 4.667] b (1.992, 4.667] c (4.667, 7.333] d (7.333, 10.0] e (7.333, 10.0] dtype: category Categories (3, interval[float64, right]): [(1.992, 4.667] < (4.667, ... Passing a Series as an input returns a Series with mapping value. It is used to map numerically to intervals based on bins. >>> s = pd.Series(np.array([2, 4, 6, 8, 10]), ... index=['a', 'b', 'c', 'd', 'e']) >>> pd.cut(s, [0, 2, 4, 6, 8, 10], labels=False, retbins=True, right=False) ... # doctest: +ELLIPSIS (a 1.0 b 2.0 c 3.0 d 4.0 e NaN dtype: float64, array([ 0, 2, 4, 6, 8, 10])) Use `drop` optional when bins is not unique >>> pd.cut(s, [0, 2, 4, 6, 10, 10], labels=False, retbins=True, ... right=False, duplicates='drop') ... # doctest: +ELLIPSIS (a 1.0 b 2.0 c 3.0 d 3.0 e NaN dtype: float64, array([ 0, 2, 4, 6, 10])) Passing an IntervalIndex for `bins` results in those categories exactly. Notice that values not covered by the IntervalIndex are set to NaN. 0 is to the left of the first bin (which is closed on the right), and 1.5 falls between two bins. >>> bins = pd.IntervalIndex.from_tuples([(0, 1), (2, 3), (4, 5)]) >>> pd.cut([0, 0.5, 1.5, 2.5, 4.5], bins) [NaN, (0.0, 1.0], NaN, (2.0, 3.0], (4.0, 5.0]] Categories (3, interval[int64, right]): [(0, 1] < (2, 3] < (4, 5]] z*Overlapping IntervalIndex is not accepted.z!bins must increase monotonically.)rightlabels precisioninclude_lowest duplicatesordered) _preprocess_for_cut_coerce_to_typenpiterable_nbins_to_bins isinstanceris_overlapping ValueErrorris_monotonic_increasing _bins_to_cuts_postprocess_for_cut) xbinsrrretbinsrr r!r"originalx_idx_facs J/var/www/html/env/lib/python3.13/site-packages/pandas/core/reshape/tile.pycutr64szH  "Eu%HE ;;t  e51 D- ( (   IJ J T{++@A A  % IC 7 ==c 4Un[U5n[U5upx[U5(a[R"SSUS-5OUn UR 5R 5RU 5n [U[U 5UUSUS9up[XX65$)am Quantile-based discretization function. Discretize variable into equal-sized buckets based on rank or based on sample quantiles. For example 1000 values for 10 quantiles would produce a Categorical object indicating quantile membership for each data point. Parameters ---------- x : 1d ndarray or Series q : int or list-like of float Number of quantiles. 10 for deciles, 4 for quartiles, etc. Alternately array of quantiles, e.g. [0, .25, .5, .75, 1.] for quartiles. labels : array or False, default None Used as labels for the resulting bins. Must be of the same length as the resulting bins. If False, return only integer indicators of the bins. If True, raises an error. retbins : bool, optional Whether to return the (bins, labels) or not. Can be useful if bins is given as a scalar. precision : int, optional The precision at which to store and display the bins labels. duplicates : {default 'raise', 'drop'}, optional If bin edges are not unique, raise ValueError or drop non-uniques. Returns ------- out : Categorical or Series or array of integers if labels is False The return type (Categorical or Series) depends on the input: a Series of type category if input is a Series else Categorical. Bins are represented as categories when categorical data is returned. bins : ndarray of floats Returned only if `retbins` is True. Notes ----- Out of bounds values will be NA in the resulting Categorical object Examples -------- >>> pd.qcut(range(5), 4) ... # doctest: +ELLIPSIS [(-0.001, 1.0], (-0.001, 1.0], (1.0, 2.0], (2.0, 3.0], (3.0, 4.0]] Categories (4, interval[float64, right]): [(-0.001, 1.0] < (1.0, 2.0] ... >>> pd.qcut(range(5), 3, labels=["good", "medium", "bad"]) ... # doctest: +SKIP [good, good, medium, bad, bad] Categories (3, object): [good < medium < bad] >>> pd.qcut(range(5), 4, labels=False) array([0, 0, 1, 2, 3]) rT)rrr r!) r#r$r r%linspace to_seriesdropnaquantiler,rr-) r.qrr0rr!r1r2r3 quantilesr/r4s r5qcutr@szH  "Eu%HE,6qMM Aq!a%(qI ??  # # % . .y 9D  d  IC 7 ==r7c&[U5(aUS:a [S5eURS:Xa [S5eUR5UR 54nUupE[ UR 5(aA[R"U5(d[R"U5(a [S5eXE:Xa[UR 5(aR[UR 5n[SS9RU5nURRXG- XW-US-SUS9nOXDS:waS [U5-OS -nXUS:waS [U5-OS - n[R "XEUS-S S 9nO[UR 5(a5[UR 5nURRXEUS-SUS9nO[R "XEUS-S S 9nXT- S -n U(aUS==U -ss'O US ==U - ss'[#U5$) z` If a user passed an integer N for bins, convert this to a sequence of N equal(ish)-sized bins. r9z$`bins` should be a positive integer.rzCannot cut empty arrayz?cannot specify integer `bins` when input data contains infinity)secondsN)startendperiodsfrequnitgMbP?T)endpoint)rr*sizeminmaxrdtyper%isinf _is_dt_or_tdrras_unit_values_generate_rangeabsr:r) r2nbinsrrngmnmxrGtdr/adjs r5r'r'`s EAI?@@ zzQ122 99; $C FB $$"((2,,"((2,, M   x  $ $!-D1%--d3B==00g27EAIDt1D 1W%#b'/% 7B 1W%#b'/% 7B;;ruqy4@D  $ $ !-D==00%!)$T1D;;ruqy4@Dw%  GsNG HOH ;r7cjU(dUc [S5eUS;a [S5e[U[5(a3URU5n[ USS9n [ R "XSS9n X4$[R"U5n [U 5[U5:a/[U5S:wa US :Xa[S [U5S 35eU nU(aS OS n URX S9n[U5nU(a SXUS:H'[!U5U[U5:H-US:H-nUR#5nUSLGaUb[%U5(d [S5eUc ['XX%S9nOYU(a,[[)U55[U5:wa [S5e[U5[U5S- :wa [S5e[[+USS5[5(d.[ U[[)U55[U5:XaUOSUS9n[,R."XS5 [R0"X8S- 5n X4$US- n U(aDU R3[,R45n [,R."X[,R65 X4$![an URRS:Xa [S5U eURRURRs=:XaS:XaO O [S5U eURRS:Xa [S5U eeSn A ff=f)Nz.'labels' must be provided if 'ordered = False')raisedropzHinvalid value for 'duplicates' parameter, valid options are: raise, dropT)r"F)rMvalidater[zBin edges must be unique: z@. You can drop duplicate edges by setting the 'duplicates' kwargleftr)sidemz!bins must be of timedelta64 dtypeMzHCannot use timezone-naive bins with timezone-aware values, or vice-versaz bins must be of datetime64 dtyper9rzJBin labels must either be False, None or passed in as a list-like argument)rr zNlabels must be unique if ordered=True; pass ordered=False for duplicate labelsz9Bin labels must be one fewer than the number of bin edgesrM) categoriesr")r*r(r get_indexerrr from_codesalgosuniquelenrepr searchsorted TypeErrorrMkindr ranyr_format_labelssetgetattrr%putmasktake_ndastypefloat64nan)r2r/rrrr r!r"ids cat_dtyperesult unique_binsr`errna_maskhas_nass r5r,r,s v~IJJ** V  $ &&u%$T48 ''uM|,,t$K ;#d)#D Q  ,T$ZL9QR /4V'D1 c "C !T!W 5kSCI-.#(;GkkmG U,v"6"6%  >#uFS[)S[8'  6{c$i!m+ O'&'48:JKK %(V%5V%D6$F 3#vQw/ < q ]]2::.F JJv / <y   ;;  s "@As J [[   7C 7  [[   $?@c I  sJ L2BL--L2cSn[UR5(a URnO[UR5(a UR[R 5nOp[ UR[5(aQ[UR5(a7UR[R[RS9n[U5n[U5U4$)z if the passed data is of datetime/timedelta, bool or nullable int type, this method converts it to numeric so that cut or qcut method can handle it N)rMna_value) rOrMr rsr%int64r(rrto_numpyrtrur)r.rMx_arrs r5r$r$s "EAGG qww   HHRXX  AGG^ , ,1A!''1J1J bff = %L 8U?r7c^[U[5=(d [R"US5$)NmM)r(rr is_np_dtype)rMs r5rOrOs! e_ - M1MMr7c^^ U(aSOSn[UR5(a[UR5m SnU 4SjnO[TU5mU4SjnU4SjnUVs/sH ou"U5PM nnU(aU(aU"US5US'[UR5(a [ U5"U5R T 5n[ R"XS9$s snf) z%based on the dtype, return our labelsrr_cU$N)r.s r5 _format_labels..1sar7c<>U[STS9RT5- $)Nr9)rG)rrP)r.rGs r5rr2s1y6>>tDDr7c>[UT5$r) _round_fracr.rs r5rr5s k!Y7r7c>UST*-- $)N rrs r5rr6s1ryj11r7r)closed)rOrMr_infer_precisiontyperPr from_breaks) r/rrr r formatteradjustbbreaksrGs ` @r5rnrn"s,1fFDJJTZZ( D$Y5 7 1$( )DqilDF ) 6!9%q DJJdF#++D1  $ $V ;;*s#C c[USS5nUc[R"U5nURS:wa [ S5e[ U5$)z{ handles preprocessing for cut where we convert passed input to array, strip the index information and store it separately ndimNr9z!Input array must be 1 dimensional)rpr%asarrayrr*r)r.rs r5r#r#DsD 1fd #D | JJqMvv{<== 8Or7c[U[5(a$URXRURS9nU(dU$[U[ 5(a&[ UR5(a URnX4$)z handles post processing for the cut method where we combine the index information if the originally passed datatype was a series )indexname) r(r _constructorrrrrrMrQ)r4r/r0r1s r5r-r-Usc (I&&##C~~HMM#R  $#3DJJ#?#?|| 9r7c <[R"U5(aUS:XaU$[R"U5up#US:XaD[[R"[R "[ U5555*S- U-nOUn[R"X5$)z/ Round the fractional part of the given number rr9)r%isfinitemodfintfloorlog10rSaround)r.rfracwholedigitss r5rrgss ;;q>>Q!Vggaj  A:"((288CI#678812. E1[6EF <<  $ $ 1 / FsA8 )TNFFr[T) rboolr0rrrr rr!strr"r)NFrr[)r0rrrr!r)r2rrTrrrreturnr)TNrFr[T)r2rr/rrrrrr rr!rr"r)r.rrztuple[Index, DtypeObj | None])rMrrr)TF)r/rrrrrr r)rr)r0r)rr)rrr/rrr)5__doc__ __future__rtypingrrrrnumpyr% pandas._libsrr r pandas.core.dtypes.commonr r r rrrpandas.core.dtypes.dtypesrrrpandas.core.dtypes.genericrpandas.core.dtypes.missingrpandasrrrpandas.core.algorithmscore algorithmsrfpandas.core.arrays.datetimelikerpandas._typingrrr6r@r'r,r$rOrnr#r-rrrr7r5rs#  1+ '&9  X> X>  X>  X>X>X>X>|  N> N>  N>  N>b:@  d d d d  d  dddN0N < << <