Number of days between 2 dates, excluding weekends

How can I calculate number of days between two dates excluding weekends?

I think the cleanest solution is to use the numpy function busday_count

import numpy as np
import datetime as dt

start = dt.date( 2014, 1, 1 )
end = dt.date( 2014, 1, 16 )

days = np.busday_count( start, end )

>>> from datetime import date,timedelta
>>> fromdate = date(2010,1,1)
>>> todate = date(2010,3,31)
>>> daygenerator = (fromdate + timedelta(x + 1) for x in xrange((todate - fromdate).days))
>>> sum(1 for day in daygenerator if day.weekday() < 5)
63

This creates a generator using a generator expression which will yield the list of days to get from the fromdate to todate.

We could then create a list from the generator, filtering out weekends using the weekday() function, and the size of the list gives the number of days we want. However, to save having the whole list in memory which could be a problem if the dates are a long time apart we use another generator expression which filters out weekends but returns 1 instead of each date. We can then just add all these 1s together to get the length without having to store the whole list.

Note, if fromdate == todate this calculate 0 not 1.

First import numpy as np. The function np.busday_count counts the number of valid days between two dates, excluding the day of the end date.

If end date is earlier than the begin date, the count will be negative. For more on np.busday_count read the documentation here.

import numpy as np
np.busday_count('2018-04-10', '2018-04-11')

Note that the function accepts strings, it's not necessary to instantiate datetime objects before calling the function.

Also supports specific valid days and option to add holidays as well.

import numpy as np
np.busyday_count('2019-01-21','2020-03-28',weekmask=[1,1,1,1,1,0,0],holidays=['2020-01-01'])

weekmask format = [Mon,Tue,Wed.....Sat,Sun]

The answers given so far will work, but are highly inefficient if the dates are a large distance apart (due to the loop).

This should work:

import datetime

start = datetime.date(2010,1,1)
end = datetime.date(2010,3,31)

daydiff = end.weekday() - start.weekday()

days = ((end-start).days - daydiff) / 7 * 5 + min(daydiff,5) - (max(end.weekday() - 4, 0) % 5)

This turns it into whole weeks (which have 5 working days) and then deals with the remaining days.

The lazy way is to pip install workdays to get the python package that does exactly this.

https://pypi.python.org/pypi/workdays/

So far, I found none of the provided solutions satisfactory. Either there is a dependency to a lib I don't want or there are inefficient looping algorithms or there are algorithms that won't work for all cases. Unfortunately the one provided by @neil did not work sufficiently well. This was corrected by @vekerdyb's answer which unfortunately did not work for all cases, either (pick a Saturday or a Sunday on the same weekend for example...).
So I sat down and tried my best to come up with a solution that is working for all dates entered. It's small and efficient. Feel free to find errors in this one, as well, of course. Beginning and end are inclusive (so Monday-Tuesday in one week are 2 workdays for example).

def get_workdays(from_date: datetime, to_date: datetime):
    # if the start date is on a weekend, forward the date to next Monday
    if from_date.weekday() > 4:
        from_date = from_date + timedelta(days=7 - from_date.weekday())
    # if the end date is on a weekend, rewind the date to the previous Friday
    if to_date.weekday() > 4:
        to_date = to_date - timedelta(days=to_date.weekday() - 4)
    if from_date > to_date:
        return 0
    # that makes the difference easy, no remainders etc
    diff_days = (to_date - from_date).days + 1
    weeks = int(diff_days / 7)
    return weeks * 5 + (to_date.weekday() - from_date.weekday()) + 1

import datetime

# some givens
dateB = datetime.date(2010, 8, 31)
dateA = datetime.date(2010, 7, 8)
delta = datetime.timedelta(1)

# number of days
days = 0

while dateB != dateA:
    #subtract a day
    dateB -= delta

    # if not saturday or sunday, add to count
    if dateB.isoweekday() not in (6, 7):
        days += 1

I think something like that should work. I don't have the tools to test it right now.

Fixed Saturday to Sunday same weekend to function.

from __future__ import print_function
from datetime import date, timedelta

def workdaycount(startdate,enddate):
    if startdate.year != enddate.year:
        raise ValueError("Dates to workdaycount must be during same year")
    if startdate == enddate:
        return int(startdate.weekday() < 5)
    elif (enddate - startdate).days == 1 and enddate.weekday() == 6: # Saturday and Sunday same weekend
        return 0
    first_week_workdays = min(startdate.weekday(), 4) + 1
    last_week_workdays = min(enddate.weekday(), 4) + 1
    workweeks = int(enddate.strftime('%W')) - int(startdate.strftime('%W'))
    return (5 * workweeks)  + last_week_workdays - first_week_workdays + 1

for comment, start,end in (
     ("Two dates same weekend:", date(2010,9,18), date(2010,9,19)),
     ("Same dates during weekend:", date(2010,9,19), date(2010,9,19)),
     ("Same dates during week", date(2010,9,16), date(2010,9,16)),
     ("Dates during same week", date(2010,9,13), date(2010,9,16)),
     ("Dates during following weeks", date(2010,9,7), date(2010,9,16)),
     ("Dates after two weeks", date(2010,9,7), date(2010,9,24)),
     ("Dates from other solution", date(2010,1, 1), date(2010, 3,31))):
    
    daydiff = end.weekday() - start.weekday()
    days = ((end-start).days - daydiff) / 7 * 5 + min(daydiff,5)
    daygenerator = (start + timedelta(x + 1) for x in xrange((end - start).days))
    gendays = sum(day.weekday() < 5 for day in daygenerator)

    print(comment,start,end,workdaycount(start,end))
    print('Other formula:', days, '. Generator formula: ', gendays)

I adapted Dave Webb's answer into a function and added some test cases:

import datetime

def weekdays_between(start, end):
    return sum([1 for daydelta in xrange(1, (end - start).days + 1)
                if (start + datetime.timedelta(daydelta)).weekday() < 5])

assert 7 == weekdays_between(
    datetime.date(2014,2,19),
    datetime.date(2014,3,1))

assert 1 == weekdays_between(
    datetime.date(2014,2,19),
    datetime.date(2014,2,20))

assert 2 == weekdays_between(
    datetime.date(2014,2,19),
    datetime.date(2014,2,22))

assert 2 == weekdays_between(
    datetime.date(2014,2,19),
    datetime.date(2014,2,23))

assert 3 == weekdays_between(
    datetime.date(2014,2,19),
    datetime.date(2014,2,24))

assert 1 == weekdays_between(
    datetime.date(2014,2,21),
    datetime.date(2014,2,24))

assert 1 == weekdays_between(
    datetime.date(2014,2,22),
    datetime.date(2014,2,24))

assert 2 == weekdays_between(
    datetime.date(2014,2,23),
    datetime.date(2014,2,25))

Note that the @neil's (otherwise great) code will fail for Sunday-Thursday intervals. Here is a fix:

def working_days_in_range(from_date, to_date):
    from_weekday = from_date.weekday()
    to_weekday = to_date.weekday()
    # If start date is after Friday, modify it to Monday
    if from_weekday > 4:
        from_weekday = 0
    day_diff = to_weekday - from_weekday
    whole_weeks = ((to_date - from_date).days - day_diff) / 7
    workdays_in_whole_weeks = whole_weeks * 5
    beginning_end_correction = min(day_diff, 5) - (max(to_weekday - 4, 0) % 5)
    working_days = workdays_in_whole_weeks + beginning_end_correction
    # Final sanity check (i.e. if the entire range is weekends)
    return max(0, working_days)

You can use the following foolproof function to get the number of working days between any two given dates:

import datetime

def working_days(start_dt,end_dt):
    num_days = (end_dt -start_dt).days +1
    num_weeks =(num_days)//7
    a=0
    #condition 1
    if end_dt.strftime('%a')=='Sat':
        if start_dt.strftime('%a') != 'Sun':
            a= 1
    #condition 2
    if start_dt.strftime('%a')=='Sun':
        if end_dt.strftime('%a') !='Sat':
            a =1
    #condition 3
    if end_dt.strftime('%a')=='Sun':
        if start_dt.strftime('%a') not in ('Mon','Sun'):
            a =2
    #condition 4        
    if start_dt.weekday() not in (0,6):
        if (start_dt.weekday() -end_dt.weekday()) >=2:
            a =2
    working_days =num_days -(num_weeks*2)-a
    
    return working_days

Usage example:

start_dt = datetime.date(2019,6,5)
end_dt = datetime.date(2019,6,21)

working_days(start_dt,end_dt)

Here, both the start date and the end date is included, excluding all the weekends.
Hope this helps!!

Here's something I use for my management scripts, which takes into account holidays, regardless of which country you're in (uses a web service to pull in country-specific holiday data). Needs a bit of efficiency refactoring but besides that, it works.

from dateutil import rrule
from datetime import datetime
import pytz

timezone_manila = pytz.timezone('Asia/Manila')

class Holidays(object):
    
    def __init__(self, holidaydata):
        self.holidaydata = holidaydata
        
    def isHoliday(self,dateobj):
        for holiday in self.holidaydata:
            d = datetime(holiday['date']['year'], holiday['date']['month'], holiday['date']['day'], tzinfo=timezone_manila)            
            if d == dateobj:
                return True
        
        return False

def pullHolidays(start, end):
    import urllib.request, json
    urlstring = "https://kayaposoft.com/enrico/json/v2.0/?action=getHolidaysForDateRange&fromDate=%s&toDate=%s&country=phl&region=dc&holidayType=public_holiday" % (start.strftime("%d-%m-%Y"),end.strftime("%d-%m-%Y")) 
    
    with urllib.request.urlopen(urlstring) as url:
        holidaydata = json.loads(url.read().decode())
    
    return Holidays(holidaydata)


def countWorkDays(start, end):
    workdays=0
    holidayData=pullHolidays(start,end)
    for dt in rrule.rrule(rrule.DAILY, dtstart=start, until=end):
        if dt.weekday() < 5:
            if holidayData.isHoliday(dt) == False:
                workdays+=1
    
    return workdays

1. With using external service to get public holidays/extra work days

Can't thank @Renan enough for introducing this amazing API that I'm now using in my own project. Here's his answer with slight cleaning + tests.

import urllib.request
import json
from typing import Dict

from dateutil import rrule
from datetime import date


WEEKDAY_FRIDAY = 4  # date.weekday() starts with 0


class CountryCalendar(object):

    def __init__(self, special_dates: Dict[date, str]):
        self.special_dates = special_dates

    def is_working_day(self, dt: date):
        date_type = self.special_dates.get(dt)
        if date_type == "extra_working_day":
            return True
        if date_type == "public_holiday":
            return False
        return dt.weekday() <= WEEKDAY_FRIDAY


def load_calendar(
    country: str,
    region: str,
    start_date: date,
    end_date: date
) -> CountryCalendar:
    """
    Access Enrico Service 2.0 JSON
    https://kayaposoft.com/enrico/

    Response format (for country=rus):

    [
        {
            holidayType: "public_holiday",
            date: {
                day: 2,
                month: 1,
                year: 2022,
                dayOfWeek: 7
            },
            name: [
                {lang: "ru", text: "Новогодние каникулы"},
                {lang: "en", text: "New Year’s Holiday"}
            ]
        },
        ...
    ]
    """
    urlstring = (
        f"https://kayaposoft.com/enrico/json/v2.0/"
        f"?action=getHolidaysForDateRange"
        f"&fromDate={start_date:%d-%m-%Y}"
        f"&toDate={end_date:%d-%m-%Y}"
        f"&country={country}"
        f"&region={region}"
        f"&holidayType=all"
    )

    with urllib.request.urlopen(urlstring) as url:
        payload = json.loads(url.read().decode())

    return CountryCalendar({
        date(
            special_date["date"]["year"],
            special_date["date"]["month"],
            special_date["date"]["day"],
        ): special_date["holidayType"]
        for special_date in payload
    })


def count_work_days(
    start_date: date,
    end_date: date,
    country: str,
    region: str,
):
    """
    Get working days specific for country
    using public holidays internet provider
    """
    if start_date > end_date:
        return 0

    try:
        country_calendar = load_calendar(country, region, start_date, end_date)
    except Exception as exc:
        print(f"Error accessing calendar of country: {country}. Exception: {exc}")
        raise

    workdays = 0
    for dt in rrule.rrule(rrule.DAILY, dtstart=start_date, until=end_date):
        if country_calendar.is_working_day(dt):
            workdays += 1

    return workdays


def test(test_name: str, start_date: date, end_date: date, expected: int):
    print(f"Running: {test_name}... ", end="")
    params = dict(
        start_date=start_date,
        end_date=end_date,
        country="rus",
        region=""
    )
    assert expected == count_work_days(**params), dict(
        expected=expected,
        actual=count_work_days(**params),
        **params
    )
    print("ok")


# Start on Mon
test("Mon - Mon", date(2022, 4, 4), date(2022, 4, 4), 1)
test("Mon - Tue", date(2022, 4, 4), date(2022, 4, 5), 2)
test("Mon - Wed", date(2022, 4, 4), date(2022, 4, 6), 3)
test("Mon - Thu", date(2022, 4, 4), date(2022, 4, 7), 4)
test("Mon - Fri", date(2022, 4, 4), date(2022, 4, 8), 5)
test("Mon - Sut", date(2022, 4, 4), date(2022, 4, 9), 5)
test("Mon - Sun", date(2022, 4, 4), date(2022, 4, 10), 5)
test("Mon - next Mon", date(2022, 4, 4), date(2022, 4, 11), 6)
test("Mon - next Tue", date(2022, 4, 4), date(2022, 4, 12), 7)


# Start on Fri
test("Fri - Sut", date(2022, 4, 1), date(2022, 4, 2), 1)
test("Fri - Sun", date(2022, 4, 1), date(2022, 4, 3), 1)
test("Fri - Mon", date(2022, 4, 1), date(2022, 4, 4), 2)
test("Fri - Tue", date(2022, 4, 1), date(2022, 4, 5), 3)
test("Fri - Wed", date(2022, 4, 1), date(2022, 4, 6), 4)
test("Fri - Thu", date(2022, 4, 1), date(2022, 4, 7), 5)
test("Fri - next Fri", date(2022, 4, 1), date(2022, 4, 8), 6)
test("Fri - next Sut", date(2022, 4, 1), date(2022, 4, 9), 6)
test("Fri - next Sun", date(2022, 4, 1), date(2022, 4, 10), 6)
test("Fri - next Mon", date(2022, 4, 1), date(2022, 4, 11), 7)


# Some edge cases
test("start > end", date(2022, 4, 2), date(2022, 4, 1), 0)
test("Sut - Sun", date(2022, 4, 2), date(2022, 4, 3), 0)
test("Sut - Mon", date(2022, 4, 2), date(2022, 4, 4), 1)
test("Sut - Fri", date(2022, 4, 2), date(2022, 4, 8), 5)
test("Thu - Fri", date(2022, 3, 31), date(2022, 4, 8), 7)

2. Simple math: without usage of service for public holidays/extra work days

Even if @Sebastian answer can't be applied in many cases, as it's not considering public holidays and extra working days, I still find it great, as it's do the job without and decided to fix a bug (basically only his last line was changed).

from datetime import date, timedelta


WEEKDAY_FRIDAY = 4  # date.weekday() starts with 0


def count_work_days(start_date: date, end_date: date):
    """
    Math function to get workdays between 2 dates.
    Can be used only as fallback as it doesn't know
    about specific country holidays or extra working days.
    """
    # if the start date is on a weekend, forward the date to next Monday

    if start_date.weekday() > WEEKDAY_FRIDAY:
        start_date = start_date + timedelta(days=7 - start_date.weekday())

    # if the end date is on a weekend, rewind the date to the previous Friday
    if end_date.weekday() > WEEKDAY_FRIDAY:
        end_date = end_date - timedelta(days=end_date.weekday() - WEEKDAY_FRIDAY)

    if start_date > end_date:
        return 0
    # that makes the difference easy, no remainders etc
    diff_days = (end_date - start_date).days + 1
    weeks = int(diff_days / 7)

    remainder = end_date.weekday() - start_date.weekday() + 1

    if remainder != 0 and end_date.weekday() < start_date.weekday():
        remainder = 5 + remainder

    return weeks * 5 + remainder


def test(test_name: str, start_date: date, end_date: date, expected: int):
    print(f"Running: {test_name}... ", end="")
    params = dict(
        start_date=start_date,
        end_date=end_date,
    )
    assert expected == count_work_days(**params), dict(
        expected=expected,
        actual=count_work_days(**params),
        **params
    )
    print("ok")


# Start on Mon
test("Mon - Mon", date(2022, 4, 4), date(2022, 4, 4), 1)
test("Mon - Tue", date(2022, 4, 4), date(2022, 4, 5), 2)
test("Mon - Wed", date(2022, 4, 4), date(2022, 4, 6), 3)
test("Mon - Thu", date(2022, 4, 4), date(2022, 4, 7), 4)
test("Mon - Fri", date(2022, 4, 4), date(2022, 4, 8), 5)
test("Mon - Sut", date(2022, 4, 4), date(2022, 4, 9), 5)
test("Mon - Sun", date(2022, 4, 4), date(2022, 4, 10), 5)
test("Mon - next Mon", date(2022, 4, 4), date(2022, 4, 11), 6)
test("Mon - next Tue", date(2022, 4, 4), date(2022, 4, 12), 7)


# Start on Fri
test("Fri - Sut", date(2022, 4, 1), date(2022, 4, 2), 1)
test("Fri - Sun", date(2022, 4, 1), date(2022, 4, 3), 1)
test("Fri - Mon", date(2022, 4, 1), date(2022, 4, 4), 2)
test("Fri - Tue", date(2022, 4, 1), date(2022, 4, 5), 3)
test("Fri - Wed", date(2022, 4, 1), date(2022, 4, 6), 4)
test("Fri - Thu", date(2022, 4, 1), date(2022, 4, 7), 5)
test("Fri - next Fri", date(2022, 4, 1), date(2022, 4, 8), 6)
test("Fri - next Sut", date(2022, 4, 1), date(2022, 4, 9), 6)
test("Fri - next Sun", date(2022, 4, 1), date(2022, 4, 10), 6)
test("Fri - next Mon", date(2022, 4, 1), date(2022, 4, 11), 7)


# Some edge cases
test("start > end", date(2022, 4, 2), date(2022, 4, 1), 0)
test("Sut - Sun", date(2022, 4, 2), date(2022, 4, 3), 0)
test("Sut - Mon", date(2022, 4, 2), date(2022, 4, 4), 1)
test("Sut - Fri", date(2022, 4, 2), date(2022, 4, 8), 5)
test("Thu - Fri", date(2022, 3, 31), date(2022, 4, 8), 7)

I tried the top two answers (Dave Webb's and neil's) and for some reason I was getting incorrect answers from both. It might have been an error on my part but I went with an existing library on the basis that it probably had more functionality and was better tested for edge cases:

https://bitbucket.org/shelldweller/python-bizdatetime

This is a function that I implemented for measuring how many working days it takes for code to be integrated across branches. It does not need iterating over the whole intermediate days, as other solutions do, but only for the first week.

This problem can be broken down into two different problems:

1. Calculating the number of integral weeks in the interval: for an integral week, the number of weekend days is always 2. This is a trivial integer division: (todate - fromdate)/7

2. Calculating the number of weekend days in the remaining interval: this can be easily solved with the counting approach (map-reduce like): sum(map(is_weekend, rem_days)).

def count_working_days(fromdate, todate):
from datetime import timedelta as td
def is_weekend(d): return d.weekday() > 4



# 1st problem
num_weeks = (todate - fromdate).days/7

# 2nd problem
rem_days = (todate - fromdate).days%7
rem_weekend_days = sum(is_weekend(fromdate + td(days=i+1)) for i in range(rem_days))

return (todate - fromdate).days - 2*num_weeks - rem_weekend_days

And a sample of its working:

>>> for i in range(10): latency(datetime.now(), datetime.now() + timedelta(days=i))
...
0    1    1    1    2    3    4    5    6    6

Use this package called business-duration in PyPi.

Example Code:

from business_duration import businessDuration

import pandas as pd

import datetime

start = pd.to_datetime("2010-1-1 00:00:00")

end = pd.to_datetime("2010-3-31 00:00:00")

businessDuration(startdate=start,enddate=end,unit='day')

> Out[6]: 62.99927083333333

you may use https://pypi.org/project/python-networkdays/ The package has no dependencies, no NumPy or pandas to calculate a date. ;)

In [3]: import datetime

In [4]: from networkdays import networkdays

In [5]: HOLIDAYS  = { datetime.date(2020, 12, 25),}

In [6]: days = networkdays.Networkdays(datetime.date(2020, 12, 1),datetime.date(2020, 12, 31), holidays=HOLIDAYS, weekdaysoff={6,7})

In [7]: days.networkdays()
Out[7]:
[datetime.date(2020, 12, 1),
 datetime.date(2020, 12, 2),
 datetime.date(2020, 12, 3),
 datetime.date(2020, 12, 4),
 datetime.date(2020, 12, 7),
 datetime.date(2020, 12, 8),
 datetime.date(2020, 12, 9),
 datetime.date(2020, 12, 10),
 datetime.date(2020, 12, 11),
 datetime.date(2020, 12, 14),
 datetime.date(2020, 12, 15),
 datetime.date(2020, 12, 16),
 datetime.date(2020, 12, 17),
 datetime.date(2020, 12, 18),
 datetime.date(2020, 12, 21),
 datetime.date(2020, 12, 22),
 datetime.date(2020, 12, 23),
 datetime.date(2020, 12, 24),
 datetime.date(2020, 12, 28),
 datetime.date(2020, 12, 29),
 datetime.date(2020, 12, 30),
 datetime.date(2020, 12, 31)]

For Python 3; xrange() is only for Python 2. Based on the answer from Dave Webb and includes code to show the days including weekends

import datetime

start_date = datetime.date(2014, 1, 1)
end_date = datetime.date(2014, 1, 16)

delta_days = (end_date - start_date).days
delta_days # 13

day_generator = (start_date + datetime.timedelta(x + 1) for x in range((end_date - start_date).days))
delta_days = sum(1 for day in day_generator if day.weekday() < 5)
delta_days # 10

For those also wanting to exclude public holidays without manually specifying them, one can use the holidays package along with busday_count from numpy.

from datetime import date 

import numpy as np
import holidays

np.busday_count(
    begindates=date(2021, 1, 1),
    enddates=date(2021, 3, 20),
    holidays=list(
        holidays.US(state="CA", years=2021).keys()
    ),
)

My solution is also counting the last day. So if start and end are set to the same weekday then the asnwer will be 1 (eg 17th Oct both). If start and end are 2 consecutive weekdays then answer will be 2 (eg for 17th and 18th Oct). It counts the whole weeks (in each we will have 2 weekend days) and then check reminder days if they contain weekend days.

import datetime

def getWeekdaysNumber(start,end):
    numberOfDays = (end-start).days+1
    numberOfWeeks = numberOfDays // 7
    reminderDays = numberOfDays % 7
    numberOfDays -= numberOfWeeks *2
    if reminderDays:
        #this line is creating a set of weekdays for remainder days where 7 and 0 will be Saturday, 6 and -1 will be Sunday
        weekdays = set(range(end.isoweekday(), end.isoweekday() - reminderDays, -1))
        numberOfDays -= len(weekdays.intersection([7,6,0,-1])
    return numberOfDays 

usage example:

start = date(2018,10,10)
end = date (2018,10,17)
result = getWeekdaysNumber(start,end)`