python date intervalle d'intersection

Question

Pour des raisons d'intérêt général, je me demande s'il existe une façon plus élégante/efficace de le faire. J'ai une fonction qui compare deux tuples début/fin de dates retournant vrai si elles se croisent.

from datetime import date 
def date_intersection(t1, t2): 
    t1start, t1end = t1[0], t1[1] 
    t2start, t2end = t2[0], t2[1] 

    if t1end < t2start: return False 
    if t1end == t2start: return True 
    if t1start == t2start: return True 
    if t1start < t2start and t2start < t1end: return True 
    if t1start > t2start and t1end < t2end: return True 
    if t1start < t2start and t1end > t2end: return True 
    if t1start < t2end and t1end > t2end: return True 
    if t1start > t2start and t1start < t2end: return True 
    if t1start == t2end: return True 
    if t1end == t2end: return True 
    if t1start > t2end: return False 

si:

d1 = date(2000, 1, 10) 
d2 = date(2000, 1, 11) 
d3 = date(2000, 1, 12) 
d4 = date(2000, 1, 13) 

alors:

>>> date_intersection((d1,d2),(d3,d4)) 
False 
>>> date_intersection((d1,d2),(d2,d3)) 
True 
>>> date_intersection((d1,d3),(d2,d4)) 
True 

etc.

Je suis curieux de savoir s'il y a un plus pythonique/élégante/plus efficace/moins verbose/généralement mieux, façon de le faire avec peut-être mxDateTime ou un bidouillage intelligent avec timedelta ou set()?

Une autre forme et utile serait la fonction pour retourner un tuple début/fin de l'intersection si l'on se trouve

Merci

Answer 1

Ce n'est pas vraiment plus Pythonic, mais vous pouvez simplement décider de l'intersection. Ce problème particulier affleure beaucoup:

return (t1start <= t2start <= t1end) or (t2start <= t1start <= t2end) 

Pour voir pourquoi cela fonctionne réfléchir sur les différentes façons possibles que les deux intervalles peuvent se croiser et voir que le point de départ d'un doit toujours être dans la plage de l'autre.

Answer 2

if t1end < t2start or t1start > t2end: return False 
if t1start <= t2end or t2start <= t1start: return True 
return False 

Pas qui couvre toutes les séries intersectées?

Answer 3

Voici une version qui vous donne la plage d'intersection. À mon humble avis, ce n'est peut-être pas le # le plus optimisé des conditions, mais il montre clairement quand t2 chevauche t1. Vous pouvez modifier en fonction d'autres réponses si vous voulez juste le vrai/faux.

if (t1start <= t2start <= t2end <= t1end): 
    return t2start,t2end 
elif (t1start <= t2start <= t1end): 
    return t2start,t1end 
elif (t1start <= t2end <= t1end): 
    return t1start,t2end 
elif (t2start <= t1start <= t1end <= t2end): 
    return t1start,t1end 
else: 
    return None 

Answer 4

Une solution alternative et je l'espère plus intelligible:

def has_overlap(A_start, A_end, B_start, B_end): 
    latest_start = max(A_start, B_start) 
    earliest_end = min(A_end, B_end) 
    return latest_start <= earliest_end: 

Nous pouvons obtenir l'intervalle du chevauchement facilement, il est (latest_start, earliest_end). Notez que latest_start peut être égal à earliest_end. Il convient de noter que cela suppose que A_start <= A_end et B_start <= B_end.

Answer 5

Final Comparison: start <= other_finish and other_start <= finish 

# All of the conditions below result in overlap I have left out the non overlaps 

start <= other_start | start <= other_finish | other_start <= finish | finish <= other_finish 

     0      1      1      0     
     0      1      1      1 
     1      1      1      0   
     1      1      1      1 

Seul le début < = other_finish et other_start < = finition besoin d'être vrai pour retourner un chevauchement.