Le couper en deux Le module en Python fournit des fonctions simples et rapides (basées sur la recherche binaire) pour rechercher un élément dans une liste triée, trouver la position correcte pour insérer de nouveaux éléments et insérer de nouveaux éléments en garantissant que la liste reste triée.

Pourquoi avons-nous besoin du module Bisect ?

1. Utile pour les opérations de recherche binaire afin de rechercher dans une liste triée et de localiser les points d'insertion.
2. Fournit des méthodes efficaces pour insérer des éléments dans une liste triée tout en maintenant l’ordre.
3. Évite le tri manuel après chaque insertion, économisant du temps et des efforts.
4. Offre des fonctions comme bisect() bisect_left() bisect_right() et insort() pour un code propre et optimisé.
5. Idéal pour les tâches telles que la maintenance des données classées dans les classements ou tout scénario impliquant l'insertion/la recherche de données triées.

Fonctions de base du module Bisect

Le module bisect propose principalement deux types de fonctionnalités :

• Trouver le point d'insertion (sans insertion)
• Insérer des éléments au bon endroit

1. Trouver des points d'insertion

Ces fonctions renvoient l'index où le nouvel élément doit être inséré pour garder la liste triée.

a) bisect.bisect() : Renvoie le point d'insertion le plus à droite de l'élément. Si l'élément existe déjà, le point d'insertion sera après les entrées existantes.

bisect.bisect(list num beg=0 end=len(list))

Paramètre:

• liste: Liste triée.
• numéro : Élément à insérer.
• mendier: Index de démarrage pour la recherche (facultatif).
• fin: Index de fin de recherche (facultatif).

b) bisect.bisect_left() : Renvoie le point d'insertion le plus à gauche de l'élément. Si l'élément existe, le point d'insertion sera avant les entrées existantes.

bisect.bisect_left(list num beg=0 end=len(list))

c) bisect.bisect_right() : Identique à bisect.bisect() renvoie le point d'insertion le plus à droite.

bisect.bisect_right(list num beg=0 end=len(list))

Exemple: Recherchez les indices d'insertion pour la valeur 4 dans une liste triée à l'aide de différentes fonctions de bissectrice.

   import   bisect   li   =   [  1     3     4     4     4     6     7  ]   print  (  bisect  .  bisect  (  li     4  ))   # right   print  (  bisect  .  bisect_left  (  li     4  ))   # left   print  (  bisect  .  bisect_right  (  li     4     0     4  ))   # subright   

5 2 4  

Explication:

• bissecter(li 4): Renvoie 5 car il trouve la position la plus à droite après les 4 derniers de la liste (index 4), donc le point d'insertion est 5.
• bisect_left(li 4) : Renvoie 2 car il trouve la position la plus à gauche avant les 4 premières de la liste (index 2).
• bisect_right(li 4 0 4) : Fonctionne uniquement sur la sous-liste que[0:4] et renvoie 4 car il insère 4 après les 4 derniers dans la sous-liste.

2. Insertion d'éléments

Ces fonctions insèrent l'élément à la position appropriée pour maintenir le tri.

a) bisect.insort() : Insère l'élément à la position la plus à droite. Contrairement aux fonctions bisect(), cela modifie en fait la liste en insérant l'élément.

bisect.insort(list num beg=0 end=len(list))

Paramètre:

• liste: Liste triée.
• numéro : Élément à insérer.
• mendier (facultatif): Index de départ pour l'insertion (0 par défaut).
• fin (facultatif) : Index de fin pour l'insertion (len(list) par défaut).

b) bisect.insort_left() : Insère l'élément à la position la plus à gauche.

bisect.insort_left(list num beg=0 end=len(list))

c) bisect.insort_right() : Insère l'élément à la position la plus à droite (similaire à insort()).

bisect.insort_right(list num beg=0 end=len(list))

Exemple: Insérez la valeur 5 dans une liste triée tout en la gardant triée en utilisant différentes stratégies d'insertion.

   import   bisect   l1   =   [  1     3     4     4     4     6     7  ]   l2   =   [  1     3     4     4     4     6     7  ]   l3   =   [  1     3     4     4     4     6     7  ]   bisect  .  insort  (  l1     5  )   # right   print  (  l1  )   bisect  .  insort_left  (  l2     5  )   # left   print  (  l2  )   bisect  .  insort_right  (  l3     5     0     4  )   # subright   print  (  l3  )   

[1 3 4 4 4 5 6 7] [1 3 4 4 4 5 6 7] [1 3 4 4 5 4 6 7]  

Explication:

• surgir(l1 5) insère 5 à la position appropriée la plus à droite – après tous les 4 et avant 6.
• insert_left(l2 ​​5) insère 5 à la position appropriée la plus à gauche – identique à insort ici puisque 5 n'est pas dans la liste.
• insert_right(l3 5 0 4) insère 5 à l'index 4 en travaillant uniquement sur la sous-liste l3[0:4] = [1 3 4 4] après le dernier ≤ 5 dans cette plage sans affecter le reste de la liste.