U
|
¬ý°dka ã @ sJ d Z ddlmZ ddlmZmZmZmZmZm Z ddl
|
Z ddl
|
m Z ddl mZ ddlmZ ddlmZmZmZmZmZ dd lmZmZ dd
|
lm Z m Z m Z m Z m Z m!Z!m"Z" dd l#m$Z$m%Z%m&Z&m'Z'm(Z(m)Z)m*Z* dd l+m,Z, dd l-m.Z.m/Z/m0Z0m1Z1m2Z2m3Z3 ddl4m5Z5 ddl6m7 m8Z9 er<ddl:m;Z;m<Z< ddl=m>Z> dHdddddddZ?e dIddddd d d Z@e dJd ddd d d!d Z@dKd ddd d d#d Z@d$d% ZAd&d'd(d)d*ZBdLd"d+d,d-dddd.d/d0ZCd1d'd2d3d4ZDd5d6d7d8ZEd"d+dd-d,ddd9d:d;ZFd'd<dd'd=d>d?ZGdd,dd@dAdBZHdCdDdddEdFdGZIdS )Mz
|
Constructor functions intended to be shared by pd.array, Series.__init__,
|
and Index.__new__.
|
|
These should not depend on core.internals.
|
é )Ú annotations)Ú TYPE_CHECKINGÚOptionalÚSequenceÚUnionÚcastÚoverloadN)Úma)Úlib)ÚPeriod)Ú AnyArrayLikeÚ ArrayLikeÚDtypeÚDtypeObjÚT)ÚExtensionDtypeÚ _registry)Ú"construct_1d_arraylike_from_scalarÚ'construct_1d_object_array_from_listlikeÚmaybe_cast_to_datetimeÚmaybe_cast_to_integer_arrayÚmaybe_convert_platformÚmaybe_infer_to_datetimelikeÚ maybe_promote)Úis_datetime64_ns_dtypeÚis_dtype_equalÚis_extension_array_dtypeÚis_integer_dtypeÚ is_list_likeÚis_object_dtypeÚis_timedelta64_ns_dtype)Ú PandasDtype)Ú ABCDataFrameÚABCExtensionArrayÚABCIndexÚABCPandasArrayÚ ABCRangeIndexÚ ABCSeries)Úisna)ÚIndexÚSeries)ÚExtensionArrayTz Sequence[object] | AnyArrayLikez Dtype | NoneÚboolr+ )ÚdataÚdtypeÚcopyÚreturnc C sp ddl m}m}m}m}m}m}m} m}
|
m } ddl
|
m } t | ¡rXd| d} t| nt| trjtd|dkrt| tt|fr| j}t| dd } t|tr¬t |¡pª|}t| |rÚ|dksÊt|| jrÚ|rÖ| ¡ S | S t|rt t | ¡ }|j | ||d
|
S |dkr,t j | dd }|d krLt t!t"t#t$ t%f | }|
|
j ||d S |dkrb|| |d S | &d¡rz|j | |d W S tk
|
r Y nX n| &d¡r²| j | |d S |dkrÐ| ¡ j | |d S |dkrè|j | |d S |dkrt'| ddt(j)kr|j | |d S |dkr,|j | |d S t*|rF|j | ||d
|
S t+|r`| j | ||d
|
S | j | ||d
|
S )a
|
Create an array.
|
|
Parameters
|
----------
|
data : Sequence of objects
|
The scalars inside `data` should be instances of the
|
scalar type for `dtype`. It's expected that `data`
|
represents a 1-dimensional array of data.
|
|
When `data` is an Index or Series, the underlying array
|
will be extracted from `data`.
|
|
dtype : str, np.dtype, or ExtensionDtype, optional
|
The dtype to use for the array. This may be a NumPy
|
dtype or an extension type registered with pandas using
|
:meth:`pandas.api.extensions.register_extension_dtype`.
|
|
If not specified, there are two possibilities:
|
|
1. When `data` is a :class:`Series`, :class:`Index`, or
|
:class:`ExtensionArray`, the `dtype` will be taken
|
from the data.
|
2. Otherwise, pandas will attempt to infer the `dtype`
|
from the data.
|
|
Note that when `data` is a NumPy array, ``data.dtype`` is
|
*not* used for inferring the array type. This is because
|
NumPy cannot represent all the types of data that can be
|
held in extension arrays.
|
|
Currently, pandas will infer an extension dtype for sequences of
|
|
============================== =======================================
|
Scalar Type Array Type
|
============================== =======================================
|
:class:`pandas.Interval` :class:`pandas.arrays.IntervalArray`
|
:class:`pandas.Period` :class:`pandas.arrays.PeriodArray`
|
:class:`datetime.datetime` :class:`pandas.arrays.DatetimeArray`
|
:class:`datetime.timedelta` :class:`pandas.arrays.TimedeltaArray`
|
:class:`int` :class:`pandas.arrays.IntegerArray`
|
:class:`float` :class:`pandas.arrays.FloatingArray`
|
:class:`str` :class:`pandas.arrays.StringArray` or
|
:class:`pandas.arrays.ArrowStringArray`
|
:class:`bool` :class:`pandas.arrays.BooleanArray`
|
============================== =======================================
|
|
The ExtensionArray created when the scalar type is :class:`str` is determined by
|
``pd.options.mode.string_storage`` if the dtype is not explicitly given.
|
|
For all other cases, NumPy's usual inference rules will be used.
|
|
.. versionchanged:: 1.2.0
|
|
Pandas now also infers nullable-floating dtype for float-like
|
input data
|
|
copy : bool, default True
|
Whether to copy the data, even if not necessary. Depending
|
on the type of `data`, creating the new array may require
|
copying data, even if ``copy=False``.
|
|
Returns
|
-------
|
ExtensionArray
|
The newly created array.
|
|
Raises
|
------
|
ValueError
|
When `data` is not 1-dimensional.
|
|
See Also
|
--------
|
numpy.array : Construct a NumPy array.
|
Series : Construct a pandas Series.
|
Index : Construct a pandas Index.
|
arrays.PandasArray : ExtensionArray wrapping a NumPy array.
|
Series.array : Extract the array stored within a Series.
|
|
Notes
|
-----
|
Omitting the `dtype` argument means pandas will attempt to infer the
|
best array type from the values in the data. As new array types are
|
added by pandas and 3rd party libraries, the "best" array type may
|
change. We recommend specifying `dtype` to ensure that
|
|
1. the correct array type for the data is returned
|
2. the returned array type doesn't change as new extension types
|
are added by pandas and third-party libraries
|
|
Additionally, if the underlying memory representation of the returned
|
array matters, we recommend specifying the `dtype` as a concrete object
|
rather than a string alias or allowing it to be inferred. For example,
|
a future version of pandas or a 3rd-party library may include a
|
dedicated ExtensionArray for string data. In this event, the following
|
would no longer return a :class:`arrays.PandasArray` backed by a NumPy
|
array.
|
|
>>> pd.array(['a', 'b'], dtype=str)
|
<PandasArray>
|
['a', 'b']
|
Length: 2, dtype: str32
|
|
This would instead return the new ExtensionArray dedicated for string
|
data. If you really need the new array to be backed by a NumPy array,
|
specify that in the dtype.
|
|
>>> pd.array(['a', 'b'], dtype=np.dtype("<U1"))
|
<PandasArray>
|
['a', 'b']
|
Length: 2, dtype: str32
|
|
Finally, Pandas has arrays that mostly overlap with NumPy
|
|
* :class:`arrays.DatetimeArray`
|
* :class:`arrays.TimedeltaArray`
|
|
When data with a ``datetime64[ns]`` or ``timedelta64[ns]`` dtype is
|
passed, pandas will always return a ``DatetimeArray`` or ``TimedeltaArray``
|
rather than a ``PandasArray``. This is for symmetry with the case of
|
timezone-aware data, which NumPy does not natively support.
|
|
>>> pd.array(['2015', '2016'], dtype='datetime64[ns]')
|
<DatetimeArray>
|
['2015-01-01 00:00:00', '2016-01-01 00:00:00']
|
Length: 2, dtype: datetime64[ns]
|
|
>>> pd.array(["1H", "2H"], dtype='timedelta64[ns]')
|
<TimedeltaArray>
|
['0 days 01:00:00', '0 days 02:00:00']
|
Length: 2, dtype: timedelta64[ns]
|
|
Examples
|
--------
|
If a dtype is not specified, pandas will infer the best dtype from the values.
|
See the description of `dtype` for the types pandas infers for.
|
|
>>> pd.array([1, 2])
|
<IntegerArray>
|
[1, 2]
|
Length: 2, dtype: Int64
|
|
>>> pd.array([1, 2, np.nan])
|
<IntegerArray>
|
[1, 2, <NA>]
|
Length: 3, dtype: Int64
|
|
>>> pd.array([1.1, 2.2])
|
<FloatingArray>
|
[1.1, 2.2]
|
Length: 2, dtype: Float64
|
|
>>> pd.array(["a", None, "c"])
|
<StringArray>
|
['a', <NA>, 'c']
|
Length: 3, dtype: string
|
|
>>> with pd.option_context("string_storage", "pyarrow"):
|
... arr = pd.array(["a", None, "c"])
|
...
|
>>> arr
|
<ArrowStringArray>
|
['a', <NA>, 'c']
|
Length: 3, dtype: string
|
|
>>> pd.array([pd.Period('2000', freq="D"), pd.Period("2000", freq="D")])
|
<PeriodArray>
|
['2000-01-01', '2000-01-01']
|
Length: 2, dtype: period[D]
|
|
You can use the string alias for `dtype`
|
|
>>> pd.array(['a', 'b', 'a'], dtype='category')
|
['a', 'b', 'a']
|
Categories (2, object): ['a', 'b']
|
|
Or specify the actual dtype
|
|
>>> pd.array(['a', 'b', 'a'],
|
... dtype=pd.CategoricalDtype(['a', 'b', 'c'], ordered=True))
|
['a', 'b', 'a']
|
Categories (3, object): ['a' < 'b' < 'c']
|
|
If pandas does not infer a dedicated extension type a
|
:class:`arrays.PandasArray` is returned.
|
|
>>> pd.array([1 + 1j, 3 + 2j])
|
<PandasArray>
|
[(1+1j), (3+2j)]
|
Length: 2, dtype: complex128
|
|
As mentioned in the "Notes" section, new extension types may be added
|
in the future (by pandas or 3rd party libraries), causing the return
|
value to no longer be a :class:`arrays.PandasArray`. Specify the `dtype`
|
as a NumPy dtype if you need to ensure there's no future change in
|
behavior.
|
|
>>> pd.array([1, 2], dtype=np.dtype("int32"))
|
<PandasArray>
|
[1, 2]
|
Length: 2, dtype: int32
|
|
`data` must be 1-dimensional. A ValueError is raised when the input
|
has the wrong dimensionality.
|
|
>>> pd.array(1)
|
Traceback (most recent call last):
|
...
|
ValueError: Cannot pass scalar '1' to 'pandas.array'.
|
r ) Ú BooleanArrayÚ DatetimeArrayr+ Ú FloatingArrayÚ IntegerArrayÚ IntervalArrayÚ PandasArrayÚ PeriodArrayÚTimedeltaArray)Ú StringDtypezCannot pass scalar 'z' to 'pandas.array'.z'Cannot pass DataFrame to 'pandas.array'NT)Ú extract_numpy©r. r/ )ZskipnaZperiod©r/ ÚintervalÚdatetimeÚ timedeltaÚstringÚinteger)Zfloatingzmixed-integer-floatr. Úboolean),Úpandas.core.arraysr1 r2 r+ r3 r4 r5 r6 r7 r8 Zpandas.core.arrays.string_r9 r
|
Ú is_scalarÚ
|
ValueErrorÚ
|
isinstancer" Ú TypeErrorr' r$ r. Ú extract_arrayÚstrÚregistryÚfindr r/ r r r Úconstruct_array_typeÚ_from_sequenceZ infer_dtyper r r r r Ú
|
startswithÚgetattrÚnpÚfloat16r r )r- r. r/ r1 r2 r+ r3 r4 r5 r6 r7 r8 r9 ÚmsgÚclsZinferred_dtypeZ period_data© rT úOd:\z\workplace\vscode\pyvenv\venv\Lib\site-packages\pandas/core/construction.pyÚarrayJ sl Y,
|
|
|
|
|
ÿ
|
ÿ
|
|
|
|
|
|
ÿþ
|
|
|
rV .zSeries | Indexr )Úobjr: Ú extract_ranger0 c C s d S ©NrT ©rW r: rX rT rT rU rH ~ s rH r z T | ArrayLikec C s d S rY rT rZ rT rT rU rH
s Fc C sF t | ttfr,t | tr&|r"| jS | S | jS |rBt | trB| ¡ S | S )a
|
Extract the ndarray or ExtensionArray from a Series or Index.
|
|
For all other types, `obj` is just returned as is.
|
|
Parameters
|
----------
|
obj : object
|
For Series / Index, the underlying ExtensionArray is unboxed.
|
|
extract_numpy : bool, default False
|
Whether to extract the ndarray from a PandasArray.
|
|
extract_range : bool, default False
|
If we have a RangeIndex, return range._values if True
|
(which is a materialized integer ndarray), otherwise return unchanged.
|
|
Returns
|
-------
|
arr : object
|
|
Examples
|
--------
|
>>> extract_array(pd.Series(['a', 'b', 'c'], dtype='category'))
|
['a', 'b', 'c']
|
Categories (3, object): ['a', 'b', 'c']
|
|
Other objects like lists, arrays, and DataFrames are just passed through.
|
|
>>> extract_array([1, 2, 3])
|
[1, 2, 3]
|
|
For an ndarray-backed Series / Index the ndarray is returned.
|
|
>>> extract_array(pd.Series([1, 2, 3]))
|
array([1, 2, 3])
|
|
To extract all the way down to the ndarray, pass ``extract_numpy=True``.
|
|
>>> extract_array(pd.Series([1, 2, 3]), extract_numpy=True)
|
array([1, 2, 3])
|
)rF r$ r' r& Z_valuesr% Zto_numpyrZ rT rT rU rH s -
|
c C sT t | tjrP| jjdkr.ddlm} | | ¡S | jjdkrPddlm} | | ¡S | S )zS
|
Wrap datetime64 and timedelta64 ndarrays in DatetimeArray/TimedeltaArray.
|
ÚMr )r2 Úm)r8 ) rF rP Úndarrayr. ÚkindrC r2 rM r8 )Úarrr2 r8 rT rT rU Ú ensure_wrapped_if_datetimelikeÊ s
|
|
r` zma.MaskedArrayz
|
np.ndarray)r- r0 c C s\ t | ¡}| ¡ rPt| jtj\}}ttj|}| j|dd} | ¡ || |< n|
|
¡ } | S )z?
|
Convert numpy MaskedArray to ensure mask is softened.
|
Tr< ) r Z getmaskarrayÚanyr r. rP Únanr ÚastypeZ soften_maskr/ )r- Úmaskr. Z
|
fill_valuerT rT rU Úsanitize_masked_arrayÜ s
|
|
re ©Úallow_2dz Index | NonezDtypeObj | None)Úindexr. r/ rg r0 c C s\ t | tjrt| } t |tr$|j}t| ddd} t | tjrb| j dkrb|dkrV| j
|
}t | ¡} nt | t rxt| } d}t| s¤|dkrtdt| t||} | S t | trÜ|dk rÆ| j||d}n|rÔ| ¡ }n| }nBt |tr t| | ¡ }|j| ||d}nt | tjrxt | tjr.| j} |dkrj| }| j
|
t krPt | }|| krv|rv| ¡ }n t | ||}n¦t | d r¤tj | |d} t!| ||d|d
|
S t| t"| } t| dkrÞ|dkrÞtj g tj#d }n@|dk röt | ||}n(t$| }|j
|
t kr t%tj|}t |}t&|| |||d }t |tjrXt%tj
|
|}t'|| ||}|S ) a¸
|
Sanitize input data to an ndarray or ExtensionArray, copy if specified,
|
coerce to the dtype if specified.
|
|
Parameters
|
----------
|
data : Any
|
index : Index or None, default None
|
dtype : np.dtype, ExtensionDtype, or None, default None
|
copy : bool, default False
|
allow_2d : bool, default False
|
If False, raise if we have a 2D Arraylike.
|
|
Returns
|
-------
|
np.ndarray or ExtensionArray
|
T)r: rX r NFz2index must be specified when data is not list-liker< r; Z __array__)rh r. r/ rg ©r. rf )(rF r Z MaskedArrayre r! Z numpy_dtyperH rP r] Úndimr. r
|
Zitem_from_zerodimÚrangeÚrange_to_ndarrayr rE r Úlenr# rc r/ r Ú_sanitize_non_orderedrL rM ZmatrixÚAÚobjectr Ú _try_castÚhasattrrV Úsanitize_arrayÚlistÚfloat64r r Ú_sanitize_ndimÚ_sanitize_str_dtypes)r- rh r. r/ rg ÚsubarrrS rT rT rU rs î sz
|
|
|
|
|
|
û
|
rs rk )Úrngr0 c C s² z t j| j| j| jdd}W n tk
|
r¬ | jdkr@| jdks\| jd k rX| jkrn n@z t j| j| j| jdd}W q¨ tk
|
r tt| }Y q¨X n tt| }Y nX |S )z)
|
Cast a range object to ndarray.
|
Úint64ri r Zuint64)rP ZarangeÚstartÚstopÚstepÚ OverflowErrorr rt )ry r_ rT rT rU rl i s 0 rl ÚNone)r0 c C s( t | ttfr$tdt| j ddS )z@
|
Raise only for unordered sets, e.g., not for dict_keys
|
ú'z' type is unorderedN)rF ÚsetÚ frozensetrG ÚtypeÚ__name__)r- rT rT rU rn | s rn )Úresultr. rh rg r0 c C s® t | dddkrtd| jdkr.t| |} n|| jdkrªt|tjr^|rL| S td|j dt|rt|t rt
|
j |t d¡d} | ¡ }|j| |d} nt
|
j ||d} | S ) z6
|
Ensure we have a 1-dimensional result array.
|
rj r z(result should be arraylike with ndim > 0é z1Data must be 1-dimensional, got ndarray of shape z insteadrp ri )rO rE rj Ú _maybe_repeatrF rP r] Úshaper r ÚcomZasarray_tuplesafer. rL rM )r
r- r. rh rg rS rT rT rU rv s"
|
|
ÿrv znp.dtype | None)r
r. r/ r0 c C sJ t | jjtrFt |¡sFt t|¡s6tj ||dd}tj |t
|
|d} | S )z=
|
Ensure we have a dtype that is supported by pandas.
|
Fr; ) Ú
|
issubclassr. r rI r
|
rD rP Úallr( rV rp )r
r- r. r/ rT rT rU rw « s
|
rw )r_ rh r0 c C s: |dk r6dt | kr$t |kr6n n| t |¡} | S )zx
|
If we have a length-1 array and an index describing how long we expect
|
the result to be, repeat the array.
|
Nr )rm Úrepeat)r_ rh rT rT rU r ¿ s r zlist | np.ndarrayznp.dtype)r_ r. r/ r0 c C sÆ t | tj}t|r6|s$t| }|S t| j||dS |jdkr|rjttj| } | j }| j
|
dkrt| ¡ } n
|
t | f}t j| d|d |¡S |jdkrt| |S t|r²t| |}ntj| ||d}|S )aL
|
Convert input to numpy ndarray and optionally cast to a given dtype.
|
|
Parameters
|
----------
|
arr : ndarray or list
|
Excludes: ExtensionArray, Series, Index.
|
dtype : np.dtype
|
copy : bool
|
If False, don't copy the data if not needed.
|
|
Returns
|
-------
|
np.ndarray or ExtensionArray
|
r< ÚUr F)Zconvert_na_valuer/ )r\ r[ r; )rF rP r] r r r` rc r^ r r rj Zravelrm r
|
Zensure_string_arrayZreshaper r r rV )r_ r. r/ Z
|
is_ndarrayrx r rT rT rU rq Ê s,
|
|
|
|
ÿ
|
|
rq )NT)..)..)FF)NF)JÚ__doc__Ú
|
__future__r Útypingr r r r r r ÚnumpyrP r Z pandas._libsr
|
Zpandas._libs.tslibs.periodr Zpandas._typingr r r r r Zpandas.core.dtypes.baser r rJ Zpandas.core.dtypes.castr r r r r r r Zpandas.core.dtypes.commonr r r r r r r Zpandas.core.dtypes.dtypesr! Zpandas.core.dtypes.genericr" r# r$ r% r& r' Zpandas.core.dtypes.missingr( Zpandas.core.commonÚcoreÚcommonr Zpandasr) r* Zpandas.core.arrays.baser+ rV rH r` re rs rl rn rv rw r rq rT rT rT rU Ú<module> s^ $ $ ý 6 ÿ ÿ ÿ> üú{ú'
|
