Lặp lại qua một loạt các ngày trong Python

Tôi có đoạn mã sau để làm điều này, nhưng làm thế nào tôi có thể làm nó tốt hơn? Ngay bây giờ tôi nghĩ rằng nó tốt hơn các vòng lặp lồng nhau, nhưng nó bắt đầu nhận được Perl-one-linerish khi bạn có một trình tạo trong danh sách hiểu.

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

Ghi chú

• Tôi thực sự không sử dụng điều này để in. Đó chỉ là mục đích demo.
• Các biến start_datevà end_datelà datetime.datecác đối tượng vì tôi không cần dấu thời gian. (Chúng sẽ được sử dụng để tạo báo cáo).

Đầu ra mẫu

Đối với ngày bắt đầu 2009-05-30và ngày kết thúc 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

Tại sao có hai lần lặp lồng nhau? Đối với tôi, nó tạo ra cùng một danh sách dữ liệu chỉ với một lần lặp:

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

Và không có danh sách nào được lưu trữ, chỉ có một trình tạo được lặp lại. Ngoài ra, "nếu" trong trình tạo dường như là không cần thiết.

Rốt cuộc, một chuỗi tuyến tính chỉ cần một vòng lặp, không phải hai.

Cập nhật sau khi thảo luận với John Machin:

Có lẽ giải pháp tao nhã nhất là sử dụng hàm tạo để ẩn / tóm tắt hoàn toàn việc lặp lại trong phạm vi ngày:

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: Để thống nhất với range()chức năng tích hợp, phép lặp này dừng trước khi đến end_date. Vì vậy, để lặp lại bao gồm sử dụng vào ngày hôm sau, như bạn sẽ làm với range().

Điều này có thể rõ ràng hơn:

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

Sử dụng dateutilthư viện:

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

Thư viện python này có nhiều tính năng nâng cao hơn, một số tính năng rất hữu ích, như relative deltas, và được triển khai dưới dạng một tệp (mô-đun) dễ dàng đưa vào một dự án.

Pandas là tuyệt vời cho chuỗi thời gian nói chung, và có hỗ trợ trực tiếp cho phạm vi ngày.

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

Sau đó, bạn có thể lặp qua daterange để in ngày:

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

Nó cũng có rất nhiều lựa chọn để làm cho cuộc sống dễ dàng hơn. Ví dụ: nếu bạn chỉ muốn các ngày trong tuần, bạn sẽ chỉ trao đổi trong bdate_range. Xem http://pandas.pydata.org/pandas-docs/urdy/timeseries.html#generating-ranges-of-timestamp

Sức mạnh của Pandas thực sự là các dataframes của nó, hỗ trợ các hoạt động được vector hóa (giống như numpy) giúp cho các hoạt động trên một lượng lớn dữ liệu rất nhanh và dễ dàng.

EDIT: Bạn cũng có thể hoàn toàn bỏ qua vòng lặp for và chỉ cần in trực tiếp, dễ dàng và hiệu quả hơn:

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

Hàm này thực hiện nhiều hơn yêu cầu của bạn, bằng cách hỗ trợ bước phủ định, v.v ... Miễn là bạn tính ra logic phạm vi của mình, thì bạn không cần riêng biệt day_countvà quan trọng nhất là mã trở nên dễ đọc hơn khi bạn gọi hàm từ nhiều nơi.

Đây là giải pháp dễ đọc nhất mà con người tôi có thể nghĩ ra.

import datetime

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

Sao không thử nhỉ:

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

arangeChức năng của Numpy có thể được áp dụng cho ngày:

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)

Việc sử dụng astypelà để chuyển đổi từ numpy.datetime64một mảng các datetime.datetimeđối tượng.

Hiển thị n ngày cuối cùng kể từ hôm nay:

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

Đầu ra:

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)

Để hoàn thiện, Pandas cũng có period_rangechức năng cho dấu thời gian nằm ngoài giới hạn:

import pandas as pd

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

Tôi có một vấn đề tương tự, nhưng tôi cần lặp đi lặp lại hàng tháng thay vì hàng ngày.

Đây là giải pháp của tôi

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

Ví dụ 1

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

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

Đầu ra

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

Ví dụ # 2

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

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

Đầu ra

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

Có thể 't * tin rằng câu hỏi này đã tồn tại 9 năm mà không ai thấy một hàm đệ quy đơn giản:

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)

Đầu ra:

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

Chỉnh sửa: * Bây giờ tôi có thể tin điều đó - xem Python có tối ưu hóa đệ quy đuôi không? . Cảm ơn bạn Tim .

Bạn có thể tạo một chuỗi ngày giữa hai ngày bằng thư viện gấu trúc một cách đơn giản và đáng tin cậy

import pandas as pd

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

Bạn có thể thay đổi tần suất tạo ngày bằng cách đặt freq là D, M, Q, Y (hàng ngày, hàng tháng, hàng quý, hàng năm)

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

Chức năng này có một số tính năng bổ sung:

• có thể vượt qua một chuỗi khớp với DATE_FORMAT để bắt đầu hoặc kết thúc và nó được chuyển đổi thành một đối tượng ngày
• có thể vượt qua một đối tượng ngày để bắt đầu hoặc kết thúc

• kiểm tra lỗi trong trường hợp kết thúc cũ hơn bắt đầu

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

Đây là mã cho một hàm phạm vi ngày chung, tương tự như câu trả lời của Ber, nhưng linh hoạt hơn:

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

Điều gì về những điều sau đây để thực hiện một phạm vi tăng theo ngày:

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

• startDate và stopDate là các đối tượng datetime.date

Đối với phiên bản chung:

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

• startTime và stopTime là đối tượng datetime.date hoặc datetime.datetime (cả hai nên cùng loại)
• stepTime là một đối tượng timedelta

Lưu ý rằng .total_seconds () chỉ được hỗ trợ sau python 2.7 Nếu bạn bị kẹt với phiên bản cũ hơn, bạn có thể viết hàm của riêng mình:

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

Cách tiếp cận hơi khác nhau đối với các bước có thể đảo ngược bằng cách lưu trữ rangeargs trong một 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')

ĐẦU RA:

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