Iterasi melalui berbagai tanggal dalam Python

Saya memiliki kode berikut untuk melakukan ini, tetapi bagaimana saya bisa melakukannya dengan lebih baik? Saat ini saya pikir ini lebih baik daripada loop bersarang, tetapi mulai mendapatkan Perl-one-linerish ketika Anda memiliki generator dalam daftar pemahaman.

day_count = (end_date - start_date).days + 1
for single_date in [d for d in (start_date + timedelta(n) for n in range(day_count)) if d <= end_date]:
    print strftime("%Y-%m-%d", single_date.timetuple())

Catatan

• Saya sebenarnya tidak menggunakan ini untuk mencetak. Itu hanya untuk keperluan demo.
• The start_datedan end_datevariabel datetime.datebenda karena saya tidak perlu cap waktu. (Mereka akan digunakan untuk menghasilkan laporan).

Output Sampel

Untuk tanggal mulai 2009-05-30dan tanggal akhir 2009-06-09:

2009-05-30
2009-05-31
2009-06-01
2009-06-02
2009-06-03
2009-06-04
2009-06-05
2009-06-06
2009-06-07
2009-06-08
2009-06-09

Mengapa ada dua iterasi bersarang? Bagi saya itu menghasilkan daftar data yang sama dengan hanya satu iterasi:

for single_date in (start_date + timedelta(n) for n in range(day_count)):
    print ...

Dan tidak ada daftar yang disimpan, hanya satu generator yang diulang. Juga "jika" di generator tampaknya tidak perlu.

Lagipula, urutan linear seharusnya hanya membutuhkan satu iterator, bukan dua.

Pembaruan setelah diskusi dengan John Machin:

Mungkin solusi yang paling elegan adalah menggunakan fungsi generator untuk sepenuhnya menyembunyikan / mengabstraksi iterasi pada rentang tanggal:

from datetime import timedelta, date

def daterange(start_date, end_date):
    for n in range(int ((end_date - start_date).days)):
        yield start_date + timedelta(n)

start_date = date(2013, 1, 1)
end_date = date(2015, 6, 2)
for single_date in daterange(start_date, end_date):
    print(single_date.strftime("%Y-%m-%d"))

NB: Untuk konsistensi dengan range()fungsi bawaan iterasi ini berhenti sebelum mencapai end_date. Jadi untuk iterasi inklusif gunakan hari berikutnya, seperti yang Anda lakukan dengan range().

Ini mungkin lebih jelas:

from datetime import date, timedelta

start_date = date(2019, 1, 1)
end_date = date(2020, 1, 1)
delta = timedelta(days=1)
while start_date <= end_date:
    print (start_date.strftime("%Y-%m-%d"))
    start_date += delta

Gunakan dateutilperpustakaan:

from datetime import date
from dateutil.rrule import rrule, DAILY

a = date(2009, 5, 30)
b = date(2009, 6, 9)

for dt in rrule(DAILY, dtstart=a, until=b):
    print dt.strftime("%Y-%m-%d")

Pustaka python ini memiliki banyak fitur canggih, beberapa sangat berguna, seperti relative deltas — dan diimplementasikan sebagai satu file (modul) yang mudah dimasukkan ke dalam proyek.

Panda bagus untuk deret waktu secara umum, dan memiliki dukungan langsung untuk rentang tanggal.

import pandas as pd
daterange = pd.date_range(start_date, end_date)

Anda kemudian dapat mengulangi daterange untuk mencetak tanggal:

for single_date in daterange:
    print (single_date.strftime("%Y-%m-%d"))

Ini juga memiliki banyak pilihan untuk membuat hidup lebih mudah. Misalnya, jika Anda hanya menginginkan hari kerja, Anda cukup menukar di bdate_range. Lihat http://pandas.pydata.org/pandas-docs/stable/timeseries.html#generating-ranges-of-timestamps

Kekuatan Pandas adalah benar-benar kerangka datanya, yang mendukung operasi vektor (seperti numpy) yang membuat operasi melintasi sejumlah besar data sangat cepat dan mudah.

EDIT: Anda juga bisa melewatkan loop untuk dan hanya mencetaknya secara langsung, yang lebih mudah dan lebih efisien:

print(daterange)

import datetime

def daterange(start, stop, step=datetime.timedelta(days=1), inclusive=False):
  # inclusive=False to behave like range by default
  if step.days > 0:
    while start < stop:
      yield start
      start = start + step
      # not +=! don't modify object passed in if it's mutable
      # since this function is not restricted to
      # only types from datetime module
  elif step.days < 0:
    while start > stop:
      yield start
      start = start + step
  if inclusive and start == stop:
    yield start

# ...

for date in daterange(start_date, end_date, inclusive=True):
  print strftime("%Y-%m-%d", date.timetuple())

Fungsi ini melakukan lebih dari yang Anda perlukan, dengan mendukung langkah negatif, dll. Selama Anda memfaktorkan logika jangkauan Anda, maka Anda tidak perlu terpisah day_countdan yang paling penting kode menjadi lebih mudah dibaca saat Anda memanggil fungsi dari banyak tempat

Ini adalah solusi yang paling bisa dibaca manusia yang bisa saya pikirkan.

import datetime

def daterange(start, end, step=datetime.timedelta(1)):
    curr = start
    while curr < end:
        yield curr
        curr += step

Kenapa tidak mencoba:

import datetime as dt

start_date = dt.datetime(2012, 12,1)
end_date = dt.datetime(2012, 12,5)

total_days = (end_date - start_date).days + 1 #inclusive 5 days

for day_number in range(total_days):
    current_date = (start_date + dt.timedelta(days = day_number)).date()
    print current_date

Fungsi Numpy arangedapat diterapkan ke tanggal:

import numpy as np
from datetime import datetime, timedelta
d0 = datetime(2009, 1,1)
d1 = datetime(2010, 1,1)
dt = timedelta(days = 1)
dates = np.arange(d0, d1, dt).astype(datetime)

Penggunaan astypeis untuk mengkonversi dari numpy.datetime64ke array datetime.datetimeobjek.

Perlihatkan n hari terakhir mulai hari ini:

import datetime
for i in range(0, 100):
    print((datetime.date.today() + datetime.timedelta(i)).isoformat())

Keluaran:

2016-06-29
2016-06-30
2016-07-01
2016-07-02
2016-07-03
2016-07-04

import datetime

def daterange(start, stop, step_days=1):
    current = start
    step = datetime.timedelta(step_days)
    if step_days > 0:
        while current < stop:
            yield current
            current += step
    elif step_days < 0:
        while current > stop:
            yield current
            current += step
    else:
        raise ValueError("daterange() step_days argument must not be zero")

if __name__ == "__main__":
    from pprint import pprint as pp
    lo = datetime.date(2008, 12, 27)
    hi = datetime.date(2009, 1, 5)
    pp(list(daterange(lo, hi)))
    pp(list(daterange(hi, lo, -1)))
    pp(list(daterange(lo, hi, 7)))
    pp(list(daterange(hi, lo, -7))) 
    assert not list(daterange(lo, hi, -1))
    assert not list(daterange(hi, lo))
    assert not list(daterange(lo, hi, -7))
    assert not list(daterange(hi, lo, 7)) 

for i in range(16):
    print datetime.date.today() + datetime.timedelta(days=i)

Untuk kelengkapan, Pandas juga memiliki period_rangefungsi untuk cap waktu yang di luar batas:

import pandas as pd

pd.period_range(start='1/1/1626', end='1/08/1627', freq='D')

Saya memiliki masalah yang sama, tetapi saya harus mengulanginya setiap bulan, bukan setiap hari.

Ini solusi saya

import calendar
from datetime import datetime, timedelta

def days_in_month(dt):
    return calendar.monthrange(dt.year, dt.month)[1]

def monthly_range(dt_start, dt_end):
    forward = dt_end >= dt_start
    finish = False
    dt = dt_start

    while not finish:
        yield dt.date()
        if forward:
            days = days_in_month(dt)
            dt = dt + timedelta(days=days)            
            finish = dt > dt_end
        else:
            _tmp_dt = dt.replace(day=1) - timedelta(days=1)
            dt = (_tmp_dt.replace(day=dt.day))
            finish = dt < dt_end

Contoh 1

date_start = datetime(2016, 6, 1)
date_end = datetime(2017, 1, 1)

for p in monthly_range(date_start, date_end):
    print(p)

Keluaran

2016-06-01
2016-07-01
2016-08-01
2016-09-01
2016-10-01
2016-11-01
2016-12-01
2017-01-01

Contoh # 2

date_start = datetime(2017, 1, 1)
date_end = datetime(2016, 6, 1)

for p in monthly_range(date_start, date_end):
    print(p)

Keluaran

2017-01-01
2016-12-01
2016-11-01
2016-10-01
2016-09-01
2016-08-01
2016-07-01
2016-06-01

Dapat 't * percaya pertanyaan ini telah ada selama 9 tahun tanpa ada yang menyarankan fungsi rekursif sederhana:

from datetime import datetime, timedelta

def walk_days(start_date, end_date):
    if start_date <= end_date:
        print(start_date.strftime("%Y-%m-%d"))
        next_date = start_date + timedelta(days=1)
        walk_days(next_date, end_date)

#demo
start_date = datetime(2009, 5, 30)
end_date   = datetime(2009, 6, 9)

walk_days(start_date, end_date)

Keluaran:

2009-05-30
2009-05-31
2009-06-01
2009-06-02
2009-06-03
2009-06-04
2009-06-05
2009-06-06
2009-06-07
2009-06-08
2009-06-09

Sunting: * Sekarang saya dapat mempercayainya - lihat Apakah Python mengoptimalkan rekursi ekor? . Terima kasih, Tim .

Anda dapat menghasilkan serangkaian tanggal antara dua tanggal menggunakan perpustakaan panda secara sederhana dan penuh kepercayaan

import pandas as pd

print pd.date_range(start='1/1/2010', end='1/08/2018', freq='M')

Anda dapat mengubah frekuensi menghasilkan tanggal dengan menetapkan freq sebagai D, M, Q, Y (harian, bulanan, triwulanan, tahunan)

> pip install DateTimeRange

from datetimerange import DateTimeRange

def dateRange(start, end, step):
        rangeList = []
        time_range = DateTimeRange(start, end)
        for value in time_range.range(datetime.timedelta(days=step)):
            rangeList.append(value.strftime('%m/%d/%Y'))
        return rangeList

    dateRange("2018-09-07", "2018-12-25", 7)  

    Out[92]: 
    ['09/07/2018',
     '09/14/2018',
     '09/21/2018',
     '09/28/2018',
     '10/05/2018',
     '10/12/2018',
     '10/19/2018',
     '10/26/2018',
     '11/02/2018',
     '11/09/2018',
     '11/16/2018',
     '11/23/2018',
     '11/30/2018',
     '12/07/2018',
     '12/14/2018',
     '12/21/2018']

Fungsi ini memiliki beberapa fitur tambahan:

• dapat meneruskan string yang cocok dengan DATE_FORMAT untuk awal atau akhir dan itu dikonversi ke objek tanggal
• dapat melewati objek tanggal untuk memulai atau mengakhiri

• memeriksa kesalahan jika akhirnya lebih tua dari awal

  import datetime
  from datetime import timedelta
  
  
  DATE_FORMAT = '%Y/%m/%d'
  
  def daterange(start, end):
        def convert(date):
              try:
                    date = datetime.datetime.strptime(date, DATE_FORMAT)
                    return date.date()
              except TypeError:
                    return date
  
        def get_date(n):
              return datetime.datetime.strftime(convert(start) + timedelta(days=n), DATE_FORMAT)
  
        days = (convert(end) - convert(start)).days
        if days <= 0:
              raise ValueError('The start date must be before the end date.')
        for n in range(0, days):
              yield get_date(n)
  
  
  start = '2014/12/1'
  end = '2014/12/31'
  print list(daterange(start, end))
  
  start_ = datetime.date.today()
  end = '2015/12/1'
  print list(daterange(start, end))

Berikut kode untuk fungsi rentang tanggal umum, mirip dengan jawaban Ber, tetapi lebih fleksibel:

def count_timedelta(delta, step, seconds_in_interval):
    """Helper function for iterate.  Finds the number of intervals in the timedelta."""
    return int(delta.total_seconds() / (seconds_in_interval * step))


def range_dt(start, end, step=1, interval='day'):
    """Iterate over datetimes or dates, similar to builtin range."""
    intervals = functools.partial(count_timedelta, (end - start), step)

    if interval == 'week':
        for i in range(intervals(3600 * 24 * 7)):
            yield start + datetime.timedelta(weeks=i) * step

    elif interval == 'day':
        for i in range(intervals(3600 * 24)):
            yield start + datetime.timedelta(days=i) * step

    elif interval == 'hour':
        for i in range(intervals(3600)):
            yield start + datetime.timedelta(hours=i) * step

    elif interval == 'minute':
        for i in range(intervals(60)):
            yield start + datetime.timedelta(minutes=i) * step

    elif interval == 'second':
        for i in range(intervals(1)):
            yield start + datetime.timedelta(seconds=i) * step

    elif interval == 'millisecond':
        for i in range(intervals(1 / 1000)):
            yield start + datetime.timedelta(milliseconds=i) * step

    elif interval == 'microsecond':
        for i in range(intervals(1e-6)):
            yield start + datetime.timedelta(microseconds=i) * step

    else:
        raise AttributeError("Interval must be 'week', 'day', 'hour' 'second', \
            'microsecond' or 'millisecond'.")

Bagaimana dengan yang berikut untuk melakukan rentang yang bertambah berdasarkan hari:

for d in map( lambda x: startDate+datetime.timedelta(days=x), xrange( (stopDate-startDate).days ) ):
  # Do stuff here

• startDate dan stopDate adalah objek datetime.date

Untuk versi generik:

for d in map( lambda x: startTime+x*stepTime, xrange( (stopTime-startTime).total_seconds() / stepTime.total_seconds() ) ):
  # Do stuff here

• startTime dan stopTime adalah objek datetime.date atau datetime.datetime (keduanya harus bertipe sama)
• stepTime adalah objek timedelta

Perhatikan bahwa .total_seconds () hanya didukung setelah python 2.7. Jika Anda terjebak dengan versi sebelumnya, Anda dapat menulis fungsi Anda sendiri:

def total_seconds( td ):
  return float(td.microseconds + (td.seconds + td.days * 24 * 3600) * 10**6) / 10**6

Pendekatan yang sedikit berbeda untuk langkah reversibel dengan menyimpan rangeargs dalam tuple.

def date_range(start, stop, step=1, inclusive=False):
    day_count = (stop - start).days
    if inclusive:
        day_count += 1

    if step > 0:
        range_args = (0, day_count, step)
    elif step < 0:
        range_args = (day_count - 1, -1, step)
    else:
        raise ValueError("date_range(): step arg must be non-zero")

    for i in range(*range_args):
        yield start + timedelta(days=i)

import datetime
from dateutil.rrule import DAILY,rrule

date=datetime.datetime(2019,1,10)

date1=datetime.datetime(2019,2,2)

for i in rrule(DAILY , dtstart=date,until=date1):
     print(i.strftime('%Y%b%d'),sep='\n')

KELUARAN:

2019Jan10
2019Jan11
2019Jan12
2019Jan13
2019Jan14
2019Jan15
2019Jan16
2019Jan17
2019Jan18
2019Jan19
2019Jan20
2019Jan21
2019Jan22
2019Jan23
2019Jan24
2019Jan25
2019Jan26
2019Jan27
2019Jan28
2019Jan29
2019Jan30
2019Jan31
2019Feb01
2019Feb02