La création d'un éventail de dates en Python

Je veux créer une liste de dates, à partir d'aujourd'hui, et de revenir à un nombre arbitraire de jours, par exemple, dans mon exemple 100 jours. Est-il une meilleure façon de le faire que cela?

import datetime

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

InformationsquelleAutor Thomas Browne | 2009-06-14

416

Un peu mieux...
```
base = datetime.datetime.today()
date_list = [base - datetime.timedelta(days=x) for x in range(numdays)]
```
- Cela ne fonctionne pas si vous utilisez le fuseau horaire courant datetimes et il y a un changement d'heure d'été!!! Je veux dire, lorsque vous utilisez un début et une date de fin et le remplir au milieu de cette façon...
- ne pourriez-vous utiliser range(0, numdays) dans ce cas?
- J'ai utilisé cette méthode d'une manière légèrement différente, afin de générer des dix, intervalles de 5 minutes, +/- une certaine valeur(30 secondes dans mon cas). J'ai juste pensé que je vous ferais partager: datetimes = [start + timedelta(seconds=x*60+randint(-30, 30)) for x in range (0, range_end*5, 5)] où la variable range_end = 10
InformationsquelleAutor S.Lott
212

Pandas est grand pour le temps de la série en général, et a le soutien direct des plages de dates.

Par exemple mp.date_range():
```
import pandas as pd
datelist = pd.date_range(pd.datetime.today(), periods=100).tolist()
```
Il a aussi beaucoup d'options pour rendre la vie plus facile. Par exemple, si vous souhaitez uniquement les jours de la semaine, vous serait-il suffit de l'échanger dans bdate_range.

Voir la plage de dates de la documentation

En outre, il soutient pleinement pytz et fuseaux horaires peut en douceur durée de printemps/automne de l'heure d'été se déplace.

MODIFIER par l'OP:

Si vous avez besoin d'réelle python datetimes, par opposition aux Pandas horodateurs:
```
pd.date_range(end = pd.datetime.today(), periods = 100).to_pydatetime().tolist()
```
Il utilise le paramètre "fin" pour correspondre à la question d'origine, mais si vous voulez décroissant des dates:
```
pd.date_range(pd.datetime.today(), periods=100).to_pydatetime().tolist()
```
- Defo la meilleure réponse si pandas est déjà utilisé. La seule chose que je voudrais ajouter, c'est que vous utiliseriez la fin = paramètre si vos dates sont à reculons comme par le post original. pd.date_range(fin = pd.datetime.aujourd'hui(), les périodes = 100).tolist()
- Un seul problème avec cette méthode, c'est quand vous avez besoin de Python de type Datetime... à l'Aide des Pandas ou des numpy date éventail de méthodes permettra de créer de l'Horodatage et des Datetime64 types ... Vous avez besoin d' list(map(pd.Timestamp.to_pydatetime, datelist)) pour obtenir de type datetime de retour...
InformationsquelleAutor fantabolous
64

Obtenir la gamme de dates entre le début et date de fin (Optimisé pour le temps & espace de complexité):
```
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")
```
- Suggestion initiale est d'utiliser () au lieu de [] à obtenir un date_generator. Efficace en ce sens il n'y aura pas besoin de stocker l'ensemble de l'éventail de dates et de générer un uniquement lorsque cela est nécessaire.
- Remarque le end_date n'est pas généré.
- (fin-debut+1) pour obtenir la date de fin.
- Ne pas les réponses que l'OP est question, mais c'est ce que je recherchais 🙂
InformationsquelleAutor Sandeep

Vous pouvez écrire un générateur de fonction qui renvoie la date d'objets à partir d'aujourd'hui:

import datetime

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

Ce générateur renvoie la date à compter d'aujourd'hui et de revenir un jour à la fois. Voici comment faire pour prendre les 3 premières dates:

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

L'avantage de cette approche sur une boucle ou d'une compréhension de liste, c'est que vous pouvez revenir autant de fois que vous le souhaitez.

Modifier

Une version plus compacte à l'aide d'un générateur d'expression au lieu d'une fonction:

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

Utilisation:

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

Générateurs est le moyen idéal de le faire, si le nombre de jours est arbitraire.

InformationsquelleAutor Ayman Hourieh

Vous pouvez également utiliser le jour ordinale pour faire plus simple:

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

Ou, comme suggéré dans les commentaires, vous pouvez créer une liste comme ceci:

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

InformationsquelleAutor Hosane

28

ouais, réinventer la roue....
juste une recherche sur le forum, et vous obtiendrez quelque chose comme ceci:
```
from dateutil import rrule
from datetime import datetime

list(rrule.rrule(rrule.DAILY,count=100,dtstart=datetime.now()))
```
- Il faut labix.org/python-dateutil. L'air joli, mais à peine une dépendance externe juste pour sauver une seule ligne.
- Ne peux pas croire que quelqu'un les choses de l'autre les réponses sont très pythonic. Alors que rrule est un nom terrible, celui-ci est au moins facile sur les yeux.
- c'est très facile d'introduire des bogues subtils tandis que la période de mise en œuvre (calendrier) de l'arithmétique. dateutil.rrule implémente iCalendar RFC - il est plus facile à utiliser avec des fonctions bien définies comportement au lieu de plusieurs implémentations de près les mêmes fonctionnalités qui sont très légèrement différentes. dateutil.rrule permet de limiter correction d'un bug à un seul endroit.
- le nom n'est pas arbitraire; c'est à partir de le correspondant rfc
- Oui, je n'étais pas blâmer dateutil pour la malheureuse choix des noms 🙂
- Accordé en général, mais pour l'OP de l'objectif simple de sauter exactement les N jours, date + timedelta tel qu'utilisé dans la plupart des solutions sonne comme un bien défini pour l'exprimer. J'aimerais en apprendre d'un bug.
InformationsquelleAutor BOFH
15

Dans le titre de cette question, je m'attendais à trouver quelque chose comme range(), qui allait me permettre de spécifier deux dates et de créer une liste avec toutes les dates entre les deux. De cette manière, on n'a pas besoin de calculer le nombre de jours entre ces deux dates, si l'on ne sait pas à l'avance.

Donc, avec le risque d'être un peu hors-sujet, ce one-liner fait le travail:
```
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))]
```
Tous les crédits à cette réponse!
- Ce n'est pas un paquebot, pas plus que beaucoup d'autres réponses à la question.
- Je n'ai jamais prétendu que c'était plus un one-liner que les autres réponses, ni que c'était une meilleure solution. J'ai montré un morceau de code qui fait quelque chose de légèrement différent de ce que vous avez demandé, mais que j'aurais été heureux de trouver ici le titre de la question.
InformationsquelleAutor snake_charmer
10

Ici est un peu une réponse différente, en profitant de S. Lott de la réponse qui donne une liste de dates entre les deux dates start et end. Dans l'exemple ci-dessous, à partir du début de 2017 à aujourd'hui.
```
start = datetime.datetime(2017,1,1)
end = datetime.datetime.today()
daterange = [start + datetime.timedelta(days=x) for x in range(0, (end-start).days)]
```
InformationsquelleAutor Derek Powell

Un peu de retard de la réponse, je sais, mais j'ai juste eu le même problème et a décidé que Python interne de gamme de la fonction est un peu défaut à cet égard, j'ai donc remplacé dans une util module de la mine.

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

Je pense que vous voulez output = [] et de permuter les lignes dans le while cmp(...) boucle. Comparer range(0,10,1) et _range(0,10,1).
Je pense que cette réponse serait mieux si vous avez appelé la fonction date_range.

InformationsquelleAutor Rob Young

Si il y a deux dates et vous avez besoin de la gamme essayez

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

InformationsquelleAutor Nelu

Ici est essentiel que j'ai créé, à partir de mon propre code, ce qui pourrait aider. (Je sais que la question est trop vieux, mais d'autres peuvent l'utiliser)

https://gist.github.com/2287345

(même chose que ci-dessous)

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

InformationsquelleAutor roopesh

Basée sur les réponses que j'ai écrit pour moi-même:

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

De sortie:

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

La différence est que j'ai l' 'date' objet, non pas ladatetime.datetime' un.

InformationsquelleAutor wmlynarski

Voici un liner pour les scripts bash pour obtenir une liste des jours de la semaine, c'est python 3. Facilement modifié pour que ce soit, l'int à la fin est le nombre de jours dans le passé que vous voulez.

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

Ici est une variante de fournir un début (ou plutôt à la fin) date

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

Ici est une variante de l'arbitraire de début et dates de fin. non pas que ce n'est pas très efficace, mais qui est bon pour mettre dans une boucle for dans un 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

Pourriez voulez mettre à jour votre réponse post avec le code dans votre commentaire. Python obtient de déformation dans les commentaires, et un peu les besoins de la mise en forme.

InformationsquelleAutor Tim P

Matplotlib liées

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)

InformationsquelleAutor milton

2

Je sais que cela a été répondu, mais je vais le mettre en bas de ma réponse, pour des raisons historiques, et depuis je pense que c'est simple.
```
import numpy as np
import datetime as dt
listOfDates=[date for date in np.arange(firstDate,lastDate,dt.timedelta(days=x))]
```
Assurer qu'il ne sera pas gagner quoi que ce soit comme le code-golf, mais je pense que c'est élégant.
- Le arange avec les étapes est très gentil, mais listOfDates se compose de numpy datetime64 au lieu de python natif datetimes.
- Cependant, vous pouvez utiliser np.arange(…).astype(dt.datetime) de faire arange retour natif python datetime au lieu de numpy datetime64.
InformationsquelleAutor BarocliniCplusplus

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

InformationsquelleAutor xmduhan

Mensuel de la plage de dates générateur avec datetime et dateutil. Simple et facile à comprendre:

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)

InformationsquelleAutor aysa

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

Il voulait revenir en arrière, pas avant.. Si le end devrait être base - datetime.timedelta. D'ailleurs... Pourquoi est-ce une solution meilleure que l'original?

InformationsquelleAutor Sasmita

De réponses ci-dessus, j'ai créé cet exemple pour la date générateur

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)

InformationsquelleAutor Dimitris Kougioumtzis

Un autre exemple qui compte avant ou en arrière, à partir de Sandeep de réponse.

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)

donne

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

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)

donne

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

Noter que la date de départ est inclus dans le retour, donc si vous voulez un total de quatre dates, l'utilisation timedelta(days=3)

InformationsquelleAutor Chad Lowe

Vous devez vous connecter pour publier un commentaire.