반응형
두 날짜 사이의 달을 찾는 가장 좋은 방법
파이썬에서 두 날짜 사이의 달을 정확하게 찾을 수 있어야합니다. 나는 작동하지만 그다지 좋지 않거나 (우아하게) 빠르지 않은 해결책이 있습니다.
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 형식에서 파이썬 datetime 객체로 변환하는 것입니다. 그런 다음 시작 datetime 개체에 주를 추가하는 과정을 반복하고 월의 숫자 값이 더 큰지 확인합니다 (월이 12 월이 아니면 날짜가 더 적은지 확인합니다). 값이 더 크면 목록에 추가합니다. 종료 날짜에 도달 할 때까지 계속 반복합니다.
완벽하게 작동합니다. 좋은 방법이 아닌 것 같습니다.
업데이트 2018-04-20 : OP @Joshkunz가 두 날짜 사이에 "몇 개월"이 아니라 두 날짜 사이에 있는 달 을 찾는 것을 요청한 것 같습니다 . 그래서 @JohnLaRooy가 왜 100 번 이상 찬성표를 받았는지 모르겠습니다. @Joshkunz는 원래 질문의 주석에서 총 개월 수를 찾는 대신 실제 날짜 (또는 개월)를 원한다고 표시했습니다 .
그래서 두 날짜 사이 2018-04-11에2018-06-01
Apr 2018, May 2018, June 2018
그리고 사이 2014-04-11에 있다면 2018-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 코드로 테스트하지 않았지만 같은 줄의 아이디어가 작동 할 것이라고 생각합니다.
테스트 케이스를 정의하는 것으로 시작하면 함수가 매우 간단하고 루프가 필요하지 않음을 알 수 있습니다.
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 * (r.years+1)
종료 월을 가져온 다음 (시작 월의 연도 및 월과 관련하여 예 : 시작 날짜가 2010 년 10 월에 시작하는 경우 2011 년 1 월 = 13) 다음과 같이 시작 월과 종료 월을 시작하는 datetimes를 생성합니다.
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 모듈의 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)]
이 포스트는 그것을 잘한다! 사용 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
모든 달이 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
도움이 되었기를 바랍니다!
이런 식으로 시도하십시오. 두 날짜가 같은 달인 경우 현재 해당 월이 포함됩니다.
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 : 월별 두 날짜 시간의 차이 참조
내 간단한 해결책 :
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))
는 "달"로 정의 (1) / (12) 년 후이 작업을 수행을 :
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 일 (연도에 따라 다름)의 기간"으로 정의 할 수 있습니다. 하지만 그렇게하면 해결해야 할 추가 문제가 있습니다.
이 6월 15일 것이 일반적 분명하지만 일 + 1 개월 7월 15일해야 일 1월 30일 경우, 보통 명확하지 않다 일 + 1개월 월 3 월입니다. 후자의 경우, 당신은 2 월 30 일로 날짜를 계산하도록 강요 할 수있다 일 년 3 월 2 다음 "올바른"을 차 . 당신이 그렇게 할 때, 당신 월 2 것을 찾을 수 있습니다 차 1 개월 명확 년 2 월 2 - 차 . Ergo, reductio ad absurdum (이 작업은 잘 정의되어 있지 않습니다).
datetime.timedelta를 사용하여 수행 할 수 있으며 다음 달로 건너 뛸 일 수는 calender.monthrange에서 얻을 수 있습니다. monthrange는 주어진 연도 및 월의 요일 (0-6 ~ 월-일) 및 일 수 (28-31)를 반환합니다.
예 : monthrange (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])
`
#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)
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
파이썬 셸의 예
>>> 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)]
일반적으로 90 일은 말 그대로 3 개월이 아니라 단지 참조 일뿐입니다.
따라서 마지막으로 월 카운터에 +1을 추가하려면 일이 15보다 큰지 확인해야합니다. 또는 더 나은, 반달 카운터로 다른 elif를 추가하십시오.
에서 이 다른 유래 응답 내가 마침내 끝났다했습니다 :
#/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 )
올해 남은 일수 이상을 추가하면 작동하지 않는 것으로 나타 났으며 이는 예상치 못한 일입니다.
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')
주어진 시작일 다음 달 부터 시작됩니다.
답변이 불만족스럽고 이해하기 쉬운 자체 코드를 사용했습니다.
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
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
이 시도:
dateRange = [datetime.strptime(dateRanges[0], "%Y-%m-%d"),
datetime.strptime(dateRanges[1], "%Y-%m-%d")]
delta_time = max(dateRange) - min(dateRange)
#Need to use min(dateRange).month to account for different length month
#Note that timedelta returns a number of days
delta_datetime = (datetime(1, min(dateRange).month, 1) + delta_time -
timedelta(days=1)) #min y/m/d are 1
months = ((delta_datetime.year - 1) * 12 + delta_datetime.month -
min(dateRange).month)
print months
날짜를 입력하는 순서는 중요하지 않으며 월 길이의 차이를 고려합니다.
이것은 작동합니다 ...
from datetime import datetime as dt
from dateutil.relativedelta import relativedelta
def number_of_months(d1, d2):
months = 0
r = relativedelta(d1,d2)
if r.years==0:
months = r.months
if r.years>=1:
months = 12*r.years+r.months
return months
#example
number_of_months(dt(2017,9,1),dt(2016,8,1))
from datetime import datetime
def diff_month(start_date,end_date):
qty_month = ((end_date.year - start_date.year) * 12) + (end_date.month - start_date.month)
d_days = end_date.day - start_date.day
if d_days >= 0:
adjust = 0
else:
adjust = -1
qty_month += adjust
return qty_month
diff_month(datetime.date.today(),datetime(2019,08,24))
#Examples:
#diff_month(datetime(2018,02,12),datetime(2019,08,24)) = 18
#diff_month(datetime(2018,02,12),datetime(2018,08,10)) = 5
이것은 내 방법입니다.
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
월을 사용하여 날짜 범위를 만들고 길이를 계산합니다.
Many people have already given you good answers to solve this but I have not read any using list comprehension so I give you what I used for a similar use case :
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']
참고URL : https://stackoverflow.com/questions/4039879/best-way-to-find-the-months-between-two-dates
반응형
'programing' 카테고리의 다른 글
| Java에서 두 날짜 사이의 일 차이? (0) | 2020.10.06 |
|---|---|
| 루비의 for 루프 구문 (0) | 2020.10.06 |
| git AuthorDate가 CommitDate와 다른 이유는 무엇입니까? (0) | 2020.10.05 |
| Swift의 Exhaustive Switch 문에 대한 Noop (0) | 2020.10.05 |
| 클라이언트 측 Javascript를 사용하여 DNS 조회 (호스트 이름에서 IP 주소로)를 수행 할 수 있습니까? (0) | 2020.10.05 |