.. _l-properties: Properties ========== .. contents:: :local: :depth: 1 Summary +++++++ +---------------------------------------------------------------------------------------------------------------------+------------------------+------------------------------------------------------------------------------------------------------------------------------+ | property | class parent | truncated documentation | +=====================================================================================================================+========================+==============================================================================================================================+ | :meth:`T ` | WeightedSeries | Return the transpose, which is by definition self. | +---------------------------------------------------------------------------------------------------------------------+------------------------+------------------------------------------------------------------------------------------------------------------------------+ | :py:meth:`_can_hold_na ` | WeightedSeries | | +---------------------------------------------------------------------------------------------------------------------+------------------------+------------------------------------------------------------------------------------------------------------------------------+ | :py:meth:`_can_hold_na ` | WeightedSeriesDtype | Can arrays of this dtype hold NA values? | +---------------------------------------------------------------------------------------------------------------------+------------------------+------------------------------------------------------------------------------------------------------------------------------+ | :py:meth:`_constructor ` | WeightedSeries | | +---------------------------------------------------------------------------------------------------------------------+------------------------+------------------------------------------------------------------------------------------------------------------------------+ | :py:meth:`_constructor_expanddim ` | WeightedSeries | Used when a manipulation result has one higher dimension as the original, such as Series.to_frame() | +---------------------------------------------------------------------------------------------------------------------+------------------------+------------------------------------------------------------------------------------------------------------------------------+ | :py:meth:`_data ` | WeightedSeries | | +---------------------------------------------------------------------------------------------------------------------+------------------------+------------------------------------------------------------------------------------------------------------------------------+ | :py:meth:`_hasna ` | WeightedArray | Equivalent to `self.isna().any()`. Some ExtensionArray subclasses may be able to optimize this check. | +---------------------------------------------------------------------------------------------------------------------+------------------------+------------------------------------------------------------------------------------------------------------------------------+ | :py:meth:`_info_axis ` | WeightedSeries | | +---------------------------------------------------------------------------------------------------------------------+------------------------+------------------------------------------------------------------------------------------------------------------------------+ | :py:meth:`_is_boolean ` | WeightedSeriesDtype | Whether this dtype should be considered boolean. By default, ExtensionDtypes are assumed to be non-numeric. ... | +---------------------------------------------------------------------------------------------------------------------+------------------------+------------------------------------------------------------------------------------------------------------------------------+ | :py:meth:`_is_cached ` | WeightedSeries | Return boolean indicating if self is cached or not. | +---------------------------------------------------------------------------------------------------------------------+------------------------+------------------------------------------------------------------------------------------------------------------------------+ | :py:meth:`_is_mixed_type ` | WeightedSeries | | +---------------------------------------------------------------------------------------------------------------------+------------------------+------------------------------------------------------------------------------------------------------------------------------+ | :py:meth:`_is_numeric ` | WeightedSeriesDtype | Whether columns with this dtype should be considered numeric. By default ExtensionDtypes are assumed to be non-numeric. ... | +---------------------------------------------------------------------------------------------------------------------+------------------------+------------------------------------------------------------------------------------------------------------------------------+ | :py:meth:`_is_view ` | WeightedSeries | Return boolean indicating if self is view of another array | +---------------------------------------------------------------------------------------------------------------------+------------------------+------------------------------------------------------------------------------------------------------------------------------+ | :py:meth:`_references ` | WeightedSeries | | +---------------------------------------------------------------------------------------------------------------------+------------------------+------------------------------------------------------------------------------------------------------------------------------+ | :py:meth:`_stat_axis ` | WeightedSeries | | +---------------------------------------------------------------------------------------------------------------------+------------------------+------------------------------------------------------------------------------------------------------------------------------+ | :py:meth:`_values ` | WeightedSeries | Return the internal repr of this data (defined by Block.interval_values). This are the values as stored in the Block ... | +---------------------------------------------------------------------------------------------------------------------+------------------------+------------------------------------------------------------------------------------------------------------------------------+ | :meth:`array ` | WeightedSeries | The ExtensionArray of the data backing this Series or Index. Returns ------- ExtensionArray An ExtensionArray of the ... | +---------------------------------------------------------------------------------------------------------------------+------------------------+------------------------------------------------------------------------------------------------------------------------------+ | :meth:`at ` | WeightedSeries | Access a single value for a row/column label pair. Similar to ``loc``, in that both provide label-based lookups. ... | +---------------------------------------------------------------------------------------------------------------------+------------------------+------------------------------------------------------------------------------------------------------------------------------+ | :meth:`attrs ` | WeightedSeries | Dictionary of global attributes of this dataset. | +---------------------------------------------------------------------------------------------------------------------+------------------------+------------------------------------------------------------------------------------------------------------------------------+ | :meth:`average ` | ExecutionStat | average processing time | +---------------------------------------------------------------------------------------------------------------------+------------------------+------------------------------------------------------------------------------------------------------------------------------+ | :meth:`axes ` | WeightedSeries | Return a list of the row axis labels. | +---------------------------------------------------------------------------------------------------------------------+------------------------+------------------------------------------------------------------------------------------------------------------------------+ | :meth:`daemon ` | KThread | A boolean value indicating whether this thread is a daemon thread. This must be set before start() is called, otherwise ... | +---------------------------------------------------------------------------------------------------------------------+------------------------+------------------------------------------------------------------------------------------------------------------------------+ | :meth:`deviation ` | ExecutionStat | standard deviation | +---------------------------------------------------------------------------------------------------------------------+------------------------+------------------------------------------------------------------------------------------------------------------------------+ | :meth:`dtype ` | PyCContainer | Returns the type of every elements of the container. | +---------------------------------------------------------------------------------------------------------------------+------------------------+------------------------------------------------------------------------------------------------------------------------------+ | :meth:`dtype ` | WeightedArray | Returns @see cl WeightedSeriesDtype. | +---------------------------------------------------------------------------------------------------------------------+------------------------+------------------------------------------------------------------------------------------------------------------------------+ | :meth:`dtype ` | WeightedSeries | Return the dtype object of the underlying data. Examples -------- >>> s = pd.Series([1, 2, 3]) ... | +---------------------------------------------------------------------------------------------------------------------+------------------------+------------------------------------------------------------------------------------------------------------------------------+ | :meth:`dtypes ` | WeightedSeries | Return the dtype object of the underlying data. Examples -------- >>> s = pd.Series([1, 2, 3]) ... | +---------------------------------------------------------------------------------------------------------------------+------------------------+------------------------------------------------------------------------------------------------------------------------------+ | :meth:`element_type ` | OneTensor | Returns the type of every element of the tensor. | +---------------------------------------------------------------------------------------------------------------------+------------------------+------------------------------------------------------------------------------------------------------------------------------+ | :meth:`element_type ` | OneTensor2 | Returns the type of every element of the tensor. | +---------------------------------------------------------------------------------------------------------------------+------------------------+------------------------------------------------------------------------------------------------------------------------------+ | :meth:`empty ` | WeightedSeries | | +---------------------------------------------------------------------------------------------------------------------+------------------------+------------------------------------------------------------------------------------------------------------------------------+ | :meth:`event ` | CEventProfilerEvent | event kind | +---------------------------------------------------------------------------------------------------------------------+------------------------+------------------------------------------------------------------------------------------------------------------------------+ | :meth:`flags ` | WeightedSeries | Get the properties associated with this pandas object. The available flags are | +---------------------------------------------------------------------------------------------------------------------+------------------------+------------------------------------------------------------------------------------------------------------------------------+ | :meth:`hasnans ` | WeightedSeries | Return True if there are any NaNs. Enables various performance speedups. Returns ------- ... | +---------------------------------------------------------------------------------------------------------------------+------------------------+------------------------------------------------------------------------------------------------------------------------------+ | :meth:`iat ` | WeightedSeries | Access a single value for a row/column pair by integer position. Similar to ``iloc``, in that both provide integer-based ... | +---------------------------------------------------------------------------------------------------------------------+------------------------+------------------------------------------------------------------------------------------------------------------------------+ | :meth:`id_arg ` | CEventProfilerEvent | arg id | +---------------------------------------------------------------------------------------------------------------------+------------------------+------------------------------------------------------------------------------------------------------------------------------+ | :meth:`id_frame ` | CEventProfilerEvent | frame id | +---------------------------------------------------------------------------------------------------------------------+------------------------+------------------------------------------------------------------------------------------------------------------------------+ | :meth:`ident ` | KThread | Thread identifier of this thread or None if it has not been started. This is a nonzero integer. See the get_ident() ... | +---------------------------------------------------------------------------------------------------------------------+------------------------+------------------------------------------------------------------------------------------------------------------------------+ | :meth:`iloc ` | WeightedSeries | Purely integer-location based indexing for selection by position. ``.iloc[]`` is primarily integer position based ... | +---------------------------------------------------------------------------------------------------------------------+------------------------+------------------------------------------------------------------------------------------------------------------------------+ | :meth:`is_monotonic_decreasing ` | WeightedSeries | Return boolean if values in the object are monotonically decreasing. Returns ------- bool | +---------------------------------------------------------------------------------------------------------------------+------------------------+------------------------------------------------------------------------------------------------------------------------------+ | :meth:`is_monotonic_increasing ` | WeightedSeries | Return boolean if values in the object are monotonically increasing. Returns ------- bool | +---------------------------------------------------------------------------------------------------------------------+------------------------+------------------------------------------------------------------------------------------------------------------------------+ | :meth:`is_unique ` | WeightedSeries | Return boolean if values in the object are unique. Returns ------- bool | +---------------------------------------------------------------------------------------------------------------------+------------------------+------------------------------------------------------------------------------------------------------------------------------+ | :meth:`kind ` | WeightedSeriesDtype | A character code (one of 'biufcmMOSUV'), default 'O' This should match the NumPy dtype used when the array is ... | +---------------------------------------------------------------------------------------------------------------------+------------------------+------------------------------------------------------------------------------------------------------------------------------+ | :meth:`loc ` | WeightedSeries | Access a group of rows and columns by label(s) or a boolean array. ``.loc[]`` is primarily label based, but may ... | +---------------------------------------------------------------------------------------------------------------------+------------------------+------------------------------------------------------------------------------------------------------------------------------+ | :meth:`max_exec ` | ExecutionStat | maximum execution time | +---------------------------------------------------------------------------------------------------------------------+------------------------+------------------------------------------------------------------------------------------------------------------------------+ | :meth:`min_exec ` | ExecutionStat | minimum execution time | +---------------------------------------------------------------------------------------------------------------------+------------------------+------------------------------------------------------------------------------------------------------------------------------+ | :meth:`n_columns ` | EventProfiler | Returns the number of stored informations by the profiler in memory. This corresponds to the number of columns returned ... | +---------------------------------------------------------------------------------------------------------------------+------------------------+------------------------------------------------------------------------------------------------------------------------------+ | :meth:`n_columns ` | EventProfilerDebug | Returns the number of stored informations by the profiler in memory. This corresponds to the number of columns returned ... | +---------------------------------------------------------------------------------------------------------------------+------------------------+------------------------------------------------------------------------------------------------------------------------------+ | :meth:`na_value ` | WeightedSeriesDtype | Default NA value to use for this type. This is used in e.g. ExtensionArray.take. This should be the user-facing ... | +---------------------------------------------------------------------------------------------------------------------+------------------------+------------------------------------------------------------------------------------------------------------------------------+ | :meth:`name ` | ContainerType | name(self: handle) -> str | +---------------------------------------------------------------------------------------------------------------------+------------------------+------------------------------------------------------------------------------------------------------------------------------+ | :meth:`name ` | WeightedArray | A string identifying the data type. Will be used for display in, e.g. ``Series.dtype`` | +---------------------------------------------------------------------------------------------------------------------+------------------------+------------------------------------------------------------------------------------------------------------------------------+ | :meth:`name ` | WeightedSeries | Return the name of the Series. The name of a Series becomes its index or column name if it is used to form ... | +---------------------------------------------------------------------------------------------------------------------+------------------------+------------------------------------------------------------------------------------------------------------------------------+ | :meth:`name ` | WeightedSeriesDtype | A string identifying the data type. Will be used for display in, e.g. ``Series.dtype`` | +---------------------------------------------------------------------------------------------------------------------+------------------------+------------------------------------------------------------------------------------------------------------------------------+ | :meth:`name ` | KThread | A string used for identification purposes only. It has no semantics. Multiple threads may be given the same name. ... | +---------------------------------------------------------------------------------------------------------------------+------------------------+------------------------------------------------------------------------------------------------------------------------------+ | :meth:`names ` | WeightedSeriesDtype | Ordered list of field names, or None if there are no fields. This is for compatibility with NumPy arrays, and may ... | +---------------------------------------------------------------------------------------------------------------------+------------------------+------------------------------------------------------------------------------------------------------------------------------+ | :meth:`native_id ` | KThread | Native integral thread ID of this thread, or None if it has not been started. This is a non-negative integer. ... | +---------------------------------------------------------------------------------------------------------------------+------------------------+------------------------------------------------------------------------------------------------------------------------------+ | :meth:`nbytes ` | WeightedSeries | Return the number of bytes in the underlying data. | +---------------------------------------------------------------------------------------------------------------------+------------------------+------------------------------------------------------------------------------------------------------------------------------+ | :meth:`ndim ` | WeightedSeries | Number of dimensions of the underlying data, by definition 1. | +---------------------------------------------------------------------------------------------------------------------+------------------------+------------------------------------------------------------------------------------------------------------------------------+ | :meth:`number ` | ExecutionStat | number of executions being measured | +---------------------------------------------------------------------------------------------------------------------+------------------------+------------------------------------------------------------------------------------------------------------------------------+ | :meth:`repeat ` | ExecutionStat | number of times the experiment is repeated | +---------------------------------------------------------------------------------------------------------------------+------------------------+------------------------------------------------------------------------------------------------------------------------------+ | :meth:`report ` | WithEventProfiler | Returns the profiling report as a dataframe. | +---------------------------------------------------------------------------------------------------------------------+------------------------+------------------------------------------------------------------------------------------------------------------------------+ | :meth:`shape ` | OneTensor | Returns the tensor shape. | +---------------------------------------------------------------------------------------------------------------------+------------------------+------------------------------------------------------------------------------------------------------------------------------+ | :meth:`shape ` | OneTensor2 | Returns the tensor shape. | +---------------------------------------------------------------------------------------------------------------------+------------------------+------------------------------------------------------------------------------------------------------------------------------+ | :meth:`shape ` | WeightedSeries | Return a tuple of the shape of the underlying data. Examples -------- >>> s = pd.Series([1, 2, ... | +---------------------------------------------------------------------------------------------------------------------+------------------------+------------------------------------------------------------------------------------------------------------------------------+ | :meth:`size ` | PyCContainer | Returns the size in bytes of the container. | +---------------------------------------------------------------------------------------------------------------------+------------------------+------------------------------------------------------------------------------------------------------------------------------+ | :meth:`size ` | WeightedSeries | Return the number of elements in the underlying data. | +---------------------------------------------------------------------------------------------------------------------+------------------------+------------------------------------------------------------------------------------------------------------------------------+ | :meth:`time ` | CEventProfilerEvent | time | +---------------------------------------------------------------------------------------------------------------------+------------------------+------------------------------------------------------------------------------------------------------------------------------+ | :meth:`type ` | WeightedSeriesDtype | The scalar type for the array, e.g. ``int`` It's expected ``ExtensionArray[item]`` returns an instance of ... | +---------------------------------------------------------------------------------------------------------------------+------------------------+------------------------------------------------------------------------------------------------------------------------------+ | :meth:`value ` | ContainerType | | +---------------------------------------------------------------------------------------------------------------------+------------------------+------------------------------------------------------------------------------------------------------------------------------+ | :meth:`value ` | WeightedDoubleAccessor | Returns the values. | +---------------------------------------------------------------------------------------------------------------------+------------------------+------------------------------------------------------------------------------------------------------------------------------+ | :meth:`value ` | WeightedDouble | unweighted numeric value (counter) | +---------------------------------------------------------------------------------------------------------------------+------------------------+------------------------------------------------------------------------------------------------------------------------------+ | :meth:`value ` | WeightedFloat | unweighted numeric value (counter) | +---------------------------------------------------------------------------------------------------------------------+------------------------+------------------------------------------------------------------------------------------------------------------------------+ | :meth:`value1 ` | CEventProfilerEvent | first value | +---------------------------------------------------------------------------------------------------------------------+------------------------+------------------------------------------------------------------------------------------------------------------------------+ | :meth:`value2 ` | CEventProfilerEvent | second value | +---------------------------------------------------------------------------------------------------------------------+------------------------+------------------------------------------------------------------------------------------------------------------------------+ | :meth:`values ` | WeightedSeries | Return Series as ndarray or ndarray-like depending on the dtype. | +---------------------------------------------------------------------------------------------------------------------+------------------------+------------------------------------------------------------------------------------------------------------------------------+ | :meth:`version ` | OneTensor | Returns the version. | +---------------------------------------------------------------------------------------------------------------------+------------------------+------------------------------------------------------------------------------------------------------------------------------+ | :meth:`version ` | OneTensor2 | Returns the version. | +---------------------------------------------------------------------------------------------------------------------+------------------------+------------------------------------------------------------------------------------------------------------------------------+ | :meth:`weight ` | WeightedDoubleAccessor | Returns the weights. | +---------------------------------------------------------------------------------------------------------------------+------------------------+------------------------------------------------------------------------------------------------------------------------------+ | :meth:`weight ` | WeightedDouble | weight | +---------------------------------------------------------------------------------------------------------------------+------------------------+------------------------------------------------------------------------------------------------------------------------------+ | :meth:`weight ` | WeightedFloat | weight | +---------------------------------------------------------------------------------------------------------------------+------------------------+------------------------------------------------------------------------------------------------------------------------------+