두 날짜 사이의 월을 찾는 가장 좋은 방법

두 날짜 사이의 월을 찾는 가장 좋은 방법

저는 파이썬에서 두 날짜 사이의 월을 정확하게 찾을 수 있어야 합니다.저는 효과가 있는 솔루션을 가지고 있지만 (우아한 것처럼) 별로 좋지도 않고 빠르지도 않습니다.

dateRange = [datetime.strptime(dateRanges[0], "%Y-%m-%d"), datetime.strptime(dateRanges[1], "%Y-%m-%d")]
months = [] 

tmpTime = dateRange[0]
oneWeek = timedelta(weeks=1)
tmpTime = tmpTime.replace(day=1)
dateRange[0] = tmpTime
dateRange[1] = dateRange[1].replace(day=1)
lastMonth = tmpTime.month
months.append(tmpTime)
while tmpTime < dateRange[1]:
    if lastMonth != 12:
        while tmpTime.month <= lastMonth:
            tmpTime += oneWeek
        tmpTime = tmpTime.replace(day=1)
        months.append(tmpTime)
        lastMonth = tmpTime.month

    else:
        while tmpTime.month >= lastMonth:
            tmpTime += oneWeek
        tmpTime = tmpTime.replace(day=1)
        months.append(tmpTime)
        lastMonth = tmpTime.month

그래서 설명을 하자면, 제가 여기서 하고 있는 것은 두 개의 날짜를 가져와서 그것들을 iso 형식에서 python datetime 객체로 변환하는 것입니다.그런 다음 시작 날짜 시간 개체에 일주일을 추가하고 월의 숫자 값이 더 큰지 확인합니다(월이 12월이 아닌 경우 날짜가 더 작은지 확인합니다). 값이 더 크면 월 목록에 추가하고 종료 날짜에 도달할 때까지 계속 반복합니다.

완벽하게 작동합니다. 좋은 방법은 아닌 것 같습니다.

몇 가지 테스트 사례를 정의하는 것으로 시작하면 기능이 매우 단순하고 루프가 필요하지 않음을 알 수 있습니다.

from datetime import datetime

def diff_month(d1, d2):
    return (d1.year - d2.year) * 12 + d1.month - d2.month

assert diff_month(datetime(2010,10,1), datetime(2010,9,1)) == 1
assert diff_month(datetime(2010,10,1), datetime(2009,10,1)) == 12
assert diff_month(datetime(2010,10,1), datetime(2009,11,1)) == 11
assert diff_month(datetime(2010,10,1), datetime(2009,8,1)) == 14

잠재적인 코너 사례가 많기 때문에 질문에 테스트 사례를 추가해야 합니다. 두 날짜 사이의 월 수를 정의하는 방법은 여러 가지가 있습니다.

한 라이너가 두 날짜 사이의 날짜 시간 목록을 찾습니다.

import datetime
from dateutil.rrule import rrule, MONTHLY

strt_dt = datetime.date(2001,1,1)
end_dt = datetime.date(2005,6,1)

dates = [dt for dt in rrule(MONTHLY, dtstart=strt_dt, until=end_dt)]

내겐 효과가 있었어요

from datetime import datetime
from dateutil import relativedelta
date1 = datetime.strptime('2011-08-15 12:00:00', '%Y-%m-%d %H:%M:%S')
date2 = datetime.strptime('2012-02-15', '%Y-%m-%d')
r = relativedelta.relativedelta(date2, date1)
r.months + (12*r.years)

from dateutil import relativedelta

r = relativedelta.relativedelta(date1, date2)

months_difference = (r.years * 12) + r.months

dateutil 모듈의 rrule을 사용하여 쉽게 계산할 수 있습니다.

from dateutil import rrule
from datetime import date

print(list(rrule.rrule(rrule.MONTHLY, dtstart=date(2013, 11, 1), until=date(2014, 2, 1))))

다음을 제공합니다.

 [datetime.datetime(2013, 11, 1, 0, 0),
 datetime.datetime(2013, 12, 1, 0, 0),
 datetime.datetime(2014, 1, 1, 0, 0),
 datetime.datetime(2014, 2, 1, 0, 0)]

종료 월(시작 날짜가 2010년 10월에 시작하는 경우 2011년 1월 = 13)을 가져온 다음 시작 월과 종료 월을 시작하는 날짜 시간을 다음과 같이 생성합니다.

dt1, dt2 = dateRange
start_month=dt1.month
end_months=(dt2.year-dt1.year)*12 + dt2.month+1
dates=[datetime.datetime(year=yr, month=mn, day=1) for (yr, mn) in (
          ((m - 1) / 12 + dt1.year, (m - 1) % 12 + 1) for m in range(start_month, end_months)
      )]

두 날짜가 동일한 연도인 경우 다음과 같이 간단히 작성할 수도 있습니다.

dates=[datetime.datetime(year=dt1.year, month=mn, day=1) for mn in range(dt1.month, dt2.month + 1)]

이 포스트는 못을 박아요! 사용하세요.dateutil.relativedelta.

from datetime import datetime
from dateutil import relativedelta
date1 = datetime.strptime(str('2011-08-15 12:00:00'), '%Y-%m-%d %H:%M:%S')
date2 = datetime.strptime(str('2012-02-15'), '%Y-%m-%d')
r = relativedelta.relativedelta(date2, date1)
r.months

간단한 해결책:

import datetime

def months(d1, d2):
    return d1.month - d2.month + 12*(d1.year - d2.year)

d1 = datetime.datetime(2009, 9, 26)  
d2 = datetime.datetime(2019, 9, 26) 

print(months(d1, d2))

2018-04-20 업데이트: OP @Joshkunz는 "몇 개월"이 두 날짜 사이에 있는지 확인하는 대신 두 날짜 사이에 있는 달을 찾아달라고 요청한 것 같습니다.그래서 저는 왜 @JohnLaRooy가 100번 이상 투표를 하는지 잘 모르겠습니다.@Joshkunz는 원래 질문 아래 댓글에서 총 월 수를 찾는 대신 실제 날짜[또는 월]를 원한다고 표시했습니다.

그래서 두 데이트 사이에 질문이 필요한 것처럼 보였습니다.2018-04-112018-06-01

Apr 2018, May 2018, June 2018 

그리고 만약 그것이 사이라면?2014-04-112018-06-01그렇다면 답은

Apr 2014, May 2014, ..., Dec 2014, Jan 2015, ..., Jan 2018, ..., June 2018

그래서 저는 수년 전에 다음과 같은 유사 코드를 가지고 있었습니다.단지 두 달을 끝점으로 사용하고 반복하여 한 번에 한 달씩 증가하는 것을 제안했을 뿐입니다.@Joshkunz는 "월"을 원한다고 언급했고, "날짜"를 원한다고도 언급했습니다. 정확하게 알지 못하고 정확한 코드를 작성하는 것은 어려웠지만, 아이디어는 하나의 간단한 루프를 사용하여 끝점을 순환하고 한 번에 한 달씩 증가하는 것입니다.

8년 전인 2010년의 답은 다음과 같습니다.

일주일을 더하면 필요한 작업의 약 4.35배가 됩니다.왜 그냥:

1. get start date in array of integer, set it to i: [2008, 3, 12], 
       and change it to [2008, 3, 1]
2. get end date in array: [2010, 10, 26]
3. add the date to your result by parsing i
       increment the month in i
       if month is >= 13, then set it to 1, and increment the year by 1
   until either the year in i is > year in end_date, 
           or (year in i == year in end_date and month in i > month in end_date)

지금은 pseduo 코드만 테스트하지 않았지만, 같은 라인에 있는 아이디어가 효과가 있을 것이라고 생각합니다.

"월"을 /₁₂년으로 정의한 다음 다음을 수행합니다.

def month_diff(d1, d2): 
    """Return the number of months between d1 and d2, 
    such that d2 + month_diff(d1, d2) == d1
    """
    diff = (12 * d1.year + d1.month) - (12 * d2.year + d2.month)
    return diff

한 달을 "29일, 28일, 30일 또는 31일(연도에 따라)"로 정의할 수 있습니다.하지만 그렇게 하면, 해결해야 할 추가적인 문제가 있습니다.

일반적으로^th 6월 15일 + 1개월이^th 7월 15일이어야 한다는 것은 명확하지만, 1월^th 30일 + 1개월이 2월인지 3월인지는 일반적으로 명확하지 않습니다.후자의 경우에는 날짜를 2월^th 30일로 계산한 다음 3월^nd 2일로 "수정"해야 할 수 있습니다.하지만 그렇게 하면 3월^nd 2일 - 1개월이 분명히 2월^nd 2일이라는 것을 알게 될 것입니다.Ergo, reductio ad branusicum(이 작업은 잘 정의되지 않음).

Pandas FWIW로 이를 수행하는 방법은 다음과 같습니다.

import pandas as pd
pd.date_range("1990/04/03", "2014/12/31", freq="MS")

DatetimeIndex(['1990-05-01', '1990-06-01', '1990-07-01', '1990-08-01',
               '1990-09-01', '1990-10-01', '1990-11-01', '1990-12-01',
               '1991-01-01', '1991-02-01',
               ...
               '2014-03-01', '2014-04-01', '2014-05-01', '2014-06-01',
               '2014-07-01', '2014-08-01', '2014-09-01', '2014-10-01',
               '2014-11-01', '2014-12-01'],
              dtype='datetime64[ns]', length=296, freq='MS')

지정된 시작 날짜 이후의 달로 시작합니다.

많은 사람들이 이미 이 문제를 해결하기 위해 당신에게 좋은 답을 주었지만 나는 목록 이해를 사용하는 것을 전혀 읽지 않았기 때문에 유사한 사용 사례에 사용한 것을 당신에게 줍니다.

def compute_months(first_date, second_date):
    year1, month1, year2, month2 = map(
        int, 
        (first_date[:4], first_date[5:7], second_date[:4], second_date[5:7])
    )

    return [
        '{:0>4}-{:0>2}'.format(year, month)
        for year in range(year1, year2 + 1)
        for month in range(month1 if year == year1 else 1, month2 + 1 if year == year2 else 13)
    ]

>>> first_date = "2016-05"
>>> second_date = "2017-11"
>>> compute_months(first_date, second_date)
['2016-05',
 '2016-06',
 '2016-07',
 '2016-08',
 '2016-09',
 '2016-10',
 '2016-11',
 '2016-12',
 '2017-01',
 '2017-02',
 '2017-03',
 '2017-04',
 '2017-05',
 '2017-06',
 '2017-07',
 '2017-08',
 '2017-09',
 '2017-10',
 '2017-11']

모든 달이 30일인 360일을 기준으로 한 간단한 해결책이 있습니다.두 개의 날짜가 주어지면 전체 월 수와 남은 일 수를 계산해야 하는 대부분의 사용 사례에 적합합니다.

from datetime import datetime, timedelta

def months_between(start_date, end_date):
    #Add 1 day to end date to solve different last days of month 
    s1, e1 = start_date , end_date  + timedelta(days=1)
    #Convert to 360 days
    s360 = (s1.year * 12 + s1.month) * 30 + s1.day
    e360 = (e1.year * 12 + e1.month) * 30 + e1.day
    #Count days between the two 360 dates and return tuple (months, days)
    return divmod(e360 - s360, 30)

print "Counting full and half months"
print months_between( datetime(2012, 01, 1), datetime(2012, 03, 31)) #3m
print months_between( datetime(2012, 01, 1), datetime(2012, 03, 15)) #2m 15d
print months_between( datetime(2012, 01, 16), datetime(2012, 03, 31)) #2m 15d
print months_between( datetime(2012, 01, 16), datetime(2012, 03, 15)) #2m
print "Adding +1d and -1d to 31 day month"
print months_between( datetime(2011, 12, 01), datetime(2011, 12, 31)) #1m 0d
print months_between( datetime(2011, 12, 02), datetime(2011, 12, 31)) #-1d => 29d
print months_between( datetime(2011, 12, 01), datetime(2011, 12, 30)) #30d => 1m
print "Adding +1d and -1d to 29 day month"
print months_between( datetime(2012, 02, 01), datetime(2012, 02, 29)) #1m 0d
print months_between( datetime(2012, 02, 02), datetime(2012, 02, 29)) #-1d => 29d
print months_between( datetime(2012, 02, 01), datetime(2012, 02, 28)) #28d
print "Every month has 30 days - 26/M to 5/M+1 always counts 10 days"
print months_between( datetime(2011, 02, 26), datetime(2011, 03, 05))
print months_between( datetime(2012, 02, 26), datetime(2012, 03, 05))
print months_between( datetime(2012, 03, 26), datetime(2012, 04, 05))

@Vin-G의 약간 예쁜 해결책.

import datetime

def monthrange(start, finish):
  months = (finish.year - start.year) * 12 + finish.month + 1 
  for i in xrange(start.month, months):
    year  = (i - 1) / 12 + start.year 
    month = (i - 1) % 12 + 1
    yield datetime.date(year, month, 1)

화살표 라이브러리를 사용할 수도 있습니다.다음은 간단한 예입니다.

from datetime import datetime
import arrow

start = datetime(2014, 1, 17)
end = datetime(2014, 6, 20)

for d in arrow.Arrow.range('month', start, end):
    print d.month, d.format('MMMM')

인쇄할 내용:

1 January
2 February
3 March
4 April
5 May
6 June

이것이 도움이 되길 바랍니다!

두 날짜 사이의 일 수, 월 수 및 연도 차이를 확인합니다.

import datetime    
from dateutil.relativedelta import relativedelta


iphead_proc_dt = datetime.datetime.now()
new_date = iphead_proc_dt + relativedelta(months=+25, days=+23)

# Get Number of Days difference bewtween two dates
print((new_date - iphead_proc_dt).days)

difference = relativedelta(new_date, iphead_proc_dt)

# Get Number of Months difference bewtween two dates
print(difference.months + 12 * difference.years)

# Get Number of Years difference bewtween two dates
print(difference.years)

이런 거 해보세요.두 날짜가 같은 달일 경우 현재 월이 포함됩니다.

from datetime import datetime,timedelta

def months_between(start,end):
    months = []
    cursor = start

    while cursor <= end:
        if cursor.month not in months:
            months.append(cursor.month)
        cursor += timedelta(weeks=1)

    return months

출력은 다음과 같습니다.

>>> start = datetime.now() - timedelta(days=120)
>>> end = datetime.now()
>>> months_between(start,end)
[6, 7, 8, 9, 10]

python-dateutil을 사용할 수 있습니다.참고 항목: Python: 2개월 간의 데이트 시간 차이

은같과 range기능, 13살이 되면, 내년으로 갑니다.

def year_month_range(start_date, end_date):
    '''
    start_date: datetime.date(2015, 9, 1) or datetime.datetime
    end_date: datetime.date(2016, 3, 1) or datetime.datetime
    return: datetime.date list of 201509, 201510, 201511, 201512, 201601, 201602
    '''
    start, end = start_date.strftime('%Y%m'), end_date.strftime('%Y%m')
    assert len(start) == 6 and len(end) == 6
    start, end = int(start), int(end)

    year_month_list = []
    while start < end:
        year, month = divmod(start, 100)
        if month == 13:
            start += 88  # 201513 + 88 = 201601
            continue
        year_month_list.append(datetime.date(year, month, 1))

        start += 1
    return year_month_list

python 쉘의 예제

>>> import datetime
>>> s = datetime.date(2015,9,1)
>>> e = datetime.date(2016, 3, 1)
>>> year_month_set_range(s, e)
[datetime.date(2015, 11, 1), datetime.date(2015, 9, 1), datetime.date(2016, 1, 1), datetime.date(2016, 2, 1),
 datetime.date(2015, 12, 1), datetime.date(2015, 10, 1)]

weekday(~및 및 수 . monthrange는 평일(0-6 ~ Mon-Sun)을 반환합니다.
예를 들어, 월 범위(2017, 1)는 (6,31)을 반환합니다.

다음은 이 논리를 사용하여 두 달 동안 반복하는 스크립트입니다.

from datetime import timedelta
import datetime as dt
from calendar import monthrange

def month_iterator(start_month, end_month):
    start_month = dt.datetime.strptime(start_month,
                                   '%Y-%m-%d').date().replace(day=1)
    end_month = dt.datetime.strptime(end_month,
                                 '%Y-%m-%d').date().replace(day=1)
    while start_month <= end_month:
        yield start_month
        start_month = start_month + timedelta(days=monthrange(start_month.year, 
                                                         start_month.month)[1])

`

답이 만족스럽지 못한 것 같고 그 이후로 나는 이해하기 쉬운 나만의 코드를 사용했습니다.

from datetime import datetime
from dateutil import relativedelta

date1 = datetime.strptime(str('2017-01-01'), '%Y-%m-%d')
date2 = datetime.strptime(str('2019-03-19'), '%Y-%m-%d')

difference = relativedelta.relativedelta(date2, date1)
months = difference.months
years = difference.years
# add in the number of months (12) for difference in years
months += 12 * difference.years
months

from datetime import datetime
from dateutil import relativedelta

def get_months(d1, d2):
    date1 = datetime.strptime(str(d1), '%Y-%m-%d')
    date2 = datetime.strptime(str(d2), '%Y-%m-%d')
    print (date2, date1)
    r = relativedelta.relativedelta(date2, date1)
    months = r.months +  12 * r.years
    if r.days > 0:
        months += 1
    print (months)
    return  months


assert  get_months('2018-08-13','2019-06-19') == 11
assert  get_months('2018-01-01','2019-06-19') == 18
assert  get_months('2018-07-20','2019-06-19') == 11
assert  get_months('2018-07-18','2019-06-19') == 12
assert  get_months('2019-03-01','2019-06-19') == 4
assert  get_months('2019-03-20','2019-06-19') == 3
assert  get_months('2019-01-01','2019-06-19') == 6
assert  get_months('2018-09-09','2019-06-19') == 10

#This definition gives an array of months between two dates.
import datetime
def MonthsBetweenDates(BeginDate, EndDate):
    firstyearmonths = [mn for mn in range(BeginDate.month, 13)]<p>
    lastyearmonths = [mn for mn in range(1, EndDate.month+1)]<p>
    months = [mn for mn in range(1, 13)]<p>
    numberofyearsbetween = EndDate.year - BeginDate.year - 1<p>
    return firstyearmonths + months * numberofyearsbetween + lastyearmonths<p>

#example
BD = datetime.datetime.strptime("2000-35", '%Y-%j')
ED = datetime.datetime.strptime("2004-200", '%Y-%j')
MonthsBetweenDates(BD, ED)

일반적으로 90일은 문자 그대로 3개월이 아니라 참조일 뿐입니다.

따라서 마지막으로 날짜가 15일보다 큰지 확인해야 월 카운터에 +1을 추가할 수 있습니다.또는 반월 카운터가 있는 다른 엘프를 추가하는 것이 더 낫습니다.

이 다른 스택 오버플로 답변에서 저는 마침내 다음과 같이 끝냈습니다.

#/usr/bin/env python
# -*- coding: utf8 -*-

import datetime
from datetime import timedelta
from dateutil.relativedelta import relativedelta
import calendar

start_date = datetime.date.today()
end_date = start_date + timedelta(days=111)
start_month = calendar.month_abbr[int(start_date.strftime("%m"))]

print str(start_date) + " to " + str(end_date)

months = relativedelta(end_date, start_date).months
days = relativedelta(end_date, start_date).days

print months, "months", days, "days"

if days > 16:
    months += 1

print "around " + str(months) + " months", "(",

for i in range(0, months):
    print calendar.month_abbr[int(start_date.strftime("%m"))],
    start_date = start_date + relativedelta(months=1)

print ")"

출력:

2016-02-29 2016-06-14
3 months 16 days
around 4 months ( Feb Mar Apr May )

현재 연도에 남은 일수를 더하면 작동하지 않는다는 것을 알았고, 예상치 못한 일입니다.

이것이 제가 할 수 있는 그대로입니다.

Start_date = "2000-06-01"
End_date   = "2001-05-01"

month_num  = len(pd.date_range(start = Start_date[:7], end = End_date[:7] ,freq='M'))+1

저는 날짜 범위를 만들고 길이를 계산하는 데 월을 사용합니다.

이에 대한 제 솔루션은 다음과 같습니다.

def calc_age_months(from_date, to_date):
    from_date = time.strptime(from_date, "%Y-%m-%d")
    to_date = time.strptime(to_date, "%Y-%m-%d")

    age_in_months = (to_date.tm_year - from_date.tm_year)*12 + (to_date.tm_mon - from_date.tm_mon)

    if to_date.tm_mday < from_date.tm_mday:
        return age_in_months -1
    else
        return age_in_months

이는 2018년 12월 31일과 2019년 1월 1일 사이의 달 차이가 0인 일부 에지 사례도 처리합니다(차이가 하루에 불과하기 때문에).

upperDate가 항상 lowerDate보다 나중이고 둘 다 datetime.date 개체라고 가정합니다.

if lowerDate.year == upperDate.year:
    monthsInBetween = range( lowerDate.month + 1, upperDate.month )
elif upperDate.year > lowerDate.year:
    monthsInBetween = range( lowerDate.month + 1, 12 )
    for year in range( lowerDate.year + 1, upperDate.year ):
        monthsInBetween.extend( range(1,13) )
    monthsInBetween.extend( range( 1, upperDate.month ) )

저는 이것을 완전히 테스트하지는 않았지만, 효과가 있을 것으로 보입니다.

방법은 다음과 같습니다.

def months_between(start_dt, stop_dt):
    month_list = []
    total_months = 12*(stop_dt.year-start_dt.year)+(stop_dt.month-start_d.month)+1
    if total_months > 0:
        month_list=[ datetime.date(start_dt.year+int((start_dt+i-1)/12), 
                                   ((start_dt-1+i)%12)+1,
                                   1) for i in xrange(0,total_months) ]
    return month_list

먼저 두 날짜 사이의 총 월 수를 계산합니다.그런 다음 첫 번째 날짜를 기준으로 목록을 만들고 모듈식 산술을 수행하여 날짜 객체를 만듭니다.

사실 방금 비슷한 일을 해야 했습니다.

결국 다음을 나타내는 튜플 목록을 반환하는 함수를 작성했습니다.start그리고.end두 날짜 집합 사이의 매월 총 매출액 등에 대한 SQL 쿼리를 뒤에 작성할 수 있습니다.

자신들이 무엇을 하고 있는지 알고 있지만 도움이 되기를 바라는 누군가에 의해 개선될 수 있다고 확신합니다.

반환된 값은 다음과 같습니다(예: 오늘 - 오늘까지 365일 생성).

[   (datetime.date(2013, 5, 1), datetime.date(2013, 5, 31)),
    (datetime.date(2013, 6, 1), datetime.date(2013, 6, 30)),
    (datetime.date(2013, 7, 1), datetime.date(2013, 7, 31)),
    (datetime.date(2013, 8, 1), datetime.date(2013, 8, 31)),
    (datetime.date(2013, 9, 1), datetime.date(2013, 9, 30)),
    (datetime.date(2013, 10, 1), datetime.date(2013, 10, 31)),
    (datetime.date(2013, 11, 1), datetime.date(2013, 11, 30)),
    (datetime.date(2013, 12, 1), datetime.date(2013, 12, 31)),
    (datetime.date(2014, 1, 1), datetime.date(2014, 1, 31)),
    (datetime.date(2014, 2, 1), datetime.date(2014, 2, 28)),
    (datetime.date(2014, 3, 1), datetime.date(2014, 3, 31)),
    (datetime.date(2014, 4, 1), datetime.date(2014, 4, 30)),
    (datetime.date(2014, 5, 1), datetime.date(2014, 5, 31))]

다음과 같이 코드화합니다(삭제할 수 있는 디버그 정보가 있습니다).

#! /usr/env/python
import datetime

def gen_month_ranges(start_date=None, end_date=None, debug=False):
    today = datetime.date.today()
    if not start_date: start_date = datetime.datetime.strptime(
        "{0}/01/01".format(today.year),"%Y/%m/%d").date()  # start of this year
    if not end_date: end_date = today
    if debug: print("Start: {0} | End {1}".format(start_date, end_date))

    # sense-check
    if end_date < start_date:
        print("Error. Start Date of {0} is greater than End Date of {1}?!".format(start_date, end_date))
        return None

    date_ranges = []  # list of tuples (month_start, month_end)

    current_year = start_date.year
    current_month = start_date.month

    while current_year <= end_date.year:
        next_month = current_month + 1
        next_year = current_year
        if next_month > 12:
            next_month = 1
            next_year = current_year + 1

        month_start = datetime.datetime.strptime(
            "{0}/{1}/01".format(current_year,
                                current_month),"%Y/%m/%d").date()  # start of month
        month_end = datetime.datetime.strptime(
            "{0}/{1}/01".format(next_year,
                                next_month),"%Y/%m/%d").date()  # start of next month
        month_end  = month_end+datetime.timedelta(days=-1)  # start of next month less one day

        range_tuple = (month_start, month_end)
        if debug: print("Month runs from {0} --> {1}".format(
            range_tuple[0], range_tuple[1]))
        date_ranges.append(range_tuple)

        if current_month == 12:
            current_month = 1
            current_year += 1
            if debug: print("End of year encountered, resetting months")
        else:
            current_month += 1
            if debug: print("Next iteration for {0}-{1}".format(
                current_year, current_month))

        if current_year == end_date.year and current_month > end_date.month:
            if debug: print("Final month encountered. Terminating loop")
            break

    return date_ranges


if __name__ == '__main__':
    print("Running in standalone mode. Debug set to True")
    from pprint import pprint
    pprint(gen_month_ranges(debug=True), indent=4)
    pprint(gen_month_ranges(start_date=datetime.date.today()+datetime.timedelta(days=-365),
                            debug=True), indent=4)

만약 당신이 제가 날짜가 있었던 달의 "분수"를 알고 싶어한다고 가정한다면, 당신은 좀 더 많은 일을 해야 합니다.

from datetime import datetime, date
import calendar

def monthdiff(start_period, end_period, decimal_places = 2):
    if start_period > end_period:
        raise Exception('Start is after end')
    if start_period.year == end_period.year and start_period.month == end_period.month:
        days_in_month = calendar.monthrange(start_period.year, start_period.month)[1]
        days_to_charge = end_period.day - start_period.day+1
        diff = round(float(days_to_charge)/float(days_in_month), decimal_places)
        return diff
    months = 0
    # we have a start date within one month and not at the start, and an end date that is not
    # in the same month as the start date
    if start_period.day > 1:
        last_day_in_start_month = calendar.monthrange(start_period.year, start_period.month)[1]
        days_to_charge = last_day_in_start_month - start_period.day +1
        months = months + round(float(days_to_charge)/float(last_day_in_start_month), decimal_places)
        start_period = datetime(start_period.year, start_period.month+1, 1)

    last_day_in_last_month = calendar.monthrange(end_period.year, end_period.month)[1]
    if end_period.day != last_day_in_last_month:
        # we have lest days in the last month
        months = months + round(float(end_period.day) / float(last_day_in_last_month), decimal_places)
        last_day_in_previous_month = calendar.monthrange(end_period.year, end_period.month - 1)[1]
        end_period = datetime(end_period.year, end_period.month - 1, last_day_in_previous_month)

    #whatever happens, we now have a period of whole months to calculate the difference between

    if start_period != end_period:
        months = months + (end_period.year - start_period.year) * 12 + (end_period.month - start_period.month) + 1

    # just counter for any final decimal place manipulation
    diff = round(months, decimal_places)
    return diff

assert monthdiff(datetime(2015,1,1), datetime(2015,1,31)) == 1
assert monthdiff(datetime(2015,1,1), datetime(2015,02,01)) == 1.04
assert monthdiff(datetime(2014,1,1), datetime(2014,12,31)) == 12
assert monthdiff(datetime(2014,7,1), datetime(2015,06,30)) == 12
assert monthdiff(datetime(2015,1,10), datetime(2015,01,20)) == 0.35
assert monthdiff(datetime(2015,1,10), datetime(2015,02,20)) == 0.71 + 0.71
assert monthdiff(datetime(2015,1,31), datetime(2015,02,01)) == round(1.0/31.0,2) + round(1.0/28.0,2)
assert monthdiff(datetime(2013,1,31), datetime(2015,02,01)) == 12*2 + round(1.0/31.0,2) + round(1.0/28.0,2)

에는 날짜가 속한 각 월의 비율을 포함하여 두 날짜 사이의 월 수를 계산하는 예제가 나와 있습니다.즉, 2015-01-20에서 2015-02-14 사이의 달 수를 계산할 수 있습니다. 1월의 날짜 비율은 1월의 일 수에 따라 결정됩니다. 또는 2월의 일 수가 해마다 바뀔 수 있다는 점을 고려하여 계산할 수 있습니다.

참고로 이 코드는 github에도 있습니다 - https://gist.github.com/andrewyager/6b9284a4f1cdb1779b10

언급URL : https://stackoverflow.com/questions/4039879/best-way-to-find-the-months-between-two-dates