Come posso calcolare la data a sei mesi dalla data corrente usando il modulo Python datetime?

Sto usando il modulo Python datetime. Sto cercando di calcolare la data 6 mesi dalla data corrente. Qualcuno potrebbe darmi un piccolo aiuto per fare questo?

Il motivo per cui desidero generare una data a 6 mesi dalla data corrente è produrre una data di revisione . Se l'utente inserisce i dati nel sistema, avrà una data di revisione di 6 mesi dalla data in cui ha inserito i dati.

Ho trovato questa soluzione buona. (Questo utilizza l' estensione python-dateutil )

from datetime import date
from dateutil.relativedelta import relativedelta

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

Il vantaggio di questo approccio è che risolve i problemi con 28, 30, 31 giorni ecc. Ciò diventa molto utile nella gestione delle regole e degli scenari aziendali (ad esempio generazione di fatture, ecc.)

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

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

Bene, questo dipende da cosa intendi per 6 mesi dalla data corrente.

1. Usando i mesi naturali:

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

2. Utilizzando la definizione di un banchiere, 6 * 30:

   date += datetime.timedelta(6 * 30)

Con Python 3.x puoi farlo in questo modo:

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

ma dovrai installare il modulo python-dateutil :

pip install python-dateutil

Per il calcolo di inizio mese in mese:

from datetime import timedelta
from dateutil.relativedelta import relativedelta

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

Cosa intendi con "6 mesi"?

Il periodo 13/02/2009 + 6 mesi == 2009-08-13? O è 13/02/2009 + 6 * 30 giorni?

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'

Maggiori informazioni su mx.DateTime

Quindi, ecco un esempio di quello dateutil.relativedeltache ho trovato utile per iterare durante l'anno passato, saltando un mese ogni volta alla data attuale:

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

Come con le altre risposte, devi capire cosa intendi effettivamente per "6 mesi da adesso". Se intendi "il giorno del mese di oggi nel mese di sei anni in futuro", ciò farebbe:

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

Questa soluzione funziona correttamente per dicembre, che la maggior parte delle risposte in questa pagina non lo fanno. Devi prima spostare i mesi dalla base 1 (cioè Jan = 1) alla base 0 (cioè Jan = 0) prima di utilizzare il modulo (%) o la divisione intera (//), altrimenti novembre (11) più 1 mese ti danno 12 , che quando trova il resto (12% 12) dà 0.

(E non suggerire "(mese% 12) + 1" o ottobre + 1 = dicembre!)

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)

Tuttavia ... Questo non tiene conto di problemi come il 31 gennaio + un mese. Quindi torniamo al PO - cosa intendi con l'aggiunta di un mese? Una soluzione è tornare indietro fino a quando non si arriva a un giorno valido, dato che la maggior parte delle persone presume che l'ultimo giorno di gennaio, più un mese, sia uguale all'ultimo giorno di febbraio. Funzionerà anche su un numero negativo di mesi. Prova:

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

So che è stato per 6 mesi, tuttavia la risposta mostra in Google per "l'aggiunta di mesi in Python" se si aggiunge un mese:

import calendar

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

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

questo conterebbe i giorni del mese corrente e li aggiungerebbe alla data corrente, l'uso di 365/12 sarebbe 1/12 di un anno può causare problemi per brevi / lunghi mesi se si scorre la data.

Non esiste un modo diretto per farlo con il datetime di Python.

Dai un'occhiata al tipo di relativedelta su python-dateutil . Ti consente di specificare un delta temporale in mesi.

Usa semplicemente il metodo della agenda per estrarre i mesi, aggiungere i tuoi mesi e creare un nuovo oggetto data. Se esiste un metodo già esistente per questo non lo so.

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 è un po 'goffa, ma funziona come un esempio. Ovviamente non funzionerà su casi angolari come il 31-01-2008 + 1 mese. :)

Il pacchetto Dateutil ha l'implementazione di tale funzionalità. Ma attenzione, questo sarà ingenuo , come già indicato da altri.

Utilizzando le librerie standard di Python, ovvero senza dateutilo altre, e risolvendo il problema "31 febbraio":

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

test:

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

Ho un modo migliore per risolvere il problema "31 febbraio":

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)

Penso che funzioni anche con numeri negativi (per sottrarre mesi), ma non l'ho testato molto.

La classe QDate di PyQt4 ha una funzione 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)

Cosa ne pensi di questo? Non stai usando un'altra libreria ( dateutil) o timedelta? basandomi sulla risposta di Vartec , l'ho fatto e credo che funzioni:

import datetime

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

Ho provato a usare timedelta, ma perché conta i giorni 365/2o 6*356/12non si traduce sempre in 6 mesi, ma piuttosto in 182 giorni. per esempio

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

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

Credo che di solito assumiamo che 6 mesi da un determinato giorno atterreranno nello stesso giorno del mese ma 6 mesi dopo (cioè 2015-03-10-> 2015-09-10, Non2015-09-08 )

Spero che lo trovi utile

Questo non risponde alla domanda specifica ( datetimesolo usando ) ma, dato che altri hanno suggerito l'uso di moduli diversi, qui c'è una soluzione che usa 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

Che funziona come previsto negli anni bisestili

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

2019-02-28 00:00:00

Modificati gli AddMonths () per l'uso in Zope e la gestione dei numeri dei giorni non validi:

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

Modificata la risposta di Johannes Wei nel caso 1new_month = 121. Questo funziona perfettamente per me. I mesi potrebbero essere positivi o negativi.

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)

Ancora un'altra soluzione: spero che a qualcuno piacerà:

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

Questa soluzione non funziona per giorni 29,30,31 in tutti i casi, quindi è necessaria una soluzione più solida (che non è più così piacevole :)):

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

Da questa risposta , vedi parsedatetime . Segue un esempio di codice. Maggiori dettagli: test unitari con molti linguaggi naturali -> esempi di conversione AAAA-MM-GG e problemi / bug di conversione apparentemente analizzati .

#!/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')

Il codice precedente genera quanto segue da un computer MacOSX:

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

Ecco un esempio che consente all'utente di decidere come restituire una data in cui il giorno è maggiore del numero di giorni del mese.

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)

dato che la tua variabile datetime è chiamata 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)

Funzione generale per ottenere la data successiva dopo / prima di x mesi.

dalla data di importazione datetime

def after_month (given_date, mese):
    aaaa = int ((((data_data.anno * 12 + data_data.mese) + mese) / 12)
    mm = int (((given_date.year * 12 + given_date.month) + mese)% 12)

    se mm == 0:
        yyyy - = 1
        mm = 12
    return given_date.replace (anno = aaaa, mese = mm)


se __name__ == "__main__":
    oggi = date.today ()
    stampa (oggi)

    per mm in [-12, -1, 0, 1, 2, 12, 20]:
        next_date = after_month (oggi, mm)
        stampare (next_date)

Un rapido suggerimento è Arrow

freccia di installazione pip

>>> import arrow

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

Utilizzare il modulo datetime python per aggiungere un timedelta di sei mesi a datetime.today ().

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

Sarà ovviamente necessario risolvere il problema sollevato da Johannes Weiß-- cosa cosa si intende per 6 mesi?

Questo è quello che mi è venuto in mente. Sposta il numero corretto di mesi e anni ma ignora i giorni (che era ciò di cui avevo bisogno nella mia situazione).

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)

Uso questa funzione per cambiare anno e mese ma mantengo il giorno:

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

Dovresti scrivere:

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)

Penso che sarebbe più sicuro fare qualcosa del genere invece di aggiungere manualmente giorni:

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)