# 5 Best Ways to Find Number of Times Every Day Occurs in a Year in Python

Rate this post

π‘ Problem Formulation: When working with dates in Python, one may need to determine how frequently each day of the week occurs in a given year. For example, knowing how many Mondays or Sundays are in the year 2023 is useful for planning and analysis. This article illustrates five methods of calculating the number of occurrences of each day of the week within a specific year using Python.

## Method 1: Using the Calendar Module and a For Loop

The Calendar module in Python provides various classes for manipulating dates and times. By iterating over each month and day of the week in a given year, we can count the occurrences of each day using the `calendar.weekday(year, month, day)` function. This method is straightforward but involves writing a loop which can be seen as verbose compared to other approaches.

Here’s an example:

```import calendar
from collections import defaultdict

def find_day_occurrences(year):
day_count = defaultdict(int)
for month in range(1, 13):
for day in range(1, 32):
try:
weekday = calendar.weekday(year, month, day)
day_count[weekday] += 1
except ValueError:
# This day does not exist in this month
continue
return day_count

day_occurrences = find_day_occurrences(2023)
print(day_occurrences)```

Output:

`defaultdict(<class 'int'>, {5: 53, 6: 52, 0: 52, 1: 52, 2: 52, 3: 52, 4: 52})`

This code snippet defines a function `find_day_occurrences()` which uses the `calendar.weekday()` method and a loop to iterate over each day of the year. This function returns a dictionary where the keys are the weekday numbers and the values are the counts of their occurrences. Since some months do not have 31 days, a try-except block is used to handle `ValueError` exceptions.

## Method 2: Using List Comprehensions and Calendar

List comprehensions in Python provide a concise way to create lists. When paired with the Calendar module, we can use them to create a list of all the weekdays for each day of a year and count their occurrences with a single line of code within a function. This method is streamlined and Pythonic, ideal for those who prefer functional programming paradigms.

Here’s an example:

```import calendar

def count_weekdays(year):
return [len([1 for i in range(1, 13) for day in range(1, 32) if calendar.monthrange(year, i)[1] >= day and calendar.weekday(year, i, day) == w]) for w in range(7)]

print(count_weekdays(2023))```

Output:

`[52, 52, 52, 52, 52, 53, 52]`

In this example, `count_weekdays()` is a function that uses list comprehensions and the `calendar.monthrange()` function to check the number of days in a month, paired with the `calendar.weekday()` function to match the day of the week. It then counts the occurrences for each weekday. The list comprehension constructs a list counting the occurrence of each weekday (from 0 to 6) within the given year.

## Method 3: Using the pandas Library

The pandas library, while primarily used for data manipulation and analysis, offers a convenient date range functionality. By generating a date range for the full year and extracting the day of the week, we can easily calculate the occurrences of each day using pandas’ grouping and counting capabilities.

Here’s an example:

```import pandas as pd

def day_occurrences_with_pandas(year):
date_range = pd.date_range(f'{year}-01-01', f'{year}-12-31')
days_of_week = date_range.dayofweek
return days_of_week.value_counts().sort_index()

print(day_occurrences_with_pandas(2023))```

Output:

```0    52
1    52
2    52
3    52
4    52
5    53
6    52
dtype: int64```

The function `day_occurrences_with_pandas()` creates a pandas date range from the start to the end of the given year. The `dayofweek` attribute is then used to determine the weekday of each date. This creates a series where the `value_counts()` method counts occurrences of each day, and `sort_index()` sorts them by the day of the week.

## Method 4: Using GroupBy and Resample in pandas

Another approach using pandas is to resample the date range by ‘D’ (day) and then use the `groupBy()` method with the `size()` function to count occurrences per day. This is a more advanced pandas technique suitable for those comfortable with time series analysis.

Here’s an example:

```import pandas as pd

def count_days_with_resample(year):
date_range = pd.date_range(start=f'{year}-01-01', periods=365 + calendar.isleap(year), freq='D')
day_counts = date_range.to_series().groupby(date_range.dayofweek).size()
return day_counts

print(count_days_with_resample(2023))```

Output:

```0    52
1    52
2    52
3    52
4    52
5    53
6    52
dtype: int64```

This function `count_days_with_resample()` uses pandas to create a date range, checking for leap years with `calendar.isleap()`. It then converts the date range to a pandas Series, groups by the `dayofweek`, and counts the occurrences using `size()`. The result is a pandas Series where the index represents the weekdays, and the values are the counts.

## Bonus One-Liner Method 5: Using datetime and Collections

In this one-liner approach, we combine Python’s built-in `datetime` library with the `collections.Counter` class to count the occurrences of each day in a year. While succinct, this method may not be as readable as the others to those unfamiliar with one-liners.

Here’s an example:

```from datetime import date, timedelta
from collections import Counter

def count_days_oneliner(year):
return Counter((date(year, 1, 1) + timedelta(days=i)).weekday() for i in range(365 + calendar.isleap(year)))

print(count_days_oneliner(2023))```

Output:

`Counter({5: 53, 0: 52, 1: 52, 2: 52, 3: 52, 4: 52, 6: 52})`

The `count_days_oneliner()` function uses a `for` comprehension within the `Counter` class to iterate through every day of the year, incrementing the date by one day using `timedelta`, and counting the occurrences of each weekday. This efficient line of code handles the logic of counting days without explicitly looping or using bulky constructs.

## Summary/Discussion

• Method 1: Using the Calendar Module and a For Loop. Strengths: Intuitive and uses built-in modules. Weaknesses: Somewhat verbose and less efficient.
• Method 2: Using List Comprehensions and Calendar. Strengths: Concise and Pythonic. Weaknesses: Can be difficult to read for non-pythonic programmers.
• Method 3: Using the pandas Library. Strengths: Utilizes powerful data manipulation tools, easy to understand. Weaknesses: Requires an external library that may not be installed by default.
• Method 4: Using GroupBy and Resample in pandas. Strengths: Good for time series analysis, powerful data grouping features. Weaknesses: More complex and requires understanding of pandas’ advanced features.
• Bonus Method 5: Using datetime and Collections. Strengths: Extremely concise one-liner. Weaknesses: Potentially harder to read and understand for beginners.