महीने का आखिरी दिन कैसे प्राप्त करें?

Question

क्या दिए गए महीने के अंतिम दिन को आसानी से निर्धारित करने के लिए पायथन के मानक पुस्तकालय का उपयोग करने का एक तरीका है (यानी एक फ़ंक्शन कॉल)?

यदि मानक पुस्तकालय उस का समर्थन नहीं करता है, तो क्या डेटुटाइल पैकेज इसका समर्थन करता है?

Answer 1

मैंने इसे पहले नहीं देखा था जब मैं मॉड्यूल के लिए दस्तावेजcalendar देख रहा था , लेकिन एक विधि जिसे monthrangeयह जानकारी प्रदान करता है:

महीने की व्यवस्था (वर्ष, माह) महीने
    के पहले दिन का सप्ताह का दिन और महीने में दिनों की संख्या, निर्दिष्ट वर्ष और महीने के लिए।

>>> import calendar
>>> calendar.monthrange(2002,1)
(1, 31)
>>> calendar.monthrange(2008,2)
(4, 29)
>>> calendar.monthrange(2100,2)
(0, 28)

इसलिए:

calendar.monthrange(year, month)[1]

जाने का सबसे सरल तरीका लगता है।

बस स्पष्ट होने के लिए, monthrangeलीप वर्ष का समर्थन करता है:

>>> from calendar import monthrange
>>> monthrange(2012, 2)
(2, 29)

मेरा पिछला उत्तर अभी भी काम करता है, लेकिन स्पष्ट रूप से उप-रूपी है।

Comments

यह मूल प्रश्न का सही उत्तर नहीं है! क्या होगा अगर महीने का आखिरी दिन शनि / सूर्य हो।

— महदी

@ मेहदी: यह सही है, दूसरा नंबर "माह में दिनों की एनआर" == "आखिरी दिन" है, भले ही वह दिन कैसा भी हो।

— रिका डे

यह वर्ष 1800 के लिए गलत दिन है। मैं यह नहीं मिलता है

— sword1st

@ तलवार 1st, मैं 28जवाब के रूप में देखता हूं , जो कि सही है, ग्रेगोरियन कैलेंडर के नियमों

— ब्लेयर कॉनरैड

मैं केवल एक ही monthrangeभ्रमित करने वाला नाम नहीं हो सकता । आपको लगता है कि यह लौटेगा (first_day, last_day), नहीं(week_day_of_first_day, number_of_days)

— फ्लिम

Answer 2

यदि आप calendarमॉड्यूल को आयात नहीं करना चाहते हैं , तो एक सरल दो-चरण फ़ंक्शन भी हो सकता है:

import datetime

def last_day_of_month(any_day):
    next_month = any_day.replace(day=28) + datetime.timedelta(days=4)  # this will never fail
    return next_month - datetime.timedelta(days=next_month.day)

आउटपुट:

>>> for month in range(1, 13):
...     print last_day_of_month(datetime.date(2012, month, 1))
...
2012-01-31
2012-02-29
2012-03-31
2012-04-30
2012-05-31
2012-06-30
2012-07-31
2012-08-31
2012-09-30
2012-10-31
2012-11-30
2012-12-31

Answer 3

संपादित करें: क्लीनर समाधान के लिए @Blair कॉनराड का जवाब देखें

---

>>> import datetime
>>> datetime.date(2000, 2, 1) - datetime.timedelta(days=1)
datetime.date(2000, 1, 31)

Comments

मैं वास्तव में इस क्लीनर को बुलाऊंगा, इस तथ्य को छोड़कर कि यह दिसंबर में विफल रहता है जब today.month + 1 == 13आपको मिलता है ValueError।

— fletom

आप इसका उपयोग करके हल कर सकते हैं (today.month % 12) + 1क्योंकि 12 % 120

— bluesmoon

महीने के 31 वें दिन कुछ अजीब डेलाइट सेविंग स्विच (मुझे लगता है कि आज मौजूद नहीं है, लेकिन भविष्य अलग हो सकता है) उस महीने के 31 वें को सिर्फ 23 घंटे की लंबाई के साथ प्रस्तुत कर सकता है, ताकि एक दिन घटाना आपको मदद कर सके 30 तारीख को 23:00:00 बजे समाप्त होगा। यह एक अजीब मामला है, यकीन है, लेकिन यह दिखाता है कि दृष्टिकोण ध्वनि नहीं है।

— अल्फ

Answer 4

यह dateutil.relativedelta(पाइप के लिए पैकेज पायथन-डेटेटिल) के साथ वास्तव में बहुत आसान है । day=31हमेशा महीने के आखिरी दिन लौटेंगे।

उदाहरण:

from datetime import datetime
from dateutil.relativedelta import relativedelta

date_in_feb = datetime.datetime(2013, 2, 21)
print datetime.datetime(2013, 2, 21) + relativedelta(day=31)  # End-of-month
>>> datetime.datetime(2013, 2, 28, 0, 0)

Comments

मैं व्यक्तिगत रूप से relativedelta पसंद करता हूं (महीने = + 1, सेकंड = -1) और अधिक स्पष्ट लगता है कि क्या चल रहा है

— BenH

तुम गलत हो। datetime(2014, 2, 1) + relativedelta(days=31)देता है datetime(2014, 3, 4, 0, 0)...

— इमैनुएल

आपने दिन के बजाय = = दिन का उपयोग किया

— विंस स्पाइसर

@BenH इस उम्मीद पर आधारित है (मुझे यकीन नहीं है कि यह निर्दिष्ट है) कि पहले monthsजोड़ा गया है, फिर secondsघटाया गया है। चूंकि वे पारित हो चुके हैं, इसलिए **kwargsमैं उस पर भरोसा नहीं करूंगा और अलग-अलग ऑपरेशन की श्रृंखला करूंगा: now + relative(months=+1) + relative(day=1) + relative(days=-1)जो कि असंदिग्ध है।

— अल्फ

last_day = (<datetime_object> + relativedelta(day=31)).day

— user12345

Answer 5

संपादित करें: मेरा अन्य उत्तर देखें । यह इस से बेहतर कार्यान्वयन है, जिसे मैं सिर्फ इस मामले में छोड़ देता हूं कि किसी को यह देखने में दिलचस्पी है कि कोई व्यक्ति आपके "कैलकुलेटर" को कैसे रोल कर सकता है।

@ जॉन मिलिकिन एक अच्छा जवाब देता है, अगले महीने के पहले दिन की गणना की अतिरिक्त जटिलता के साथ।

निम्नलिखित विशेष रूप से सुरुचिपूर्ण नहीं है, लेकिन इस महीने के अंतिम दिन का पता लगाने के लिए कि किसी भी तारीख में रहता है, आप कोशिश कर सकते हैं:

def last_day_of_month(date):
    if date.month == 12:
        return date.replace(day=31)
    return date.replace(month=date.month+1, day=1) - datetime.timedelta(days=1)

>>> last_day_of_month(datetime.date(2002, 1, 17))
datetime.date(2002, 1, 31)
>>> last_day_of_month(datetime.date(2002, 12, 9))
datetime.date(2002, 12, 31)
>>> last_day_of_month(datetime.date(2008, 2, 14))
datetime.date(2008, 2, 29)

Comments

यह मूर्खतापूर्ण लगता है लेकिन मुझे इस तरह से महीने का पहला दिन कैसे मिलता है।

— किशन

यह हमेशा 1 नहीं है?

— ब्लेयर कॉनराड

हाँ, लेकिन मैं उलझन में था कि मैं कुछ इस तरह से देख रहा था: start_date = date (datetime.now ()। वर्ष, datetime.now ()। माह, 1)

— किशन

आह। today = datetime.date.today(); start_date = today.replace(day=1)। यदि आप इसे 31 दिसंबर को आधी रात से पहले और फिर आधी रात के बाद कहते हैं, तो आप दो बार कॉल करने से बचना चाहेंगे। आपको 2016-12-01 या 2017-01-01 के बजाय 2016-01-01 मिलेगा।

— ब्लेयर कॉनराड

यह एक सीधा-सादा उदाहरण समझने और लौटाने के लिए बहुत सरल है, जो कई मामलों में उपयोगी हो सकता है। एक अन्य लाभ यह है कि यह काम करता है यदि इनपुट dateएक उदाहरण है datetime.date, datetime.datetimeऔर यह भी pandas.Timestamp।

— गिलहर्मे सालोमे

Answer 6

का उपयोग करते हुए dateutil.relativedeltaआप इस तरह माह के अंतिम तिथि मिलेगा:

from dateutil.relativedelta import relativedelta
last_date_of_month = datetime(mydate.year, mydate.month, 1) + relativedelta(months=1, days=-1)

यह विचार है कि महीने के पहले दिन को प्राप्त करें और relativedelta1 महीने आगे और 1 दिन पहले जाने का उपयोग करें ताकि आपको उस महीने का अंतिम दिन मिल जाए जो आप चाहते थे।

Answer 7

एक और उपाय कुछ इस तरह करना होगा:

from datetime import datetime

def last_day_of_month(year, month):
    """ Work out the last day of the month """
    last_days = [31, 30, 29, 28, 27]
    for i in last_days:
        try:
            end = datetime(year, month, i)
        except ValueError:
            continue
        else:
            return end.date()
    return None

और इस तरह फ़ंक्शन का उपयोग करें:

>>> 
>>> last_day_of_month(2008, 2)
datetime.date(2008, 2, 29)
>>> last_day_of_month(2009, 2)
datetime.date(2009, 2, 28)
>>> last_day_of_month(2008, 11)
datetime.date(2008, 11, 30)
>>> last_day_of_month(2008, 12)
datetime.date(2008, 12, 31)

Comments

बहुत जटिल है, अजगर के ज़ेन के तीसरे नियम को तोड़ता है।

— 22:39 पर 22:39

Answer 8

from datetime import timedelta
(any_day.replace(day=1) + timedelta(days=32)).replace(day=1) - timedelta(days=1)

Comments

यह क्या बग से बना है;) 31 जनवरी के साथ कोशिश करें

— LeartS

@LeartS: यह मेरे लिए काम करता है। आपकी कोशिश के व़क्त क्या होता है?

— कोलिन एंडरसन

यह काम करता हैं। any_day 31 जनवरी है, हम दिन को 1 से बदलते हैं, इसलिए 1 जनवरी को, 32 दिन जोड़ते हैं, हमें फ़रवरी 2 मिलता है, दिन = 1 के साथ फिर से मिलता है और हमें 1 फरवरी मिलता है। एक दिन घटाएं और हमें 31 जनवरी मिलेगा। मैं नहीं देखता मुद्दा क्या है। किस दिन क्या मिलेगा?

— कोलिन एंडरसन

Answer 9

>>> import datetime
>>> import calendar
>>> date  = datetime.datetime.now()

>>> print date
2015-03-06 01:25:14.939574

>>> print date.replace(day = 1)
2015-03-01 01:25:14.939574

>>> print date.replace(day = calendar.monthrange(date.year, date.month)[1])
2015-03-31 01:25:14.939574

Answer 10

यदि आप बाहरी पुस्तकालय का उपयोग करने के इच्छुक हैं, तो http://crsmithdev.com/arrow/ देखें।

यू तो महीने के अंतिम दिन के साथ मिल सकता है:

import arrow
arrow.utcnow().ceil('month').date()

यह एक दिनांक ऑब्जेक्ट देता है जिसे आप तब अपना हेरफेर कर सकते हैं।

Answer 11

महीने की आखिरी तारीख पाने के लिए हम कुछ इस तरह करते हैं:

from datetime import date, timedelta
import calendar
last_day = date.today().replace(day=calendar.monthrange(date.today().year, date.today().month)[1])

अब हम यहाँ क्या कर रहे हैं यह समझाने के लिए हम इसे दो भागों में तोड़ेंगे:

पहले को चालू महीने के दिनों की संख्या मिल रही है, जिसके लिए हम उस महीने का उपयोग करते हैं जो ब्लेयर कॉनरैड ने पहले ही अपने समाधान का उल्लेख किया है:

calendar.monthrange(date.today().year, date.today().month)[1]

दूसरा अंतिम तिथि को ही प्राप्त हो रहा है, जिसे हम उदाहरण के लिए प्रतिस्थापित कर रहे हैं

>>> date.today()
datetime.date(2017, 1, 3)
>>> date.today().replace(day=31)
datetime.date(2017, 1, 31)

और जब हम उन्हें जोड़ते हैं तो शीर्ष पर उल्लिखित एक गतिशील समाधान मिलता है।

Comments

हालाँकि यह कोड समस्या को हल करने में मदद कर सकता है, लेकिन यह इस बात की व्याख्या नहीं करता कि क्यों और / या यह कैसे उत्तर देता है। इस अतिरिक्त संदर्भ को प्रदान करने से इसके दीर्घकालिक शैक्षिक मूल्य में काफी सुधार होगा। कृपया स्पष्टीकरण जोड़ने के लिए अपने जवाब को संपादित करें, जिसमें सीमाएं और मान्यताएं शामिल हैं।

— टोबी स्पाइट

यह सबसे सरल लगता है .. यदि आप इसे दो पंक्तियों को देने के लिए तैयार कर रहे हैं तो आप एक अच्छा प्राप्त कर सकते हैं, date.replace(day=day)इसलिए हर कोई जानता है कि क्या हो रहा है।

— एडम स्टार्र

Answer 12

पायथॉन 3.7 में अनिर्धारित calendar.monthlen(year, month)समारोह है :

>>> calendar.monthlen(2002, 1)
31
>>> calendar.monthlen(2008, 2)
29
>>> calendar.monthlen(2100, 2)
28

यह डॉक्यूमेंटेड calendar.monthrange(year, month)[1]कॉल के बराबर है ।

Comments

यह पायथन 3.8.1 पर काम करने के लिए प्रतीत नहीं होता है: एट्रीब्यूट: मॉड्यूल 'कैलेंडर' में कोई विशेषता 'महीनेलेन' नहीं है

— jeppoo1

@ jeppoo1: हाँ, यह bpo-28292 में निजी रूप से चिह्नित है - एक अनैच्छिक फ़ंक्शन के लिए अपेक्षित है।

— JFS

Answer 13

import datetime

now = datetime.datetime.now()
start_month = datetime.datetime(now.year, now.month, 1)
date_on_next_month = start_month + datetime.timedelta(35)
start_next_month = datetime.datetime(date_on_next_month.year, date_on_next_month.month, 1)
last_day_month = start_next_month - datetime.timedelta(1)

Answer 14

पांडा का उपयोग करें!

def isMonthEnd(date):
    return date + pd.offsets.MonthEnd(0) == date

isMonthEnd(datetime(1999, 12, 31))
True
isMonthEnd(pd.Timestamp('1999-12-31'))
True
isMonthEnd(pd.Timestamp(1965, 1, 10))
False

Comments

आप pd.series.dt.is_month_end लिंक

— पाब्लो

now=datetime.datetime.now(); pd_now = pd.to_datetime(now); print(pd_now.days_in_month)

— पांडस डेटाइम

Answer 15

मेरे लिए यह सबसे आसान तरीका है:

selected_date = date(some_year, some_month, some_day)

if selected_date.month == 12: # December
     last_day_selected_month = date(selected_date.year, selected_date.month, 31)
else:
     last_day_selected_month = date(selected_date.year, selected_date.month + 1, 1) - timedelta(days=1)

Answer 16

सबसे आसान तरीका (कैलेंडर आयात करने के बिना), अगले महीने का पहला दिन प्राप्त करना है, और फिर इसमें से एक दिन घटाना है।

import datetime as dt
from dateutil.relativedelta import relativedelta

thisDate = dt.datetime(2017, 11, 17)

last_day_of_the_month = dt.datetime(thisDate.year, (thisDate + relativedelta(months=1)).month, 1) - dt.timedelta(days=1)
print last_day_of_the_month

आउटपुट:

datetime.datetime(2017, 11, 30, 0, 0)

---

पुनश्च:import calendar दृष्टिकोण की तुलना में यह कोड तेजी से चलता है ; निचे देखो:

import datetime as dt
import calendar
from dateutil.relativedelta import relativedelta

someDates = [dt.datetime.today() - dt.timedelta(days=x) for x in range(0, 10000)]

start1 = dt.datetime.now()
for thisDate in someDates:
    lastDay = dt.datetime(thisDate.year, (thisDate + relativedelta(months=1)).month, 1) - dt.timedelta(days=1)

print ('Time Spent= ', dt.datetime.now() - start1)


start2 = dt.datetime.now()
for thisDate in someDates:
    lastDay = dt.datetime(thisDate.year, 
                          thisDate.month, 
                          calendar.monthrange(thisDate.year, thisDate.month)[1])

print ('Time Spent= ', dt.datetime.now() - start2)

उत्पादन:

Time Spent=  0:00:00.097814
Time Spent=  0:00:00.109791

यह कोड मानता है कि आप महीने के अंतिम दिन की तारीख चाहते हैं (यानी, केवल डीडी हिस्सा नहीं है, बल्कि पूरी YYYMMD तारीख)

Comments

आप क्यों नहीं करना चाहेंगे import calendar?

— एडम वेंचरला

क्योंकि यह तेज है। इसे शामिल करने के लिए मैंने अपना उत्तर ऊपर संशोधित किया है।

— विशाल

@Vishal आपको अवधारणा सही मिली लेकिन निम्न पंक्ति नहीं थी: `` dt.datetime (thisDate.year, (thisDate + relativedelta (महीने = 1)))। महीने, 1) - dt.dimedelta (दिन = 1) `। `` खासकर यदि माह वर्ष के अंत में हो। कोशिश करें `` `last_date_of_month = \ first_date_of_month + relativedelta (महीने = 1) - relativedelta (दिन = 1)` `` के बजाय

— XV

Answer 17

यहाँ एक और जवाब है। कोई अतिरिक्त पैकेज की आवश्यकता नहीं है।

datetime.date(year + int(month/12), month%12+1, 1)-datetime.timedelta(days=1)

अगले महीने का पहला दिन प्राप्त करें और उससे एक दिन घटाएं।

Answer 18

आप अंतिम तिथि की गणना स्वयं कर सकते हैं। साधारण तर्क अगले महीने के start_date से एक दिन घटाना है। :)

इसलिए एक कस्टम विधि लिखें,

import datetime

def end_date_of_a_month(date):


    start_date_of_this_month = date.replace(day=1)

    month = start_date_of_this_month.month
    year = start_date_of_this_month.year
    if month == 12:
        month = 1
        year += 1
    else:
        month += 1
    next_month_start_date = start_date_of_this_month.replace(month=month, year=year)

    this_month_end_date = next_month_start_date - datetime.timedelta(days=1)
    return this_month_end_date

कॉलिंग,

end_date_of_a_month(datetime.datetime.now().date())

यह इस महीने की अंतिम तारीख लौटाएगा। इस फंक्शन में किसी भी तारीख को पास करें। आपको उस महीने की अंतिम तारीख देता है।

Answer 19

आप relativedelta का उपयोग कर सकते हैं https://dateutil.readthedocs.io/en/stable/relativedelta.html month_end = <your datetime value within the month> + relativedelta(day=31) जो आपको अंतिम दिन देगा।

Answer 20

यह मेरे लिए सबसे आसान समाधान है जो सिर्फ मानक डेटाटाइम लाइब्रेरी का उपयोग कर रहा है:

import datetime

def get_month_end(dt):
    first_of_month = datetime.datetime(dt.year, dt.month, 1)
    next_month_date = first_of_month + datetime.timedelta(days=32)
    new_dt = datetime.datetime(next_month_date.year, next_month_date.month, 1)
    return new_dt - datetime.timedelta(days=1)

Answer 21

यह मुख्य प्रश्न को संबोधित नहीं करता है, लेकिन एक महीने में अंतिम कार्यदिवस प्राप्त करने के लिए एक अच्छी चाल है calendar.monthcalendar, जो तारीखों के एक मैट्रिक्स को लौटाता है, जो सोमवार के साथ पहले कॉलम के रूप में रविवार को अंतिम के रूप में आयोजित किया जाता है।

# Some random date.
some_date = datetime.date(2012, 5, 23)

# Get last weekday
last_weekday = np.asarray(calendar.monthcalendar(some_date.year, some_date.month))[:,0:-2].ravel().max()

print last_weekday
31

पूरी [0:-2]बात सप्ताहांत के कॉलम को बंद करने और उन्हें बाहर फेंकने के लिए है। महीने के बाहर आने वाली तिथियां 0 से इंगित होती हैं, इसलिए अधिकतम प्रभावी रूप से उनकी उपेक्षा करता है।

का उपयोग numpy.ravelकड़ाई से आवश्यक नहीं है, लेकिन मैं मात्र सम्मेलन पर भरोसा करने से नफरत करता हूं जो कि numpy.ndarray.maxसरणी को समतल कर देगा यदि यह नहीं बताया गया है कि किस धुरी पर गणना करना है।

Answer 22

import calendar
from time import gmtime, strftime
calendar.monthrange(int(strftime("%Y", gmtime())), int(strftime("%m", gmtime())))[1]

आउटपुट:

31

यह चालू माह जो भी है, उसके अंतिम दिन को प्रिंट करेगा। इस उदाहरण में यह १५ मई २०१६ था। इसलिए आपका आउटपुट अलग हो सकता है, हालाँकि आउटपुट चालू माह जितना ही होगा। महान यदि आप दैनिक क्रोन नौकरी चलाकर महीने के अंतिम दिन की जांच करना चाहते हैं।

इसलिए:

import calendar
from time import gmtime, strftime
lastDay = calendar.monthrange(int(strftime("%Y", gmtime())), int(strftime("%m", gmtime())))[1]
today = strftime("%d", gmtime())
lastDay == today

आउटपुट:

False

जब तक यह महीने का आखिरी दिन न हो।

Answer 23

मैं इस तरह से पसंद करता हूं

import datetime
import calendar

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

Answer 24

यदि आप अपना छोटा कार्य करना चाहते हैं, तो यह एक अच्छा प्रारंभिक बिंदु है:

def eomday(year, month):
    """returns the number of days in a given month"""
    days_per_month = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]
    d = days_per_month[month - 1]
    if month == 2 and (year % 4 == 0 and year % 100 != 0 or year % 400 == 0):
        d = 29
    return d

इसके लिए आपको लीप वर्षों के नियमों को जानना होगा:

• हर चौथे साल
• हर 100 साल के अपवाद के साथ
• लेकिन हर 400 साल बाद

Comments

ज़रूर, लेकिन सिस्टम पुस्तकालयों में पहले से ही यह डेटा है, और नियमों को बदलना चाहिए क्योंकि पुस्तकालयों का अद्यतन किसी और की समस्या है।

— जैसन

ठीक है, संभव है, लेकिन अत्यधिक संभावना नहीं है, और यहां तक ​​कि अगर - यह केवल आपको लगभग 2000 वर्षों में

— काटेगा

ये नियम अतीत में 500 साल तक काम नहीं करते हैं, मुझे विश्वास नहीं है कि वे भविष्य में हजारों साल तक खड़े रहेंगे,

— जैसन

Answer 25

यदि आप दिनांक सीमा में पास होते हैं, तो आप इसका उपयोग कर सकते हैं:

def last_day_of_month(any_days):
    res = []
    for any_day in any_days:
        nday = any_day.days_in_month -any_day.day
        res.append(any_day + timedelta(days=nday))
    return res

Answer 26

नीचे दिए गए कोड में 'get_last_day_of_month (dt)' यह आपको 'YYYY-MM-DD' जैसे स्ट्रिंग प्रारूप में तारीख के साथ देगा।

import datetime

def DateTime( d ):
    return datetime.datetime.strptime( d, '%Y-%m-%d').date()

def RelativeDate( start, num_days ):
    d = DateTime( start )
    return str( d + datetime.timedelta( days = num_days ) )

def get_first_day_of_month( dt ):
    return dt[:-2] + '01'

def get_last_day_of_month( dt ):
    fd = get_first_day_of_month( dt )
    fd_next_month = get_first_day_of_month( RelativeDate( fd, 31 ) )
    return RelativeDate( fd_next_month, -1 )

Answer 27

सबसे सरल तरीका है datetimeकुछ गणित का उपयोग करना , जैसे कि अगले महीने के पहले दिन से एक दिन घटाना:

import datetime

def last_day_of_month(d: datetime.date) -> datetime.date:
    return (
        datetime.date(d.year + d.month//12, d.month % 12 + 1, 1) -
        datetime.timedelta(days=1)
    )

वैकल्पिक रूप से, आप calendar.monthrange()एक महीने में दिनों की संख्या प्राप्त करने के लिए उपयोग कर सकते हैं (खाते में लीप वर्ष लेते हुए) और तदनुसार तारीख अपडेट करें:

import calendar, datetime

def last_day_of_month(d: datetime.date) -> datetime.date:
    return d.replace(day=calendar.monthrange(d.year, d.month)[1])

एक त्वरित बेंचमार्क दर्शाता है कि पहला संस्करण काफ़ी तेज़ है:

In [14]: today = datetime.date.today()

In [15]: %timeit last_day_of_month_dt(today)
918 ns ± 3.54 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)

In [16]: %timeit last_day_of_month_calendar(today)
1.4 µs ± 17.3 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)

Answer 28

यहां एक लंबा (समझने में आसान) संस्करण है लेकिन लीप वर्षों का ध्यान रखता है।

चीयर्स, जेके

def last_day_month(year, month):
    leap_year_flag = 0
    end_dates = {
        1: 31,
        2: 28,
        3: 31,
        4: 30,
        5: 31,
        6: 30,
        7: 31,
        8: 31,
        9: 30,
        10: 31,
        11: 30,
        12: 31
    }

    # Checking for regular leap year    
    if year % 4 == 0:
        leap_year_flag = 1
    else:
        leap_year_flag = 0

    # Checking for century leap year    
    if year % 100 == 0:
        if year % 400 == 0:
            leap_year_flag = 1
        else:
            leap_year_flag = 0
    else:
        pass

    # return end date of the year-month
    if leap_year_flag == 1 and month == 2:
        return 29
    elif leap_year_flag == 1 and month != 2:
        return end_dates[month]
    else:
        return end_dates[month]

Comments

आप हटा सकते हैं else: passऔर यह भी कि आप if year % 400 == 0: leap_year_flag = 1छोटे संशोधनों से छुटकारा पा सकते हैं

— कैनबक्स

Answer 29

यहाँ एक समाधान आधारित अजगर भेड़ का बच्चा है:

next_month = lambda y, m, d: (y, m + 1, 1) if m + 1 < 13 else ( y+1 , 1, 1)
month_end  = lambda dte: date( *next_month( *dte.timetuple()[:3] ) ) - timedelta(days=1)

next_monthलैम्ब्डा अगले साल के लिए खत्म हो अगले महीने के पहले दिन की टपल प्रतिनिधित्व, और रोल पाता है। month_endलैम्ब्डा एक तारीख (बदल देती है dte) एक टपल करने के लिए लागू होता है next_monthऔर एक नई तारीख पैदा करता है। फिर "महीने का अंत" अगले महीने का पहला दिन है timedelta(days=1)।