Tính toán chồng chéo phạm vi ngày hiệu quả trong python?

Tôi có hai phạm vi ngày trong đó mỗi phạm vi được xác định bởi ngày bắt đầu và ngày kết thúc (rõ ràng là phiên bản datetime.date ()). Hai phạm vi có thể trùng nhau hoặc không. Tôi cần số ngày trùng lặp. Tất nhiên tôi có thể điền trước hai tập hợp với tất cả các ngày trong cả hai phạm vi và thực hiện một giao điểm đã đặt nhưng điều này có thể không hiệu quả ... có cách nào tốt hơn ngoài giải pháp khác bằng cách sử dụng phần if-elif dài bao gồm tất cả các trường hợp không?

• Xác định ngày muộn nhất trong hai ngày bắt đầu và ngày sớm nhất trong hai ngày kết thúc.
• Tính toán thời gian bằng cách trừ chúng.
• Nếu delta là số dương, đó là số ngày trùng lặp.

Đây là một ví dụ tính toán:

>>> from datetime import datetime
>>> from collections import namedtuple
>>> Range = namedtuple('Range', ['start', 'end'])

>>> r1 = Range(start=datetime(2012, 1, 15), end=datetime(2012, 5, 10))
>>> r2 = Range(start=datetime(2012, 3, 20), end=datetime(2012, 9, 15))
>>> latest_start = max(r1.start, r2.start)
>>> earliest_end = min(r1.end, r2.end)
>>> delta = (earliest_end - latest_start).days + 1
>>> overlap = max(0, delta)
>>> overlap
52

Các cuộc gọi hàm đắt hơn các phép toán số học.

Cách nhanh nhất để làm điều này bao gồm 2 phép trừ và 1 min ():

min(r1.end - r2.start, r2.end - r1.start).days + 1

so với sản phẩm tốt nhất tiếp theo cần 1 phép trừ, 1 min () và max ():

(min(r1.end, r2.end) - max(r1.start, r2.start)).days + 1

Tất nhiên với cả hai biểu thức, bạn vẫn cần phải kiểm tra sự chồng chéo tích cực.

Tôi đã triển khai một lớp TimeRange như bạn có thể thấy bên dưới.

Đầu tiên get_overlapped_range phủ định tất cả các tùy chọn không bị chồng chéo bằng một điều kiện đơn giản, sau đó tính toán phạm vi bị chồng chéo bằng cách xem xét tất cả các tùy chọn có thể.

Để có số ngày, bạn sẽ cần lấy giá trị TimeRange được trả về từ get_overlapped_range và chia thời lượng cho 60 * 60 * 24.

class TimeRange(object):
    def __init__(self, start, end):
        self.start = start
        self.end = end
        self.duration = self.end - self.start

    def is_overlapped(self, time_range):
        if max(self.start, time_range.start) < min(self.end, time_range.end):
            return True
        else:
            return False

    def get_overlapped_range(self, time_range):
        if not self.is_overlapped(time_range):
            return

        if time_range.start >= self.start:
            if self.end >= time_range.end:
                return TimeRange(time_range.start, time_range.end)
            else:
                return TimeRange(time_range.start, self.end)
        elif time_range.start < self.start:
            if time_range.end >= self.end:
                return TimeRange(self.start, self.end)
            else:
                return TimeRange(self.start, time_range.end)

    def __repr__(self):
        return '{0} ------> {1}'.format(*[time.strftime('%Y-%m-%d %H:%M:%S', time.localtime(d))
                                          for d in [self.start, self.end]])

Bạn có thể sử dụng gói datetimerange: https://pypi.org/project/DateTimeRange/

from datetimerange import DateTimeRange
time_range1 = DateTimeRange("2015-01-01T00:00:00+0900", "2015-01-04T00:20:00+0900") 
time_range2 = DateTimeRange("2015-01-01T00:00:10+0900", "2015-01-04T00:20:00+0900")
tem3 = time_range1.intersection(time_range2)
if tem3.NOT_A_TIME_STR == 'NaT':  # No overlap
    S_Time = 0
else: # Output the overlap seconds
    S_Time = tem3.timedelta.total_seconds()

"2015-01-01T00: 00: 00 + 0900" bên trong DateTimeRange () cũng có thể là định dạng ngày giờ, như Dấu thời gian ('2017-08-30 20:36:25').

Mã giả:

 1 + max( -1, min( a.dateEnd, b.dateEnd) - max( a.dateStart, b.dateStart) )

def get_overlap(r1,r2):
    latest_start=max(r1[0],r2[0])
    earliest_end=min(r1[1],r2[1])
    delta=(earliest_end-latest_start).days
    if delta>0:
        return delta+1
    else:
        return 0

Được rồi, giải pháp của tôi hơi rắc rối vì df của tôi sử dụng tất cả các chuỗi - nhưng giả sử bạn có các cột sau, 2 trong số đó đã được sửa, đó là "Năm tài chính" của bạn. PoP là "Khoảng thời gian hiệu suất" là dữ liệu biến đổi của bạn:

df['PoP_Start']
df['PoP_End']
df['FY19_Start'] = '10/1/2018'
df['FY19_End'] = '09/30/2019'

Giả sử tất cả dữ liệu ở định dạng ngày giờ tức là -

df['FY19_Start'] = pd.to_datetime(df['FY19_Start'])
df['FY19_End'] = pd.to_datetime(df['FY19_End'])

Hãy thử các phương trình sau để tìm số ngày trùng lặp:

min1 = np.minimum(df['POP_End'], df['FY19_End'])
max2 = np.maximum(df['POP_Start'], df['FY19_Start'])

df['Overlap_2019'] = (min1 - max2) / np.timedelta64(1, 'D')
df['Overlap_2019'] = np.maximum(df['Overlap_2019']+1,0)