neulab/docprompting-conala huggingface dataset:
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.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.min   Timestamp.min=Timestamp('1677-09-21 00:12:43.145224193')
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.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')