title
stringlengths 5
65
| summary
stringlengths 5
98.2k
| context
stringlengths 9
121k
| path
stringlengths 10
84
⌀ |
|---|---|---|---|
pandas.IntervalIndex.get_loc
|
`pandas.IntervalIndex.get_loc`
Get integer location, slice or boolean mask for requested label.
default: matches where the label is within an interval only.
```
>>> i1, i2 = pd.Interval(0, 1), pd.Interval(1, 2)
>>> index = pd.IntervalIndex([i1, i2])
>>> index.get_loc(1)
0
```
|
IntervalIndex.get_loc(key, method=None, tolerance=None)[source]#
Get integer location, slice or boolean mask for requested label.
Parameters
keylabel
method{None}, optional
default: matches where the label is within an interval only.
Deprecated since version 1.4.
Returns
int if unique index, slice if monotonic index, else mask
Examples
>>> i1, i2 = pd.Interval(0, 1), pd.Interval(1, 2)
>>> index = pd.IntervalIndex([i1, i2])
>>> index.get_loc(1)
0
You can also supply a point inside an interval.
>>> index.get_loc(1.5)
1
If a label is in several intervals, you get the locations of all the
relevant intervals.
>>> i3 = pd.Interval(0, 2)
>>> overlapping_index = pd.IntervalIndex([i1, i2, i3])
>>> overlapping_index.get_loc(0.5)
array([ True, False, True])
Only exact matches will be returned if an interval is provided.
>>> index.get_loc(pd.Interval(0, 1))
0
|
reference/api/pandas.IntervalIndex.get_loc.html
|
pandas.tseries.offsets.CustomBusinessDay.name
|
`pandas.tseries.offsets.CustomBusinessDay.name`
Return a string representing the base frequency.
Examples
```
>>> pd.offsets.Hour().name
'H'
```
|
CustomBusinessDay.name#
Return a string representing the base frequency.
Examples
>>> pd.offsets.Hour().name
'H'
>>> pd.offsets.Hour(5).name
'H'
|
reference/api/pandas.tseries.offsets.CustomBusinessDay.name.html
|
pandas.tseries.offsets.FY5253Quarter.is_on_offset
|
`pandas.tseries.offsets.FY5253Quarter.is_on_offset`
Return boolean whether a timestamp intersects with this frequency.
```
>>> ts = pd.Timestamp(2022, 1, 1)
>>> freq = pd.offsets.Day(1)
>>> freq.is_on_offset(ts)
True
```
|
FY5253Quarter.is_on_offset()#
Return boolean whether a timestamp intersects with this frequency.
Parameters
dtdatetime.datetimeTimestamp to check intersections with frequency.
Examples
>>> ts = pd.Timestamp(2022, 1, 1)
>>> freq = pd.offsets.Day(1)
>>> freq.is_on_offset(ts)
True
>>> ts = pd.Timestamp(2022, 8, 6)
>>> ts.day_name()
'Saturday'
>>> freq = pd.offsets.BusinessDay(1)
>>> freq.is_on_offset(ts)
False
|
reference/api/pandas.tseries.offsets.FY5253Quarter.is_on_offset.html
|
pandas.core.resample.Resampler.fillna
|
`pandas.core.resample.Resampler.fillna`
Fill missing values introduced by upsampling.
```
>>> s = pd.Series([1, 2, 3],
... index=pd.date_range('20180101', periods=3, freq='h'))
>>> s
2018-01-01 00:00:00 1
2018-01-01 01:00:00 2
2018-01-01 02:00:00 3
Freq: H, dtype: int64
```
|
Resampler.fillna(method, limit=None)[source]#
Fill missing values introduced by upsampling.
In statistics, imputation is the process of replacing missing data with
substituted values [1]. When resampling data, missing values may
appear (e.g., when the resampling frequency is higher than the original
frequency).
Missing values that existed in the original data will
not be modified.
Parameters
method{‘pad’, ‘backfill’, ‘ffill’, ‘bfill’, ‘nearest’}Method to use for filling holes in resampled data
‘pad’ or ‘ffill’: use previous valid observation to fill gap
(forward fill).
‘backfill’ or ‘bfill’: use next valid observation to fill gap.
‘nearest’: use nearest valid observation to fill gap.
limitint, optionalLimit of how many consecutive missing values to fill.
Returns
Series or DataFrameAn upsampled Series or DataFrame with missing values filled.
See also
bfillBackward fill NaN values in the resampled data.
ffillForward fill NaN values in the resampled data.
nearestFill NaN values in the resampled data with nearest neighbor starting from center.
interpolateFill NaN values using interpolation.
Series.fillnaFill NaN values in the Series using the specified method, which can be ‘bfill’ and ‘ffill’.
DataFrame.fillnaFill NaN values in the DataFrame using the specified method, which can be ‘bfill’ and ‘ffill’.
References
1
https://en.wikipedia.org/wiki/Imputation_(statistics)
Examples
Resampling a Series:
>>> s = pd.Series([1, 2, 3],
... index=pd.date_range('20180101', periods=3, freq='h'))
>>> s
2018-01-01 00:00:00 1
2018-01-01 01:00:00 2
2018-01-01 02:00:00 3
Freq: H, dtype: int64
Without filling the missing values you get:
>>> s.resample("30min").asfreq()
2018-01-01 00:00:00 1.0
2018-01-01 00:30:00 NaN
2018-01-01 01:00:00 2.0
2018-01-01 01:30:00 NaN
2018-01-01 02:00:00 3.0
Freq: 30T, dtype: float64
>>> s.resample('30min').fillna("backfill")
2018-01-01 00:00:00 1
2018-01-01 00:30:00 2
2018-01-01 01:00:00 2
2018-01-01 01:30:00 3
2018-01-01 02:00:00 3
Freq: 30T, dtype: int64
>>> s.resample('15min').fillna("backfill", limit=2)
2018-01-01 00:00:00 1.0
2018-01-01 00:15:00 NaN
2018-01-01 00:30:00 2.0
2018-01-01 00:45:00 2.0
2018-01-01 01:00:00 2.0
2018-01-01 01:15:00 NaN
2018-01-01 01:30:00 3.0
2018-01-01 01:45:00 3.0
2018-01-01 02:00:00 3.0
Freq: 15T, dtype: float64
>>> s.resample('30min').fillna("pad")
2018-01-01 00:00:00 1
2018-01-01 00:30:00 1
2018-01-01 01:00:00 2
2018-01-01 01:30:00 2
2018-01-01 02:00:00 3
Freq: 30T, dtype: int64
>>> s.resample('30min').fillna("nearest")
2018-01-01 00:00:00 1
2018-01-01 00:30:00 2
2018-01-01 01:00:00 2
2018-01-01 01:30:00 3
2018-01-01 02:00:00 3
Freq: 30T, dtype: int64
Missing values present before the upsampling are not affected.
>>> sm = pd.Series([1, None, 3],
... index=pd.date_range('20180101', periods=3, freq='h'))
>>> sm
2018-01-01 00:00:00 1.0
2018-01-01 01:00:00 NaN
2018-01-01 02:00:00 3.0
Freq: H, dtype: float64
>>> sm.resample('30min').fillna('backfill')
2018-01-01 00:00:00 1.0
2018-01-01 00:30:00 NaN
2018-01-01 01:00:00 NaN
2018-01-01 01:30:00 3.0
2018-01-01 02:00:00 3.0
Freq: 30T, dtype: float64
>>> sm.resample('30min').fillna('pad')
2018-01-01 00:00:00 1.0
2018-01-01 00:30:00 1.0
2018-01-01 01:00:00 NaN
2018-01-01 01:30:00 NaN
2018-01-01 02:00:00 3.0
Freq: 30T, dtype: float64
>>> sm.resample('30min').fillna('nearest')
2018-01-01 00:00:00 1.0
2018-01-01 00:30:00 NaN
2018-01-01 01:00:00 NaN
2018-01-01 01:30:00 3.0
2018-01-01 02:00:00 3.0
Freq: 30T, dtype: float64
DataFrame resampling is done column-wise. All the same options are
available.
>>> df = pd.DataFrame({'a': [2, np.nan, 6], 'b': [1, 3, 5]},
... index=pd.date_range('20180101', periods=3,
... freq='h'))
>>> df
a b
2018-01-01 00:00:00 2.0 1
2018-01-01 01:00:00 NaN 3
2018-01-01 02:00:00 6.0 5
>>> df.resample('30min').fillna("bfill")
a b
2018-01-01 00:00:00 2.0 1
2018-01-01 00:30:00 NaN 3
2018-01-01 01:00:00 NaN 3
2018-01-01 01:30:00 6.0 5
2018-01-01 02:00:00 6.0 5
|
reference/api/pandas.core.resample.Resampler.fillna.html
|
pandas.Series.dt.nanosecond
|
`pandas.Series.dt.nanosecond`
The nanoseconds of the datetime.
```
>>> datetime_series = pd.Series(
... pd.date_range("2000-01-01", periods=3, freq="ns")
... )
>>> datetime_series
0 2000-01-01 00:00:00.000000000
1 2000-01-01 00:00:00.000000001
2 2000-01-01 00:00:00.000000002
dtype: datetime64[ns]
>>> datetime_series.dt.nanosecond
0 0
1 1
2 2
dtype: int64
```
|
Series.dt.nanosecond[source]#
The nanoseconds of the datetime.
Examples
>>> datetime_series = pd.Series(
... pd.date_range("2000-01-01", periods=3, freq="ns")
... )
>>> datetime_series
0 2000-01-01 00:00:00.000000000
1 2000-01-01 00:00:00.000000001
2 2000-01-01 00:00:00.000000002
dtype: datetime64[ns]
>>> datetime_series.dt.nanosecond
0 0
1 1
2 2
dtype: int64
|
reference/api/pandas.Series.dt.nanosecond.html
|
pandas.errors.SpecificationError
|
`pandas.errors.SpecificationError`
Exception raised by agg when the functions are ill-specified.
```
>>> df = pd.DataFrame({'A': [1, 1, 1, 2, 2],
... 'B': range(5),
... 'C': range(5)})
>>> df.groupby('A').B.agg({'foo': 'count'})
... # SpecificationError: nested renamer is not supported
```
|
exception pandas.errors.SpecificationError[source]#
Exception raised by agg when the functions are ill-specified.
The exception raised in two scenarios.
The first way is calling agg on a
Dataframe or Series using a nested renamer (dict-of-dict).
The second way is calling agg on a Dataframe with duplicated functions
names without assigning column name.
Examples
>>> df = pd.DataFrame({'A': [1, 1, 1, 2, 2],
... 'B': range(5),
... 'C': range(5)})
>>> df.groupby('A').B.agg({'foo': 'count'})
... # SpecificationError: nested renamer is not supported
>>> df.groupby('A').agg({'B': {'foo': ['sum', 'max']}})
... # SpecificationError: nested renamer is not supported
>>> df.groupby('A').agg(['min', 'min'])
... # SpecificationError: nested renamer is not supported
|
reference/api/pandas.errors.SpecificationError.html
|
pandas.Series.str.startswith
|
`pandas.Series.str.startswith`
Test if the start of each string element matches a pattern.
```
>>> s = pd.Series(['bat', 'Bear', 'cat', np.nan])
>>> s
0 bat
1 Bear
2 cat
3 NaN
dtype: object
```
|
Series.str.startswith(pat, na=None)[source]#
Test if the start of each string element matches a pattern.
Equivalent to str.startswith().
Parameters
patstr or tuple[str, …]Character sequence or tuple of strings. Regular expressions are not
accepted.
naobject, default NaNObject shown if element tested is not a string. The default depends
on dtype of the array. For object-dtype, numpy.nan is used.
For StringDtype, pandas.NA is used.
Returns
Series or Index of boolA Series of booleans indicating whether the given pattern matches
the start of each string element.
See also
str.startswithPython standard library string method.
Series.str.endswithSame as startswith, but tests the end of string.
Series.str.containsTests if string element contains a pattern.
Examples
>>> s = pd.Series(['bat', 'Bear', 'cat', np.nan])
>>> s
0 bat
1 Bear
2 cat
3 NaN
dtype: object
>>> s.str.startswith('b')
0 True
1 False
2 False
3 NaN
dtype: object
>>> s.str.startswith(('b', 'B'))
0 True
1 True
2 False
3 NaN
dtype: object
Specifying na to be False instead of NaN.
>>> s.str.startswith('b', na=False)
0 True
1 False
2 False
3 False
dtype: bool
|
reference/api/pandas.Series.str.startswith.html
|
pandas.io.formats.style.Styler.hide
|
`pandas.io.formats.style.Styler.hide`
Hide the entire index / column headers, or specific rows / columns from display.
```
>>> df = pd.DataFrame([[1,2], [3,4], [5,6]], index=["a", "b", "c"])
>>> df.style.hide(["a", "b"])
0 1
c 5 6
```
|
Styler.hide(subset=None, axis=0, level=None, names=False)[source]#
Hide the entire index / column headers, or specific rows / columns from display.
New in version 1.4.0.
Parameters
subsetlabel, array-like, IndexSlice, optionalA valid 1d input or single key along the axis within
DataFrame.loc[<subset>, :] or DataFrame.loc[:, <subset>] depending
upon axis, to limit data to select hidden rows / columns.
axis{“index”, 0, “columns”, 1}Apply to the index or columns.
levelint, str, listThe level(s) to hide in a MultiIndex if hiding the entire index / column
headers. Cannot be used simultaneously with subset.
namesboolWhether to hide the level name(s) of the index / columns headers in the case
it (or at least one the levels) remains visible.
Returns
selfStyler
Notes
Warning
This method only works with the output methods to_html, to_string
and to_latex.
Other output methods, including to_excel, ignore this hiding method
and will display all data.
This method has multiple functionality depending upon the combination
of the subset, level and names arguments (see examples). The
axis argument is used only to control whether the method is applied to row
or column headers:
Argument combinations#
subset
level
names
Effect
None
None
False
The axis-Index is hidden entirely.
None
None
True
Only the axis-Index names are hidden.
None
Int, Str, List
False
Specified axis-MultiIndex levels are hidden entirely.
None
Int, Str, List
True
Specified axis-MultiIndex levels are hidden entirely and the names of
remaining axis-MultiIndex levels.
Subset
None
False
The specified data rows/columns are hidden, but the axis-Index itself,
and names, remain unchanged.
Subset
None
True
The specified data rows/columns and axis-Index names are hidden, but
the axis-Index itself remains unchanged.
Subset
Int, Str, List
Boolean
ValueError: cannot supply subset and level simultaneously.
Note this method only hides the identifed elements so can be chained to hide
multiple elements in sequence.
Examples
Simple application hiding specific rows:
>>> df = pd.DataFrame([[1,2], [3,4], [5,6]], index=["a", "b", "c"])
>>> df.style.hide(["a", "b"])
0 1
c 5 6
Hide the index and retain the data values:
>>> midx = pd.MultiIndex.from_product([["x", "y"], ["a", "b", "c"]])
>>> df = pd.DataFrame(np.random.randn(6,6), index=midx, columns=midx)
>>> df.style.format("{:.1f}").hide()
x y
a b c a b c
0.1 0.0 0.4 1.3 0.6 -1.4
0.7 1.0 1.3 1.5 -0.0 -0.2
1.4 -0.8 1.6 -0.2 -0.4 -0.3
0.4 1.0 -0.2 -0.8 -1.2 1.1
-0.6 1.2 1.8 1.9 0.3 0.3
0.8 0.5 -0.3 1.2 2.2 -0.8
Hide specific rows in a MultiIndex but retain the index:
>>> df.style.format("{:.1f}").hide(subset=(slice(None), ["a", "c"]))
...
x y
a b c a b c
x b 0.7 1.0 1.3 1.5 -0.0 -0.2
y b -0.6 1.2 1.8 1.9 0.3 0.3
Hide specific rows and the index through chaining:
>>> df.style.format("{:.1f}").hide(subset=(slice(None), ["a", "c"])).hide()
...
x y
a b c a b c
0.7 1.0 1.3 1.5 -0.0 -0.2
-0.6 1.2 1.8 1.9 0.3 0.3
Hide a specific level:
>>> df.style.format("{:,.1f}").hide(level=1)
x y
a b c a b c
x 0.1 0.0 0.4 1.3 0.6 -1.4
0.7 1.0 1.3 1.5 -0.0 -0.2
1.4 -0.8 1.6 -0.2 -0.4 -0.3
y 0.4 1.0 -0.2 -0.8 -1.2 1.1
-0.6 1.2 1.8 1.9 0.3 0.3
0.8 0.5 -0.3 1.2 2.2 -0.8
Hiding just the index level names:
>>> df.index.names = ["lev0", "lev1"]
>>> df.style.format("{:,.1f}").hide(names=True)
x y
a b c a b c
x a 0.1 0.0 0.4 1.3 0.6 -1.4
b 0.7 1.0 1.3 1.5 -0.0 -0.2
c 1.4 -0.8 1.6 -0.2 -0.4 -0.3
y a 0.4 1.0 -0.2 -0.8 -1.2 1.1
b -0.6 1.2 1.8 1.9 0.3 0.3
c 0.8 0.5 -0.3 1.2 2.2 -0.8
Examples all produce equivalently transposed effects with axis="columns".
|
reference/api/pandas.io.formats.style.Styler.hide.html
|
pandas.tseries.offsets.MonthEnd.is_month_start
|
`pandas.tseries.offsets.MonthEnd.is_month_start`
Return boolean whether a timestamp occurs on the month start.
```
>>> ts = pd.Timestamp(2022, 1, 1)
>>> freq = pd.offsets.Hour(5)
>>> freq.is_month_start(ts)
True
```
|
MonthEnd.is_month_start()#
Return boolean whether a timestamp occurs on the month start.
Examples
>>> ts = pd.Timestamp(2022, 1, 1)
>>> freq = pd.offsets.Hour(5)
>>> freq.is_month_start(ts)
True
|
reference/api/pandas.tseries.offsets.MonthEnd.is_month_start.html
|
pandas.Series.str.repeat
|
`pandas.Series.str.repeat`
Duplicate each string in the Series or Index.
```
>>> s = pd.Series(['a', 'b', 'c'])
>>> s
0 a
1 b
2 c
dtype: object
```
|
Series.str.repeat(repeats)[source]#
Duplicate each string in the Series or Index.
Parameters
repeatsint or sequence of intSame value for all (int) or different value per (sequence).
Returns
Series or Index of objectSeries or Index of repeated string objects specified by
input parameter repeats.
Examples
>>> s = pd.Series(['a', 'b', 'c'])
>>> s
0 a
1 b
2 c
dtype: object
Single int repeats string in Series
>>> s.str.repeat(repeats=2)
0 aa
1 bb
2 cc
dtype: object
Sequence of int repeats corresponding string in Series
>>> s.str.repeat(repeats=[1, 2, 3])
0 a
1 bb
2 ccc
dtype: object
|
reference/api/pandas.Series.str.repeat.html
|
Resampling
|
Resampling
|
Resampler objects are returned by resample calls: pandas.DataFrame.resample(), pandas.Series.resample().
Indexing, iteration#
Resampler.__iter__()
Groupby iterator.
Resampler.groups
Dict {group name -> group labels}.
Resampler.indices
Dict {group name -> group indices}.
Resampler.get_group(name[, obj])
Construct DataFrame from group with provided name.
Function application#
Resampler.apply([func])
Aggregate using one or more operations over the specified axis.
Resampler.aggregate([func])
Aggregate using one or more operations over the specified axis.
Resampler.transform(arg, *args, **kwargs)
Call function producing a like-indexed Series on each group.
Resampler.pipe(func, *args, **kwargs)
Apply a func with arguments to this Resampler object and return its result.
Upsampling#
Resampler.ffill([limit])
Forward fill the values.
Resampler.backfill([limit])
(DEPRECATED) Backward fill the values.
Resampler.bfill([limit])
Backward fill the new missing values in the resampled data.
Resampler.pad([limit])
(DEPRECATED) Forward fill the values.
Resampler.nearest([limit])
Resample by using the nearest value.
Resampler.fillna(method[, limit])
Fill missing values introduced by upsampling.
Resampler.asfreq([fill_value])
Return the values at the new freq, essentially a reindex.
Resampler.interpolate([method, axis, limit, ...])
Interpolate values according to different methods.
Computations / descriptive stats#
Resampler.count()
Compute count of group, excluding missing values.
Resampler.nunique(*args, **kwargs)
Return number of unique elements in the group.
Resampler.first([numeric_only, min_count])
Compute the first non-null entry of each column.
Resampler.last([numeric_only, min_count])
Compute the last non-null entry of each column.
Resampler.max([numeric_only, min_count])
Compute max of group values.
Resampler.mean([numeric_only])
Compute mean of groups, excluding missing values.
Resampler.median([numeric_only])
Compute median of groups, excluding missing values.
Resampler.min([numeric_only, min_count])
Compute min of group values.
Resampler.ohlc(*args, **kwargs)
Compute open, high, low and close values of a group, excluding missing values.
Resampler.prod([numeric_only, min_count])
Compute prod of group values.
Resampler.size()
Compute group sizes.
Resampler.sem([ddof, numeric_only])
Compute standard error of the mean of groups, excluding missing values.
Resampler.std([ddof, numeric_only])
Compute standard deviation of groups, excluding missing values.
Resampler.sum([numeric_only, min_count])
Compute sum of group values.
Resampler.var([ddof, numeric_only])
Compute variance of groups, excluding missing values.
Resampler.quantile([q])
Return value at the given quantile.
|
reference/resampling.html
|
pandas.MultiIndex.to_frame
|
`pandas.MultiIndex.to_frame`
Create a DataFrame with the levels of the MultiIndex as columns.
```
>>> mi = pd.MultiIndex.from_arrays([['a', 'b'], ['c', 'd']])
>>> mi
MultiIndex([('a', 'c'),
('b', 'd')],
)
```
|
MultiIndex.to_frame(index=True, name=_NoDefault.no_default, allow_duplicates=False)[source]#
Create a DataFrame with the levels of the MultiIndex as columns.
Column ordering is determined by the DataFrame constructor with data as
a dict.
Parameters
indexbool, default TrueSet the index of the returned DataFrame as the original MultiIndex.
namelist / sequence of str, optionalThe passed names should substitute index level names.
allow_duplicatesbool, optional default FalseAllow duplicate column labels to be created.
New in version 1.5.0.
Returns
DataFramea DataFrame containing the original MultiIndex data.
See also
DataFrameTwo-dimensional, size-mutable, potentially heterogeneous tabular data.
Examples
>>> mi = pd.MultiIndex.from_arrays([['a', 'b'], ['c', 'd']])
>>> mi
MultiIndex([('a', 'c'),
('b', 'd')],
)
>>> df = mi.to_frame()
>>> df
0 1
a c a c
b d b d
>>> df = mi.to_frame(index=False)
>>> df
0 1
0 a c
1 b d
>>> df = mi.to_frame(name=['x', 'y'])
>>> df
x y
a c a c
b d b d
|
reference/api/pandas.MultiIndex.to_frame.html
|
pandas.DatetimeIndex.freq
|
`pandas.DatetimeIndex.freq`
Return the frequency object if it is set, otherwise None.
|
property DatetimeIndex.freq[source]#
Return the frequency object if it is set, otherwise None.
|
reference/api/pandas.DatetimeIndex.freq.html
|
pandas.api.types.is_number
|
`pandas.api.types.is_number`
Check if the object is a number.
Returns True when the object is a number, and False if is not.
```
>>> from pandas.api.types import is_number
>>> is_number(1)
True
>>> is_number(7.15)
True
```
|
pandas.api.types.is_number(obj)[source]#
Check if the object is a number.
Returns True when the object is a number, and False if is not.
Parameters
objany typeThe object to check if is a number.
Returns
is_numberboolWhether obj is a number or not.
See also
api.types.is_integerChecks a subgroup of numbers.
Examples
>>> from pandas.api.types import is_number
>>> is_number(1)
True
>>> is_number(7.15)
True
Booleans are valid because they are int subclass.
>>> is_number(False)
True
>>> is_number("foo")
False
>>> is_number("5")
False
|
reference/api/pandas.api.types.is_number.html
|
pandas.DataFrame.assign
|
`pandas.DataFrame.assign`
Assign new columns to a DataFrame.
Returns a new object with all original columns in addition to new ones.
Existing columns that are re-assigned will be overwritten.
```
>>> df = pd.DataFrame({'temp_c': [17.0, 25.0]},
... index=['Portland', 'Berkeley'])
>>> df
temp_c
Portland 17.0
Berkeley 25.0
```
|
DataFrame.assign(**kwargs)[source]#
Assign new columns to a DataFrame.
Returns a new object with all original columns in addition to new ones.
Existing columns that are re-assigned will be overwritten.
Parameters
**kwargsdict of {str: callable or Series}The column names are keywords. If the values are
callable, they are computed on the DataFrame and
assigned to the new columns. The callable must not
change input DataFrame (though pandas doesn’t check it).
If the values are not callable, (e.g. a Series, scalar, or array),
they are simply assigned.
Returns
DataFrameA new DataFrame with the new columns in addition to
all the existing columns.
Notes
Assigning multiple columns within the same assign is possible.
Later items in ‘**kwargs’ may refer to newly created or modified
columns in ‘df’; items are computed and assigned into ‘df’ in order.
Examples
>>> df = pd.DataFrame({'temp_c': [17.0, 25.0]},
... index=['Portland', 'Berkeley'])
>>> df
temp_c
Portland 17.0
Berkeley 25.0
Where the value is a callable, evaluated on df:
>>> df.assign(temp_f=lambda x: x.temp_c * 9 / 5 + 32)
temp_c temp_f
Portland 17.0 62.6
Berkeley 25.0 77.0
Alternatively, the same behavior can be achieved by directly
referencing an existing Series or sequence:
>>> df.assign(temp_f=df['temp_c'] * 9 / 5 + 32)
temp_c temp_f
Portland 17.0 62.6
Berkeley 25.0 77.0
You can create multiple columns within the same assign where one
of the columns depends on another one defined within the same assign:
>>> df.assign(temp_f=lambda x: x['temp_c'] * 9 / 5 + 32,
... temp_k=lambda x: (x['temp_f'] + 459.67) * 5 / 9)
temp_c temp_f temp_k
Portland 17.0 62.6 290.15
Berkeley 25.0 77.0 298.15
|
reference/api/pandas.DataFrame.assign.html
|
pandas.PeriodIndex.year
|
`pandas.PeriodIndex.year`
The year of the period.
|
property PeriodIndex.year[source]#
The year of the period.
|
reference/api/pandas.PeriodIndex.year.html
|
pandas.Timedelta.value
|
pandas.Timedelta.value
|
Timedelta.value#
|
reference/api/pandas.Timedelta.value.html
|
Date offsets
|
Date offsets
|
DateOffset#
DateOffset
Standard kind of date increment used for a date range.
Properties#
DateOffset.freqstr
Return a string representing the frequency.
DateOffset.kwds
Return a dict of extra parameters for the offset.
DateOffset.name
Return a string representing the base frequency.
DateOffset.nanos
DateOffset.normalize
DateOffset.rule_code
DateOffset.n
DateOffset.is_month_start
Return boolean whether a timestamp occurs on the month start.
DateOffset.is_month_end
Return boolean whether a timestamp occurs on the month end.
Methods#
DateOffset.apply
DateOffset.apply_index
(DEPRECATED) Vectorized apply of DateOffset to DatetimeIndex.
DateOffset.copy
Return a copy of the frequency.
DateOffset.isAnchored
DateOffset.onOffset
DateOffset.is_anchored
Return boolean whether the frequency is a unit frequency (n=1).
DateOffset.is_on_offset
Return boolean whether a timestamp intersects with this frequency.
DateOffset.__call__(*args, **kwargs)
Call self as a function.
DateOffset.is_month_start
Return boolean whether a timestamp occurs on the month start.
DateOffset.is_month_end
Return boolean whether a timestamp occurs on the month end.
DateOffset.is_quarter_start
Return boolean whether a timestamp occurs on the quarter start.
DateOffset.is_quarter_end
Return boolean whether a timestamp occurs on the quarter end.
DateOffset.is_year_start
Return boolean whether a timestamp occurs on the year start.
DateOffset.is_year_end
Return boolean whether a timestamp occurs on the year end.
BusinessDay#
BusinessDay
DateOffset subclass representing possibly n business days.
Alias:
BDay
alias of pandas._libs.tslibs.offsets.BusinessDay
Properties#
BusinessDay.freqstr
Return a string representing the frequency.
BusinessDay.kwds
Return a dict of extra parameters for the offset.
BusinessDay.name
Return a string representing the base frequency.
BusinessDay.nanos
BusinessDay.normalize
BusinessDay.rule_code
BusinessDay.n
BusinessDay.weekmask
BusinessDay.holidays
BusinessDay.calendar
Methods#
BusinessDay.apply
BusinessDay.apply_index
(DEPRECATED) Vectorized apply of DateOffset to DatetimeIndex.
BusinessDay.copy
Return a copy of the frequency.
BusinessDay.isAnchored
BusinessDay.onOffset
BusinessDay.is_anchored
Return boolean whether the frequency is a unit frequency (n=1).
BusinessDay.is_on_offset
Return boolean whether a timestamp intersects with this frequency.
BusinessDay.__call__(*args, **kwargs)
Call self as a function.
BusinessDay.is_month_start
Return boolean whether a timestamp occurs on the month start.
BusinessDay.is_month_end
Return boolean whether a timestamp occurs on the month end.
BusinessDay.is_quarter_start
Return boolean whether a timestamp occurs on the quarter start.
BusinessDay.is_quarter_end
Return boolean whether a timestamp occurs on the quarter end.
BusinessDay.is_year_start
Return boolean whether a timestamp occurs on the year start.
BusinessDay.is_year_end
Return boolean whether a timestamp occurs on the year end.
BusinessHour#
BusinessHour
DateOffset subclass representing possibly n business hours.
Properties#
BusinessHour.freqstr
Return a string representing the frequency.
BusinessHour.kwds
Return a dict of extra parameters for the offset.
BusinessHour.name
Return a string representing the base frequency.
BusinessHour.nanos
BusinessHour.normalize
BusinessHour.rule_code
BusinessHour.n
BusinessHour.start
BusinessHour.end
BusinessHour.weekmask
BusinessHour.holidays
BusinessHour.calendar
Methods#
BusinessHour.apply
BusinessHour.apply_index
(DEPRECATED) Vectorized apply of DateOffset to DatetimeIndex.
BusinessHour.copy
Return a copy of the frequency.
BusinessHour.isAnchored
BusinessHour.onOffset
BusinessHour.is_anchored
Return boolean whether the frequency is a unit frequency (n=1).
BusinessHour.is_on_offset
Return boolean whether a timestamp intersects with this frequency.
BusinessHour.__call__(*args, **kwargs)
Call self as a function.
BusinessHour.is_month_start
Return boolean whether a timestamp occurs on the month start.
BusinessHour.is_month_end
Return boolean whether a timestamp occurs on the month end.
BusinessHour.is_quarter_start
Return boolean whether a timestamp occurs on the quarter start.
BusinessHour.is_quarter_end
Return boolean whether a timestamp occurs on the quarter end.
BusinessHour.is_year_start
Return boolean whether a timestamp occurs on the year start.
BusinessHour.is_year_end
Return boolean whether a timestamp occurs on the year end.
CustomBusinessDay#
CustomBusinessDay
DateOffset subclass representing custom business days excluding holidays.
Alias:
CDay
alias of pandas._libs.tslibs.offsets.CustomBusinessDay
Properties#
CustomBusinessDay.freqstr
Return a string representing the frequency.
CustomBusinessDay.kwds
Return a dict of extra parameters for the offset.
CustomBusinessDay.name
Return a string representing the base frequency.
CustomBusinessDay.nanos
CustomBusinessDay.normalize
CustomBusinessDay.rule_code
CustomBusinessDay.n
CustomBusinessDay.weekmask
CustomBusinessDay.calendar
CustomBusinessDay.holidays
Methods#
CustomBusinessDay.apply_index
(DEPRECATED) Vectorized apply of DateOffset to DatetimeIndex.
CustomBusinessDay.apply
CustomBusinessDay.copy
Return a copy of the frequency.
CustomBusinessDay.isAnchored
CustomBusinessDay.onOffset
CustomBusinessDay.is_anchored
Return boolean whether the frequency is a unit frequency (n=1).
CustomBusinessDay.is_on_offset
Return boolean whether a timestamp intersects with this frequency.
CustomBusinessDay.__call__(*args, **kwargs)
Call self as a function.
CustomBusinessDay.is_month_start
Return boolean whether a timestamp occurs on the month start.
CustomBusinessDay.is_month_end
Return boolean whether a timestamp occurs on the month end.
CustomBusinessDay.is_quarter_start
Return boolean whether a timestamp occurs on the quarter start.
CustomBusinessDay.is_quarter_end
Return boolean whether a timestamp occurs on the quarter end.
CustomBusinessDay.is_year_start
Return boolean whether a timestamp occurs on the year start.
CustomBusinessDay.is_year_end
Return boolean whether a timestamp occurs on the year end.
CustomBusinessHour#
CustomBusinessHour
DateOffset subclass representing possibly n custom business days.
Properties#
CustomBusinessHour.freqstr
Return a string representing the frequency.
CustomBusinessHour.kwds
Return a dict of extra parameters for the offset.
CustomBusinessHour.name
Return a string representing the base frequency.
CustomBusinessHour.nanos
CustomBusinessHour.normalize
CustomBusinessHour.rule_code
CustomBusinessHour.n
CustomBusinessHour.weekmask
CustomBusinessHour.calendar
CustomBusinessHour.holidays
CustomBusinessHour.start
CustomBusinessHour.end
Methods#
CustomBusinessHour.apply
CustomBusinessHour.apply_index
(DEPRECATED) Vectorized apply of DateOffset to DatetimeIndex.
CustomBusinessHour.copy
Return a copy of the frequency.
CustomBusinessHour.isAnchored
CustomBusinessHour.onOffset
CustomBusinessHour.is_anchored
Return boolean whether the frequency is a unit frequency (n=1).
CustomBusinessHour.is_on_offset
Return boolean whether a timestamp intersects with this frequency.
CustomBusinessHour.__call__(*args, **kwargs)
Call self as a function.
CustomBusinessHour.is_month_start
Return boolean whether a timestamp occurs on the month start.
CustomBusinessHour.is_month_end
Return boolean whether a timestamp occurs on the month end.
CustomBusinessHour.is_quarter_start
Return boolean whether a timestamp occurs on the quarter start.
CustomBusinessHour.is_quarter_end
Return boolean whether a timestamp occurs on the quarter end.
CustomBusinessHour.is_year_start
Return boolean whether a timestamp occurs on the year start.
CustomBusinessHour.is_year_end
Return boolean whether a timestamp occurs on the year end.
MonthEnd#
MonthEnd
DateOffset of one month end.
Properties#
MonthEnd.freqstr
Return a string representing the frequency.
MonthEnd.kwds
Return a dict of extra parameters for the offset.
MonthEnd.name
Return a string representing the base frequency.
MonthEnd.nanos
MonthEnd.normalize
MonthEnd.rule_code
MonthEnd.n
Methods#
MonthEnd.apply
MonthEnd.apply_index
(DEPRECATED) Vectorized apply of DateOffset to DatetimeIndex.
MonthEnd.copy
Return a copy of the frequency.
MonthEnd.isAnchored
MonthEnd.onOffset
MonthEnd.is_anchored
Return boolean whether the frequency is a unit frequency (n=1).
MonthEnd.is_on_offset
Return boolean whether a timestamp intersects with this frequency.
MonthEnd.__call__(*args, **kwargs)
Call self as a function.
MonthEnd.is_month_start
Return boolean whether a timestamp occurs on the month start.
MonthEnd.is_month_end
Return boolean whether a timestamp occurs on the month end.
MonthEnd.is_quarter_start
Return boolean whether a timestamp occurs on the quarter start.
MonthEnd.is_quarter_end
Return boolean whether a timestamp occurs on the quarter end.
MonthEnd.is_year_start
Return boolean whether a timestamp occurs on the year start.
MonthEnd.is_year_end
Return boolean whether a timestamp occurs on the year end.
MonthBegin#
MonthBegin
DateOffset of one month at beginning.
Properties#
MonthBegin.freqstr
Return a string representing the frequency.
MonthBegin.kwds
Return a dict of extra parameters for the offset.
MonthBegin.name
Return a string representing the base frequency.
MonthBegin.nanos
MonthBegin.normalize
MonthBegin.rule_code
MonthBegin.n
Methods#
MonthBegin.apply
MonthBegin.apply_index
(DEPRECATED) Vectorized apply of DateOffset to DatetimeIndex.
MonthBegin.copy
Return a copy of the frequency.
MonthBegin.isAnchored
MonthBegin.onOffset
MonthBegin.is_anchored
Return boolean whether the frequency is a unit frequency (n=1).
MonthBegin.is_on_offset
Return boolean whether a timestamp intersects with this frequency.
MonthBegin.__call__(*args, **kwargs)
Call self as a function.
MonthBegin.is_month_start
Return boolean whether a timestamp occurs on the month start.
MonthBegin.is_month_end
Return boolean whether a timestamp occurs on the month end.
MonthBegin.is_quarter_start
Return boolean whether a timestamp occurs on the quarter start.
MonthBegin.is_quarter_end
Return boolean whether a timestamp occurs on the quarter end.
MonthBegin.is_year_start
Return boolean whether a timestamp occurs on the year start.
MonthBegin.is_year_end
Return boolean whether a timestamp occurs on the year end.
BusinessMonthEnd#
BusinessMonthEnd
DateOffset increments between the last business day of the month.
Alias:
BMonthEnd
alias of pandas._libs.tslibs.offsets.BusinessMonthEnd
Properties#
BusinessMonthEnd.freqstr
Return a string representing the frequency.
BusinessMonthEnd.kwds
Return a dict of extra parameters for the offset.
BusinessMonthEnd.name
Return a string representing the base frequency.
BusinessMonthEnd.nanos
BusinessMonthEnd.normalize
BusinessMonthEnd.rule_code
BusinessMonthEnd.n
Methods#
BusinessMonthEnd.apply
BusinessMonthEnd.apply_index
(DEPRECATED) Vectorized apply of DateOffset to DatetimeIndex.
BusinessMonthEnd.copy
Return a copy of the frequency.
BusinessMonthEnd.isAnchored
BusinessMonthEnd.onOffset
BusinessMonthEnd.is_anchored
Return boolean whether the frequency is a unit frequency (n=1).
BusinessMonthEnd.is_on_offset
Return boolean whether a timestamp intersects with this frequency.
BusinessMonthEnd.__call__(*args, **kwargs)
Call self as a function.
BusinessMonthEnd.is_month_start
Return boolean whether a timestamp occurs on the month start.
BusinessMonthEnd.is_month_end
Return boolean whether a timestamp occurs on the month end.
BusinessMonthEnd.is_quarter_start
Return boolean whether a timestamp occurs on the quarter start.
BusinessMonthEnd.is_quarter_end
Return boolean whether a timestamp occurs on the quarter end.
BusinessMonthEnd.is_year_start
Return boolean whether a timestamp occurs on the year start.
BusinessMonthEnd.is_year_end
Return boolean whether a timestamp occurs on the year end.
BusinessMonthBegin#
BusinessMonthBegin
DateOffset of one month at the first business day.
Alias:
BMonthBegin
alias of pandas._libs.tslibs.offsets.BusinessMonthBegin
Properties#
BusinessMonthBegin.freqstr
Return a string representing the frequency.
BusinessMonthBegin.kwds
Return a dict of extra parameters for the offset.
BusinessMonthBegin.name
Return a string representing the base frequency.
BusinessMonthBegin.nanos
BusinessMonthBegin.normalize
BusinessMonthBegin.rule_code
BusinessMonthBegin.n
Methods#
BusinessMonthBegin.apply
BusinessMonthBegin.apply_index
(DEPRECATED) Vectorized apply of DateOffset to DatetimeIndex.
BusinessMonthBegin.copy
Return a copy of the frequency.
BusinessMonthBegin.isAnchored
BusinessMonthBegin.onOffset
BusinessMonthBegin.is_anchored
Return boolean whether the frequency is a unit frequency (n=1).
BusinessMonthBegin.is_on_offset
Return boolean whether a timestamp intersects with this frequency.
BusinessMonthBegin.__call__(*args, **kwargs)
Call self as a function.
BusinessMonthBegin.is_month_start
Return boolean whether a timestamp occurs on the month start.
BusinessMonthBegin.is_month_end
Return boolean whether a timestamp occurs on the month end.
BusinessMonthBegin.is_quarter_start
Return boolean whether a timestamp occurs on the quarter start.
BusinessMonthBegin.is_quarter_end
Return boolean whether a timestamp occurs on the quarter end.
BusinessMonthBegin.is_year_start
Return boolean whether a timestamp occurs on the year start.
BusinessMonthBegin.is_year_end
Return boolean whether a timestamp occurs on the year end.
CustomBusinessMonthEnd#
CustomBusinessMonthEnd
Attributes
Alias:
CBMonthEnd
alias of pandas._libs.tslibs.offsets.CustomBusinessMonthEnd
Properties#
CustomBusinessMonthEnd.freqstr
Return a string representing the frequency.
CustomBusinessMonthEnd.kwds
Return a dict of extra parameters for the offset.
CustomBusinessMonthEnd.m_offset
CustomBusinessMonthEnd.name
Return a string representing the base frequency.
CustomBusinessMonthEnd.nanos
CustomBusinessMonthEnd.normalize
CustomBusinessMonthEnd.rule_code
CustomBusinessMonthEnd.n
CustomBusinessMonthEnd.weekmask
CustomBusinessMonthEnd.calendar
CustomBusinessMonthEnd.holidays
Methods#
CustomBusinessMonthEnd.apply
CustomBusinessMonthEnd.apply_index
(DEPRECATED) Vectorized apply of DateOffset to DatetimeIndex.
CustomBusinessMonthEnd.copy
Return a copy of the frequency.
CustomBusinessMonthEnd.isAnchored
CustomBusinessMonthEnd.onOffset
CustomBusinessMonthEnd.is_anchored
Return boolean whether the frequency is a unit frequency (n=1).
CustomBusinessMonthEnd.is_on_offset
Return boolean whether a timestamp intersects with this frequency.
CustomBusinessMonthEnd.__call__(*args, **kwargs)
Call self as a function.
CustomBusinessMonthEnd.is_month_start
Return boolean whether a timestamp occurs on the month start.
CustomBusinessMonthEnd.is_month_end
Return boolean whether a timestamp occurs on the month end.
CustomBusinessMonthEnd.is_quarter_start
Return boolean whether a timestamp occurs on the quarter start.
CustomBusinessMonthEnd.is_quarter_end
Return boolean whether a timestamp occurs on the quarter end.
CustomBusinessMonthEnd.is_year_start
Return boolean whether a timestamp occurs on the year start.
CustomBusinessMonthEnd.is_year_end
Return boolean whether a timestamp occurs on the year end.
CustomBusinessMonthBegin#
CustomBusinessMonthBegin
Attributes
Alias:
CBMonthBegin
alias of pandas._libs.tslibs.offsets.CustomBusinessMonthBegin
Properties#
CustomBusinessMonthBegin.freqstr
Return a string representing the frequency.
CustomBusinessMonthBegin.kwds
Return a dict of extra parameters for the offset.
CustomBusinessMonthBegin.m_offset
CustomBusinessMonthBegin.name
Return a string representing the base frequency.
CustomBusinessMonthBegin.nanos
CustomBusinessMonthBegin.normalize
CustomBusinessMonthBegin.rule_code
CustomBusinessMonthBegin.n
CustomBusinessMonthBegin.weekmask
CustomBusinessMonthBegin.calendar
CustomBusinessMonthBegin.holidays
Methods#
CustomBusinessMonthBegin.apply
CustomBusinessMonthBegin.apply_index
(DEPRECATED) Vectorized apply of DateOffset to DatetimeIndex.
CustomBusinessMonthBegin.copy
Return a copy of the frequency.
CustomBusinessMonthBegin.isAnchored
CustomBusinessMonthBegin.onOffset
CustomBusinessMonthBegin.is_anchored
Return boolean whether the frequency is a unit frequency (n=1).
CustomBusinessMonthBegin.is_on_offset
Return boolean whether a timestamp intersects with this frequency.
CustomBusinessMonthBegin.__call__(*args, ...)
Call self as a function.
CustomBusinessMonthBegin.is_month_start
Return boolean whether a timestamp occurs on the month start.
CustomBusinessMonthBegin.is_month_end
Return boolean whether a timestamp occurs on the month end.
CustomBusinessMonthBegin.is_quarter_start
Return boolean whether a timestamp occurs on the quarter start.
CustomBusinessMonthBegin.is_quarter_end
Return boolean whether a timestamp occurs on the quarter end.
CustomBusinessMonthBegin.is_year_start
Return boolean whether a timestamp occurs on the year start.
CustomBusinessMonthBegin.is_year_end
Return boolean whether a timestamp occurs on the year end.
SemiMonthEnd#
SemiMonthEnd
Two DateOffset's per month repeating on the last day of the month & day_of_month.
Properties#
SemiMonthEnd.freqstr
Return a string representing the frequency.
SemiMonthEnd.kwds
Return a dict of extra parameters for the offset.
SemiMonthEnd.name
Return a string representing the base frequency.
SemiMonthEnd.nanos
SemiMonthEnd.normalize
SemiMonthEnd.rule_code
SemiMonthEnd.n
SemiMonthEnd.day_of_month
Methods#
SemiMonthEnd.apply
SemiMonthEnd.apply_index
(DEPRECATED) Vectorized apply of DateOffset to DatetimeIndex.
SemiMonthEnd.copy
Return a copy of the frequency.
SemiMonthEnd.isAnchored
SemiMonthEnd.onOffset
SemiMonthEnd.is_anchored
Return boolean whether the frequency is a unit frequency (n=1).
SemiMonthEnd.is_on_offset
Return boolean whether a timestamp intersects with this frequency.
SemiMonthEnd.__call__(*args, **kwargs)
Call self as a function.
SemiMonthEnd.is_month_start
Return boolean whether a timestamp occurs on the month start.
SemiMonthEnd.is_month_end
Return boolean whether a timestamp occurs on the month end.
SemiMonthEnd.is_quarter_start
Return boolean whether a timestamp occurs on the quarter start.
SemiMonthEnd.is_quarter_end
Return boolean whether a timestamp occurs on the quarter end.
SemiMonthEnd.is_year_start
Return boolean whether a timestamp occurs on the year start.
SemiMonthEnd.is_year_end
Return boolean whether a timestamp occurs on the year end.
SemiMonthBegin#
SemiMonthBegin
Two DateOffset's per month repeating on the first day of the month & day_of_month.
Properties#
SemiMonthBegin.freqstr
Return a string representing the frequency.
SemiMonthBegin.kwds
Return a dict of extra parameters for the offset.
SemiMonthBegin.name
Return a string representing the base frequency.
SemiMonthBegin.nanos
SemiMonthBegin.normalize
SemiMonthBegin.rule_code
SemiMonthBegin.n
SemiMonthBegin.day_of_month
Methods#
SemiMonthBegin.apply
SemiMonthBegin.apply_index
(DEPRECATED) Vectorized apply of DateOffset to DatetimeIndex.
SemiMonthBegin.copy
Return a copy of the frequency.
SemiMonthBegin.isAnchored
SemiMonthBegin.onOffset
SemiMonthBegin.is_anchored
Return boolean whether the frequency is a unit frequency (n=1).
SemiMonthBegin.is_on_offset
Return boolean whether a timestamp intersects with this frequency.
SemiMonthBegin.__call__(*args, **kwargs)
Call self as a function.
SemiMonthBegin.is_month_start
Return boolean whether a timestamp occurs on the month start.
SemiMonthBegin.is_month_end
Return boolean whether a timestamp occurs on the month end.
SemiMonthBegin.is_quarter_start
Return boolean whether a timestamp occurs on the quarter start.
SemiMonthBegin.is_quarter_end
Return boolean whether a timestamp occurs on the quarter end.
SemiMonthBegin.is_year_start
Return boolean whether a timestamp occurs on the year start.
SemiMonthBegin.is_year_end
Return boolean whether a timestamp occurs on the year end.
Week#
Week
Weekly offset.
Properties#
Week.freqstr
Return a string representing the frequency.
Week.kwds
Return a dict of extra parameters for the offset.
Week.name
Return a string representing the base frequency.
Week.nanos
Week.normalize
Week.rule_code
Week.n
Week.weekday
Methods#
Week.apply
Week.apply_index
(DEPRECATED) Vectorized apply of DateOffset to DatetimeIndex.
Week.copy
Return a copy of the frequency.
Week.isAnchored
Week.onOffset
Week.is_anchored
Return boolean whether the frequency is a unit frequency (n=1).
Week.is_on_offset
Return boolean whether a timestamp intersects with this frequency.
Week.__call__(*args, **kwargs)
Call self as a function.
Week.is_month_start
Return boolean whether a timestamp occurs on the month start.
Week.is_month_end
Return boolean whether a timestamp occurs on the month end.
Week.is_quarter_start
Return boolean whether a timestamp occurs on the quarter start.
Week.is_quarter_end
Return boolean whether a timestamp occurs on the quarter end.
Week.is_year_start
Return boolean whether a timestamp occurs on the year start.
Week.is_year_end
Return boolean whether a timestamp occurs on the year end.
WeekOfMonth#
WeekOfMonth
Describes monthly dates like "the Tuesday of the 2nd week of each month".
Properties#
WeekOfMonth.freqstr
Return a string representing the frequency.
WeekOfMonth.kwds
Return a dict of extra parameters for the offset.
WeekOfMonth.name
Return a string representing the base frequency.
WeekOfMonth.nanos
WeekOfMonth.normalize
WeekOfMonth.rule_code
WeekOfMonth.n
WeekOfMonth.week
Methods#
WeekOfMonth.apply
WeekOfMonth.apply_index
(DEPRECATED) Vectorized apply of DateOffset to DatetimeIndex.
WeekOfMonth.copy
Return a copy of the frequency.
WeekOfMonth.isAnchored
WeekOfMonth.onOffset
WeekOfMonth.is_anchored
Return boolean whether the frequency is a unit frequency (n=1).
WeekOfMonth.is_on_offset
Return boolean whether a timestamp intersects with this frequency.
WeekOfMonth.__call__(*args, **kwargs)
Call self as a function.
WeekOfMonth.weekday
WeekOfMonth.is_month_start
Return boolean whether a timestamp occurs on the month start.
WeekOfMonth.is_month_end
Return boolean whether a timestamp occurs on the month end.
WeekOfMonth.is_quarter_start
Return boolean whether a timestamp occurs on the quarter start.
WeekOfMonth.is_quarter_end
Return boolean whether a timestamp occurs on the quarter end.
WeekOfMonth.is_year_start
Return boolean whether a timestamp occurs on the year start.
WeekOfMonth.is_year_end
Return boolean whether a timestamp occurs on the year end.
LastWeekOfMonth#
LastWeekOfMonth
Describes monthly dates in last week of month.
Properties#
LastWeekOfMonth.freqstr
Return a string representing the frequency.
LastWeekOfMonth.kwds
Return a dict of extra parameters for the offset.
LastWeekOfMonth.name
Return a string representing the base frequency.
LastWeekOfMonth.nanos
LastWeekOfMonth.normalize
LastWeekOfMonth.rule_code
LastWeekOfMonth.n
LastWeekOfMonth.weekday
LastWeekOfMonth.week
Methods#
LastWeekOfMonth.apply
LastWeekOfMonth.apply_index
(DEPRECATED) Vectorized apply of DateOffset to DatetimeIndex.
LastWeekOfMonth.copy
Return a copy of the frequency.
LastWeekOfMonth.isAnchored
LastWeekOfMonth.onOffset
LastWeekOfMonth.is_anchored
Return boolean whether the frequency is a unit frequency (n=1).
LastWeekOfMonth.is_on_offset
Return boolean whether a timestamp intersects with this frequency.
LastWeekOfMonth.__call__(*args, **kwargs)
Call self as a function.
LastWeekOfMonth.is_month_start
Return boolean whether a timestamp occurs on the month start.
LastWeekOfMonth.is_month_end
Return boolean whether a timestamp occurs on the month end.
LastWeekOfMonth.is_quarter_start
Return boolean whether a timestamp occurs on the quarter start.
LastWeekOfMonth.is_quarter_end
Return boolean whether a timestamp occurs on the quarter end.
LastWeekOfMonth.is_year_start
Return boolean whether a timestamp occurs on the year start.
LastWeekOfMonth.is_year_end
Return boolean whether a timestamp occurs on the year end.
BQuarterEnd#
BQuarterEnd
DateOffset increments between the last business day of each Quarter.
Properties#
BQuarterEnd.freqstr
Return a string representing the frequency.
BQuarterEnd.kwds
Return a dict of extra parameters for the offset.
BQuarterEnd.name
Return a string representing the base frequency.
BQuarterEnd.nanos
BQuarterEnd.normalize
BQuarterEnd.rule_code
BQuarterEnd.n
BQuarterEnd.startingMonth
Methods#
BQuarterEnd.apply
BQuarterEnd.apply_index
(DEPRECATED) Vectorized apply of DateOffset to DatetimeIndex.
BQuarterEnd.copy
Return a copy of the frequency.
BQuarterEnd.isAnchored
BQuarterEnd.onOffset
BQuarterEnd.is_anchored
Return boolean whether the frequency is a unit frequency (n=1).
BQuarterEnd.is_on_offset
Return boolean whether a timestamp intersects with this frequency.
BQuarterEnd.__call__(*args, **kwargs)
Call self as a function.
BQuarterEnd.is_month_start
Return boolean whether a timestamp occurs on the month start.
BQuarterEnd.is_month_end
Return boolean whether a timestamp occurs on the month end.
BQuarterEnd.is_quarter_start
Return boolean whether a timestamp occurs on the quarter start.
BQuarterEnd.is_quarter_end
Return boolean whether a timestamp occurs on the quarter end.
BQuarterEnd.is_year_start
Return boolean whether a timestamp occurs on the year start.
BQuarterEnd.is_year_end
Return boolean whether a timestamp occurs on the year end.
BQuarterBegin#
BQuarterBegin
DateOffset increments between the first business day of each Quarter.
Properties#
BQuarterBegin.freqstr
Return a string representing the frequency.
BQuarterBegin.kwds
Return a dict of extra parameters for the offset.
BQuarterBegin.name
Return a string representing the base frequency.
BQuarterBegin.nanos
BQuarterBegin.normalize
BQuarterBegin.rule_code
BQuarterBegin.n
BQuarterBegin.startingMonth
Methods#
BQuarterBegin.apply
BQuarterBegin.apply_index
(DEPRECATED) Vectorized apply of DateOffset to DatetimeIndex.
BQuarterBegin.copy
Return a copy of the frequency.
BQuarterBegin.isAnchored
BQuarterBegin.onOffset
BQuarterBegin.is_anchored
Return boolean whether the frequency is a unit frequency (n=1).
BQuarterBegin.is_on_offset
Return boolean whether a timestamp intersects with this frequency.
BQuarterBegin.__call__(*args, **kwargs)
Call self as a function.
BQuarterBegin.is_month_start
Return boolean whether a timestamp occurs on the month start.
BQuarterBegin.is_month_end
Return boolean whether a timestamp occurs on the month end.
BQuarterBegin.is_quarter_start
Return boolean whether a timestamp occurs on the quarter start.
BQuarterBegin.is_quarter_end
Return boolean whether a timestamp occurs on the quarter end.
BQuarterBegin.is_year_start
Return boolean whether a timestamp occurs on the year start.
BQuarterBegin.is_year_end
Return boolean whether a timestamp occurs on the year end.
QuarterEnd#
QuarterEnd
DateOffset increments between Quarter end dates.
Properties#
QuarterEnd.freqstr
Return a string representing the frequency.
QuarterEnd.kwds
Return a dict of extra parameters for the offset.
QuarterEnd.name
Return a string representing the base frequency.
QuarterEnd.nanos
QuarterEnd.normalize
QuarterEnd.rule_code
QuarterEnd.n
QuarterEnd.startingMonth
Methods#
QuarterEnd.apply
QuarterEnd.apply_index
(DEPRECATED) Vectorized apply of DateOffset to DatetimeIndex.
QuarterEnd.copy
Return a copy of the frequency.
QuarterEnd.isAnchored
QuarterEnd.onOffset
QuarterEnd.is_anchored
Return boolean whether the frequency is a unit frequency (n=1).
QuarterEnd.is_on_offset
Return boolean whether a timestamp intersects with this frequency.
QuarterEnd.__call__(*args, **kwargs)
Call self as a function.
QuarterEnd.is_month_start
Return boolean whether a timestamp occurs on the month start.
QuarterEnd.is_month_end
Return boolean whether a timestamp occurs on the month end.
QuarterEnd.is_quarter_start
Return boolean whether a timestamp occurs on the quarter start.
QuarterEnd.is_quarter_end
Return boolean whether a timestamp occurs on the quarter end.
QuarterEnd.is_year_start
Return boolean whether a timestamp occurs on the year start.
QuarterEnd.is_year_end
Return boolean whether a timestamp occurs on the year end.
QuarterBegin#
QuarterBegin
DateOffset increments between Quarter start dates.
Properties#
QuarterBegin.freqstr
Return a string representing the frequency.
QuarterBegin.kwds
Return a dict of extra parameters for the offset.
QuarterBegin.name
Return a string representing the base frequency.
QuarterBegin.nanos
QuarterBegin.normalize
QuarterBegin.rule_code
QuarterBegin.n
QuarterBegin.startingMonth
Methods#
QuarterBegin.apply
QuarterBegin.apply_index
(DEPRECATED) Vectorized apply of DateOffset to DatetimeIndex.
QuarterBegin.copy
Return a copy of the frequency.
QuarterBegin.isAnchored
QuarterBegin.onOffset
QuarterBegin.is_anchored
Return boolean whether the frequency is a unit frequency (n=1).
QuarterBegin.is_on_offset
Return boolean whether a timestamp intersects with this frequency.
QuarterBegin.__call__(*args, **kwargs)
Call self as a function.
QuarterBegin.is_month_start
Return boolean whether a timestamp occurs on the month start.
QuarterBegin.is_month_end
Return boolean whether a timestamp occurs on the month end.
QuarterBegin.is_quarter_start
Return boolean whether a timestamp occurs on the quarter start.
QuarterBegin.is_quarter_end
Return boolean whether a timestamp occurs on the quarter end.
QuarterBegin.is_year_start
Return boolean whether a timestamp occurs on the year start.
QuarterBegin.is_year_end
Return boolean whether a timestamp occurs on the year end.
BYearEnd#
BYearEnd
DateOffset increments between the last business day of the year.
Properties#
BYearEnd.freqstr
Return a string representing the frequency.
BYearEnd.kwds
Return a dict of extra parameters for the offset.
BYearEnd.name
Return a string representing the base frequency.
BYearEnd.nanos
BYearEnd.normalize
BYearEnd.rule_code
BYearEnd.n
BYearEnd.month
Methods#
BYearEnd.apply
BYearEnd.apply_index
(DEPRECATED) Vectorized apply of DateOffset to DatetimeIndex.
BYearEnd.copy
Return a copy of the frequency.
BYearEnd.isAnchored
BYearEnd.onOffset
BYearEnd.is_anchored
Return boolean whether the frequency is a unit frequency (n=1).
BYearEnd.is_on_offset
Return boolean whether a timestamp intersects with this frequency.
BYearEnd.__call__(*args, **kwargs)
Call self as a function.
BYearEnd.is_month_start
Return boolean whether a timestamp occurs on the month start.
BYearEnd.is_month_end
Return boolean whether a timestamp occurs on the month end.
BYearEnd.is_quarter_start
Return boolean whether a timestamp occurs on the quarter start.
BYearEnd.is_quarter_end
Return boolean whether a timestamp occurs on the quarter end.
BYearEnd.is_year_start
Return boolean whether a timestamp occurs on the year start.
BYearEnd.is_year_end
Return boolean whether a timestamp occurs on the year end.
BYearBegin#
BYearBegin
DateOffset increments between the first business day of the year.
Properties#
BYearBegin.freqstr
Return a string representing the frequency.
BYearBegin.kwds
Return a dict of extra parameters for the offset.
BYearBegin.name
Return a string representing the base frequency.
BYearBegin.nanos
BYearBegin.normalize
BYearBegin.rule_code
BYearBegin.n
BYearBegin.month
Methods#
BYearBegin.apply
BYearBegin.apply_index
(DEPRECATED) Vectorized apply of DateOffset to DatetimeIndex.
BYearBegin.copy
Return a copy of the frequency.
BYearBegin.isAnchored
BYearBegin.onOffset
BYearBegin.is_anchored
Return boolean whether the frequency is a unit frequency (n=1).
BYearBegin.is_on_offset
Return boolean whether a timestamp intersects with this frequency.
BYearBegin.__call__(*args, **kwargs)
Call self as a function.
BYearBegin.is_month_start
Return boolean whether a timestamp occurs on the month start.
BYearBegin.is_month_end
Return boolean whether a timestamp occurs on the month end.
BYearBegin.is_quarter_start
Return boolean whether a timestamp occurs on the quarter start.
BYearBegin.is_quarter_end
Return boolean whether a timestamp occurs on the quarter end.
BYearBegin.is_year_start
Return boolean whether a timestamp occurs on the year start.
BYearBegin.is_year_end
Return boolean whether a timestamp occurs on the year end.
YearEnd#
YearEnd
DateOffset increments between calendar year ends.
Properties#
YearEnd.freqstr
Return a string representing the frequency.
YearEnd.kwds
Return a dict of extra parameters for the offset.
YearEnd.name
Return a string representing the base frequency.
YearEnd.nanos
YearEnd.normalize
YearEnd.rule_code
YearEnd.n
YearEnd.month
Methods#
YearEnd.apply
YearEnd.apply_index
(DEPRECATED) Vectorized apply of DateOffset to DatetimeIndex.
YearEnd.copy
Return a copy of the frequency.
YearEnd.isAnchored
YearEnd.onOffset
YearEnd.is_anchored
Return boolean whether the frequency is a unit frequency (n=1).
YearEnd.is_on_offset
Return boolean whether a timestamp intersects with this frequency.
YearEnd.__call__(*args, **kwargs)
Call self as a function.
YearEnd.is_month_start
Return boolean whether a timestamp occurs on the month start.
YearEnd.is_month_end
Return boolean whether a timestamp occurs on the month end.
YearEnd.is_quarter_start
Return boolean whether a timestamp occurs on the quarter start.
YearEnd.is_quarter_end
Return boolean whether a timestamp occurs on the quarter end.
YearEnd.is_year_start
Return boolean whether a timestamp occurs on the year start.
YearEnd.is_year_end
Return boolean whether a timestamp occurs on the year end.
YearBegin#
YearBegin
DateOffset increments between calendar year begin dates.
Properties#
YearBegin.freqstr
Return a string representing the frequency.
YearBegin.kwds
Return a dict of extra parameters for the offset.
YearBegin.name
Return a string representing the base frequency.
YearBegin.nanos
YearBegin.normalize
YearBegin.rule_code
YearBegin.n
YearBegin.month
Methods#
YearBegin.apply
YearBegin.apply_index
(DEPRECATED) Vectorized apply of DateOffset to DatetimeIndex.
YearBegin.copy
Return a copy of the frequency.
YearBegin.isAnchored
YearBegin.onOffset
YearBegin.is_anchored
Return boolean whether the frequency is a unit frequency (n=1).
YearBegin.is_on_offset
Return boolean whether a timestamp intersects with this frequency.
YearBegin.__call__(*args, **kwargs)
Call self as a function.
YearBegin.is_month_start
Return boolean whether a timestamp occurs on the month start.
YearBegin.is_month_end
Return boolean whether a timestamp occurs on the month end.
YearBegin.is_quarter_start
Return boolean whether a timestamp occurs on the quarter start.
YearBegin.is_quarter_end
Return boolean whether a timestamp occurs on the quarter end.
YearBegin.is_year_start
Return boolean whether a timestamp occurs on the year start.
YearBegin.is_year_end
Return boolean whether a timestamp occurs on the year end.
FY5253#
FY5253
Describes 52-53 week fiscal year.
Properties#
FY5253.freqstr
Return a string representing the frequency.
FY5253.kwds
Return a dict of extra parameters for the offset.
FY5253.name
Return a string representing the base frequency.
FY5253.nanos
FY5253.normalize
FY5253.rule_code
FY5253.n
FY5253.startingMonth
FY5253.variation
FY5253.weekday
Methods#
FY5253.apply
FY5253.apply_index
(DEPRECATED) Vectorized apply of DateOffset to DatetimeIndex.
FY5253.copy
Return a copy of the frequency.
FY5253.get_rule_code_suffix
FY5253.get_year_end
FY5253.isAnchored
FY5253.onOffset
FY5253.is_anchored
Return boolean whether the frequency is a unit frequency (n=1).
FY5253.is_on_offset
Return boolean whether a timestamp intersects with this frequency.
FY5253.__call__(*args, **kwargs)
Call self as a function.
FY5253.is_month_start
Return boolean whether a timestamp occurs on the month start.
FY5253.is_month_end
Return boolean whether a timestamp occurs on the month end.
FY5253.is_quarter_start
Return boolean whether a timestamp occurs on the quarter start.
FY5253.is_quarter_end
Return boolean whether a timestamp occurs on the quarter end.
FY5253.is_year_start
Return boolean whether a timestamp occurs on the year start.
FY5253.is_year_end
Return boolean whether a timestamp occurs on the year end.
FY5253Quarter#
FY5253Quarter
DateOffset increments between business quarter dates for 52-53 week fiscal year.
Properties#
FY5253Quarter.freqstr
Return a string representing the frequency.
FY5253Quarter.kwds
Return a dict of extra parameters for the offset.
FY5253Quarter.name
Return a string representing the base frequency.
FY5253Quarter.nanos
FY5253Quarter.normalize
FY5253Quarter.rule_code
FY5253Quarter.n
FY5253Quarter.qtr_with_extra_week
FY5253Quarter.startingMonth
FY5253Quarter.variation
FY5253Quarter.weekday
Methods#
FY5253Quarter.apply
FY5253Quarter.apply_index
(DEPRECATED) Vectorized apply of DateOffset to DatetimeIndex.
FY5253Quarter.copy
Return a copy of the frequency.
FY5253Quarter.get_rule_code_suffix
FY5253Quarter.get_weeks
FY5253Quarter.isAnchored
FY5253Quarter.onOffset
FY5253Quarter.is_anchored
Return boolean whether the frequency is a unit frequency (n=1).
FY5253Quarter.is_on_offset
Return boolean whether a timestamp intersects with this frequency.
FY5253Quarter.year_has_extra_week
FY5253Quarter.__call__(*args, **kwargs)
Call self as a function.
FY5253Quarter.is_month_start
Return boolean whether a timestamp occurs on the month start.
FY5253Quarter.is_month_end
Return boolean whether a timestamp occurs on the month end.
FY5253Quarter.is_quarter_start
Return boolean whether a timestamp occurs on the quarter start.
FY5253Quarter.is_quarter_end
Return boolean whether a timestamp occurs on the quarter end.
FY5253Quarter.is_year_start
Return boolean whether a timestamp occurs on the year start.
FY5253Quarter.is_year_end
Return boolean whether a timestamp occurs on the year end.
Easter#
Easter
DateOffset for the Easter holiday using logic defined in dateutil.
Properties#
Easter.freqstr
Return a string representing the frequency.
Easter.kwds
Return a dict of extra parameters for the offset.
Easter.name
Return a string representing the base frequency.
Easter.nanos
Easter.normalize
Easter.rule_code
Easter.n
Methods#
Easter.apply
Easter.apply_index
(DEPRECATED) Vectorized apply of DateOffset to DatetimeIndex.
Easter.copy
Return a copy of the frequency.
Easter.isAnchored
Easter.onOffset
Easter.is_anchored
Return boolean whether the frequency is a unit frequency (n=1).
Easter.is_on_offset
Return boolean whether a timestamp intersects with this frequency.
Easter.__call__(*args, **kwargs)
Call self as a function.
Easter.is_month_start
Return boolean whether a timestamp occurs on the month start.
Easter.is_month_end
Return boolean whether a timestamp occurs on the month end.
Easter.is_quarter_start
Return boolean whether a timestamp occurs on the quarter start.
Easter.is_quarter_end
Return boolean whether a timestamp occurs on the quarter end.
Easter.is_year_start
Return boolean whether a timestamp occurs on the year start.
Easter.is_year_end
Return boolean whether a timestamp occurs on the year end.
Tick#
Tick
Attributes
Properties#
Tick.delta
Tick.freqstr
Return a string representing the frequency.
Tick.kwds
Return a dict of extra parameters for the offset.
Tick.name
Return a string representing the base frequency.
Tick.nanos
Return an integer of the total number of nanoseconds.
Tick.normalize
Tick.rule_code
Tick.n
Methods#
Tick.copy
Return a copy of the frequency.
Tick.isAnchored
Tick.onOffset
Tick.is_anchored
Return boolean whether the frequency is a unit frequency (n=1).
Tick.is_on_offset
Return boolean whether a timestamp intersects with this frequency.
Tick.__call__(*args, **kwargs)
Call self as a function.
Tick.apply
Tick.apply_index
(DEPRECATED) Vectorized apply of DateOffset to DatetimeIndex.
Tick.is_month_start
Return boolean whether a timestamp occurs on the month start.
Tick.is_month_end
Return boolean whether a timestamp occurs on the month end.
Tick.is_quarter_start
Return boolean whether a timestamp occurs on the quarter start.
Tick.is_quarter_end
Return boolean whether a timestamp occurs on the quarter end.
Tick.is_year_start
Return boolean whether a timestamp occurs on the year start.
Tick.is_year_end
Return boolean whether a timestamp occurs on the year end.
Day#
Day
Attributes
Properties#
Day.delta
Day.freqstr
Return a string representing the frequency.
Day.kwds
Return a dict of extra parameters for the offset.
Day.name
Return a string representing the base frequency.
Day.nanos
Return an integer of the total number of nanoseconds.
Day.normalize
Day.rule_code
Day.n
Methods#
Day.copy
Return a copy of the frequency.
Day.isAnchored
Day.onOffset
Day.is_anchored
Return boolean whether the frequency is a unit frequency (n=1).
Day.is_on_offset
Return boolean whether a timestamp intersects with this frequency.
Day.__call__(*args, **kwargs)
Call self as a function.
Day.apply
Day.apply_index
(DEPRECATED) Vectorized apply of DateOffset to DatetimeIndex.
Day.is_month_start
Return boolean whether a timestamp occurs on the month start.
Day.is_month_end
Return boolean whether a timestamp occurs on the month end.
Day.is_quarter_start
Return boolean whether a timestamp occurs on the quarter start.
Day.is_quarter_end
Return boolean whether a timestamp occurs on the quarter end.
Day.is_year_start
Return boolean whether a timestamp occurs on the year start.
Day.is_year_end
Return boolean whether a timestamp occurs on the year end.
Hour#
Hour
Attributes
Properties#
Hour.delta
Hour.freqstr
Return a string representing the frequency.
Hour.kwds
Return a dict of extra parameters for the offset.
Hour.name
Return a string representing the base frequency.
Hour.nanos
Return an integer of the total number of nanoseconds.
Hour.normalize
Hour.rule_code
Hour.n
Methods#
Hour.copy
Return a copy of the frequency.
Hour.isAnchored
Hour.onOffset
Hour.is_anchored
Return boolean whether the frequency is a unit frequency (n=1).
Hour.is_on_offset
Return boolean whether a timestamp intersects with this frequency.
Hour.__call__(*args, **kwargs)
Call self as a function.
Hour.apply
Hour.apply_index
(DEPRECATED) Vectorized apply of DateOffset to DatetimeIndex.
Hour.is_month_start
Return boolean whether a timestamp occurs on the month start.
Hour.is_month_end
Return boolean whether a timestamp occurs on the month end.
Hour.is_quarter_start
Return boolean whether a timestamp occurs on the quarter start.
Hour.is_quarter_end
Return boolean whether a timestamp occurs on the quarter end.
Hour.is_year_start
Return boolean whether a timestamp occurs on the year start.
Hour.is_year_end
Return boolean whether a timestamp occurs on the year end.
Minute#
Minute
Attributes
Properties#
Minute.delta
Minute.freqstr
Return a string representing the frequency.
Minute.kwds
Return a dict of extra parameters for the offset.
Minute.name
Return a string representing the base frequency.
Minute.nanos
Return an integer of the total number of nanoseconds.
Minute.normalize
Minute.rule_code
Minute.n
Methods#
Minute.copy
Return a copy of the frequency.
Minute.isAnchored
Minute.onOffset
Minute.is_anchored
Return boolean whether the frequency is a unit frequency (n=1).
Minute.is_on_offset
Return boolean whether a timestamp intersects with this frequency.
Minute.__call__(*args, **kwargs)
Call self as a function.
Minute.apply
Minute.apply_index
(DEPRECATED) Vectorized apply of DateOffset to DatetimeIndex.
Minute.is_month_start
Return boolean whether a timestamp occurs on the month start.
Minute.is_month_end
Return boolean whether a timestamp occurs on the month end.
Minute.is_quarter_start
Return boolean whether a timestamp occurs on the quarter start.
Minute.is_quarter_end
Return boolean whether a timestamp occurs on the quarter end.
Minute.is_year_start
Return boolean whether a timestamp occurs on the year start.
Minute.is_year_end
Return boolean whether a timestamp occurs on the year end.
Second#
Second
Attributes
Properties#
Second.delta
Second.freqstr
Return a string representing the frequency.
Second.kwds
Return a dict of extra parameters for the offset.
Second.name
Return a string representing the base frequency.
Second.nanos
Return an integer of the total number of nanoseconds.
Second.normalize
Second.rule_code
Second.n
Methods#
Second.copy
Return a copy of the frequency.
Second.isAnchored
Second.onOffset
Second.is_anchored
Return boolean whether the frequency is a unit frequency (n=1).
Second.is_on_offset
Return boolean whether a timestamp intersects with this frequency.
Second.__call__(*args, **kwargs)
Call self as a function.
Second.apply
Second.apply_index
(DEPRECATED) Vectorized apply of DateOffset to DatetimeIndex.
Second.is_month_start
Return boolean whether a timestamp occurs on the month start.
Second.is_month_end
Return boolean whether a timestamp occurs on the month end.
Second.is_quarter_start
Return boolean whether a timestamp occurs on the quarter start.
Second.is_quarter_end
Return boolean whether a timestamp occurs on the quarter end.
Second.is_year_start
Return boolean whether a timestamp occurs on the year start.
Second.is_year_end
Return boolean whether a timestamp occurs on the year end.
Milli#
Milli
Attributes
Properties#
Milli.delta
Milli.freqstr
Return a string representing the frequency.
Milli.kwds
Return a dict of extra parameters for the offset.
Milli.name
Return a string representing the base frequency.
Milli.nanos
Return an integer of the total number of nanoseconds.
Milli.normalize
Milli.rule_code
Milli.n
Methods#
Milli.copy
Return a copy of the frequency.
Milli.isAnchored
Milli.onOffset
Milli.is_anchored
Return boolean whether the frequency is a unit frequency (n=1).
Milli.is_on_offset
Return boolean whether a timestamp intersects with this frequency.
Milli.__call__(*args, **kwargs)
Call self as a function.
Milli.apply
Milli.apply_index
(DEPRECATED) Vectorized apply of DateOffset to DatetimeIndex.
Milli.is_month_start
Return boolean whether a timestamp occurs on the month start.
Milli.is_month_end
Return boolean whether a timestamp occurs on the month end.
Milli.is_quarter_start
Return boolean whether a timestamp occurs on the quarter start.
Milli.is_quarter_end
Return boolean whether a timestamp occurs on the quarter end.
Milli.is_year_start
Return boolean whether a timestamp occurs on the year start.
Milli.is_year_end
Return boolean whether a timestamp occurs on the year end.
Micro#
Micro
Attributes
Properties#
Micro.delta
Micro.freqstr
Return a string representing the frequency.
Micro.kwds
Return a dict of extra parameters for the offset.
Micro.name
Return a string representing the base frequency.
Micro.nanos
Return an integer of the total number of nanoseconds.
Micro.normalize
Micro.rule_code
Micro.n
Methods#
Micro.copy
Return a copy of the frequency.
Micro.isAnchored
Micro.onOffset
Micro.is_anchored
Return boolean whether the frequency is a unit frequency (n=1).
Micro.is_on_offset
Return boolean whether a timestamp intersects with this frequency.
Micro.__call__(*args, **kwargs)
Call self as a function.
Micro.apply
Micro.apply_index
(DEPRECATED) Vectorized apply of DateOffset to DatetimeIndex.
Micro.is_month_start
Return boolean whether a timestamp occurs on the month start.
Micro.is_month_end
Return boolean whether a timestamp occurs on the month end.
Micro.is_quarter_start
Return boolean whether a timestamp occurs on the quarter start.
Micro.is_quarter_end
Return boolean whether a timestamp occurs on the quarter end.
Micro.is_year_start
Return boolean whether a timestamp occurs on the year start.
Micro.is_year_end
Return boolean whether a timestamp occurs on the year end.
Nano#
Nano
Attributes
Properties#
Nano.delta
Nano.freqstr
Return a string representing the frequency.
Nano.kwds
Return a dict of extra parameters for the offset.
Nano.name
Return a string representing the base frequency.
Nano.nanos
Return an integer of the total number of nanoseconds.
Nano.normalize
Nano.rule_code
Nano.n
Methods#
Nano.copy
Return a copy of the frequency.
Nano.isAnchored
Nano.onOffset
Nano.is_anchored
Return boolean whether the frequency is a unit frequency (n=1).
Nano.is_on_offset
Return boolean whether a timestamp intersects with this frequency.
Nano.__call__(*args, **kwargs)
Call self as a function.
Nano.apply
Nano.apply_index
(DEPRECATED) Vectorized apply of DateOffset to DatetimeIndex.
Nano.is_month_start
Return boolean whether a timestamp occurs on the month start.
Nano.is_month_end
Return boolean whether a timestamp occurs on the month end.
Nano.is_quarter_start
Return boolean whether a timestamp occurs on the quarter start.
Nano.is_quarter_end
Return boolean whether a timestamp occurs on the quarter end.
Nano.is_year_start
Return boolean whether a timestamp occurs on the year start.
Nano.is_year_end
Return boolean whether a timestamp occurs on the year end.
Frequencies#
to_offset
Return DateOffset object from string or datetime.timedelta object.
|
reference/offset_frequency.html
|
pandas.UInt32Dtype
|
`pandas.UInt32Dtype`
An ExtensionDtype for uint32 integer data.
|
class pandas.UInt32Dtype[source]#
An ExtensionDtype for uint32 integer data.
Changed in version 1.0.0: Now uses pandas.NA as its missing value,
rather than numpy.nan.
Attributes
None
Methods
None
|
reference/api/pandas.UInt32Dtype.html
|
pandas.DataFrame.to_hdf
|
`pandas.DataFrame.to_hdf`
Write the contained data to an HDF5 file using HDFStore.
Hierarchical Data Format (HDF) is self-describing, allowing an
application to interpret the structure and contents of a file with
no outside information. One HDF file can hold a mix of related objects
which can be accessed as a group or as individual objects.
```
>>> df = pd.DataFrame({'A': [1, 2, 3], 'B': [4, 5, 6]},
... index=['a', 'b', 'c'])
>>> df.to_hdf('data.h5', key='df', mode='w')
```
|
DataFrame.to_hdf(path_or_buf, key, mode='a', complevel=None, complib=None, append=False, format=None, index=True, min_itemsize=None, nan_rep=None, dropna=None, data_columns=None, errors='strict', encoding='UTF-8')[source]#
Write the contained data to an HDF5 file using HDFStore.
Hierarchical Data Format (HDF) is self-describing, allowing an
application to interpret the structure and contents of a file with
no outside information. One HDF file can hold a mix of related objects
which can be accessed as a group or as individual objects.
In order to add another DataFrame or Series to an existing HDF file
please use append mode and a different a key.
Warning
One can store a subclass of DataFrame or Series to HDF5,
but the type of the subclass is lost upon storing.
For more information see the user guide.
Parameters
path_or_bufstr or pandas.HDFStoreFile path or HDFStore object.
keystrIdentifier for the group in the store.
mode{‘a’, ‘w’, ‘r+’}, default ‘a’Mode to open file:
‘w’: write, a new file is created (an existing file with
the same name would be deleted).
‘a’: append, an existing file is opened for reading and
writing, and if the file does not exist it is created.
‘r+’: similar to ‘a’, but the file must already exist.
complevel{0-9}, default NoneSpecifies a compression level for data.
A value of 0 or None disables compression.
complib{‘zlib’, ‘lzo’, ‘bzip2’, ‘blosc’}, default ‘zlib’Specifies the compression library to be used.
As of v0.20.2 these additional compressors for Blosc are supported
(default if no compressor specified: ‘blosc:blosclz’):
{‘blosc:blosclz’, ‘blosc:lz4’, ‘blosc:lz4hc’, ‘blosc:snappy’,
‘blosc:zlib’, ‘blosc:zstd’}.
Specifying a compression library which is not available issues
a ValueError.
appendbool, default FalseFor Table formats, append the input data to the existing.
format{‘fixed’, ‘table’, None}, default ‘fixed’Possible values:
‘fixed’: Fixed format. Fast writing/reading. Not-appendable,
nor searchable.
‘table’: Table format. Write as a PyTables Table structure
which may perform worse but allow more flexible operations
like searching / selecting subsets of the data.
If None, pd.get_option(‘io.hdf.default_format’) is checked,
followed by fallback to “fixed”.
indexbool, default TrueWrite DataFrame index as a column.
min_itemsizedict or int, optionalMap column names to minimum string sizes for columns.
nan_repAny, optionalHow to represent null values as str.
Not allowed with append=True.
dropnabool, default False, optionalRemove missing values.
data_columnslist of columns or True, optionalList of columns to create as indexed data columns for on-disk
queries, or True to use all columns. By default only the axes
of the object are indexed. See
Query via data columns. for
more information.
Applicable only to format=’table’.
errorsstr, default ‘strict’Specifies how encoding and decoding errors are to be handled.
See the errors argument for open() for a full list
of options.
encodingstr, default “UTF-8”
See also
read_hdfRead from HDF file.
DataFrame.to_orcWrite a DataFrame to the binary orc format.
DataFrame.to_parquetWrite a DataFrame to the binary parquet format.
DataFrame.to_sqlWrite to a SQL table.
DataFrame.to_featherWrite out feather-format for DataFrames.
DataFrame.to_csvWrite out to a csv file.
Examples
>>> df = pd.DataFrame({'A': [1, 2, 3], 'B': [4, 5, 6]},
... index=['a', 'b', 'c'])
>>> df.to_hdf('data.h5', key='df', mode='w')
We can add another object to the same file:
>>> s = pd.Series([1, 2, 3, 4])
>>> s.to_hdf('data.h5', key='s')
Reading from HDF file:
>>> pd.read_hdf('data.h5', 'df')
A B
a 1 4
b 2 5
c 3 6
>>> pd.read_hdf('data.h5', 's')
0 1
1 2
2 3
3 4
dtype: int64
|
reference/api/pandas.DataFrame.to_hdf.html
|
pandas.api.types.is_list_like
|
`pandas.api.types.is_list_like`
Check if the object is list-like.
Objects that are considered list-like are for example Python
lists, tuples, sets, NumPy arrays, and Pandas Series.
```
>>> import datetime
>>> is_list_like([1, 2, 3])
True
>>> is_list_like({1, 2, 3})
True
>>> is_list_like(datetime.datetime(2017, 1, 1))
False
>>> is_list_like("foo")
False
>>> is_list_like(1)
False
>>> is_list_like(np.array([2]))
True
>>> is_list_like(np.array(2))
False
```
|
pandas.api.types.is_list_like()#
Check if the object is list-like.
Objects that are considered list-like are for example Python
lists, tuples, sets, NumPy arrays, and Pandas Series.
Strings and datetime objects, however, are not considered list-like.
Parameters
objobjectObject to check.
allow_setsbool, default TrueIf this parameter is False, sets will not be considered list-like.
Returns
boolWhether obj has list-like properties.
Examples
>>> import datetime
>>> is_list_like([1, 2, 3])
True
>>> is_list_like({1, 2, 3})
True
>>> is_list_like(datetime.datetime(2017, 1, 1))
False
>>> is_list_like("foo")
False
>>> is_list_like(1)
False
>>> is_list_like(np.array([2]))
True
>>> is_list_like(np.array(2))
False
|
reference/api/pandas.api.types.is_list_like.html
|
pandas.tseries.offsets.FY5253.rollback
|
`pandas.tseries.offsets.FY5253.rollback`
Roll provided date backward to next offset only if not on offset.
|
FY5253.rollback()#
Roll provided date backward to next offset only if not on offset.
Returns
TimeStampRolled timestamp if not on offset, otherwise unchanged timestamp.
|
reference/api/pandas.tseries.offsets.FY5253.rollback.html
|
pandas.io.formats.style.Styler.hide_columns
|
`pandas.io.formats.style.Styler.hide_columns`
Hide the column headers or specific keys in the columns from rendering.
|
Styler.hide_columns(subset=None, level=None, names=False)[source]#
Hide the column headers or specific keys in the columns from rendering.
This method has dual functionality:
if subset is None then the entire column headers row, or
specific levels, will be hidden whilst the data-values remain visible.
if a subset is given then those specific columns, including the
data-values will be hidden, whilst the column headers row remains visible.
Changed in version 1.3.0.
..deprecated:: 1.4.0This method should be replaced by hide(axis="columns", **kwargs)
Parameters
subsetlabel, array-like, IndexSlice, optionalA valid 1d input or single key along the columns axis within
DataFrame.loc[:, <subset>], to limit data to before applying
the function.
levelint, str, listThe level(s) to hide in a MultiIndex if hiding the entire column headers
row. Cannot be used simultaneously with subset.
New in version 1.4.0.
namesboolWhether to hide the column index name(s), in the case all column headers,
or some levels, are visible.
New in version 1.4.0.
Returns
selfStyler
See also
Styler.hideHide the entire index / columns, or specific rows / columns.
|
reference/api/pandas.io.formats.style.Styler.hide_columns.html
|
pandas.core.resample.Resampler.transform
|
`pandas.core.resample.Resampler.transform`
Call function producing a like-indexed Series on each group.
Return a Series with the transformed values.
```
>>> s = pd.Series([1, 2],
... index=pd.date_range('20180101',
... periods=2,
... freq='1h'))
>>> s
2018-01-01 00:00:00 1
2018-01-01 01:00:00 2
Freq: H, dtype: int64
```
|
Resampler.transform(arg, *args, **kwargs)[source]#
Call function producing a like-indexed Series on each group.
Return a Series with the transformed values.
Parameters
argfunctionTo apply to each group. Should return a Series with the same index.
Returns
transformedSeries
Examples
>>> s = pd.Series([1, 2],
... index=pd.date_range('20180101',
... periods=2,
... freq='1h'))
>>> s
2018-01-01 00:00:00 1
2018-01-01 01:00:00 2
Freq: H, dtype: int64
>>> resampled = s.resample('15min')
>>> resampled.transform(lambda x: (x - x.mean()) / x.std())
2018-01-01 00:00:00 NaN
2018-01-01 01:00:00 NaN
Freq: H, dtype: float64
|
reference/api/pandas.core.resample.Resampler.transform.html
|
Options and settings
|
Options and settings
|
API for configuring global behavior. See the User Guide for more.
Working with options#
describe_option(pat[, _print_desc])
Prints the description for one or more registered options.
reset_option(pat)
Reset one or more options to their default value.
get_option(pat)
Retrieves the value of the specified option.
set_option(pat, value)
Sets the value of the specified option.
option_context(*args)
Context manager to temporarily set options in the with statement context.
|
reference/options.html
|
pandas.Series.dt.daysinmonth
|
`pandas.Series.dt.daysinmonth`
The number of days in the month.
|
Series.dt.daysinmonth[source]#
The number of days in the month.
|
reference/api/pandas.Series.dt.daysinmonth.html
|
pandas.Series.append
|
`pandas.Series.append`
Concatenate two or more Series.
Deprecated since version 1.4.0: Use concat() instead. For further details see
Deprecated DataFrame.append and Series.append
```
>>> s1 = pd.Series([1, 2, 3])
>>> s2 = pd.Series([4, 5, 6])
>>> s3 = pd.Series([4, 5, 6], index=[3, 4, 5])
>>> s1.append(s2)
0 1
1 2
2 3
0 4
1 5
2 6
dtype: int64
```
|
Series.append(to_append, ignore_index=False, verify_integrity=False)[source]#
Concatenate two or more Series.
Deprecated since version 1.4.0: Use concat() instead. For further details see
Deprecated DataFrame.append and Series.append
Parameters
to_appendSeries or list/tuple of SeriesSeries to append with self.
ignore_indexbool, default FalseIf True, the resulting axis will be labeled 0, 1, …, n - 1.
verify_integritybool, default FalseIf True, raise Exception on creating index with duplicates.
Returns
SeriesConcatenated Series.
See also
concatGeneral function to concatenate DataFrame or Series objects.
Notes
Iteratively appending to a Series can be more computationally intensive
than a single concatenate. A better solution is to append values to a
list and then concatenate the list with the original Series all at
once.
Examples
>>> s1 = pd.Series([1, 2, 3])
>>> s2 = pd.Series([4, 5, 6])
>>> s3 = pd.Series([4, 5, 6], index=[3, 4, 5])
>>> s1.append(s2)
0 1
1 2
2 3
0 4
1 5
2 6
dtype: int64
>>> s1.append(s3)
0 1
1 2
2 3
3 4
4 5
5 6
dtype: int64
With ignore_index set to True:
>>> s1.append(s2, ignore_index=True)
0 1
1 2
2 3
3 4
4 5
5 6
dtype: int64
With verify_integrity set to True:
>>> s1.append(s2, verify_integrity=True)
Traceback (most recent call last):
...
ValueError: Indexes have overlapping values: [0, 1, 2]
|
reference/api/pandas.Series.append.html
|
pandas.tseries.offsets.BQuarterBegin.isAnchored
|
pandas.tseries.offsets.BQuarterBegin.isAnchored
|
BQuarterBegin.isAnchored()#
|
reference/api/pandas.tseries.offsets.BQuarterBegin.isAnchored.html
|
pandas.interval_range
|
`pandas.interval_range`
Return a fixed frequency IntervalIndex.
```
>>> pd.interval_range(start=0, end=5)
IntervalIndex([(0, 1], (1, 2], (2, 3], (3, 4], (4, 5]],
dtype='interval[int64, right]')
```
|
pandas.interval_range(start=None, end=None, periods=None, freq=None, name=None, closed='right')[source]#
Return a fixed frequency IntervalIndex.
Parameters
startnumeric or datetime-like, default NoneLeft bound for generating intervals.
endnumeric or datetime-like, default NoneRight bound for generating intervals.
periodsint, default NoneNumber of periods to generate.
freqnumeric, str, or DateOffset, default NoneThe length of each interval. Must be consistent with the type of start
and end, e.g. 2 for numeric, or ‘5H’ for datetime-like. Default is 1
for numeric and ‘D’ for datetime-like.
namestr, default NoneName of the resulting IntervalIndex.
closed{‘left’, ‘right’, ‘both’, ‘neither’}, default ‘right’Whether the intervals are closed on the left-side, right-side, both
or neither.
Returns
IntervalIndex
See also
IntervalIndexAn Index of intervals that are all closed on the same side.
Notes
Of the four parameters start, end, periods, and freq,
exactly three must be specified. If freq is omitted, the resulting
IntervalIndex will have periods linearly spaced elements between
start and end, inclusively.
To learn more about datetime-like frequency strings, please see this link.
Examples
Numeric start and end is supported.
>>> pd.interval_range(start=0, end=5)
IntervalIndex([(0, 1], (1, 2], (2, 3], (3, 4], (4, 5]],
dtype='interval[int64, right]')
Additionally, datetime-like input is also supported.
>>> pd.interval_range(start=pd.Timestamp('2017-01-01'),
... end=pd.Timestamp('2017-01-04'))
IntervalIndex([(2017-01-01, 2017-01-02], (2017-01-02, 2017-01-03],
(2017-01-03, 2017-01-04]],
dtype='interval[datetime64[ns], right]')
The freq parameter specifies the frequency between the left and right.
endpoints of the individual intervals within the IntervalIndex. For
numeric start and end, the frequency must also be numeric.
>>> pd.interval_range(start=0, periods=4, freq=1.5)
IntervalIndex([(0.0, 1.5], (1.5, 3.0], (3.0, 4.5], (4.5, 6.0]],
dtype='interval[float64, right]')
Similarly, for datetime-like start and end, the frequency must be
convertible to a DateOffset.
>>> pd.interval_range(start=pd.Timestamp('2017-01-01'),
... periods=3, freq='MS')
IntervalIndex([(2017-01-01, 2017-02-01], (2017-02-01, 2017-03-01],
(2017-03-01, 2017-04-01]],
dtype='interval[datetime64[ns], right]')
Specify start, end, and periods; the frequency is generated
automatically (linearly spaced).
>>> pd.interval_range(start=0, end=6, periods=4)
IntervalIndex([(0.0, 1.5], (1.5, 3.0], (3.0, 4.5], (4.5, 6.0]],
dtype='interval[float64, right]')
The closed parameter specifies which endpoints of the individual
intervals within the IntervalIndex are closed.
>>> pd.interval_range(end=5, periods=4, closed='both')
IntervalIndex([[1, 2], [2, 3], [3, 4], [4, 5]],
dtype='interval[int64, both]')
|
reference/api/pandas.interval_range.html
|
pandas.tseries.offsets.BusinessDay.is_on_offset
|
`pandas.tseries.offsets.BusinessDay.is_on_offset`
Return boolean whether a timestamp intersects with this frequency.
```
>>> ts = pd.Timestamp(2022, 1, 1)
>>> freq = pd.offsets.Day(1)
>>> freq.is_on_offset(ts)
True
```
|
BusinessDay.is_on_offset()#
Return boolean whether a timestamp intersects with this frequency.
Parameters
dtdatetime.datetimeTimestamp to check intersections with frequency.
Examples
>>> ts = pd.Timestamp(2022, 1, 1)
>>> freq = pd.offsets.Day(1)
>>> freq.is_on_offset(ts)
True
>>> ts = pd.Timestamp(2022, 8, 6)
>>> ts.day_name()
'Saturday'
>>> freq = pd.offsets.BusinessDay(1)
>>> freq.is_on_offset(ts)
False
|
reference/api/pandas.tseries.offsets.BusinessDay.is_on_offset.html
|
pandas.Series.str.replace
|
`pandas.Series.str.replace`
Replace each occurrence of pattern/regex in the Series/Index.
```
>>> pd.Series(['foo', 'fuz', np.nan]).str.replace('f.', 'ba', regex=True)
0 bao
1 baz
2 NaN
dtype: object
```
|
Series.str.replace(pat, repl, n=- 1, case=None, flags=0, regex=None)[source]#
Replace each occurrence of pattern/regex in the Series/Index.
Equivalent to str.replace() or re.sub(), depending on
the regex value.
Parameters
patstr or compiled regexString can be a character sequence or regular expression.
replstr or callableReplacement string or a callable. The callable is passed the regex
match object and must return a replacement string to be used.
See re.sub().
nint, default -1 (all)Number of replacements to make from start.
casebool, default NoneDetermines if replace is case sensitive:
If True, case sensitive (the default if pat is a string)
Set to False for case insensitive
Cannot be set if pat is a compiled regex.
flagsint, default 0 (no flags)Regex module flags, e.g. re.IGNORECASE. Cannot be set if pat is a compiled
regex.
regexbool, default TrueDetermines if the passed-in pattern is a regular expression:
If True, assumes the passed-in pattern is a regular expression.
If False, treats the pattern as a literal string
Cannot be set to False if pat is a compiled regex or repl is
a callable.
New in version 0.23.0.
Returns
Series or Index of objectA copy of the object with all matching occurrences of pat replaced by
repl.
Raises
ValueError
if regex is False and repl is a callable or pat is a compiled
regex
if pat is a compiled regex and case or flags is set
Notes
When pat is a compiled regex, all flags should be included in the
compiled regex. Use of case, flags, or regex=False with a compiled
regex will raise an error.
Examples
When pat is a string and regex is True (the default), the given pat
is compiled as a regex. When repl is a string, it replaces matching
regex patterns as with re.sub(). NaN value(s) in the Series are
left as is:
>>> pd.Series(['foo', 'fuz', np.nan]).str.replace('f.', 'ba', regex=True)
0 bao
1 baz
2 NaN
dtype: object
When pat is a string and regex is False, every pat is replaced with
repl as with str.replace():
>>> pd.Series(['f.o', 'fuz', np.nan]).str.replace('f.', 'ba', regex=False)
0 bao
1 fuz
2 NaN
dtype: object
When repl is a callable, it is called on every pat using
re.sub(). The callable should expect one positional argument
(a regex object) and return a string.
To get the idea:
>>> pd.Series(['foo', 'fuz', np.nan]).str.replace('f', repr, regex=True)
0 <re.Match object; span=(0, 1), match='f'>oo
1 <re.Match object; span=(0, 1), match='f'>uz
2 NaN
dtype: object
Reverse every lowercase alphabetic word:
>>> repl = lambda m: m.group(0)[::-1]
>>> ser = pd.Series(['foo 123', 'bar baz', np.nan])
>>> ser.str.replace(r'[a-z]+', repl, regex=True)
0 oof 123
1 rab zab
2 NaN
dtype: object
Using regex groups (extract second group and swap case):
>>> pat = r"(?P<one>\w+) (?P<two>\w+) (?P<three>\w+)"
>>> repl = lambda m: m.group('two').swapcase()
>>> ser = pd.Series(['One Two Three', 'Foo Bar Baz'])
>>> ser.str.replace(pat, repl, regex=True)
0 tWO
1 bAR
dtype: object
Using a compiled regex with flags
>>> import re
>>> regex_pat = re.compile(r'FUZ', flags=re.IGNORECASE)
>>> pd.Series(['foo', 'fuz', np.nan]).str.replace(regex_pat, 'bar', regex=True)
0 foo
1 bar
2 NaN
dtype: object
|
reference/api/pandas.Series.str.replace.html
|
pandas.Series.iloc
|
`pandas.Series.iloc`
Purely integer-location based indexing for selection by position.
```
>>> mydict = [{'a': 1, 'b': 2, 'c': 3, 'd': 4},
... {'a': 100, 'b': 200, 'c': 300, 'd': 400},
... {'a': 1000, 'b': 2000, 'c': 3000, 'd': 4000 }]
>>> df = pd.DataFrame(mydict)
>>> df
a b c d
0 1 2 3 4
1 100 200 300 400
2 1000 2000 3000 4000
```
|
property Series.iloc[source]#
Purely integer-location based indexing for selection by position.
.iloc[] is primarily integer position based (from 0 to
length-1 of the axis), but may also be used with a boolean
array.
Allowed inputs are:
An integer, e.g. 5.
A list or array of integers, e.g. [4, 3, 0].
A slice object with ints, e.g. 1:7.
A boolean array.
A callable function with one argument (the calling Series or
DataFrame) and that returns valid output for indexing (one of the above).
This is useful in method chains, when you don’t have a reference to the
calling object, but would like to base your selection on some value.
A tuple of row and column indexes. The tuple elements consist of one of the
above inputs, e.g. (0, 1).
.iloc will raise IndexError if a requested indexer is
out-of-bounds, except slice indexers which allow out-of-bounds
indexing (this conforms with python/numpy slice semantics).
See more at Selection by Position.
See also
DataFrame.iatFast integer location scalar accessor.
DataFrame.locPurely label-location based indexer for selection by label.
Series.ilocPurely integer-location based indexing for selection by position.
Examples
>>> mydict = [{'a': 1, 'b': 2, 'c': 3, 'd': 4},
... {'a': 100, 'b': 200, 'c': 300, 'd': 400},
... {'a': 1000, 'b': 2000, 'c': 3000, 'd': 4000 }]
>>> df = pd.DataFrame(mydict)
>>> df
a b c d
0 1 2 3 4
1 100 200 300 400
2 1000 2000 3000 4000
Indexing just the rows
With a scalar integer.
>>> type(df.iloc[0])
<class 'pandas.core.series.Series'>
>>> df.iloc[0]
a 1
b 2
c 3
d 4
Name: 0, dtype: int64
With a list of integers.
>>> df.iloc[[0]]
a b c d
0 1 2 3 4
>>> type(df.iloc[[0]])
<class 'pandas.core.frame.DataFrame'>
>>> df.iloc[[0, 1]]
a b c d
0 1 2 3 4
1 100 200 300 400
With a slice object.
>>> df.iloc[:3]
a b c d
0 1 2 3 4
1 100 200 300 400
2 1000 2000 3000 4000
With a boolean mask the same length as the index.
>>> df.iloc[[True, False, True]]
a b c d
0 1 2 3 4
2 1000 2000 3000 4000
With a callable, useful in method chains. The x passed
to the lambda is the DataFrame being sliced. This selects
the rows whose index label even.
>>> df.iloc[lambda x: x.index % 2 == 0]
a b c d
0 1 2 3 4
2 1000 2000 3000 4000
Indexing both axes
You can mix the indexer types for the index and columns. Use : to
select the entire axis.
With scalar integers.
>>> df.iloc[0, 1]
2
With lists of integers.
>>> df.iloc[[0, 2], [1, 3]]
b d
0 2 4
2 2000 4000
With slice objects.
>>> df.iloc[1:3, 0:3]
a b c
1 100 200 300
2 1000 2000 3000
With a boolean array whose length matches the columns.
>>> df.iloc[:, [True, False, True, False]]
a c
0 1 3
1 100 300
2 1000 3000
With a callable function that expects the Series or DataFrame.
>>> df.iloc[:, lambda df: [0, 2]]
a c
0 1 3
1 100 300
2 1000 3000
|
reference/api/pandas.Series.iloc.html
|
pandas.Series.cummax
|
`pandas.Series.cummax`
Return cumulative maximum over a DataFrame or Series axis.
```
>>> s = pd.Series([2, np.nan, 5, -1, 0])
>>> s
0 2.0
1 NaN
2 5.0
3 -1.0
4 0.0
dtype: float64
```
|
Series.cummax(axis=None, skipna=True, *args, **kwargs)[source]#
Return cumulative maximum over a DataFrame or Series axis.
Returns a DataFrame or Series of the same size containing the cumulative
maximum.
Parameters
axis{0 or ‘index’, 1 or ‘columns’}, default 0The index or the name of the axis. 0 is equivalent to None or ‘index’.
For Series this parameter is unused and defaults to 0.
skipnabool, default TrueExclude NA/null values. If an entire row/column is NA, the result
will be NA.
*args, **kwargsAdditional keywords have no effect but might be accepted for
compatibility with NumPy.
Returns
scalar or SeriesReturn cumulative maximum of scalar or Series.
See also
core.window.expanding.Expanding.maxSimilar functionality but ignores NaN values.
Series.maxReturn the maximum over Series axis.
Series.cummaxReturn cumulative maximum over Series axis.
Series.cumminReturn cumulative minimum over Series axis.
Series.cumsumReturn cumulative sum over Series axis.
Series.cumprodReturn cumulative product over Series axis.
Examples
Series
>>> s = pd.Series([2, np.nan, 5, -1, 0])
>>> s
0 2.0
1 NaN
2 5.0
3 -1.0
4 0.0
dtype: float64
By default, NA values are ignored.
>>> s.cummax()
0 2.0
1 NaN
2 5.0
3 5.0
4 5.0
dtype: float64
To include NA values in the operation, use skipna=False
>>> s.cummax(skipna=False)
0 2.0
1 NaN
2 NaN
3 NaN
4 NaN
dtype: float64
DataFrame
>>> df = pd.DataFrame([[2.0, 1.0],
... [3.0, np.nan],
... [1.0, 0.0]],
... columns=list('AB'))
>>> df
A B
0 2.0 1.0
1 3.0 NaN
2 1.0 0.0
By default, iterates over rows and finds the maximum
in each column. This is equivalent to axis=None or axis='index'.
>>> df.cummax()
A B
0 2.0 1.0
1 3.0 NaN
2 3.0 1.0
To iterate over columns and find the maximum in each row,
use axis=1
>>> df.cummax(axis=1)
A B
0 2.0 2.0
1 3.0 NaN
2 1.0 1.0
|
reference/api/pandas.Series.cummax.html
|
pandas.tseries.offsets.WeekOfMonth.rollback
|
`pandas.tseries.offsets.WeekOfMonth.rollback`
Roll provided date backward to next offset only if not on offset.
|
WeekOfMonth.rollback()#
Roll provided date backward to next offset only if not on offset.
Returns
TimeStampRolled timestamp if not on offset, otherwise unchanged timestamp.
|
reference/api/pandas.tseries.offsets.WeekOfMonth.rollback.html
|
pandas.Series.to_sql
|
`pandas.Series.to_sql`
Write records stored in a DataFrame to a SQL database.
```
>>> from sqlalchemy import create_engine
>>> engine = create_engine('sqlite://', echo=False)
```
|
Series.to_sql(name, con, schema=None, if_exists='fail', index=True, index_label=None, chunksize=None, dtype=None, method=None)[source]#
Write records stored in a DataFrame to a SQL database.
Databases supported by SQLAlchemy [1] are supported. Tables can be
newly created, appended to, or overwritten.
Parameters
namestrName of SQL table.
consqlalchemy.engine.(Engine or Connection) or sqlite3.ConnectionUsing SQLAlchemy makes it possible to use any DB supported by that
library. Legacy support is provided for sqlite3.Connection objects. The user
is responsible for engine disposal and connection closure for the SQLAlchemy
connectable See here.
schemastr, optionalSpecify the schema (if database flavor supports this). If None, use
default schema.
if_exists{‘fail’, ‘replace’, ‘append’}, default ‘fail’How to behave if the table already exists.
fail: Raise a ValueError.
replace: Drop the table before inserting new values.
append: Insert new values to the existing table.
indexbool, default TrueWrite DataFrame index as a column. Uses index_label as the column
name in the table.
index_labelstr or sequence, default NoneColumn label for index column(s). If None is given (default) and
index is True, then the index names are used.
A sequence should be given if the DataFrame uses MultiIndex.
chunksizeint, optionalSpecify the number of rows in each batch to be written at a time.
By default, all rows will be written at once.
dtypedict or scalar, optionalSpecifying the datatype for columns. If a dictionary is used, the
keys should be the column names and the values should be the
SQLAlchemy types or strings for the sqlite3 legacy mode. If a
scalar is provided, it will be applied to all columns.
method{None, ‘multi’, callable}, optionalControls the SQL insertion clause used:
None : Uses standard SQL INSERT clause (one per row).
‘multi’: Pass multiple values in a single INSERT clause.
callable with signature (pd_table, conn, keys, data_iter).
Details and a sample callable implementation can be found in the
section insert method.
Returns
None or intNumber of rows affected by to_sql. None is returned if the callable
passed into method does not return an integer number of rows.
The number of returned rows affected is the sum of the rowcount
attribute of sqlite3.Cursor or SQLAlchemy connectable which may not
reflect the exact number of written rows as stipulated in the
sqlite3 or
SQLAlchemy.
New in version 1.4.0.
Raises
ValueErrorWhen the table already exists and if_exists is ‘fail’ (the
default).
See also
read_sqlRead a DataFrame from a table.
Notes
Timezone aware datetime columns will be written as
Timestamp with timezone type with SQLAlchemy if supported by the
database. Otherwise, the datetimes will be stored as timezone unaware
timestamps local to the original timezone.
References
1
https://docs.sqlalchemy.org
2
https://www.python.org/dev/peps/pep-0249/
Examples
Create an in-memory SQLite database.
>>> from sqlalchemy import create_engine
>>> engine = create_engine('sqlite://', echo=False)
Create a table from scratch with 3 rows.
>>> df = pd.DataFrame({'name' : ['User 1', 'User 2', 'User 3']})
>>> df
name
0 User 1
1 User 2
2 User 3
>>> df.to_sql('users', con=engine)
3
>>> engine.execute("SELECT * FROM users").fetchall()
[(0, 'User 1'), (1, 'User 2'), (2, 'User 3')]
An sqlalchemy.engine.Connection can also be passed to con:
>>> with engine.begin() as connection:
... df1 = pd.DataFrame({'name' : ['User 4', 'User 5']})
... df1.to_sql('users', con=connection, if_exists='append')
2
This is allowed to support operations that require that the same
DBAPI connection is used for the entire operation.
>>> df2 = pd.DataFrame({'name' : ['User 6', 'User 7']})
>>> df2.to_sql('users', con=engine, if_exists='append')
2
>>> engine.execute("SELECT * FROM users").fetchall()
[(0, 'User 1'), (1, 'User 2'), (2, 'User 3'),
(0, 'User 4'), (1, 'User 5'), (0, 'User 6'),
(1, 'User 7')]
Overwrite the table with just df2.
>>> df2.to_sql('users', con=engine, if_exists='replace',
... index_label='id')
2
>>> engine.execute("SELECT * FROM users").fetchall()
[(0, 'User 6'), (1, 'User 7')]
Specify the dtype (especially useful for integers with missing values).
Notice that while pandas is forced to store the data as floating point,
the database supports nullable integers. When fetching the data with
Python, we get back integer scalars.
>>> df = pd.DataFrame({"A": [1, None, 2]})
>>> df
A
0 1.0
1 NaN
2 2.0
>>> from sqlalchemy.types import Integer
>>> df.to_sql('integers', con=engine, index=False,
... dtype={"A": Integer()})
3
>>> engine.execute("SELECT * FROM integers").fetchall()
[(1,), (None,), (2,)]
|
reference/api/pandas.Series.to_sql.html
|
pandas.Int64Dtype
|
`pandas.Int64Dtype`
An ExtensionDtype for int64 integer data.
Changed in version 1.0.0: Now uses pandas.NA as its missing value,
rather than numpy.nan.
|
class pandas.Int64Dtype[source]#
An ExtensionDtype for int64 integer data.
Changed in version 1.0.0: Now uses pandas.NA as its missing value,
rather than numpy.nan.
Attributes
None
Methods
None
|
reference/api/pandas.Int64Dtype.html
|
pandas.api.types.is_numeric_dtype
|
`pandas.api.types.is_numeric_dtype`
Check whether the provided array or dtype is of a numeric dtype.
```
>>> is_numeric_dtype(str)
False
>>> is_numeric_dtype(int)
True
>>> is_numeric_dtype(float)
True
>>> is_numeric_dtype(np.uint64)
True
>>> is_numeric_dtype(np.datetime64)
False
>>> is_numeric_dtype(np.timedelta64)
False
>>> is_numeric_dtype(np.array(['a', 'b']))
False
>>> is_numeric_dtype(pd.Series([1, 2]))
True
>>> is_numeric_dtype(pd.Index([1, 2.]))
True
>>> is_numeric_dtype(np.array([], dtype=np.timedelta64))
False
```
|
pandas.api.types.is_numeric_dtype(arr_or_dtype)[source]#
Check whether the provided array or dtype is of a numeric dtype.
Parameters
arr_or_dtypearray-like or dtypeThe array or dtype to check.
Returns
booleanWhether or not the array or dtype is of a numeric dtype.
Examples
>>> is_numeric_dtype(str)
False
>>> is_numeric_dtype(int)
True
>>> is_numeric_dtype(float)
True
>>> is_numeric_dtype(np.uint64)
True
>>> is_numeric_dtype(np.datetime64)
False
>>> is_numeric_dtype(np.timedelta64)
False
>>> is_numeric_dtype(np.array(['a', 'b']))
False
>>> is_numeric_dtype(pd.Series([1, 2]))
True
>>> is_numeric_dtype(pd.Index([1, 2.]))
True
>>> is_numeric_dtype(np.array([], dtype=np.timedelta64))
False
|
reference/api/pandas.api.types.is_numeric_dtype.html
|
pandas.DataFrame.to_numpy
|
`pandas.DataFrame.to_numpy`
Convert the DataFrame to a NumPy array.
```
>>> pd.DataFrame({"A": [1, 2], "B": [3, 4]}).to_numpy()
array([[1, 3],
[2, 4]])
```
|
DataFrame.to_numpy(dtype=None, copy=False, na_value=_NoDefault.no_default)[source]#
Convert the DataFrame to a NumPy array.
By default, the dtype of the returned array will be the common NumPy
dtype of all types in the DataFrame. For example, if the dtypes are
float16 and float32, the results dtype will be float32.
This may require copying data and coercing values, which may be
expensive.
Parameters
dtypestr or numpy.dtype, optionalThe dtype to pass to numpy.asarray().
copybool, default FalseWhether to ensure that the returned value is not a view on
another array. Note that copy=False does not ensure that
to_numpy() is no-copy. Rather, copy=True ensure that
a copy is made, even if not strictly necessary.
na_valueAny, optionalThe value to use for missing values. The default value depends
on dtype and the dtypes of the DataFrame columns.
New in version 1.1.0.
Returns
numpy.ndarray
See also
Series.to_numpySimilar method for Series.
Examples
>>> pd.DataFrame({"A": [1, 2], "B": [3, 4]}).to_numpy()
array([[1, 3],
[2, 4]])
With heterogeneous data, the lowest common type will have to
be used.
>>> df = pd.DataFrame({"A": [1, 2], "B": [3.0, 4.5]})
>>> df.to_numpy()
array([[1. , 3. ],
[2. , 4.5]])
For a mix of numeric and non-numeric types, the output array will
have object dtype.
>>> df['C'] = pd.date_range('2000', periods=2)
>>> df.to_numpy()
array([[1, 3.0, Timestamp('2000-01-01 00:00:00')],
[2, 4.5, Timestamp('2000-01-02 00:00:00')]], dtype=object)
|
reference/api/pandas.DataFrame.to_numpy.html
|
pandas.tseries.offsets.Tick.apply_index
|
`pandas.tseries.offsets.Tick.apply_index`
Vectorized apply of DateOffset to DatetimeIndex.
|
Tick.apply_index()#
Vectorized apply of DateOffset to DatetimeIndex.
Deprecated since version 1.1.0: Use offset + dtindex instead.
Parameters
indexDatetimeIndex
Returns
DatetimeIndex
Raises
NotImplementedErrorWhen the specific offset subclass does not have a vectorized
implementation.
|
reference/api/pandas.tseries.offsets.Tick.apply_index.html
|
pandas.Index.to_numpy
|
`pandas.Index.to_numpy`
A NumPy ndarray representing the values in this Series or Index.
The dtype to pass to numpy.asarray().
```
>>> ser = pd.Series(pd.Categorical(['a', 'b', 'a']))
>>> ser.to_numpy()
array(['a', 'b', 'a'], dtype=object)
```
|
Index.to_numpy(dtype=None, copy=False, na_value=_NoDefault.no_default, **kwargs)[source]#
A NumPy ndarray representing the values in this Series or Index.
Parameters
dtypestr or numpy.dtype, optionalThe dtype to pass to numpy.asarray().
copybool, default FalseWhether to ensure that the returned value is not a view on
another array. Note that copy=False does not ensure that
to_numpy() is no-copy. Rather, copy=True ensure that
a copy is made, even if not strictly necessary.
na_valueAny, optionalThe value to use for missing values. The default value depends
on dtype and the type of the array.
New in version 1.0.0.
**kwargsAdditional keywords passed through to the to_numpy method
of the underlying array (for extension arrays).
New in version 1.0.0.
Returns
numpy.ndarray
See also
Series.arrayGet the actual data stored within.
Index.arrayGet the actual data stored within.
DataFrame.to_numpySimilar method for DataFrame.
Notes
The returned array will be the same up to equality (values equal
in self will be equal in the returned array; likewise for values
that are not equal). When self contains an ExtensionArray, the
dtype may be different. For example, for a category-dtype Series,
to_numpy() will return a NumPy array and the categorical dtype
will be lost.
For NumPy dtypes, this will be a reference to the actual data stored
in this Series or Index (assuming copy=False). Modifying the result
in place will modify the data stored in the Series or Index (not that
we recommend doing that).
For extension types, to_numpy() may require copying data and
coercing the result to a NumPy type (possibly object), which may be
expensive. When you need a no-copy reference to the underlying data,
Series.array should be used instead.
This table lays out the different dtypes and default return types of
to_numpy() for various dtypes within pandas.
dtype
array type
category[T]
ndarray[T] (same dtype as input)
period
ndarray[object] (Periods)
interval
ndarray[object] (Intervals)
IntegerNA
ndarray[object]
datetime64[ns]
datetime64[ns]
datetime64[ns, tz]
ndarray[object] (Timestamps)
Examples
>>> ser = pd.Series(pd.Categorical(['a', 'b', 'a']))
>>> ser.to_numpy()
array(['a', 'b', 'a'], dtype=object)
Specify the dtype to control how datetime-aware data is represented.
Use dtype=object to return an ndarray of pandas Timestamp
objects, each with the correct tz.
>>> ser = pd.Series(pd.date_range('2000', periods=2, tz="CET"))
>>> ser.to_numpy(dtype=object)
array([Timestamp('2000-01-01 00:00:00+0100', tz='CET'),
Timestamp('2000-01-02 00:00:00+0100', tz='CET')],
dtype=object)
Or dtype='datetime64[ns]' to return an ndarray of native
datetime64 values. The values are converted to UTC and the timezone
info is dropped.
>>> ser.to_numpy(dtype="datetime64[ns]")
...
array(['1999-12-31T23:00:00.000000000', '2000-01-01T23:00:00...'],
dtype='datetime64[ns]')
|
reference/api/pandas.Index.to_numpy.html
|
pandas.tseries.offsets.BQuarterBegin.startingMonth
|
pandas.tseries.offsets.BQuarterBegin.startingMonth
|
BQuarterBegin.startingMonth#
|
reference/api/pandas.tseries.offsets.BQuarterBegin.startingMonth.html
|
Options and settings
|
Options and settings
|
API for configuring global behavior. See the User Guide for more.
Working with options#
describe_option(pat[, _print_desc])
Prints the description for one or more registered options.
reset_option(pat)
Reset one or more options to their default value.
get_option(pat)
Retrieves the value of the specified option.
set_option(pat, value)
Sets the value of the specified option.
option_context(*args)
Context manager to temporarily set options in the with statement context.
|
reference/options.html
|
pandas.Index.dtype
|
`pandas.Index.dtype`
Return the dtype object of the underlying data.
|
Index.dtype[source]#
Return the dtype object of the underlying data.
|
reference/api/pandas.Index.dtype.html
|
pandas.tseries.offsets.CustomBusinessMonthBegin.is_on_offset
|
`pandas.tseries.offsets.CustomBusinessMonthBegin.is_on_offset`
Return boolean whether a timestamp intersects with this frequency.
```
>>> ts = pd.Timestamp(2022, 1, 1)
>>> freq = pd.offsets.Day(1)
>>> freq.is_on_offset(ts)
True
```
|
CustomBusinessMonthBegin.is_on_offset()#
Return boolean whether a timestamp intersects with this frequency.
Parameters
dtdatetime.datetimeTimestamp to check intersections with frequency.
Examples
>>> ts = pd.Timestamp(2022, 1, 1)
>>> freq = pd.offsets.Day(1)
>>> freq.is_on_offset(ts)
True
>>> ts = pd.Timestamp(2022, 8, 6)
>>> ts.day_name()
'Saturday'
>>> freq = pd.offsets.BusinessDay(1)
>>> freq.is_on_offset(ts)
False
|
reference/api/pandas.tseries.offsets.CustomBusinessMonthBegin.is_on_offset.html
|
pandas.tseries.offsets.Milli
|
`pandas.tseries.offsets.Milli`
Attributes
base
|
class pandas.tseries.offsets.Milli#
Attributes
base
Returns a copy of the calling offset object with n=1 and all other attributes equal.
freqstr
Return a string representing the frequency.
kwds
Return a dict of extra parameters for the offset.
name
Return a string representing the base frequency.
nanos
Return an integer of the total number of nanoseconds.
delta
n
normalize
rule_code
Methods
__call__(*args, **kwargs)
Call self as a function.
apply_index
(DEPRECATED) Vectorized apply of DateOffset to DatetimeIndex.
copy
Return a copy of the frequency.
is_anchored
Return boolean whether the frequency is a unit frequency (n=1).
is_month_end
Return boolean whether a timestamp occurs on the month end.
is_month_start
Return boolean whether a timestamp occurs on the month start.
is_on_offset
Return boolean whether a timestamp intersects with this frequency.
is_quarter_end
Return boolean whether a timestamp occurs on the quarter end.
is_quarter_start
Return boolean whether a timestamp occurs on the quarter start.
is_year_end
Return boolean whether a timestamp occurs on the year end.
is_year_start
Return boolean whether a timestamp occurs on the year start.
rollback
Roll provided date backward to next offset only if not on offset.
rollforward
Roll provided date forward to next offset only if not on offset.
apply
isAnchored
onOffset
|
reference/api/pandas.tseries.offsets.Milli.html
|
pandas.errors.UndefinedVariableError
|
`pandas.errors.UndefinedVariableError`
Exception raised by query or eval when using an undefined variable name.
It will also specify whether the undefined variable is local or not.
```
>>> df = pd.DataFrame({'A': [1, 1, 1]})
>>> df.query("A > x")
... # UndefinedVariableError: name 'x' is not defined
>>> df.query("A > @y")
... # UndefinedVariableError: local variable 'y' is not defined
>>> pd.eval('x + 1')
... # UndefinedVariableError: name 'x' is not defined
```
|
exception pandas.errors.UndefinedVariableError(name, is_local=None)[source]#
Exception raised by query or eval when using an undefined variable name.
It will also specify whether the undefined variable is local or not.
Examples
>>> df = pd.DataFrame({'A': [1, 1, 1]})
>>> df.query("A > x")
... # UndefinedVariableError: name 'x' is not defined
>>> df.query("A > @y")
... # UndefinedVariableError: local variable 'y' is not defined
>>> pd.eval('x + 1')
... # UndefinedVariableError: name 'x' is not defined
|
reference/api/pandas.errors.UndefinedVariableError.html
|
pandas.api.types.infer_dtype
|
`pandas.api.types.infer_dtype`
Return a string label of the type of a scalar or list-like of values.
```
>>> import datetime
>>> infer_dtype(['foo', 'bar'])
'string'
```
|
pandas.api.types.infer_dtype()#
Return a string label of the type of a scalar or list-like of values.
Parameters
valuescalar, list, ndarray, or pandas type
skipnabool, default TrueIgnore NaN values when inferring the type.
Returns
strDescribing the common type of the input data.
Results can include:
string
bytes
floating
integer
mixed-integer
mixed-integer-float
decimal
complex
categorical
boolean
datetime64
datetime
date
timedelta64
timedelta
time
period
mixed
unknown-array
Raises
TypeErrorIf ndarray-like but cannot infer the dtype
Notes
‘mixed’ is the catchall for anything that is not otherwise
specialized
‘mixed-integer-float’ are floats and integers
‘mixed-integer’ are integers mixed with non-integers
‘unknown-array’ is the catchall for something that is an array (has
a dtype attribute), but has a dtype unknown to pandas (e.g. external
extension array)
Examples
>>> import datetime
>>> infer_dtype(['foo', 'bar'])
'string'
>>> infer_dtype(['a', np.nan, 'b'], skipna=True)
'string'
>>> infer_dtype(['a', np.nan, 'b'], skipna=False)
'mixed'
>>> infer_dtype([b'foo', b'bar'])
'bytes'
>>> infer_dtype([1, 2, 3])
'integer'
>>> infer_dtype([1, 2, 3.5])
'mixed-integer-float'
>>> infer_dtype([1.0, 2.0, 3.5])
'floating'
>>> infer_dtype(['a', 1])
'mixed-integer'
>>> infer_dtype([Decimal(1), Decimal(2.0)])
'decimal'
>>> infer_dtype([True, False])
'boolean'
>>> infer_dtype([True, False, np.nan])
'boolean'
>>> infer_dtype([pd.Timestamp('20130101')])
'datetime'
>>> infer_dtype([datetime.date(2013, 1, 1)])
'date'
>>> infer_dtype([np.datetime64('2013-01-01')])
'datetime64'
>>> infer_dtype([datetime.timedelta(0, 1, 1)])
'timedelta'
>>> infer_dtype(pd.Series(list('aabc')).astype('category'))
'categorical'
|
reference/api/pandas.api.types.infer_dtype.html
|
pandas.core.groupby.GroupBy.cummin
|
`pandas.core.groupby.GroupBy.cummin`
Cumulative min for each group.
|
final GroupBy.cummin(axis=0, numeric_only=False, **kwargs)[source]#
Cumulative min for each group.
Returns
Series or DataFrame
See also
Series.groupbyApply a function groupby to a Series.
DataFrame.groupbyApply a function groupby to each row or column of a DataFrame.
|
reference/api/pandas.core.groupby.GroupBy.cummin.html
|
pandas.DatetimeIndex.month
|
`pandas.DatetimeIndex.month`
The month as January=1, December=12.
Examples
```
>>> datetime_series = pd.Series(
... pd.date_range("2000-01-01", periods=3, freq="M")
... )
>>> datetime_series
0 2000-01-31
1 2000-02-29
2 2000-03-31
dtype: datetime64[ns]
>>> datetime_series.dt.month
0 1
1 2
2 3
dtype: int64
```
|
property DatetimeIndex.month[source]#
The month as January=1, December=12.
Examples
>>> datetime_series = pd.Series(
... pd.date_range("2000-01-01", periods=3, freq="M")
... )
>>> datetime_series
0 2000-01-31
1 2000-02-29
2 2000-03-31
dtype: datetime64[ns]
>>> datetime_series.dt.month
0 1
1 2
2 3
dtype: int64
|
reference/api/pandas.DatetimeIndex.month.html
|
pandas.DataFrame.eval
|
`pandas.DataFrame.eval`
Evaluate a string describing operations on DataFrame columns.
```
>>> df = pd.DataFrame({'A': range(1, 6), 'B': range(10, 0, -2)})
>>> df
A B
0 1 10
1 2 8
2 3 6
3 4 4
4 5 2
>>> df.eval('A + B')
0 11
1 10
2 9
3 8
4 7
dtype: int64
```
|
DataFrame.eval(expr, *, inplace=False, **kwargs)[source]#
Evaluate a string describing operations on DataFrame columns.
Operates on columns only, not specific rows or elements. This allows
eval to run arbitrary code, which can make you vulnerable to code
injection if you pass user input to this function.
Parameters
exprstrThe expression string to evaluate.
inplacebool, default FalseIf the expression contains an assignment, whether to perform the
operation inplace and mutate the existing DataFrame. Otherwise,
a new DataFrame is returned.
**kwargsSee the documentation for eval() for complete details
on the keyword arguments accepted by
query().
Returns
ndarray, scalar, pandas object, or NoneThe result of the evaluation or None if inplace=True.
See also
DataFrame.queryEvaluates a boolean expression to query the columns of a frame.
DataFrame.assignCan evaluate an expression or function to create new values for a column.
evalEvaluate a Python expression as a string using various backends.
Notes
For more details see the API documentation for eval().
For detailed examples see enhancing performance with eval.
Examples
>>> df = pd.DataFrame({'A': range(1, 6), 'B': range(10, 0, -2)})
>>> df
A B
0 1 10
1 2 8
2 3 6
3 4 4
4 5 2
>>> df.eval('A + B')
0 11
1 10
2 9
3 8
4 7
dtype: int64
Assignment is allowed though by default the original DataFrame is not
modified.
>>> df.eval('C = A + B')
A B C
0 1 10 11
1 2 8 10
2 3 6 9
3 4 4 8
4 5 2 7
>>> df
A B
0 1 10
1 2 8
2 3 6
3 4 4
4 5 2
Use inplace=True to modify the original DataFrame.
>>> df.eval('C = A + B', inplace=True)
>>> df
A B C
0 1 10 11
1 2 8 10
2 3 6 9
3 4 4 8
4 5 2 7
Multiple columns can be assigned to using multi-line expressions:
>>> df.eval(
... '''
... C = A + B
... D = A - B
... '''
... )
A B C D
0 1 10 11 -9
1 2 8 10 -6
2 3 6 9 -3
3 4 4 8 0
4 5 2 7 3
|
reference/api/pandas.DataFrame.eval.html
|
pandas.tseries.offsets.BusinessHour.is_year_end
|
`pandas.tseries.offsets.BusinessHour.is_year_end`
Return boolean whether a timestamp occurs on the year end.
```
>>> ts = pd.Timestamp(2022, 1, 1)
>>> freq = pd.offsets.Hour(5)
>>> freq.is_year_end(ts)
False
```
|
BusinessHour.is_year_end()#
Return boolean whether a timestamp occurs on the year end.
Examples
>>> ts = pd.Timestamp(2022, 1, 1)
>>> freq = pd.offsets.Hour(5)
>>> freq.is_year_end(ts)
False
|
reference/api/pandas.tseries.offsets.BusinessHour.is_year_end.html
|
pandas.Series.at
|
`pandas.Series.at`
Access a single value for a row/column label pair.
Similar to loc, in that both provide label-based lookups. Use
at if you only need to get or set a single value in a DataFrame
or Series.
```
>>> df = pd.DataFrame([[0, 2, 3], [0, 4, 1], [10, 20, 30]],
... index=[4, 5, 6], columns=['A', 'B', 'C'])
>>> df
A B C
4 0 2 3
5 0 4 1
6 10 20 30
```
|
property Series.at[source]#
Access a single value for a row/column label pair.
Similar to loc, in that both provide label-based lookups. Use
at if you only need to get or set a single value in a DataFrame
or Series.
Raises
KeyError
If getting a value and ‘label’ does not exist in a DataFrame orSeries.
ValueError
If row/column label pair is not a tuple or if any label fromthe pair is not a scalar for DataFrame.
If label is list-like (excluding NamedTuple) for Series.
See also
DataFrame.atAccess a single value for a row/column pair by label.
DataFrame.iatAccess a single value for a row/column pair by integer position.
DataFrame.locAccess a group of rows and columns by label(s).
DataFrame.ilocAccess a group of rows and columns by integer position(s).
Series.atAccess a single value by label.
Series.iatAccess a single value by integer position.
Series.locAccess a group of rows by label(s).
Series.ilocAccess a group of rows by integer position(s).
Notes
See Fast scalar value getting and setting
for more details.
Examples
>>> df = pd.DataFrame([[0, 2, 3], [0, 4, 1], [10, 20, 30]],
... index=[4, 5, 6], columns=['A', 'B', 'C'])
>>> df
A B C
4 0 2 3
5 0 4 1
6 10 20 30
Get value at specified row/column pair
>>> df.at[4, 'B']
2
Set value at specified row/column pair
>>> df.at[4, 'B'] = 10
>>> df.at[4, 'B']
10
Get value within a Series
>>> df.loc[5].at['B']
4
|
reference/api/pandas.Series.at.html
|
pandas.tseries.offsets.BusinessMonthEnd.rollforward
|
`pandas.tseries.offsets.BusinessMonthEnd.rollforward`
Roll provided date forward to next offset only if not on offset.
|
BusinessMonthEnd.rollforward()#
Roll provided date forward to next offset only if not on offset.
Returns
TimeStampRolled timestamp if not on offset, otherwise unchanged timestamp.
|
reference/api/pandas.tseries.offsets.BusinessMonthEnd.rollforward.html
|
pandas.tseries.offsets.BQuarterEnd.rollback
|
`pandas.tseries.offsets.BQuarterEnd.rollback`
Roll provided date backward to next offset only if not on offset.
|
BQuarterEnd.rollback()#
Roll provided date backward to next offset only if not on offset.
Returns
TimeStampRolled timestamp if not on offset, otherwise unchanged timestamp.
|
reference/api/pandas.tseries.offsets.BQuarterEnd.rollback.html
|
pandas.Series.plot.area
|
`pandas.Series.plot.area`
Draw a stacked area plot.
An area plot displays quantitative data visually.
This function wraps the matplotlib area function.
```
>>> df = pd.DataFrame({
... 'sales': [3, 2, 3, 9, 10, 6],
... 'signups': [5, 5, 6, 12, 14, 13],
... 'visits': [20, 42, 28, 62, 81, 50],
... }, index=pd.date_range(start='2018/01/01', end='2018/07/01',
... freq='M'))
>>> ax = df.plot.area()
```
|
Series.plot.area(x=None, y=None, **kwargs)[source]#
Draw a stacked area plot.
An area plot displays quantitative data visually.
This function wraps the matplotlib area function.
Parameters
xlabel or position, optionalCoordinates for the X axis. By default uses the index.
ylabel or position, optionalColumn to plot. By default uses all columns.
stackedbool, default TrueArea plots are stacked by default. Set to False to create a
unstacked plot.
**kwargsAdditional keyword arguments are documented in
DataFrame.plot().
Returns
matplotlib.axes.Axes or numpy.ndarrayArea plot, or array of area plots if subplots is True.
See also
DataFrame.plotMake plots of DataFrame using matplotlib / pylab.
Examples
Draw an area plot based on basic business metrics:
>>> df = pd.DataFrame({
... 'sales': [3, 2, 3, 9, 10, 6],
... 'signups': [5, 5, 6, 12, 14, 13],
... 'visits': [20, 42, 28, 62, 81, 50],
... }, index=pd.date_range(start='2018/01/01', end='2018/07/01',
... freq='M'))
>>> ax = df.plot.area()
Area plots are stacked by default. To produce an unstacked plot,
pass stacked=False:
>>> ax = df.plot.area(stacked=False)
Draw an area plot for a single column:
>>> ax = df.plot.area(y='sales')
Draw with a different x:
>>> df = pd.DataFrame({
... 'sales': [3, 2, 3],
... 'visits': [20, 42, 28],
... 'day': [1, 2, 3],
... })
>>> ax = df.plot.area(x='day')
|
reference/api/pandas.Series.plot.area.html
|
Python Module Index
|
p
p
pandas
|
py-modindex.html
| null |
pandas.PeriodIndex.weekofyear
|
`pandas.PeriodIndex.weekofyear`
The week ordinal of the year.
|
property PeriodIndex.weekofyear[source]#
The week ordinal of the year.
|
reference/api/pandas.PeriodIndex.weekofyear.html
|
pandas.core.groupby.GroupBy.size
|
`pandas.core.groupby.GroupBy.size`
Compute group sizes.
|
final GroupBy.size()[source]#
Compute group sizes.
Returns
DataFrame or SeriesNumber of rows in each group as a Series if as_index is True
or a DataFrame if as_index is False.
See also
Series.groupbyApply a function groupby to a Series.
DataFrame.groupbyApply a function groupby to each row or column of a DataFrame.
|
reference/api/pandas.core.groupby.GroupBy.size.html
|
pandas.Timestamp.is_year_start
|
`pandas.Timestamp.is_year_start`
Return True if date is first day of the year.
```
>>> ts = pd.Timestamp(2020, 3, 14)
>>> ts.is_year_start
False
```
|
Timestamp.is_year_start#
Return True if date is first day of the year.
Examples
>>> ts = pd.Timestamp(2020, 3, 14)
>>> ts.is_year_start
False
>>> ts = pd.Timestamp(2020, 1, 1)
>>> ts.is_year_start
True
|
reference/api/pandas.Timestamp.is_year_start.html
|
Style
|
Style
|
Styler objects are returned by pandas.DataFrame.style.
Styler constructor#
Styler(data[, precision, table_styles, ...])
Helps style a DataFrame or Series according to the data with HTML and CSS.
Styler.from_custom_template(searchpath[, ...])
Factory function for creating a subclass of Styler.
Styler properties#
Styler.env
Styler.template_html
Styler.template_html_style
Styler.template_html_table
Styler.template_latex
Styler.template_string
Styler.loader
Style application#
Styler.apply(func[, axis, subset])
Apply a CSS-styling function column-wise, row-wise, or table-wise.
Styler.applymap(func[, subset])
Apply a CSS-styling function elementwise.
Styler.apply_index(func[, axis, level])
Apply a CSS-styling function to the index or column headers, level-wise.
Styler.applymap_index(func[, axis, level])
Apply a CSS-styling function to the index or column headers, elementwise.
Styler.format([formatter, subset, na_rep, ...])
Format the text display value of cells.
Styler.format_index([formatter, axis, ...])
Format the text display value of index labels or column headers.
Styler.relabel_index(labels[, axis, level])
Relabel the index, or column header, keys to display a set of specified values.
Styler.hide([subset, axis, level, names])
Hide the entire index / column headers, or specific rows / columns from display.
Styler.concat(other)
Append another Styler to combine the output into a single table.
Styler.set_td_classes(classes)
Set the class attribute of <td> HTML elements.
Styler.set_table_styles([table_styles, ...])
Set the table styles included within the <style> HTML element.
Styler.set_table_attributes(attributes)
Set the table attributes added to the <table> HTML element.
Styler.set_tooltips(ttips[, props, css_class])
Set the DataFrame of strings on Styler generating :hover tooltips.
Styler.set_caption(caption)
Set the text added to a <caption> HTML element.
Styler.set_sticky([axis, pixel_size, levels])
Add CSS to permanently display the index or column headers in a scrolling frame.
Styler.set_properties([subset])
Set defined CSS-properties to each <td> HTML element for the given subset.
Styler.set_uuid(uuid)
Set the uuid applied to id attributes of HTML elements.
Styler.clear()
Reset the Styler, removing any previously applied styles.
Styler.pipe(func, *args, **kwargs)
Apply func(self, *args, **kwargs), and return the result.
Builtin styles#
Styler.highlight_null([color, subset, ...])
Highlight missing values with a style.
Styler.highlight_max([subset, color, axis, ...])
Highlight the maximum with a style.
Styler.highlight_min([subset, color, axis, ...])
Highlight the minimum with a style.
Styler.highlight_between([subset, color, ...])
Highlight a defined range with a style.
Styler.highlight_quantile([subset, color, ...])
Highlight values defined by a quantile with a style.
Styler.background_gradient([cmap, low, ...])
Color the background in a gradient style.
Styler.text_gradient([cmap, low, high, ...])
Color the text in a gradient style.
Styler.bar([subset, axis, color, cmap, ...])
Draw bar chart in the cell backgrounds.
Style export and import#
Styler.to_html([buf, table_uuid, ...])
Write Styler to a file, buffer or string in HTML-CSS format.
Styler.to_latex([buf, column_format, ...])
Write Styler to a file, buffer or string in LaTeX format.
Styler.to_excel(excel_writer[, sheet_name, ...])
Write Styler to an Excel sheet.
Styler.to_string([buf, encoding, ...])
Write Styler to a file, buffer or string in text format.
Styler.export()
Export the styles applied to the current Styler.
Styler.use(styles)
Set the styles on the current Styler.
|
reference/style.html
|
Index
|
Index
|
_
| A
| B
| C
| D
| E
| F
| G
| H
| I
| J
| K
| L
| M
| N
| O
| P
| Q
| R
| S
| T
| U
| V
| W
| X
| Y
| Z
_
__array__() (pandas.Categorical method)
(pandas.Series method)
__call__() (pandas.option_context method)
(pandas.tseries.offsets.BQuarterBegin method)
(pandas.tseries.offsets.BQuarterEnd method)
(pandas.tseries.offsets.BusinessDay method)
(pandas.tseries.offsets.BusinessHour method)
(pandas.tseries.offsets.BusinessMonthBegin method)
(pandas.tseries.offsets.BusinessMonthEnd method)
(pandas.tseries.offsets.BYearBegin method)
(pandas.tseries.offsets.BYearEnd method)
(pandas.tseries.offsets.CustomBusinessDay method)
(pandas.tseries.offsets.CustomBusinessHour method)
(pandas.tseries.offsets.CustomBusinessMonthBegin method)
(pandas.tseries.offsets.CustomBusinessMonthEnd method)
(pandas.tseries.offsets.DateOffset method)
(pandas.tseries.offsets.Day method)
(pandas.tseries.offsets.Easter method)
(pandas.tseries.offsets.FY5253 method)
(pandas.tseries.offsets.FY5253Quarter method)
(pandas.tseries.offsets.Hour method)
(pandas.tseries.offsets.LastWeekOfMonth method)
(pandas.tseries.offsets.Micro method)
(pandas.tseries.offsets.Milli method)
(pandas.tseries.offsets.Minute method)
(pandas.tseries.offsets.MonthBegin method)
(pandas.tseries.offsets.MonthEnd method)
(pandas.tseries.offsets.Nano method)
(pandas.tseries.offsets.QuarterBegin method)
(pandas.tseries.offsets.QuarterEnd method)
(pandas.tseries.offsets.Second method)
(pandas.tseries.offsets.SemiMonthBegin method)
(pandas.tseries.offsets.SemiMonthEnd method)
(pandas.tseries.offsets.Tick method)
(pandas.tseries.offsets.Week method)
(pandas.tseries.offsets.WeekOfMonth method)
(pandas.tseries.offsets.YearBegin method)
(pandas.tseries.offsets.YearEnd method)
__dataframe__() (pandas.DataFrame method)
__iter__() (pandas.core.groupby.GroupBy method)
(pandas.core.resample.Resampler method)
(pandas.DataFrame method)
(pandas.Series method)
_concat_same_type() (pandas.api.extensions.ExtensionArray class method)
_formatter() (pandas.api.extensions.ExtensionArray method)
_from_factorized() (pandas.api.extensions.ExtensionArray class method)
_from_sequence() (pandas.api.extensions.ExtensionArray class method)
_from_sequence_of_strings() (pandas.api.extensions.ExtensionArray class method)
_reduce() (pandas.api.extensions.ExtensionArray method)
_values_for_argsort() (pandas.api.extensions.ExtensionArray method)
_values_for_factorize() (pandas.api.extensions.ExtensionArray method)
A
abs() (pandas.DataFrame method)
(pandas.Series method)
AbstractMethodError
AccessorRegistrationWarning
add() (pandas.DataFrame method)
(pandas.Series method)
add_categories() (pandas.CategoricalIndex method)
(pandas.Series.cat method)
add_prefix() (pandas.DataFrame method)
(pandas.Series method)
add_suffix() (pandas.DataFrame method)
(pandas.Series method)
agg() (pandas.core.groupby.GroupBy method)
(pandas.DataFrame method)
(pandas.Series method)
aggregate() (pandas.core.groupby.DataFrameGroupBy method)
(pandas.core.groupby.SeriesGroupBy method)
(pandas.core.resample.Resampler method)
(pandas.core.window.expanding.Expanding method)
(pandas.core.window.rolling.Rolling method)
(pandas.DataFrame method)
(pandas.Series method)
align() (pandas.DataFrame method)
(pandas.Series method)
all() (pandas.core.groupby.DataFrameGroupBy method)
(pandas.core.groupby.GroupBy method)
(pandas.DataFrame method)
(pandas.Index method)
(pandas.Series method)
allows_duplicate_labels (pandas.Flags property)
andrews_curves() (in module pandas.plotting)
any() (pandas.core.groupby.DataFrameGroupBy method)
(pandas.core.groupby.GroupBy method)
(pandas.DataFrame method)
(pandas.Index method)
(pandas.Series method)
append() (pandas.DataFrame method)
(pandas.HDFStore method)
(pandas.Index method)
(pandas.Series method)
apply() (pandas.core.groupby.GroupBy method)
(pandas.core.resample.Resampler method)
(pandas.core.window.expanding.Expanding method)
(pandas.core.window.rolling.Rolling method)
(pandas.DataFrame method)
(pandas.io.formats.style.Styler method)
(pandas.Series method)
(pandas.tseries.offsets.BQuarterBegin method)
(pandas.tseries.offsets.BQuarterEnd method)
(pandas.tseries.offsets.BusinessDay method)
(pandas.tseries.offsets.BusinessHour method)
(pandas.tseries.offsets.BusinessMonthBegin method)
(pandas.tseries.offsets.BusinessMonthEnd method)
(pandas.tseries.offsets.BYearBegin method)
(pandas.tseries.offsets.BYearEnd method)
(pandas.tseries.offsets.CustomBusinessDay method)
(pandas.tseries.offsets.CustomBusinessHour method)
(pandas.tseries.offsets.CustomBusinessMonthBegin method)
(pandas.tseries.offsets.CustomBusinessMonthEnd method)
(pandas.tseries.offsets.DateOffset method)
(pandas.tseries.offsets.Day method)
(pandas.tseries.offsets.Easter method)
(pandas.tseries.offsets.FY5253 method)
(pandas.tseries.offsets.FY5253Quarter method)
(pandas.tseries.offsets.Hour method)
(pandas.tseries.offsets.LastWeekOfMonth method)
(pandas.tseries.offsets.Micro method)
(pandas.tseries.offsets.Milli method)
(pandas.tseries.offsets.Minute method)
(pandas.tseries.offsets.MonthBegin method)
(pandas.tseries.offsets.MonthEnd method)
(pandas.tseries.offsets.Nano method)
(pandas.tseries.offsets.QuarterBegin method)
(pandas.tseries.offsets.QuarterEnd method)
(pandas.tseries.offsets.Second method)
(pandas.tseries.offsets.SemiMonthBegin method)
(pandas.tseries.offsets.SemiMonthEnd method)
(pandas.tseries.offsets.Tick method)
(pandas.tseries.offsets.Week method)
(pandas.tseries.offsets.WeekOfMonth method)
(pandas.tseries.offsets.YearBegin method)
(pandas.tseries.offsets.YearEnd method)
apply_index() (pandas.io.formats.style.Styler method)
(pandas.tseries.offsets.BQuarterBegin method)
(pandas.tseries.offsets.BQuarterEnd method)
(pandas.tseries.offsets.BusinessDay method)
(pandas.tseries.offsets.BusinessHour method)
(pandas.tseries.offsets.BusinessMonthBegin method)
(pandas.tseries.offsets.BusinessMonthEnd method)
(pandas.tseries.offsets.BYearBegin method)
(pandas.tseries.offsets.BYearEnd method)
(pandas.tseries.offsets.CustomBusinessDay method)
(pandas.tseries.offsets.CustomBusinessHour method)
(pandas.tseries.offsets.CustomBusinessMonthBegin method)
(pandas.tseries.offsets.CustomBusinessMonthEnd method)
(pandas.tseries.offsets.DateOffset method)
(pandas.tseries.offsets.Day method)
(pandas.tseries.offsets.Easter method)
(pandas.tseries.offsets.FY5253 method)
(pandas.tseries.offsets.FY5253Quarter method)
(pandas.tseries.offsets.Hour method)
(pandas.tseries.offsets.LastWeekOfMonth method)
(pandas.tseries.offsets.Micro method)
(pandas.tseries.offsets.Milli method)
(pandas.tseries.offsets.Minute method)
(pandas.tseries.offsets.MonthBegin method)
(pandas.tseries.offsets.MonthEnd method)
(pandas.tseries.offsets.Nano method)
(pandas.tseries.offsets.QuarterBegin method)
(pandas.tseries.offsets.QuarterEnd method)
(pandas.tseries.offsets.Second method)
(pandas.tseries.offsets.SemiMonthBegin method)
(pandas.tseries.offsets.SemiMonthEnd method)
(pandas.tseries.offsets.Tick method)
(pandas.tseries.offsets.Week method)
(pandas.tseries.offsets.WeekOfMonth method)
(pandas.tseries.offsets.YearBegin method)
(pandas.tseries.offsets.YearEnd method)
applymap() (pandas.DataFrame method)
(pandas.io.formats.style.Styler method)
applymap_index() (pandas.io.formats.style.Styler method)
area() (pandas.DataFrame.plot method)
(pandas.Series.plot method)
argmax() (pandas.Index method)
(pandas.Series method)
argmin() (pandas.Index method)
(pandas.Series method)
argsort() (pandas.api.extensions.ExtensionArray method)
(pandas.Index method)
(pandas.Series method)
array (pandas.Index attribute)
(pandas.Series property)
array() (in module pandas)
ArrowDtype (class in pandas)
ArrowExtensionArray (class in pandas.arrays)
ArrowStringArray (class in pandas.arrays)
as_ordered() (pandas.CategoricalIndex method)
(pandas.Series.cat method)
as_unordered() (pandas.CategoricalIndex method)
(pandas.Series.cat method)
asfreq() (pandas.core.resample.Resampler method)
(pandas.DataFrame method)
(pandas.Period method)
(pandas.PeriodIndex method)
(pandas.Series method)
asi8 (pandas.Index property)
asm8 (pandas.Timedelta attribute)
(pandas.Timestamp attribute)
asof() (pandas.DataFrame method)
(pandas.Index method)
(pandas.Series method)
asof_locs() (pandas.Index method)
assert_extension_array_equal() (in module pandas.testing)
assert_frame_equal() (in module pandas.testing)
assert_index_equal() (in module pandas.testing)
assert_series_equal() (in module pandas.testing)
assign() (pandas.DataFrame method)
astimezone() (pandas.Timestamp method)
astype() (pandas.api.extensions.ExtensionArray method)
(pandas.DataFrame method)
(pandas.Index method)
(pandas.Series method)
at (pandas.DataFrame property)
(pandas.Series property)
at_time() (pandas.DataFrame method)
(pandas.Series method)
AttributeConflictWarning
attrs (pandas.DataFrame property)
(pandas.Series property)
autocorr() (pandas.Series method)
autocorrelation_plot() (in module pandas.plotting)
axes (pandas.DataFrame property)
(pandas.Series property)
B
backfill() (pandas.core.groupby.DataFrameGroupBy method)
(pandas.core.groupby.GroupBy method)
(pandas.core.resample.Resampler method)
(pandas.DataFrame method)
(pandas.Series method)
background_gradient() (pandas.io.formats.style.Styler method)
bar() (pandas.DataFrame.plot method)
(pandas.io.formats.style.Styler method)
(pandas.Series.plot method)
barh() (pandas.DataFrame.plot method)
(pandas.Series.plot method)
base (pandas.tseries.offsets.BQuarterBegin attribute)
(pandas.tseries.offsets.BQuarterEnd attribute)
(pandas.tseries.offsets.BusinessDay attribute)
(pandas.tseries.offsets.BusinessHour attribute)
(pandas.tseries.offsets.BusinessMonthBegin attribute)
(pandas.tseries.offsets.BusinessMonthEnd attribute)
(pandas.tseries.offsets.BYearBegin attribute)
(pandas.tseries.offsets.BYearEnd attribute)
(pandas.tseries.offsets.CustomBusinessDay attribute)
(pandas.tseries.offsets.CustomBusinessHour attribute)
(pandas.tseries.offsets.CustomBusinessMonthBegin attribute)
(pandas.tseries.offsets.CustomBusinessMonthEnd attribute)
(pandas.tseries.offsets.DateOffset attribute)
(pandas.tseries.offsets.Day attribute)
(pandas.tseries.offsets.Easter attribute)
(pandas.tseries.offsets.FY5253 attribute)
(pandas.tseries.offsets.FY5253Quarter attribute)
(pandas.tseries.offsets.Hour attribute)
(pandas.tseries.offsets.LastWeekOfMonth attribute)
(pandas.tseries.offsets.Micro attribute)
(pandas.tseries.offsets.Milli attribute)
(pandas.tseries.offsets.Minute attribute)
(pandas.tseries.offsets.MonthBegin attribute)
(pandas.tseries.offsets.MonthEnd attribute)
(pandas.tseries.offsets.Nano attribute)
(pandas.tseries.offsets.QuarterBegin attribute)
(pandas.tseries.offsets.QuarterEnd attribute)
(pandas.tseries.offsets.Second attribute)
(pandas.tseries.offsets.SemiMonthBegin attribute)
(pandas.tseries.offsets.SemiMonthEnd attribute)
(pandas.tseries.offsets.Tick attribute)
(pandas.tseries.offsets.Week attribute)
(pandas.tseries.offsets.WeekOfMonth attribute)
(pandas.tseries.offsets.YearBegin attribute)
(pandas.tseries.offsets.YearEnd attribute)
BaseIndexer (class in pandas.api.indexers)
bdate_range() (in module pandas)
BDay (in module pandas.tseries.offsets)
between() (pandas.Series method)
between_time() (pandas.DataFrame method)
(pandas.Series method)
bfill() (pandas.core.groupby.DataFrameGroupBy method)
(pandas.core.groupby.GroupBy method)
(pandas.core.resample.Resampler method)
(pandas.DataFrame method)
(pandas.Series method)
BMonthBegin (in module pandas.tseries.offsets)
BMonthEnd (in module pandas.tseries.offsets)
book (pandas.ExcelWriter property)
bool() (pandas.DataFrame method)
(pandas.Series method)
BooleanArray (class in pandas.arrays)
BooleanDtype (class in pandas)
bootstrap_plot() (in module pandas.plotting)
box() (pandas.DataFrame.plot method)
(pandas.Series.plot method)
boxplot() (in module pandas.plotting)
(pandas.core.groupby.DataFrameGroupBy method)
(pandas.DataFrame method)
BQuarterBegin (class in pandas.tseries.offsets)
BQuarterEnd (class in pandas.tseries.offsets)
build_table_schema() (in module pandas.io.json)
BusinessDay (class in pandas.tseries.offsets)
BusinessHour (class in pandas.tseries.offsets)
BusinessMonthBegin (class in pandas.tseries.offsets)
BusinessMonthEnd (class in pandas.tseries.offsets)
BYearBegin (class in pandas.tseries.offsets)
BYearEnd (class in pandas.tseries.offsets)
C
calendar (pandas.tseries.offsets.BusinessDay attribute)
(pandas.tseries.offsets.BusinessHour attribute)
(pandas.tseries.offsets.CustomBusinessDay attribute)
(pandas.tseries.offsets.CustomBusinessHour attribute)
(pandas.tseries.offsets.CustomBusinessMonthBegin attribute)
(pandas.tseries.offsets.CustomBusinessMonthEnd attribute)
capitalize() (pandas.Series.str method)
casefold() (pandas.Series.str method)
cat() (pandas.Series method)
(pandas.Series.str method)
Categorical (class in pandas)
CategoricalConversionWarning
CategoricalDtype (class in pandas)
CategoricalIndex (class in pandas)
categories (pandas.Categorical property)
(pandas.CategoricalDtype property)
(pandas.CategoricalIndex property)
(pandas.Series.cat attribute)
cbday_roll (pandas.tseries.offsets.CustomBusinessMonthBegin attribute)
(pandas.tseries.offsets.CustomBusinessMonthEnd attribute)
CBMonthBegin (in module pandas.tseries.offsets)
CBMonthEnd (in module pandas.tseries.offsets)
CDay (in module pandas.tseries.offsets)
ceil() (pandas.DatetimeIndex method)
(pandas.Series.dt method)
(pandas.Timedelta method)
(pandas.TimedeltaIndex method)
(pandas.Timestamp method)
center() (pandas.Series.str method)
check_array_indexer() (in module pandas.api.indexers)
check_extension() (pandas.ExcelWriter class method)
clear() (pandas.io.formats.style.Styler method)
clip() (pandas.DataFrame method)
(pandas.Series method)
close() (pandas.ExcelWriter method)
closed (pandas.arrays.IntervalArray property)
(pandas.Interval attribute)
(pandas.IntervalIndex attribute)
closed_left (pandas.Interval attribute)
closed_right (pandas.Interval attribute)
ClosedFileError
codes (pandas.Categorical property)
(pandas.CategoricalIndex property)
(pandas.MultiIndex property)
(pandas.Series.cat attribute)
columns (pandas.DataFrame attribute)
combine() (pandas.DataFrame method)
(pandas.Series method)
(pandas.Timestamp class method)
combine_first() (pandas.DataFrame method)
(pandas.Series method)
compare() (pandas.DataFrame method)
(pandas.Series method)
components (pandas.Series.dt attribute)
(pandas.Timedelta attribute)
(pandas.TimedeltaIndex property)
concat() (in module pandas)
(pandas.io.formats.style.Styler method)
construct_array_type() (pandas.api.extensions.ExtensionDtype class method)
construct_from_string() (pandas.api.extensions.ExtensionDtype class method)
contains() (pandas.arrays.IntervalArray method)
(pandas.IntervalIndex method)
(pandas.Series.str method)
convert_dtypes() (pandas.DataFrame method)
(pandas.Series method)
copy() (pandas.api.extensions.ExtensionArray method)
(pandas.DataFrame method)
(pandas.Index method)
(pandas.Series method)
(pandas.tseries.offsets.BQuarterBegin method)
(pandas.tseries.offsets.BQuarterEnd method)
(pandas.tseries.offsets.BusinessDay method)
(pandas.tseries.offsets.BusinessHour method)
(pandas.tseries.offsets.BusinessMonthBegin method)
(pandas.tseries.offsets.BusinessMonthEnd method)
(pandas.tseries.offsets.BYearBegin method)
(pandas.tseries.offsets.BYearEnd method)
(pandas.tseries.offsets.CustomBusinessDay method)
(pandas.tseries.offsets.CustomBusinessHour method)
(pandas.tseries.offsets.CustomBusinessMonthBegin method)
(pandas.tseries.offsets.CustomBusinessMonthEnd method)
(pandas.tseries.offsets.DateOffset method)
(pandas.tseries.offsets.Day method)
(pandas.tseries.offsets.Easter method)
(pandas.tseries.offsets.FY5253 method)
(pandas.tseries.offsets.FY5253Quarter method)
(pandas.tseries.offsets.Hour method)
(pandas.tseries.offsets.LastWeekOfMonth method)
(pandas.tseries.offsets.Micro method)
(pandas.tseries.offsets.Milli method)
(pandas.tseries.offsets.Minute method)
(pandas.tseries.offsets.MonthBegin method)
(pandas.tseries.offsets.MonthEnd method)
(pandas.tseries.offsets.Nano method)
(pandas.tseries.offsets.QuarterBegin method)
(pandas.tseries.offsets.QuarterEnd method)
(pandas.tseries.offsets.Second method)
(pandas.tseries.offsets.SemiMonthBegin method)
(pandas.tseries.offsets.SemiMonthEnd method)
(pandas.tseries.offsets.Tick method)
(pandas.tseries.offsets.Week method)
(pandas.tseries.offsets.WeekOfMonth method)
(pandas.tseries.offsets.YearBegin method)
(pandas.tseries.offsets.YearEnd method)
corr (pandas.core.groupby.DataFrameGroupBy property)
corr() (pandas.core.window.ewm.ExponentialMovingWindow method)
(pandas.core.window.expanding.Expanding method)
(pandas.core.window.rolling.Rolling method)
(pandas.DataFrame method)
(pandas.Series method)
corrwith (pandas.core.groupby.DataFrameGroupBy property)
corrwith() (pandas.DataFrame method)
count() (pandas.core.groupby.DataFrameGroupBy method)
(pandas.core.groupby.GroupBy method)
(pandas.core.resample.Resampler method)
(pandas.core.window.expanding.Expanding method)
(pandas.core.window.rolling.Rolling method)
(pandas.DataFrame method)
(pandas.Series method)
(pandas.Series.str method)
cov (pandas.core.groupby.DataFrameGroupBy property)
cov() (pandas.core.window.ewm.ExponentialMovingWindow method)
(pandas.core.window.expanding.Expanding method)
(pandas.core.window.rolling.Rolling method)
(pandas.DataFrame method)
(pandas.Series method)
crosstab() (in module pandas)
CSSWarning
ctime() (pandas.Timestamp method)
cumcount() (pandas.core.groupby.DataFrameGroupBy method)
(pandas.core.groupby.GroupBy method)
cummax() (pandas.core.groupby.DataFrameGroupBy method)
(pandas.core.groupby.GroupBy method)
(pandas.DataFrame method)
(pandas.Series method)
cummin() (pandas.core.groupby.DataFrameGroupBy method)
(pandas.core.groupby.GroupBy method)
(pandas.DataFrame method)
(pandas.Series method)
cumprod() (pandas.core.groupby.DataFrameGroupBy method)
(pandas.core.groupby.GroupBy method)
(pandas.DataFrame method)
(pandas.Series method)
cumsum() (pandas.core.groupby.DataFrameGroupBy method)
(pandas.core.groupby.GroupBy method)
(pandas.DataFrame method)
(pandas.Series method)
cur_sheet (pandas.ExcelWriter property)
CustomBusinessDay (class in pandas.tseries.offsets)
CustomBusinessHour (class in pandas.tseries.offsets)
CustomBusinessMonthBegin (class in pandas.tseries.offsets)
CustomBusinessMonthEnd (class in pandas.tseries.offsets)
cut() (in module pandas)
D
data_label (pandas.io.stata.StataReader property)
DatabaseError
DataError
DataFrame (class in pandas)
date (pandas.DatetimeIndex property)
(pandas.Series.dt attribute)
date() (pandas.Timestamp method)
date_format (pandas.ExcelWriter property)
date_range() (in module pandas)
DateOffset (class in pandas.tseries.offsets)
datetime_format (pandas.ExcelWriter property)
DatetimeArray (class in pandas.arrays)
DatetimeIndex (class in pandas)
DatetimeTZDtype (class in pandas)
Day (class in pandas.tseries.offsets)
day (pandas.DatetimeIndex property)
(pandas.Period attribute)
(pandas.PeriodIndex property)
(pandas.Series.dt attribute)
(pandas.Timestamp attribute)
day_name() (pandas.DatetimeIndex method)
(pandas.Series.dt method)
(pandas.Timestamp method)
day_of_month (pandas.tseries.offsets.SemiMonthBegin attribute)
(pandas.tseries.offsets.SemiMonthEnd attribute)
day_of_week (pandas.DatetimeIndex property)
(pandas.Period attribute)
(pandas.PeriodIndex property)
(pandas.Series.dt attribute)
(pandas.Timestamp attribute)
day_of_year (pandas.DatetimeIndex property)
(pandas.Period attribute)
(pandas.PeriodIndex property)
(pandas.Series.dt attribute)
(pandas.Timestamp attribute)
dayofweek (pandas.DatetimeIndex property)
(pandas.Period attribute)
(pandas.PeriodIndex property)
(pandas.Series.dt attribute)
(pandas.Timestamp attribute)
dayofyear (pandas.DatetimeIndex property)
(pandas.Period attribute)
(pandas.PeriodIndex property)
(pandas.Series.dt attribute)
(pandas.Timestamp attribute)
days (pandas.Series.dt attribute)
(pandas.Timedelta attribute)
(pandas.TimedeltaIndex property)
days_in_month (pandas.Period attribute)
(pandas.PeriodIndex property)
(pandas.Series.dt attribute)
(pandas.Timestamp attribute)
daysinmonth (pandas.Period attribute)
(pandas.PeriodIndex property)
(pandas.Series.dt attribute)
(pandas.Timestamp attribute)
decode() (pandas.Series.str method)
delete() (pandas.Index method)
delta (pandas.Timedelta attribute)
(pandas.tseries.offsets.Day attribute)
(pandas.tseries.offsets.Hour attribute)
(pandas.tseries.offsets.Micro attribute)
(pandas.tseries.offsets.Milli attribute)
(pandas.tseries.offsets.Minute attribute)
(pandas.tseries.offsets.Nano attribute)
(pandas.tseries.offsets.Second attribute)
(pandas.tseries.offsets.Tick attribute)
density (pandas.DataFrame.sparse attribute)
(pandas.Series.sparse attribute)
density() (pandas.DataFrame.plot method)
(pandas.Series.plot method)
deregister_matplotlib_converters() (in module pandas.plotting)
describe() (pandas.core.groupby.DataFrameGroupBy method)
(pandas.DataFrame method)
(pandas.Series method)
describe_option (in module pandas)
diff() (pandas.core.groupby.DataFrameGroupBy method)
(pandas.DataFrame method)
(pandas.Series method)
difference() (pandas.Index method)
div() (pandas.DataFrame method)
(pandas.Series method)
divide() (pandas.DataFrame method)
(pandas.Series method)
divmod() (pandas.Series method)
dot() (pandas.DataFrame method)
(pandas.Series method)
drop() (pandas.DataFrame method)
(pandas.Index method)
(pandas.Series method)
drop_duplicates() (pandas.DataFrame method)
(pandas.Index method)
(pandas.Series method)
droplevel() (pandas.DataFrame method)
(pandas.Index method)
(pandas.MultiIndex method)
(pandas.Series method)
dropna() (pandas.api.extensions.ExtensionArray method)
(pandas.DataFrame method)
(pandas.Index method)
(pandas.Series method)
dst() (pandas.Timestamp method)
dt() (pandas.Series method)
dtype (pandas.api.extensions.ExtensionArray property)
(pandas.Categorical property)
(pandas.Index attribute)
(pandas.Series property)
dtypes (pandas.DataFrame property)
(pandas.MultiIndex attribute)
(pandas.Series property)
DtypeWarning
duplicated() (pandas.DataFrame method)
(pandas.Index method)
(pandas.Series method)
DuplicateLabelError
E
Easter (class in pandas.tseries.offsets)
empty (pandas.DataFrame property)
(pandas.Index property)
(pandas.Series property)
empty() (pandas.api.extensions.ExtensionDtype method)
EmptyDataError
encode() (pandas.Series.str method)
end (pandas.tseries.offsets.BusinessHour attribute)
(pandas.tseries.offsets.CustomBusinessHour attribute)
end_time (pandas.Period attribute)
(pandas.PeriodIndex property)
(pandas.Series.dt attribute)
endswith() (pandas.Series.str method)
engine (pandas.ExcelWriter property)
env (pandas.io.formats.style.Styler attribute)
eq() (pandas.DataFrame method)
(pandas.Series method)
equals() (pandas.api.extensions.ExtensionArray method)
(pandas.CategoricalIndex method)
(pandas.DataFrame method)
(pandas.Index method)
(pandas.Series method)
eval() (in module pandas)
(pandas.DataFrame method)
ewm() (pandas.DataFrame method)
(pandas.Series method)
ExcelWriter (class in pandas)
expanding() (pandas.DataFrame method)
(pandas.Series method)
explode() (pandas.DataFrame method)
(pandas.Series method)
export() (pandas.io.formats.style.Styler method)
ExtensionArray (class in pandas.api.extensions)
ExtensionDtype (class in pandas.api.extensions)
extract() (pandas.Series.str method)
extractall() (pandas.Series.str method)
F
factorize() (in module pandas)
(pandas.api.extensions.ExtensionArray method)
(pandas.Index method)
(pandas.Series method)
ffill() (pandas.core.groupby.DataFrameGroupBy method)
(pandas.core.groupby.GroupBy method)
(pandas.core.resample.Resampler method)
(pandas.DataFrame method)
(pandas.Series method)
fill_value (pandas.Series.sparse attribute)
fillna (pandas.core.groupby.DataFrameGroupBy property)
fillna() (pandas.api.extensions.ExtensionArray method)
(pandas.core.resample.Resampler method)
(pandas.DataFrame method)
(pandas.Index method)
(pandas.Series method)
filter() (pandas.core.groupby.DataFrameGroupBy method)
(pandas.DataFrame method)
(pandas.Series method)
find() (pandas.Series.str method)
findall() (pandas.Series.str method)
first() (pandas.core.groupby.GroupBy method)
(pandas.core.resample.Resampler method)
(pandas.DataFrame method)
(pandas.Series method)
first_valid_index() (pandas.DataFrame method)
(pandas.Series method)
FixedForwardWindowIndexer (class in pandas.api.indexers)
Flags (class in pandas)
flags (pandas.DataFrame property)
(pandas.Series property)
Float64Index (class in pandas)
floor() (pandas.DatetimeIndex method)
(pandas.Series.dt method)
(pandas.Timedelta method)
(pandas.TimedeltaIndex method)
(pandas.Timestamp method)
floordiv() (pandas.DataFrame method)
(pandas.Series method)
fold (pandas.Timestamp attribute)
format() (pandas.Index method)
(pandas.io.formats.style.Styler method)
format_index() (pandas.io.formats.style.Styler method)
freq (pandas.DatetimeIndex property)
(pandas.Period attribute)
(pandas.PeriodDtype property)
(pandas.PeriodIndex property)
(pandas.Series.dt attribute)
(pandas.Timedelta attribute)
(pandas.Timestamp attribute)
freqstr (pandas.DatetimeIndex property)
(pandas.Period attribute)
(pandas.PeriodIndex property)
(pandas.Timestamp property)
(pandas.tseries.offsets.BQuarterBegin attribute)
(pandas.tseries.offsets.BQuarterEnd attribute)
(pandas.tseries.offsets.BusinessDay attribute)
(pandas.tseries.offsets.BusinessHour attribute)
(pandas.tseries.offsets.BusinessMonthBegin attribute)
(pandas.tseries.offsets.BusinessMonthEnd attribute)
(pandas.tseries.offsets.BYearBegin attribute)
(pandas.tseries.offsets.BYearEnd attribute)
(pandas.tseries.offsets.CustomBusinessDay attribute)
(pandas.tseries.offsets.CustomBusinessHour attribute)
(pandas.tseries.offsets.CustomBusinessMonthBegin attribute)
(pandas.tseries.offsets.CustomBusinessMonthEnd attribute)
(pandas.tseries.offsets.DateOffset attribute)
(pandas.tseries.offsets.Day attribute)
(pandas.tseries.offsets.Easter attribute)
(pandas.tseries.offsets.FY5253 attribute)
(pandas.tseries.offsets.FY5253Quarter attribute)
(pandas.tseries.offsets.Hour attribute)
(pandas.tseries.offsets.LastWeekOfMonth attribute)
(pandas.tseries.offsets.Micro attribute)
(pandas.tseries.offsets.Milli attribute)
(pandas.tseries.offsets.Minute attribute)
(pandas.tseries.offsets.MonthBegin attribute)
(pandas.tseries.offsets.MonthEnd attribute)
(pandas.tseries.offsets.Nano attribute)
(pandas.tseries.offsets.QuarterBegin attribute)
(pandas.tseries.offsets.QuarterEnd attribute)
(pandas.tseries.offsets.Second attribute)
(pandas.tseries.offsets.SemiMonthBegin attribute)
(pandas.tseries.offsets.SemiMonthEnd attribute)
(pandas.tseries.offsets.Tick attribute)
(pandas.tseries.offsets.Week attribute)
(pandas.tseries.offsets.WeekOfMonth attribute)
(pandas.tseries.offsets.YearBegin attribute)
(pandas.tseries.offsets.YearEnd attribute)
from_arrays() (pandas.arrays.IntervalArray class method)
(pandas.IntervalIndex class method)
(pandas.MultiIndex class method)
from_breaks() (pandas.arrays.IntervalArray class method)
(pandas.IntervalIndex class method)
from_codes() (pandas.Categorical class method)
from_coo() (pandas.Series.sparse class method)
from_custom_template() (pandas.io.formats.style.Styler class method)
from_dataframe() (in module pandas.api.interchange)
from_dict() (pandas.DataFrame class method)
from_dummies() (in module pandas)
from_frame() (pandas.MultiIndex class method)
from_product() (pandas.MultiIndex class method)
from_range() (pandas.RangeIndex class method)
from_records() (pandas.DataFrame class method)
from_spmatrix() (pandas.DataFrame.sparse class method)
from_tuples() (pandas.arrays.IntervalArray class method)
(pandas.IntervalIndex class method)
(pandas.MultiIndex class method)
fromisocalendar() (pandas.Timestamp method)
fromisoformat() (pandas.Timestamp method)
fromordinal() (pandas.Timestamp class method)
fromtimestamp() (pandas.Timestamp class method)
fullmatch() (pandas.Series.str method)
FY5253 (class in pandas.tseries.offsets)
FY5253Quarter (class in pandas.tseries.offsets)
G
ge() (pandas.DataFrame method)
(pandas.Series method)
get() (pandas.DataFrame method)
(pandas.HDFStore method)
(pandas.Series method)
(pandas.Series.str method)
get_dummies() (in module pandas)
(pandas.Series.str method)
get_group() (pandas.core.groupby.GroupBy method)
(pandas.core.resample.Resampler method)
get_indexer() (pandas.Index method)
(pandas.IntervalIndex method)
(pandas.MultiIndex method)
get_indexer_for() (pandas.Index method)
get_indexer_non_unique() (pandas.Index method)
get_level_values() (pandas.Index method)
(pandas.MultiIndex method)
get_loc() (pandas.Index method)
(pandas.IntervalIndex method)
(pandas.MultiIndex method)
get_loc_level() (pandas.MultiIndex method)
get_locs() (pandas.MultiIndex method)
get_option (in module pandas)
get_rule_code_suffix() (pandas.tseries.offsets.FY5253 method)
(pandas.tseries.offsets.FY5253Quarter method)
get_slice_bound() (pandas.Index method)
get_value() (pandas.Index method)
get_weeks() (pandas.tseries.offsets.FY5253Quarter method)
get_window_bounds() (pandas.api.indexers.BaseIndexer method)
(pandas.api.indexers.FixedForwardWindowIndexer method)
(pandas.api.indexers.VariableOffsetWindowIndexer method)
get_year_end() (pandas.tseries.offsets.FY5253 method)
groupby() (pandas.DataFrame method)
(pandas.Index method)
(pandas.Series method)
Grouper (class in pandas)
groups (pandas.core.groupby.GroupBy property)
(pandas.core.resample.Resampler property)
groups() (pandas.HDFStore method)
gt() (pandas.DataFrame method)
(pandas.Series method)
H
handles (pandas.ExcelWriter property)
has_duplicates (pandas.Index property)
hash_array() (in module pandas.util)
hash_pandas_object() (in module pandas.util)
hasnans (pandas.Index attribute)
(pandas.Series property)
head() (pandas.core.groupby.GroupBy method)
(pandas.DataFrame method)
(pandas.Series method)
hexbin() (pandas.DataFrame.plot method)
hide() (pandas.io.formats.style.Styler method)
hide_columns() (pandas.io.formats.style.Styler method)
hide_index() (pandas.io.formats.style.Styler method)
highlight_between() (pandas.io.formats.style.Styler method)
highlight_max() (pandas.io.formats.style.Styler method)
highlight_min() (pandas.io.formats.style.Styler method)
highlight_null() (pandas.io.formats.style.Styler method)
highlight_quantile() (pandas.io.formats.style.Styler method)
hist (pandas.core.groupby.DataFrameGroupBy property)
(pandas.core.groupby.SeriesGroupBy property)
hist() (pandas.DataFrame method)
(pandas.DataFrame.plot method)
(pandas.Series method)
(pandas.Series.plot method)
holds_integer() (pandas.Index method)
holidays (pandas.tseries.offsets.BusinessDay attribute)
(pandas.tseries.offsets.BusinessHour attribute)
(pandas.tseries.offsets.CustomBusinessDay attribute)
(pandas.tseries.offsets.CustomBusinessHour attribute)
(pandas.tseries.offsets.CustomBusinessMonthBegin attribute)
(pandas.tseries.offsets.CustomBusinessMonthEnd attribute)
Hour (class in pandas.tseries.offsets)
hour (pandas.DatetimeIndex property)
(pandas.Period attribute)
(pandas.PeriodIndex property)
(pandas.Series.dt attribute)
(pandas.Timestamp attribute)
I
iat (pandas.DataFrame property)
(pandas.Series property)
identical() (pandas.Index method)
idxmax() (pandas.core.groupby.DataFrameGroupBy method)
(pandas.DataFrame method)
(pandas.Series method)
idxmin() (pandas.core.groupby.DataFrameGroupBy method)
(pandas.DataFrame method)
(pandas.Series method)
if_sheet_exists (pandas.ExcelWriter property)
iloc (pandas.DataFrame property)
(pandas.Series property)
IncompatibilityWarning
Index (class in pandas)
index (pandas.DataFrame attribute)
(pandas.Series attribute)
index() (pandas.Series.str method)
indexer_at_time() (pandas.DatetimeIndex method)
indexer_between_time() (pandas.DatetimeIndex method)
IndexingError
IndexSlice (in module pandas)
indices (pandas.core.groupby.GroupBy property)
(pandas.core.resample.Resampler property)
infer_dtype() (in module pandas.api.types)
infer_freq() (in module pandas)
infer_objects() (pandas.DataFrame method)
(pandas.Series method)
inferred_freq (pandas.DatetimeIndex attribute)
(pandas.TimedeltaIndex attribute)
inferred_type (pandas.Index attribute)
info() (pandas.DataFrame method)
(pandas.HDFStore method)
(pandas.Series method)
insert() (pandas.api.extensions.ExtensionArray method)
(pandas.DataFrame method)
(pandas.Index method)
Int16Dtype (class in pandas)
Int32Dtype (class in pandas)
Int64Dtype (class in pandas)
Int64Index (class in pandas)
Int8Dtype (class in pandas)
IntCastingNaNError
IntegerArray (class in pandas.arrays)
interpolate() (pandas.core.resample.Resampler method)
(pandas.DataFrame method)
(pandas.Series method)
intersection() (pandas.Index method)
Interval (class in pandas)
interval_range() (in module pandas)
IntervalArray (class in pandas.arrays)
IntervalDtype (class in pandas)
IntervalIndex (class in pandas)
InvalidColumnName
InvalidIndexError
is_() (pandas.Index method)
is_all_dates (pandas.Index attribute)
is_anchored() (pandas.tseries.offsets.BQuarterBegin method)
(pandas.tseries.offsets.BQuarterEnd method)
(pandas.tseries.offsets.BusinessDay method)
(pandas.tseries.offsets.BusinessHour method)
(pandas.tseries.offsets.BusinessMonthBegin method)
(pandas.tseries.offsets.BusinessMonthEnd method)
(pandas.tseries.offsets.BYearBegin method)
(pandas.tseries.offsets.BYearEnd method)
(pandas.tseries.offsets.CustomBusinessDay method)
(pandas.tseries.offsets.CustomBusinessHour method)
(pandas.tseries.offsets.CustomBusinessMonthBegin method)
(pandas.tseries.offsets.CustomBusinessMonthEnd method)
(pandas.tseries.offsets.DateOffset method)
(pandas.tseries.offsets.Day method)
(pandas.tseries.offsets.Easter method)
(pandas.tseries.offsets.FY5253 method)
(pandas.tseries.offsets.FY5253Quarter method)
(pandas.tseries.offsets.Hour method)
(pandas.tseries.offsets.LastWeekOfMonth method)
(pandas.tseries.offsets.Micro method)
(pandas.tseries.offsets.Milli method)
(pandas.tseries.offsets.Minute method)
(pandas.tseries.offsets.MonthBegin method)
(pandas.tseries.offsets.MonthEnd method)
(pandas.tseries.offsets.Nano method)
(pandas.tseries.offsets.QuarterBegin method)
(pandas.tseries.offsets.QuarterEnd method)
(pandas.tseries.offsets.Second method)
(pandas.tseries.offsets.SemiMonthBegin method)
(pandas.tseries.offsets.SemiMonthEnd method)
(pandas.tseries.offsets.Tick method)
(pandas.tseries.offsets.Week method)
(pandas.tseries.offsets.WeekOfMonth method)
(pandas.tseries.offsets.YearBegin method)
(pandas.tseries.offsets.YearEnd method)
is_bool() (in module pandas.api.types)
is_bool_dtype() (in module pandas.api.types)
is_boolean() (pandas.Index method)
is_categorical() (in module pandas.api.types)
(pandas.Index method)
is_categorical_dtype() (in module pandas.api.types)
is_complex() (in module pandas.api.types)
is_complex_dtype() (in module pandas.api.types)
is_datetime64_any_dtype() (in module pandas.api.types)
is_datetime64_dtype() (in module pandas.api.types)
is_datetime64_ns_dtype() (in module pandas.api.types)
is_datetime64tz_dtype() (in module pandas.api.types)
is_dict_like() (in module pandas.api.types)
is_dtype() (pandas.api.extensions.ExtensionDtype class method)
is_empty (pandas.arrays.IntervalArray attribute)
(pandas.Interval attribute)
(pandas.IntervalIndex property)
is_extension_array_dtype() (in module pandas.api.types)
is_extension_type() (in module pandas.api.types)
is_file_like() (in module pandas.api.types)
is_float() (in module pandas.api.types)
is_float_dtype() (in module pandas.api.types)
is_floating() (pandas.Index method)
is_hashable() (in module pandas.api.types)
is_int64_dtype() (in module pandas.api.types)
is_integer() (in module pandas.api.types)
(pandas.Index method)
is_integer_dtype() (in module pandas.api.types)
is_interval() (in module pandas.api.types)
(pandas.Index method)
is_interval_dtype() (in module pandas.api.types)
is_iterator() (in module pandas.api.types)
is_leap_year (pandas.DatetimeIndex property)
(pandas.Period attribute)
(pandas.PeriodIndex property)
(pandas.Series.dt attribute)
(pandas.Timestamp attribute)
is_list_like() (in module pandas.api.types)
is_mixed() (pandas.Index method)
is_monotonic (pandas.Index property)
(pandas.Series property)
is_monotonic_decreasing (pandas.core.groupby.SeriesGroupBy property)
(pandas.Index property)
(pandas.Series property)
is_monotonic_increasing (pandas.core.groupby.SeriesGroupBy property)
(pandas.Index property)
(pandas.Series property)
is_month_end (pandas.DatetimeIndex property)
(pandas.Series.dt attribute)
(pandas.Timestamp attribute)
is_month_end() (pandas.tseries.offsets.BQuarterBegin method)
(pandas.tseries.offsets.BQuarterEnd method)
(pandas.tseries.offsets.BusinessDay method)
(pandas.tseries.offsets.BusinessHour method)
(pandas.tseries.offsets.BusinessMonthBegin method)
(pandas.tseries.offsets.BusinessMonthEnd method)
(pandas.tseries.offsets.BYearBegin method)
(pandas.tseries.offsets.BYearEnd method)
(pandas.tseries.offsets.CustomBusinessDay method)
(pandas.tseries.offsets.CustomBusinessHour method)
(pandas.tseries.offsets.CustomBusinessMonthBegin method)
(pandas.tseries.offsets.CustomBusinessMonthEnd method)
(pandas.tseries.offsets.DateOffset method)
(pandas.tseries.offsets.Day method)
(pandas.tseries.offsets.Easter method)
(pandas.tseries.offsets.FY5253 method)
(pandas.tseries.offsets.FY5253Quarter method)
(pandas.tseries.offsets.Hour method)
(pandas.tseries.offsets.LastWeekOfMonth method)
(pandas.tseries.offsets.Micro method)
(pandas.tseries.offsets.Milli method)
(pandas.tseries.offsets.Minute method)
(pandas.tseries.offsets.MonthBegin method)
(pandas.tseries.offsets.MonthEnd method)
(pandas.tseries.offsets.Nano method)
(pandas.tseries.offsets.QuarterBegin method)
(pandas.tseries.offsets.QuarterEnd method)
(pandas.tseries.offsets.Second method)
(pandas.tseries.offsets.SemiMonthBegin method)
(pandas.tseries.offsets.SemiMonthEnd method)
(pandas.tseries.offsets.Tick method)
(pandas.tseries.offsets.Week method)
(pandas.tseries.offsets.WeekOfMonth method)
(pandas.tseries.offsets.YearBegin method)
(pandas.tseries.offsets.YearEnd method)
is_month_start (pandas.DatetimeIndex property)
(pandas.Series.dt attribute)
(pandas.Timestamp attribute)
is_month_start() (pandas.tseries.offsets.BQuarterBegin method)
(pandas.tseries.offsets.BQuarterEnd method)
(pandas.tseries.offsets.BusinessDay method)
(pandas.tseries.offsets.BusinessHour method)
(pandas.tseries.offsets.BusinessMonthBegin method)
(pandas.tseries.offsets.BusinessMonthEnd method)
(pandas.tseries.offsets.BYearBegin method)
(pandas.tseries.offsets.BYearEnd method)
(pandas.tseries.offsets.CustomBusinessDay method)
(pandas.tseries.offsets.CustomBusinessHour method)
(pandas.tseries.offsets.CustomBusinessMonthBegin method)
(pandas.tseries.offsets.CustomBusinessMonthEnd method)
(pandas.tseries.offsets.DateOffset method)
(pandas.tseries.offsets.Day method)
(pandas.tseries.offsets.Easter method)
(pandas.tseries.offsets.FY5253 method)
(pandas.tseries.offsets.FY5253Quarter method)
(pandas.tseries.offsets.Hour method)
(pandas.tseries.offsets.LastWeekOfMonth method)
(pandas.tseries.offsets.Micro method)
(pandas.tseries.offsets.Milli method)
(pandas.tseries.offsets.Minute method)
(pandas.tseries.offsets.MonthBegin method)
(pandas.tseries.offsets.MonthEnd method)
(pandas.tseries.offsets.Nano method)
(pandas.tseries.offsets.QuarterBegin method)
(pandas.tseries.offsets.QuarterEnd method)
(pandas.tseries.offsets.Second method)
(pandas.tseries.offsets.SemiMonthBegin method)
(pandas.tseries.offsets.SemiMonthEnd method)
(pandas.tseries.offsets.Tick method)
(pandas.tseries.offsets.Week method)
(pandas.tseries.offsets.WeekOfMonth method)
(pandas.tseries.offsets.YearBegin method)
(pandas.tseries.offsets.YearEnd method)
is_named_tuple() (in module pandas.api.types)
is_non_overlapping_monotonic (pandas.arrays.IntervalArray property)
(pandas.IntervalIndex attribute)
is_number() (in module pandas.api.types)
is_numeric() (pandas.Index method)
is_numeric_dtype() (in module pandas.api.types)
is_object() (pandas.Index method)
is_object_dtype() (in module pandas.api.types)
is_on_offset() (pandas.tseries.offsets.BQuarterBegin method)
(pandas.tseries.offsets.BQuarterEnd method)
(pandas.tseries.offsets.BusinessDay method)
(pandas.tseries.offsets.BusinessHour method)
(pandas.tseries.offsets.BusinessMonthBegin method)
(pandas.tseries.offsets.BusinessMonthEnd method)
(pandas.tseries.offsets.BYearBegin method)
(pandas.tseries.offsets.BYearEnd method)
(pandas.tseries.offsets.CustomBusinessDay method)
(pandas.tseries.offsets.CustomBusinessHour method)
(pandas.tseries.offsets.CustomBusinessMonthBegin method)
(pandas.tseries.offsets.CustomBusinessMonthEnd method)
(pandas.tseries.offsets.DateOffset method)
(pandas.tseries.offsets.Day method)
(pandas.tseries.offsets.Easter method)
(pandas.tseries.offsets.FY5253 method)
(pandas.tseries.offsets.FY5253Quarter method)
(pandas.tseries.offsets.Hour method)
(pandas.tseries.offsets.LastWeekOfMonth method)
(pandas.tseries.offsets.Micro method)
(pandas.tseries.offsets.Milli method)
(pandas.tseries.offsets.Minute method)
(pandas.tseries.offsets.MonthBegin method)
(pandas.tseries.offsets.MonthEnd method)
(pandas.tseries.offsets.Nano method)
(pandas.tseries.offsets.QuarterBegin method)
(pandas.tseries.offsets.QuarterEnd method)
(pandas.tseries.offsets.Second method)
(pandas.tseries.offsets.SemiMonthBegin method)
(pandas.tseries.offsets.SemiMonthEnd method)
(pandas.tseries.offsets.Tick method)
(pandas.tseries.offsets.Week method)
(pandas.tseries.offsets.WeekOfMonth method)
(pandas.tseries.offsets.YearBegin method)
(pandas.tseries.offsets.YearEnd method)
is_overlapping (pandas.IntervalIndex property)
is_period_dtype() (in module pandas.api.types)
is_populated (pandas.Timedelta attribute)
is_quarter_end (pandas.DatetimeIndex property)
(pandas.Series.dt attribute)
(pandas.Timestamp attribute)
is_quarter_end() (pandas.tseries.offsets.BQuarterBegin method)
(pandas.tseries.offsets.BQuarterEnd method)
(pandas.tseries.offsets.BusinessDay method)
(pandas.tseries.offsets.BusinessHour method)
(pandas.tseries.offsets.BusinessMonthBegin method)
(pandas.tseries.offsets.BusinessMonthEnd method)
(pandas.tseries.offsets.BYearBegin method)
(pandas.tseries.offsets.BYearEnd method)
(pandas.tseries.offsets.CustomBusinessDay method)
(pandas.tseries.offsets.CustomBusinessHour method)
(pandas.tseries.offsets.CustomBusinessMonthBegin method)
(pandas.tseries.offsets.CustomBusinessMonthEnd method)
(pandas.tseries.offsets.DateOffset method)
(pandas.tseries.offsets.Day method)
(pandas.tseries.offsets.Easter method)
(pandas.tseries.offsets.FY5253 method)
(pandas.tseries.offsets.FY5253Quarter method)
(pandas.tseries.offsets.Hour method)
(pandas.tseries.offsets.LastWeekOfMonth method)
(pandas.tseries.offsets.Micro method)
(pandas.tseries.offsets.Milli method)
(pandas.tseries.offsets.Minute method)
(pandas.tseries.offsets.MonthBegin method)
(pandas.tseries.offsets.MonthEnd method)
(pandas.tseries.offsets.Nano method)
(pandas.tseries.offsets.QuarterBegin method)
(pandas.tseries.offsets.QuarterEnd method)
(pandas.tseries.offsets.Second method)
(pandas.tseries.offsets.SemiMonthBegin method)
(pandas.tseries.offsets.SemiMonthEnd method)
(pandas.tseries.offsets.Tick method)
(pandas.tseries.offsets.Week method)
(pandas.tseries.offsets.WeekOfMonth method)
(pandas.tseries.offsets.YearBegin method)
(pandas.tseries.offsets.YearEnd method)
is_quarter_start (pandas.DatetimeIndex property)
(pandas.Series.dt attribute)
(pandas.Timestamp attribute)
is_quarter_start() (pandas.tseries.offsets.BQuarterBegin method)
(pandas.tseries.offsets.BQuarterEnd method)
(pandas.tseries.offsets.BusinessDay method)
(pandas.tseries.offsets.BusinessHour method)
(pandas.tseries.offsets.BusinessMonthBegin method)
(pandas.tseries.offsets.BusinessMonthEnd method)
(pandas.tseries.offsets.BYearBegin method)
(pandas.tseries.offsets.BYearEnd method)
(pandas.tseries.offsets.CustomBusinessDay method)
(pandas.tseries.offsets.CustomBusinessHour method)
(pandas.tseries.offsets.CustomBusinessMonthBegin method)
(pandas.tseries.offsets.CustomBusinessMonthEnd method)
(pandas.tseries.offsets.DateOffset method)
(pandas.tseries.offsets.Day method)
(pandas.tseries.offsets.Easter method)
(pandas.tseries.offsets.FY5253 method)
(pandas.tseries.offsets.FY5253Quarter method)
(pandas.tseries.offsets.Hour method)
(pandas.tseries.offsets.LastWeekOfMonth method)
(pandas.tseries.offsets.Micro method)
(pandas.tseries.offsets.Milli method)
(pandas.tseries.offsets.Minute method)
(pandas.tseries.offsets.MonthBegin method)
(pandas.tseries.offsets.MonthEnd method)
(pandas.tseries.offsets.Nano method)
(pandas.tseries.offsets.QuarterBegin method)
(pandas.tseries.offsets.QuarterEnd method)
(pandas.tseries.offsets.Second method)
(pandas.tseries.offsets.SemiMonthBegin method)
(pandas.tseries.offsets.SemiMonthEnd method)
(pandas.tseries.offsets.Tick method)
(pandas.tseries.offsets.Week method)
(pandas.tseries.offsets.WeekOfMonth method)
(pandas.tseries.offsets.YearBegin method)
(pandas.tseries.offsets.YearEnd method)
is_re() (in module pandas.api.types)
is_re_compilable() (in module pandas.api.types)
is_scalar() (in module pandas.api.types)
is_signed_integer_dtype() (in module pandas.api.types)
is_sparse() (in module pandas.api.types)
is_string_dtype() (in module pandas.api.types)
is_timedelta64_dtype() (in module pandas.api.types)
is_timedelta64_ns_dtype() (in module pandas.api.types)
is_type_compatible() (pandas.Index method)
is_unique (pandas.Index attribute)
(pandas.Series property)
is_unsigned_integer_dtype() (in module pandas.api.types)
is_year_end (pandas.DatetimeIndex property)
(pandas.Series.dt attribute)
(pandas.Timestamp attribute)
is_year_end() (pandas.tseries.offsets.BQuarterBegin method)
(pandas.tseries.offsets.BQuarterEnd method)
(pandas.tseries.offsets.BusinessDay method)
(pandas.tseries.offsets.BusinessHour method)
(pandas.tseries.offsets.BusinessMonthBegin method)
(pandas.tseries.offsets.BusinessMonthEnd method)
(pandas.tseries.offsets.BYearBegin method)
(pandas.tseries.offsets.BYearEnd method)
(pandas.tseries.offsets.CustomBusinessDay method)
(pandas.tseries.offsets.CustomBusinessHour method)
(pandas.tseries.offsets.CustomBusinessMonthBegin method)
(pandas.tseries.offsets.CustomBusinessMonthEnd method)
(pandas.tseries.offsets.DateOffset method)
(pandas.tseries.offsets.Day method)
(pandas.tseries.offsets.Easter method)
(pandas.tseries.offsets.FY5253 method)
(pandas.tseries.offsets.FY5253Quarter method)
(pandas.tseries.offsets.Hour method)
(pandas.tseries.offsets.LastWeekOfMonth method)
(pandas.tseries.offsets.Micro method)
(pandas.tseries.offsets.Milli method)
(pandas.tseries.offsets.Minute method)
(pandas.tseries.offsets.MonthBegin method)
(pandas.tseries.offsets.MonthEnd method)
(pandas.tseries.offsets.Nano method)
(pandas.tseries.offsets.QuarterBegin method)
(pandas.tseries.offsets.QuarterEnd method)
(pandas.tseries.offsets.Second method)
(pandas.tseries.offsets.SemiMonthBegin method)
(pandas.tseries.offsets.SemiMonthEnd method)
(pandas.tseries.offsets.Tick method)
(pandas.tseries.offsets.Week method)
(pandas.tseries.offsets.WeekOfMonth method)
(pandas.tseries.offsets.YearBegin method)
(pandas.tseries.offsets.YearEnd method)
is_year_start (pandas.DatetimeIndex property)
(pandas.Series.dt attribute)
(pandas.Timestamp attribute)
is_year_start() (pandas.tseries.offsets.BQuarterBegin method)
(pandas.tseries.offsets.BQuarterEnd method)
(pandas.tseries.offsets.BusinessDay method)
(pandas.tseries.offsets.BusinessHour method)
(pandas.tseries.offsets.BusinessMonthBegin method)
(pandas.tseries.offsets.BusinessMonthEnd method)
(pandas.tseries.offsets.BYearBegin method)
(pandas.tseries.offsets.BYearEnd method)
(pandas.tseries.offsets.CustomBusinessDay method)
(pandas.tseries.offsets.CustomBusinessHour method)
(pandas.tseries.offsets.CustomBusinessMonthBegin method)
(pandas.tseries.offsets.CustomBusinessMonthEnd method)
(pandas.tseries.offsets.DateOffset method)
(pandas.tseries.offsets.Day method)
(pandas.tseries.offsets.Easter method)
(pandas.tseries.offsets.FY5253 method)
(pandas.tseries.offsets.FY5253Quarter method)
(pandas.tseries.offsets.Hour method)
(pandas.tseries.offsets.LastWeekOfMonth method)
(pandas.tseries.offsets.Micro method)
(pandas.tseries.offsets.Milli method)
(pandas.tseries.offsets.Minute method)
(pandas.tseries.offsets.MonthBegin method)
(pandas.tseries.offsets.MonthEnd method)
(pandas.tseries.offsets.Nano method)
(pandas.tseries.offsets.QuarterBegin method)
(pandas.tseries.offsets.QuarterEnd method)
(pandas.tseries.offsets.Second method)
(pandas.tseries.offsets.SemiMonthBegin method)
(pandas.tseries.offsets.SemiMonthEnd method)
(pandas.tseries.offsets.Tick method)
(pandas.tseries.offsets.Week method)
(pandas.tseries.offsets.WeekOfMonth method)
(pandas.tseries.offsets.YearBegin method)
(pandas.tseries.offsets.YearEnd method)
isalnum() (pandas.Series.str method)
isalpha() (pandas.Series.str method)
isAnchored() (pandas.tseries.offsets.BQuarterBegin method)
(pandas.tseries.offsets.BQuarterEnd method)
(pandas.tseries.offsets.BusinessDay method)
(pandas.tseries.offsets.BusinessHour method)
(pandas.tseries.offsets.BusinessMonthBegin method)
(pandas.tseries.offsets.BusinessMonthEnd method)
(pandas.tseries.offsets.BYearBegin method)
(pandas.tseries.offsets.BYearEnd method)
(pandas.tseries.offsets.CustomBusinessDay method)
(pandas.tseries.offsets.CustomBusinessHour method)
(pandas.tseries.offsets.CustomBusinessMonthBegin method)
(pandas.tseries.offsets.CustomBusinessMonthEnd method)
(pandas.tseries.offsets.DateOffset method)
(pandas.tseries.offsets.Day method)
(pandas.tseries.offsets.Easter method)
(pandas.tseries.offsets.FY5253 method)
(pandas.tseries.offsets.FY5253Quarter method)
(pandas.tseries.offsets.Hour method)
(pandas.tseries.offsets.LastWeekOfMonth method)
(pandas.tseries.offsets.Micro method)
(pandas.tseries.offsets.Milli method)
(pandas.tseries.offsets.Minute method)
(pandas.tseries.offsets.MonthBegin method)
(pandas.tseries.offsets.MonthEnd method)
(pandas.tseries.offsets.Nano method)
(pandas.tseries.offsets.QuarterBegin method)
(pandas.tseries.offsets.QuarterEnd method)
(pandas.tseries.offsets.Second method)
(pandas.tseries.offsets.SemiMonthBegin method)
(pandas.tseries.offsets.SemiMonthEnd method)
(pandas.tseries.offsets.Tick method)
(pandas.tseries.offsets.Week method)
(pandas.tseries.offsets.WeekOfMonth method)
(pandas.tseries.offsets.YearBegin method)
(pandas.tseries.offsets.YearEnd method)
isdecimal() (pandas.Series.str method)
isdigit() (pandas.Series.str method)
isetitem() (pandas.DataFrame method)
isin() (pandas.api.extensions.ExtensionArray method)
(pandas.DataFrame method)
(pandas.Index method)
(pandas.Series method)
islower() (pandas.Series.str method)
isna() (in module pandas)
(pandas.api.extensions.ExtensionArray method)
(pandas.DataFrame method)
(pandas.Index method)
(pandas.Series method)
isnull() (in module pandas)
(pandas.DataFrame method)
(pandas.Index method)
(pandas.Series method)
isnumeric() (pandas.Series.str method)
isocalendar() (pandas.Series.dt method)
(pandas.Timestamp method)
isoformat() (pandas.Timedelta method)
(pandas.Timestamp method)
isoweekday() (pandas.Timestamp method)
isspace() (pandas.Series.str method)
istitle() (pandas.Series.str method)
isupper() (pandas.Series.str method)
item() (pandas.Index method)
(pandas.Series method)
items() (pandas.DataFrame method)
(pandas.Series method)
iteritems() (pandas.DataFrame method)
(pandas.Series method)
iterrows() (pandas.DataFrame method)
itertuples() (pandas.DataFrame method)
J
join() (pandas.DataFrame method)
(pandas.Index method)
(pandas.Series.str method)
json_normalize() (in module pandas)
K
kde() (pandas.DataFrame.plot method)
(pandas.Series.plot method)
keys() (pandas.DataFrame method)
(pandas.HDFStore method)
(pandas.Series method)
kind (pandas.api.extensions.ExtensionDtype property)
kurt() (pandas.core.window.expanding.Expanding method)
(pandas.core.window.rolling.Rolling method)
(pandas.DataFrame method)
(pandas.Series method)
kurtosis() (pandas.DataFrame method)
(pandas.Series method)
kwds (pandas.tseries.offsets.BQuarterBegin attribute)
(pandas.tseries.offsets.BQuarterEnd attribute)
(pandas.tseries.offsets.BusinessDay attribute)
(pandas.tseries.offsets.BusinessHour attribute)
(pandas.tseries.offsets.BusinessMonthBegin attribute)
(pandas.tseries.offsets.BusinessMonthEnd attribute)
(pandas.tseries.offsets.BYearBegin attribute)
(pandas.tseries.offsets.BYearEnd attribute)
(pandas.tseries.offsets.CustomBusinessDay attribute)
(pandas.tseries.offsets.CustomBusinessHour attribute)
(pandas.tseries.offsets.CustomBusinessMonthBegin attribute)
(pandas.tseries.offsets.CustomBusinessMonthEnd attribute)
(pandas.tseries.offsets.DateOffset attribute)
(pandas.tseries.offsets.Day attribute)
(pandas.tseries.offsets.Easter attribute)
(pandas.tseries.offsets.FY5253 attribute)
(pandas.tseries.offsets.FY5253Quarter attribute)
(pandas.tseries.offsets.Hour attribute)
(pandas.tseries.offsets.LastWeekOfMonth attribute)
(pandas.tseries.offsets.Micro attribute)
(pandas.tseries.offsets.Milli attribute)
(pandas.tseries.offsets.Minute attribute)
(pandas.tseries.offsets.MonthBegin attribute)
(pandas.tseries.offsets.MonthEnd attribute)
(pandas.tseries.offsets.Nano attribute)
(pandas.tseries.offsets.QuarterBegin attribute)
(pandas.tseries.offsets.QuarterEnd attribute)
(pandas.tseries.offsets.Second attribute)
(pandas.tseries.offsets.SemiMonthBegin attribute)
(pandas.tseries.offsets.SemiMonthEnd attribute)
(pandas.tseries.offsets.Tick attribute)
(pandas.tseries.offsets.Week attribute)
(pandas.tseries.offsets.WeekOfMonth attribute)
(pandas.tseries.offsets.YearBegin attribute)
(pandas.tseries.offsets.YearEnd attribute)
L
lag_plot() (in module pandas.plotting)
last() (pandas.core.groupby.GroupBy method)
(pandas.core.resample.Resampler method)
(pandas.DataFrame method)
(pandas.Series method)
last_valid_index() (pandas.DataFrame method)
(pandas.Series method)
LastWeekOfMonth (class in pandas.tseries.offsets)
le() (pandas.DataFrame method)
(pandas.Series method)
left (pandas.arrays.IntervalArray property)
(pandas.Interval attribute)
(pandas.IntervalIndex attribute)
len() (pandas.Series.str method)
length (pandas.arrays.IntervalArray property)
(pandas.Interval attribute)
(pandas.IntervalIndex property)
levels (pandas.MultiIndex attribute)
levshape (pandas.MultiIndex property)
line() (pandas.DataFrame.plot method)
(pandas.Series.plot method)
ljust() (pandas.Series.str method)
loader (pandas.io.formats.style.Styler attribute)
loc (pandas.DataFrame property)
(pandas.Series property)
lookup() (pandas.DataFrame method)
lower() (pandas.Series.str method)
lstrip() (pandas.Series.str method)
lt() (pandas.DataFrame method)
(pandas.Series method)
M
m_offset (pandas.tseries.offsets.CustomBusinessMonthBegin attribute)
(pandas.tseries.offsets.CustomBusinessMonthEnd attribute)
mad (pandas.core.groupby.DataFrameGroupBy property)
mad() (pandas.DataFrame method)
(pandas.Series method)
map() (pandas.CategoricalIndex method)
(pandas.Index method)
(pandas.Series method)
mask() (pandas.DataFrame method)
(pandas.Series method)
match() (pandas.Series.str method)
max (pandas.Timedelta attribute)
(pandas.Timestamp attribute)
max() (pandas.core.groupby.GroupBy method)
(pandas.core.resample.Resampler method)
(pandas.core.window.expanding.Expanding method)
(pandas.core.window.rolling.Rolling method)
(pandas.DataFrame method)
(pandas.Index method)
(pandas.Series method)
mean() (pandas.core.groupby.GroupBy method)
(pandas.core.resample.Resampler method)
(pandas.core.window.ewm.ExponentialMovingWindow method)
(pandas.core.window.expanding.Expanding method)
(pandas.core.window.rolling.Rolling method)
(pandas.core.window.rolling.Window method)
(pandas.DataFrame method)
(pandas.DatetimeIndex method)
(pandas.Series method)
(pandas.TimedeltaIndex method)
median() (pandas.core.groupby.GroupBy method)
(pandas.core.resample.Resampler method)
(pandas.core.window.expanding.Expanding method)
(pandas.core.window.rolling.Rolling method)
(pandas.DataFrame method)
(pandas.Series method)
melt() (in module pandas)
(pandas.DataFrame method)
memory_usage() (pandas.DataFrame method)
(pandas.Index method)
(pandas.Series method)
merge() (in module pandas)
(pandas.DataFrame method)
merge_asof() (in module pandas)
merge_ordered() (in module pandas)
MergeError
Micro (class in pandas.tseries.offsets)
microsecond (pandas.DatetimeIndex property)
(pandas.Series.dt attribute)
(pandas.Timestamp attribute)
microseconds (pandas.Series.dt attribute)
(pandas.Timedelta attribute)
(pandas.TimedeltaIndex property)
mid (pandas.arrays.IntervalArray property)
(pandas.Interval attribute)
(pandas.IntervalIndex attribute)
Milli (class in pandas.tseries.offsets)
min (pandas.Timedelta attribute)
(pandas.Timestamp attribute)
min() (pandas.core.groupby.GroupBy method)
(pandas.core.resample.Resampler method)
(pandas.core.window.expanding.Expanding method)
(pandas.core.window.rolling.Rolling method)
(pandas.DataFrame method)
(pandas.Index method)
(pandas.Series method)
Minute (class in pandas.tseries.offsets)
minute (pandas.DatetimeIndex property)
(pandas.Period attribute)
(pandas.PeriodIndex property)
(pandas.Series.dt attribute)
(pandas.Timestamp attribute)
mod() (pandas.DataFrame method)
(pandas.Series method)
mode() (pandas.DataFrame method)
(pandas.Series method)
module
pandas
month (pandas.DatetimeIndex property)
(pandas.Period attribute)
(pandas.PeriodIndex property)
(pandas.Series.dt attribute)
(pandas.Timestamp attribute)
(pandas.tseries.offsets.BYearBegin attribute)
(pandas.tseries.offsets.BYearEnd attribute)
(pandas.tseries.offsets.YearBegin attribute)
(pandas.tseries.offsets.YearEnd attribute)
month_name() (pandas.DatetimeIndex method)
(pandas.Series.dt method)
(pandas.Timestamp method)
month_roll (pandas.tseries.offsets.CustomBusinessMonthBegin attribute)
(pandas.tseries.offsets.CustomBusinessMonthEnd attribute)
MonthBegin (class in pandas.tseries.offsets)
MonthEnd (class in pandas.tseries.offsets)
mul() (pandas.DataFrame method)
(pandas.Series method)
MultiIndex (class in pandas)
multiply() (pandas.DataFrame method)
(pandas.Series method)
N
n (pandas.tseries.offsets.BQuarterBegin attribute)
(pandas.tseries.offsets.BQuarterEnd attribute)
(pandas.tseries.offsets.BusinessDay attribute)
(pandas.tseries.offsets.BusinessHour attribute)
(pandas.tseries.offsets.BusinessMonthBegin attribute)
(pandas.tseries.offsets.BusinessMonthEnd attribute)
(pandas.tseries.offsets.BYearBegin attribute)
(pandas.tseries.offsets.BYearEnd attribute)
(pandas.tseries.offsets.CustomBusinessDay attribute)
(pandas.tseries.offsets.CustomBusinessHour attribute)
(pandas.tseries.offsets.CustomBusinessMonthBegin attribute)
(pandas.tseries.offsets.CustomBusinessMonthEnd attribute)
(pandas.tseries.offsets.DateOffset attribute)
(pandas.tseries.offsets.Day attribute)
(pandas.tseries.offsets.Easter attribute)
(pandas.tseries.offsets.FY5253 attribute)
(pandas.tseries.offsets.FY5253Quarter attribute)
(pandas.tseries.offsets.Hour attribute)
(pandas.tseries.offsets.LastWeekOfMonth attribute)
(pandas.tseries.offsets.Micro attribute)
(pandas.tseries.offsets.Milli attribute)
(pandas.tseries.offsets.Minute attribute)
(pandas.tseries.offsets.MonthBegin attribute)
(pandas.tseries.offsets.MonthEnd attribute)
(pandas.tseries.offsets.Nano attribute)
(pandas.tseries.offsets.QuarterBegin attribute)
(pandas.tseries.offsets.QuarterEnd attribute)
(pandas.tseries.offsets.Second attribute)
(pandas.tseries.offsets.SemiMonthBegin attribute)
(pandas.tseries.offsets.SemiMonthEnd attribute)
(pandas.tseries.offsets.Tick attribute)
(pandas.tseries.offsets.Week attribute)
(pandas.tseries.offsets.WeekOfMonth attribute)
(pandas.tseries.offsets.YearBegin attribute)
(pandas.tseries.offsets.YearEnd attribute)
na_value (pandas.api.extensions.ExtensionDtype property)
name (pandas.api.extensions.ExtensionDtype property)
(pandas.Index property)
(pandas.Series property)
(pandas.tseries.offsets.BQuarterBegin attribute)
(pandas.tseries.offsets.BQuarterEnd attribute)
(pandas.tseries.offsets.BusinessDay attribute)
(pandas.tseries.offsets.BusinessHour attribute)
(pandas.tseries.offsets.BusinessMonthBegin attribute)
(pandas.tseries.offsets.BusinessMonthEnd attribute)
(pandas.tseries.offsets.BYearBegin attribute)
(pandas.tseries.offsets.BYearEnd attribute)
(pandas.tseries.offsets.CustomBusinessDay attribute)
(pandas.tseries.offsets.CustomBusinessHour attribute)
(pandas.tseries.offsets.CustomBusinessMonthBegin attribute)
(pandas.tseries.offsets.CustomBusinessMonthEnd attribute)
(pandas.tseries.offsets.DateOffset attribute)
(pandas.tseries.offsets.Day attribute)
(pandas.tseries.offsets.Easter attribute)
(pandas.tseries.offsets.FY5253 attribute)
(pandas.tseries.offsets.FY5253Quarter attribute)
(pandas.tseries.offsets.Hour attribute)
(pandas.tseries.offsets.LastWeekOfMonth attribute)
(pandas.tseries.offsets.Micro attribute)
(pandas.tseries.offsets.Milli attribute)
(pandas.tseries.offsets.Minute attribute)
(pandas.tseries.offsets.MonthBegin attribute)
(pandas.tseries.offsets.MonthEnd attribute)
(pandas.tseries.offsets.Nano attribute)
(pandas.tseries.offsets.QuarterBegin attribute)
(pandas.tseries.offsets.QuarterEnd attribute)
(pandas.tseries.offsets.Second attribute)
(pandas.tseries.offsets.SemiMonthBegin attribute)
(pandas.tseries.offsets.SemiMonthEnd attribute)
(pandas.tseries.offsets.Tick attribute)
(pandas.tseries.offsets.Week attribute)
(pandas.tseries.offsets.WeekOfMonth attribute)
(pandas.tseries.offsets.YearBegin attribute)
(pandas.tseries.offsets.YearEnd attribute)
names (pandas.api.extensions.ExtensionDtype property)
(pandas.Index property)
(pandas.MultiIndex property)
Nano (class in pandas.tseries.offsets)
nanos (pandas.tseries.offsets.BQuarterBegin attribute)
(pandas.tseries.offsets.BQuarterEnd attribute)
(pandas.tseries.offsets.BusinessDay attribute)
(pandas.tseries.offsets.BusinessHour attribute)
(pandas.tseries.offsets.BusinessMonthBegin attribute)
(pandas.tseries.offsets.BusinessMonthEnd attribute)
(pandas.tseries.offsets.BYearBegin attribute)
(pandas.tseries.offsets.BYearEnd attribute)
(pandas.tseries.offsets.CustomBusinessDay attribute)
(pandas.tseries.offsets.CustomBusinessHour attribute)
(pandas.tseries.offsets.CustomBusinessMonthBegin attribute)
(pandas.tseries.offsets.CustomBusinessMonthEnd attribute)
(pandas.tseries.offsets.DateOffset attribute)
(pandas.tseries.offsets.Day attribute)
(pandas.tseries.offsets.Easter attribute)
(pandas.tseries.offsets.FY5253 attribute)
(pandas.tseries.offsets.FY5253Quarter attribute)
(pandas.tseries.offsets.Hour attribute)
(pandas.tseries.offsets.LastWeekOfMonth attribute)
(pandas.tseries.offsets.Micro attribute)
(pandas.tseries.offsets.Milli attribute)
(pandas.tseries.offsets.Minute attribute)
(pandas.tseries.offsets.MonthBegin attribute)
(pandas.tseries.offsets.MonthEnd attribute)
(pandas.tseries.offsets.Nano attribute)
(pandas.tseries.offsets.QuarterBegin attribute)
(pandas.tseries.offsets.QuarterEnd attribute)
(pandas.tseries.offsets.Second attribute)
(pandas.tseries.offsets.SemiMonthBegin attribute)
(pandas.tseries.offsets.SemiMonthEnd attribute)
(pandas.tseries.offsets.Tick attribute)
(pandas.tseries.offsets.Week attribute)
(pandas.tseries.offsets.WeekOfMonth attribute)
(pandas.tseries.offsets.YearBegin attribute)
(pandas.tseries.offsets.YearEnd attribute)
nanosecond (pandas.DatetimeIndex property)
(pandas.Series.dt attribute)
(pandas.Timestamp attribute)
nanoseconds (pandas.Series.dt attribute)
(pandas.Timedelta attribute)
(pandas.TimedeltaIndex property)
nbytes (pandas.api.extensions.ExtensionArray property)
(pandas.Index property)
(pandas.Series property)
ndim (pandas.api.extensions.ExtensionArray property)
(pandas.DataFrame property)
(pandas.Index property)
(pandas.Series property)
ne() (pandas.DataFrame method)
(pandas.Series method)
nearest() (pandas.core.resample.Resampler method)
next_bday (pandas.tseries.offsets.BusinessHour attribute)
(pandas.tseries.offsets.CustomBusinessHour attribute)
ngroup() (pandas.core.groupby.GroupBy method)
nlargest() (pandas.core.groupby.SeriesGroupBy method)
(pandas.DataFrame method)
(pandas.Series method)
nlevels (pandas.Index property)
(pandas.MultiIndex property)
normalize (pandas.tseries.offsets.BQuarterBegin attribute)
(pandas.tseries.offsets.BQuarterEnd attribute)
(pandas.tseries.offsets.BusinessDay attribute)
(pandas.tseries.offsets.BusinessHour attribute)
(pandas.tseries.offsets.BusinessMonthBegin attribute)
(pandas.tseries.offsets.BusinessMonthEnd attribute)
(pandas.tseries.offsets.BYearBegin attribute)
(pandas.tseries.offsets.BYearEnd attribute)
(pandas.tseries.offsets.CustomBusinessDay attribute)
(pandas.tseries.offsets.CustomBusinessHour attribute)
(pandas.tseries.offsets.CustomBusinessMonthBegin attribute)
(pandas.tseries.offsets.CustomBusinessMonthEnd attribute)
(pandas.tseries.offsets.DateOffset attribute)
(pandas.tseries.offsets.Day attribute)
(pandas.tseries.offsets.Easter attribute)
(pandas.tseries.offsets.FY5253 attribute)
(pandas.tseries.offsets.FY5253Quarter attribute)
(pandas.tseries.offsets.Hour attribute)
(pandas.tseries.offsets.LastWeekOfMonth attribute)
(pandas.tseries.offsets.Micro attribute)
(pandas.tseries.offsets.Milli attribute)
(pandas.tseries.offsets.Minute attribute)
(pandas.tseries.offsets.MonthBegin attribute)
(pandas.tseries.offsets.MonthEnd attribute)
(pandas.tseries.offsets.Nano attribute)
(pandas.tseries.offsets.QuarterBegin attribute)
(pandas.tseries.offsets.QuarterEnd attribute)
(pandas.tseries.offsets.Second attribute)
(pandas.tseries.offsets.SemiMonthBegin attribute)
(pandas.tseries.offsets.SemiMonthEnd attribute)
(pandas.tseries.offsets.Tick attribute)
(pandas.tseries.offsets.Week attribute)
(pandas.tseries.offsets.WeekOfMonth attribute)
(pandas.tseries.offsets.YearBegin attribute)
(pandas.tseries.offsets.YearEnd attribute)
normalize() (pandas.DatetimeIndex method)
(pandas.Series.dt method)
(pandas.Series.str method)
(pandas.Timestamp method)
notna() (in module pandas)
(pandas.DataFrame method)
(pandas.Index method)
(pandas.Series method)
notnull() (in module pandas)
(pandas.DataFrame method)
(pandas.Index method)
(pandas.Series method)
now() (pandas.Period method)
(pandas.Timestamp class method)
npoints (pandas.Series.sparse attribute)
nsmallest() (pandas.core.groupby.SeriesGroupBy method)
(pandas.DataFrame method)
(pandas.Series method)
nth (pandas.core.groupby.GroupBy property)
NullFrequencyError
NumbaUtilError
NumExprClobberingError
nunique() (pandas.core.groupby.DataFrameGroupBy method)
(pandas.core.resample.Resampler method)
(pandas.DataFrame method)
(pandas.Index method)
(pandas.Series method)
O
offset (pandas.tseries.offsets.BusinessDay attribute)
(pandas.tseries.offsets.BusinessHour attribute)
(pandas.tseries.offsets.CustomBusinessDay attribute)
(pandas.tseries.offsets.CustomBusinessHour attribute)
(pandas.tseries.offsets.CustomBusinessMonthBegin attribute)
(pandas.tseries.offsets.CustomBusinessMonthEnd attribute)
ohlc() (pandas.core.groupby.GroupBy method)
(pandas.core.resample.Resampler method)
onOffset() (pandas.tseries.offsets.BQuarterBegin method)
(pandas.tseries.offsets.BQuarterEnd method)
(pandas.tseries.offsets.BusinessDay method)
(pandas.tseries.offsets.BusinessHour method)
(pandas.tseries.offsets.BusinessMonthBegin method)
(pandas.tseries.offsets.BusinessMonthEnd method)
(pandas.tseries.offsets.BYearBegin method)
(pandas.tseries.offsets.BYearEnd method)
(pandas.tseries.offsets.CustomBusinessDay method)
(pandas.tseries.offsets.CustomBusinessHour method)
(pandas.tseries.offsets.CustomBusinessMonthBegin method)
(pandas.tseries.offsets.CustomBusinessMonthEnd method)
(pandas.tseries.offsets.DateOffset method)
(pandas.tseries.offsets.Day method)
(pandas.tseries.offsets.Easter method)
(pandas.tseries.offsets.FY5253 method)
(pandas.tseries.offsets.FY5253Quarter method)
(pandas.tseries.offsets.Hour method)
(pandas.tseries.offsets.LastWeekOfMonth method)
(pandas.tseries.offsets.Micro method)
(pandas.tseries.offsets.Milli method)
(pandas.tseries.offsets.Minute method)
(pandas.tseries.offsets.MonthBegin method)
(pandas.tseries.offsets.MonthEnd method)
(pandas.tseries.offsets.Nano method)
(pandas.tseries.offsets.QuarterBegin method)
(pandas.tseries.offsets.QuarterEnd method)
(pandas.tseries.offsets.Second method)
(pandas.tseries.offsets.SemiMonthBegin method)
(pandas.tseries.offsets.SemiMonthEnd method)
(pandas.tseries.offsets.Tick method)
(pandas.tseries.offsets.Week method)
(pandas.tseries.offsets.WeekOfMonth method)
(pandas.tseries.offsets.YearBegin method)
(pandas.tseries.offsets.YearEnd method)
open_left (pandas.Interval attribute)
open_right (pandas.Interval attribute)
option_context (class in pandas)
OptionError
ordered (pandas.Categorical property)
(pandas.CategoricalDtype property)
(pandas.CategoricalIndex property)
(pandas.Series.cat attribute)
ordinal (pandas.Period attribute)
OutOfBoundsDatetime
OutOfBoundsTimedelta
overlaps() (pandas.arrays.IntervalArray method)
(pandas.Interval method)
(pandas.IntervalIndex method)
P
pad() (pandas.core.groupby.DataFrameGroupBy method)
(pandas.core.groupby.GroupBy method)
(pandas.core.resample.Resampler method)
(pandas.DataFrame method)
(pandas.Series method)
(pandas.Series.str method)
pandas
module
pandas_dtype() (in module pandas.api.types)
PandasArray (class in pandas.arrays)
parallel_coordinates() (in module pandas.plotting)
parse() (pandas.ExcelFile method)
ParserError
ParserWarning
partition() (pandas.Series.str method)
path (pandas.ExcelWriter property)
pct_change() (pandas.core.groupby.DataFrameGroupBy method)
(pandas.core.groupby.GroupBy method)
(pandas.DataFrame method)
(pandas.Series method)
PerformanceWarning
Period (class in pandas)
period_range() (in module pandas)
PeriodArray (class in pandas.arrays)
PeriodDtype (class in pandas)
PeriodIndex (class in pandas)
pie() (pandas.DataFrame.plot method)
(pandas.Series.plot method)
pipe() (pandas.core.groupby.GroupBy method)
(pandas.core.resample.Resampler method)
(pandas.DataFrame method)
(pandas.io.formats.style.Styler method)
(pandas.Series method)
pivot() (in module pandas)
(pandas.DataFrame method)
pivot_table() (in module pandas)
(pandas.DataFrame method)
plot (pandas.core.groupby.DataFrameGroupBy property)
plot() (pandas.DataFrame method)
(pandas.Series method)
plot_params (in module pandas.plotting)
pop() (pandas.DataFrame method)
(pandas.Series method)
PossibleDataLossError
PossiblePrecisionLoss
pow() (pandas.DataFrame method)
(pandas.Series method)
prod() (pandas.core.groupby.GroupBy method)
(pandas.core.resample.Resampler method)
(pandas.DataFrame method)
(pandas.Series method)
product() (pandas.DataFrame method)
(pandas.Series method)
put() (pandas.HDFStore method)
putmask() (pandas.Index method)
PyperclipException
PyperclipWindowsException
Python Enhancement Proposals
PEP 484
PEP 561
PEP 585
PEP 8#imports
Q
qcut() (in module pandas)
qtr_with_extra_week (pandas.tseries.offsets.FY5253Quarter attribute)
quantile() (pandas.core.groupby.DataFrameGroupBy method)
(pandas.core.resample.Resampler method)
(pandas.core.window.expanding.Expanding method)
(pandas.core.window.rolling.Rolling method)
(pandas.DataFrame method)
(pandas.Series method)
quarter (pandas.DatetimeIndex property)
(pandas.Period attribute)
(pandas.PeriodIndex property)
(pandas.Series.dt attribute)
(pandas.Timestamp attribute)
QuarterBegin (class in pandas.tseries.offsets)
QuarterEnd (class in pandas.tseries.offsets)
query() (pandas.DataFrame method)
qyear (pandas.Period attribute)
(pandas.PeriodIndex property)
(pandas.Series.dt attribute)
R
radd() (pandas.DataFrame method)
(pandas.Series method)
radviz() (in module pandas.plotting)
RangeIndex (class in pandas)
rank() (pandas.core.groupby.DataFrameGroupBy method)
(pandas.core.groupby.GroupBy method)
(pandas.core.window.expanding.Expanding method)
(pandas.core.window.rolling.Rolling method)
(pandas.DataFrame method)
(pandas.Series method)
ravel() (pandas.api.extensions.ExtensionArray method)
(pandas.Index method)
(pandas.Series method)
rdiv() (pandas.DataFrame method)
(pandas.Series method)
rdivmod() (pandas.Series method)
read_clipboard() (in module pandas)
read_csv() (in module pandas)
read_excel() (in module pandas)
read_feather() (in module pandas)
read_fwf() (in module pandas)
read_gbq() (in module pandas)
read_hdf() (in module pandas)
read_html() (in module pandas)
read_json() (in module pandas)
read_orc() (in module pandas)
read_parquet() (in module pandas)
read_pickle() (in module pandas)
read_sas() (in module pandas)
read_spss() (in module pandas)
read_sql() (in module pandas)
read_sql_query() (in module pandas)
read_sql_table() (in module pandas)
read_stata() (in module pandas)
read_table() (in module pandas)
read_xml() (in module pandas)
register_dataframe_accessor() (in module pandas.api.extensions)
register_extension_dtype() (in module pandas.api.extensions)
register_index_accessor() (in module pandas.api.extensions)
register_matplotlib_converters() (in module pandas.plotting)
register_series_accessor() (in module pandas.api.extensions)
reindex() (pandas.DataFrame method)
(pandas.Index method)
(pandas.Series method)
reindex_like() (pandas.DataFrame method)
(pandas.Series method)
relabel_index() (pandas.io.formats.style.Styler method)
remove_categories() (pandas.CategoricalIndex method)
(pandas.Series.cat method)
remove_unused_categories() (pandas.CategoricalIndex method)
(pandas.Series.cat method)
remove_unused_levels() (pandas.MultiIndex method)
removeprefix() (pandas.Series.str method)
removesuffix() (pandas.Series.str method)
rename() (pandas.DataFrame method)
(pandas.Index method)
(pandas.Series method)
rename_axis() (pandas.DataFrame method)
(pandas.Series method)
rename_categories() (pandas.CategoricalIndex method)
(pandas.Series.cat method)
render() (pandas.io.formats.style.Styler method)
reorder_categories() (pandas.CategoricalIndex method)
(pandas.Series.cat method)
reorder_levels() (pandas.DataFrame method)
(pandas.MultiIndex method)
(pandas.Series method)
repeat() (pandas.api.extensions.ExtensionArray method)
(pandas.Index method)
(pandas.Series method)
(pandas.Series.str method)
replace() (pandas.DataFrame method)
(pandas.Series method)
(pandas.Series.str method)
(pandas.Timestamp method)
resample() (pandas.core.groupby.DataFrameGroupBy method)
(pandas.DataFrame method)
(pandas.Series method)
reset_index() (pandas.DataFrame method)
(pandas.Series method)
reset_option (in module pandas)
resolution (pandas.Timedelta attribute)
(pandas.Timestamp attribute)
resolution_string (pandas.Timedelta attribute)
rfind() (pandas.Series.str method)
rfloordiv() (pandas.DataFrame method)
(pandas.Series method)
right (pandas.arrays.IntervalArray property)
(pandas.Interval attribute)
(pandas.IntervalIndex attribute)
rindex() (pandas.Series.str method)
rjust() (pandas.Series.str method)
rmod() (pandas.DataFrame method)
(pandas.Series method)
rmul() (pandas.DataFrame method)
(pandas.Series method)
rollback() (pandas.tseries.offsets.BQuarterBegin method)
(pandas.tseries.offsets.BQuarterEnd method)
(pandas.tseries.offsets.BusinessDay method)
(pandas.tseries.offsets.BusinessHour method)
(pandas.tseries.offsets.BusinessMonthBegin method)
(pandas.tseries.offsets.BusinessMonthEnd method)
(pandas.tseries.offsets.BYearBegin method)
(pandas.tseries.offsets.BYearEnd method)
(pandas.tseries.offsets.CustomBusinessDay method)
(pandas.tseries.offsets.CustomBusinessHour method)
(pandas.tseries.offsets.CustomBusinessMonthBegin method)
(pandas.tseries.offsets.CustomBusinessMonthEnd method)
(pandas.tseries.offsets.DateOffset method)
(pandas.tseries.offsets.Day method)
(pandas.tseries.offsets.Easter method)
(pandas.tseries.offsets.FY5253 method)
(pandas.tseries.offsets.FY5253Quarter method)
(pandas.tseries.offsets.Hour method)
(pandas.tseries.offsets.LastWeekOfMonth method)
(pandas.tseries.offsets.Micro method)
(pandas.tseries.offsets.Milli method)
(pandas.tseries.offsets.Minute method)
(pandas.tseries.offsets.MonthBegin method)
(pandas.tseries.offsets.MonthEnd method)
(pandas.tseries.offsets.Nano method)
(pandas.tseries.offsets.QuarterBegin method)
(pandas.tseries.offsets.QuarterEnd method)
(pandas.tseries.offsets.Second method)
(pandas.tseries.offsets.SemiMonthBegin method)
(pandas.tseries.offsets.SemiMonthEnd method)
(pandas.tseries.offsets.Tick method)
(pandas.tseries.offsets.Week method)
(pandas.tseries.offsets.WeekOfMonth method)
(pandas.tseries.offsets.YearBegin method)
(pandas.tseries.offsets.YearEnd method)
rollforward() (pandas.tseries.offsets.BQuarterBegin method)
(pandas.tseries.offsets.BQuarterEnd method)
(pandas.tseries.offsets.BusinessDay method)
(pandas.tseries.offsets.BusinessHour method)
(pandas.tseries.offsets.BusinessMonthBegin method)
(pandas.tseries.offsets.BusinessMonthEnd method)
(pandas.tseries.offsets.BYearBegin method)
(pandas.tseries.offsets.BYearEnd method)
(pandas.tseries.offsets.CustomBusinessDay method)
(pandas.tseries.offsets.CustomBusinessHour method)
(pandas.tseries.offsets.CustomBusinessMonthBegin method)
(pandas.tseries.offsets.CustomBusinessMonthEnd method)
(pandas.tseries.offsets.DateOffset method)
(pandas.tseries.offsets.Day method)
(pandas.tseries.offsets.Easter method)
(pandas.tseries.offsets.FY5253 method)
(pandas.tseries.offsets.FY5253Quarter method)
(pandas.tseries.offsets.Hour method)
(pandas.tseries.offsets.LastWeekOfMonth method)
(pandas.tseries.offsets.Micro method)
(pandas.tseries.offsets.Milli method)
(pandas.tseries.offsets.Minute method)
(pandas.tseries.offsets.MonthBegin method)
(pandas.tseries.offsets.MonthEnd method)
(pandas.tseries.offsets.Nano method)
(pandas.tseries.offsets.QuarterBegin method)
(pandas.tseries.offsets.QuarterEnd method)
(pandas.tseries.offsets.Second method)
(pandas.tseries.offsets.SemiMonthBegin method)
(pandas.tseries.offsets.SemiMonthEnd method)
(pandas.tseries.offsets.Tick method)
(pandas.tseries.offsets.Week method)
(pandas.tseries.offsets.WeekOfMonth method)
(pandas.tseries.offsets.YearBegin method)
(pandas.tseries.offsets.YearEnd method)
rolling() (pandas.DataFrame method)
(pandas.Series method)
round() (pandas.DataFrame method)
(pandas.DatetimeIndex method)
(pandas.Series method)
(pandas.Series.dt method)
(pandas.Timedelta method)
(pandas.TimedeltaIndex method)
(pandas.Timestamp method)
rpartition() (pandas.Series.str method)
rpow() (pandas.DataFrame method)
(pandas.Series method)
rsplit() (pandas.Series.str method)
rstrip() (pandas.Series.str method)
rsub() (pandas.DataFrame method)
(pandas.Series method)
rtruediv() (pandas.DataFrame method)
(pandas.Series method)
rule_code (pandas.tseries.offsets.BQuarterBegin attribute)
(pandas.tseries.offsets.BQuarterEnd attribute)
(pandas.tseries.offsets.BusinessDay attribute)
(pandas.tseries.offsets.BusinessHour attribute)
(pandas.tseries.offsets.BusinessMonthBegin attribute)
(pandas.tseries.offsets.BusinessMonthEnd attribute)
(pandas.tseries.offsets.BYearBegin attribute)
(pandas.tseries.offsets.BYearEnd attribute)
(pandas.tseries.offsets.CustomBusinessDay attribute)
(pandas.tseries.offsets.CustomBusinessHour attribute)
(pandas.tseries.offsets.CustomBusinessMonthBegin attribute)
(pandas.tseries.offsets.CustomBusinessMonthEnd attribute)
(pandas.tseries.offsets.DateOffset attribute)
(pandas.tseries.offsets.Day attribute)
(pandas.tseries.offsets.Easter attribute)
(pandas.tseries.offsets.FY5253 attribute)
(pandas.tseries.offsets.FY5253Quarter attribute)
(pandas.tseries.offsets.Hour attribute)
(pandas.tseries.offsets.LastWeekOfMonth attribute)
(pandas.tseries.offsets.Micro attribute)
(pandas.tseries.offsets.Milli attribute)
(pandas.tseries.offsets.Minute attribute)
(pandas.tseries.offsets.MonthBegin attribute)
(pandas.tseries.offsets.MonthEnd attribute)
(pandas.tseries.offsets.Nano attribute)
(pandas.tseries.offsets.QuarterBegin attribute)
(pandas.tseries.offsets.QuarterEnd attribute)
(pandas.tseries.offsets.Second attribute)
(pandas.tseries.offsets.SemiMonthBegin attribute)
(pandas.tseries.offsets.SemiMonthEnd attribute)
(pandas.tseries.offsets.Tick attribute)
(pandas.tseries.offsets.Week attribute)
(pandas.tseries.offsets.WeekOfMonth attribute)
(pandas.tseries.offsets.YearBegin attribute)
(pandas.tseries.offsets.YearEnd attribute)
S
sample() (pandas.core.groupby.DataFrameGroupBy method)
(pandas.DataFrame method)
(pandas.Series method)
save() (pandas.ExcelWriter method)
scatter() (pandas.DataFrame.plot method)
scatter_matrix() (in module pandas.plotting)
searchsorted() (pandas.api.extensions.ExtensionArray method)
(pandas.Index method)
(pandas.Series method)
Second (class in pandas.tseries.offsets)
second (pandas.DatetimeIndex property)
(pandas.Period attribute)
(pandas.PeriodIndex property)
(pandas.Series.dt attribute)
(pandas.Timestamp attribute)
seconds (pandas.Series.dt attribute)
(pandas.Timedelta attribute)
(pandas.TimedeltaIndex property)
select() (pandas.HDFStore method)
select_dtypes() (pandas.DataFrame method)
sem() (pandas.core.groupby.GroupBy method)
(pandas.core.resample.Resampler method)
(pandas.core.window.expanding.Expanding method)
(pandas.core.window.rolling.Rolling method)
(pandas.DataFrame method)
(pandas.Series method)
SemiMonthBegin (class in pandas.tseries.offsets)
SemiMonthEnd (class in pandas.tseries.offsets)
Series (class in pandas)
set_axis() (pandas.DataFrame method)
(pandas.Series method)
set_caption() (pandas.io.formats.style.Styler method)
set_categories() (pandas.CategoricalIndex method)
(pandas.Series.cat method)
set_closed() (pandas.arrays.IntervalArray method)
(pandas.IntervalIndex method)
set_codes() (pandas.MultiIndex method)
set_flags() (pandas.DataFrame method)
(pandas.Series method)
set_index() (pandas.DataFrame method)
set_levels() (pandas.MultiIndex method)
set_na_rep() (pandas.io.formats.style.Styler method)
set_names() (pandas.Index method)
set_option (in module pandas)
set_precision() (pandas.io.formats.style.Styler method)
set_properties() (pandas.io.formats.style.Styler method)
set_sticky() (pandas.io.formats.style.Styler method)
set_table_attributes() (pandas.io.formats.style.Styler method)
set_table_styles() (pandas.io.formats.style.Styler method)
set_td_classes() (pandas.io.formats.style.Styler method)
set_tooltips() (pandas.io.formats.style.Styler method)
set_uuid() (pandas.io.formats.style.Styler method)
set_value() (pandas.Index method)
SettingWithCopyError
SettingWithCopyWarning
shape (pandas.api.extensions.ExtensionArray property)
(pandas.DataFrame property)
(pandas.Index property)
(pandas.Series property)
sheets (pandas.ExcelWriter property)
shift() (pandas.api.extensions.ExtensionArray method)
(pandas.core.groupby.DataFrameGroupBy method)
(pandas.DataFrame method)
(pandas.Index method)
(pandas.Series method)
show_versions() (in module pandas)
size (pandas.DataFrame property)
(pandas.Index property)
(pandas.Series property)
size() (pandas.core.groupby.DataFrameGroupBy method)
(pandas.core.groupby.GroupBy method)
(pandas.core.resample.Resampler method)
skew (pandas.core.groupby.DataFrameGroupBy property)
skew() (pandas.core.window.expanding.Expanding method)
(pandas.core.window.rolling.Rolling method)
(pandas.DataFrame method)
(pandas.Series method)
slice() (pandas.Series.str method)
slice_indexer() (pandas.Index method)
slice_locs() (pandas.Index method)
slice_replace() (pandas.Series.str method)
slice_shift() (pandas.DataFrame method)
(pandas.Series method)
snap() (pandas.DatetimeIndex method)
sort() (pandas.Index method)
sort_index() (pandas.DataFrame method)
(pandas.Series method)
sort_values() (pandas.DataFrame method)
(pandas.Index method)
(pandas.Series method)
sortlevel() (pandas.Index method)
(pandas.MultiIndex method)
sp_values (pandas.Series.sparse attribute)
sparse() (pandas.DataFrame method)
(pandas.Series method)
SparseArray (class in pandas.arrays)
SparseDtype (class in pandas)
SpecificationError
split() (pandas.Series.str method)
squeeze() (pandas.DataFrame method)
(pandas.Series method)
stack() (pandas.DataFrame method)
start (pandas.RangeIndex property)
(pandas.tseries.offsets.BusinessHour attribute)
(pandas.tseries.offsets.CustomBusinessHour attribute)
start_time (pandas.Period attribute)
(pandas.PeriodIndex property)
(pandas.Series.dt attribute)
startingMonth (pandas.tseries.offsets.BQuarterBegin attribute)
(pandas.tseries.offsets.BQuarterEnd attribute)
(pandas.tseries.offsets.FY5253 attribute)
(pandas.tseries.offsets.FY5253Quarter attribute)
(pandas.tseries.offsets.QuarterBegin attribute)
(pandas.tseries.offsets.QuarterEnd attribute)
startswith() (pandas.Series.str method)
std() (pandas.core.groupby.GroupBy method)
(pandas.core.resample.Resampler method)
(pandas.core.window.ewm.ExponentialMovingWindow method)
(pandas.core.window.expanding.Expanding method)
(pandas.core.window.rolling.Rolling method)
(pandas.core.window.rolling.Window method)
(pandas.DataFrame method)
(pandas.DatetimeIndex method)
(pandas.Series method)
step (pandas.RangeIndex property)
stop (pandas.RangeIndex property)
str() (pandas.Index method)
(pandas.Series method)
strftime() (pandas.DatetimeIndex method)
(pandas.Period method)
(pandas.PeriodIndex method)
(pandas.Series.dt method)
(pandas.Timestamp method)
StringArray (class in pandas.arrays)
StringDtype (class in pandas)
strip() (pandas.Series.str method)
strptime() (pandas.Timestamp class method)
style (pandas.DataFrame property)
Styler (class in pandas.io.formats.style)
sub() (pandas.DataFrame method)
(pandas.Series method)
subtract() (pandas.DataFrame method)
(pandas.Series method)
subtype (pandas.IntervalDtype property)
sum() (pandas.core.groupby.GroupBy method)
(pandas.core.resample.Resampler method)
(pandas.core.window.ewm.ExponentialMovingWindow method)
(pandas.core.window.expanding.Expanding method)
(pandas.core.window.rolling.Rolling method)
(pandas.core.window.rolling.Window method)
(pandas.DataFrame method)
(pandas.Series method)
supported_extensions (pandas.ExcelWriter property)
swapaxes() (pandas.DataFrame method)
(pandas.Series method)
swapcase() (pandas.Series.str method)
swaplevel() (pandas.DataFrame method)
(pandas.MultiIndex method)
(pandas.Series method)
symmetric_difference() (pandas.Index method)
T
T (pandas.DataFrame property)
(pandas.Index property)
(pandas.Series property)
table() (in module pandas.plotting)
tail() (pandas.core.groupby.GroupBy method)
(pandas.DataFrame method)
(pandas.Series method)
take (pandas.core.groupby.DataFrameGroupBy property)
take() (pandas.api.extensions.ExtensionArray method)
(pandas.DataFrame method)
(pandas.Index method)
(pandas.Series method)
template_html (pandas.io.formats.style.Styler attribute)
template_html_style (pandas.io.formats.style.Styler attribute)
template_html_table (pandas.io.formats.style.Styler attribute)
template_latex (pandas.io.formats.style.Styler attribute)
template_string (pandas.io.formats.style.Styler attribute)
test() (in module pandas)
text_gradient() (pandas.io.formats.style.Styler method)
Tick (class in pandas.tseries.offsets)
time (pandas.DatetimeIndex property)
(pandas.Series.dt attribute)
time() (pandas.Timestamp method)
Timedelta (class in pandas)
timedelta_range() (in module pandas)
TimedeltaArray (class in pandas.arrays)
TimedeltaIndex (class in pandas)
Timestamp (class in pandas)
timestamp() (pandas.Timestamp method)
timetuple() (pandas.Timestamp method)
timetz (pandas.DatetimeIndex property)
(pandas.Series.dt attribute)
timetz() (pandas.Timestamp method)
title() (pandas.Series.str method)
to_clipboard() (pandas.DataFrame method)
(pandas.Series method)
to_coo() (pandas.DataFrame.sparse method)
(pandas.Series.sparse method)
to_csv() (pandas.DataFrame method)
(pandas.Series method)
to_datetime() (in module pandas)
to_datetime64() (pandas.Timestamp method)
to_dense() (pandas.DataFrame.sparse method)
to_dict() (pandas.DataFrame method)
(pandas.Series method)
to_excel() (pandas.DataFrame method)
(pandas.io.formats.style.Styler method)
(pandas.Series method)
to_feather() (pandas.DataFrame method)
to_flat_index() (pandas.Index method)
(pandas.MultiIndex method)
to_frame() (pandas.DatetimeIndex method)
(pandas.Index method)
(pandas.MultiIndex method)
(pandas.Series method)
(pandas.TimedeltaIndex method)
to_gbq() (pandas.DataFrame method)
to_hdf() (pandas.DataFrame method)
(pandas.Series method)
to_html() (pandas.DataFrame method)
(pandas.io.formats.style.Styler method)
to_json() (pandas.DataFrame method)
(pandas.Series method)
to_julian_date() (pandas.Timestamp method)
to_latex() (pandas.DataFrame method)
(pandas.io.formats.style.Styler method)
(pandas.Series method)
to_list() (pandas.Index method)
(pandas.Series method)
to_markdown() (pandas.DataFrame method)
(pandas.Series method)
to_native_types() (pandas.Index method)
to_numeric() (in module pandas)
to_numpy() (pandas.DataFrame method)
(pandas.Index method)
(pandas.Series method)
(pandas.Timedelta method)
(pandas.Timestamp method)
to_offset() (in module pandas.tseries.frequencies)
to_orc() (pandas.DataFrame method)
to_parquet() (pandas.DataFrame method)
to_period() (pandas.DataFrame method)
(pandas.DatetimeIndex method)
(pandas.Series method)
(pandas.Series.dt method)
(pandas.Timestamp method)
to_perioddelta() (pandas.DatetimeIndex method)
to_pickle() (pandas.DataFrame method)
(pandas.Series method)
to_pydatetime() (pandas.DatetimeIndex method)
(pandas.Series.dt method)
(pandas.Timestamp method)
to_pytimedelta() (pandas.Series.dt method)
(pandas.Timedelta method)
(pandas.TimedeltaIndex method)
to_records() (pandas.DataFrame method)
to_series() (pandas.DatetimeIndex method)
(pandas.Index method)
(pandas.TimedeltaIndex method)
to_sql() (pandas.DataFrame method)
(pandas.Series method)
to_stata() (pandas.DataFrame method)
to_string() (pandas.DataFrame method)
(pandas.io.formats.style.Styler method)
(pandas.Series method)
to_timedelta() (in module pandas)
to_timedelta64() (pandas.Timedelta method)
to_timestamp() (pandas.DataFrame method)
(pandas.Period method)
(pandas.PeriodIndex method)
(pandas.Series method)
to_tuples() (pandas.arrays.IntervalArray method)
(pandas.IntervalIndex method)
to_xarray() (pandas.DataFrame method)
(pandas.Series method)
to_xml() (pandas.DataFrame method)
today() (pandas.Timestamp class method)
tolist() (pandas.api.extensions.ExtensionArray method)
(pandas.Index method)
(pandas.Series method)
toordinal() (pandas.Timestamp method)
total_seconds() (pandas.Series.dt method)
(pandas.Timedelta method)
transform() (pandas.core.groupby.DataFrameGroupBy method)
(pandas.core.groupby.SeriesGroupBy method)
(pandas.core.resample.Resampler method)
(pandas.DataFrame method)
(pandas.Series method)
translate() (pandas.Series.str method)
transpose() (pandas.DataFrame method)
(pandas.Index method)
(pandas.Series method)
truediv() (pandas.DataFrame method)
(pandas.Series method)
truncate() (pandas.DataFrame method)
(pandas.Series method)
tshift (pandas.core.groupby.DataFrameGroupBy property)
tshift() (pandas.DataFrame method)
(pandas.Series method)
type (pandas.api.extensions.ExtensionDtype property)
tz (pandas.DatetimeIndex property)
(pandas.DatetimeTZDtype property)
(pandas.Series.dt attribute)
(pandas.Timestamp property)
tz_convert() (pandas.DataFrame method)
(pandas.DatetimeIndex method)
(pandas.Series method)
(pandas.Series.dt method)
(pandas.Timestamp method)
tz_localize() (pandas.DataFrame method)
(pandas.DatetimeIndex method)
(pandas.Series method)
(pandas.Series.dt method)
(pandas.Timestamp method)
tzinfo (pandas.Timestamp attribute)
tzname() (pandas.Timestamp method)
U
UInt16Dtype (class in pandas)
UInt32Dtype (class in pandas)
UInt64Dtype (class in pandas)
UInt64Index (class in pandas)
UInt8Dtype (class in pandas)
UndefinedVariableError
union() (pandas.Index method)
union_categoricals() (in module pandas.api.types)
unique (pandas.core.groupby.SeriesGroupBy property)
unique() (in module pandas)
(pandas.api.extensions.ExtensionArray method)
(pandas.Index method)
(pandas.Series method)
unit (pandas.DatetimeTZDtype property)
UnsortedIndexError
unstack() (pandas.DataFrame method)
(pandas.Series method)
UnsupportedFunctionCall
update() (pandas.DataFrame method)
(pandas.Series method)
upper() (pandas.Series.str method)
use() (pandas.io.formats.style.Styler method)
utcfromtimestamp() (pandas.Timestamp class method)
utcnow() (pandas.Timestamp class method)
utcoffset() (pandas.Timestamp method)
utctimetuple() (pandas.Timestamp method)
V
value (pandas.Timedelta attribute)
(pandas.Timestamp attribute)
value_counts() (pandas.core.groupby.DataFrameGroupBy method)
(pandas.DataFrame method)
(pandas.Index method)
(pandas.Series method)
value_labels() (pandas.io.stata.StataReader method)
ValueLabelTypeMismatch
values (pandas.DataFrame property)
(pandas.Index property)
(pandas.IntervalIndex property)
(pandas.Series property)
var() (pandas.core.groupby.GroupBy method)
(pandas.core.resample.Resampler method)
(pandas.core.window.ewm.ExponentialMovingWindow method)
(pandas.core.window.expanding.Expanding method)
(pandas.core.window.rolling.Rolling method)
(pandas.core.window.rolling.Window method)
(pandas.DataFrame method)
(pandas.Series method)
variable_labels() (pandas.io.stata.StataReader method)
VariableOffsetWindowIndexer (class in pandas.api.indexers)
variation (pandas.tseries.offsets.FY5253 attribute)
(pandas.tseries.offsets.FY5253Quarter attribute)
view() (pandas.api.extensions.ExtensionArray method)
(pandas.Index method)
(pandas.Series method)
(pandas.Timedelta method)
W
walk() (pandas.HDFStore method)
Week (class in pandas.tseries.offsets)
week (pandas.DatetimeIndex property)
(pandas.Period attribute)
(pandas.PeriodIndex property)
(pandas.Series.dt attribute)
(pandas.Timestamp attribute)
(pandas.tseries.offsets.LastWeekOfMonth attribute)
(pandas.tseries.offsets.WeekOfMonth attribute)
weekday (pandas.DatetimeIndex property)
(pandas.Period attribute)
(pandas.PeriodIndex property)
(pandas.Series.dt attribute)
(pandas.tseries.offsets.FY5253 attribute)
(pandas.tseries.offsets.FY5253Quarter attribute)
(pandas.tseries.offsets.LastWeekOfMonth attribute)
(pandas.tseries.offsets.Week attribute)
(pandas.tseries.offsets.WeekOfMonth attribute)
weekday() (pandas.Timestamp method)
weekmask (pandas.tseries.offsets.BusinessDay attribute)
(pandas.tseries.offsets.BusinessHour attribute)
(pandas.tseries.offsets.CustomBusinessDay attribute)
(pandas.tseries.offsets.CustomBusinessHour attribute)
(pandas.tseries.offsets.CustomBusinessMonthBegin attribute)
(pandas.tseries.offsets.CustomBusinessMonthEnd attribute)
WeekOfMonth (class in pandas.tseries.offsets)
weekofyear (pandas.DatetimeIndex property)
(pandas.Period attribute)
(pandas.PeriodIndex property)
(pandas.Series.dt attribute)
(pandas.Timestamp attribute)
where() (pandas.DataFrame method)
(pandas.Index method)
(pandas.io.formats.style.Styler method)
(pandas.Series method)
wide_to_long() (in module pandas)
wrap() (pandas.Series.str method)
write_cells() (pandas.ExcelWriter method)
write_file() (pandas.io.stata.StataWriter method)
X
xs() (pandas.DataFrame method)
(pandas.Series method)
Y
year (pandas.DatetimeIndex property)
(pandas.Period attribute)
(pandas.PeriodIndex property)
(pandas.Series.dt attribute)
(pandas.Timestamp attribute)
year_has_extra_week() (pandas.tseries.offsets.FY5253Quarter method)
YearBegin (class in pandas.tseries.offsets)
YearEnd (class in pandas.tseries.offsets)
Z
zfill() (pandas.Series.str method)
|
genindex.html
|
pandas.tseries.offsets.BQuarterBegin.is_anchored
|
`pandas.tseries.offsets.BQuarterBegin.is_anchored`
Return boolean whether the frequency is a unit frequency (n=1).
```
>>> pd.DateOffset().is_anchored()
True
>>> pd.DateOffset(2).is_anchored()
False
```
|
BQuarterBegin.is_anchored()#
Return boolean whether the frequency is a unit frequency (n=1).
Examples
>>> pd.DateOffset().is_anchored()
True
>>> pd.DateOffset(2).is_anchored()
False
|
reference/api/pandas.tseries.offsets.BQuarterBegin.is_anchored.html
|
pandas.tseries.offsets.BusinessMonthEnd.n
|
pandas.tseries.offsets.BusinessMonthEnd.n
|
BusinessMonthEnd.n#
|
reference/api/pandas.tseries.offsets.BusinessMonthEnd.n.html
|
pandas.Series.rpow
|
`pandas.Series.rpow`
Return Exponential power of series and other, element-wise (binary operator rpow).
```
>>> a = pd.Series([1, 1, 1, np.nan], index=['a', 'b', 'c', 'd'])
>>> a
a 1.0
b 1.0
c 1.0
d NaN
dtype: float64
>>> b = pd.Series([1, np.nan, 1, np.nan], index=['a', 'b', 'd', 'e'])
>>> b
a 1.0
b NaN
d 1.0
e NaN
dtype: float64
>>> a.pow(b, fill_value=0)
a 1.0
b 1.0
c 1.0
d 0.0
e NaN
dtype: float64
```
|
Series.rpow(other, level=None, fill_value=None, axis=0)[source]#
Return Exponential power of series and other, element-wise (binary operator rpow).
Equivalent to other ** series, but with support to substitute a fill_value for
missing data in either one of the inputs.
Parameters
otherSeries or scalar value
levelint or nameBroadcast across a level, matching Index values on the
passed MultiIndex level.
fill_valueNone or float value, default None (NaN)Fill existing missing (NaN) values, and any new element needed for
successful Series alignment, with this value before computation.
If data in both corresponding Series locations is missing
the result of filling (at that location) will be missing.
axis{0 or ‘index’}Unused. Parameter needed for compatibility with DataFrame.
Returns
SeriesThe result of the operation.
See also
Series.powElement-wise Exponential power, see Python documentation for more details.
Examples
>>> a = pd.Series([1, 1, 1, np.nan], index=['a', 'b', 'c', 'd'])
>>> a
a 1.0
b 1.0
c 1.0
d NaN
dtype: float64
>>> b = pd.Series([1, np.nan, 1, np.nan], index=['a', 'b', 'd', 'e'])
>>> b
a 1.0
b NaN
d 1.0
e NaN
dtype: float64
>>> a.pow(b, fill_value=0)
a 1.0
b 1.0
c 1.0
d 0.0
e NaN
dtype: float64
|
reference/api/pandas.Series.rpow.html
|
pandas.Series.cat.remove_unused_categories
|
`pandas.Series.cat.remove_unused_categories`
Remove categories which are not used.
Whether or not to drop unused categories inplace or return a copy of
this categorical with unused categories dropped.
```
>>> c = pd.Categorical(['a', 'c', 'b', 'c', 'd'])
>>> c
['a', 'c', 'b', 'c', 'd']
Categories (4, object): ['a', 'b', 'c', 'd']
```
|
Series.cat.remove_unused_categories(*args, **kwargs)[source]#
Remove categories which are not used.
Parameters
inplacebool, default FalseWhether or not to drop unused categories inplace or return a copy of
this categorical with unused categories dropped.
Deprecated since version 1.2.0.
Returns
catCategorical or NoneCategorical with unused categories dropped or None if inplace=True.
See also
rename_categoriesRename categories.
reorder_categoriesReorder categories.
add_categoriesAdd new categories.
remove_categoriesRemove the specified categories.
set_categoriesSet the categories to the specified ones.
Examples
>>> c = pd.Categorical(['a', 'c', 'b', 'c', 'd'])
>>> c
['a', 'c', 'b', 'c', 'd']
Categories (4, object): ['a', 'b', 'c', 'd']
>>> c[2] = 'a'
>>> c[4] = 'c'
>>> c
['a', 'c', 'a', 'c', 'c']
Categories (4, object): ['a', 'b', 'c', 'd']
>>> c.remove_unused_categories()
['a', 'c', 'a', 'c', 'c']
Categories (2, object): ['a', 'c']
|
reference/api/pandas.Series.cat.remove_unused_categories.html
|
pandas.Series.sparse.sp_values
|
`pandas.Series.sparse.sp_values`
An ndarray containing the non- fill_value values.
Examples
```
>>> s = SparseArray([0, 0, 1, 0, 2], fill_value=0)
>>> s.sp_values
array([1, 2])
```
|
Series.sparse.sp_values[source]#
An ndarray containing the non- fill_value values.
Examples
>>> s = SparseArray([0, 0, 1, 0, 2], fill_value=0)
>>> s.sp_values
array([1, 2])
|
reference/api/pandas.Series.sparse.sp_values.html
|
pandas.tseries.offsets.Day.base
|
`pandas.tseries.offsets.Day.base`
Returns a copy of the calling offset object with n=1 and all other
attributes equal.
|
Day.base#
Returns a copy of the calling offset object with n=1 and all other
attributes equal.
|
reference/api/pandas.tseries.offsets.Day.base.html
|
pandas.DataFrame.sparse.from_spmatrix
|
`pandas.DataFrame.sparse.from_spmatrix`
Create a new DataFrame from a scipy sparse matrix.
```
>>> import scipy.sparse
>>> mat = scipy.sparse.eye(3)
>>> pd.DataFrame.sparse.from_spmatrix(mat)
0 1 2
0 1.0 0.0 0.0
1 0.0 1.0 0.0
2 0.0 0.0 1.0
```
|
classmethod DataFrame.sparse.from_spmatrix(data, index=None, columns=None)[source]#
Create a new DataFrame from a scipy sparse matrix.
New in version 0.25.0.
Parameters
datascipy.sparse.spmatrixMust be convertible to csc format.
index, columnsIndex, optionalRow and column labels to use for the resulting DataFrame.
Defaults to a RangeIndex.
Returns
DataFrameEach column of the DataFrame is stored as a
arrays.SparseArray.
Examples
>>> import scipy.sparse
>>> mat = scipy.sparse.eye(3)
>>> pd.DataFrame.sparse.from_spmatrix(mat)
0 1 2
0 1.0 0.0 0.0
1 0.0 1.0 0.0
2 0.0 0.0 1.0
|
reference/api/pandas.DataFrame.sparse.from_spmatrix.html
|
Window
|
Rolling objects are returned by .rolling calls: pandas.DataFrame.rolling(), pandas.Series.rolling(), etc.
Expanding objects are returned by .expanding calls: pandas.DataFrame.expanding(), pandas.Series.expanding(), etc.
ExponentialMovingWindow objects are returned by .ewm calls: pandas.DataFrame.ewm(), pandas.Series.ewm(), etc.
Rolling window functions#
Rolling.count([numeric_only])
Calculate the rolling count of non NaN observations.
Rolling.sum([numeric_only, engine, ...])
Calculate the rolling sum.
Rolling.mean([numeric_only, engine, ...])
Calculate the rolling mean.
Rolling.median([numeric_only, engine, ...])
Calculate the rolling median.
Rolling.var([ddof, numeric_only, engine, ...])
Calculate the rolling variance.
Rolling.std([ddof, numeric_only, engine, ...])
Calculate the rolling standard deviation.
Rolling.min([numeric_only, engine, ...])
Calculate the rolling minimum.
Rolling.max([numeric_only, engine, ...])
Calculate the rolling maximum.
Rolling.corr([other, pairwise, ddof, ...])
Calculate the rolling correlation.
Rolling.cov([other, pairwise, ddof, ...])
Calculate the rolling sample covariance.
Rolling.skew([numeric_only])
Calculate the rolling unbiased skewness.
Rolling.kurt([numeric_only])
Calculate the rolling Fisher's definition of kurtosis without bias.
Rolling.apply(func[, raw, engine, ...])
Calculate the rolling custom aggregation function.
Rolling.aggregate(func, *args, **kwargs)
Aggregate using one or more operations over the specified axis.
Rolling.quantile(quantile[, interpolation, ...])
Calculate the rolling quantile.
Rolling.sem([ddof, numeric_only])
Calculate the rolling standard error of mean.
Rolling.rank([method, ascending, pct, ...])
Calculate the rolling rank.
Weighted window functions#
Window.mean([numeric_only])
Calculate the rolling weighted window mean.
Window.sum([numeric_only])
Calculate the rolling weighted window sum.
Window.var([ddof, numeric_only])
Calculate the rolling weighted window variance.
Window.std([ddof, numeric_only])
Calculate the rolling weighted window standard deviation.
Expanding window functions#
Expanding.count([numeric_only])
Calculate the expanding count of non NaN observations.
Expanding.sum([numeric_only, engine, ...])
Calculate the expanding sum.
Expanding.mean([numeric_only, engine, ...])
Calculate the expanding mean.
Expanding.median([numeric_only, engine, ...])
Calculate the expanding median.
Expanding.var([ddof, numeric_only, engine, ...])
Calculate the expanding variance.
Expanding.std([ddof, numeric_only, engine, ...])
Calculate the expanding standard deviation.
Expanding.min([numeric_only, engine, ...])
Calculate the expanding minimum.
Expanding.max([numeric_only, engine, ...])
Calculate the expanding maximum.
Expanding.corr([other, pairwise, ddof, ...])
Calculate the expanding correlation.
Expanding.cov([other, pairwise, ddof, ...])
Calculate the expanding sample covariance.
Expanding.skew([numeric_only])
Calculate the expanding unbiased skewness.
Expanding.kurt([numeric_only])
Calculate the expanding Fisher's definition of kurtosis without bias.
Expanding.apply(func[, raw, engine, ...])
Calculate the expanding custom aggregation function.
Expanding.aggregate(func, *args, **kwargs)
Aggregate using one or more operations over the specified axis.
Expanding.quantile(quantile[, ...])
Calculate the expanding quantile.
Expanding.sem([ddof, numeric_only])
Calculate the expanding standard error of mean.
Expanding.rank([method, ascending, pct, ...])
Calculate the expanding rank.
Exponentially-weighted window functions#
ExponentialMovingWindow.mean([numeric_only, ...])
Calculate the ewm (exponential weighted moment) mean.
ExponentialMovingWindow.sum([numeric_only, ...])
Calculate the ewm (exponential weighted moment) sum.
ExponentialMovingWindow.std([bias, numeric_only])
Calculate the ewm (exponential weighted moment) standard deviation.
ExponentialMovingWindow.var([bias, numeric_only])
Calculate the ewm (exponential weighted moment) variance.
ExponentialMovingWindow.corr([other, ...])
Calculate the ewm (exponential weighted moment) sample correlation.
ExponentialMovingWindow.cov([other, ...])
Calculate the ewm (exponential weighted moment) sample covariance.
Window indexer#
Base class for defining custom window boundaries.
api.indexers.BaseIndexer([index_array, ...])
Base class for window bounds calculations.
api.indexers.FixedForwardWindowIndexer([...])
Creates window boundaries for fixed-length windows that include the current row.
api.indexers.VariableOffsetWindowIndexer([...])
Calculate window boundaries based on a non-fixed offset such as a BusinessDay.
|
reference/window.html
| null |
pandas.tseries.offsets.FY5253Quarter.variation
|
pandas.tseries.offsets.FY5253Quarter.variation
|
FY5253Quarter.variation#
|
reference/api/pandas.tseries.offsets.FY5253Quarter.variation.html
|
pandas.tseries.offsets.CustomBusinessMonthBegin.freqstr
|
`pandas.tseries.offsets.CustomBusinessMonthBegin.freqstr`
Return a string representing the frequency.
Examples
```
>>> pd.DateOffset(5).freqstr
'<5 * DateOffsets>'
```
|
CustomBusinessMonthBegin.freqstr#
Return a string representing the frequency.
Examples
>>> pd.DateOffset(5).freqstr
'<5 * DateOffsets>'
>>> pd.offsets.BusinessHour(2).freqstr
'2BH'
>>> pd.offsets.Nano().freqstr
'N'
>>> pd.offsets.Nano(-3).freqstr
'-3N'
|
reference/api/pandas.tseries.offsets.CustomBusinessMonthBegin.freqstr.html
|
pandas.tseries.offsets.BQuarterBegin.n
|
pandas.tseries.offsets.BQuarterBegin.n
|
BQuarterBegin.n#
|
reference/api/pandas.tseries.offsets.BQuarterBegin.n.html
|
pandas.tseries.offsets.Hour.is_month_start
|
`pandas.tseries.offsets.Hour.is_month_start`
Return boolean whether a timestamp occurs on the month start.
```
>>> ts = pd.Timestamp(2022, 1, 1)
>>> freq = pd.offsets.Hour(5)
>>> freq.is_month_start(ts)
True
```
|
Hour.is_month_start()#
Return boolean whether a timestamp occurs on the month start.
Examples
>>> ts = pd.Timestamp(2022, 1, 1)
>>> freq = pd.offsets.Hour(5)
>>> freq.is_month_start(ts)
True
|
reference/api/pandas.tseries.offsets.Hour.is_month_start.html
|
pandas.api.extensions.ExtensionArray.tolist
|
`pandas.api.extensions.ExtensionArray.tolist`
Return a list of the values.
These are each a scalar type, which is a Python scalar
(for str, int, float) or a pandas scalar
(for Timestamp/Timedelta/Interval/Period)
|
ExtensionArray.tolist()[source]#
Return a list of the values.
These are each a scalar type, which is a Python scalar
(for str, int, float) or a pandas scalar
(for Timestamp/Timedelta/Interval/Period)
Returns
list
|
reference/api/pandas.api.extensions.ExtensionArray.tolist.html
|
Series
|
Series
|
Constructor#
Series([data, index, dtype, name, copy, ...])
One-dimensional ndarray with axis labels (including time series).
Attributes#
Axes
Series.index
The index (axis labels) of the Series.
Series.array
The ExtensionArray of the data backing this Series or Index.
Series.values
Return Series as ndarray or ndarray-like depending on the dtype.
Series.dtype
Return the dtype object of the underlying data.
Series.shape
Return a tuple of the shape of the underlying data.
Series.nbytes
Return the number of bytes in the underlying data.
Series.ndim
Number of dimensions of the underlying data, by definition 1.
Series.size
Return the number of elements in the underlying data.
Series.T
Return the transpose, which is by definition self.
Series.memory_usage([index, deep])
Return the memory usage of the Series.
Series.hasnans
Return True if there are any NaNs.
Series.empty
Indicator whether Series/DataFrame is empty.
Series.dtypes
Return the dtype object of the underlying data.
Series.name
Return the name of the Series.
Series.flags
Get the properties associated with this pandas object.
Series.set_flags(*[, copy, ...])
Return a new object with updated flags.
Conversion#
Series.astype(dtype[, copy, errors])
Cast a pandas object to a specified dtype dtype.
Series.convert_dtypes([infer_objects, ...])
Convert columns to best possible dtypes using dtypes supporting pd.NA.
Series.infer_objects()
Attempt to infer better dtypes for object columns.
Series.copy([deep])
Make a copy of this object's indices and data.
Series.bool()
Return the bool of a single element Series or DataFrame.
Series.to_numpy([dtype, copy, na_value])
A NumPy ndarray representing the values in this Series or Index.
Series.to_period([freq, copy])
Convert Series from DatetimeIndex to PeriodIndex.
Series.to_timestamp([freq, how, copy])
Cast to DatetimeIndex of Timestamps, at beginning of period.
Series.to_list()
Return a list of the values.
Series.__array__([dtype])
Return the values as a NumPy array.
Indexing, iteration#
Series.get(key[, default])
Get item from object for given key (ex: DataFrame column).
Series.at
Access a single value for a row/column label pair.
Series.iat
Access a single value for a row/column pair by integer position.
Series.loc
Access a group of rows and columns by label(s) or a boolean array.
Series.iloc
Purely integer-location based indexing for selection by position.
Series.__iter__()
Return an iterator of the values.
Series.items()
Lazily iterate over (index, value) tuples.
Series.iteritems()
(DEPRECATED) Lazily iterate over (index, value) tuples.
Series.keys()
Return alias for index.
Series.pop(item)
Return item and drops from series.
Series.item()
Return the first element of the underlying data as a Python scalar.
Series.xs(key[, axis, level, drop_level])
Return cross-section from the Series/DataFrame.
For more information on .at, .iat, .loc, and
.iloc, see the indexing documentation.
Binary operator functions#
Series.add(other[, level, fill_value, axis])
Return Addition of series and other, element-wise (binary operator add).
Series.sub(other[, level, fill_value, axis])
Return Subtraction of series and other, element-wise (binary operator sub).
Series.mul(other[, level, fill_value, axis])
Return Multiplication of series and other, element-wise (binary operator mul).
Series.div(other[, level, fill_value, axis])
Return Floating division of series and other, element-wise (binary operator truediv).
Series.truediv(other[, level, fill_value, axis])
Return Floating division of series and other, element-wise (binary operator truediv).
Series.floordiv(other[, level, fill_value, axis])
Return Integer division of series and other, element-wise (binary operator floordiv).
Series.mod(other[, level, fill_value, axis])
Return Modulo of series and other, element-wise (binary operator mod).
Series.pow(other[, level, fill_value, axis])
Return Exponential power of series and other, element-wise (binary operator pow).
Series.radd(other[, level, fill_value, axis])
Return Addition of series and other, element-wise (binary operator radd).
Series.rsub(other[, level, fill_value, axis])
Return Subtraction of series and other, element-wise (binary operator rsub).
Series.rmul(other[, level, fill_value, axis])
Return Multiplication of series and other, element-wise (binary operator rmul).
Series.rdiv(other[, level, fill_value, axis])
Return Floating division of series and other, element-wise (binary operator rtruediv).
Series.rtruediv(other[, level, fill_value, axis])
Return Floating division of series and other, element-wise (binary operator rtruediv).
Series.rfloordiv(other[, level, fill_value, ...])
Return Integer division of series and other, element-wise (binary operator rfloordiv).
Series.rmod(other[, level, fill_value, axis])
Return Modulo of series and other, element-wise (binary operator rmod).
Series.rpow(other[, level, fill_value, axis])
Return Exponential power of series and other, element-wise (binary operator rpow).
Series.combine(other, func[, fill_value])
Combine the Series with a Series or scalar according to func.
Series.combine_first(other)
Update null elements with value in the same location in 'other'.
Series.round([decimals])
Round each value in a Series to the given number of decimals.
Series.lt(other[, level, fill_value, axis])
Return Less than of series and other, element-wise (binary operator lt).
Series.gt(other[, level, fill_value, axis])
Return Greater than of series and other, element-wise (binary operator gt).
Series.le(other[, level, fill_value, axis])
Return Less than or equal to of series and other, element-wise (binary operator le).
Series.ge(other[, level, fill_value, axis])
Return Greater than or equal to of series and other, element-wise (binary operator ge).
Series.ne(other[, level, fill_value, axis])
Return Not equal to of series and other, element-wise (binary operator ne).
Series.eq(other[, level, fill_value, axis])
Return Equal to of series and other, element-wise (binary operator eq).
Series.product([axis, skipna, level, ...])
Return the product of the values over the requested axis.
Series.dot(other)
Compute the dot product between the Series and the columns of other.
Function application, GroupBy & window#
Series.apply(func[, convert_dtype, args])
Invoke function on values of Series.
Series.agg([func, axis])
Aggregate using one or more operations over the specified axis.
Series.aggregate([func, axis])
Aggregate using one or more operations over the specified axis.
Series.transform(func[, axis])
Call func on self producing a Series with the same axis shape as self.
Series.map(arg[, na_action])
Map values of Series according to an input mapping or function.
Series.groupby([by, axis, level, as_index, ...])
Group Series using a mapper or by a Series of columns.
Series.rolling(window[, min_periods, ...])
Provide rolling window calculations.
Series.expanding([min_periods, center, ...])
Provide expanding window calculations.
Series.ewm([com, span, halflife, alpha, ...])
Provide exponentially weighted (EW) calculations.
Series.pipe(func, *args, **kwargs)
Apply chainable functions that expect Series or DataFrames.
Computations / descriptive stats#
Series.abs()
Return a Series/DataFrame with absolute numeric value of each element.
Series.all([axis, bool_only, skipna, level])
Return whether all elements are True, potentially over an axis.
Series.any(*[, axis, bool_only, skipna, level])
Return whether any element is True, potentially over an axis.
Series.autocorr([lag])
Compute the lag-N autocorrelation.
Series.between(left, right[, inclusive])
Return boolean Series equivalent to left <= series <= right.
Series.clip([lower, upper, axis, inplace])
Trim values at input threshold(s).
Series.corr(other[, method, min_periods])
Compute correlation with other Series, excluding missing values.
Series.count([level])
Return number of non-NA/null observations in the Series.
Series.cov(other[, min_periods, ddof])
Compute covariance with Series, excluding missing values.
Series.cummax([axis, skipna])
Return cumulative maximum over a DataFrame or Series axis.
Series.cummin([axis, skipna])
Return cumulative minimum over a DataFrame or Series axis.
Series.cumprod([axis, skipna])
Return cumulative product over a DataFrame or Series axis.
Series.cumsum([axis, skipna])
Return cumulative sum over a DataFrame or Series axis.
Series.describe([percentiles, include, ...])
Generate descriptive statistics.
Series.diff([periods])
First discrete difference of element.
Series.factorize([sort, na_sentinel, ...])
Encode the object as an enumerated type or categorical variable.
Series.kurt([axis, skipna, level, numeric_only])
Return unbiased kurtosis over requested axis.
Series.mad([axis, skipna, level])
(DEPRECATED) Return the mean absolute deviation of the values over the requested axis.
Series.max([axis, skipna, level, numeric_only])
Return the maximum of the values over the requested axis.
Series.mean([axis, skipna, level, numeric_only])
Return the mean of the values over the requested axis.
Series.median([axis, skipna, level, ...])
Return the median of the values over the requested axis.
Series.min([axis, skipna, level, numeric_only])
Return the minimum of the values over the requested axis.
Series.mode([dropna])
Return the mode(s) of the Series.
Series.nlargest([n, keep])
Return the largest n elements.
Series.nsmallest([n, keep])
Return the smallest n elements.
Series.pct_change([periods, fill_method, ...])
Percentage change between the current and a prior element.
Series.prod([axis, skipna, level, ...])
Return the product of the values over the requested axis.
Series.quantile([q, interpolation])
Return value at the given quantile.
Series.rank([axis, method, numeric_only, ...])
Compute numerical data ranks (1 through n) along axis.
Series.sem([axis, skipna, level, ddof, ...])
Return unbiased standard error of the mean over requested axis.
Series.skew([axis, skipna, level, numeric_only])
Return unbiased skew over requested axis.
Series.std([axis, skipna, level, ddof, ...])
Return sample standard deviation over requested axis.
Series.sum([axis, skipna, level, ...])
Return the sum of the values over the requested axis.
Series.var([axis, skipna, level, ddof, ...])
Return unbiased variance over requested axis.
Series.kurtosis([axis, skipna, level, ...])
Return unbiased kurtosis over requested axis.
Series.unique()
Return unique values of Series object.
Series.nunique([dropna])
Return number of unique elements in the object.
Series.is_unique
Return boolean if values in the object are unique.
Series.is_monotonic
(DEPRECATED) Return boolean if values in the object are monotonically increasing.
Series.is_monotonic_increasing
Return boolean if values in the object are monotonically increasing.
Series.is_monotonic_decreasing
Return boolean if values in the object are monotonically decreasing.
Series.value_counts([normalize, sort, ...])
Return a Series containing counts of unique values.
Reindexing / selection / label manipulation#
Series.align(other[, join, axis, level, ...])
Align two objects on their axes with the specified join method.
Series.drop([labels, axis, index, columns, ...])
Return Series with specified index labels removed.
Series.droplevel(level[, axis])
Return Series/DataFrame with requested index / column level(s) removed.
Series.drop_duplicates(*[, keep, inplace])
Return Series with duplicate values removed.
Series.duplicated([keep])
Indicate duplicate Series values.
Series.equals(other)
Test whether two objects contain the same elements.
Series.first(offset)
Select initial periods of time series data based on a date offset.
Series.head([n])
Return the first n rows.
Series.idxmax([axis, skipna])
Return the row label of the maximum value.
Series.idxmin([axis, skipna])
Return the row label of the minimum value.
Series.isin(values)
Whether elements in Series are contained in values.
Series.last(offset)
Select final periods of time series data based on a date offset.
Series.reindex(*args, **kwargs)
Conform Series to new index with optional filling logic.
Series.reindex_like(other[, method, copy, ...])
Return an object with matching indices as other object.
Series.rename([index, axis, copy, inplace, ...])
Alter Series index labels or name.
Series.rename_axis([mapper, inplace])
Set the name of the axis for the index or columns.
Series.reset_index([level, drop, name, ...])
Generate a new DataFrame or Series with the index reset.
Series.sample([n, frac, replace, weights, ...])
Return a random sample of items from an axis of object.
Series.set_axis(labels, *[, axis, inplace, copy])
Assign desired index to given axis.
Series.take(indices[, axis, is_copy])
Return the elements in the given positional indices along an axis.
Series.tail([n])
Return the last n rows.
Series.truncate([before, after, axis, copy])
Truncate a Series or DataFrame before and after some index value.
Series.where(cond[, other, inplace, axis, ...])
Replace values where the condition is False.
Series.mask(cond[, other, inplace, axis, ...])
Replace values where the condition is True.
Series.add_prefix(prefix)
Prefix labels with string prefix.
Series.add_suffix(suffix)
Suffix labels with string suffix.
Series.filter([items, like, regex, axis])
Subset the dataframe rows or columns according to the specified index labels.
Missing data handling#
Series.backfill(*[, axis, inplace, limit, ...])
Synonym for DataFrame.fillna() with method='bfill'.
Series.bfill(*[, axis, inplace, limit, downcast])
Synonym for DataFrame.fillna() with method='bfill'.
Series.dropna(*[, axis, inplace, how])
Return a new Series with missing values removed.
Series.ffill(*[, axis, inplace, limit, downcast])
Synonym for DataFrame.fillna() with method='ffill'.
Series.fillna([value, method, axis, ...])
Fill NA/NaN values using the specified method.
Series.interpolate([method, axis, limit, ...])
Fill NaN values using an interpolation method.
Series.isna()
Detect missing values.
Series.isnull()
Series.isnull is an alias for Series.isna.
Series.notna()
Detect existing (non-missing) values.
Series.notnull()
Series.notnull is an alias for Series.notna.
Series.pad(*[, axis, inplace, limit, downcast])
Synonym for DataFrame.fillna() with method='ffill'.
Series.replace([to_replace, value, inplace, ...])
Replace values given in to_replace with value.
Reshaping, sorting#
Series.argsort([axis, kind, order])
Return the integer indices that would sort the Series values.
Series.argmin([axis, skipna])
Return int position of the smallest value in the Series.
Series.argmax([axis, skipna])
Return int position of the largest value in the Series.
Series.reorder_levels(order)
Rearrange index levels using input order.
Series.sort_values(*[, axis, ascending, ...])
Sort by the values.
Series.sort_index(*[, axis, level, ...])
Sort Series by index labels.
Series.swaplevel([i, j, copy])
Swap levels i and j in a MultiIndex.
Series.unstack([level, fill_value])
Unstack, also known as pivot, Series with MultiIndex to produce DataFrame.
Series.explode([ignore_index])
Transform each element of a list-like to a row.
Series.searchsorted(value[, side, sorter])
Find indices where elements should be inserted to maintain order.
Series.ravel([order])
Return the flattened underlying data as an ndarray.
Series.repeat(repeats[, axis])
Repeat elements of a Series.
Series.squeeze([axis])
Squeeze 1 dimensional axis objects into scalars.
Series.view([dtype])
Create a new view of the Series.
Combining / comparing / joining / merging#
Series.append(to_append[, ignore_index, ...])
(DEPRECATED) Concatenate two or more Series.
Series.compare(other[, align_axis, ...])
Compare to another Series and show the differences.
Series.update(other)
Modify Series in place using values from passed Series.
Time Series-related#
Series.asfreq(freq[, method, how, ...])
Convert time series to specified frequency.
Series.asof(where[, subset])
Return the last row(s) without any NaNs before where.
Series.shift([periods, freq, axis, fill_value])
Shift index by desired number of periods with an optional time freq.
Series.first_valid_index()
Return index for first non-NA value or None, if no non-NA value is found.
Series.last_valid_index()
Return index for last non-NA value or None, if no non-NA value is found.
Series.resample(rule[, axis, closed, label, ...])
Resample time-series data.
Series.tz_convert(tz[, axis, level, copy])
Convert tz-aware axis to target time zone.
Series.tz_localize(tz[, axis, level, copy, ...])
Localize tz-naive index of a Series or DataFrame to target time zone.
Series.at_time(time[, asof, axis])
Select values at particular time of day (e.g., 9:30AM).
Series.between_time(start_time, end_time[, ...])
Select values between particular times of the day (e.g., 9:00-9:30 AM).
Series.tshift([periods, freq, axis])
(DEPRECATED) Shift the time index, using the index's frequency if available.
Series.slice_shift([periods, axis])
(DEPRECATED) Equivalent to shift without copying data.
Accessors#
pandas provides dtype-specific methods under various accessors.
These are separate namespaces within Series that only apply
to specific data types.
Data Type
Accessor
Datetime, Timedelta, Period
dt
String
str
Categorical
cat
Sparse
sparse
Datetimelike properties#
Series.dt can be used to access the values of the series as
datetimelike and return several properties.
These can be accessed like Series.dt.<property>.
Datetime properties#
Series.dt.date
Returns numpy array of python datetime.date objects.
Series.dt.time
Returns numpy array of datetime.time objects.
Series.dt.timetz
Returns numpy array of datetime.time objects with timezones.
Series.dt.year
The year of the datetime.
Series.dt.month
The month as January=1, December=12.
Series.dt.day
The day of the datetime.
Series.dt.hour
The hours of the datetime.
Series.dt.minute
The minutes of the datetime.
Series.dt.second
The seconds of the datetime.
Series.dt.microsecond
The microseconds of the datetime.
Series.dt.nanosecond
The nanoseconds of the datetime.
Series.dt.week
(DEPRECATED) The week ordinal of the year according to the ISO 8601 standard.
Series.dt.weekofyear
(DEPRECATED) The week ordinal of the year according to the ISO 8601 standard.
Series.dt.dayofweek
The day of the week with Monday=0, Sunday=6.
Series.dt.day_of_week
The day of the week with Monday=0, Sunday=6.
Series.dt.weekday
The day of the week with Monday=0, Sunday=6.
Series.dt.dayofyear
The ordinal day of the year.
Series.dt.day_of_year
The ordinal day of the year.
Series.dt.quarter
The quarter of the date.
Series.dt.is_month_start
Indicates whether the date is the first day of the month.
Series.dt.is_month_end
Indicates whether the date is the last day of the month.
Series.dt.is_quarter_start
Indicator for whether the date is the first day of a quarter.
Series.dt.is_quarter_end
Indicator for whether the date is the last day of a quarter.
Series.dt.is_year_start
Indicate whether the date is the first day of a year.
Series.dt.is_year_end
Indicate whether the date is the last day of the year.
Series.dt.is_leap_year
Boolean indicator if the date belongs to a leap year.
Series.dt.daysinmonth
The number of days in the month.
Series.dt.days_in_month
The number of days in the month.
Series.dt.tz
Return the timezone.
Series.dt.freq
Return the frequency object for this PeriodArray.
Datetime methods#
Series.dt.isocalendar()
Calculate year, week, and day according to the ISO 8601 standard.
Series.dt.to_period(*args, **kwargs)
Cast to PeriodArray/Index at a particular frequency.
Series.dt.to_pydatetime()
Return the data as an array of datetime.datetime objects.
Series.dt.tz_localize(*args, **kwargs)
Localize tz-naive Datetime Array/Index to tz-aware Datetime Array/Index.
Series.dt.tz_convert(*args, **kwargs)
Convert tz-aware Datetime Array/Index from one time zone to another.
Series.dt.normalize(*args, **kwargs)
Convert times to midnight.
Series.dt.strftime(*args, **kwargs)
Convert to Index using specified date_format.
Series.dt.round(*args, **kwargs)
Perform round operation on the data to the specified freq.
Series.dt.floor(*args, **kwargs)
Perform floor operation on the data to the specified freq.
Series.dt.ceil(*args, **kwargs)
Perform ceil operation on the data to the specified freq.
Series.dt.month_name(*args, **kwargs)
Return the month names with specified locale.
Series.dt.day_name(*args, **kwargs)
Return the day names with specified locale.
Period properties#
Series.dt.qyear
Series.dt.start_time
Get the Timestamp for the start of the period.
Series.dt.end_time
Get the Timestamp for the end of the period.
Timedelta properties#
Series.dt.days
Number of days for each element.
Series.dt.seconds
Number of seconds (>= 0 and less than 1 day) for each element.
Series.dt.microseconds
Number of microseconds (>= 0 and less than 1 second) for each element.
Series.dt.nanoseconds
Number of nanoseconds (>= 0 and less than 1 microsecond) for each element.
Series.dt.components
Return a Dataframe of the components of the Timedeltas.
Timedelta methods#
Series.dt.to_pytimedelta()
Return an array of native datetime.timedelta objects.
Series.dt.total_seconds(*args, **kwargs)
Return total duration of each element expressed in seconds.
String handling#
Series.str can be used to access the values of the series as
strings and apply several methods to it. These can be accessed like
Series.str.<function/property>.
Series.str.capitalize()
Convert strings in the Series/Index to be capitalized.
Series.str.casefold()
Convert strings in the Series/Index to be casefolded.
Series.str.cat([others, sep, na_rep, join])
Concatenate strings in the Series/Index with given separator.
Series.str.center(width[, fillchar])
Pad left and right side of strings in the Series/Index.
Series.str.contains(pat[, case, flags, na, ...])
Test if pattern or regex is contained within a string of a Series or Index.
Series.str.count(pat[, flags])
Count occurrences of pattern in each string of the Series/Index.
Series.str.decode(encoding[, errors])
Decode character string in the Series/Index using indicated encoding.
Series.str.encode(encoding[, errors])
Encode character string in the Series/Index using indicated encoding.
Series.str.endswith(pat[, na])
Test if the end of each string element matches a pattern.
Series.str.extract(pat[, flags, expand])
Extract capture groups in the regex pat as columns in a DataFrame.
Series.str.extractall(pat[, flags])
Extract capture groups in the regex pat as columns in DataFrame.
Series.str.find(sub[, start, end])
Return lowest indexes in each strings in the Series/Index.
Series.str.findall(pat[, flags])
Find all occurrences of pattern or regular expression in the Series/Index.
Series.str.fullmatch(pat[, case, flags, na])
Determine if each string entirely matches a regular expression.
Series.str.get(i)
Extract element from each component at specified position or with specified key.
Series.str.index(sub[, start, end])
Return lowest indexes in each string in Series/Index.
Series.str.join(sep)
Join lists contained as elements in the Series/Index with passed delimiter.
Series.str.len()
Compute the length of each element in the Series/Index.
Series.str.ljust(width[, fillchar])
Pad right side of strings in the Series/Index.
Series.str.lower()
Convert strings in the Series/Index to lowercase.
Series.str.lstrip([to_strip])
Remove leading characters.
Series.str.match(pat[, case, flags, na])
Determine if each string starts with a match of a regular expression.
Series.str.normalize(form)
Return the Unicode normal form for the strings in the Series/Index.
Series.str.pad(width[, side, fillchar])
Pad strings in the Series/Index up to width.
Series.str.partition([sep, expand])
Split the string at the first occurrence of sep.
Series.str.removeprefix(prefix)
Remove a prefix from an object series.
Series.str.removesuffix(suffix)
Remove a suffix from an object series.
Series.str.repeat(repeats)
Duplicate each string in the Series or Index.
Series.str.replace(pat, repl[, n, case, ...])
Replace each occurrence of pattern/regex in the Series/Index.
Series.str.rfind(sub[, start, end])
Return highest indexes in each strings in the Series/Index.
Series.str.rindex(sub[, start, end])
Return highest indexes in each string in Series/Index.
Series.str.rjust(width[, fillchar])
Pad left side of strings in the Series/Index.
Series.str.rpartition([sep, expand])
Split the string at the last occurrence of sep.
Series.str.rstrip([to_strip])
Remove trailing characters.
Series.str.slice([start, stop, step])
Slice substrings from each element in the Series or Index.
Series.str.slice_replace([start, stop, repl])
Replace a positional slice of a string with another value.
Series.str.split([pat, n, expand, regex])
Split strings around given separator/delimiter.
Series.str.rsplit([pat, n, expand])
Split strings around given separator/delimiter.
Series.str.startswith(pat[, na])
Test if the start of each string element matches a pattern.
Series.str.strip([to_strip])
Remove leading and trailing characters.
Series.str.swapcase()
Convert strings in the Series/Index to be swapcased.
Series.str.title()
Convert strings in the Series/Index to titlecase.
Series.str.translate(table)
Map all characters in the string through the given mapping table.
Series.str.upper()
Convert strings in the Series/Index to uppercase.
Series.str.wrap(width, **kwargs)
Wrap strings in Series/Index at specified line width.
Series.str.zfill(width)
Pad strings in the Series/Index by prepending '0' characters.
Series.str.isalnum()
Check whether all characters in each string are alphanumeric.
Series.str.isalpha()
Check whether all characters in each string are alphabetic.
Series.str.isdigit()
Check whether all characters in each string are digits.
Series.str.isspace()
Check whether all characters in each string are whitespace.
Series.str.islower()
Check whether all characters in each string are lowercase.
Series.str.isupper()
Check whether all characters in each string are uppercase.
Series.str.istitle()
Check whether all characters in each string are titlecase.
Series.str.isnumeric()
Check whether all characters in each string are numeric.
Series.str.isdecimal()
Check whether all characters in each string are decimal.
Series.str.get_dummies([sep])
Return DataFrame of dummy/indicator variables for Series.
Categorical accessor#
Categorical-dtype specific methods and attributes are available under
the Series.cat accessor.
Series.cat.categories
The categories of this categorical.
Series.cat.ordered
Whether the categories have an ordered relationship.
Series.cat.codes
Return Series of codes as well as the index.
Series.cat.rename_categories(*args, **kwargs)
Rename categories.
Series.cat.reorder_categories(*args, **kwargs)
Reorder categories as specified in new_categories.
Series.cat.add_categories(*args, **kwargs)
Add new categories.
Series.cat.remove_categories(*args, **kwargs)
Remove the specified categories.
Series.cat.remove_unused_categories(*args, ...)
Remove categories which are not used.
Series.cat.set_categories(*args, **kwargs)
Set the categories to the specified new_categories.
Series.cat.as_ordered(*args, **kwargs)
Set the Categorical to be ordered.
Series.cat.as_unordered(*args, **kwargs)
Set the Categorical to be unordered.
Sparse accessor#
Sparse-dtype specific methods and attributes are provided under the
Series.sparse accessor.
Series.sparse.npoints
The number of non- fill_value points.
Series.sparse.density
The percent of non- fill_value points, as decimal.
Series.sparse.fill_value
Elements in data that are fill_value are not stored.
Series.sparse.sp_values
An ndarray containing the non- fill_value values.
Series.sparse.from_coo(A[, dense_index])
Create a Series with sparse values from a scipy.sparse.coo_matrix.
Series.sparse.to_coo([row_levels, ...])
Create a scipy.sparse.coo_matrix from a Series with MultiIndex.
Flags#
Flags refer to attributes of the pandas object. Properties of the dataset (like
the date is was recorded, the URL it was accessed from, etc.) should be stored
in Series.attrs.
Flags(obj, *, allows_duplicate_labels)
Flags that apply to pandas objects.
Metadata#
Series.attrs is a dictionary for storing global metadata for this Series.
Warning
Series.attrs is considered experimental and may change without warning.
Series.attrs
Dictionary of global attributes of this dataset.
Plotting#
Series.plot is both a callable method and a namespace attribute for
specific plotting methods of the form Series.plot.<kind>.
Series.plot([kind, ax, figsize, ....])
Series plotting accessor and method
Series.plot.area([x, y])
Draw a stacked area plot.
Series.plot.bar([x, y])
Vertical bar plot.
Series.plot.barh([x, y])
Make a horizontal bar plot.
Series.plot.box([by])
Make a box plot of the DataFrame columns.
Series.plot.density([bw_method, ind])
Generate Kernel Density Estimate plot using Gaussian kernels.
Series.plot.hist([by, bins])
Draw one histogram of the DataFrame's columns.
Series.plot.kde([bw_method, ind])
Generate Kernel Density Estimate plot using Gaussian kernels.
Series.plot.line([x, y])
Plot Series or DataFrame as lines.
Series.plot.pie(**kwargs)
Generate a pie plot.
Series.hist([by, ax, grid, xlabelsize, ...])
Draw histogram of the input series using matplotlib.
Serialization / IO / conversion#
Series.to_pickle(path[, compression, ...])
Pickle (serialize) object to file.
Series.to_csv([path_or_buf, sep, na_rep, ...])
Write object to a comma-separated values (csv) file.
Series.to_dict([into])
Convert Series to {label -> value} dict or dict-like object.
Series.to_excel(excel_writer[, sheet_name, ...])
Write object to an Excel sheet.
Series.to_frame([name])
Convert Series to DataFrame.
Series.to_xarray()
Return an xarray object from the pandas object.
Series.to_hdf(path_or_buf, key[, mode, ...])
Write the contained data to an HDF5 file using HDFStore.
Series.to_sql(name, con[, schema, ...])
Write records stored in a DataFrame to a SQL database.
Series.to_json([path_or_buf, orient, ...])
Convert the object to a JSON string.
Series.to_string([buf, na_rep, ...])
Render a string representation of the Series.
Series.to_clipboard([excel, sep])
Copy object to the system clipboard.
Series.to_latex([buf, columns, col_space, ...])
Render object to a LaTeX tabular, longtable, or nested table.
Series.to_markdown([buf, mode, index, ...])
Print Series in Markdown-friendly format.
|
reference/series.html
|
pandas.api.extensions.ExtensionDtype.empty
|
`pandas.api.extensions.ExtensionDtype.empty`
Construct an ExtensionArray of this dtype with the given shape.
|
ExtensionDtype.empty(shape)[source]#
Construct an ExtensionArray of this dtype with the given shape.
Analogous to numpy.empty.
Parameters
shapeint or tuple[int]
Returns
ExtensionArray
|
reference/api/pandas.api.extensions.ExtensionDtype.empty.html
|
pandas.Index.asi8
|
`pandas.Index.asi8`
Integer representation of the values.
|
property Index.asi8[source]#
Integer representation of the values.
Returns
ndarrayAn ndarray with int64 dtype.
|
reference/api/pandas.Index.asi8.html
|
Sparse data structures
|
Sparse data structures
pandas provides data structures for efficiently storing sparse data.
These are not necessarily sparse in the typical “mostly 0”. Rather, you can view these
objects as being “compressed” where any data matching a specific value (NaN / missing value, though any value
can be chosen, including 0) is omitted. The compressed values are not actually stored in the array.
Notice the dtype, Sparse[float64, nan]. The nan means that elements in the
array that are nan aren’t actually stored, only the non-nan elements are.
Those non-nan elements have a float64 dtype.
The sparse objects exist for memory efficiency reasons. Suppose you had a
large, mostly NA DataFrame:
As you can see, the density (% of values that have not been “compressed”) is
extremely low. This sparse object takes up much less memory on disk (pickled)
and in the Python interpreter.
Functionally, their behavior should be nearly
identical to their dense counterparts.
|
pandas provides data structures for efficiently storing sparse data.
These are not necessarily sparse in the typical “mostly 0”. Rather, you can view these
objects as being “compressed” where any data matching a specific value (NaN / missing value, though any value
can be chosen, including 0) is omitted. The compressed values are not actually stored in the array.
In [1]: arr = np.random.randn(10)
In [2]: arr[2:-2] = np.nan
In [3]: ts = pd.Series(pd.arrays.SparseArray(arr))
In [4]: ts
Out[4]:
0 0.469112
1 -0.282863
2 NaN
3 NaN
4 NaN
5 NaN
6 NaN
7 NaN
8 -0.861849
9 -2.104569
dtype: Sparse[float64, nan]
Notice the dtype, Sparse[float64, nan]. The nan means that elements in the
array that are nan aren’t actually stored, only the non-nan elements are.
Those non-nan elements have a float64 dtype.
The sparse objects exist for memory efficiency reasons. Suppose you had a
large, mostly NA DataFrame:
In [5]: df = pd.DataFrame(np.random.randn(10000, 4))
In [6]: df.iloc[:9998] = np.nan
In [7]: sdf = df.astype(pd.SparseDtype("float", np.nan))
In [8]: sdf.head()
Out[8]:
0 1 2 3
0 NaN NaN NaN NaN
1 NaN NaN NaN NaN
2 NaN NaN NaN NaN
3 NaN NaN NaN NaN
4 NaN NaN NaN NaN
In [9]: sdf.dtypes
Out[9]:
0 Sparse[float64, nan]
1 Sparse[float64, nan]
2 Sparse[float64, nan]
3 Sparse[float64, nan]
dtype: object
In [10]: sdf.sparse.density
Out[10]: 0.0002
As you can see, the density (% of values that have not been “compressed”) is
extremely low. This sparse object takes up much less memory on disk (pickled)
and in the Python interpreter.
In [11]: 'dense : {:0.2f} bytes'.format(df.memory_usage().sum() / 1e3)
Out[11]: 'dense : 320.13 bytes'
In [12]: 'sparse: {:0.2f} bytes'.format(sdf.memory_usage().sum() / 1e3)
Out[12]: 'sparse: 0.22 bytes'
Functionally, their behavior should be nearly
identical to their dense counterparts.
SparseArray#
arrays.SparseArray is a ExtensionArray
for storing an array of sparse values (see dtypes for more
on extension arrays). It is a 1-dimensional ndarray-like object storing
only values distinct from the fill_value:
In [13]: arr = np.random.randn(10)
In [14]: arr[2:5] = np.nan
In [15]: arr[7:8] = np.nan
In [16]: sparr = pd.arrays.SparseArray(arr)
In [17]: sparr
Out[17]:
[-1.9556635297215477, -1.6588664275960427, nan, nan, nan, 1.1589328886422277, 0.14529711373305043, nan, 0.6060271905134522, 1.3342113401317768]
Fill: nan
IntIndex
Indices: array([0, 1, 5, 6, 8, 9], dtype=int32)
A sparse array can be converted to a regular (dense) ndarray with numpy.asarray()
In [18]: np.asarray(sparr)
Out[18]:
array([-1.9557, -1.6589, nan, nan, nan, 1.1589, 0.1453,
nan, 0.606 , 1.3342])
SparseDtype#
The SparseArray.dtype property stores two pieces of information
The dtype of the non-sparse values
The scalar fill value
In [19]: sparr.dtype
Out[19]: Sparse[float64, nan]
A SparseDtype may be constructed by passing only a dtype
In [20]: pd.SparseDtype(np.dtype('datetime64[ns]'))
Out[20]: Sparse[datetime64[ns], numpy.datetime64('NaT')]
in which case a default fill value will be used (for NumPy dtypes this is often the
“missing” value for that dtype). To override this default an explicit fill value may be
passed instead
In [21]: pd.SparseDtype(np.dtype('datetime64[ns]'),
....: fill_value=pd.Timestamp('2017-01-01'))
....:
Out[21]: Sparse[datetime64[ns], Timestamp('2017-01-01 00:00:00')]
Finally, the string alias 'Sparse[dtype]' may be used to specify a sparse dtype
in many places
In [22]: pd.array([1, 0, 0, 2], dtype='Sparse[int]')
Out[22]:
[1, 0, 0, 2]
Fill: 0
IntIndex
Indices: array([0, 3], dtype=int32)
Sparse accessor#
pandas provides a .sparse accessor, similar to .str for string data, .cat
for categorical data, and .dt for datetime-like data. This namespace provides
attributes and methods that are specific to sparse data.
In [23]: s = pd.Series([0, 0, 1, 2], dtype="Sparse[int]")
In [24]: s.sparse.density
Out[24]: 0.5
In [25]: s.sparse.fill_value
Out[25]: 0
This accessor is available only on data with SparseDtype, and on the Series
class itself for creating a Series with sparse data from a scipy COO matrix with.
New in version 0.25.0.
A .sparse accessor has been added for DataFrame as well.
See Sparse accessor for more.
Sparse calculation#
You can apply NumPy ufuncs
to arrays.SparseArray and get a arrays.SparseArray as a result.
In [26]: arr = pd.arrays.SparseArray([1., np.nan, np.nan, -2., np.nan])
In [27]: np.abs(arr)
Out[27]:
[1.0, nan, nan, 2.0, nan]
Fill: nan
IntIndex
Indices: array([0, 3], dtype=int32)
The ufunc is also applied to fill_value. This is needed to get
the correct dense result.
In [28]: arr = pd.arrays.SparseArray([1., -1, -1, -2., -1], fill_value=-1)
In [29]: np.abs(arr)
Out[29]:
[1, 1, 1, 2.0, 1]
Fill: 1
IntIndex
Indices: array([3], dtype=int32)
In [30]: np.abs(arr).to_dense()
Out[30]: array([1., 1., 1., 2., 1.])
Migrating#
Note
SparseSeries and SparseDataFrame were removed in pandas 1.0.0. This migration
guide is present to aid in migrating from previous versions.
In older versions of pandas, the SparseSeries and SparseDataFrame classes (documented below)
were the preferred way to work with sparse data. With the advent of extension arrays, these subclasses
are no longer needed. Their purpose is better served by using a regular Series or DataFrame with
sparse values instead.
Note
There’s no performance or memory penalty to using a Series or DataFrame with sparse values,
rather than a SparseSeries or SparseDataFrame.
This section provides some guidance on migrating your code to the new style. As a reminder,
you can use the Python warnings module to control warnings. But we recommend modifying
your code, rather than ignoring the warning.
Construction
From an array-like, use the regular Series or
DataFrame constructors with arrays.SparseArray values.
# Previous way
>>> pd.SparseDataFrame({"A": [0, 1]})
# New way
In [31]: pd.DataFrame({"A": pd.arrays.SparseArray([0, 1])})
Out[31]:
A
0 0
1 1
From a SciPy sparse matrix, use DataFrame.sparse.from_spmatrix(),
# Previous way
>>> from scipy import sparse
>>> mat = sparse.eye(3)
>>> df = pd.SparseDataFrame(mat, columns=['A', 'B', 'C'])
# New way
In [32]: from scipy import sparse
In [33]: mat = sparse.eye(3)
In [34]: df = pd.DataFrame.sparse.from_spmatrix(mat, columns=['A', 'B', 'C'])
In [35]: df.dtypes
Out[35]:
A Sparse[float64, 0]
B Sparse[float64, 0]
C Sparse[float64, 0]
dtype: object
Conversion
From sparse to dense, use the .sparse accessors
In [36]: df.sparse.to_dense()
Out[36]:
A B C
0 1.0 0.0 0.0
1 0.0 1.0 0.0
2 0.0 0.0 1.0
In [37]: df.sparse.to_coo()
Out[37]:
<3x3 sparse matrix of type '<class 'numpy.float64'>'
with 3 stored elements in COOrdinate format>
From dense to sparse, use DataFrame.astype() with a SparseDtype.
In [38]: dense = pd.DataFrame({"A": [1, 0, 0, 1]})
In [39]: dtype = pd.SparseDtype(int, fill_value=0)
In [40]: dense.astype(dtype)
Out[40]:
A
0 1
1 0
2 0
3 1
Sparse Properties
Sparse-specific properties, like density, are available on the .sparse accessor.
In [41]: df.sparse.density
Out[41]: 0.3333333333333333
General differences
In a SparseDataFrame, all columns were sparse. A DataFrame can have a mixture of
sparse and dense columns. As a consequence, assigning new columns to a DataFrame with sparse
values will not automatically convert the input to be sparse.
# Previous Way
>>> df = pd.SparseDataFrame({"A": [0, 1]})
>>> df['B'] = [0, 0] # implicitly becomes Sparse
>>> df['B'].dtype
Sparse[int64, nan]
Instead, you’ll need to ensure that the values being assigned are sparse
In [42]: df = pd.DataFrame({"A": pd.arrays.SparseArray([0, 1])})
In [43]: df['B'] = [0, 0] # remains dense
In [44]: df['B'].dtype
Out[44]: dtype('int64')
In [45]: df['B'] = pd.arrays.SparseArray([0, 0])
In [46]: df['B'].dtype
Out[46]: Sparse[int64, 0]
The SparseDataFrame.default_kind and SparseDataFrame.default_fill_value attributes
have no replacement.
Interaction with scipy.sparse#
Use DataFrame.sparse.from_spmatrix() to create a DataFrame with sparse values from a sparse matrix.
New in version 0.25.0.
In [47]: from scipy.sparse import csr_matrix
In [48]: arr = np.random.random(size=(1000, 5))
In [49]: arr[arr < .9] = 0
In [50]: sp_arr = csr_matrix(arr)
In [51]: sp_arr
Out[51]:
<1000x5 sparse matrix of type '<class 'numpy.float64'>'
with 517 stored elements in Compressed Sparse Row format>
In [52]: sdf = pd.DataFrame.sparse.from_spmatrix(sp_arr)
In [53]: sdf.head()
Out[53]:
0 1 2 3 4
0 0.956380 0.0 0.0 0.000000 0.0
1 0.000000 0.0 0.0 0.000000 0.0
2 0.000000 0.0 0.0 0.000000 0.0
3 0.000000 0.0 0.0 0.000000 0.0
4 0.999552 0.0 0.0 0.956153 0.0
In [54]: sdf.dtypes
Out[54]:
0 Sparse[float64, 0]
1 Sparse[float64, 0]
2 Sparse[float64, 0]
3 Sparse[float64, 0]
4 Sparse[float64, 0]
dtype: object
All sparse formats are supported, but matrices that are not in COOrdinate format will be converted, copying data as needed.
To convert back to sparse SciPy matrix in COO format, you can use the DataFrame.sparse.to_coo() method:
In [55]: sdf.sparse.to_coo()
Out[55]:
<1000x5 sparse matrix of type '<class 'numpy.float64'>'
with 517 stored elements in COOrdinate format>
Series.sparse.to_coo() is implemented for transforming a Series with sparse values indexed by a MultiIndex to a scipy.sparse.coo_matrix.
The method requires a MultiIndex with two or more levels.
In [56]: s = pd.Series([3.0, np.nan, 1.0, 3.0, np.nan, np.nan])
In [57]: s.index = pd.MultiIndex.from_tuples(
....: [
....: (1, 2, "a", 0),
....: (1, 2, "a", 1),
....: (1, 1, "b", 0),
....: (1, 1, "b", 1),
....: (2, 1, "b", 0),
....: (2, 1, "b", 1),
....: ],
....: names=["A", "B", "C", "D"],
....: )
....:
In [58]: ss = s.astype('Sparse')
In [59]: ss
Out[59]:
A B C D
1 2 a 0 3.0
1 NaN
1 b 0 1.0
1 3.0
2 1 b 0 NaN
1 NaN
dtype: Sparse[float64, nan]
In the example below, we transform the Series to a sparse representation of a 2-d array by specifying that the first and second MultiIndex levels define labels for the rows and the third and fourth levels define labels for the columns. We also specify that the column and row labels should be sorted in the final sparse representation.
In [60]: A, rows, columns = ss.sparse.to_coo(
....: row_levels=["A", "B"], column_levels=["C", "D"], sort_labels=True
....: )
....:
In [61]: A
Out[61]:
<3x4 sparse matrix of type '<class 'numpy.float64'>'
with 3 stored elements in COOrdinate format>
In [62]: A.todense()
Out[62]:
matrix([[0., 0., 1., 3.],
[3., 0., 0., 0.],
[0., 0., 0., 0.]])
In [63]: rows
Out[63]: [(1, 1), (1, 2), (2, 1)]
In [64]: columns
Out[64]: [('a', 0), ('a', 1), ('b', 0), ('b', 1)]
Specifying different row and column labels (and not sorting them) yields a different sparse matrix:
In [65]: A, rows, columns = ss.sparse.to_coo(
....: row_levels=["A", "B", "C"], column_levels=["D"], sort_labels=False
....: )
....:
In [66]: A
Out[66]:
<3x2 sparse matrix of type '<class 'numpy.float64'>'
with 3 stored elements in COOrdinate format>
In [67]: A.todense()
Out[67]:
matrix([[3., 0.],
[1., 3.],
[0., 0.]])
In [68]: rows
Out[68]: [(1, 2, 'a'), (1, 1, 'b'), (2, 1, 'b')]
In [69]: columns
Out[69]: [(0,), (1,)]
A convenience method Series.sparse.from_coo() is implemented for creating a Series with sparse values from a scipy.sparse.coo_matrix.
In [70]: from scipy import sparse
In [71]: A = sparse.coo_matrix(([3.0, 1.0, 2.0], ([1, 0, 0], [0, 2, 3])), shape=(3, 4))
In [72]: A
Out[72]:
<3x4 sparse matrix of type '<class 'numpy.float64'>'
with 3 stored elements in COOrdinate format>
In [73]: A.todense()
Out[73]:
matrix([[0., 0., 1., 2.],
[3., 0., 0., 0.],
[0., 0., 0., 0.]])
The default behaviour (with dense_index=False) simply returns a Series containing
only the non-null entries.
In [74]: ss = pd.Series.sparse.from_coo(A)
In [75]: ss
Out[75]:
0 2 1.0
3 2.0
1 0 3.0
dtype: Sparse[float64, nan]
Specifying dense_index=True will result in an index that is the Cartesian product of the
row and columns coordinates of the matrix. Note that this will consume a significant amount of memory
(relative to dense_index=False) if the sparse matrix is large (and sparse) enough.
In [76]: ss_dense = pd.Series.sparse.from_coo(A, dense_index=True)
In [77]: ss_dense
Out[77]:
0 0 NaN
1 NaN
2 1.0
3 2.0
1 0 3.0
1 NaN
2 NaN
3 NaN
2 0 NaN
1 NaN
2 NaN
3 NaN
dtype: Sparse[float64, nan]
|
user_guide/sparse.html
|
pandas.Series.cat.reorder_categories
|
`pandas.Series.cat.reorder_categories`
Reorder categories as specified in new_categories.
new_categories need to include all old categories and no new category
items.
|
Series.cat.reorder_categories(*args, **kwargs)[source]#
Reorder categories as specified in new_categories.
new_categories need to include all old categories and no new category
items.
Parameters
new_categoriesIndex-likeThe categories in new order.
orderedbool, optionalWhether or not the categorical is treated as a ordered categorical.
If not given, do not change the ordered information.
inplacebool, default FalseWhether or not to reorder the categories inplace or return a copy of
this categorical with reordered categories.
Deprecated since version 1.3.0.
Returns
catCategorical or NoneCategorical with removed categories or None if inplace=True.
Raises
ValueErrorIf the new categories do not contain all old category items or any
new ones
See also
rename_categoriesRename categories.
add_categoriesAdd new categories.
remove_categoriesRemove the specified categories.
remove_unused_categoriesRemove categories which are not used.
set_categoriesSet the categories to the specified ones.
|
reference/api/pandas.Series.cat.reorder_categories.html
|
pandas.io.formats.style.Styler.template_latex
|
pandas.io.formats.style.Styler.template_latex
|
Styler.template_latex = <Template 'latex.tpl'>#
|
reference/api/pandas.io.formats.style.Styler.template_latex.html
|
pandas.api.extensions.ExtensionDtype.empty
|
`pandas.api.extensions.ExtensionDtype.empty`
Construct an ExtensionArray of this dtype with the given shape.
Analogous to numpy.empty.
|
ExtensionDtype.empty(shape)[source]#
Construct an ExtensionArray of this dtype with the given shape.
Analogous to numpy.empty.
Parameters
shapeint or tuple[int]
Returns
ExtensionArray
|
reference/api/pandas.api.extensions.ExtensionDtype.empty.html
|
pandas.DataFrame.shape
|
`pandas.DataFrame.shape`
Return a tuple representing the dimensionality of the DataFrame.
```
>>> df = pd.DataFrame({'col1': [1, 2], 'col2': [3, 4]})
>>> df.shape
(2, 2)
```
|
property DataFrame.shape[source]#
Return a tuple representing the dimensionality of the DataFrame.
See also
ndarray.shapeTuple of array dimensions.
Examples
>>> df = pd.DataFrame({'col1': [1, 2], 'col2': [3, 4]})
>>> df.shape
(2, 2)
>>> df = pd.DataFrame({'col1': [1, 2], 'col2': [3, 4],
... 'col3': [5, 6]})
>>> df.shape
(2, 3)
|
reference/api/pandas.DataFrame.shape.html
|
pandas.PeriodIndex.qyear
|
pandas.PeriodIndex.qyear
|
property PeriodIndex.qyear[source]#
|
reference/api/pandas.PeriodIndex.qyear.html
|
pandas.Series.str.extract
|
`pandas.Series.str.extract`
Extract capture groups in the regex pat as columns in a DataFrame.
```
>>> s = pd.Series(['a1', 'b2', 'c3'])
>>> s.str.extract(r'([ab])(\d)')
0 1
0 a 1
1 b 2
2 NaN NaN
```
|
Series.str.extract(pat, flags=0, expand=True)[source]#
Extract capture groups in the regex pat as columns in a DataFrame.
For each subject string in the Series, extract groups from the
first match of regular expression pat.
Parameters
patstrRegular expression pattern with capturing groups.
flagsint, default 0 (no flags)Flags from the re module, e.g. re.IGNORECASE, that
modify regular expression matching for things like case,
spaces, etc. For more details, see re.
expandbool, default TrueIf True, return DataFrame with one column per capture group.
If False, return a Series/Index if there is one capture group
or DataFrame if there are multiple capture groups.
Returns
DataFrame or Series or IndexA DataFrame with one row for each subject string, and one
column for each group. Any capture group names in regular
expression pat will be used for column names; otherwise
capture group numbers will be used. The dtype of each result
column is always object, even when no match is found. If
expand=False and pat has only one capture group, then
return a Series (if subject is a Series) or Index (if subject
is an Index).
See also
extractallReturns all matches (not just the first match).
Examples
A pattern with two groups will return a DataFrame with two columns.
Non-matches will be NaN.
>>> s = pd.Series(['a1', 'b2', 'c3'])
>>> s.str.extract(r'([ab])(\d)')
0 1
0 a 1
1 b 2
2 NaN NaN
A pattern may contain optional groups.
>>> s.str.extract(r'([ab])?(\d)')
0 1
0 a 1
1 b 2
2 NaN 3
Named groups will become column names in the result.
>>> s.str.extract(r'(?P<letter>[ab])(?P<digit>\d)')
letter digit
0 a 1
1 b 2
2 NaN NaN
A pattern with one group will return a DataFrame with one column
if expand=True.
>>> s.str.extract(r'[ab](\d)', expand=True)
0
0 1
1 2
2 NaN
A pattern with one group will return a Series if expand=False.
>>> s.str.extract(r'[ab](\d)', expand=False)
0 1
1 2
2 NaN
dtype: object
|
reference/api/pandas.Series.str.extract.html
|
pandas.tseries.offsets.BusinessMonthEnd.n
|
pandas.tseries.offsets.BusinessMonthEnd.n
|
BusinessMonthEnd.n#
|
reference/api/pandas.tseries.offsets.BusinessMonthEnd.n.html
|
pandas.core.window.rolling.Rolling.min
|
`pandas.core.window.rolling.Rolling.min`
Calculate the rolling minimum.
Include only float, int, boolean columns.
```
>>> s = pd.Series([4, 3, 5, 2, 6])
>>> s.rolling(3).min()
0 NaN
1 NaN
2 3.0
3 2.0
4 2.0
dtype: float64
```
|
Rolling.min(numeric_only=False, *args, engine=None, engine_kwargs=None, **kwargs)[source]#
Calculate the rolling minimum.
Parameters
numeric_onlybool, default FalseInclude only float, int, boolean columns.
New in version 1.5.0.
*argsFor NumPy compatibility and will not have an effect on the result.
Deprecated since version 1.5.0.
enginestr, default None
'cython' : Runs the operation through C-extensions from cython.
'numba' : Runs the operation through JIT compiled code from numba.
None : Defaults to 'cython' or globally setting compute.use_numba
New in version 1.3.0.
engine_kwargsdict, default None
For 'cython' engine, there are no accepted engine_kwargs
For 'numba' engine, the engine can accept nopython, nogil
and parallel dictionary keys. The values must either be True or
False. The default engine_kwargs for the 'numba' engine is
{'nopython': True, 'nogil': False, 'parallel': False}
New in version 1.3.0.
**kwargsFor NumPy compatibility and will not have an effect on the result.
Deprecated since version 1.5.0.
Returns
Series or DataFrameReturn type is the same as the original object with np.float64 dtype.
See also
pandas.Series.rollingCalling rolling with Series data.
pandas.DataFrame.rollingCalling rolling with DataFrames.
pandas.Series.minAggregating min for Series.
pandas.DataFrame.minAggregating min for DataFrame.
Notes
See Numba engine and Numba (JIT compilation) for extended documentation and performance considerations for the Numba engine.
Examples
Performing a rolling minimum with a window size of 3.
>>> s = pd.Series([4, 3, 5, 2, 6])
>>> s.rolling(3).min()
0 NaN
1 NaN
2 3.0
3 2.0
4 2.0
dtype: float64
|
reference/api/pandas.core.window.rolling.Rolling.min.html
|
pandas.Interval
|
`pandas.Interval`
Immutable object implementing an Interval, a bounded slice-like interval.
```
>>> iv = pd.Interval(left=0, right=5)
>>> iv
Interval(0, 5, closed='right')
```
|
class pandas.Interval#
Immutable object implementing an Interval, a bounded slice-like interval.
Parameters
leftorderable scalarLeft bound for the interval.
rightorderable scalarRight bound for the interval.
closed{‘right’, ‘left’, ‘both’, ‘neither’}, default ‘right’Whether the interval is closed on the left-side, right-side, both or
neither. See the Notes for more detailed explanation.
See also
IntervalIndexAn Index of Interval objects that are all closed on the same side.
cutConvert continuous data into discrete bins (Categorical of Interval objects).
qcutConvert continuous data into bins (Categorical of Interval objects) based on quantiles.
PeriodRepresents a period of time.
Notes
The parameters left and right must be from the same type, you must be
able to compare them and they must satisfy left <= right.
A closed interval (in mathematics denoted by square brackets) contains
its endpoints, i.e. the closed interval [0, 5] is characterized by the
conditions 0 <= x <= 5. This is what closed='both' stands for.
An open interval (in mathematics denoted by parentheses) does not contain
its endpoints, i.e. the open interval (0, 5) is characterized by the
conditions 0 < x < 5. This is what closed='neither' stands for.
Intervals can also be half-open or half-closed, i.e. [0, 5) is
described by 0 <= x < 5 (closed='left') and (0, 5] is
described by 0 < x <= 5 (closed='right').
Examples
It is possible to build Intervals of different types, like numeric ones:
>>> iv = pd.Interval(left=0, right=5)
>>> iv
Interval(0, 5, closed='right')
You can check if an element belongs to it, or if it contains another interval:
>>> 2.5 in iv
True
>>> pd.Interval(left=2, right=5, closed='both') in iv
True
You can test the bounds (closed='right', so 0 < x <= 5):
>>> 0 in iv
False
>>> 5 in iv
True
>>> 0.0001 in iv
True
Calculate its length
>>> iv.length
5
You can operate with + and * over an Interval and the operation
is applied to each of its bounds, so the result depends on the type
of the bound elements
>>> shifted_iv = iv + 3
>>> shifted_iv
Interval(3, 8, closed='right')
>>> extended_iv = iv * 10.0
>>> extended_iv
Interval(0.0, 50.0, closed='right')
To create a time interval you can use Timestamps as the bounds
>>> year_2017 = pd.Interval(pd.Timestamp('2017-01-01 00:00:00'),
... pd.Timestamp('2018-01-01 00:00:00'),
... closed='left')
>>> pd.Timestamp('2017-01-01 00:00') in year_2017
True
>>> year_2017.length
Timedelta('365 days 00:00:00')
Attributes
closed
String describing the inclusive side the intervals.
closed_left
Check if the interval is closed on the left side.
closed_right
Check if the interval is closed on the right side.
is_empty
Indicates if an interval is empty, meaning it contains no points.
left
Left bound for the interval.
length
Return the length of the Interval.
mid
Return the midpoint of the Interval.
open_left
Check if the interval is open on the left side.
open_right
Check if the interval is open on the right side.
right
Right bound for the interval.
Methods
overlaps
Check whether two Interval objects overlap.
|
reference/api/pandas.Interval.html
|
pandas.tseries.offsets.QuarterEnd.is_quarter_end
|
`pandas.tseries.offsets.QuarterEnd.is_quarter_end`
Return boolean whether a timestamp occurs on the quarter end.
Examples
```
>>> ts = pd.Timestamp(2022, 1, 1)
>>> freq = pd.offsets.Hour(5)
>>> freq.is_quarter_end(ts)
False
```
|
QuarterEnd.is_quarter_end()#
Return boolean whether a timestamp occurs on the quarter end.
Examples
>>> ts = pd.Timestamp(2022, 1, 1)
>>> freq = pd.offsets.Hour(5)
>>> freq.is_quarter_end(ts)
False
|
reference/api/pandas.tseries.offsets.QuarterEnd.is_quarter_end.html
|
pandas.tseries.offsets.MonthBegin.rule_code
|
pandas.tseries.offsets.MonthBegin.rule_code
|
MonthBegin.rule_code#
|
reference/api/pandas.tseries.offsets.MonthBegin.rule_code.html
|
pandas.DataFrame.tz_convert
|
`pandas.DataFrame.tz_convert`
Convert tz-aware axis to target time zone.
|
DataFrame.tz_convert(tz, axis=0, level=None, copy=True)[source]#
Convert tz-aware axis to target time zone.
Parameters
tzstr or tzinfo object
axisthe axis to convert
levelint, str, default NoneIf axis is a MultiIndex, convert a specific level. Otherwise
must be None.
copybool, default TrueAlso make a copy of the underlying data.
Returns
Series/DataFrameObject with time zone converted axis.
Raises
TypeErrorIf the axis is tz-naive.
|
reference/api/pandas.DataFrame.tz_convert.html
|
pandas.core.resample.Resampler.ohlc
|
`pandas.core.resample.Resampler.ohlc`
Compute open, high, low and close values of a group, excluding missing values.
|
Resampler.ohlc(*args, **kwargs)[source]#
Compute open, high, low and close values of a group, excluding missing values.
For multiple groupings, the result index will be a MultiIndex
Returns
DataFrameOpen, high, low and close values within each group.
See also
Series.groupbyApply a function groupby to a Series.
DataFrame.groupbyApply a function groupby to each row or column of a DataFrame.
|
reference/api/pandas.core.resample.Resampler.ohlc.html
|
pandas.Series.head
|
`pandas.Series.head`
Return the first n rows.
```
>>> df = pd.DataFrame({'animal': ['alligator', 'bee', 'falcon', 'lion',
... 'monkey', 'parrot', 'shark', 'whale', 'zebra']})
>>> df
animal
0 alligator
1 bee
2 falcon
3 lion
4 monkey
5 parrot
6 shark
7 whale
8 zebra
```
|
Series.head(n=5)[source]#
Return the first n rows.
This function returns the first n rows for the object based
on position. It is useful for quickly testing if your object
has the right type of data in it.
For negative values of n, this function returns all rows except
the last |n| rows, equivalent to df[:n].
If n is larger than the number of rows, this function returns all rows.
Parameters
nint, default 5Number of rows to select.
Returns
same type as callerThe first n rows of the caller object.
See also
DataFrame.tailReturns the last n rows.
Examples
>>> df = pd.DataFrame({'animal': ['alligator', 'bee', 'falcon', 'lion',
... 'monkey', 'parrot', 'shark', 'whale', 'zebra']})
>>> df
animal
0 alligator
1 bee
2 falcon
3 lion
4 monkey
5 parrot
6 shark
7 whale
8 zebra
Viewing the first 5 lines
>>> df.head()
animal
0 alligator
1 bee
2 falcon
3 lion
4 monkey
Viewing the first n lines (three in this case)
>>> df.head(3)
animal
0 alligator
1 bee
2 falcon
For negative values of n
>>> df.head(-3)
animal
0 alligator
1 bee
2 falcon
3 lion
4 monkey
5 parrot
|
reference/api/pandas.Series.head.html
|
pandas.tseries.offsets.BQuarterBegin
|
`pandas.tseries.offsets.BQuarterBegin`
DateOffset increments between the first business day of each Quarter.
startingMonth = 1 corresponds to dates like 1/01/2007, 4/01/2007, …
startingMonth = 2 corresponds to dates like 2/01/2007, 5/01/2007, …
startingMonth = 3 corresponds to dates like 3/01/2007, 6/01/2007, …
```
>>> from pandas.tseries.offsets import BQuarterBegin
>>> ts = pd.Timestamp('2020-05-24 05:01:15')
>>> ts + BQuarterBegin()
Timestamp('2020-06-01 05:01:15')
>>> ts + BQuarterBegin(2)
Timestamp('2020-09-01 05:01:15')
>>> ts + BQuarterBegin(startingMonth=2)
Timestamp('2020-08-03 05:01:15')
>>> ts + BQuarterBegin(-1)
Timestamp('2020-03-02 05:01:15')
```
|
class pandas.tseries.offsets.BQuarterBegin#
DateOffset increments between the first business day of each Quarter.
startingMonth = 1 corresponds to dates like 1/01/2007, 4/01/2007, …
startingMonth = 2 corresponds to dates like 2/01/2007, 5/01/2007, …
startingMonth = 3 corresponds to dates like 3/01/2007, 6/01/2007, …
Examples
>>> from pandas.tseries.offsets import BQuarterBegin
>>> ts = pd.Timestamp('2020-05-24 05:01:15')
>>> ts + BQuarterBegin()
Timestamp('2020-06-01 05:01:15')
>>> ts + BQuarterBegin(2)
Timestamp('2020-09-01 05:01:15')
>>> ts + BQuarterBegin(startingMonth=2)
Timestamp('2020-08-03 05:01:15')
>>> ts + BQuarterBegin(-1)
Timestamp('2020-03-02 05:01:15')
Attributes
base
Returns a copy of the calling offset object with n=1 and all other attributes equal.
freqstr
Return a string representing the frequency.
kwds
Return a dict of extra parameters for the offset.
name
Return a string representing the base frequency.
n
nanos
normalize
rule_code
startingMonth
Methods
__call__(*args, **kwargs)
Call self as a function.
apply_index
(DEPRECATED) Vectorized apply of DateOffset to DatetimeIndex.
copy
Return a copy of the frequency.
is_anchored
Return boolean whether the frequency is a unit frequency (n=1).
is_month_end
Return boolean whether a timestamp occurs on the month end.
is_month_start
Return boolean whether a timestamp occurs on the month start.
is_on_offset
Return boolean whether a timestamp intersects with this frequency.
is_quarter_end
Return boolean whether a timestamp occurs on the quarter end.
is_quarter_start
Return boolean whether a timestamp occurs on the quarter start.
is_year_end
Return boolean whether a timestamp occurs on the year end.
is_year_start
Return boolean whether a timestamp occurs on the year start.
rollback
Roll provided date backward to next offset only if not on offset.
rollforward
Roll provided date forward to next offset only if not on offset.
apply
isAnchored
onOffset
|
reference/api/pandas.tseries.offsets.BQuarterBegin.html
|
pandas.tseries.offsets.SemiMonthEnd.is_quarter_end
|
`pandas.tseries.offsets.SemiMonthEnd.is_quarter_end`
Return boolean whether a timestamp occurs on the quarter end.
Examples
```
>>> ts = pd.Timestamp(2022, 1, 1)
>>> freq = pd.offsets.Hour(5)
>>> freq.is_quarter_end(ts)
False
```
|
SemiMonthEnd.is_quarter_end()#
Return boolean whether a timestamp occurs on the quarter end.
Examples
>>> ts = pd.Timestamp(2022, 1, 1)
>>> freq = pd.offsets.Hour(5)
>>> freq.is_quarter_end(ts)
False
|
reference/api/pandas.tseries.offsets.SemiMonthEnd.is_quarter_end.html
|
pandas.Series.str.rsplit
|
`pandas.Series.str.rsplit`
Split strings around given separator/delimiter.
Splits the string in the Series/Index from the end,
at the specified delimiter string.
```
>>> s = pd.Series(
... [
... "this is a regular sentence",
... "https://docs.python.org/3/tutorial/index.html",
... np.nan
... ]
... )
>>> s
0 this is a regular sentence
1 https://docs.python.org/3/tutorial/index.html
2 NaN
dtype: object
```
|
Series.str.rsplit(pat=None, *, n=- 1, expand=False)[source]#
Split strings around given separator/delimiter.
Splits the string in the Series/Index from the end,
at the specified delimiter string.
Parameters
patstr, optionalString to split on.
If not specified, split on whitespace.
nint, default -1 (all)Limit number of splits in output.
None, 0 and -1 will be interpreted as return all splits.
expandbool, default FalseExpand the split strings into separate columns.
If True, return DataFrame/MultiIndex expanding dimensionality.
If False, return Series/Index, containing lists of strings.
Returns
Series, Index, DataFrame or MultiIndexType matches caller unless expand=True (see Notes).
See also
Series.str.splitSplit strings around given separator/delimiter.
Series.str.rsplitSplits string around given separator/delimiter, starting from the right.
Series.str.joinJoin lists contained as elements in the Series/Index with passed delimiter.
str.splitStandard library version for split.
str.rsplitStandard library version for rsplit.
Notes
The handling of the n keyword depends on the number of found splits:
If found splits > n, make first n splits only
If found splits <= n, make all splits
If for a certain row the number of found splits < n,
append None for padding up to n if expand=True
If using expand=True, Series and Index callers return DataFrame and
MultiIndex objects, respectively.
Examples
>>> s = pd.Series(
... [
... "this is a regular sentence",
... "https://docs.python.org/3/tutorial/index.html",
... np.nan
... ]
... )
>>> s
0 this is a regular sentence
1 https://docs.python.org/3/tutorial/index.html
2 NaN
dtype: object
In the default setting, the string is split by whitespace.
>>> s.str.split()
0 [this, is, a, regular, sentence]
1 [https://docs.python.org/3/tutorial/index.html]
2 NaN
dtype: object
Without the n parameter, the outputs of rsplit and split
are identical.
>>> s.str.rsplit()
0 [this, is, a, regular, sentence]
1 [https://docs.python.org/3/tutorial/index.html]
2 NaN
dtype: object
The n parameter can be used to limit the number of splits on the
delimiter. The outputs of split and rsplit are different.
>>> s.str.split(n=2)
0 [this, is, a regular sentence]
1 [https://docs.python.org/3/tutorial/index.html]
2 NaN
dtype: object
>>> s.str.rsplit(n=2)
0 [this is a, regular, sentence]
1 [https://docs.python.org/3/tutorial/index.html]
2 NaN
dtype: object
The pat parameter can be used to split by other characters.
>>> s.str.split(pat="/")
0 [this is a regular sentence]
1 [https:, , docs.python.org, 3, tutorial, index...
2 NaN
dtype: object
When using expand=True, the split elements will expand out into
separate columns. If NaN is present, it is propagated throughout
the columns during the split.
>>> s.str.split(expand=True)
0 1 2 3 4
0 this is a regular sentence
1 https://docs.python.org/3/tutorial/index.html None None None None
2 NaN NaN NaN NaN NaN
For slightly more complex use cases like splitting the html document name
from a url, a combination of parameter settings can be used.
>>> s.str.rsplit("/", n=1, expand=True)
0 1
0 this is a regular sentence None
1 https://docs.python.org/3/tutorial index.html
2 NaN NaN
|
reference/api/pandas.Series.str.rsplit.html
|
pandas.tseries.offsets.YearBegin.apply_index
|
`pandas.tseries.offsets.YearBegin.apply_index`
Vectorized apply of DateOffset to DatetimeIndex.
|
YearBegin.apply_index()#
Vectorized apply of DateOffset to DatetimeIndex.
Deprecated since version 1.1.0: Use offset + dtindex instead.
Parameters
indexDatetimeIndex
Returns
DatetimeIndex
Raises
NotImplementedErrorWhen the specific offset subclass does not have a vectorized
implementation.
|
reference/api/pandas.tseries.offsets.YearBegin.apply_index.html
|
pandas.testing.assert_index_equal
|
`pandas.testing.assert_index_equal`
Check that left and right Index are equal.
```
>>> from pandas import testing as tm
>>> a = pd.Index([1, 2, 3])
>>> b = pd.Index([1, 2, 3])
>>> tm.assert_index_equal(a, b)
```
|
pandas.testing.assert_index_equal(left, right, exact='equiv', check_names=True, check_less_precise=_NoDefault.no_default, check_exact=True, check_categorical=True, check_order=True, rtol=1e-05, atol=1e-08, obj='Index')[source]#
Check that left and right Index are equal.
Parameters
leftIndex
rightIndex
exactbool or {‘equiv’}, default ‘equiv’Whether to check the Index class, dtype and inferred_type
are identical. If ‘equiv’, then RangeIndex can be substituted for
Int64Index as well.
check_namesbool, default TrueWhether to check the names attribute.
check_less_precisebool or int, default FalseSpecify comparison precision. Only used when check_exact is False.
5 digits (False) or 3 digits (True) after decimal points are compared.
If int, then specify the digits to compare.
Deprecated since version 1.1.0: Use rtol and atol instead to define relative/absolute
tolerance, respectively. Similar to math.isclose().
check_exactbool, default TrueWhether to compare number exactly.
check_categoricalbool, default TrueWhether to compare internal Categorical exactly.
check_orderbool, default TrueWhether to compare the order of index entries as well as their values.
If True, both indexes must contain the same elements, in the same order.
If False, both indexes must contain the same elements, but in any order.
New in version 1.2.0.
rtolfloat, default 1e-5Relative tolerance. Only used when check_exact is False.
New in version 1.1.0.
atolfloat, default 1e-8Absolute tolerance. Only used when check_exact is False.
New in version 1.1.0.
objstr, default ‘Index’Specify object name being compared, internally used to show appropriate
assertion message.
Examples
>>> from pandas import testing as tm
>>> a = pd.Index([1, 2, 3])
>>> b = pd.Index([1, 2, 3])
>>> tm.assert_index_equal(a, b)
|
reference/api/pandas.testing.assert_index_equal.html
|
Input/output
|
Pickling#
read_pickle(filepath_or_buffer[, ...])
Load pickled pandas object (or any object) from file.
DataFrame.to_pickle(path[, compression, ...])
Pickle (serialize) object to file.
Flat file#
read_table(filepath_or_buffer, *[, sep, ...])
Read general delimited file into DataFrame.
read_csv(filepath_or_buffer, *[, sep, ...])
Read a comma-separated values (csv) file into DataFrame.
DataFrame.to_csv([path_or_buf, sep, na_rep, ...])
Write object to a comma-separated values (csv) file.
read_fwf(filepath_or_buffer, *[, colspecs, ...])
Read a table of fixed-width formatted lines into DataFrame.
Clipboard#
read_clipboard([sep])
Read text from clipboard and pass to read_csv.
DataFrame.to_clipboard([excel, sep])
Copy object to the system clipboard.
Excel#
read_excel(io[, sheet_name, header, names, ...])
Read an Excel file into a pandas DataFrame.
DataFrame.to_excel(excel_writer[, ...])
Write object to an Excel sheet.
ExcelFile.parse([sheet_name, header, names, ...])
Parse specified sheet(s) into a DataFrame.
Styler.to_excel(excel_writer[, sheet_name, ...])
Write Styler to an Excel sheet.
ExcelWriter(path[, engine, date_format, ...])
Class for writing DataFrame objects into excel sheets.
JSON#
read_json(path_or_buf, *[, orient, typ, ...])
Convert a JSON string to pandas object.
json_normalize(data[, record_path, meta, ...])
Normalize semi-structured JSON data into a flat table.
DataFrame.to_json([path_or_buf, orient, ...])
Convert the object to a JSON string.
build_table_schema(data[, index, ...])
Create a Table schema from data.
HTML#
read_html(io, *[, match, flavor, header, ...])
Read HTML tables into a list of DataFrame objects.
DataFrame.to_html([buf, columns, col_space, ...])
Render a DataFrame as an HTML table.
Styler.to_html([buf, table_uuid, ...])
Write Styler to a file, buffer or string in HTML-CSS format.
XML#
read_xml(path_or_buffer, *[, xpath, ...])
Read XML document into a DataFrame object.
DataFrame.to_xml([path_or_buffer, index, ...])
Render a DataFrame to an XML document.
Latex#
DataFrame.to_latex([buf, columns, ...])
Render object to a LaTeX tabular, longtable, or nested table.
Styler.to_latex([buf, column_format, ...])
Write Styler to a file, buffer or string in LaTeX format.
HDFStore: PyTables (HDF5)#
read_hdf(path_or_buf[, key, mode, errors, ...])
Read from the store, close it if we opened it.
HDFStore.put(key, value[, format, index, ...])
Store object in HDFStore.
HDFStore.append(key, value[, format, axes, ...])
Append to Table in file.
HDFStore.get(key)
Retrieve pandas object stored in file.
HDFStore.select(key[, where, start, stop, ...])
Retrieve pandas object stored in file, optionally based on where criteria.
HDFStore.info()
Print detailed information on the store.
HDFStore.keys([include])
Return a list of keys corresponding to objects stored in HDFStore.
HDFStore.groups()
Return a list of all the top-level nodes.
HDFStore.walk([where])
Walk the pytables group hierarchy for pandas objects.
Warning
One can store a subclass of DataFrame or Series to HDF5,
but the type of the subclass is lost upon storing.
Feather#
read_feather(path[, columns, use_threads, ...])
Load a feather-format object from the file path.
DataFrame.to_feather(path, **kwargs)
Write a DataFrame to the binary Feather format.
Parquet#
read_parquet(path[, engine, columns, ...])
Load a parquet object from the file path, returning a DataFrame.
DataFrame.to_parquet([path, engine, ...])
Write a DataFrame to the binary parquet format.
ORC#
read_orc(path[, columns])
Load an ORC object from the file path, returning a DataFrame.
DataFrame.to_orc([path, engine, index, ...])
Write a DataFrame to the ORC format.
SAS#
read_sas(filepath_or_buffer, *[, format, ...])
Read SAS files stored as either XPORT or SAS7BDAT format files.
SPSS#
read_spss(path[, usecols, convert_categoricals])
Load an SPSS file from the file path, returning a DataFrame.
SQL#
read_sql_table(table_name, con[, schema, ...])
Read SQL database table into a DataFrame.
read_sql_query(sql, con[, index_col, ...])
Read SQL query into a DataFrame.
read_sql(sql, con[, index_col, ...])
Read SQL query or database table into a DataFrame.
DataFrame.to_sql(name, con[, schema, ...])
Write records stored in a DataFrame to a SQL database.
Google BigQuery#
read_gbq(query[, project_id, index_col, ...])
Load data from Google BigQuery.
STATA#
read_stata(filepath_or_buffer, *[, ...])
Read Stata file into DataFrame.
DataFrame.to_stata(path, *[, convert_dates, ...])
Export DataFrame object to Stata dta format.
StataReader.data_label
Return data label of Stata file.
StataReader.value_labels()
Return a nested dict associating each variable name to its value and label.
StataReader.variable_labels()
Return a dict associating each variable name with corresponding label.
StataWriter.write_file()
Export DataFrame object to Stata dta format.
|
reference/io.html
| null |
Series
|
Constructor#
Series([data, index, dtype, name, copy, ...])
One-dimensional ndarray with axis labels (including time series).
Attributes#
Axes
Series.index
The index (axis labels) of the Series.
Series.array
The ExtensionArray of the data backing this Series or Index.
Series.values
Return Series as ndarray or ndarray-like depending on the dtype.
Series.dtype
Return the dtype object of the underlying data.
Series.shape
Return a tuple of the shape of the underlying data.
Series.nbytes
Return the number of bytes in the underlying data.
Series.ndim
Number of dimensions of the underlying data, by definition 1.
Series.size
Return the number of elements in the underlying data.
Series.T
Return the transpose, which is by definition self.
Series.memory_usage([index, deep])
Return the memory usage of the Series.
Series.hasnans
Return True if there are any NaNs.
Series.empty
Indicator whether Series/DataFrame is empty.
Series.dtypes
Return the dtype object of the underlying data.
Series.name
Return the name of the Series.
Series.flags
Get the properties associated with this pandas object.
Series.set_flags(*[, copy, ...])
Return a new object with updated flags.
Conversion#
Series.astype(dtype[, copy, errors])
Cast a pandas object to a specified dtype dtype.
Series.convert_dtypes([infer_objects, ...])
Convert columns to best possible dtypes using dtypes supporting pd.NA.
Series.infer_objects()
Attempt to infer better dtypes for object columns.
Series.copy([deep])
Make a copy of this object's indices and data.
Series.bool()
Return the bool of a single element Series or DataFrame.
Series.to_numpy([dtype, copy, na_value])
A NumPy ndarray representing the values in this Series or Index.
Series.to_period([freq, copy])
Convert Series from DatetimeIndex to PeriodIndex.
Series.to_timestamp([freq, how, copy])
Cast to DatetimeIndex of Timestamps, at beginning of period.
Series.to_list()
Return a list of the values.
Series.__array__([dtype])
Return the values as a NumPy array.
Indexing, iteration#
Series.get(key[, default])
Get item from object for given key (ex: DataFrame column).
Series.at
Access a single value for a row/column label pair.
Series.iat
Access a single value for a row/column pair by integer position.
Series.loc
Access a group of rows and columns by label(s) or a boolean array.
Series.iloc
Purely integer-location based indexing for selection by position.
Series.__iter__()
Return an iterator of the values.
Series.items()
Lazily iterate over (index, value) tuples.
Series.iteritems()
(DEPRECATED) Lazily iterate over (index, value) tuples.
Series.keys()
Return alias for index.
Series.pop(item)
Return item and drops from series.
Series.item()
Return the first element of the underlying data as a Python scalar.
Series.xs(key[, axis, level, drop_level])
Return cross-section from the Series/DataFrame.
For more information on .at, .iat, .loc, and
.iloc, see the indexing documentation.
Binary operator functions#
Series.add(other[, level, fill_value, axis])
Return Addition of series and other, element-wise (binary operator add).
Series.sub(other[, level, fill_value, axis])
Return Subtraction of series and other, element-wise (binary operator sub).
Series.mul(other[, level, fill_value, axis])
Return Multiplication of series and other, element-wise (binary operator mul).
Series.div(other[, level, fill_value, axis])
Return Floating division of series and other, element-wise (binary operator truediv).
Series.truediv(other[, level, fill_value, axis])
Return Floating division of series and other, element-wise (binary operator truediv).
Series.floordiv(other[, level, fill_value, axis])
Return Integer division of series and other, element-wise (binary operator floordiv).
Series.mod(other[, level, fill_value, axis])
Return Modulo of series and other, element-wise (binary operator mod).
Series.pow(other[, level, fill_value, axis])
Return Exponential power of series and other, element-wise (binary operator pow).
Series.radd(other[, level, fill_value, axis])
Return Addition of series and other, element-wise (binary operator radd).
Series.rsub(other[, level, fill_value, axis])
Return Subtraction of series and other, element-wise (binary operator rsub).
Series.rmul(other[, level, fill_value, axis])
Return Multiplication of series and other, element-wise (binary operator rmul).
Series.rdiv(other[, level, fill_value, axis])
Return Floating division of series and other, element-wise (binary operator rtruediv).
Series.rtruediv(other[, level, fill_value, axis])
Return Floating division of series and other, element-wise (binary operator rtruediv).
Series.rfloordiv(other[, level, fill_value, ...])
Return Integer division of series and other, element-wise (binary operator rfloordiv).
Series.rmod(other[, level, fill_value, axis])
Return Modulo of series and other, element-wise (binary operator rmod).
Series.rpow(other[, level, fill_value, axis])
Return Exponential power of series and other, element-wise (binary operator rpow).
Series.combine(other, func[, fill_value])
Combine the Series with a Series or scalar according to func.
Series.combine_first(other)
Update null elements with value in the same location in 'other'.
Series.round([decimals])
Round each value in a Series to the given number of decimals.
Series.lt(other[, level, fill_value, axis])
Return Less than of series and other, element-wise (binary operator lt).
Series.gt(other[, level, fill_value, axis])
Return Greater than of series and other, element-wise (binary operator gt).
Series.le(other[, level, fill_value, axis])
Return Less than or equal to of series and other, element-wise (binary operator le).
Series.ge(other[, level, fill_value, axis])
Return Greater than or equal to of series and other, element-wise (binary operator ge).
Series.ne(other[, level, fill_value, axis])
Return Not equal to of series and other, element-wise (binary operator ne).
Series.eq(other[, level, fill_value, axis])
Return Equal to of series and other, element-wise (binary operator eq).
Series.product([axis, skipna, level, ...])
Return the product of the values over the requested axis.
Series.dot(other)
Compute the dot product between the Series and the columns of other.
Function application, GroupBy & window#
Series.apply(func[, convert_dtype, args])
Invoke function on values of Series.
Series.agg([func, axis])
Aggregate using one or more operations over the specified axis.
Series.aggregate([func, axis])
Aggregate using one or more operations over the specified axis.
Series.transform(func[, axis])
Call func on self producing a Series with the same axis shape as self.
Series.map(arg[, na_action])
Map values of Series according to an input mapping or function.
Series.groupby([by, axis, level, as_index, ...])
Group Series using a mapper or by a Series of columns.
Series.rolling(window[, min_periods, ...])
Provide rolling window calculations.
Series.expanding([min_periods, center, ...])
Provide expanding window calculations.
Series.ewm([com, span, halflife, alpha, ...])
Provide exponentially weighted (EW) calculations.
Series.pipe(func, *args, **kwargs)
Apply chainable functions that expect Series or DataFrames.
Computations / descriptive stats#
Series.abs()
Return a Series/DataFrame with absolute numeric value of each element.
Series.all([axis, bool_only, skipna, level])
Return whether all elements are True, potentially over an axis.
Series.any(*[, axis, bool_only, skipna, level])
Return whether any element is True, potentially over an axis.
Series.autocorr([lag])
Compute the lag-N autocorrelation.
Series.between(left, right[, inclusive])
Return boolean Series equivalent to left <= series <= right.
Series.clip([lower, upper, axis, inplace])
Trim values at input threshold(s).
Series.corr(other[, method, min_periods])
Compute correlation with other Series, excluding missing values.
Series.count([level])
Return number of non-NA/null observations in the Series.
Series.cov(other[, min_periods, ddof])
Compute covariance with Series, excluding missing values.
Series.cummax([axis, skipna])
Return cumulative maximum over a DataFrame or Series axis.
Series.cummin([axis, skipna])
Return cumulative minimum over a DataFrame or Series axis.
Series.cumprod([axis, skipna])
Return cumulative product over a DataFrame or Series axis.
Series.cumsum([axis, skipna])
Return cumulative sum over a DataFrame or Series axis.
Series.describe([percentiles, include, ...])
Generate descriptive statistics.
Series.diff([periods])
First discrete difference of element.
Series.factorize([sort, na_sentinel, ...])
Encode the object as an enumerated type or categorical variable.
Series.kurt([axis, skipna, level, numeric_only])
Return unbiased kurtosis over requested axis.
Series.mad([axis, skipna, level])
(DEPRECATED) Return the mean absolute deviation of the values over the requested axis.
Series.max([axis, skipna, level, numeric_only])
Return the maximum of the values over the requested axis.
Series.mean([axis, skipna, level, numeric_only])
Return the mean of the values over the requested axis.
Series.median([axis, skipna, level, ...])
Return the median of the values over the requested axis.
Series.min([axis, skipna, level, numeric_only])
Return the minimum of the values over the requested axis.
Series.mode([dropna])
Return the mode(s) of the Series.
Series.nlargest([n, keep])
Return the largest n elements.
Series.nsmallest([n, keep])
Return the smallest n elements.
Series.pct_change([periods, fill_method, ...])
Percentage change between the current and a prior element.
Series.prod([axis, skipna, level, ...])
Return the product of the values over the requested axis.
Series.quantile([q, interpolation])
Return value at the given quantile.
Series.rank([axis, method, numeric_only, ...])
Compute numerical data ranks (1 through n) along axis.
Series.sem([axis, skipna, level, ddof, ...])
Return unbiased standard error of the mean over requested axis.
Series.skew([axis, skipna, level, numeric_only])
Return unbiased skew over requested axis.
Series.std([axis, skipna, level, ddof, ...])
Return sample standard deviation over requested axis.
Series.sum([axis, skipna, level, ...])
Return the sum of the values over the requested axis.
Series.var([axis, skipna, level, ddof, ...])
Return unbiased variance over requested axis.
Series.kurtosis([axis, skipna, level, ...])
Return unbiased kurtosis over requested axis.
Series.unique()
Return unique values of Series object.
Series.nunique([dropna])
Return number of unique elements in the object.
Series.is_unique
Return boolean if values in the object are unique.
Series.is_monotonic
(DEPRECATED) Return boolean if values in the object are monotonically increasing.
Series.is_monotonic_increasing
Return boolean if values in the object are monotonically increasing.
Series.is_monotonic_decreasing
Return boolean if values in the object are monotonically decreasing.
Series.value_counts([normalize, sort, ...])
Return a Series containing counts of unique values.
Reindexing / selection / label manipulation#
Series.align(other[, join, axis, level, ...])
Align two objects on their axes with the specified join method.
Series.drop([labels, axis, index, columns, ...])
Return Series with specified index labels removed.
Series.droplevel(level[, axis])
Return Series/DataFrame with requested index / column level(s) removed.
Series.drop_duplicates(*[, keep, inplace])
Return Series with duplicate values removed.
Series.duplicated([keep])
Indicate duplicate Series values.
Series.equals(other)
Test whether two objects contain the same elements.
Series.first(offset)
Select initial periods of time series data based on a date offset.
Series.head([n])
Return the first n rows.
Series.idxmax([axis, skipna])
Return the row label of the maximum value.
Series.idxmin([axis, skipna])
Return the row label of the minimum value.
Series.isin(values)
Whether elements in Series are contained in values.
Series.last(offset)
Select final periods of time series data based on a date offset.
Series.reindex(*args, **kwargs)
Conform Series to new index with optional filling logic.
Series.reindex_like(other[, method, copy, ...])
Return an object with matching indices as other object.
Series.rename([index, axis, copy, inplace, ...])
Alter Series index labels or name.
Series.rename_axis([mapper, inplace])
Set the name of the axis for the index or columns.
Series.reset_index([level, drop, name, ...])
Generate a new DataFrame or Series with the index reset.
Series.sample([n, frac, replace, weights, ...])
Return a random sample of items from an axis of object.
Series.set_axis(labels, *[, axis, inplace, copy])
Assign desired index to given axis.
Series.take(indices[, axis, is_copy])
Return the elements in the given positional indices along an axis.
Series.tail([n])
Return the last n rows.
Series.truncate([before, after, axis, copy])
Truncate a Series or DataFrame before and after some index value.
Series.where(cond[, other, inplace, axis, ...])
Replace values where the condition is False.
Series.mask(cond[, other, inplace, axis, ...])
Replace values where the condition is True.
Series.add_prefix(prefix)
Prefix labels with string prefix.
Series.add_suffix(suffix)
Suffix labels with string suffix.
Series.filter([items, like, regex, axis])
Subset the dataframe rows or columns according to the specified index labels.
Missing data handling#
Series.backfill(*[, axis, inplace, limit, ...])
Synonym for DataFrame.fillna() with method='bfill'.
Series.bfill(*[, axis, inplace, limit, downcast])
Synonym for DataFrame.fillna() with method='bfill'.
Series.dropna(*[, axis, inplace, how])
Return a new Series with missing values removed.
Series.ffill(*[, axis, inplace, limit, downcast])
Synonym for DataFrame.fillna() with method='ffill'.
Series.fillna([value, method, axis, ...])
Fill NA/NaN values using the specified method.
Series.interpolate([method, axis, limit, ...])
Fill NaN values using an interpolation method.
Series.isna()
Detect missing values.
Series.isnull()
Series.isnull is an alias for Series.isna.
Series.notna()
Detect existing (non-missing) values.
Series.notnull()
Series.notnull is an alias for Series.notna.
Series.pad(*[, axis, inplace, limit, downcast])
Synonym for DataFrame.fillna() with method='ffill'.
Series.replace([to_replace, value, inplace, ...])
Replace values given in to_replace with value.
Reshaping, sorting#
Series.argsort([axis, kind, order])
Return the integer indices that would sort the Series values.
Series.argmin([axis, skipna])
Return int position of the smallest value in the Series.
Series.argmax([axis, skipna])
Return int position of the largest value in the Series.
Series.reorder_levels(order)
Rearrange index levels using input order.
Series.sort_values(*[, axis, ascending, ...])
Sort by the values.
Series.sort_index(*[, axis, level, ...])
Sort Series by index labels.
Series.swaplevel([i, j, copy])
Swap levels i and j in a MultiIndex.
Series.unstack([level, fill_value])
Unstack, also known as pivot, Series with MultiIndex to produce DataFrame.
Series.explode([ignore_index])
Transform each element of a list-like to a row.
Series.searchsorted(value[, side, sorter])
Find indices where elements should be inserted to maintain order.
Series.ravel([order])
Return the flattened underlying data as an ndarray.
Series.repeat(repeats[, axis])
Repeat elements of a Series.
Series.squeeze([axis])
Squeeze 1 dimensional axis objects into scalars.
Series.view([dtype])
Create a new view of the Series.
Combining / comparing / joining / merging#
Series.append(to_append[, ignore_index, ...])
(DEPRECATED) Concatenate two or more Series.
Series.compare(other[, align_axis, ...])
Compare to another Series and show the differences.
Series.update(other)
Modify Series in place using values from passed Series.
Time Series-related#
Series.asfreq(freq[, method, how, ...])
Convert time series to specified frequency.
Series.asof(where[, subset])
Return the last row(s) without any NaNs before where.
Series.shift([periods, freq, axis, fill_value])
Shift index by desired number of periods with an optional time freq.
Series.first_valid_index()
Return index for first non-NA value or None, if no non-NA value is found.
Series.last_valid_index()
Return index for last non-NA value or None, if no non-NA value is found.
Series.resample(rule[, axis, closed, label, ...])
Resample time-series data.
Series.tz_convert(tz[, axis, level, copy])
Convert tz-aware axis to target time zone.
Series.tz_localize(tz[, axis, level, copy, ...])
Localize tz-naive index of a Series or DataFrame to target time zone.
Series.at_time(time[, asof, axis])
Select values at particular time of day (e.g., 9:30AM).
Series.between_time(start_time, end_time[, ...])
Select values between particular times of the day (e.g., 9:00-9:30 AM).
Series.tshift([periods, freq, axis])
(DEPRECATED) Shift the time index, using the index's frequency if available.
Series.slice_shift([periods, axis])
(DEPRECATED) Equivalent to shift without copying data.
Accessors#
pandas provides dtype-specific methods under various accessors.
These are separate namespaces within Series that only apply
to specific data types.
Data Type
Accessor
Datetime, Timedelta, Period
dt
String
str
Categorical
cat
Sparse
sparse
Datetimelike properties#
Series.dt can be used to access the values of the series as
datetimelike and return several properties.
These can be accessed like Series.dt.<property>.
Datetime properties#
Series.dt.date
Returns numpy array of python datetime.date objects.
Series.dt.time
Returns numpy array of datetime.time objects.
Series.dt.timetz
Returns numpy array of datetime.time objects with timezones.
Series.dt.year
The year of the datetime.
Series.dt.month
The month as January=1, December=12.
Series.dt.day
The day of the datetime.
Series.dt.hour
The hours of the datetime.
Series.dt.minute
The minutes of the datetime.
Series.dt.second
The seconds of the datetime.
Series.dt.microsecond
The microseconds of the datetime.
Series.dt.nanosecond
The nanoseconds of the datetime.
Series.dt.week
(DEPRECATED) The week ordinal of the year according to the ISO 8601 standard.
Series.dt.weekofyear
(DEPRECATED) The week ordinal of the year according to the ISO 8601 standard.
Series.dt.dayofweek
The day of the week with Monday=0, Sunday=6.
Series.dt.day_of_week
The day of the week with Monday=0, Sunday=6.
Series.dt.weekday
The day of the week with Monday=0, Sunday=6.
Series.dt.dayofyear
The ordinal day of the year.
Series.dt.day_of_year
The ordinal day of the year.
Series.dt.quarter
The quarter of the date.
Series.dt.is_month_start
Indicates whether the date is the first day of the month.
Series.dt.is_month_end
Indicates whether the date is the last day of the month.
Series.dt.is_quarter_start
Indicator for whether the date is the first day of a quarter.
Series.dt.is_quarter_end
Indicator for whether the date is the last day of a quarter.
Series.dt.is_year_start
Indicate whether the date is the first day of a year.
Series.dt.is_year_end
Indicate whether the date is the last day of the year.
Series.dt.is_leap_year
Boolean indicator if the date belongs to a leap year.
Series.dt.daysinmonth
The number of days in the month.
Series.dt.days_in_month
The number of days in the month.
Series.dt.tz
Return the timezone.
Series.dt.freq
Return the frequency object for this PeriodArray.
Datetime methods#
Series.dt.isocalendar()
Calculate year, week, and day according to the ISO 8601 standard.
Series.dt.to_period(*args, **kwargs)
Cast to PeriodArray/Index at a particular frequency.
Series.dt.to_pydatetime()
Return the data as an array of datetime.datetime objects.
Series.dt.tz_localize(*args, **kwargs)
Localize tz-naive Datetime Array/Index to tz-aware Datetime Array/Index.
Series.dt.tz_convert(*args, **kwargs)
Convert tz-aware Datetime Array/Index from one time zone to another.
Series.dt.normalize(*args, **kwargs)
Convert times to midnight.
Series.dt.strftime(*args, **kwargs)
Convert to Index using specified date_format.
Series.dt.round(*args, **kwargs)
Perform round operation on the data to the specified freq.
Series.dt.floor(*args, **kwargs)
Perform floor operation on the data to the specified freq.
Series.dt.ceil(*args, **kwargs)
Perform ceil operation on the data to the specified freq.
Series.dt.month_name(*args, **kwargs)
Return the month names with specified locale.
Series.dt.day_name(*args, **kwargs)
Return the day names with specified locale.
Period properties#
Series.dt.qyear
Series.dt.start_time
Get the Timestamp for the start of the period.
Series.dt.end_time
Get the Timestamp for the end of the period.
Timedelta properties#
Series.dt.days
Number of days for each element.
Series.dt.seconds
Number of seconds (>= 0 and less than 1 day) for each element.
Series.dt.microseconds
Number of microseconds (>= 0 and less than 1 second) for each element.
Series.dt.nanoseconds
Number of nanoseconds (>= 0 and less than 1 microsecond) for each element.
Series.dt.components
Return a Dataframe of the components of the Timedeltas.
Timedelta methods#
Series.dt.to_pytimedelta()
Return an array of native datetime.timedelta objects.
Series.dt.total_seconds(*args, **kwargs)
Return total duration of each element expressed in seconds.
String handling#
Series.str can be used to access the values of the series as
strings and apply several methods to it. These can be accessed like
Series.str.<function/property>.
Series.str.capitalize()
Convert strings in the Series/Index to be capitalized.
Series.str.casefold()
Convert strings in the Series/Index to be casefolded.
Series.str.cat([others, sep, na_rep, join])
Concatenate strings in the Series/Index with given separator.
Series.str.center(width[, fillchar])
Pad left and right side of strings in the Series/Index.
Series.str.contains(pat[, case, flags, na, ...])
Test if pattern or regex is contained within a string of a Series or Index.
Series.str.count(pat[, flags])
Count occurrences of pattern in each string of the Series/Index.
Series.str.decode(encoding[, errors])
Decode character string in the Series/Index using indicated encoding.
Series.str.encode(encoding[, errors])
Encode character string in the Series/Index using indicated encoding.
Series.str.endswith(pat[, na])
Test if the end of each string element matches a pattern.
Series.str.extract(pat[, flags, expand])
Extract capture groups in the regex pat as columns in a DataFrame.
Series.str.extractall(pat[, flags])
Extract capture groups in the regex pat as columns in DataFrame.
Series.str.find(sub[, start, end])
Return lowest indexes in each strings in the Series/Index.
Series.str.findall(pat[, flags])
Find all occurrences of pattern or regular expression in the Series/Index.
Series.str.fullmatch(pat[, case, flags, na])
Determine if each string entirely matches a regular expression.
Series.str.get(i)
Extract element from each component at specified position or with specified key.
Series.str.index(sub[, start, end])
Return lowest indexes in each string in Series/Index.
Series.str.join(sep)
Join lists contained as elements in the Series/Index with passed delimiter.
Series.str.len()
Compute the length of each element in the Series/Index.
Series.str.ljust(width[, fillchar])
Pad right side of strings in the Series/Index.
Series.str.lower()
Convert strings in the Series/Index to lowercase.
Series.str.lstrip([to_strip])
Remove leading characters.
Series.str.match(pat[, case, flags, na])
Determine if each string starts with a match of a regular expression.
Series.str.normalize(form)
Return the Unicode normal form for the strings in the Series/Index.
Series.str.pad(width[, side, fillchar])
Pad strings in the Series/Index up to width.
Series.str.partition([sep, expand])
Split the string at the first occurrence of sep.
Series.str.removeprefix(prefix)
Remove a prefix from an object series.
Series.str.removesuffix(suffix)
Remove a suffix from an object series.
Series.str.repeat(repeats)
Duplicate each string in the Series or Index.
Series.str.replace(pat, repl[, n, case, ...])
Replace each occurrence of pattern/regex in the Series/Index.
Series.str.rfind(sub[, start, end])
Return highest indexes in each strings in the Series/Index.
Series.str.rindex(sub[, start, end])
Return highest indexes in each string in Series/Index.
Series.str.rjust(width[, fillchar])
Pad left side of strings in the Series/Index.
Series.str.rpartition([sep, expand])
Split the string at the last occurrence of sep.
Series.str.rstrip([to_strip])
Remove trailing characters.
Series.str.slice([start, stop, step])
Slice substrings from each element in the Series or Index.
Series.str.slice_replace([start, stop, repl])
Replace a positional slice of a string with another value.
Series.str.split([pat, n, expand, regex])
Split strings around given separator/delimiter.
Series.str.rsplit([pat, n, expand])
Split strings around given separator/delimiter.
Series.str.startswith(pat[, na])
Test if the start of each string element matches a pattern.
Series.str.strip([to_strip])
Remove leading and trailing characters.
Series.str.swapcase()
Convert strings in the Series/Index to be swapcased.
Series.str.title()
Convert strings in the Series/Index to titlecase.
Series.str.translate(table)
Map all characters in the string through the given mapping table.
Series.str.upper()
Convert strings in the Series/Index to uppercase.
Series.str.wrap(width, **kwargs)
Wrap strings in Series/Index at specified line width.
Series.str.zfill(width)
Pad strings in the Series/Index by prepending '0' characters.
Series.str.isalnum()
Check whether all characters in each string are alphanumeric.
Series.str.isalpha()
Check whether all characters in each string are alphabetic.
Series.str.isdigit()
Check whether all characters in each string are digits.
Series.str.isspace()
Check whether all characters in each string are whitespace.
Series.str.islower()
Check whether all characters in each string are lowercase.
Series.str.isupper()
Check whether all characters in each string are uppercase.
Series.str.istitle()
Check whether all characters in each string are titlecase.
Series.str.isnumeric()
Check whether all characters in each string are numeric.
Series.str.isdecimal()
Check whether all characters in each string are decimal.
Series.str.get_dummies([sep])
Return DataFrame of dummy/indicator variables for Series.
Categorical accessor#
Categorical-dtype specific methods and attributes are available under
the Series.cat accessor.
Series.cat.categories
The categories of this categorical.
Series.cat.ordered
Whether the categories have an ordered relationship.
Series.cat.codes
Return Series of codes as well as the index.
Series.cat.rename_categories(*args, **kwargs)
Rename categories.
Series.cat.reorder_categories(*args, **kwargs)
Reorder categories as specified in new_categories.
Series.cat.add_categories(*args, **kwargs)
Add new categories.
Series.cat.remove_categories(*args, **kwargs)
Remove the specified categories.
Series.cat.remove_unused_categories(*args, ...)
Remove categories which are not used.
Series.cat.set_categories(*args, **kwargs)
Set the categories to the specified new_categories.
Series.cat.as_ordered(*args, **kwargs)
Set the Categorical to be ordered.
Series.cat.as_unordered(*args, **kwargs)
Set the Categorical to be unordered.
Sparse accessor#
Sparse-dtype specific methods and attributes are provided under the
Series.sparse accessor.
Series.sparse.npoints
The number of non- fill_value points.
Series.sparse.density
The percent of non- fill_value points, as decimal.
Series.sparse.fill_value
Elements in data that are fill_value are not stored.
Series.sparse.sp_values
An ndarray containing the non- fill_value values.
Series.sparse.from_coo(A[, dense_index])
Create a Series with sparse values from a scipy.sparse.coo_matrix.
Series.sparse.to_coo([row_levels, ...])
Create a scipy.sparse.coo_matrix from a Series with MultiIndex.
Flags#
Flags refer to attributes of the pandas object. Properties of the dataset (like
the date is was recorded, the URL it was accessed from, etc.) should be stored
in Series.attrs.
Flags(obj, *, allows_duplicate_labels)
Flags that apply to pandas objects.
Metadata#
Series.attrs is a dictionary for storing global metadata for this Series.
Warning
Series.attrs is considered experimental and may change without warning.
Series.attrs
Dictionary of global attributes of this dataset.
Plotting#
Series.plot is both a callable method and a namespace attribute for
specific plotting methods of the form Series.plot.<kind>.
Series.plot([kind, ax, figsize, ....])
Series plotting accessor and method
Series.plot.area([x, y])
Draw a stacked area plot.
Series.plot.bar([x, y])
Vertical bar plot.
Series.plot.barh([x, y])
Make a horizontal bar plot.
Series.plot.box([by])
Make a box plot of the DataFrame columns.
Series.plot.density([bw_method, ind])
Generate Kernel Density Estimate plot using Gaussian kernels.
Series.plot.hist([by, bins])
Draw one histogram of the DataFrame's columns.
Series.plot.kde([bw_method, ind])
Generate Kernel Density Estimate plot using Gaussian kernels.
Series.plot.line([x, y])
Plot Series or DataFrame as lines.
Series.plot.pie(**kwargs)
Generate a pie plot.
Series.hist([by, ax, grid, xlabelsize, ...])
Draw histogram of the input series using matplotlib.
Serialization / IO / conversion#
Series.to_pickle(path[, compression, ...])
Pickle (serialize) object to file.
Series.to_csv([path_or_buf, sep, na_rep, ...])
Write object to a comma-separated values (csv) file.
Series.to_dict([into])
Convert Series to {label -> value} dict or dict-like object.
Series.to_excel(excel_writer[, sheet_name, ...])
Write object to an Excel sheet.
Series.to_frame([name])
Convert Series to DataFrame.
Series.to_xarray()
Return an xarray object from the pandas object.
Series.to_hdf(path_or_buf, key[, mode, ...])
Write the contained data to an HDF5 file using HDFStore.
Series.to_sql(name, con[, schema, ...])
Write records stored in a DataFrame to a SQL database.
Series.to_json([path_or_buf, orient, ...])
Convert the object to a JSON string.
Series.to_string([buf, na_rep, ...])
Render a string representation of the Series.
Series.to_clipboard([excel, sep])
Copy object to the system clipboard.
Series.to_latex([buf, columns, col_space, ...])
Render object to a LaTeX tabular, longtable, or nested table.
Series.to_markdown([buf, mode, index, ...])
Print Series in Markdown-friendly format.
|
reference/series.html
| null |
pandas.tseries.offsets.BusinessMonthEnd.kwds
|
`pandas.tseries.offsets.BusinessMonthEnd.kwds`
Return a dict of extra parameters for the offset.
```
>>> pd.DateOffset(5).kwds
{}
```
|
BusinessMonthEnd.kwds#
Return a dict of extra parameters for the offset.
Examples
>>> pd.DateOffset(5).kwds
{}
>>> pd.offsets.FY5253Quarter().kwds
{'weekday': 0,
'startingMonth': 1,
'qtr_with_extra_week': 1,
'variation': 'nearest'}
|
reference/api/pandas.tseries.offsets.BusinessMonthEnd.kwds.html
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.