Criando um intervalo de datas no Python

Quero criar uma lista de datas, começando com hoje e retornando um número arbitrário de dias, digamos, no meu exemplo, 100 dias. Existe uma maneira melhor de fazer isso do que isso?

import datetime

a = datetime.datetime.today()
numdays = 100
dateList = []
for x in range (0, numdays):
    dateList.append(a - datetime.timedelta(days = x))
print dateList

Marginalmente melhor ...

base = datetime.datetime.today()
date_list = [base - datetime.timedelta(days=x) for x in range(numdays)]

Pandas é ótimo para séries temporais em geral e tem suporte direto para períodos.

Por exemplo pd.date_range():

import pandas as pd
from datetime import datetime

datelist = pd.date_range(datetime.today(), periods=100).tolist()

Ele também tem muitas opções para facilitar a vida. Por exemplo, se você quisesse apenas dias da semana, você apenas trocaria bdate_range.

Consulte a documentação do período

Além disso, ele suporta totalmente fusos horários de pytz e pode abranger suavemente as mudanças de horário de verão da primavera / outono.

EDITAR por OP:

Se você precisar de datetime reais em python, em oposição aos carimbos de data e hora do Pandas:

import pandas as pd
from datetime import datetime

pd.date_range(end = datetime.today(), periods = 100).to_pydatetime().tolist()

#OR

pd.date_range(start="2018-09-09",end="2020-02-02")

Isso usa o parâmetro "end" para corresponder à pergunta original, mas se você quiser datas decrescentes:

pd.date_range(datetime.today(), periods=100).to_pydatetime().tolist()

Obtenha intervalo de datas entre a data inicial e final especificada (otimizado para complexidade de tempo e espaço):

import datetime

start = datetime.datetime.strptime("21-06-2014", "%d-%m-%Y")
end = datetime.datetime.strptime("07-07-2014", "%d-%m-%Y")
date_generated = [start + datetime.timedelta(days=x) for x in range(0, (end-start).days)]

for date in date_generated:
    print date.strftime("%d-%m-%Y")

Você pode escrever uma função geradora que retorna objetos de data a partir de hoje:

import datetime

def date_generator():
  from_date = datetime.datetime.today()
  while True:
    yield from_date
    from_date = from_date - datetime.timedelta(days=1)

Este gerador retorna datas a partir de hoje e voltando um dia de cada vez. Veja como tirar as 3 primeiras datas:

>>> import itertools
>>> dates = itertools.islice(date_generator(), 3)
>>> list(dates)
[datetime.datetime(2009, 6, 14, 19, 12, 21, 703890), datetime.datetime(2009, 6, 13, 19, 12, 21, 703890), datetime.datetime(2009, 6, 12, 19, 12, 21, 703890)]

A vantagem dessa abordagem sobre um loop ou compreensão da lista é que você pode voltar quantas vezes quiser.

Editar

Uma versão mais compacta usando uma expressão de gerador em vez de uma função:

date_generator = (datetime.datetime.today() - datetime.timedelta(days=i) for i in itertools.count())

Uso:

>>> dates = itertools.islice(date_generator, 3)
>>> list(dates)
[datetime.datetime(2009, 6, 15, 1, 32, 37, 286765), datetime.datetime(2009, 6, 14, 1, 32, 37, 286836), datetime.datetime(2009, 6, 13, 1, 32, 37, 286859)]

sim, reinvente a roda .... basta pesquisar no fórum e você terá algo como isto:

from dateutil import rrule
from datetime import datetime

list(rrule.rrule(rrule.DAILY,count=100,dtstart=datetime.now()))

Você também pode usar o ordinal do dia para simplificar:

def date_range(start_date, end_date):
    for ordinal in range(start_date.toordinal(), end_date.toordinal()):
        yield datetime.date.fromordinal(ordinal)

Ou, conforme sugerido nos comentários, você pode criar uma lista como esta:

date_range = [
    datetime.date.fromordinal(ordinal) 
    for ordinal in range(
        start_date.toordinal(),
        end_date.toordinal(),
    )
]

A partir do título desta pergunta, eu esperava encontrar algo como range(), que me permitisse especificar duas datas e criar uma lista com todas as datas intermediárias. Dessa forma, não é necessário calcular o número de dias entre essas duas datas, se não o soubermos de antemão.

Portanto, com o risco de ser um pouco fora de tópico, esse recurso faz o trabalho:

import datetime
start_date = datetime.date(2011, 01, 01)
end_date   = datetime.date(2014, 01, 01)

dates_2011_2013 = [ start_date + datetime.timedelta(n) for n in range(int ((end_date - start_date).days))]

Todos os créditos para esta resposta !

Aqui está uma resposta um pouco diferente, baseada na resposta de S.Lott, que fornece uma lista de datas entre duas datas starte end. No exemplo abaixo, do início de 2017 até hoje.

start = datetime.datetime(2017,1,1)
end = datetime.datetime.today()
daterange = [start + datetime.timedelta(days=x) for x in range(0, (end-start).days)]

Uma resposta tardia, eu sei, mas acabei de ter o mesmo problema e decidi que a função de alcance interno do Python estava um pouco ausente nesse aspecto, então substituí-a em um módulo utilitário meu.

from __builtin__ import range as _range
from datetime import datetime, timedelta

def range(*args):
    if len(args) != 3:
        return _range(*args)
    start, stop, step = args
    if start < stop:
        cmp = lambda a, b: a < b
        inc = lambda a: a + step
    else:
        cmp = lambda a, b: a > b
        inc = lambda a: a - step
    output = [start]
    while cmp(start, stop):
        start = inc(start)
        output.append(start)

    return output

print range(datetime(2011, 5, 1), datetime(2011, 10, 1), timedelta(days=30))

Com base nas respostas que escrevi para mim mesmo:

import datetime;
print [(datetime.date.today() - datetime.timedelta(days=x)).strftime('%Y-%m-%d') for x in range(-5, 0)]

Resultado:

['2017-12-11', '2017-12-10', '2017-12-09', '2017-12-08', '2017-12-07']

A diferença é que eu recebo o dateobjeto ' ', não o ' datetime.datetime'.

Se houver duas datas e você precisar do intervalo, tente

from dateutil import rrule, parser
date1 = '1995-01-01'
date2 = '1995-02-28'
datesx = list(rrule.rrule(rrule.DAILY, dtstart=parser.parse(date1), until=parser.parse(date2)))

Aqui está a essência que eu criei, a partir do meu próprio código, isso pode ajudar. (Eu sei que a pergunta é muito antiga, mas outros podem usá-la)

https://gist.github.com/2287345

(mesma coisa abaixo)

import datetime
from time import mktime

def convert_date_to_datetime(date_object):
    date_tuple = date_object.timetuple()
    date_timestamp = mktime(date_tuple)
    return datetime.datetime.fromtimestamp(date_timestamp)

def date_range(how_many=7):
    for x in range(0, how_many):
        some_date = datetime.datetime.today() - datetime.timedelta(days=x)
        some_datetime = convert_date_to_datetime(some_date.date())
        yield some_datetime

def pick_two_dates(how_many=7):
    a = b = convert_date_to_datetime(datetime.datetime.now().date())
    for each_date in date_range(how_many):
        b = a
        a = each_date
        if a == b:
            continue
        yield b, a

Aqui está uma lista de scripts bash para obter uma lista de dias da semana, este é o python 3. Modificado facilmente para qualquer que seja o int, no final, é o número de dias no passado que você deseja.

python -c "import sys,datetime; print('\n'.join([(datetime.datetime.today() - datetime.timedelta(days=x)).strftime(\"%Y/%m/%d\") for x in range(0,int(sys.argv[1])) if (datetime.datetime.today() - datetime.timedelta(days=x)).isoweekday()<6]))" 10

Aqui está uma variante para fornecer uma data de início (ou melhor, final)

python -c "import sys,datetime; print('\n'.join([(datetime.datetime.strptime(sys.argv[1],\"%Y/%m/%d\") - datetime.timedelta(days=x)).strftime(\"%Y/%m/%d \") for x in range(0,int(sys.argv[2])) if (datetime.datetime.today() - datetime.timedelta(days=x)).isoweekday()<6]))" 2015/12/30 10

Aqui está uma variante para datas de início e término arbitrárias. não que isso não seja muito eficiente, mas seja bom para inserir um loop for em um script bash:

python -c "import sys,datetime; print('\n'.join([(datetime.datetime.strptime(sys.argv[1],\"%Y/%m/%d\") + datetime.timedelta(days=x)).strftime(\"%Y/%m/%d\") for x in range(0,int((datetime.datetime.strptime(sys.argv[2], \"%Y/%m/%d\") - datetime.datetime.strptime(sys.argv[1], \"%Y/%m/%d\")).days)) if (datetime.datetime.strptime(sys.argv[1], \"%Y/%m/%d\") + datetime.timedelta(days=x)).isoweekday()<6]))" 2015/12/15 2015/12/30

Relacionado com Matplotlib

from matplotlib.dates import drange
import datetime

base = datetime.date.today()
end  = base + datetime.timedelta(days=100)
delta = datetime.timedelta(days=1)
l = drange(base, end, delta)

Sei que isso foi respondido, mas colocarei minha resposta para propósitos históricos e, como acho que é direta.

import numpy as np
import datetime as dt
listOfDates=[date for date in np.arange(firstDate,lastDate,dt.timedelta(days=x))]

Claro que não vai ganhar nada como código-golfe, mas acho que é elegante.

Outro exemplo que conta para frente ou para trás, a partir da resposta de Sandeep.

from datetime import date, datetime, timedelta
from typing import Sequence
def range_of_dates(start_of_range: date, end_of_range: date) -> Sequence[date]:

    if start_of_range <= end_of_range:
        return [
            start_of_range + timedelta(days=x)
            for x in range(0, (end_of_range - start_of_range).days + 1)
        ]
    return [
        start_of_range - timedelta(days=x)
        for x in range(0, (start_of_range - end_of_range).days + 1)
    ]

start_of_range = datetime.today().date()
end_of_range = start_of_range + timedelta(days=3)
date_range = range_of_dates(start_of_range, end_of_range)
print(date_range)

dá

[datetime.date(2019, 12, 20), datetime.date(2019, 12, 21), datetime.date(2019, 12, 22), datetime.date(2019, 12, 23)]

e

start_of_range = datetime.today().date()
end_of_range = start_of_range - timedelta(days=3)
date_range = range_of_dates(start_of_range, end_of_range)
print(date_range)

dá

[datetime.date(2019, 12, 20), datetime.date(2019, 12, 19), datetime.date(2019, 12, 18), datetime.date(2019, 12, 17)]

Observe que a data de início está incluída no retorno; portanto, se você quiser quatro datas no total, use timedelta(days=3)

from datetime import datetime, timedelta
from dateutil import parser
def getDateRange(begin, end):
    """  """
    beginDate = parser.parse(begin)
    endDate =  parser.parse(end)
    delta = endDate-beginDate
    numdays = delta.days + 1
    dayList = [datetime.strftime(beginDate + timedelta(days=x), '%Y%m%d') for x in range(0, numdays)]
    return dayList

Um gerador de período mensal com datetimee dateutil. Simples e fácil de se entender:

import datetime as dt
from dateutil.relativedelta import relativedelta

def month_range(start_date, n_months):
        for m in range(n_months):
            yield start_date + relativedelta(months=+m)

import datetime    
def date_generator():
    cur = base = datetime.date.today()
    end  = base + datetime.timedelta(days=100)
    delta = datetime.timedelta(days=1)
    while(end>base):
        base = base+delta
        print base

date_generator()

Das respostas acima, criei este exemplo para o gerador de datas

import datetime
date = datetime.datetime.now()
time = date.time()
def date_generator(date, delta):
  counter =0
  date = date - datetime.timedelta(days=delta)
  while counter <= delta:
    yield date
    date = date + datetime.timedelta(days=1)
    counter +=1

for date in date_generator(date, 30):
   if date.date() != datetime.datetime.now().date():
     start_date = datetime.datetime.combine(date, datetime.time())
     end_date = datetime.datetime.combine(date, datetime.time.max)
   else:
     start_date = datetime.datetime.combine(date, datetime.time())
     end_date = datetime.datetime.combine(date, time)
   print('start_date---->',start_date,'end_date---->',end_date)