Python generating a list of dates between two dates

Question

I want to generate a list of dates between two dates and store them in a list in string format. This list is useful to compare with other dates I have.

My code is given below:

from datetime import date, timedelta

sdate = date(2019,3,22)   # start date
edate = date(2019,4,9)   # end date

def dates_bwn_twodates(start_date, end_date):
    for n in range(int ((end_date - start_date).days)):
        yield start_date + timedelta(n)
print(dates_bwn_twodates(sdate,edate))

My present output:

<generator object dates_bwn_twodates at 0x000002A8E7929410>

My expected output:

['2019-03-22',.....,'2019-04-08']

Something wrong in my code.

Incult

Using yield means that your function will return a generator. If you want to run the generator to get all of the elements, you can do print(list(dates_bwn_twodates(sdate, edate))). – Couchant

@anky_91 I need advise. If I want to check if a date is in above list? how to compare with a list? – Incult

@Incult Is your goal to check if a date is between two other dates? If so, the list is unnecessary and there are simpler ways to accomplish that check – Affluence

@Affluence Yes! goal is having a list of dates in hand (stored in a list) and compare if a date is already in the list. I thought this is the only way. I appreciate any alternative solution. – Incult

@Incult for you last question you just deleted, this could be done: print(round(df["value"].min(), -2)) and print(round(df["value"].max(), -2) + 100) – Mob

@Mob it was not giving the correct value. I just tried it. – Incult

Answer 1

You can use pandas.date_range() for this:

import pandas
pandas.date_range(sdate,edate-timedelta(days=1),freq='d')

---

DatetimeIndex(['2019-03-22', '2019-03-23', '2019-03-24', '2019-03-25',
           '2019-03-26', '2019-03-27', '2019-03-28', '2019-03-29',
           '2019-03-30', '2019-03-31', '2019-04-01', '2019-04-02',
           '2019-04-03', '2019-04-04', '2019-04-05', '2019-04-06',
           '2019-04-07', '2019-04-08'],
          dtype='datetime64[ns]', freq='D')

Custos

@Custos If I want to get date list as ['20190322', '20190323',.......], what to do? Thankyou :-) – Hiccup

@RSJohn add .tolist() at the end – Custos

@Custos Actually I don't want the hyphen (-) in the date format. Sorry for the being less clear. – Hiccup

@RSJohn try .strftime('%Y%m%d').tolist() in the end then. Basically create the date format according to your need and then convert to list, docs here: pandas.pydata.org/pandas-docs/stable/reference/api/… – Custos

The only quip I have about this answer being marked as "right" is that it relies on Pandas, which is wholly unnecessary to solve the OP's question. You do not need the pandas data processing library to generate a list of dates between two dates. glenn15's and jagerber48's answers below don't rely on third-party libraries, and accomplish the same thing. – Blackandwhite

@Blackandwhite may be you didn't notice the tags this question was posted into. Pandas was clearly tagged. – Custos

Yep, you're right, I missed the tags! I was too busy looking at the actual code and was puzzled by the pandas answer – Blackandwhite

This is probably the most efficient way to solve date range calculation. – Blabbermouth

Answer 2

Your code rewritten as a list comprehension:

[sdate+timedelta(days=x) for x in range((edate-sdate).days)]

results:

[datetime.date(2019, 3, 22),
 datetime.date(2019, 3, 23),
 datetime.date(2019, 3, 24),
          :
 datetime.date(2019, 4, 7),
 datetime.date(2019, 4, 8)]

Confraternity

That's just sexy. Easy to adjust if you need the edate included in your list, like so: range(((edate + timedelta(days=1))-sdate).days). – Pebble

Very elegant, and relies only on the standard library. – Looker

Answer 3

I'm surprised this isn't a standard function in datetime package.

Here's a function that does what is requested:

from datetime import timedelta

def date_range_list(start_date, end_date):
    # Return list of datetime.date objects (inclusive) between start_date and end_date (inclusive).
    date_list = []
    curr_date = start_date
    while curr_date <= end_date:
        date_list.append(curr_date)
        curr_date += timedelta(days=1)
    return date_list

Usage:

from datetime import date, timedelta

def date_range_list(start_date, end_date):
    # Return list of datetime.date objects (inclusive) between start_date and end_date (inclusive).
    date_list = []
    curr_date = start_date
    while curr_date <= end_date:
        date_list.append(curr_date)
        curr_date += timedelta(days=1)
    return date_list

start_date = date(year=2021, month=12, day=20)
stop_date = date(year=2021, month=12, day=25)
date_list = date_range_list(start_date, stop_date)

date_list

Output:

[datetime.date(2021, 12, 20),
 datetime.date(2021, 12, 21),
 datetime.date(2021, 12, 22),
 datetime.date(2021, 12, 23),
 datetime.date(2021, 12, 24),
 datetime.date(2021, 12, 25)]

Update

While the above code is simple and easy to follow it would be better to give a generator to a list rather than the list itself. This way the entire datetime array doesn't need to be generated and stored into memory unless it needs to be. Here is how that approach would look:

from datetime import timedelta

def date_range_list(start_date, end_date):
    # Return generator for a list datetime.date objects (inclusive) between start_date and end_date (inclusive).
    curr_date = start_date
    while curr_date <= end_date:
        yield curr_date 
        curr_date += timedelta(days=1)

Usage:

from datetime import date, timedelta

def date_range_list(start_date, end_date):
    # Return generator for a list datetime.date objects (inclusive) between start_date and end_date (inclusive).
    curr_date = start_date
    while curr_date <= end_date:
        yield curr_date 
        curr_date += timedelta(days=1)

start_date = date(year=2021, month=12, day=20)
stop_date = date(year=2021, month=12, day=25)
date_list = date_range_list(start_date, stop_date)

for date in date_list:
   print(date)

Output:

2021-12-20
2021-12-21
2021-12-22
2021-12-23
2021-12-24
2021-12-25

Chud

Answer 4

from datetime import date, timedelta

sdate = date(2019,3,22)   # start date
edate = date(2019,4,9)   # end date
date_modified=sdate
list=[sdate] 


while date_modified<edate:
    date_modified+=timedelta(days=nbDaysbtw2dates) 
    list.append(date_modified)

print(list) 

Godred

Of course, need to specify nbDaysbtw2dates – Turbit

Answer 5

You'd need to turn it into a list with strings explicitly:

print([str(d) for d in dates_bwn_twodates(sdate,edate)])

Epiphysis

Answer 6

There is a much simpler approach and can be used by just modifying your code. It is as follows;

from datetime import datetime, timedelta
from datetime import date


def date_bwn_two_dates(start_date, end_date):
    date_list = [] # The list where we want to store
    for i in range(int((end_date-start_date).days)+1): # Iterate between the range of dates
        year = (start_date+timedelta(i)).strftime("%Y") # Get the Year
        month = (start_date+timedelta(i)).strftime("%m") # Get the month
        date_a = (start_date+timedelta(i)).strftime("%d") # Get the day
        date_list.append([year, month, date_a]) # Append the Objects accquired
    return date_list # return the list


for i in date_bwn_two_dates(date(2020, 12, 1), date(2021, 12, 1)):
    print(i)

Breeder

Answer 7

If you want the strings of the list of dates and not a just datetime index then It will also need to be formatted using strftime

from datetime import date, timedelta

def timer():
    global datelist
    sdate = date(2022, 5, 1)
    edate = date(2022, 6, 1)

    delta = edate - sdate       
    datetimes = []
    for i in range(delta.days + 1):
        day = sdate + timedelta(days=i)
        datetimes.append(day)


    def formatting():
        global converted
        converted = pd.to_datetime(datetimes)
        return converted

    datelist = converted.strftime("%Y-%m-%d").tolist()

    formatting()

Titustityus

Answer 8

Another simple way is to use numpy np.arange between 2 datetime objects.

from datetime import datetime, timedelta
import numpy as np

start_date = datetime.strptime("2023-06-10", "%Y-%m-%d")
end_date = start_date + timedelta(13)

fut_dates = np.arange(fut_start_date, fut_end_date, dtype="datetime64[D]")

fut_dates:

array(['2023-06-10', '2023-06-11', '2023-06-12', '2023-06-13',
       '2023-06-14', '2023-06-15', '2023-06-16', '2023-06-17',
       '2023-06-18', '2023-06-19', '2023-06-20', '2023-06-21',
       '2023-06-22'], dtype='datetime64[D]')

To convert to datetime.date objects:

fut_dates.astype(datetime)

array([datetime.date(2023, 6, 10), datetime.date(2023, 6, 11),
       datetime.date(2023, 6, 12), datetime.date(2023, 6, 13),
       datetime.date(2023, 6, 14), datetime.date(2023, 6, 15),
       datetime.date(2023, 6, 16), datetime.date(2023, 6, 17),
       datetime.date(2023, 6, 18), datetime.date(2023, 6, 19),
       datetime.date(2023, 6, 20), datetime.date(2023, 6, 21),
       datetime.date(2023, 6, 22)], dtype=object)

To output a list of strings you can do something like

[dt.strftime("%Y-%m-%d") for dt in pd.to_datetime(fut_dates)]

which returns

['2023-06-10',
 '2023-06-11',
 '2023-06-12',
 '2023-06-13',
 '2023-06-14',
 '2023-06-15',
 '2023-06-16',
 '2023-06-17',
 '2023-06-18',
 '2023-06-19',
 '2023-06-20',
 '2023-06-21',
 '2023-06-22']

Crinite

Answer 9

You can use the moment library from https://github.com/zachwill/moment.git to make your life easier.

import moment

def dates_bwn_twodates(start_date, end_date):
    diff = abs(start_date.diff(end_date).days)
    
    for n in range(0,diff+1):
        yield start_date.strftime("%Y-%m-%d")
        start_date = (start_date).add(days=1)

sdate = moment.date('2019-03-22')   #start date
edate = moment.date('2019-04-09')   #end date  

and then you have options

dates = list(dates_bwn_twodates(sdate,edate)) #dates as a list

or you can iterate

for date in dates_bwn_twodates(sdate,edate):
    #do something with each date

Feriga

Answer 10

A bit of an old question, but I thought I'd throw my suggestion in because some of these seem to over-complicate the answer:

from datetime import date, timedelta

#-- the actual method --#
def get_start_to_end(start_date, end_date):
    date_list = []
    for i in range(0, (end_date - start_date).days + 1):
        date_list.append(  str(start_date + timedelta(days=i))  ) #<-- here
    return date_list
#-- end of the actual method --#

# -- demonstrating it --#
sd = date(2022,8,12)
ed = date(2022,11,17)
dates = get_start_to_end(sd, ed)

for d in dates:
    print(d)

#-- You can just append the date object, the default string (iso)
#-- or use strftime for a different format
#-- (start_date + timedelta(days=i)) <-- date object
#-- str(start_date + timedelta(days=i))  <-- default string
#-- (start_date + timedelta(days=i)).strftime("%b %d, %Y") <-- other string format

Morion