兩個日期之間的天數，不包括周末

Question

如何計算不包括周末的兩個日期之間的天數？

Answer 1

我認為最干凈的解決方案是使用 numpy 函數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 )

Answer 2

>>> 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

這將使用生成器表達式創建一個生成器，該生成器將生成從fromdate到todate獲取的天數列表。

然后我們可以從生成器創建一個列表，使用weekday()函數過濾掉周末，列表的大小給出了我們想要的天數。 但是，為了將整個列表保存在內存中，如果日期相隔很長時間，這可能會成為問題，我們使用另一個生成器表達式來過濾周末但返回 1 而不是每個日期。 然后我們可以將所有這些 1 加在一起以獲得長度，而無需存儲整個列表。

請注意，如果fromdate == todate這將計算 0 而不是 1。

Answer 3

首先將numpy導入為np 。 函數np.busday_count計算兩個日期之間的有效天數，不包括結束日期的那一天。

如果結束日期早於開始日期，則計數將為負數。 有關np.busday_count的更多信息，請閱讀此處的文檔。

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

請注意，該函數接受字符串，無需在調用該函數之前實例化datetime對象。

還支持特定的有效日期和添加假期的選項。

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 格式 = [Mon,Tue,Wed....Sat,Sun]

Answer 4

懶惰的方法是pip install workdays來獲取執行此操作的 python 包。

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

Answer 5

到目前為止給出的答案將起作用，但如果日期相距很遠（由於循環），效率會非常低。

這應該有效：

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)

這會將其變成整周（有 5 個工作日），然后處理剩余的天數。

Answer 6

到目前為止，我發現沒有一個提供的解決方案令人滿意。 要么存在對我不想要的庫的依賴，要么存在低效的循環算法，或者存在不適用於所有情況的算法。 不幸的是，@neil 提供的那個不能很好地工作。 @vekerdyb 的回答糾正了這一點，不幸的是，這也不適用於所有情況（例如，在同一個周末選擇周六或周日......）。
所以我坐下來，盡力想出一個適用於所有輸入日期的解決方案。 它小巧高效。 當然，您也可以隨意發現其中的錯誤。 開始和結束都包括在內（例如，一周中的周一至周二是 2 個工作日）。

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

Answer 7

我將 Dave Webb 的答案改編成一個函數並添加了一些測試用例：

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))

Answer 8

請注意，@neil 的（否則很棒）代碼將在周日至周四的時間間隔內失敗。 這是一個修復：

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)

Answer 9

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

我認為這樣的事情應該有效。 我現在沒有工具來測試它。

Answer 10

固定周六至周日在同一周末運行。

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)

Answer 11

您可以使用以下萬無一失的功能來獲取任意兩個給定日期之間的工作日數：

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

使用示例：

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

working_days(start_dt,end_dt)

此處包括開始日期和結束日期，不包括所有周末。
希望這可以幫助！！

Answer 12

這是我用於管理腳本的東西，它考慮了假期，無論您在哪個國家/地區（使用 Web 服務來獲取特定於國家/地區的假期數據）。 需要一些效率重構，但除此之外，它還有效。

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

Answer 13

1. 使用外部服務獲得公共假期/額外工作日

非常感謝@Renan 介紹了我現在在我自己的項目中使用的這個令人驚嘆的 API。 這是他對輕微清潔+測試的回答。

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. 簡單數學：公共假期/額外工作日不使用服務

即使@Sebastian 的回答在很多情況下都不能應用，因為它沒有考慮公共假期和額外的工作日，我仍然覺得它很棒，因為它可以在沒有的情況下完成工作並決定修復一個錯誤（基本上只有他的最后一行是改變）。

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)

Answer 14

我嘗試了前兩個答案（Dave Webb 和 Neil 的），但由於某種原因，我從兩個答案中都得到了不正確的答案。 這可能是我的一個錯誤，但我選擇了一個現有的庫，因為它可能具有更多功能並且針對邊緣情況進行了更好的測試：

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

Answer 15

這是我實現的一個函數，用於測量跨分支集成代碼需要多少工作日。 它不需要像其他解決方案那樣在整個中間天進行迭代，而只需要在第一周進行。

這個問題可以分解成兩個不同的問題：

1. 計算區間內的整數周數：對於整數周，周末天數始終為 2。這是一個簡單的整數除法： (todate - fromdate)/7

2. 計算剩余間隔中的周末天數：這可以通過計數方法（類似map-reduce）輕松解決： 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

及其工作示例：

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

Answer 16

在 PyPi 中使用這個名為 business-duration 的包。

示例代碼：

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')

出[6]：62.99927083333333

Answer 17

您可以使用https://pypi.org/project/python-networkdays/包沒有依賴項，沒有 NumPy 或 pandas 來計算日期。 ;)

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)]

Answer 18

對於 Python 3； xrange() 僅適用於 Python 2。基於 Dave Webb 的回答，包括顯示包括周末在內的日期的代碼

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

Answer 19

對於那些還想在不手動指定公共假期的情況下排除公共holidays的人，可以使用 holiday 包和numpy中的busday_count包。

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()
    ),
)

Answer 20

如果您想要一個date ，距已知日期x工作日，您可以

import datetime
from pandas.tseries.offsets import BusinessDay
known_date = datetime.date(2022, 6, 7)
x = 7 # 7 business days away

date = known_date - 7 * BusinessDay() # Timestamp('2022-05-27 00:00:00')

如果你想要一系列日期

import pandas as pd
date_series  = pd.bdate_range(date, known_date) # DatetimeIndex(['2022-05-27', '2022-05-30', '2022-05-31', '2022-06-01','2022-06-02', '2022-06-03','2022-06-06', '2022-06-07'],dtype='datetime64[ns]', freq='B')

Answer 21

我想建議這個（我在 David Webb 的解決方案中修復了一個錯誤）給出了 64 而不是 63 天

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 [fromdate] + list(daygenerator) if day.weekday() < 5)

注意：我們必須在生成的日期頂部添加第一個日期 (fromdate)，以確保在排除周末時會考慮它

Answer 22

我的解決方案也是計算最后一天。 因此，如果 start 和 end 設置為同一工作日，則 asnwer 將為 1（例如 10 月 17 日）。 如果開始和結束是連續 2 個工作日，則答案將為 2（例如 10 月 17 日和 18 日）。 它計算整個星期（每個星期我們將有 2 個周末），然后檢查提醒天是否包含周末。

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 

用法示例：

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