MhJfSSKJr SSKJr SSKJrJr SSKrSSKJ r J r SSK r SSK Jr SSKJrJrJrJr SSKJrJr SS KJr SS KJr SS KJr SS KJr SS KJ r J!r! SSK"J#r# \ (aSSK$J%r% SSSjjr&SSSjjr'SSSjjr(g)) annotations) defaultdict)HashableIterableN) TYPE_CHECKINGcast)IntIndex)is_integer_dtype is_list_likeis_object_dtype pandas_dtype) ArrowDtypeCategoricalDtype) SparseArray)factorize_from_iterable) StringDtype) DataFrame)Index default_index)Series)NpDtypec ^SSKJn /SQn [U[5(GaUcUR U S9mO[ U5(d [ S5eXmSU4Sjjn U "US5 U "US5 [U[5(a[R"U/5n[U[5(aTRV s/sHoU PM nn Uc TRn[U[5(a[R"U/5nO3[U[5(aTRV s/sHoU PM nn TRUR:Xa/n O%UbURUS S 9/n OUR U S 9/n [TR5X5H)upn[!U S U UUUUUS 9nU R#U5 M+ U"U S S 9nU$[!UUUUUUUS 9nU$s sn fs sn f)a? Convert categorical variable into dummy/indicator variables. Each variable is converted in as many 0/1 variables as there are different values. Columns in the output are each named after a value; if the input is a DataFrame, the name of the original variable is prepended to the value. Parameters ---------- data : array-like, Series, or DataFrame Data of which to get dummy indicators. prefix : str, list of str, or dict of str, default None String to append DataFrame column names. Pass a list with length equal to the number of columns when calling get_dummies on a DataFrame. Alternatively, `prefix` can be a dictionary mapping column names to prefixes. prefix_sep : str, default '_' If appending prefix, separator/delimiter to use. Or pass a list or dictionary as with `prefix`. dummy_na : bool, default False Add a column to indicate NaNs, if False NaNs are ignored. columns : list-like, default None Column names in the DataFrame to be encoded. If `columns` is None then all the columns with `object`, `string`, or `category` dtype will be converted. sparse : bool, default False Whether the dummy-encoded columns should be backed by a :class:`SparseArray` (True) or a regular NumPy array (False). drop_first : bool, default False Whether to get k-1 dummies out of k categorical levels by removing the first level. dtype : dtype, default bool Data type for new columns. Only a single dtype is allowed. Returns ------- DataFrame Dummy-coded data. If `data` contains other columns than the dummy-coded one(s), these will be prepended, unaltered, to the result. See Also -------- Series.str.get_dummies : Convert Series of strings to dummy codes. :func:`~pandas.from_dummies` : Convert dummy codes to categorical ``DataFrame``. Notes ----- Reference :ref:`the user guide ` for more examples. Examples -------- >>> s = pd.Series(list('abca')) >>> pd.get_dummies(s) a b c 0 True False False 1 False True False 2 False False True 3 True False False >>> s1 = ['a', 'b', np.nan] >>> pd.get_dummies(s1) a b 0 True False 1 False True 2 False False >>> pd.get_dummies(s1, dummy_na=True) a b NaN 0 True False False 1 False True False 2 False False True >>> df = pd.DataFrame({'A': ['a', 'b', 'a'], 'B': ['b', 'a', 'c'], ... 'C': [1, 2, 3]}) >>> pd.get_dummies(df, prefix=['col1', 'col2']) C col1_a col1_b col2_a col2_b col2_c 0 1 True False False True False 1 2 False True True False False 2 3 True False False False True >>> pd.get_dummies(pd.Series(list('abcaa'))) a b c 0 True False False 1 False True False 2 False False True 3 True False False 4 True False False >>> pd.get_dummies(pd.Series(list('abcaa')), drop_first=True) b c 0 False False 1 True False 2 False True 3 False False 4 False False >>> pd.get_dummies(pd.Series(list('abc')), dtype=float) a b c 0 1.0 0.0 0.0 1 0.0 1.0 0.0 2 0.0 0.0 1.0 rconcat)objectstringcategory)includez1Input must be a list-like for parameter `columns`c>[U5(aJ[U5TRS:Xd-SUS[U5STRSS3n[U5egg)Nz Length of 'z' (9) did not match the length of the columns being encoded (z).)r lenshape ValueError)itemnamelen_msgdata_to_encodes N/var/www/html/env/lib/python3.13/site-packages/pandas/core/reshape/encoding.py check_lenget_dummies..check_lensoD!!4yN$8$8$;;%dV3s4yk:*0034B8 %W-- <"prefix prefix_sepr axis)exclude)r-r.dummy_nasparse drop_firstdtype)r3r4r5)r&str)pandas.core.reshape.concatr isinstancer select_dtypesr TypeErrorr6 itertoolscycledictcolumnsr#dropzipitems_get_dummies_1dappend)datar-r.r2r>r3r4r5rdtypes_to_encoder*col with_dummiespresepdummyresultr(s @r) get_dummiesrL+sf27$ "" ?!//8H/INg&&OP P!]N . &(#*l+ fc " "__fX.F fd # #-;-C-CD-CcSk-CFD >#++F j# & &"*6J  D ) )5C5K5KL5KcS/5KJL   4:: -L  !IIgAI67L!..7G.HIL !5!5!7LMCc#A!%E    &M 1- M!    !  M_EMs =G,G$c SSKJn [[USS95upUc[ US5(aUR n [ U [5(aU RR n [ U [5(aSSK n [U R55nOi[ U [5(aU RS:wa [S5nO8[R "[ 5nOUc[R "[ 5n[U5n [#U 5(a [%S5eSS jn U(d['U 5S:XaU "U5$UR)5nU(a9['U 5XS :H'U R+['U 5[R,5n U(a['U 5S :XaU "U5$['U 5nUcU nO"[/U Vs/sH nUUU3PM sn5n[ U[5(a UR0nOSnU(Ga0[3U5(aSnO#U[R "[ 5:XaSnOS n/n['U5n[5['U55Vs/sHn/PM nnUS :gnUUn[R6"U5Un[9UU5HunnUUR;U5 M U(a US SnUS Sn[9UU5HSunn[=[R>"['U5US 9[AUU5UUS9nUR;[UUUSS95 MU U"US SS9$['U5U4n[ U [R 5(aU nO[Rn[RB"UUSS9n S U [R6"['U55U4'U(dSU US :H'U(aU SS2S S24n US Sn[EU UXS9$s snfs snf)NrrFcopyr5 pyarrow_numpybooleanz1dtype=object is not a valid dtype for get_dummiesc[U[5(a URnO[[ U55n[ US9$)N)index)r8rrSrr"r)rDrSs r)get_empty_frame(_get_dummies_1d..get_empty_frames1 dF # #JJE!#d),Eu%%r,r gr5) sparse_index fill_valuer5)rDrSr&rO)r0rOF)r#r5order)rSr>r5)returnr)#r7rrrhasattrr5r8r categoriesrpyarrowbool_rstorager npboolr r$r"rOinsertnanrrSr rangearanger@rCronesr zerosr)!rDr-r.r2r3r4r5rcodeslevels input_dtypepa_dtyperTnumber_of_cols dummy_colslevelrSrY sparse_seriesN_ sp_indicesmaskn_idxndxcoderFixssarrr# dummy_dtype dummy_mats! r)rBrBsy2,F4e,DEME }w//jj k#3 4 4%0066K k: . . rxxz*E {K 0 0##6 +EHHTNE  % FvLMM& F q(t$$ JJLE [rks6{BFF3c&kQ&t$$[N ~ Ouvhzl5':OP $  E " "J bhhtn $JJ I.3C O.D!E.D".D !E{d  ! T"UE*IC t  # #C (+ $ABJ#ABJJ 3HCC.%a-% D  TSu!U V4m!%88E N* fbhh ' ' K((KHH5 3G 23 "))CJ'./%&Ierk " !!QR%(I#ABJ%RR}P&"Fs O32 O8c @SSKJn [U[5(d![ S[ U5R 35e[[UR5R55nUR5(a[SUR5S35eURSSS9n[[5nUc[UR 5US 'O[U["5(aaUR HPnUR%U5Sn['U5['U5:Xa[S U35eXhR)U5 MR O![ S [ U5R 35eUb[U[*5(a?['U5['U5:Xd&S['U5S['U5S3n [U 5eOX[U[,5(a"[+[/Xb/['U5-55nO![ S[ U5R 35e0n UR15GHupUcU R35n OU Vs/sHow['X-5S PM n nUR4S S 2U 4R7SS9n [U S:5(a[SU R535e[U S:H5(ac[U[*5(aU R)X(5 O[SU R9535eU"UR4S S 2U 4U S:H4SS9nOUR4S S 2U 4nUR;XR R<S9nURSS9nUR R?U5nURAU5RCURD5X'GM [U 5nUb4UR RUR R<5UlU$![a [ S 5ef=fs snf)a Create a categorical ``DataFrame`` from a ``DataFrame`` of dummy variables. Inverts the operation performed by :func:`~pandas.get_dummies`. .. versionadded:: 1.5.0 Parameters ---------- data : DataFrame Data which contains dummy-coded variables in form of integer columns of 1's and 0's. sep : str, default None Separator used in the column names of the dummy categories they are character indicating the separation of the categorical names from the prefixes. For example, if your column names are 'prefix_A' and 'prefix_B', you can strip the underscore by specifying sep='_'. default_category : None, Hashable or dict of Hashables, default None The default category is the implied category when a value has none of the listed categories specified with a one, i.e. if all dummies in a row are zero. Can be a single value for all variables or a dict directly mapping the default categories to a prefix of a variable. Returns ------- DataFrame Categorical data decoded from the dummy input-data. Raises ------ ValueError * When the input ``DataFrame`` ``data`` contains NA values. * When the input ``DataFrame`` ``data`` contains column names with separators that do not match the separator specified with ``sep``. * When a ``dict`` passed to ``default_category`` does not include an implied category for each prefix. * When a value in ``data`` has more than one category assigned to it. * When ``default_category=None`` and a value in ``data`` has no category assigned to it. TypeError * When the input ``data`` is not of type ``DataFrame``. * When the input ``DataFrame`` ``data`` contains non-dummy data. * When the passed ``sep`` is of a wrong data type. * When the passed ``default_category`` is of a wrong data type. See Also -------- :func:`~pandas.get_dummies` : Convert ``Series`` or ``DataFrame`` to dummy codes. :class:`~pandas.Categorical` : Represent a categorical variable in classic. Notes ----- The columns of the passed dummy data should only include 1's and 0's, or boolean values. Examples -------- >>> df = pd.DataFrame({"a": [1, 0, 0, 1], "b": [0, 1, 0, 0], ... "c": [0, 0, 1, 0]}) >>> df a b c 0 1 0 0 1 0 1 0 2 0 0 1 3 1 0 0 >>> pd.from_dummies(df) 0 a 1 b 2 c 3 a >>> df = pd.DataFrame({"col1_a": [1, 0, 1], "col1_b": [0, 1, 0], ... "col2_a": [0, 1, 0], "col2_b": [1, 0, 0], ... "col2_c": [0, 0, 1]}) >>> df col1_a col1_b col2_a col2_b col2_c 0 1 0 0 1 0 1 0 1 1 0 0 2 1 0 0 0 1 >>> pd.from_dummies(df, sep="_") col1 col2 0 a b 1 b a 2 a c >>> df = pd.DataFrame({"col1_a": [1, 0, 0], "col1_b": [0, 1, 0], ... "col2_a": [0, 1, 0], "col2_b": [1, 0, 0], ... "col2_c": [0, 0, 0]}) >>> df col1_a col1_b col2_a col2_b col2_c 0 1 0 0 1 0 1 0 1 1 0 0 2 0 0 0 0 0 >>> pd.from_dummies(df, sep="_", default_category={"col1": "d", "col2": "e"}) col1 col2 0 a b 1 b a 2 d e rrz>Expected 'data' to be a 'DataFrame'; Received 'data' of type: z.Dummy DataFrame contains NA value in column: ''rQFrNz(Passed DataFrame contains non-dummy dataNz$Separator not specified for column: zFExpected 'sep' to be of type 'str' or 'None'; Received 'sep' of type: zLength of 'default_category' (r!)znExpected 'default_category' to be of type 'None', 'Hashable', or 'dict'; Received 'default_category' of type: r r/zEDummy DataFrame contains multi-assignment(s); First instance in row: zEDummy DataFrame contains unassigned value(s); First instance in row: rW)#r7rr8rr:type__name__rrisnaanyr$idxmaxastyperlistr>r6splitr"rCr=rr@rArOlocsumidxmin_constructor_slicedr5get_indexer_fortakeset_axisrS)rDrIdefault_categoryr col_isna_maskdata_to_decodevariables_slicerFr-r'cat_data prefix_slicecatsassigned data_slice cats_array true_valuesindexerrKs r) from_dummiesros\2 dI & & ((,T (;(;'< >  !23M $$&'q *  DYU; "$'O {"4<<0 C  !))CYYs^A&F6{c#h& #Gu!MNN  # * *3 / *  ''+Cy'9'9&: <  # & - -'(C,@@4S9I5J4KLO,-Q0 !)) A(( 3 3#O%7#o:N%NO  8()2235 H / 5 5 7 ;$$&D8DE FL)+, DE!%%ao6:::B x!|  **2//*;)<>  x1}  *D11 ,45 ..6oo.?-@B ##A|O4h!mD1J(++A|OrsF"# (  +B2'&& 7:  @5@ @  @@ @@L8; ~S5~S ~S  ~S  ~S ~S~SF>BK K K<K Kr,