pandas.Timedelta.round   Timedelta.round(freq)

Round the Timedelta to the specified resolution.  Parameters

freq:str

Frequency string indicating the rounding resolution.    Returns
 a new Timedelta rounded to the given resolution of freq

  Raises
 ValueError if the freq cannot be converted


pandas.Timedelta.seconds   Timedelta.seconds

Number of seconds (>= 0 and less than 1 day).


pandas.Timedelta.to_numpy   Timedelta.to_numpy()

Convert the Timedelta to a NumPy timedelta64.  New in version 0.25.0.  This is an alias method for Timedelta.to_timedelta64(). The dtype and copy parameters are available here only for compatibility. Their values will not affect the return value.  Returns
 numpy.timedelta64
    See also  Series.to_numpy

Similar method for Series.


pandas.Timedelta.to_pytimedelta   Timedelta.to_pytimedelta()

Convert a pandas Timedelta object into a python datetime.timedelta object. Timedelta objects are internally saved as numpy datetime64[ns] dtype. Use to_pytimedelta() to convert to object dtype.  Returns
 datetime.timedelta or numpy.array of datetime.timedelta
    See also  to_timedelta

Convert argument to Timedelta type.    Notes Any nanosecond resolution will be lost.


pandas.Timedelta.to_timedelta64   Timedelta.to_timedelta64()

Return a numpy.timedelta64 object with ‘ns’ precision.


pandas.Timedelta.total_seconds   Timedelta.total_seconds()

Total seconds in the duration.


pandas.Timedelta.value   Timedelta.value


pandas.Timedelta.view   Timedelta.view()

Array view compatibility.


pandas.timedelta_range   pandas.timedelta_range(start=None, end=None, periods=None, freq=None, name=None, closed=None)[source]

Return a fixed frequency TimedeltaIndex, with day as the default frequency.  Parameters

start:str or timedelta-like, default None

Left bound for generating timedeltas.
end:str or timedelta-like, default None

Right bound for generating timedeltas.
periods:int, default None

Number of periods to generate.
freq:str or DateOffset, default ‘D’

Frequency strings can have multiples, e.g. ‘5H’.
name:str, default None

Name of the resulting TimedeltaIndex.
closed:str, default None

Make the interval closed with respect to the given frequency to the ‘left’, ‘right’, or both sides (None).    Returns
 TimedeltaIndex
   Notes Of the four parameters start, end, periods, and freq, exactly three must be specified. If freq is omitted, the resulting TimedeltaIndex will have periods linearly spaced elements between start and end (closed on both sides). To learn more about the frequency strings, please see this link. Examples
>>> pd.timedelta_range(start='1 day', periods=4)
TimedeltaIndex(['1 days', '2 days', '3 days', '4 days'],
               dtype='timedelta64[ns]', freq='D')
  The closed parameter specifies which endpoint is included. The default behavior is to include both endpoints.
>>> pd.timedelta_range(start='1 day', periods=4, closed='right')
TimedeltaIndex(['2 days', '3 days', '4 days'],
               dtype='timedelta64[ns]', freq='D')
  The freq parameter specifies the frequency of the TimedeltaIndex. Only fixed frequencies can be passed, non-fixed frequencies such as ‘M’ (month end) will raise.
>>> pd.timedelta_range(start='1 day', end='2 days', freq='6H')
TimedeltaIndex(['1 days 00:00:00', '1 days 06:00:00', '1 days 12:00:00',
                '1 days 18:00:00', '2 days 00:00:00'],
               dtype='timedelta64[ns]', freq='6H')
  Specify start, end, and periods; the frequency is generated automatically (linearly spaced).
>>> pd.timedelta_range(start='1 day', end='5 days', periods=4)
TimedeltaIndex(['1 days 00:00:00', '2 days 08:00:00', '3 days 16:00:00',
                '5 days 00:00:00'],
               dtype='timedelta64[ns]', freq=None)


pandas.TimedeltaIndex   classpandas.TimedeltaIndex(data=None, unit=None, freq=NoDefault.no_default, closed=None, dtype=dtype('<m8[ns]'), copy=False, name=None)[source]

Immutable ndarray of timedelta64 data, represented internally as int64, and which can be boxed to timedelta objects.  Parameters

data:array-like (1-dimensional), optional

Optional timedelta-like data to construct index with.
unit:unit of the arg (D,h,m,s,ms,us,ns) denote the unit, optional

Which is an integer/float number.
freq:str or pandas offset object, optional

One of pandas date offset strings or corresponding objects. The string ‘infer’ can be passed in order to set the frequency of the index as the inferred frequency upon creation.
copy:bool

Make a copy of input ndarray.
name:object

Name to be stored in the index.      See also  Index

The base pandas Index type.  Timedelta

Represents a duration between two dates or times.  DatetimeIndex

Index of datetime64 data.  PeriodIndex

Index of Period data.  timedelta_range

Create a fixed-frequency TimedeltaIndex.    Notes To learn more about the frequency strings, please see this link. Attributes
days Number of days for each element.
seconds Number of seconds (>= 0 and less than 1 day) for each element.
microseconds Number of microseconds (>= 0 and less than 1 second) for each element.
nanoseconds Number of nanoseconds (>= 0 and less than 1 microsecond) for each element.
components Return a dataframe of the components (days, hours, minutes, seconds, milliseconds, microseconds, nanoseconds) of the Timedeltas.
inferred_freq Tries to return a string representing a frequency guess, generated by infer_freq.    Methods
to_pytimedelta(*args, **kwargs) Return Timedelta Array/Index as object ndarray of datetime.timedelta objects.
to_series([index, name]) Create a Series with both index and values equal to the index keys.
round(*args, **kwargs) Perform round operation on the data to the specified freq.
floor(*args, **kwargs) Perform floor operation on the data to the specified freq.
ceil(*args, **kwargs) Perform ceil operation on the data to the specified freq.
to_frame([index, name]) Create a DataFrame with a column containing the Index.
mean(*args, **kwargs) Return the mean value of the Array.


pandas.TimedeltaIndex.ceil   TimedeltaIndex.ceil(*args, **kwargs)[source]

Perform ceil operation on the data to the specified freq.  Parameters

freq:str or Offset

The frequency level to ceil the index to. Must be a fixed frequency like ‘S’ (second) not ‘ME’ (month end). See frequency aliases for a list of possible freq values.
ambiguous:‘infer’, bool-ndarray, ‘NaT’, default ‘raise’

Only relevant for DatetimeIndex:  ‘infer’ will attempt to infer fall dst-transition hours based on order bool-ndarray where True signifies a DST time, False designates a non-DST time (note that this flag is only applicable for ambiguous times) ‘NaT’ will return NaT where there are ambiguous times ‘raise’ will raise an AmbiguousTimeError if there are ambiguous times.
nonexistent:‘shift_forward’, ‘shift_backward’, ‘NaT’, timedelta, default ‘raise’

A nonexistent time does not exist in a particular timezone where clocks moved forward due to DST.  ‘shift_forward’ will shift the nonexistent time forward to the closest existing time ‘shift_backward’ will shift the nonexistent time backward to the closest existing time ‘NaT’ will return NaT where there are nonexistent times timedelta objects will shift nonexistent times by the timedelta ‘raise’ will raise an NonExistentTimeError if there are nonexistent times.     Returns
 DatetimeIndex, TimedeltaIndex, or Series

Index of the same type for a DatetimeIndex or TimedeltaIndex, or a Series with the same index for a Series.    Raises
 ValueError if the freq cannot be converted.
   Notes If the timestamps have a timezone, ceiling will take place relative to the local (“wall”) time and re-localized to the same timezone. When ceiling near daylight savings time, use nonexistent and ambiguous to control the re-localization behavior. Examples DatetimeIndex
>>> rng = pd.date_range('1/1/2018 11:59:00', periods=3, freq='min')
>>> rng
DatetimeIndex(['2018-01-01 11:59:00', '2018-01-01 12:00:00',
               '2018-01-01 12:01:00'],
              dtype='datetime64[ns]', freq='T')
>>> rng.ceil('H')
DatetimeIndex(['2018-01-01 12:00:00', '2018-01-01 12:00:00',
               '2018-01-01 13:00:00'],
              dtype='datetime64[ns]', freq=None)
  Series
>>> pd.Series(rng).dt.ceil("H")
0   2018-01-01 12:00:00
1   2018-01-01 12:00:00
2   2018-01-01 13:00:00
dtype: datetime64[ns]
  When rounding near a daylight savings time transition, use ambiguous or nonexistent to control how the timestamp should be re-localized.
>>> rng_tz = pd.DatetimeIndex(["2021-10-31 01:30:00"], tz="Europe/Amsterdam")

>>> rng_tz.ceil("H", ambiguous=False)
DatetimeIndex(['2021-10-31 02:00:00+01:00'],
              dtype='datetime64[ns, Europe/Amsterdam]', freq=None)

>>> rng_tz.ceil("H", ambiguous=True)
DatetimeIndex(['2021-10-31 02:00:00+02:00'],
              dtype='datetime64[ns, Europe/Amsterdam]', freq=None)


pandas.TimedeltaIndex.components   propertyTimedeltaIndex.components

Return a dataframe of the components (days, hours, minutes, seconds, milliseconds, microseconds, nanoseconds) of the Timedeltas.  Returns
 DataFrame


pandas.TimedeltaIndex.days   propertyTimedeltaIndex.days

Number of days for each element.


pandas.TimedeltaIndex.floor   TimedeltaIndex.floor(*args, **kwargs)[source]

Perform floor operation on the data to the specified freq.  Parameters

freq:str or Offset

The frequency level to floor the index to. Must be a fixed frequency like ‘S’ (second) not ‘ME’ (month end). See frequency aliases for a list of possible freq values.
ambiguous:‘infer’, bool-ndarray, ‘NaT’, default ‘raise’

Only relevant for DatetimeIndex:  ‘infer’ will attempt to infer fall dst-transition hours based on order bool-ndarray where True signifies a DST time, False designates a non-DST time (note that this flag is only applicable for ambiguous times) ‘NaT’ will return NaT where there are ambiguous times ‘raise’ will raise an AmbiguousTimeError if there are ambiguous times.
nonexistent:‘shift_forward’, ‘shift_backward’, ‘NaT’, timedelta, default ‘raise’

A nonexistent time does not exist in a particular timezone where clocks moved forward due to DST.  ‘shift_forward’ will shift the nonexistent time forward to the closest existing time ‘shift_backward’ will shift the nonexistent time backward to the closest existing time ‘NaT’ will return NaT where there are nonexistent times timedelta objects will shift nonexistent times by the timedelta ‘raise’ will raise an NonExistentTimeError if there are nonexistent times.     Returns
 DatetimeIndex, TimedeltaIndex, or Series

Index of the same type for a DatetimeIndex or TimedeltaIndex, or a Series with the same index for a Series.    Raises
 ValueError if the freq cannot be converted.
   Notes If the timestamps have a timezone, flooring will take place relative to the local (“wall”) time and re-localized to the same timezone. When flooring near daylight savings time, use nonexistent and ambiguous to control the re-localization behavior. Examples DatetimeIndex
>>> rng = pd.date_range('1/1/2018 11:59:00', periods=3, freq='min')
>>> rng
DatetimeIndex(['2018-01-01 11:59:00', '2018-01-01 12:00:00',
               '2018-01-01 12:01:00'],
              dtype='datetime64[ns]', freq='T')
>>> rng.floor('H')
DatetimeIndex(['2018-01-01 11:00:00', '2018-01-01 12:00:00',
               '2018-01-01 12:00:00'],
              dtype='datetime64[ns]', freq=None)
  Series
>>> pd.Series(rng).dt.floor("H")
0   2018-01-01 11:00:00
1   2018-01-01 12:00:00
2   2018-01-01 12:00:00
dtype: datetime64[ns]
  When rounding near a daylight savings time transition, use ambiguous or nonexistent to control how the timestamp should be re-localized.
>>> rng_tz = pd.DatetimeIndex(["2021-10-31 03:30:00"], tz="Europe/Amsterdam")

>>> rng_tz.floor("2H", ambiguous=False)
DatetimeIndex(['2021-10-31 02:00:00+01:00'],
             dtype='datetime64[ns, Europe/Amsterdam]', freq=None)

>>> rng_tz.floor("2H", ambiguous=True)
DatetimeIndex(['2021-10-31 02:00:00+02:00'],
              dtype='datetime64[ns, Europe/Amsterdam]', freq=None)


pandas.TimedeltaIndex.inferred_freq   TimedeltaIndex.inferred_freq

Tries to return a string representing a frequency guess, generated by infer_freq. Returns None if it can’t autodetect the frequency.


pandas.TimedeltaIndex.mean   TimedeltaIndex.mean(*args, **kwargs)[source]

Return the mean value of the Array.  New in version 0.25.0.   Parameters

skipna:bool, default True

Whether to ignore any NaT elements.
axis:int, optional, default 0

  Returns
 scalar

Timestamp or Timedelta.      See also  numpy.ndarray.mean

Returns the average of array elements along a given axis.  Series.mean

Return the mean value in a Series.    Notes mean is only defined for Datetime and Timedelta dtypes, not for Period.


pandas.TimedeltaIndex.microseconds   propertyTimedeltaIndex.microseconds

Number of microseconds (>= 0 and less than 1 second) for each element.


pandas.TimedeltaIndex.nanoseconds   propertyTimedeltaIndex.nanoseconds

Number of nanoseconds (>= 0 and less than 1 microsecond) for each element.


pandas.TimedeltaIndex.round   TimedeltaIndex.round(*args, **kwargs)[source]

Perform round operation on the data to the specified freq.  Parameters

freq:str or Offset

The frequency level to round the index to. Must be a fixed frequency like ‘S’ (second) not ‘ME’ (month end). See frequency aliases for a list of possible freq values.
ambiguous:‘infer’, bool-ndarray, ‘NaT’, default ‘raise’

Only relevant for DatetimeIndex:  ‘infer’ will attempt to infer fall dst-transition hours based on order bool-ndarray where True signifies a DST time, False designates a non-DST time (note that this flag is only applicable for ambiguous times) ‘NaT’ will return NaT where there are ambiguous times ‘raise’ will raise an AmbiguousTimeError if there are ambiguous times.
nonexistent:‘shift_forward’, ‘shift_backward’, ‘NaT’, timedelta, default ‘raise’

A nonexistent time does not exist in a particular timezone where clocks moved forward due to DST.  ‘shift_forward’ will shift the nonexistent time forward to the closest existing time ‘shift_backward’ will shift the nonexistent time backward to the closest existing time ‘NaT’ will return NaT where there are nonexistent times timedelta objects will shift nonexistent times by the timedelta ‘raise’ will raise an NonExistentTimeError if there are nonexistent times.     Returns
 DatetimeIndex, TimedeltaIndex, or Series

Index of the same type for a DatetimeIndex or TimedeltaIndex, or a Series with the same index for a Series.    Raises
 ValueError if the freq cannot be converted.
   Notes If the timestamps have a timezone, rounding will take place relative to the local (“wall”) time and re-localized to the same timezone. When rounding near daylight savings time, use nonexistent and ambiguous to control the re-localization behavior. Examples DatetimeIndex
>>> rng = pd.date_range('1/1/2018 11:59:00', periods=3, freq='min')
>>> rng
DatetimeIndex(['2018-01-01 11:59:00', '2018-01-01 12:00:00',
               '2018-01-01 12:01:00'],
              dtype='datetime64[ns]', freq='T')
>>> rng.round('H')
DatetimeIndex(['2018-01-01 12:00:00', '2018-01-01 12:00:00',
               '2018-01-01 12:00:00'],
              dtype='datetime64[ns]', freq=None)
  Series
>>> pd.Series(rng).dt.round("H")
0   2018-01-01 12:00:00
1   2018-01-01 12:00:00
2   2018-01-01 12:00:00
dtype: datetime64[ns]
  When rounding near a daylight savings time transition, use ambiguous or nonexistent to control how the timestamp should be re-localized.
>>> rng_tz = pd.DatetimeIndex(["2021-10-31 03:30:00"], tz="Europe/Amsterdam")

>>> rng_tz.floor("2H", ambiguous=False)
DatetimeIndex(['2021-10-31 02:00:00+01:00'],
              dtype='datetime64[ns, Europe/Amsterdam]', freq=None)

>>> rng_tz.floor("2H", ambiguous=True)
DatetimeIndex(['2021-10-31 02:00:00+02:00'],
              dtype='datetime64[ns, Europe/Amsterdam]', freq=None)


pandas.TimedeltaIndex.seconds   propertyTimedeltaIndex.seconds

Number of seconds (>= 0 and less than 1 day) for each element.


pandas.TimedeltaIndex.to_frame   TimedeltaIndex.to_frame(index=True, name=NoDefault.no_default)[source]

Create a DataFrame with a column containing the Index.  Parameters

index:bool, default True

Set the index of the returned DataFrame as the original Index.
name:object, default None

The passed name should substitute for the index name (if it has one).    Returns
 DataFrame

DataFrame containing the original Index data.      See also  Index.to_series

Convert an Index to a Series.  Series.to_frame

Convert Series to DataFrame.    Examples
>>> idx = pd.Index(['Ant', 'Bear', 'Cow'], name='animal')
>>> idx.to_frame()
       animal
animal
Ant       Ant
Bear     Bear
Cow       Cow
  By default, the original Index is reused. To enforce a new Index:
>>> idx.to_frame(index=False)
    animal
0   Ant
1  Bear
2   Cow
  To override the name of the resulting column, specify name:
>>> idx.to_frame(index=False, name='zoo')
    zoo
0   Ant
1  Bear
2   Cow


pandas.TimedeltaIndex.to_pytimedelta   TimedeltaIndex.to_pytimedelta(*args, **kwargs)[source]

Return Timedelta Array/Index as object ndarray of datetime.timedelta objects.  Returns

timedeltas:ndarray[object]


pandas.TimedeltaIndex.to_series   TimedeltaIndex.to_series(index=None, name=None)[source]

Create a Series with both index and values equal to the index keys. Useful with map for returning an indexer based on an index.  Parameters

index:Index, optional

Index of resulting Series. If None, defaults to original index.
name:str, optional

Name of resulting Series. If None, defaults to name of original index.    Returns
 Series

The dtype will be based on the type of the Index values.      See also  Index.to_frame

Convert an Index to a DataFrame.  Series.to_frame

Convert Series to DataFrame.    Examples
>>> idx = pd.Index(['Ant', 'Bear', 'Cow'], name='animal')
  By default, the original Index and original name is reused.
>>> idx.to_series()
animal
Ant      Ant
Bear    Bear
Cow      Cow
Name: animal, dtype: object
  To enforce a new Index, specify new labels to index:
>>> idx.to_series(index=[0, 1, 2])
0     Ant
1    Bear
2     Cow
Name: animal, dtype: object
  To override the name of the resulting column, specify name:
>>> idx.to_series(name='zoo')
animal
Ant      Ant
Bear    Bear
Cow      Cow
Name: zoo, dtype: object


pandas.Timestamp   classpandas.Timestamp(ts_input=<object object>, freq=None, tz=None, unit=None, year=None, month=None, day=None, hour=None, minute=None, second=None, microsecond=None, nanosecond=None, tzinfo=None, *, fold=None)

Pandas replacement for python datetime.datetime object. Timestamp is the pandas equivalent of python’s Datetime and is interchangeable with it in most cases. It’s the type used for the entries that make up a DatetimeIndex, and other timeseries oriented data structures in pandas.  Parameters

ts_input:datetime-like, str, int, float

Value to be converted to Timestamp.
freq:str, DateOffset

Offset which Timestamp will have.
tz:str, pytz.timezone, dateutil.tz.tzfile or None

Time zone for time which Timestamp will have.
unit:str

Unit used for conversion if ts_input is of type int or float. The valid values are ‘D’, ‘h’, ‘m’, ‘s’, ‘ms’, ‘us’, and ‘ns’. For example, ‘s’ means seconds and ‘ms’ means milliseconds.
year, month, day:int

hour, minute, second, microsecond:int, optional, default 0

nanosecond:int, optional, default 0

tzinfo:datetime.tzinfo, optional, default None

fold:{0, 1}, default None, keyword-only

Due to daylight saving time, one wall clock time can occur twice when shifting from summer to winter time; fold describes whether the datetime-like corresponds to the first (0) or the second time (1) the wall clock hits the ambiguous time.  New in version 1.1.0.      Notes There are essentially three calling conventions for the constructor. The primary form accepts four parameters. They can be passed by position or keyword. The other two forms mimic the parameters from datetime.datetime. They can be passed by either position or keyword, but not both mixed together. Examples Using the primary calling convention: This converts a datetime-like string
>>> pd.Timestamp('2017-01-01T12')
Timestamp('2017-01-01 12:00:00')
  This converts a float representing a Unix epoch in units of seconds
>>> pd.Timestamp(1513393355.5, unit='s')
Timestamp('2017-12-16 03:02:35.500000')
  This converts an int representing a Unix-epoch in units of seconds and for a particular timezone
>>> pd.Timestamp(1513393355, unit='s', tz='US/Pacific')
Timestamp('2017-12-15 19:02:35-0800', tz='US/Pacific')
  Using the other two forms that mimic the API for datetime.datetime:
>>> pd.Timestamp(2017, 1, 1, 12)
Timestamp('2017-01-01 12:00:00')

>>> pd.Timestamp(year=2017, month=1, day=1, hour=12)
Timestamp('2017-01-01 12:00:00')
  Attributes
asm8 Return numpy datetime64 format in nanoseconds.
day_of_week Return day of the week.
day_of_year Return the day of the year.
dayofweek Return day of the week.
dayofyear Return the day of the year.
days_in_month Return the number of days in the month.
daysinmonth Return the number of days in the month.
freqstr Return the total number of days in the month.
is_leap_year Return True if year is a leap year.
is_month_end Return True if date is last day of month.
is_month_start Return True if date is first day of month.
is_quarter_end Return True if date is last day of the quarter.
is_quarter_start Return True if date is first day of the quarter.
is_year_end Return True if date is last day of the year.
is_year_start Return True if date is first day of the year.
quarter Return the quarter of the year.
tz Alias for tzinfo.
week Return the week number of the year.
weekofyear Return the week number of the year.
day
fold
freq
hour
microsecond
minute
month
nanosecond
second
tzinfo
value
year     Methods
astimezone(tz) Convert timezone-aware Timestamp to another time zone.
ceil(freq[, ambiguous, nonexistent]) Return a new Timestamp ceiled to this resolution.
combine(date, time) Combine date, time into datetime with same date and time fields.
ctime Return ctime() style string.
date Return date object with same year, month and day.
day_name Return the day name of the Timestamp with specified locale.
dst Return self.tzinfo.dst(self).
floor(freq[, ambiguous, nonexistent]) Return a new Timestamp floored to this resolution.
fromisocalendar int, int, int -> Construct a date from the ISO year, week number and weekday.
fromisoformat string -> datetime from datetime.isoformat() output
fromordinal(ordinal[, freq, tz]) Passed an ordinal, translate and convert to a ts.
fromtimestamp(ts) Transform timestamp[, tz] to tz's local time from POSIX timestamp.
isocalendar Return a 3-tuple containing ISO year, week number, and weekday.
isoformat Return the time formatted according to ISO 8610.
isoweekday() Return the day of the week represented by the date.
month_name Return the month name of the Timestamp with specified locale.
normalize Normalize Timestamp to midnight, preserving tz information.
now([tz]) Return new Timestamp object representing current time local to tz.
replace([year, month, day, hour, minute, ...]) Implements datetime.replace, handles nanoseconds.
round(freq[, ambiguous, nonexistent]) Round the Timestamp to the specified resolution.
strftime(format) Return a string representing the given POSIX timestamp controlled by an explicit format string.
strptime(string, format) Function is not implemented.
time Return time object with same time but with tzinfo=None.
timestamp Return POSIX timestamp as float.
timetuple Return time tuple, compatible with time.localtime().
timetz Return time object with same time and tzinfo.
to_datetime64 Return a numpy.datetime64 object with 'ns' precision.
to_julian_date() Convert TimeStamp to a Julian Date.
to_numpy Convert the Timestamp to a NumPy datetime64.
to_period Return an period of which this timestamp is an observation.
to_pydatetime Convert a Timestamp object to a native Python datetime object.
today(cls[, tz]) Return the current time in the local timezone.
toordinal Return proleptic Gregorian ordinal.
tz_convert(tz) Convert timezone-aware Timestamp to another time zone.
tz_localize(tz[, ambiguous, nonexistent]) Convert naive Timestamp to local time zone, or remove timezone from timezone-aware Timestamp.
tzname Return self.tzinfo.tzname(self).
utcfromtimestamp(ts) Construct a naive UTC datetime from a POSIX timestamp.
utcnow() Return a new Timestamp representing UTC day and time.
utcoffset Return self.tzinfo.utcoffset(self).
utctimetuple Return UTC time tuple, compatible with time.localtime().
weekday() Return the day of the week represented by the date.


pandas.Timestamp.asm8   Timestamp.asm8

Return numpy datetime64 format in nanoseconds. Examples
>>> ts = pd.Timestamp(2020, 3, 14, 15)
>>> ts.asm8
numpy.datetime64('2020-03-14T15:00:00.000000000')


pandas.Timestamp.astimezone   Timestamp.astimezone(tz)

Convert timezone-aware Timestamp to another time zone.  Parameters

tz:str, pytz.timezone, dateutil.tz.tzfile or None

Time zone for time which Timestamp will be converted to. None will remove timezone holding UTC time.    Returns

converted:Timestamp

  Raises
 TypeError

If Timestamp is tz-naive.     Examples Create a timestamp object with UTC timezone:
>>> ts = pd.Timestamp('2020-03-14T15:32:52.192548651', tz='UTC')
>>> ts
Timestamp('2020-03-14 15:32:52.192548651+0000', tz='UTC')
  Change to Tokyo timezone:
>>> ts.tz_convert(tz='Asia/Tokyo')
Timestamp('2020-03-15 00:32:52.192548651+0900', tz='Asia/Tokyo')
  Can also use astimezone:
>>> ts.astimezone(tz='Asia/Tokyo')
Timestamp('2020-03-15 00:32:52.192548651+0900', tz='Asia/Tokyo')
  Analogous for pd.NaT:
>>> pd.NaT.tz_convert(tz='Asia/Tokyo')
NaT


pandas.Timestamp.ceil   Timestamp.ceil(freq, ambiguous='raise', nonexistent='raise')

Return a new Timestamp ceiled to this resolution.  Parameters

freq:str

Frequency string indicating the ceiling resolution.
ambiguous:bool or {‘raise’, ‘NaT’}, default ‘raise’

The behavior is as follows:  bool contains flags to determine if time is dst or not (note that this flag is only applicable for ambiguous fall dst dates). ‘NaT’ will return NaT for an ambiguous time. ‘raise’ will raise an AmbiguousTimeError for an ambiguous time.
nonexistent:{‘raise’, ‘shift_forward’, ‘shift_backward, ‘NaT’, timedelta}, default ‘raise’

A nonexistent time does not exist in a particular timezone where clocks moved forward due to DST.  ‘shift_forward’ will shift the nonexistent time forward to the closest existing time. ‘shift_backward’ will shift the nonexistent time backward to the closest existing time. ‘NaT’ will return NaT where there are nonexistent times. timedelta objects will shift nonexistent times by the timedelta. ‘raise’ will raise an NonExistentTimeError if there are nonexistent times.     Raises
 ValueError if the freq cannot be converted.
   Notes If the Timestamp has a timezone, ceiling will take place relative to the local (“wall”) time and re-localized to the same timezone. When ceiling near daylight savings time, use nonexistent and ambiguous to control the re-localization behavior. Examples Create a timestamp object:
>>> ts = pd.Timestamp('2020-03-14T15:32:52.192548651')
  A timestamp can be ceiled using multiple frequency units:
>>> ts.ceil(freq='H') # hour
Timestamp('2020-03-14 16:00:00')

>>> ts.ceil(freq='T') # minute
Timestamp('2020-03-14 15:33:00')

>>> ts.ceil(freq='S') # seconds
Timestamp('2020-03-14 15:32:53')

>>> ts.ceil(freq='U') # microseconds
Timestamp('2020-03-14 15:32:52.192549')
  freq can also be a multiple of a single unit, like ‘5T’ (i.e. 5 minutes):
>>> ts.ceil(freq='5T')
Timestamp('2020-03-14 15:35:00')
  or a combination of multiple units, like ‘1H30T’ (i.e. 1 hour and 30 minutes):
>>> ts.ceil(freq='1H30T')
Timestamp('2020-03-14 16:30:00')
  Analogous for pd.NaT:
>>> pd.NaT.ceil()
NaT
  When rounding near a daylight savings time transition, use ambiguous or nonexistent to control how the timestamp should be re-localized.
>>> ts_tz = pd.Timestamp("2021-10-31 01:30:00").tz_localize("Europe/Amsterdam")

>>> ts_tz.ceil("H", ambiguous=False)
Timestamp('2021-10-31 02:00:00+0100', tz='Europe/Amsterdam')

>>> ts_tz.ceil("H", ambiguous=True)
Timestamp('2021-10-31 02:00:00+0200', tz='Europe/Amsterdam')


pandas.Timestamp.combine   classmethodTimestamp.combine(date, time)

Combine date, time into datetime with same date and time fields. Examples
>>> from datetime import date, time
>>> pd.Timestamp.combine(date(2020, 3, 14), time(15, 30, 15))
Timestamp('2020-03-14 15:30:15')


pandas.Timestamp.ctime   Timestamp.ctime()

Return ctime() style string.


pandas.Timestamp.date   Timestamp.date()

Return date object with same year, month and day.


pandas.Timestamp.day_name   Timestamp.day_name()

Return the day name of the Timestamp with specified locale.  Parameters

locale:str, default None (English locale)

Locale determining the language in which to return the day name.    Returns
 str
   Examples
>>> ts = pd.Timestamp('2020-03-14T15:32:52.192548651')
>>> ts.day_name()
'Saturday'
  Analogous for pd.NaT:
>>> pd.NaT.day_name()
nan


pandas.Timestamp.day_of_week   Timestamp.day_of_week

Return day of the week. Examples
>>> ts = pd.Timestamp(2020, 3, 14)
>>> ts.day_of_week
5


pandas.Timestamp.day_of_year   Timestamp.day_of_year

Return the day of the year. Examples
>>> ts = pd.Timestamp(2020, 3, 14)
>>> ts.day_of_year
74


pandas.Timestamp.dayofweek   Timestamp.dayofweek

Return day of the week. Examples
>>> ts = pd.Timestamp(2020, 3, 14)
>>> ts.day_of_week
5


pandas.Timestamp.dayofyear   Timestamp.dayofyear

Return the day of the year. Examples
>>> ts = pd.Timestamp(2020, 3, 14)
>>> ts.day_of_year
74


pandas.Timestamp.days_in_month   Timestamp.days_in_month

Return the number of days in the month. Examples
>>> ts = pd.Timestamp(2020, 3, 14)
>>> ts.days_in_month
31


pandas.Timestamp.daysinmonth   Timestamp.daysinmonth

Return the number of days in the month. Examples
>>> ts = pd.Timestamp(2020, 3, 14)
>>> ts.days_in_month
31


pandas.Timestamp.dst   Timestamp.dst()

Return self.tzinfo.dst(self).


pandas.Timestamp.floor   Timestamp.floor(freq, ambiguous='raise', nonexistent='raise')

Return a new Timestamp floored to this resolution.  Parameters

freq:str

Frequency string indicating the flooring resolution.
ambiguous:bool or {‘raise’, ‘NaT’}, default ‘raise’

The behavior is as follows:  bool contains flags to determine if time is dst or not (note that this flag is only applicable for ambiguous fall dst dates). ‘NaT’ will return NaT for an ambiguous time. ‘raise’ will raise an AmbiguousTimeError for an ambiguous time.
nonexistent:{‘raise’, ‘shift_forward’, ‘shift_backward, ‘NaT’, timedelta}, default ‘raise’

A nonexistent time does not exist in a particular timezone where clocks moved forward due to DST.  ‘shift_forward’ will shift the nonexistent time forward to the closest existing time. ‘shift_backward’ will shift the nonexistent time backward to the closest existing time. ‘NaT’ will return NaT where there are nonexistent times. timedelta objects will shift nonexistent times by the timedelta. ‘raise’ will raise an NonExistentTimeError if there are nonexistent times.     Raises
 ValueError if the freq cannot be converted.
   Notes If the Timestamp has a timezone, flooring will take place relative to the local (“wall”) time and re-localized to the same timezone. When flooring near daylight savings time, use nonexistent and ambiguous to control the re-localization behavior. Examples Create a timestamp object:
>>> ts = pd.Timestamp('2020-03-14T15:32:52.192548651')
  A timestamp can be floored using multiple frequency units:
>>> ts.floor(freq='H') # hour
Timestamp('2020-03-14 15:00:00')

>>> ts.floor(freq='T') # minute
Timestamp('2020-03-14 15:32:00')

>>> ts.floor(freq='S') # seconds
Timestamp('2020-03-14 15:32:52')

>>> ts.floor(freq='N') # nanoseconds
Timestamp('2020-03-14 15:32:52.192548651')
  freq can also be a multiple of a single unit, like ‘5T’ (i.e. 5 minutes):
>>> ts.floor(freq='5T')
Timestamp('2020-03-14 15:30:00')
  or a combination of multiple units, like ‘1H30T’ (i.e. 1 hour and 30 minutes):
>>> ts.floor(freq='1H30T')
Timestamp('2020-03-14 15:00:00')
  Analogous for pd.NaT:
>>> pd.NaT.floor()
NaT
  When rounding near a daylight savings time transition, use ambiguous or nonexistent to control how the timestamp should be re-localized.
>>> ts_tz = pd.Timestamp("2021-10-31 03:30:00").tz_localize("Europe/Amsterdam")

>>> ts_tz.floor("2H", ambiguous=False)
Timestamp('2021-10-31 02:00:00+0100', tz='Europe/Amsterdam')

>>> ts_tz.floor("2H", ambiguous=True)
Timestamp('2021-10-31 02:00:00+0200', tz='Europe/Amsterdam')


pandas.Timestamp.freqstr   propertyTimestamp.freqstr

Return the total number of days in the month.


pandas.Timestamp.fromisocalendar   Timestamp.fromisocalendar()

int, int, int -> Construct a date from the ISO year, week number and weekday. This is the inverse of the date.isocalendar() function


pandas.Timestamp.fromisoformat   Timestamp.fromisoformat()

string -> datetime from datetime.isoformat() output


pandas.Timestamp.fromordinal   classmethodTimestamp.fromordinal(ordinal, freq=None, tz=None)

Passed an ordinal, translate and convert to a ts. Note: by definition there cannot be any tz info on the ordinal itself.  Parameters

ordinal:int

Date corresponding to a proleptic Gregorian ordinal.
freq:str, DateOffset

Offset to apply to the Timestamp.
tz:str, pytz.timezone, dateutil.tz.tzfile or None

Time zone for the Timestamp.     Examples
>>> pd.Timestamp.fromordinal(737425)
Timestamp('2020-01-01 00:00:00')


pandas.Timestamp.fromtimestamp   classmethodTimestamp.fromtimestamp(ts)

Transform timestamp[, tz] to tz’s local time from POSIX timestamp. Examples
>>> pd.Timestamp.fromtimestamp(1584199972)
Timestamp('2020-03-14 15:32:52')
  Note that the output may change depending on your local time.


pandas.Timestamp.is_leap_year   Timestamp.is_leap_year

Return True if year is a leap year. Examples
>>> ts = pd.Timestamp(2020, 3, 14)
>>> ts.is_leap_year
True


pandas.Timestamp.is_month_end   Timestamp.is_month_end

Return True if date is last day of month. Examples
>>> ts = pd.Timestamp(2020, 3, 14)
>>> ts.is_month_end
False

>>> ts = pd.Timestamp(2020, 12, 31)
>>> ts.is_month_end
True


pandas.Timestamp.is_month_start   Timestamp.is_month_start

Return True if date is first day of month. Examples
>>> ts = pd.Timestamp(2020, 3, 14)
>>> ts.is_month_start
False

>>> ts = pd.Timestamp(2020, 1, 1)
>>> ts.is_month_start
True


pandas.Timestamp.is_quarter_end   Timestamp.is_quarter_end

Return True if date is last day of the quarter. Examples
>>> ts = pd.Timestamp(2020, 3, 14)
>>> ts.is_quarter_end
False

>>> ts = pd.Timestamp(2020, 3, 31)
>>> ts.is_quarter_end
True


pandas.Timestamp.is_quarter_start   Timestamp.is_quarter_start

Return True if date is first day of the quarter. Examples
>>> ts = pd.Timestamp(2020, 3, 14)
>>> ts.is_quarter_start
False

>>> ts = pd.Timestamp(2020, 4, 1)
>>> ts.is_quarter_start
True


pandas.Timestamp.is_year_end   Timestamp.is_year_end

Return True if date is last day of the year. Examples
>>> ts = pd.Timestamp(2020, 3, 14)
>>> ts.is_year_end
False

>>> ts = pd.Timestamp(2020, 12, 31)
>>> ts.is_year_end
True


pandas.Timestamp.is_year_start   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


pandas.Timestamp.isocalendar   Timestamp.isocalendar()

Return a 3-tuple containing ISO year, week number, and weekday.


pandas.Timestamp.isoformat   Timestamp.isoformat()

Return the time formatted according to ISO 8610. The full format looks like ‘YYYY-MM-DD HH:MM:SS.mmmmmmnnn’. By default, the fractional part is omitted if self.microsecond == 0 and self.nanosecond == 0. If self.tzinfo is not None, the UTC offset is also attached, giving giving a full format of ‘YYYY-MM-DD HH:MM:SS.mmmmmmnnn+HH:MM’.  Parameters

sep:str, default ‘T’

String used as the separator between the date and time.
timespec:str, default ‘auto’

Specifies the number of additional terms of the time to include. The valid values are ‘auto’, ‘hours’, ‘minutes’, ‘seconds’, ‘milliseconds’, ‘microseconds’, and ‘nanoseconds’.    Returns
 str
   Examples
>>> ts = pd.Timestamp('2020-03-14T15:32:52.192548651')
>>> ts.isoformat()
'2020-03-14T15:32:52.192548651'
>>> ts.isoformat(timespec='microseconds')
'2020-03-14T15:32:52.192548'


pandas.Timestamp.isoweekday   Timestamp.isoweekday()

Return the day of the week represented by the date. Monday == 1 … Sunday == 7.


pandas.Timestamp.max   Timestamp.max=Timestamp('2262-04-11 23:47:16.854775807')


pandas.Timestamp.microsecond   Timestamp.microsecond


pandas.Timestamp.min   Timestamp.min=Timestamp('1677-09-21 00:12:43.145224193')


pandas.Timestamp.minute   Timestamp.minute


pandas.Timestamp.month   Timestamp.month


pandas.Timestamp.month_name   Timestamp.month_name()

Return the month name of the Timestamp with specified locale.  Parameters

locale:str, default None (English locale)

Locale determining the language in which to return the month name.    Returns
 str
   Examples
>>> ts = pd.Timestamp('2020-03-14T15:32:52.192548651')
>>> ts.month_name()
'March'
  Analogous for pd.NaT:
>>> pd.NaT.month_name()
nan


pandas.Timestamp.nanosecond   Timestamp.nanosecond


pandas.Timestamp.normalize   Timestamp.normalize()

Normalize Timestamp to midnight, preserving tz information. Examples
>>> ts = pd.Timestamp(2020, 3, 14, 15, 30)
>>> ts.normalize()
Timestamp('2020-03-14 00:00:00')


pandas.Timestamp.now   classmethodTimestamp.now(tz=None)

Return new Timestamp object representing current time local to tz.  Parameters

tz:str or timezone object, default None

Timezone to localize to.     Examples
>>> pd.Timestamp.now()
Timestamp('2020-11-16 22:06:16.378782')
  Analogous for pd.NaT:
>>> pd.NaT.now()
NaT


pandas.Timestamp.quarter   Timestamp.quarter

Return the quarter of the year. Examples
>>> ts = pd.Timestamp(2020, 3, 14)
>>> ts.quarter
1


pandas.Timestamp.replace   Timestamp.replace(year=None, month=None, day=None, hour=None, minute=None, second=None, microsecond=None, nanosecond=None, tzinfo=<class 'object'>, fold=None)

Implements datetime.replace, handles nanoseconds.  Parameters

year:int, optional

month:int, optional

day:int, optional

hour:int, optional

minute:int, optional

second:int, optional

microsecond:int, optional

nanosecond:int, optional

tzinfo:tz-convertible, optional

fold:int, optional

  Returns
 Timestamp with fields replaced
   Examples Create a timestamp object:
>>> ts = pd.Timestamp('2020-03-14T15:32:52.192548651', tz='UTC')
>>> ts
Timestamp('2020-03-14 15:32:52.192548651+0000', tz='UTC')
  Replace year and the hour:
>>> ts.replace(year=1999, hour=10)
Timestamp('1999-03-14 10:32:52.192548651+0000', tz='UTC')
  Replace timezone (not a conversion):
>>> import pytz
>>> ts.replace(tzinfo=pytz.timezone('US/Pacific'))
Timestamp('2020-03-14 15:32:52.192548651-0700', tz='US/Pacific')
  Analogous for pd.NaT:
>>> pd.NaT.replace(tzinfo=pytz.timezone('US/Pacific'))
NaT


pandas.Timestamp.resolution   Timestamp.resolution=Timedelta('0 days 00:00:00.000000001')


pandas.Timestamp.round   Timestamp.round(freq, ambiguous='raise', nonexistent='raise')

Round the Timestamp to the specified resolution.  Parameters

freq:str

Frequency string indicating the rounding resolution.
ambiguous:bool or {‘raise’, ‘NaT’}, default ‘raise’

The behavior is as follows:  bool contains flags to determine if time is dst or not (note that this flag is only applicable for ambiguous fall dst dates). ‘NaT’ will return NaT for an ambiguous time. ‘raise’ will raise an AmbiguousTimeError for an ambiguous time.
nonexistent:{‘raise’, ‘shift_forward’, ‘shift_backward, ‘NaT’, timedelta}, default ‘raise’

A nonexistent time does not exist in a particular timezone where clocks moved forward due to DST.  ‘shift_forward’ will shift the nonexistent time forward to the closest existing time. ‘shift_backward’ will shift the nonexistent time backward to the closest existing time. ‘NaT’ will return NaT where there are nonexistent times. timedelta objects will shift nonexistent times by the timedelta. ‘raise’ will raise an NonExistentTimeError if there are nonexistent times.     Returns
 a new Timestamp rounded to the given resolution of freq

  Raises
 ValueError if the freq cannot be converted
   Notes If the Timestamp has a timezone, rounding will take place relative to the local (“wall”) time and re-localized to the same timezone. When rounding near daylight savings time, use nonexistent and ambiguous to control the re-localization behavior. Examples Create a timestamp object:
>>> ts = pd.Timestamp('2020-03-14T15:32:52.192548651')
  A timestamp can be rounded using multiple frequency units:
>>> ts.round(freq='H') # hour
Timestamp('2020-03-14 16:00:00')

>>> ts.round(freq='T') # minute
Timestamp('2020-03-14 15:33:00')

>>> ts.round(freq='S') # seconds
Timestamp('2020-03-14 15:32:52')

>>> ts.round(freq='L') # milliseconds
Timestamp('2020-03-14 15:32:52.193000')
  freq can also be a multiple of a single unit, like ‘5T’ (i.e. 5 minutes):
>>> ts.round(freq='5T')
Timestamp('2020-03-14 15:35:00')
  or a combination of multiple units, like ‘1H30T’ (i.e. 1 hour and 30 minutes):
>>> ts.round(freq='1H30T')
Timestamp('2020-03-14 15:00:00')
  Analogous for pd.NaT:
>>> pd.NaT.round()
NaT
  When rounding near a daylight savings time transition, use ambiguous or nonexistent to control how the timestamp should be re-localized.
>>> ts_tz = pd.Timestamp("2021-10-31 01:30:00").tz_localize("Europe/Amsterdam")

>>> ts_tz.round("H", ambiguous=False)
Timestamp('2021-10-31 02:00:00+0100', tz='Europe/Amsterdam')

>>> ts_tz.round("H", ambiguous=True)
Timestamp('2021-10-31 02:00:00+0200', tz='Europe/Amsterdam')


pandas.Timestamp.second   Timestamp.second


pandas.Timestamp.strftime   Timestamp.strftime(format)

Return a string representing the given POSIX timestamp controlled by an explicit format string.  Parameters

format:str

Format string to convert Timestamp to string. See strftime documentation for more information on the format string: https://docs.python.org/3/library/datetime.html#strftime-and-strptime-behavior.     Examples
>>> ts = pd.Timestamp('2020-03-14T15:32:52.192548651')
>>> ts.strftime('%Y-%m-%d %X')
'2020-03-14 15:32:52'


pandas.Timestamp.strptime   classmethodTimestamp.strptime(string, format)

Function is not implemented. Use pd.to_datetime().


pandas.Timestamp.time   Timestamp.time()

Return time object with same time but with tzinfo=None.


pandas.Timestamp.timestamp   Timestamp.timestamp()

Return POSIX timestamp as float. Examples
>>> ts = pd.Timestamp('2020-03-14T15:32:52.192548')
>>> ts.timestamp()
1584199972.192548


pandas.Timestamp.timetuple   Timestamp.timetuple()

Return time tuple, compatible with time.localtime().


pandas.Timestamp.timetz   Timestamp.timetz()

Return time object with same time and tzinfo.


pandas.Timestamp.to_datetime64   Timestamp.to_datetime64()

Return a numpy.datetime64 object with ‘ns’ precision.


pandas.Timestamp.to_julian_date   Timestamp.to_julian_date()

Convert TimeStamp to a Julian Date. 0 Julian date is noon January 1, 4713 BC. Examples
>>> ts = pd.Timestamp('2020-03-14T15:32:52')
>>> ts.to_julian_date()
2458923.147824074


pandas.Timestamp.to_numpy   Timestamp.to_numpy()

Convert the Timestamp to a NumPy datetime64.  New in version 0.25.0.  This is an alias method for Timestamp.to_datetime64(). The dtype and copy parameters are available here only for compatibility. Their values will not affect the return value.  Returns
 numpy.datetime64
    See also  DatetimeIndex.to_numpy

Similar method for DatetimeIndex.    Examples
>>> ts = pd.Timestamp('2020-03-14T15:32:52.192548651')
>>> ts.to_numpy()
numpy.datetime64('2020-03-14T15:32:52.192548651')
  Analogous for pd.NaT:
>>> pd.NaT.to_numpy()
numpy.datetime64('NaT')


pandas.Timestamp.to_period   Timestamp.to_period()

Return an period of which this timestamp is an observation. Examples
>>> ts = pd.Timestamp('2020-03-14T15:32:52.192548651')
>>> # Year end frequency
>>> ts.to_period(freq='Y')
Period('2020', 'A-DEC')

>>> # Month end frequency
>>> ts.to_period(freq='M')
Period('2020-03', 'M')

>>> # Weekly frequency
>>> ts.to_period(freq='W')
Period('2020-03-09/2020-03-15', 'W-SUN')

>>> # Quarter end frequency
>>> ts.to_period(freq='Q')
Period('2020Q1', 'Q-DEC')


pandas.Timestamp.to_pydatetime   Timestamp.to_pydatetime()

Convert a Timestamp object to a native Python datetime object. If warn=True, issue a warning if nanoseconds is nonzero. Examples
>>> ts = pd.Timestamp('2020-03-14T15:32:52.192548')
>>> ts.to_pydatetime()
datetime.datetime(2020, 3, 14, 15, 32, 52, 192548)
  Analogous for pd.NaT:
>>> pd.NaT.to_pydatetime()
NaT


pandas.Timestamp.today   classmethodTimestamp.today(cls, tz=None)

Return the current time in the local timezone. This differs from datetime.today() in that it can be localized to a passed timezone.  Parameters

tz:str or timezone object, default None

Timezone to localize to.     Examples
>>> pd.Timestamp.today()
Timestamp('2020-11-16 22:37:39.969883')
  Analogous for pd.NaT:
>>> pd.NaT.today()
NaT


pandas.Timestamp.toordinal   Timestamp.toordinal()

Return proleptic Gregorian ordinal. January 1 of year 1 is day 1.


pandas.Timestamp.tz   propertyTimestamp.tz

Alias for tzinfo. Examples
>>> ts = pd.Timestamp(1584226800, unit='s', tz='Europe/Stockholm')
>>> ts.tz
<DstTzInfo 'Europe/Stockholm' CET+1:00:00 STD>


pandas.Timestamp.tz_convert   Timestamp.tz_convert(tz)

Convert timezone-aware Timestamp to another time zone.  Parameters

tz:str, pytz.timezone, dateutil.tz.tzfile or None

Time zone for time which Timestamp will be converted to. None will remove timezone holding UTC time.    Returns

converted:Timestamp

  Raises
 TypeError

If Timestamp is tz-naive.     Examples Create a timestamp object with UTC timezone:
>>> ts = pd.Timestamp('2020-03-14T15:32:52.192548651', tz='UTC')
>>> ts
Timestamp('2020-03-14 15:32:52.192548651+0000', tz='UTC')
  Change to Tokyo timezone:
>>> ts.tz_convert(tz='Asia/Tokyo')
Timestamp('2020-03-15 00:32:52.192548651+0900', tz='Asia/Tokyo')
  Can also use astimezone:
>>> ts.astimezone(tz='Asia/Tokyo')
Timestamp('2020-03-15 00:32:52.192548651+0900', tz='Asia/Tokyo')
  Analogous for pd.NaT:
>>> pd.NaT.tz_convert(tz='Asia/Tokyo')
NaT


pandas.Timestamp.tz_localize   Timestamp.tz_localize(tz, ambiguous='raise', nonexistent='raise')

Convert naive Timestamp to local time zone, or remove timezone from timezone-aware Timestamp.  Parameters

tz:str, pytz.timezone, dateutil.tz.tzfile or None

Time zone for time which Timestamp will be converted to. None will remove timezone holding local time.
ambiguous:bool, ‘NaT’, default ‘raise’

When clocks moved backward due to DST, ambiguous times may arise. For example in Central European Time (UTC+01), when going from 03:00 DST to 02:00 non-DST, 02:30:00 local time occurs both at 00:30:00 UTC and at 01:30:00 UTC. In such a situation, the ambiguous parameter dictates how ambiguous times should be handled. The behavior is as follows:  bool contains flags to determine if time is dst or not (note that this flag is only applicable for ambiguous fall dst dates). ‘NaT’ will return NaT for an ambiguous time. ‘raise’ will raise an AmbiguousTimeError for an ambiguous time.
nonexistent:‘shift_forward’, ‘shift_backward, ‘NaT’, timedelta, default ‘raise’

A nonexistent time does not exist in a particular timezone where clocks moved forward due to DST. The behavior is as follows:  ‘shift_forward’ will shift the nonexistent time forward to the closest existing time. ‘shift_backward’ will shift the nonexistent time backward to the closest existing time. ‘NaT’ will return NaT where there are nonexistent times. timedelta objects will shift nonexistent times by the timedelta. ‘raise’ will raise an NonExistentTimeError if there are nonexistent times.     Returns

localized:Timestamp

  Raises
 TypeError

If the Timestamp is tz-aware and tz is not None.     Examples Create a naive timestamp object:
>>> ts = pd.Timestamp('2020-03-14T15:32:52.192548651')
>>> ts
Timestamp('2020-03-14 15:32:52.192548651')
  Add ‘Europe/Stockholm’ as timezone:
>>> ts.tz_localize(tz='Europe/Stockholm')
Timestamp('2020-03-14 15:32:52.192548651+0100', tz='Europe/Stockholm')
  Analogous for pd.NaT:
>>> pd.NaT.tz_localize()
NaT


pandas.Timestamp.tzinfo   Timestamp.tzinfo


pandas.Timestamp.tzname   Timestamp.tzname()

Return self.tzinfo.tzname(self).


pandas.Timestamp.utcfromtimestamp   classmethodTimestamp.utcfromtimestamp(ts)

Construct a naive UTC datetime from a POSIX timestamp. Examples
>>> pd.Timestamp.utcfromtimestamp(1584199972)
Timestamp('2020-03-14 15:32:52')


pandas.Timestamp.utcnow   classmethodTimestamp.utcnow()

Return a new Timestamp representing UTC day and time. Examples
>>> pd.Timestamp.utcnow()
Timestamp('2020-11-16 22:50:18.092888+0000', tz='UTC')


pandas.Timestamp.utcoffset   Timestamp.utcoffset()

Return self.tzinfo.utcoffset(self).


pandas.Timestamp.utctimetuple   Timestamp.utctimetuple()

Return UTC time tuple, compatible with time.localtime().


pandas.Timestamp.value   Timestamp.value


pandas.Timestamp.week   Timestamp.week

Return the week number of the year. Examples
>>> ts = pd.Timestamp(2020, 3, 14)
>>> ts.week
11


pandas.Timestamp.weekday   Timestamp.weekday()

Return the day of the week represented by the date. Monday == 0 … Sunday == 6.


pandas.Timestamp.weekofyear   Timestamp.weekofyear

Return the week number of the year. Examples
>>> ts = pd.Timestamp(2020, 3, 14)
>>> ts.week
11


pandas.to_datetime   pandas.to_datetime(arg, errors='raise', dayfirst=False, yearfirst=False, utc=None, format=None, exact=True, unit=None, infer_datetime_format=False, origin='unix', cache=True)[source]

Convert argument to datetime. This function converts a scalar, array-like, Series or DataFrame/dict-like to a pandas datetime object.  Parameters

arg:int, float, str, datetime, list, tuple, 1-d array, Series, DataFrame/dict-like

The object to convert to a datetime. If a DataFrame is provided, the method expects minimally the following columns: "year", "month", "day".
errors:{‘ignore’, ‘raise’, ‘coerce’}, default ‘raise’

 If 'raise', then invalid parsing will raise an exception. If 'coerce', then invalid parsing will be set as NaT. If 'ignore', then invalid parsing will return the input.
dayfirst:bool, default False

Specify a date parse order if arg is str or is list-like. If True, parses dates with the day first, e.g. "10/11/12" is parsed as 2012-11-10.  Warning dayfirst=True is not strict, but will prefer to parse with day first. If a delimited date string cannot be parsed in accordance with the given dayfirst option, e.g. to_datetime(['31-12-2021']), then a warning will be shown.
yearfirst:bool, default False

Specify a date parse order if arg is str or is list-like.  If True parses dates with the year first, e.g. "10/11/12" is parsed as 2010-11-12. If both dayfirst and yearfirst are True, yearfirst is preceded (same as dateutil).   Warning yearfirst=True is not strict, but will prefer to parse with year first.
utc:bool, default None

Control timezone-related parsing, localization and conversion.  If True, the function always returns a timezone-aware UTC-localized Timestamp, Series or DatetimeIndex. To do this, timezone-naive inputs are localized as UTC, while timezone-aware inputs are converted to UTC. If False (default), inputs will not be coerced to UTC. Timezone-naive inputs will remain naive, while timezone-aware ones will keep their time offsets. Limitations exist for mixed offsets (typically, daylight savings), see Examples section for details.  See also: pandas general documentation about timezone conversion and localization.
format:str, default None

The strftime to parse time, e.g. "%d/%m/%Y". Note that "%f" will parse all the way up to nanoseconds. See strftime documentation for more information on choices.
exact:bool, default True

Control how format is used:  If True, require an exact format match. If False, allow the format to match anywhere in the target string.
unit:str, default ‘ns’

The unit of the arg (D,s,ms,us,ns) denote the unit, which is an integer or float number. This will be based off the origin. Example, with unit='ms' and origin='unix' (the default), this would calculate the number of milliseconds to the unix epoch start.
infer_datetime_format:bool, default False

If True and no format is given, attempt to infer the format of the datetime strings based on the first non-NaN element, and if it can be inferred, switch to a faster method of parsing them. In some cases this can increase the parsing speed by ~5-10x.
origin:scalar, default ‘unix’

Define the reference date. The numeric values would be parsed as number of units (defined by unit) since this reference date.  If 'unix' (or POSIX) time; origin is set to 1970-01-01. If 'julian', unit must be 'D', and origin is set to beginning of Julian Calendar. Julian day number 0 is assigned to the day starting at noon on January 1, 4713 BC. If Timestamp convertible, origin is set to Timestamp identified by origin.
cache:bool, default True

If True, use a cache of unique, converted dates to apply the datetime conversion. May produce significant speed-up when parsing duplicate date strings, especially ones with timezone offsets. The cache is only used when there are at least 50 values. The presence of out-of-bounds values will render the cache unusable and may slow down parsing.  Changed in version 0.25.0: changed default value from False to True.     Returns
 datetime

If parsing succeeded. Return type depends on input (types in parenthesis correspond to fallback in case of unsuccessful timezone or out-of-range timestamp parsing):  scalar: Timestamp (or datetime.datetime) array-like: DatetimeIndex (or Series with object dtype containing datetime.datetime) Series: Series of datetime64 dtype (or Series of object dtype containing datetime.datetime) DataFrame: Series of datetime64 dtype (or Series of object dtype containing datetime.datetime)     Raises
 ParserError

When parsing a date from string fails.  ValueError

When another datetime conversion error happens. For example when one of ‘year’, ‘month’, day’ columns is missing in a DataFrame, or when a Timezone-aware datetime.datetime is found in an array-like of mixed time offsets, and utc=False.      See also  DataFrame.astype

Cast argument to a specified dtype.  to_timedelta

Convert argument to timedelta.  convert_dtypes

Convert dtypes.    Notes Many input types are supported, and lead to different output types:  scalars can be int, float, str, datetime object (from stdlib datetime module or numpy). They are converted to Timestamp when possible, otherwise they are converted to datetime.datetime. None/NaN/null scalars are converted to NaT. array-like can contain int, float, str, datetime objects. They are converted to DatetimeIndex when possible, otherwise they are converted to Index with object dtype, containing datetime.datetime. None/NaN/null entries are converted to NaT in both cases. Series are converted to Series with datetime64 dtype when possible, otherwise they are converted to Series with object dtype, containing datetime.datetime. None/NaN/null entries are converted to NaT in both cases. DataFrame/dict-like are converted to Series with datetime64 dtype. For each row a datetime is created from assembling the various dataframe columns. Column keys can be common abbreviations like [‘year’, ‘month’, ‘day’, ‘minute’, ‘second’, ‘ms’, ‘us’, ‘ns’]) or plurals of the same.  The following causes are responsible for datetime.datetime objects being returned (possibly inside an Index or a Series with object dtype) instead of a proper pandas designated type (Timestamp, DatetimeIndex or Series with datetime64 dtype):  when any input element is before Timestamp.min or after Timestamp.max, see timestamp limitations. when utc=False (default) and the input is an array-like or Series containing mixed naive/aware datetime, or aware with mixed time offsets. Note that this happens in the (quite frequent) situation when the timezone has a daylight savings policy. In that case you may wish to use utc=True.  Examples Handling various input formats Assembling a datetime from multiple columns of a DataFrame. The keys can be common abbreviations like [‘year’, ‘month’, ‘day’, ‘minute’, ‘second’, ‘ms’, ‘us’, ‘ns’]) or plurals of the same
>>> df = pd.DataFrame({'year': [2015, 2016],
...                    'month': [2, 3],
...                    'day': [4, 5]})
>>> pd.to_datetime(df)
0   2015-02-04
1   2016-03-05
dtype: datetime64[ns]
  Passing infer_datetime_format=True can often-times speedup a parsing if its not an ISO8601 format exactly, but in a regular format.
>>> s = pd.Series(['3/11/2000', '3/12/2000', '3/13/2000'] * 1000)
>>> s.head()
0    3/11/2000
1    3/12/2000
2    3/13/2000
3    3/11/2000
4    3/12/2000
dtype: object

>>> %timeit pd.to_datetime(s, infer_datetime_format=True)
100 loops, best of 3: 10.4 ms per loop

>>> %timeit pd.to_datetime(s, infer_datetime_format=False)
1 loop, best of 3: 471 ms per loop
  Using a unix epoch time
>>> pd.to_datetime(1490195805, unit='s')
Timestamp('2017-03-22 15:16:45')
>>> pd.to_datetime(1490195805433502912, unit='ns')
Timestamp('2017-03-22 15:16:45.433502912')
   Warning For float arg, precision rounding might happen. To prevent unexpected behavior use a fixed-width exact type.  Using a non-unix epoch origin
>>> pd.to_datetime([1, 2, 3], unit='D',
...                origin=pd.Timestamp('1960-01-01'))
DatetimeIndex(['1960-01-02', '1960-01-03', '1960-01-04'],
              dtype='datetime64[ns]', freq=None)
  Non-convertible date/times If a date does not meet the timestamp limitations, passing errors='ignore' will return the original input instead of raising any exception. Passing errors='coerce' will force an out-of-bounds date to NaT, in addition to forcing non-dates (or non-parseable dates) to NaT.
>>> pd.to_datetime('13000101', format='%Y%m%d', errors='ignore')
datetime.datetime(1300, 1, 1, 0, 0)
>>> pd.to_datetime('13000101', format='%Y%m%d', errors='coerce')
NaT
  Timezones and time offsets The default behaviour (utc=False) is as follows:  Timezone-naive inputs are converted to timezone-naive DatetimeIndex:
>>> pd.to_datetime(['2018-10-26 12:00', '2018-10-26 13:00:15'])
DatetimeIndex(['2018-10-26 12:00:00', '2018-10-26 13:00:15'],
              dtype='datetime64[ns]', freq=None)
   Timezone-aware inputs with constant time offset are converted to timezone-aware DatetimeIndex:
>>> pd.to_datetime(['2018-10-26 12:00 -0500', '2018-10-26 13:00 -0500'])
DatetimeIndex(['2018-10-26 12:00:00-05:00', '2018-10-26 13:00:00-05:00'],
              dtype='datetime64[ns, pytz.FixedOffset(-300)]', freq=None)
   However, timezone-aware inputs with mixed time offsets (for example issued from a timezone with daylight savings, such as Europe/Paris) are not successfully converted to a DatetimeIndex. Instead a simple Index containing datetime.datetime objects is returned:
>>> pd.to_datetime(['2020-10-25 02:00 +0200', '2020-10-25 04:00 +0100'])
Index([2020-10-25 02:00:00+02:00, 2020-10-25 04:00:00+01:00],
      dtype='object')
   A mix of timezone-aware and timezone-naive inputs is converted to a timezone-aware DatetimeIndex if the offsets of the timezone-aware are constant:
>>> from datetime import datetime
>>> pd.to_datetime(["2020-01-01 01:00 -01:00", datetime(2020, 1, 1, 3, 0)])
DatetimeIndex(['2020-01-01 01:00:00-01:00', '2020-01-01 02:00:00-01:00'],
              dtype='datetime64[ns, pytz.FixedOffset(-60)]', freq=None)
   Finally, mixing timezone-aware strings and datetime.datetime always raises an error, even if the elements all have the same time offset.
>>> from datetime import datetime, timezone, timedelta
>>> d = datetime(2020, 1, 1, 18, tzinfo=timezone(-timedelta(hours=1)))
>>> pd.to_datetime(["2020-01-01 17:00 -0100", d])
Traceback (most recent call last):
    ...
ValueError: Tz-aware datetime.datetime cannot be converted to datetime64
            unless utc=True
     Setting utc=True solves most of the above issues:  Timezone-naive inputs are localized as UTC
>>> pd.to_datetime(['2018-10-26 12:00', '2018-10-26 13:00'], utc=True)
DatetimeIndex(['2018-10-26 12:00:00+00:00', '2018-10-26 13:00:00+00:00'],
              dtype='datetime64[ns, UTC]', freq=None)
   Timezone-aware inputs are converted to UTC (the output represents the exact same datetime, but viewed from the UTC time offset +00:00).
>>> pd.to_datetime(['2018-10-26 12:00 -0530', '2018-10-26 12:00 -0500'],
...                utc=True)
DatetimeIndex(['2018-10-26 17:30:00+00:00', '2018-10-26 17:00:00+00:00'],
              dtype='datetime64[ns, UTC]', freq=None)
   Inputs can contain both naive and aware, string or datetime, the above rules still apply
>>> pd.to_datetime(['2018-10-26 12:00', '2018-10-26 12:00 -0530',
...                datetime(2020, 1, 1, 18),
...                datetime(2020, 1, 1, 18,
...                tzinfo=timezone(-timedelta(hours=1)))],
...                utc=True)
DatetimeIndex(['2018-10-26 12:00:00+00:00', '2018-10-26 17:30:00+00:00',
               '2020-01-01 18:00:00+00:00', '2020-01-01 19:00:00+00:00'],
              dtype='datetime64[ns, UTC]', freq=None)


pandas.to_numeric   pandas.to_numeric(arg, errors='raise', downcast=None)[source]

Convert argument to a numeric type. The default return dtype is float64 or int64 depending on the data supplied. Use the downcast parameter to obtain other dtypes. Please note that precision loss may occur if really large numbers are passed in. Due to the internal limitations of ndarray, if numbers smaller than -9223372036854775808 (np.iinfo(np.int64).min) or larger than 18446744073709551615 (np.iinfo(np.uint64).max) are passed in, it is very likely they will be converted to float so that they can stored in an ndarray. These warnings apply similarly to Series since it internally leverages ndarray.  Parameters

arg:scalar, list, tuple, 1-d array, or Series

Argument to be converted.
errors:{‘ignore’, ‘raise’, ‘coerce’}, default ‘raise’

 If ‘raise’, then invalid parsing will raise an exception. If ‘coerce’, then invalid parsing will be set as NaN. If ‘ignore’, then invalid parsing will return the input.
downcast:str, default None

Can be ‘integer’, ‘signed’, ‘unsigned’, or ‘float’. If not None, and if the data has been successfully cast to a numerical dtype (or if the data was numeric to begin with), downcast that resulting data to the smallest numerical dtype possible according to the following rules:  ‘integer’ or ‘signed’: smallest signed int dtype (min.: np.int8) ‘unsigned’: smallest unsigned int dtype (min.: np.uint8) ‘float’: smallest float dtype (min.: np.float32)  As this behaviour is separate from the core conversion to numeric values, any errors raised during the downcasting will be surfaced regardless of the value of the ‘errors’ input. In addition, downcasting will only occur if the size of the resulting data’s dtype is strictly larger than the dtype it is to be cast to, so if none of the dtypes checked satisfy that specification, no downcasting will be performed on the data.    Returns
 ret

Numeric if parsing succeeded. Return type depends on input. Series if Series, otherwise ndarray.      See also  DataFrame.astype

Cast argument to a specified dtype.  to_datetime

Convert argument to datetime.  to_timedelta

Convert argument to timedelta.  numpy.ndarray.astype

Cast a numpy array to a specified type.  DataFrame.convert_dtypes

Convert dtypes.    Examples Take separate series and convert to numeric, coercing when told to
>>> s = pd.Series(['1.0', '2', -3])
>>> pd.to_numeric(s)
0    1.0
1    2.0
2   -3.0
dtype: float64
>>> pd.to_numeric(s, downcast='float')
0    1.0
1    2.0
2   -3.0
dtype: float32
>>> pd.to_numeric(s, downcast='signed')
0    1
1    2
2   -3
dtype: int8
>>> s = pd.Series(['apple', '1.0', '2', -3])
>>> pd.to_numeric(s, errors='ignore')
0    apple
1      1.0
2        2
3       -3
dtype: object
>>> pd.to_numeric(s, errors='coerce')
0    NaN
1    1.0
2    2.0
3   -3.0
dtype: float64
  Downcasting of nullable integer and floating dtypes is supported:
>>> s = pd.Series([1, 2, 3], dtype="Int64")
>>> pd.to_numeric(s, downcast="integer")
0    1
1    2
2    3
dtype: Int8
>>> s = pd.Series([1.0, 2.1, 3.0], dtype="Float64")
>>> pd.to_numeric(s, downcast="float")
0    1.0
1    2.1
2    3.0
dtype: Float32


pandas.to_timedelta   pandas.to_timedelta(arg, unit=None, errors='raise')[source]

Convert argument to timedelta. Timedeltas are absolute differences in times, expressed in difference units (e.g. days, hours, minutes, seconds). This method converts an argument from a recognized timedelta format / value into a Timedelta type.  Parameters

arg:str, timedelta, list-like or Series

The data to be converted to timedelta.  Deprecated since version 1.2: Strings with units ‘M’, ‘Y’ and ‘y’ do not represent unambiguous timedelta values and will be removed in a future version
unit:str, optional

Denotes the unit of the arg for numeric arg. Defaults to "ns". Possible values:  ‘W’ ‘D’ / ‘days’ / ‘day’ ‘hours’ / ‘hour’ / ‘hr’ / ‘h’ ‘m’ / ‘minute’ / ‘min’ / ‘minutes’ / ‘T’ ‘S’ / ‘seconds’ / ‘sec’ / ‘second’ ‘ms’ / ‘milliseconds’ / ‘millisecond’ / ‘milli’ / ‘millis’ / ‘L’ ‘us’ / ‘microseconds’ / ‘microsecond’ / ‘micro’ / ‘micros’ / ‘U’ ‘ns’ / ‘nanoseconds’ / ‘nano’ / ‘nanos’ / ‘nanosecond’ / ‘N’   Changed in version 1.1.0: Must not be specified when arg context strings and errors="raise".
errors:{‘ignore’, ‘raise’, ‘coerce’}, default ‘raise’

 If ‘raise’, then invalid parsing will raise an exception. If ‘coerce’, then invalid parsing will be set as NaT. If ‘ignore’, then invalid parsing will return the input.     Returns
 timedelta

If parsing succeeded. Return type depends on input:  list-like: TimedeltaIndex of timedelta64 dtype Series: Series of timedelta64 dtype scalar: Timedelta       See also  DataFrame.astype

Cast argument to a specified dtype.  to_datetime

Convert argument to datetime.  convert_dtypes

Convert dtypes.    Notes If the precision is higher than nanoseconds, the precision of the duration is truncated to nanoseconds for string inputs. Examples Parsing a single string to a Timedelta:
>>> pd.to_timedelta('1 days 06:05:01.00003')
Timedelta('1 days 06:05:01.000030')
>>> pd.to_timedelta('15.5us')
Timedelta('0 days 00:00:00.000015500')
  Parsing a list or array of strings:
>>> pd.to_timedelta(['1 days 06:05:01.00003', '15.5us', 'nan'])
TimedeltaIndex(['1 days 06:05:01.000030', '0 days 00:00:00.000015500', NaT],
               dtype='timedelta64[ns]', freq=None)
  Converting numbers by specifying the unit keyword argument:
>>> pd.to_timedelta(np.arange(5), unit='s')
TimedeltaIndex(['0 days 00:00:00', '0 days 00:00:01', '0 days 00:00:02',
                '0 days 00:00:03', '0 days 00:00:04'],
               dtype='timedelta64[ns]', freq=None)
>>> pd.to_timedelta(np.arange(5), unit='d')
TimedeltaIndex(['0 days', '1 days', '2 days', '3 days', '4 days'],
               dtype='timedelta64[ns]', freq=None)


pandas.tseries.frequencies.to_offset   pandas.tseries.frequencies.to_offset()

Return DateOffset object from string or tuple representation or datetime.timedelta object.  Parameters

freq:str, datetime.timedelta, BaseOffset or None

  Returns
 DateOffset or None
  Raises
 ValueError

If freq is an invalid frequency      See also  BaseOffset

Standard kind of date increment used for a date range.    Examples
>>> to_offset("5min")
<5 * Minutes>

>>> to_offset("1D1H")
<25 * Hours>

>>> to_offset("2W")
<2 * Weeks: weekday=6>

>>> to_offset("2B")
<2 * BusinessDays>

>>> to_offset(pd.Timedelta(days=1))
<Day>

>>> to_offset(Hour())
<Hour>


pandas.tseries.offsets.BDay   pandas.tseries.offsets.BDay

alias of pandas._libs.tslibs.offsets.BusinessDay


pandas.tseries.offsets.BMonthBegin   pandas.tseries.offsets.BMonthBegin

alias of pandas._libs.tslibs.offsets.BusinessMonthBegin


pandas.tseries.offsets.BMonthEnd   pandas.tseries.offsets.BMonthEnd

alias of pandas._libs.tslibs.offsets.BusinessMonthEnd


pandas.tseries.offsets.BQuarterBegin   classpandas.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
kwds
n
name
nanos
normalize
rule_code
startingMonth     Methods
__call__(*args, **kwargs) Call self as a function.
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
apply_index
copy
isAnchored
is_anchored
is_month_end
is_month_start
is_on_offset
is_quarter_end
is_quarter_start
is_year_end
is_year_start
onOffset


pandas.tseries.offsets.BQuarterBegin.__call__   BQuarterBegin.__call__(*args, **kwargs)

Call self as a function.


pandas.tseries.offsets.BQuarterBegin.apply   BQuarterBegin.apply()


pandas.tseries.offsets.BQuarterBegin.apply_index   BQuarterBegin.apply_index(other)


pandas.tseries.offsets.BQuarterBegin.base   BQuarterBegin.base

Returns a copy of the calling offset object with n=1 and all other attributes equal.


pandas.tseries.offsets.BQuarterBegin.copy   BQuarterBegin.copy()


pandas.tseries.offsets.BQuarterBegin.freqstr   BQuarterBegin.freqstr


pandas.tseries.offsets.BQuarterBegin.is_anchored   BQuarterBegin.is_anchored()


pandas.tseries.offsets.BQuarterBegin.is_month_end   BQuarterBegin.is_month_end()


pandas.tseries.offsets.BQuarterBegin.is_month_start   BQuarterBegin.is_month_start()


pandas.tseries.offsets.BQuarterBegin.is_on_offset   BQuarterBegin.is_on_offset()


pandas.tseries.offsets.BQuarterBegin.is_quarter_end   BQuarterBegin.is_quarter_end()


pandas.tseries.offsets.BQuarterBegin.is_quarter_start   BQuarterBegin.is_quarter_start()


pandas.tseries.offsets.BQuarterBegin.is_year_end   BQuarterBegin.is_year_end()


pandas.tseries.offsets.BQuarterBegin.is_year_start   BQuarterBegin.is_year_start()


pandas.tseries.offsets.BQuarterBegin.isAnchored   BQuarterBegin.isAnchored()


pandas.tseries.offsets.BQuarterBegin.kwds   BQuarterBegin.kwds


pandas.tseries.offsets.BQuarterBegin.n   BQuarterBegin.n


pandas.tseries.offsets.BQuarterBegin.name   BQuarterBegin.name


pandas.tseries.offsets.BQuarterBegin.nanos   BQuarterBegin.nanos


pandas.tseries.offsets.BQuarterBegin.normalize   BQuarterBegin.normalize


pandas.tseries.offsets.BQuarterBegin.onOffset   BQuarterBegin.onOffset()


pandas.tseries.offsets.BQuarterBegin.rollback   BQuarterBegin.rollback()

Roll provided date backward to next offset only if not on offset.  Returns
 TimeStamp

Rolled timestamp if not on offset, otherwise unchanged timestamp.


pandas.tseries.offsets.BQuarterBegin.rollforward   BQuarterBegin.rollforward()

Roll provided date forward to next offset only if not on offset.  Returns
 TimeStamp

Rolled timestamp if not on offset, otherwise unchanged timestamp.


pandas.tseries.offsets.BQuarterBegin.rule_code   BQuarterBegin.rule_code


pandas.tseries.offsets.BQuarterBegin.startingMonth   BQuarterBegin.startingMonth


pandas.tseries.offsets.BQuarterEnd   classpandas.tseries.offsets.BQuarterEnd

DateOffset increments between the last business day of each Quarter. startingMonth = 1 corresponds to dates like 1/31/2007, 4/30/2007, … startingMonth = 2 corresponds to dates like 2/28/2007, 5/31/2007, … startingMonth = 3 corresponds to dates like 3/30/2007, 6/29/2007, … Examples
>>> from pandas.tseries.offsets import BQuarterEnd
>>> ts = pd.Timestamp('2020-05-24 05:01:15')
>>> ts + BQuarterEnd()
Timestamp('2020-06-30 05:01:15')
>>> ts + BQuarterEnd(2)
Timestamp('2020-09-30 05:01:15')
>>> ts + BQuarterEnd(1, startingMonth=2)
Timestamp('2020-05-29 05:01:15')
>>> ts + BQuarterEnd(startingMonth=2)
Timestamp('2020-05-29 05:01:15')
  Attributes
base Returns a copy of the calling offset object with n=1 and all other attributes equal.
freqstr
kwds
n
name
nanos
normalize
rule_code
startingMonth     Methods
__call__(*args, **kwargs) Call self as a function.
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
apply_index
copy
isAnchored
is_anchored
is_month_end
is_month_start
is_on_offset
is_quarter_end
is_quarter_start
is_year_end
is_year_start
onOffset


pandas.tseries.offsets.BQuarterEnd.__call__   BQuarterEnd.__call__(*args, **kwargs)

Call self as a function.


pandas.tseries.offsets.BQuarterEnd.apply   BQuarterEnd.apply()


pandas.tseries.offsets.BQuarterEnd.apply_index   BQuarterEnd.apply_index(other)


pandas.tseries.offsets.BQuarterEnd.base   BQuarterEnd.base

Returns a copy of the calling offset object with n=1 and all other attributes equal.


pandas.tseries.offsets.BQuarterEnd.copy   BQuarterEnd.copy()


pandas.tseries.offsets.BQuarterEnd.freqstr   BQuarterEnd.freqstr


pandas.tseries.offsets.BQuarterEnd.is_anchored   BQuarterEnd.is_anchored()


pandas.tseries.offsets.BQuarterEnd.is_month_end   BQuarterEnd.is_month_end()


pandas.tseries.offsets.BQuarterEnd.is_month_start   BQuarterEnd.is_month_start()


pandas.tseries.offsets.BQuarterEnd.is_on_offset   BQuarterEnd.is_on_offset()


pandas.tseries.offsets.BQuarterEnd.is_quarter_end   BQuarterEnd.is_quarter_end()


pandas.tseries.offsets.BQuarterEnd.is_quarter_start   BQuarterEnd.is_quarter_start()


pandas.tseries.offsets.BQuarterEnd.is_year_end   BQuarterEnd.is_year_end()


pandas.tseries.offsets.BQuarterEnd.is_year_start   BQuarterEnd.is_year_start()


pandas.tseries.offsets.BQuarterEnd.isAnchored   BQuarterEnd.isAnchored()


pandas.tseries.offsets.BQuarterEnd.kwds   BQuarterEnd.kwds


pandas.tseries.offsets.BQuarterEnd.n   BQuarterEnd.n


pandas.tseries.offsets.BQuarterEnd.name   BQuarterEnd.name


pandas.tseries.offsets.BQuarterEnd.nanos   BQuarterEnd.nanos


pandas.tseries.offsets.BQuarterEnd.normalize   BQuarterEnd.normalize


pandas.tseries.offsets.BQuarterEnd.onOffset   BQuarterEnd.onOffset()


pandas.tseries.offsets.BQuarterEnd.rollback   BQuarterEnd.rollback()

Roll provided date backward to next offset only if not on offset.  Returns
 TimeStamp

Rolled timestamp if not on offset, otherwise unchanged timestamp.


pandas.tseries.offsets.BQuarterEnd.rollforward   BQuarterEnd.rollforward()

Roll provided date forward to next offset only if not on offset.  Returns
 TimeStamp

Rolled timestamp if not on offset, otherwise unchanged timestamp.


pandas.tseries.offsets.BQuarterEnd.rule_code   BQuarterEnd.rule_code


pandas.tseries.offsets.BQuarterEnd.startingMonth   BQuarterEnd.startingMonth


pandas.tseries.offsets.BusinessDay   classpandas.tseries.offsets.BusinessDay

DateOffset subclass representing possibly n business days. Attributes
base Returns a copy of the calling offset object with n=1 and all other attributes equal.
offset Alias for self._offset.
calendar
freqstr
holidays
kwds
n
name
nanos
normalize
rule_code
weekmask     Methods
__call__(*args, **kwargs) Call self as a function.
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
apply_index
copy
isAnchored
is_anchored
is_month_end
is_month_start
is_on_offset
is_quarter_end
is_quarter_start
is_year_end
is_year_start
onOffset


pandas.tseries.offsets.BusinessDay.__call__   BusinessDay.__call__(*args, **kwargs)

Call self as a function.


pandas.tseries.offsets.BusinessDay.apply   BusinessDay.apply()


pandas.tseries.offsets.BusinessDay.apply_index   BusinessDay.apply_index(other)


pandas.tseries.offsets.BusinessDay.base   BusinessDay.base

Returns a copy of the calling offset object with n=1 and all other attributes equal.


pandas.tseries.offsets.BusinessDay.calendar   BusinessDay.calendar


pandas.tseries.offsets.BusinessDay.copy   BusinessDay.copy()


pandas.tseries.offsets.BusinessDay.freqstr   BusinessDay.freqstr


pandas.tseries.offsets.BusinessDay.holidays   BusinessDay.holidays


pandas.tseries.offsets.BusinessDay.is_anchored   BusinessDay.is_anchored()


pandas.tseries.offsets.BusinessDay.is_month_end   BusinessDay.is_month_end()


pandas.tseries.offsets.BusinessDay.is_month_start   BusinessDay.is_month_start()


pandas.tseries.offsets.BusinessDay.is_on_offset   BusinessDay.is_on_offset()


pandas.tseries.offsets.BusinessDay.is_quarter_end   BusinessDay.is_quarter_end()


pandas.tseries.offsets.BusinessDay.is_quarter_start   BusinessDay.is_quarter_start()


pandas.tseries.offsets.BusinessDay.is_year_end   BusinessDay.is_year_end()


pandas.tseries.offsets.BusinessDay.is_year_start   BusinessDay.is_year_start()


pandas.tseries.offsets.BusinessDay.isAnchored   BusinessDay.isAnchored()


pandas.tseries.offsets.BusinessDay.kwds   BusinessDay.kwds


pandas.tseries.offsets.BusinessDay.n   BusinessDay.n


pandas.tseries.offsets.BusinessDay.name   BusinessDay.name


pandas.tseries.offsets.BusinessDay.nanos   BusinessDay.nanos


pandas.tseries.offsets.BusinessDay.normalize   BusinessDay.normalize


pandas.tseries.offsets.BusinessDay.offset   BusinessDay.offset

Alias for self._offset.


pandas.tseries.offsets.BusinessDay.onOffset   BusinessDay.onOffset()


pandas.tseries.offsets.BusinessDay.rollback   BusinessDay.rollback()

Roll provided date backward to next offset only if not on offset.  Returns
 TimeStamp

Rolled timestamp if not on offset, otherwise unchanged timestamp.


pandas.tseries.offsets.BusinessDay.rollforward   BusinessDay.rollforward()

Roll provided date forward to next offset only if not on offset.  Returns
 TimeStamp

Rolled timestamp if not on offset, otherwise unchanged timestamp.


pandas.tseries.offsets.BusinessDay.rule_code   BusinessDay.rule_code


pandas.tseries.offsets.BusinessDay.weekmask   BusinessDay.weekmask


pandas.tseries.offsets.BusinessHour   classpandas.tseries.offsets.BusinessHour

DateOffset subclass representing possibly n business hours.  Parameters

n:int, default 1

The number of months represented.
normalize:bool, default False

Normalize start/end dates to midnight before generating date range.
weekmask:str, Default ‘Mon Tue Wed Thu Fri’

Weekmask of valid business days, passed to numpy.busdaycalendar.
start:str, default “09:00”

Start time of your custom business hour in 24h format.
end:str, default: “17:00”

End time of your custom business hour in 24h format.     Attributes
base Returns a copy of the calling offset object with n=1 and all other attributes equal.
next_bday Used for moving to next business day.
offset Alias for self._offset.
calendar
end
freqstr
holidays
kwds
n
name
nanos
normalize
rule_code
start
weekmask     Methods
__call__(*args, **kwargs) Call self as a function.
rollback(other) Roll provided date backward to next offset only if not on offset.
rollforward(other) Roll provided date forward to next offset only if not on offset.
apply
apply_index
copy
isAnchored
is_anchored
is_month_end
is_month_start
is_on_offset
is_quarter_end
is_quarter_start
is_year_end
is_year_start
onOffset


pandas.tseries.offsets.BusinessHour.__call__   BusinessHour.__call__(*args, **kwargs)

Call self as a function.


pandas.tseries.offsets.BusinessHour.apply   BusinessHour.apply()


pandas.tseries.offsets.BusinessHour.apply_index   BusinessHour.apply_index(other)


pandas.tseries.offsets.BusinessHour.base   BusinessHour.base

Returns a copy of the calling offset object with n=1 and all other attributes equal.


pandas.tseries.offsets.BusinessHour.calendar   BusinessHour.calendar


pandas.tseries.offsets.BusinessHour.copy   BusinessHour.copy()


pandas.tseries.offsets.BusinessHour.end   BusinessHour.end


pandas.tseries.offsets.BusinessHour.freqstr   BusinessHour.freqstr


pandas.tseries.offsets.BusinessHour.holidays   BusinessHour.holidays


pandas.tseries.offsets.BusinessHour.is_anchored   BusinessHour.is_anchored()


pandas.tseries.offsets.BusinessHour.is_month_end   BusinessHour.is_month_end()


pandas.tseries.offsets.BusinessHour.is_month_start   BusinessHour.is_month_start()


pandas.tseries.offsets.BusinessHour.is_on_offset   BusinessHour.is_on_offset()


pandas.tseries.offsets.BusinessHour.is_quarter_end   BusinessHour.is_quarter_end()


pandas.tseries.offsets.BusinessHour.is_quarter_start   BusinessHour.is_quarter_start()


pandas.tseries.offsets.BusinessHour.is_year_end   BusinessHour.is_year_end()


pandas.tseries.offsets.BusinessHour.is_year_start   BusinessHour.is_year_start()


pandas.tseries.offsets.BusinessHour.isAnchored   BusinessHour.isAnchored()


pandas.tseries.offsets.BusinessHour.kwds   BusinessHour.kwds


pandas.tseries.offsets.BusinessHour.n   BusinessHour.n


pandas.tseries.offsets.BusinessHour.name   BusinessHour.name


pandas.tseries.offsets.BusinessHour.nanos   BusinessHour.nanos


pandas.tseries.offsets.BusinessHour.next_bday   BusinessHour.next_bday

Used for moving to next business day.


pandas.tseries.offsets.BusinessHour.normalize   BusinessHour.normalize


pandas.tseries.offsets.BusinessHour.offset   BusinessHour.offset

Alias for self._offset.


pandas.tseries.offsets.BusinessHour.onOffset   BusinessHour.onOffset()


pandas.tseries.offsets.BusinessHour.rollback   BusinessHour.rollback(other)

Roll provided date backward to next offset only if not on offset.


pandas.tseries.offsets.BusinessHour.rollforward   BusinessHour.rollforward(other)

Roll provided date forward to next offset only if not on offset.


pandas.tseries.offsets.BusinessHour.rule_code   BusinessHour.rule_code


pandas.tseries.offsets.BusinessHour.start   BusinessHour.start


pandas.tseries.offsets.BusinessHour.weekmask   BusinessHour.weekmask


pandas.tseries.offsets.BusinessMonthBegin   classpandas.tseries.offsets.BusinessMonthBegin

DateOffset of one month at the first business day. Examples
>>> from pandas.tseries.offsets import BMonthBegin
>>> ts=pd.Timestamp('2020-05-24 05:01:15')
>>> ts + BMonthBegin()
Timestamp('2020-06-01 05:01:15')
>>> ts + BMonthBegin(2)
Timestamp('2020-07-01 05:01:15')
>>> ts + BMonthBegin(-3)
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
kwds
n
name
nanos
normalize
rule_code     Methods
__call__(*args, **kwargs) Call self as a function.
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
apply_index
copy
isAnchored
is_anchored
is_month_end
is_month_start
is_on_offset
is_quarter_end
is_quarter_start
is_year_end
is_year_start
onOffset


pandas.tseries.offsets.BusinessMonthBegin.__call__   BusinessMonthBegin.__call__(*args, **kwargs)

Call self as a function.


pandas.tseries.offsets.BusinessMonthBegin.apply   BusinessMonthBegin.apply()


pandas.tseries.offsets.BusinessMonthBegin.apply_index   BusinessMonthBegin.apply_index(other)


pandas.tseries.offsets.BusinessMonthBegin.base   BusinessMonthBegin.base

Returns a copy of the calling offset object with n=1 and all other attributes equal.


pandas.tseries.offsets.BusinessMonthBegin.copy   BusinessMonthBegin.copy()


pandas.tseries.offsets.BusinessMonthBegin.freqstr   BusinessMonthBegin.freqstr


pandas.tseries.offsets.BusinessMonthBegin.is_anchored   BusinessMonthBegin.is_anchored()


pandas.tseries.offsets.BusinessMonthBegin.is_month_end   BusinessMonthBegin.is_month_end()


pandas.tseries.offsets.BusinessMonthBegin.is_month_start   BusinessMonthBegin.is_month_start()


pandas.tseries.offsets.BusinessMonthBegin.is_on_offset   BusinessMonthBegin.is_on_offset()


pandas.tseries.offsets.BusinessMonthBegin.is_quarter_end   BusinessMonthBegin.is_quarter_end()


pandas.tseries.offsets.BusinessMonthBegin.is_quarter_start   BusinessMonthBegin.is_quarter_start()


pandas.tseries.offsets.BusinessMonthBegin.is_year_end   BusinessMonthBegin.is_year_end()


pandas.tseries.offsets.BusinessMonthBegin.is_year_start   BusinessMonthBegin.is_year_start()


pandas.tseries.offsets.BusinessMonthBegin.isAnchored   BusinessMonthBegin.isAnchored()


pandas.tseries.offsets.BusinessMonthBegin.kwds   BusinessMonthBegin.kwds


pandas.tseries.offsets.BusinessMonthBegin.n   BusinessMonthBegin.n


pandas.tseries.offsets.BusinessMonthBegin.name   BusinessMonthBegin.name


pandas.tseries.offsets.BusinessMonthBegin.nanos   BusinessMonthBegin.nanos


pandas.tseries.offsets.BusinessMonthBegin.normalize   BusinessMonthBegin.normalize


pandas.tseries.offsets.BusinessMonthBegin.onOffset   BusinessMonthBegin.onOffset()


pandas.tseries.offsets.BusinessMonthBegin.rollback   BusinessMonthBegin.rollback()

Roll provided date backward to next offset only if not on offset.  Returns
 TimeStamp

Rolled timestamp if not on offset, otherwise unchanged timestamp.


pandas.tseries.offsets.BusinessMonthBegin.rollforward   BusinessMonthBegin.rollforward()

Roll provided date forward to next offset only if not on offset.  Returns
 TimeStamp

Rolled timestamp if not on offset, otherwise unchanged timestamp.


pandas.tseries.offsets.BusinessMonthBegin.rule_code   BusinessMonthBegin.rule_code


pandas.tseries.offsets.BusinessMonthEnd   classpandas.tseries.offsets.BusinessMonthEnd

DateOffset increments between the last business day of the month. Examples
>>> from pandas.tseries.offsets import BMonthEnd
>>> ts = pd.Timestamp('2020-05-24 05:01:15')
>>> ts + BMonthEnd()
Timestamp('2020-05-29 05:01:15')
>>> ts + BMonthEnd(2)
Timestamp('2020-06-30 05:01:15')
>>> ts + BMonthEnd(-2)
Timestamp('2020-03-31 05:01:15')
  Attributes
base Returns a copy of the calling offset object with n=1 and all other attributes equal.
freqstr
kwds
n
name
nanos
normalize
rule_code     Methods
__call__(*args, **kwargs) Call self as a function.
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
apply_index
copy
isAnchored
is_anchored
is_month_end
is_month_start
is_on_offset
is_quarter_end
is_quarter_start
is_year_end
is_year_start
onOffset


pandas.tseries.offsets.BusinessMonthEnd.__call__   BusinessMonthEnd.__call__(*args, **kwargs)

Call self as a function.


pandas.tseries.offsets.BusinessMonthEnd.apply   BusinessMonthEnd.apply()


pandas.tseries.offsets.BusinessMonthEnd.apply_index   BusinessMonthEnd.apply_index(other)


pandas.tseries.offsets.BusinessMonthEnd.base   BusinessMonthEnd.base

Returns a copy of the calling offset object with n=1 and all other attributes equal.


pandas.tseries.offsets.BusinessMonthEnd.copy   BusinessMonthEnd.copy()


pandas.tseries.offsets.BusinessMonthEnd.freqstr   BusinessMonthEnd.freqstr


pandas.tseries.offsets.BusinessMonthEnd.is_anchored   BusinessMonthEnd.is_anchored()


pandas.tseries.offsets.BusinessMonthEnd.is_month_end   BusinessMonthEnd.is_month_end()


pandas.tseries.offsets.BusinessMonthEnd.is_month_start   BusinessMonthEnd.is_month_start()


pandas.tseries.offsets.BusinessMonthEnd.is_on_offset   BusinessMonthEnd.is_on_offset()


pandas.tseries.offsets.BusinessMonthEnd.is_quarter_end   BusinessMonthEnd.is_quarter_end()


pandas.tseries.offsets.BusinessMonthEnd.is_quarter_start   BusinessMonthEnd.is_quarter_start()


pandas.tseries.offsets.BusinessMonthEnd.is_year_end   BusinessMonthEnd.is_year_end()


pandas.tseries.offsets.BusinessMonthEnd.is_year_start   BusinessMonthEnd.is_year_start()


pandas.tseries.offsets.BusinessMonthEnd.isAnchored   BusinessMonthEnd.isAnchored()


pandas.tseries.offsets.BusinessMonthEnd.kwds   BusinessMonthEnd.kwds


pandas.tseries.offsets.BusinessMonthEnd.n   BusinessMonthEnd.n


pandas.tseries.offsets.BusinessMonthEnd.name   BusinessMonthEnd.name


pandas.tseries.offsets.BusinessMonthEnd.nanos   BusinessMonthEnd.nanos


pandas.tseries.offsets.BusinessMonthEnd.normalize   BusinessMonthEnd.normalize


pandas.tseries.offsets.BusinessMonthEnd.onOffset   BusinessMonthEnd.onOffset()


pandas.tseries.offsets.BusinessMonthEnd.rollback   BusinessMonthEnd.rollback()

Roll provided date backward to next offset only if not on offset.  Returns
 TimeStamp

Rolled timestamp if not on offset, otherwise unchanged timestamp.


pandas.tseries.offsets.BusinessMonthEnd.rollforward   BusinessMonthEnd.rollforward()

Roll provided date forward to next offset only if not on offset.  Returns
 TimeStamp

Rolled timestamp if not on offset, otherwise unchanged timestamp.


pandas.tseries.offsets.BusinessMonthEnd.rule_code   BusinessMonthEnd.rule_code


pandas.tseries.offsets.BYearBegin   classpandas.tseries.offsets.BYearBegin

DateOffset increments between the first business day of the year. Examples
>>> from pandas.tseries.offsets import BYearBegin
>>> ts = pd.Timestamp('2020-05-24 05:01:15')
>>> ts + BYearBegin()
Timestamp('2021-01-01 05:01:15')
>>> ts - BYearBegin()
Timestamp('2020-01-01 05:01:15')
>>> ts + BYearBegin(-1)
Timestamp('2020-01-01 05:01:15')
>>> ts + BYearBegin(2)
Timestamp('2022-01-03 05:01:15')
  Attributes
base Returns a copy of the calling offset object with n=1 and all other attributes equal.
freqstr
kwds
month
n
name
nanos
normalize
rule_code     Methods
__call__(*args, **kwargs) Call self as a function.
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
apply_index
copy
isAnchored
is_anchored
is_month_end
is_month_start
is_on_offset
is_quarter_end
is_quarter_start
is_year_end
is_year_start
onOffset


pandas.tseries.offsets.BYearBegin.__call__   BYearBegin.__call__(*args, **kwargs)

Call self as a function.


pandas.tseries.offsets.BYearBegin.apply   BYearBegin.apply()


pandas.tseries.offsets.BYearBegin.apply_index   BYearBegin.apply_index(other)


pandas.tseries.offsets.BYearBegin.base   BYearBegin.base

Returns a copy of the calling offset object with n=1 and all other attributes equal.


pandas.tseries.offsets.BYearBegin.copy   BYearBegin.copy()


pandas.tseries.offsets.BYearBegin.freqstr   BYearBegin.freqstr


pandas.tseries.offsets.BYearBegin.is_anchored   BYearBegin.is_anchored()


pandas.tseries.offsets.BYearBegin.is_month_end   BYearBegin.is_month_end()


pandas.tseries.offsets.BYearBegin.is_month_start   BYearBegin.is_month_start()


pandas.tseries.offsets.BYearBegin.is_on_offset   BYearBegin.is_on_offset()


pandas.tseries.offsets.BYearBegin.is_quarter_end   BYearBegin.is_quarter_end()


pandas.tseries.offsets.BYearBegin.is_quarter_start   BYearBegin.is_quarter_start()


pandas.tseries.offsets.BYearBegin.is_year_end   BYearBegin.is_year_end()


pandas.tseries.offsets.BYearBegin.is_year_start   BYearBegin.is_year_start()


pandas.tseries.offsets.BYearBegin.isAnchored   BYearBegin.isAnchored()


pandas.tseries.offsets.BYearBegin.kwds   BYearBegin.kwds


pandas.tseries.offsets.BYearBegin.month   BYearBegin.month


pandas.tseries.offsets.BYearBegin.n   BYearBegin.n


pandas.tseries.offsets.BYearBegin.name   BYearBegin.name


pandas.tseries.offsets.BYearBegin.nanos   BYearBegin.nanos


pandas.tseries.offsets.BYearBegin.normalize   BYearBegin.normalize


pandas.tseries.offsets.BYearBegin.onOffset   BYearBegin.onOffset()


pandas.tseries.offsets.BYearBegin.rollback   BYearBegin.rollback()

Roll provided date backward to next offset only if not on offset.  Returns
 TimeStamp

Rolled timestamp if not on offset, otherwise unchanged timestamp.


pandas.tseries.offsets.BYearBegin.rollforward   BYearBegin.rollforward()

Roll provided date forward to next offset only if not on offset.  Returns
 TimeStamp

Rolled timestamp if not on offset, otherwise unchanged timestamp.


pandas.tseries.offsets.BYearBegin.rule_code   BYearBegin.rule_code


pandas.tseries.offsets.BYearEnd   classpandas.tseries.offsets.BYearEnd

DateOffset increments between the last business day of the year. Examples
>>> from pandas.tseries.offsets import BYearEnd
>>> ts = pd.Timestamp('2020-05-24 05:01:15')
>>> ts - BYearEnd()
Timestamp('2019-12-31 05:01:15')
>>> ts + BYearEnd()
Timestamp('2020-12-31 05:01:15')
>>> ts + BYearEnd(3)
Timestamp('2022-12-30 05:01:15')
>>> ts + BYearEnd(-3)
Timestamp('2017-12-29 05:01:15')
>>> ts + BYearEnd(month=11)
Timestamp('2020-11-30 05:01:15')
  Attributes
base Returns a copy of the calling offset object with n=1 and all other attributes equal.
freqstr
kwds
month
n
name
nanos
normalize
rule_code     Methods
__call__(*args, **kwargs) Call self as a function.
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
apply_index
copy
isAnchored
is_anchored
is_month_end
is_month_start
is_on_offset
is_quarter_end
is_quarter_start
is_year_end
is_year_start
onOffset


pandas.tseries.offsets.BYearEnd.__call__   BYearEnd.__call__(*args, **kwargs)

Call self as a function.


pandas.tseries.offsets.BYearEnd.apply   BYearEnd.apply()


pandas.tseries.offsets.BYearEnd.apply_index   BYearEnd.apply_index(other)


pandas.tseries.offsets.BYearEnd.base   BYearEnd.base

Returns a copy of the calling offset object with n=1 and all other attributes equal.


pandas.tseries.offsets.BYearEnd.copy   BYearEnd.copy()


pandas.tseries.offsets.BYearEnd.freqstr   BYearEnd.freqstr


pandas.tseries.offsets.BYearEnd.is_anchored   BYearEnd.is_anchored()


pandas.tseries.offsets.BYearEnd.is_month_end   BYearEnd.is_month_end()


pandas.tseries.offsets.BYearEnd.is_month_start   BYearEnd.is_month_start()


pandas.tseries.offsets.BYearEnd.is_on_offset   BYearEnd.is_on_offset()


pandas.tseries.offsets.BYearEnd.is_quarter_end   BYearEnd.is_quarter_end()


pandas.tseries.offsets.BYearEnd.is_quarter_start   BYearEnd.is_quarter_start()


pandas.tseries.offsets.BYearEnd.is_year_end   BYearEnd.is_year_end()


pandas.tseries.offsets.BYearEnd.is_year_start   BYearEnd.is_year_start()


pandas.tseries.offsets.BYearEnd.isAnchored   BYearEnd.isAnchored()


pandas.tseries.offsets.BYearEnd.kwds   BYearEnd.kwds


pandas.tseries.offsets.BYearEnd.month   BYearEnd.month


pandas.tseries.offsets.BYearEnd.n   BYearEnd.n


pandas.tseries.offsets.BYearEnd.name   BYearEnd.name


pandas.tseries.offsets.BYearEnd.nanos   BYearEnd.nanos


pandas.tseries.offsets.BYearEnd.normalize   BYearEnd.normalize


pandas.tseries.offsets.BYearEnd.onOffset   BYearEnd.onOffset()


pandas.tseries.offsets.BYearEnd.rollback   BYearEnd.rollback()

Roll provided date backward to next offset only if not on offset.  Returns
 TimeStamp

Rolled timestamp if not on offset, otherwise unchanged timestamp.


pandas.tseries.offsets.BYearEnd.rollforward   BYearEnd.rollforward()

Roll provided date forward to next offset only if not on offset.  Returns
 TimeStamp

Rolled timestamp if not on offset, otherwise unchanged timestamp.


pandas.tseries.offsets.BYearEnd.rule_code   BYearEnd.rule_code


pandas.tseries.offsets.CBMonthBegin   pandas.tseries.offsets.CBMonthBegin

alias of pandas._libs.tslibs.offsets.CustomBusinessMonthBegin


pandas.tseries.offsets.CBMonthEnd   pandas.tseries.offsets.CBMonthEnd

alias of pandas._libs.tslibs.offsets.CustomBusinessMonthEnd


pandas.tseries.offsets.CDay   pandas.tseries.offsets.CDay

alias of pandas._libs.tslibs.offsets.CustomBusinessDay


pandas.tseries.offsets.CustomBusinessDay   classpandas.tseries.offsets.CustomBusinessDay

DateOffset subclass representing custom business days excluding holidays.  Parameters

n:int, default 1

normalize:bool, default False

Normalize start/end dates to midnight before generating date range.
weekmask:str, Default ‘Mon Tue Wed Thu Fri’

Weekmask of valid business days, passed to numpy.busdaycalendar.
holidays:list

List/array of dates to exclude from the set of valid business days, passed to numpy.busdaycalendar.
calendar:pd.HolidayCalendar or np.busdaycalendar

offset:timedelta, default timedelta(0)

   Attributes
base Returns a copy of the calling offset object with n=1 and all other attributes equal.
offset Alias for self._offset.
calendar
freqstr
holidays
kwds
n
name
nanos
normalize
rule_code
weekmask     Methods
__call__(*args, **kwargs) Call self as a function.
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
apply_index
copy
isAnchored
is_anchored
is_month_end
is_month_start
is_on_offset
is_quarter_end
is_quarter_start
is_year_end
is_year_start
onOffset


pandas.tseries.offsets.CustomBusinessDay.__call__   CustomBusinessDay.__call__(*args, **kwargs)

Call self as a function.


pandas.tseries.offsets.CustomBusinessDay.apply   CustomBusinessDay.apply()


pandas.tseries.offsets.CustomBusinessDay.apply_index   CustomBusinessDay.apply_index()


pandas.tseries.offsets.CustomBusinessDay.base   CustomBusinessDay.base

Returns a copy of the calling offset object with n=1 and all other attributes equal.


pandas.tseries.offsets.CustomBusinessDay.calendar   CustomBusinessDay.calendar


pandas.tseries.offsets.CustomBusinessDay.copy   CustomBusinessDay.copy()


pandas.tseries.offsets.CustomBusinessDay.freqstr   CustomBusinessDay.freqstr


pandas.tseries.offsets.CustomBusinessDay.holidays   CustomBusinessDay.holidays


pandas.tseries.offsets.CustomBusinessDay.is_anchored   CustomBusinessDay.is_anchored()


pandas.tseries.offsets.CustomBusinessDay.is_month_end   CustomBusinessDay.is_month_end()


pandas.tseries.offsets.CustomBusinessDay.is_month_start   CustomBusinessDay.is_month_start()


pandas.tseries.offsets.CustomBusinessDay.is_on_offset   CustomBusinessDay.is_on_offset()


pandas.tseries.offsets.CustomBusinessDay.is_quarter_end   CustomBusinessDay.is_quarter_end()


pandas.tseries.offsets.CustomBusinessDay.is_quarter_start   CustomBusinessDay.is_quarter_start()


pandas.tseries.offsets.CustomBusinessDay.is_year_end   CustomBusinessDay.is_year_end()


pandas.tseries.offsets.CustomBusinessDay.is_year_start   CustomBusinessDay.is_year_start()


pandas.tseries.offsets.CustomBusinessDay.isAnchored   CustomBusinessDay.isAnchored()


pandas.tseries.offsets.CustomBusinessDay.kwds   CustomBusinessDay.kwds


pandas.tseries.offsets.CustomBusinessDay.n   CustomBusinessDay.n


pandas.tseries.offsets.CustomBusinessDay.name   CustomBusinessDay.name


pandas.tseries.offsets.CustomBusinessDay.nanos   CustomBusinessDay.nanos


pandas.tseries.offsets.CustomBusinessDay.normalize   CustomBusinessDay.normalize


pandas.tseries.offsets.CustomBusinessDay.offset   CustomBusinessDay.offset

Alias for self._offset.


pandas.tseries.offsets.CustomBusinessDay.onOffset   CustomBusinessDay.onOffset()


pandas.tseries.offsets.CustomBusinessDay.rollback   CustomBusinessDay.rollback()

Roll provided date backward to next offset only if not on offset.  Returns
 TimeStamp

Rolled timestamp if not on offset, otherwise unchanged timestamp.


pandas.tseries.offsets.CustomBusinessDay.rollforward   CustomBusinessDay.rollforward()

Roll provided date forward to next offset only if not on offset.  Returns
 TimeStamp

Rolled timestamp if not on offset, otherwise unchanged timestamp.


pandas.tseries.offsets.CustomBusinessDay.rule_code   CustomBusinessDay.rule_code


pandas.tseries.offsets.CustomBusinessDay.weekmask   CustomBusinessDay.weekmask