पायथन में तारीखों की एक श्रृंखला के माध्यम से Iterating

367

मेरे पास ऐसा करने के लिए निम्न कोड है, लेकिन मैं इसे बेहतर कैसे कर सकता हूं? अभी मुझे लगता है कि यह नेस्टेड लूप्स से बेहतर है, लेकिन यह तब शुरू होता है जब आपको लिस्ट कंप्रैशन में जनरेटर होता है।

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

टिप्पणियाँ

  • मैं वास्तव में इसे प्रिंट करने के लिए उपयोग नहीं कर रहा हूं। यह सिर्फ डेमो प्रयोजनों के लिए है।
  • start_dateऔर end_dateचर हैं datetime.dateक्योंकि मैं टाइम स्टांप की जरूरत नहीं है वस्तुओं। (वे एक रिपोर्ट उत्पन्न करने के लिए इस्तेमाल होने जा रहे हैं)।

नमूना आउटपुट

की एक आरंभ तिथि 2009-05-30और अंतिम तिथि 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
python  datetime  iteration 
— ShawnMilo
स्रोत
3
केवल यह बताने के लिए: मुझे नहीं लगता कि 'time.strftime ("% Y-% m-% d", single_date.timetuple ()) और छोटे' single_date.strftime ("% Y-%) के बीच कोई अंतर नहीं है m-% d ") '। अधिकांश उत्तर लंबी शैली की नकल करते प्रतीत होते हैं।
— मु। माइंड
8
वाह, ये जवाब बहुत जटिल हैं। इसे आज़माएं: stackoverflow.com/questions/7274267/…
— ग्रिंगो ने
@GringoSuave: शॉन कैवनघ के उत्तर के बारे में क्या जटिल है ?
— JFS
आवेदन: GitHub लकीर पर धोखा: stackoverflow.com/questions/20099235/…
— Ciro Santilli Sant it it it ''
1
डुप्लिकेट या नहीं, आपको दूसरे पृष्ठ पर एक सरल उत्तर मिलेगा।
— ग्रिंगो सुवे

जवाबों:

552

दो नेस्टेड पुनरावृत्तियों क्यों हैं? मेरे लिए यह केवल एक पुनरावृत्ति के साथ डेटा की समान सूची तैयार करता है:

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

और कोई भी सूची संग्रहित नहीं की जाती है, केवल एक जनरेटर से अधिक पुनरावृत्त होता है। साथ ही जनरेटर में "यदि" अनावश्यक लगता है।

आखिरकार, एक रैखिक अनुक्रम में केवल एक पुनरावृत्ति की आवश्यकता होनी चाहिए, दो नहीं।

जॉन मैकिन के साथ चर्चा के बाद अपडेट:

हो सकता है कि तारीखों की सीमा पर पुनरावृति को पूरी तरह से छिपाने / अमूर्त करने के लिए सबसे सुरुचिपूर्ण समाधान एक जनरेटर फ़ंक्शन का उपयोग कर रहा हो:

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

एनबी: अंतर्निहित range()फ़ंक्शन के साथ स्थिरता के लिए यह पुनरावृत्ति पहुंचने से पहले बंद हो जाता है end_date। इसलिए समावेशी पुनरावृत्ति के लिए अगले दिन का उपयोग करें, जैसा कि आप करेंगे range()।

— बेर
स्रोत
4
-1 ... day_count की प्रारंभिक गणना और रेंज का उपयोग करना भयानक नहीं है जब एक सरल जबकि लूप पर्याप्त होगा।
— जॉन मैकिन
7
@ जॉन मैकिन: ठीक है। मैं हालांकि कुछ काउंटर या मूल्य के स्पष्ट वृद्धि के साथ छोरों पर एक चलना शुरू करना। हस्तक्षेप पैटर्न अधिक पायथोनिक है (कम से कम मेरे व्यक्तिगत विचार में) और अधिक सामान्य भी है, क्योंकि यह कैसे पुनरावृत्ति किया जाता है, इसका विवरण छिपाते हुए एक पुनरावृत्ति व्यक्त करने की अनुमति देता है।
— बेर
10
@ बियर: मुझे यह बिल्कुल पसंद नहीं है; यह पूरी तरह से बुरा है। आप पहले से ही एक चलना था! एक जनरेटर में शिकायत-किए गए निर्माणों को लपेटकर, आपने अधिक निष्पादन ओवरहेड जोड़ दिया है और आपके 3-लाइनर कोड और / या डॉक्स को पढ़ने के लिए उपयोगकर्ता का ध्यान कहीं और भेज दिया है। -2
— जॉन माकिन
8
@ जॉन मैकिन: मैं असहमत हूं। बिंदु पंक्तियों की संख्या को न्यूनतम न्यूनतम तक कम करने के बारे में नहीं है। आखिर, हम यहां पर्ल से बात नहीं कर रहे हैं। इसके अलावा, मेरा कोड केवल एक पुनरावृत्ति करता है (यह है कि जनरेटर कैसे काम करता है, लेकिन मुझे लगता है कि आप जानते हैं कि)। *** मेरी बात फिर से उपयोग और आत्म व्याख्यात्मक कोड के लिए अमूर्त अवधारणाओं के बारे में है। मैं यह कहता हूं कि यह सबसे कम कोड की तुलना में कहीं अधिक सार्थक है।
— बेर
9
यदि आप मरोड़ के लिए जा रहे हैं, तो आप एक जनरेटर अभिव्यक्ति का उपयोग कर सकते हैं:(start_date + datetime.timedelta(n) for n in range((end_date - start_date).days))
— मार्क रैनसम
219

यह अधिक स्पष्ट हो सकता है:

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
— सीन कैवनाग
स्रोत
3
बहुत स्पष्ट और संक्षिप्त, लेकिन अच्छी तरह से काम नहीं करता है अगर आप जारी रखना चाहते हैं
— rslite
मेरे उपयोग के मामले के लिए प्यारा काम करता है
— प्रलय
169

dateutilपुस्तकालय का उपयोग करें :

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

इस पाइथन लाइब्रेरी में कई और उन्नत सुविधाएँ हैं, कुछ बहुत उपयोगी हैं, जैसे- relative deltaऔर इसे एक फ़ाइल (मॉड्यूल) के रूप में लागू किया जाता है जो आसानी से एक परियोजना में शामिल है।

— nosklo
स्रोत
3
ध्यान दें कि पाश यहाँ में अंतिम तारीख है समावेशी की untilजबकि के अंतिम तारीख daterangeमें विधि बेर का जवाब है अनन्य की end_date।
— निंजाकन्नन
अधिक आधुनिक डॉक्स dateutil.readthedocs.io/en/stable/rrule.html
— qwr
77

पंडों सामान्य रूप से समय श्रृंखला के लिए महान है, और तिथि सीमाओं के लिए प्रत्यक्ष समर्थन है।

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

फिर आप दिनांक को प्रिंट करने के लिए daterange पर लूप कर सकते हैं:

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

जीवन को आसान बनाने के लिए इसके पास बहुत सारे विकल्प हैं। उदाहरण के लिए यदि आप केवल कार्यदिवस चाहते हैं, तो आप बस bdate_range में स्वैप करेंगे। Http://pandas.pydata.org/pandas-docs/stable/timeseries.html#generating-ranges-of-timestamps देखें

पंडों की शक्ति वास्तव में इसके डेटाफ्रेम हैं, जो वेक्टराइज्ड ऑपरेशंस का समर्थन करते हैं (बहुत अधिक सुन्न जैसा) जो बड़ी मात्रा में डेटा को बहुत तेजी से और आसानी से संचालित करते हैं।

संपादित करें: आप लूप के लिए पूरी तरह से छोड़ सकते हैं और इसे सीधे प्रिंट कर सकते हैं, जो आसान और अधिक कुशल है:

print(daterange)
— fantabolous
स्रोत
"बहुत पसंद है" - पंडों को सुपी पर बनाया गया है: P
— Zach Saucier
15 
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())

नकारात्मक चरण का समर्थन करके, इस फ़ंक्शन को आपकी आवश्यकता से अधिक की आवश्यकता होती है, आदि जब तक आप अपनी सीमा तर्क को समाप्त करते हैं, तब आपको अलग-अलग की आवश्यकता नहीं होती है day_countऔर सबसे महत्वपूर्ण रूप से कोड को पढ़ना आसान हो जाता है क्योंकि आप कई से फ़ंक्शन को कॉल करते हैं स्थानों।

धन्यवाद, अधिक बारीकी से मैच रेंज के मापदंडों का नाम बदलकर, शरीर में बदलना भूल गया।
+1 ... लेकिन जैसा कि आप चरण को समयसीमा होने की अनुमति दे रहे हैं, आपको या तो (a) इसे डेटटाइमेंज () कॉल करना चाहिए और उदाहरण के लिए समयसीमा (घंटे = 12) और समयसीमा (घंटे = 36) के चरण बनाने चाहिए या () b) ट्रैप चरण जो दिनों की एक अभिन्न संख्या नहीं हैं या (c) कॉल करने वाले को परेशानी से बचाते हैं और समयसीमा के बजाय कई दिनों तक चरण को व्यक्त करते हैं।
— जॉन मैकिन
किसी भी समयबद्धता को पहले से ही काम करना चाहिए, लेकिन मैंने (क) के लिखने के बाद अपने व्यक्तिगत स्क्रैप संग्रह में डेटाइम_रेन्ज और डेट_रेंज जोड़ दिया। सुनिश्चित नहीं है कि (c) किसी अन्य फ़ंक्शन के लिए सार्थक है, दिनों का सबसे आम मामला = 1 पहले से ही ध्यान रखा गया है, और एक स्पष्ट समयसीमा को पारित करने से भ्रम से बचा जाता है। शायद इसे कहीं अपलोड करना सबसे अच्छा है: bitbucket.org/kniht/scraps/src/tip/python/gen_range.py
दिनों की तुलना में अन्य वेतन वृद्धि पर इस काम करने के लिए आप step.total_seconds के खिलाफ () नहीं की जाँच करनी चाहिए, और step.days
— amohr
12

यह सबसे मानव-पठनीय समाधान है जिसके बारे में मैं सोच सकता हूं।

import datetime

def daterange(start, end, step=datetime.timedelta(1)):
    curr = start
    while curr < end:
        yield curr
        curr += step
— पैट्रिक
स्रोत
11

क्यों नहीं कोशिश करो:

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
— जॉन
स्रोत
7

Numpy के arangeसमारोह तारीखों के लिए लागू किया जा सकता है:

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)

का उपयोग वस्तुओं की एक सरणी astypeसे परिवर्तित numpy.datetime64करना है datetime.datetime।

— टो
स्रोत
सुपर दुबला निर्माण! आखिरी लाइन मेरे लिएdates = np.arange(d0, d1, dt).astype(datetime.datetime)
— pyano
एक सामान्य एक-लाइनर समाधान को पोस्ट करने के लिए +1 जो किसी भी समयबद्ध कदम जैसे कि प्रति घंटा / मिनट / के बजाय किसी भी समयबद्धता की अनुमति देता है।
— एफ। रैब
7

आज से अंतिम n दिन दिखाएं:

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

आउटपुट: 

2016-06-29
2016-06-30
2016-07-01
2016-07-02
2016-07-03
2016-07-04
— user1767754
स्रोत
कृपया गोल कोष्ठक जोड़ें, जैसेprint((datetime.date.today() + datetime.timedelta(i)).isoformat())
— टाइटनफाइटर
@TitanFighter संपादन करने के लिए स्वतंत्र महसूस कृपया, मैं उन्हें स्वीकार करेंगे।
— user1767754
2
मैंने कोशिश की। संपादन के लिए न्यूनतम 6 वर्णों की आवश्यकता होती है, लेकिन इस मामले में सिर्फ 2 वर्णों को जोड़ना आवश्यक है, "(" और ")"
— टाइटनफाइटर
print((datetime.date.today() + datetime.timedelta(i)))बिना .isoformat () के समान आउटपुट देता है। मुझे YYMMDD को प्रिंट करने के लिए मेरी स्क्रिप्ट की आवश्यकता है। कोई जानता है कि उसे कैसे करना है?
— mr.zog
बस प्रिंट स्टेटमेंट के बजाय लूप के लिए ऐसा करेंd = datetime.date.today() + datetime.timedelta(i); d.strftime("%Y%m%d")
— user1767754
5 
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))
— जॉन माचिन
स्रोत
4

पूर्णता के लिए, पंडों के पास period_rangeटाइमस्टैम्प के लिए एक फ़ंक्शन है जो सीमा से बाहर हैं:

import pandas as pd

pd.period_range(start='1/1/1626', end='1/08/1627', freq='D')
— रिक होकेस्ट्रा
स्रोत
3

मुझे एक समान समस्या है, लेकिन मुझे दैनिक के बजाय मासिक रूप से पुनरावृत्त करने की आवश्यकता है।

यह मेरा समाधान है

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

उदाहरण 1

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

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

उत्पादन

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

उदाहरण # 2

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

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

उत्पादन

2017-01-01
2016-12-01
2016-11-01
2016-10-01
2016-09-01
2016-08-01
2016-07-01
2016-06-01
— juanmhidalgo
स्रोत
3

कर सकते हैं 'टी * एक सरल पुनरावर्ती क्रिया का सुझाव दे किसी को भी बिना विश्वास है कि इस सवाल का 9 साल के लिए ही अस्तित्व में है:

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)

आउटपुट:

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

संपादित करें: * अब मैं इस पर विश्वास कर सकता हूं - क्या पायथन पूंछ पुनरावृत्ति का अनुकूलन करता है? । धन्यवाद टिम ।

— Pocketsand
स्रोत
3
आप पुनरावृत्ति के साथ एक साधारण लूप को क्यों बदलेंगे? यह उन सीमाओं के लिए टूटता है जो लगभग ढाई साल से अधिक लंबे होते हैं।
— टिम-इरविन
@ टिम-इरविन ईमानदारी से मुझे नहीं पता था कि सीपीथॉन पूंछ की पुनरावृत्ति का अनुकूलन नहीं करता है इसलिए आपकी टिप्पणी मूल्यवान है।
— पॉकेटैंड
2

आप केवल और विश्वसनीय तरीके से पंडों के पुस्तकालय का उपयोग करके दो तिथियों के बीच की तारीख की एक श्रृंखला उत्पन्न कर सकते हैं

import pandas as pd

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

आप डी, एम, क्यू, वाई (दैनिक, मासिक, त्रैमासिक, वार्षिक) के रूप में फ्रीक सेट करके दिनांक बनाने की आवृत्ति को बदल सकते हैं

— शिंटो जोसेफ
स्रोत
पहले से ही इस धागे में 2014 में जवाब दिया
— एलेक्सी वाज़नोव
2 
> 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']
— LetzerWille
स्रोत
1

इस समारोह में कुछ अतिरिक्त विशेषताएं हैं:

  • प्रारंभ या समाप्ति के लिए DATE_FORMAT से मेल खाता स्ट्रिंग पास कर सकता है और इसे दिनांक ऑब्जेक्ट में बदल दिया जाता है
  • प्रारंभ या समाप्ति के लिए कोई दिनांक ऑब्जेक्ट पास कर सकता है

  • अंत के मामले में त्रुटि की जाँच शुरू से पुरानी है

    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))
— dmmfll
स्रोत
1

यहाँ एक सामान्य तिथि सीमा फ़ंक्शन के लिए कोड है, जो बेर के उत्तर के समान है, लेकिन अधिक लचीला है:

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'.")
— कछुए प्यारे हैं
स्रोत
0

दिनों के हिसाब से बढ़ाई गई सीमा के लिए निम्नलिखित के बारे में क्या:

for d in map( lambda x: startDate+datetime.timedelta(days=x), xrange( (stopDate-startDate).days ) ):
  # Do stuff here
  • startDate और stopDate डेटाइम.डेट ऑब्जेक्ट हैं

एक सामान्य संस्करण के लिए:

for d in map( lambda x: startTime+x*stepTime, xrange( (stopTime-startTime).total_seconds() / stepTime.total_seconds() ) ):
  # Do stuff here
  • स्टार्टटाइम और स्टॉपटाइम डेटाटाइमटाइम या डेटटाइम लाइफटाइम ऑब्जेक्ट हैं (दोनों एक ही प्रकार के होने चाहिए)
  • stepTime एक समयबद्ध वस्तु है

ध्यान दें कि .total_seconds () केवल python 2.7 के बाद समर्थित है। यदि आप पहले वाले संस्करण से चिपके हुए हैं तो आप अपना स्वयं का फ़ंक्शन लिख सकते हैं:

def total_seconds( td ):
  return float(td.microseconds + (td.seconds + td.days * 24 * 3600) * 10**6) / 10**6
— teambob
स्रोत
0

rangeएक ट्यूपल में आर्गन्स को संचय करके प्रतिवर्ती चरणों के लिए थोड़ा अलग दृष्टिकोण ।

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)
— GollyJer
स्रोत
0 
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')

उत्पादन:

2019Jan10
2019Jan11
2019Jan12
2019Jan13
2019Jan14
2019Jan15
2019Jan16
2019Jan17
2019Jan18
2019Jan19
2019Jan20
2019Jan21
2019Jan22
2019Jan23
2019Jan24
2019Jan25
2019Jan26
2019Jan27
2019Jan28
2019Jan29
2019Jan30
2019Jan31
2019Feb01
2019Feb02
— हन्नान शकी
स्रोत
ढेर अतिप्रवाह में आपका स्वागत है! हालांकि यह कोड प्रश्न को हल कर सकता है, जिसमें यह व्याख्या भी शामिल है कि यह समस्या कैसे और क्यों हल करती है, विशेष रूप से बहुत अच्छे उत्तरों के साथ प्रश्नों पर, वास्तव में आपकी पोस्ट की गुणवत्ता में सुधार करने में मदद करेगी, और संभवतः अधिक परिणाम देगा। याद रखें कि आप भविष्य में पाठकों के लिए प्रश्न का उत्तर दे रहे हैं, न कि केवल उस व्यक्ति से जो अब पूछ रहा है। स्पष्टीकरण जोड़ने के लिए कृपया अपना उत्तर संपादित करें और संकेत दें कि क्या सीमाएँ और मान्यताएँ लागू होती हैं। समीक्षा से
— डबल-बीप
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.