Comment calculer la date à six mois de la date actuelle à l'aide du module datetime Python?

J'utilise le module Python datetime. Je cherche à calculer la date à 6 mois de la date actuelle. Quelqu'un pourrait-il m'aider un peu à faire cela?

La raison pour laquelle je souhaite générer une date à 6 mois de la date actuelle est de produire une date de révision . Si l'utilisateur entre des données dans le système, il aura une date de révision de 6 mois à compter de la date à laquelle il a entré les données.

J'ai trouvé cette solution bonne. (Ceci utilise l' extension python-dateutil )

from datetime import date
from dateutil.relativedelta import relativedelta

six_months = date.today() + relativedelta(months=+6)

L'avantage de cette approche est qu'elle prend en charge les problèmes avec 28, 30, 31 jours, etc. Cela devient très utile pour gérer les règles et les scénarios commerciaux (par exemple, la génération de factures, etc.)

$ date(2010,12,31)+relativedelta(months=+1)
  datetime.date(2011, 1, 31)

$ date(2010,12,31)+relativedelta(months=+2)
  datetime.date(2011, 2, 28)

Eh bien, cela dépend de ce que vous entendez par 6 mois à compter de la date actuelle.

1. Utilisation des mois naturels:

   (day, month, year) = (day, (month + 5) % 12 + 1, year + (month + 5)/12)

2. En utilisant la définition d'un banquier, 6 * 30:

   date += datetime.timedelta(6 * 30)

Avec Python 3.x, vous pouvez le faire comme ceci:

from datetime import datetime, timedelta
from dateutil.relativedelta import *

date = datetime.now()
print(date)
# 2018-09-24 13:24:04.007620

date = date + relativedelta(months=+6)
print(date)
# 2019-03-24 13:24:04.007620

mais vous devrez installer le module python-dateutil :

pip install python-dateutil

Pour le calcul du début de mois en mois:

from datetime import timedelta
from dateutil.relativedelta import relativedelta

end_date = start_date + relativedelta(months=delta_period) + timedelta(days=-delta_period)

Qu'entendez-vous par «6 mois»?

Est-ce que 2009-02-13 + 6 mois == 2009-08-13? Ou est-ce le 2009-02-13 + 6 * 30 jours?

import mx.DateTime as dt

#6 Months
dt.now()+dt.RelativeDateTime(months=6)
#result is '2009-08-13 16:28:00.84'

#6*30 days
dt.now()+dt.RelativeDateTime(days=30*6)
#result is '2009-08-12 16:30:03.35'

Plus d'informations sur mx.DateTime

Donc, voici un exemple de ce dateutil.relativedeltaque j'ai trouvé utile pour répéter l'année dernière, en sautant un mois à chaque fois jusqu'à la date actuelle:

>>> import datetime
>>> from dateutil.relativedelta import relativedelta
>>> today = datetime.datetime.today()
>>> month_count = 0
>>> while month_count < 12:
...  day = today - relativedelta(months=month_count)
...  print day
...  month_count += 1
... 
2010-07-07 10:51:45.187968
2010-06-07 10:51:45.187968
2010-05-07 10:51:45.187968
2010-04-07 10:51:45.187968
2010-03-07 10:51:45.187968
2010-02-07 10:51:45.187968
2010-01-07 10:51:45.187968
2009-12-07 10:51:45.187968
2009-11-07 10:51:45.187968
2009-10-07 10:51:45.187968
2009-09-07 10:51:45.187968
2009-08-07 10:51:45.187968

Comme pour les autres réponses, vous devez comprendre ce que vous entendez réellement par «6 mois à partir de maintenant». Si vous voulez dire «le jour du mois d'aujourd'hui dans le mois, six ans dans le futur», cela ferait:

datetime.datetime.now() + relativedelta(months=6)

Cette solution fonctionne correctement pour décembre, ce que la plupart des réponses sur cette page ne font pas. Vous devez d'abord déplacer les mois de la base 1 (ie Jan = 1) à la base 0 (ie Jan = 0) avant d'utiliser le module (%) ou la division entière (//), sinon novembre (11) plus 1 mois vous donne 12 , qui lors de la recherche du reste (12% 12) donne 0.

(Et ne suggérez pas "(mois% 12) + 1" ou oct + 1 = décembre!)

def AddMonths(d,x):
    newmonth = ((( d.month - 1) + x ) % 12 ) + 1
    newyear  = int(d.year + ((( d.month - 1) + x ) / 12 ))
    return datetime.date( newyear, newmonth, d.day)

Cependant ... Cela ne représente pas un problème comme le 31 janvier + un mois. Nous revenons donc à l'OP - que voulez-vous dire par l'ajout d'un mois? Une solution consiste à revenir en arrière jusqu'à ce que vous arriviez à un jour valide, étant donné que la plupart des gens supposent que le dernier jour de janvier, plus un mois, est égal au dernier jour de février. Cela fonctionnera également sur un nombre de mois négatif. Preuve:

>>> import datetime
>>> AddMonths(datetime.datetime(2010,8,25),1)
datetime.date(2010, 9, 25)
>>> AddMonths(datetime.datetime(2010,8,25),4)
datetime.date(2010, 12, 25)
>>> AddMonths(datetime.datetime(2010,8,25),5)
datetime.date(2011, 1, 25)
>>> AddMonths(datetime.datetime(2010,8,25),13)
datetime.date(2011, 9, 25)
>>> AddMonths(datetime.datetime(2010,8,25),24)
datetime.date(2012, 8, 25)
>>> AddMonths(datetime.datetime(2010,8,25),-1)
datetime.date(2010, 7, 25)
>>> AddMonths(datetime.datetime(2010,8,25),0)
datetime.date(2010, 8, 25)
>>> AddMonths(datetime.datetime(2010,8,25),-12)
datetime.date(2009, 8, 25)
>>> AddMonths(datetime.datetime(2010,8,25),-8)
datetime.date(2009, 12, 25)
>>> AddMonths(datetime.datetime(2010,8,25),-7)
datetime.date(2010, 1, 25)>>> 

Je sais que c'était pour 6 mois, mais la réponse indique dans google pour "ajouter des mois en python" si vous ajoutez un mois:

import calendar

date = datetime.date.today()    //Or your date

datetime.timedelta(days=calendar.monthrange(date.year,date.month)[1])

cela compterait les jours du mois en cours et les ajouterait à la date du jour, l'utilisation de 365/12 signifierait qu'un 1/12 d'année peut causer des problèmes pour les mois courts / longs si votre itération sur la date.

Il n'y a aucun moyen direct de le faire avec le datetime de Python.

Découvrez le type relativedelta sur python-dateutil . Il vous permet de spécifier un delta temporel en mois.

Utilisez simplement la méthode du calendrier pour extraire les mois, ajoutez vos mois et créez un nouvel objet date. S'il existe déjà une méthode pour cela, je ne la connais pas.

import datetime

def in_the_future(months=1):
    year, month, day = datetime.date.today().timetuple()[:3]
    new_month = month + months
    return datetime.date(year + (new_month / 12), (new_month % 12) or 12, day)

L'API est un peu maladroite, mais fonctionne comme exemple. Ne fonctionnera évidemment pas non plus sur les cas d'angle comme le 2008-01-31 + 1 mois. :)

Le package Dateutil a implémenté une telle fonctionnalité. Mais sachez que ce sera naïf , comme d'autres l'ont déjà souligné.

Utilisation de bibliothèques standard Python, c'est-à-dire sans dateutilou autres, et résolution du problème du «31 février»:

import datetime
import calendar

def add_months(date, months):
    months_count = date.month + months

    # Calculate the year
    year = date.year + int(months_count / 12)

    # Calculate the month
    month = (months_count % 12)
    if month == 0:
        month = 12

    # Calculate the day
    day = date.day
    last_day_of_month = calendar.monthrange(year, month)[1]
    if day > last_day_of_month:
        day = last_day_of_month

    new_date = datetime.date(year, month, day)
    return new_date

Essai:

>>>date = datetime.date(2018, 11, 30)

>>>print(date, add_months(date, 3))
(datetime.date(2018, 11, 30), datetime.date(2019, 2, 28))

>>>print(date, add_months(date, 14))
(datetime.date(2018, 12, 31), datetime.date(2020, 2, 29))

J'ai une meilleure façon de résoudre le problème du «31 février»:

def add_months(start_date, months):
    import calendar

    year = start_date.year + (months / 12)
    month = start_date.month + (months % 12)
    day = start_date.day

    if month > 12:
        month = month % 12
        year = year + 1

    days_next = calendar.monthrange(year, month)[1]
    if day > days_next:
        day = days_next

    return start_date.replace(year, month, day)

Je pense que cela fonctionne également avec des nombres négatifs (pour soustraire des mois), mais je n'ai pas beaucoup testé cela.

La classe QDate de PyQt4 a une fonction addmonths.

>>>from PyQt4.QtCore import QDate  
>>>dt = QDate(2009,12,31)  
>>>required = dt.addMonths(6) 

>>>required
PyQt4.QtCore.QDate(2010, 6, 30)

>>>required.toPyDate()
datetime.date(2010, 6, 30)

Que dis-tu de ça? Vous n'utilisez pas une autre bibliothèque ( dateutil) ou timedelta? en s'appuyant sur la réponse de vartec , je l'ai fait et je pense que cela fonctionne:

import datetime

today = datetime.date.today()
six_months_from_today = datetime.date(today.year + (today.month + 6)/12, (today.month + 6) % 12, today.day)

J'ai essayé d'utiliser timedelta, mais parce que ça compte les jours, 365/2ou 6*356/12ne se traduit pas toujours par 6 mois, mais plutôt 182 jours. par exemple

day = datetime.date(2015, 3, 10)
print day
>>> 2015-03-10

print (day + datetime.timedelta(6*365/12))
>>> 2015-09-08

Je crois que nous supposons généralement que 6 mois à partir d'un certain jour atterriront le même jour du mois mais 6 mois plus tard (c'est 2015-03-10-à- dire -> 2015-09-10, Non 2015-09-08)

J'espère que ça t'as aidé.

Cela ne répond pas à la question spécifique (en utilisant datetimeuniquement) mais, étant donné que d'autres ont suggéré l'utilisation de différents modules, il existe ici une solution utilisant pandas.

import datetime as dt
import pandas as pd

date = dt.date.today() - \
       pd.offsets.DateOffset(months=6)

print(date)

2019-05-04 00:00:00

Qui fonctionne comme prévu dans les années bissextiles

date = dt.datetime(2019,8,29) - \
       pd.offsets.DateOffset(months=6)
print(date)

2019-02-28 00:00:00

Modification de AddMonths () pour une utilisation dans Zope et la gestion des numéros de jour non valides:

def AddMonths(d,x):
    days_of_month = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]
    newmonth = ((( d.month() - 1) + x ) % 12 ) + 1
    newyear  = d.year() + ((( d.month() - 1) + x ) // 12 ) 
    if d.day() > days_of_month[newmonth-1]:
      newday = days_of_month[newmonth-1]
    else:
      newday = d.day() 
    return DateTime( newyear, newmonth, newday)

import time

def add_month(start_time, months):  

        ret = time.strptime(start_time, '%Y-%m-%d')
        t = list(ret)

        t[1] += months

        if t[1] > 12:
            t[0] += 1 + int(months / 12)

            t[1] %= 12

        return int(time.mktime(tuple(t)))

import datetime


'''
Created on 2011-03-09

@author: tonydiep
'''

def add_business_months(start_date, months_to_add):
    """
    Add months in the way business people think of months. 
    Jan 31, 2011 + 1 month = Feb 28, 2011 to business people
    Method: Add the number of months, roll back the date until it becomes a valid date
    """
    # determine year
    years_change = months_to_add / 12

    # determine if there is carryover from adding months
    if (start_date.month + (months_to_add % 12) > 12 ):
        years_change = years_change + 1

    new_year = start_date.year + years_change

    # determine month
    work = months_to_add % 12
    if 0 == work:
        new_month = start_date.month
    else:
        new_month = (start_date.month + (work % 12)) % 12

    if 0 == new_month:
        new_month = 12 

    # determine day of the month
    new_day = start_date.day
    if(new_day in [31, 30, 29, 28]):
        #user means end of the month
        new_day = 31


    new_date = None
    while (None == new_date and 27 < new_day):
        try:
            new_date = start_date.replace(year=new_year, month=new_month, day=new_day)
        except:
            new_day = new_day - 1   #wind down until we get to a valid date

    return new_date


if __name__ == '__main__':
    #tests
    dates = [datetime.date(2011, 1, 31),
             datetime.date(2011, 2, 28),
             datetime.date(2011, 3, 28),
             datetime.date(2011, 4, 28),
             datetime.date(2011, 5, 28),
             datetime.date(2011, 6, 28),
             datetime.date(2011, 7, 28),
             datetime.date(2011, 8, 28),
             datetime.date(2011, 9, 28),
             datetime.date(2011, 10, 28),
             datetime.date(2011, 11, 28),
             datetime.date(2011, 12, 28),
             ]
    months = range(1, 24)
    for start_date in dates:
        for m in months:
            end_date = add_business_months(start_date, m)
            print("%s\t%s\t%s" %(start_date, end_date, m))

Modification de la réponse de Johannes Wei dans le cas 1new_month = 121. Cela fonctionne parfaitement pour moi. Les mois peuvent être positifs ou négatifs.

def addMonth(d,months=1):
    year, month, day = d.timetuple()[:3]
    new_month = month + months
    return datetime.date(year + ((new_month-1) / 12), (new_month-1) % 12 +1, day)

Encore une autre solution - j'espère que quelqu'un l'aimera:

def add_months(d, months):
    return d.replace(year=d.year+months//12).replace(month=(d.month+months)%12)

Cette solution ne fonctionne pas pendant les jours 29,30,31 pour tous les cas, donc une solution plus robuste est nécessaire (ce qui n'est plus si agréable :)):

def add_months(d, months):
    for i in range(4):
        day = d.day - i
        try:
            return d.replace(day=day).replace(year=d.year+int(months)//12).replace(month=(d.month+int(months))%12)
        except:
            pass
    raise Exception("should not happen")

À partir de cette réponse , voir parsedatetime . Un exemple de code suit. Plus de détails: test unitaire avec de nombreux exemples de conversion en langage naturel -> AAAA-MM-JJ , et défis / bogues de conversion apparents en temps réel .

#!/usr/bin/env python
# -*- coding: utf-8 -*-
import time, calendar
from datetime import date

# from https://github.com/bear/parsedatetime
import parsedatetime as pdt

def print_todays_date():
    todays_day_of_week = calendar.day_name[date.today().weekday()]
    print "today's date = " + todays_day_of_week + ', ' + \
                              time.strftime('%Y-%m-%d')

def convert_date(natural_language_date):
    cal = pdt.Calendar()
    (struct_time_date, success) = cal.parse(natural_language_date)
    if success:
        formal_date = time.strftime('%Y-%m-%d', struct_time_date)
    else:
        formal_date = '(conversion failed)'
    print '{0:12s} -> {1:10s}'.format(natural_language_date, formal_date)

print_todays_date()
convert_date('6 months')

Le code ci-dessus génère les éléments suivants à partir d'une machine MacOSX:

$ ./parsedatetime_simple.py 
today's date = Wednesday, 2015-05-13
6 months     -> 2015-11-13
$ 

Voici un exemple qui permet à l'utilisateur de décider comment renvoyer une date où le jour est supérieur au nombre de jours du mois.

def add_months(date, months, endOfMonthBehaviour='RoundUp'):
    assert endOfMonthBehaviour in ['RoundDown', 'RoundIn', 'RoundOut', 'RoundUp'], \
        'Unknown end of month behaviour'
    year = date.year + (date.month + months - 1) / 12
    month = (date.month + months - 1) % 12 + 1
    day = date.day
    last = monthrange(year, month)[1]
    if day > last:
        if endOfMonthBehaviour == 'RoundDown' or \
            endOfMonthBehaviour == 'RoundOut' and months < 0 or \
            endOfMonthBehaviour == 'RoundIn' and months > 0:
            day = last
        elif endOfMonthBehaviour == 'RoundUp' or \
            endOfMonthBehaviour == 'RoundOut' and months > 0 or \
            endOfMonthBehaviour == 'RoundIn' and months < 0:
            # we don't need to worry about incrementing the year
            # because there will never be a day in December > 31
            month += 1
            day = 1
    return datetime.date(year, month, day)


>>> from calendar import monthrange
>>> import datetime
>>> add_months(datetime.datetime(2016, 1, 31), 1)
datetime.date(2016, 3, 1)
>>> add_months(datetime.datetime(2016, 1, 31), -2)
datetime.date(2015, 12, 1)
>>> add_months(datetime.datetime(2016, 1, 31), -2, 'RoundDown')
datetime.date(2015, 11, 30)

étant donné que votre variable datetime est appelée date:

date=datetime.datetime(year=date.year+int((date.month+6)/12),
                       month=(date.month+6)%13 + (1 if (date.month + 
                       months>12) else 0), day=date.day)

Fonction générale pour obtenir la prochaine date après / avant x mois.

à partir de la date d'importation datetime

def after_month (given_date, month):
    aaaa = int (((date_donnée.année * 12 + date_donnée.mois) + mois) / 12)
    mm = int (((given_date.year * 12 + given_date.month) + mois)% 12)

    si mm == 0:
        aaaa - = 1
        mm = 12
    return given_date.replace (année = aaaa, mois = mm)


si __name__ == "__main__":
    aujourd'hui = date.today ()
    imprimer (aujourd'hui)

    pour mm en [-12, -1, 0, 1, 2, 12, 20]:
        next_date = after_month (aujourd'hui, mm)
        print (next_date)

Une suggestion rapide est Arrow

pip d'installation flèche

>>> import arrow

>>> arrow.now().date()
datetime.date(2019, 6, 28)
>>> arrow.now().shift(months=6).date()
datetime.date(2019, 12, 28)

Utilisez le module datetime python pour ajouter un délai de six mois à datetime.today ().

http://docs.python.org/library/datetime.html

Vous devrez bien sûr résoudre le problème soulevé par Johannes Weiß - que voulez - vous dire par 6 mois?

C'est ce que j'ai trouvé. Il déplace le nombre correct de mois et d'années mais ignore les jours (ce dont j'avais besoin dans ma situation).

import datetime

month_dt = 4
today = datetime.date.today()
y,m = today.year, today.month
m += month_dt-1
year_dt = m//12
new_month = m%12
new_date = datetime.date(y+year_dt, new_month+1, 1)

J'utilise cette fonction pour changer l'année et le mois mais garder le jour:

def replace_month_year(date1, year2, month2):
    try:
        date2 = date1.replace(month = month2, year = year2)
    except:
        date2 = datetime.date(year2, month2 + 1, 1) - datetime.timedelta(days=1)
    return date2

Vous devez écrire:

new_year = my_date.year + (my_date.month + 6) / 12
new_month = (my_date.month + 6) % 12
new_date = replace_month_year(my_date, new_year, new_month)

Je pense qu'il serait plus sûr de faire quelque chose comme ça au lieu d'ajouter manuellement des jours:

import datetime
today = datetime.date.today()

def addMonths(dt, months = 0):
    new_month = months + dt.month
    year_inc = 0
    if new_month>12:
        year_inc +=1
        new_month -=12
    return dt.replace(month = new_month, year = dt.year+year_inc)

newdate = addMonths(today, 6)