Period

class Period

Represents a period of time.

Example

import pandasCore as pd

# Create Period
obj = pd.Period(...)

Attributes

Attribute	Description	Example
day	Return the day of month (1-31)
day_of_week	Return the day of week (0=Monday, 6=Sunday)
day_of_year	Return the day of year (1-366)
dayofweek	Return the day of week (0=Monday, 6=Sunday)
dayofyear	Return the day of year (1-366)
days_in_month	Return the number of days in the current month
end_time	Return the end time of this period as a Timestamp	View
freq	Return the frequency string
freqstr	Return the frequency string	View
hour	Return the hour (0-23)
is_leap_year	Return True if the year is a leap year
minute	Return the minute (0-59)
month	Return the month (1-12)	View
ordinal	Return the ordinal value of this period	View
quarter	Return the quarter (1-4)	View
qyear	Return the fiscal year
second	Return the second (0-59)
start_time	Return the start time of this period as a Timestamp	View
week	Return the week of year (1-53)
weekofyear	Return the week of year (1-53)
year	Return the year this period belongs to	View

Construction

Method	Description	Example
__init__() (value: object = None, freq: object = None, ordinal: object = None, year: object = None, month: object = None, quarter: object = None, day: object = None, hour: object = None, minute: object = None, second: object = None)	Represents a period of time.	View

Arithmetic

Method	Description	Example
__add__() (arg0: typing.SupportsInt)
__sub__() (*args, **kwargs) | (arg0: typing.SupportsInt) | (arg0: pandasCore.Period)

Comparison

Method	Description	Example
__eq__() (arg0: object)
__ge__() (arg0: pandasCore.Period)
__gt__() (arg0: pandasCore.Period)
__le__() (arg0: pandasCore.Period)
__lt__() (arg0: pandasCore.Period)
__ne__() (arg0: object)

Time Series

Method	Description	Example
asfreq() (freq: str, how: str = 'E')	Convert Period to another frequency.	View
to_timestamp() (freq: object = None, how: str = 'start')	Return the Timestamp representation of this Period.	View

Datetime Methods

Method	Description	Example
strftime() (fmt: object)	Convert to a string representation using the specified format.	View

Other Methods

Method	Description	Example
__hash__() ()
__repr__() ()
__str__() ()
isnat() ()	Return True if the Period is NaT (Not a Time)

Code Examples

The following examples are extracted from the test suite.

end_time (test_period.py:240)

        else:
            f_print_error(f"Start timestamp year/month wrong")
            return False

        # Convert to timestamp (end)
        ts_end = p.to_timestamp(how='end')
        f_print_success(f"to_timestamp(how='end'): {ts_end}")

        # Check start_time and end_time properties
        f_print_info(f"start_time: {p.start_time}")
        f_print_info(f"end_time: {p.end_time}")

        return True

    except Exception as e:
        f_print_error(f"Exception: {e}")
        return False


def test_period_arithmetic():
    """Test Period arithmetic operations"""

freqstr (test_period.py:89)

            return False

        # Check quarter
        if p.quarter == 2:
            f_print_success(f"quarter is correct: {p.quarter}")
        else:
            f_print_error(f"quarter is wrong: {p.quarter}, expected 2")
            return False

        # Check freqstr
        if p.freqstr == 'M':
            f_print_success(f"freqstr is correct: {p.freqstr}")
        else:
            f_print_error(f"freqstr is wrong: {p.freqstr}, expected 'M'")
            return False

        # Test daily period with more properties
        p2 = pandasCore.Period('2020-06-15', 'D')
        f_print_info(f"Daily period: {p2}")
        f_print_info(f"  year={p2.year}, month={p2.month}, day={p2.day}")
        f_print_info(f"  dayofweek={p2.dayofweek}, dayofyear={p2.dayofyear}")

month (test_period.py:75)

        p = pandasCore.Period('2020-06', 'M')

        # Check year
        if p.year == 2020:
            f_print_success(f"year is correct: {p.year}")
        else:
            f_print_error(f"year is wrong: {p.year}, expected 2020")
            return False

        # Check month
        if p.month == 6:
            f_print_success(f"month is correct: {p.month}")
        else:
            f_print_error(f"month is wrong: {p.month}, expected 6")
            return False

        # Check quarter
        if p.quarter == 2:
            f_print_success(f"quarter is correct: {p.quarter}")
        else:
            f_print_error(f"quarter is wrong: {p.quarter}, expected 2")

ordinal (test_periodindex.py:118)

def test_shift():
    """Test shift method"""
    f_print_header("Test: shift")

    pi = pandasCore.PeriodIndex([0, 1, 2], freq="D")
    shifted = pi.shift(1)

    expected = [1, 2, 3]
    ctx.assert_list_equal(expected, [p.ordinal for p in shifted.tolist()], "shift by 1")

    shifted_neg = pi.shift(-1)
    expected_neg = [-1, 0, 1]
    ctx.assert_list_equal(expected_neg, [p.ordinal for p in shifted_neg.tolist()], "shift by -1")


def test_strftime():
    """Test strftime method"""
    f_print_header("Test: strftime")

quarter (test_period.py:82)

            return False

        # Check month
        if p.month == 6:
            f_print_success(f"month is correct: {p.month}")
        else:
            f_print_error(f"month is wrong: {p.month}, expected 6")
            return False

        # Check quarter
        if p.quarter == 2:
            f_print_success(f"quarter is correct: {p.quarter}")
        else:
            f_print_error(f"quarter is wrong: {p.quarter}, expected 2")
            return False

        # Check freqstr
        if p.freqstr == 'M':
            f_print_success(f"freqstr is correct: {p.freqstr}")
        else:
            f_print_error(f"freqstr is wrong: {p.freqstr}, expected 'M'")

start_time (test_period.py:239)

            f_print_success(f"Start timestamp year/month correct: {ts_start.year}-{ts_start.month}")
        else:
            f_print_error(f"Start timestamp year/month wrong")
            return False

        # Convert to timestamp (end)
        ts_end = p.to_timestamp(how='end')
        f_print_success(f"to_timestamp(how='end'): {ts_end}")

        # Check start_time and end_time properties
        f_print_info(f"start_time: {p.start_time}")
        f_print_info(f"end_time: {p.end_time}")

        return True

    except Exception as e:
        f_print_error(f"Exception: {e}")
        return False


def test_period_arithmetic():

year (test_period.py:68)

def test_period_properties():
    """Test Period component properties"""
    f_print_header("Test: Period Properties")

    try:
        # Test monthly period
        p = pandasCore.Period('2020-06', 'M')

        # Check year
        if p.year == 2020:
            f_print_success(f"year is correct: {p.year}")
        else:
            f_print_error(f"year is wrong: {p.year}, expected 2020")
            return False

        # Check month
        if p.month == 6:
            f_print_success(f"month is correct: {p.month}")
        else:
            f_print_error(f"month is wrong: {p.month}, expected 6")

__init__ (test_period.py:33)

import pandasCore
import pandas as pd


def test_period_construction():
    """Test Period construction from various inputs"""
    f_print_header("Test: Period Construction")

    try:
        # Test from period string and frequency
        p1 = pandasCore.Period('2020-01', 'M')
        f_print_success(f"Created Period from string: {p1}")

        # Test from ordinal and frequency
        p2 = pandasCore.Period(0, 'D')
        f_print_success(f"Created Period from ordinal: {p2}")

        # Test from year/month components
        p3 = pandasCore.Period(year=2020, month=6, day=15, freq='D')
        f_print_success(f"Created Period from components: {p3}")

asfreq (test_period.py:149)

def test_period_asfreq():
    """Test Period.asfreq() method"""
    f_print_header("Test: Period.asfreq()")

    try:
        # Create monthly period
        p = pandasCore.Period('2020-01', 'M')
        f_print_info(f"Original period: {p}")

        # Convert to daily frequency (end of month)
        p_day_end = p.asfreq('D', 'E')
        f_print_success(f"asfreq('D', 'E'): {p_day_end}")

        # The end of January 2020 should be day 31
        if p_day_end.day == 31:
            f_print_success(f"End of month day is correct: {p_day_end.day}")
        else:
            f_print_error(f"End of month day is wrong: {p_day_end.day}, expected 31")
            return False

        # Convert to daily frequency (start of month)

to_timestamp (test_period.py:224)

def test_period_to_timestamp():
    """Test Period.to_timestamp() method"""
    f_print_header("Test: Period.to_timestamp()")

    try:
        p = pandasCore.Period('2020-01', 'M')
        f_print_info(f"Original period: {p}")

        # Convert to timestamp (start)
        ts_start = p.to_timestamp(how='start')
        f_print_success(f"to_timestamp(how='start'): {ts_start}")

        # Verify year and month
        if ts_start.year == 2020 and ts_start.month == 1:
            f_print_success(f"Start timestamp year/month correct: {ts_start.year}-{ts_start.month}")
        else:
            f_print_error(f"Start timestamp year/month wrong")
            return False

        # Convert to timestamp (end)

strftime (test_period.py:189)

def test_period_strftime():
    """Test Period.strftime() method"""
    f_print_header("Test: Period.strftime()")

    try:
        p = pandasCore.Period('2020-06-15', 'D')

        # Test various format strings
        result1 = p.strftime('%Y-%m-%d')
        f_print_success(f"strftime('%Y-%m-%d'): {result1}")
        if result1 == '2020-06-15':
            f_print_success("Format '%Y-%m-%d' is correct")
        else:
            f_print_error(f"Format '%Y-%m-%d' is wrong: {result1}")
            return False

        result2 = p.strftime('%Y/%m')
        f_print_success(f"strftime('%Y/%m'): {result2}")
        if result2 == '2020/06':