Der halbieren Das Modul in Python bietet einfache und schnelle (auf binärer Suche basierende) Funktionen zum Durchsuchen eines Elements in einer sortierten Liste, zum Finden der richtigen Position zum Einfügen neuer Elemente und zum Einfügen neuer Elemente, um sicherzustellen, dass die Liste sortiert bleibt.

Warum brauchen wir das Bisect-Modul?

1. Nützlich für binäre Suchvorgänge, um in einer sortierten Liste zu suchen und Einfügepunkte zu finden.
2. Bietet effiziente Methoden zum Einfügen von Elementen in eine sortierte Liste unter Beibehaltung der Reihenfolge.
3. Das manuelle Sortieren nach jedem Einlegen entfällt, was Zeit und Mühe spart.
4. Bietet Funktionen wie bisect(), bisect_left(), bisect_right() und insort() für sauber optimierten Code.
5. Ideal für Aufgaben wie die Pflege von Bestenlisten-Ranglistendaten oder für jedes Szenario, das das Einfügen/Suchen sortierter Daten beinhaltet.

Kernfunktionen des Bisect-Moduls

Das Bisect-Modul bietet hauptsächlich zwei Arten von Funktionalitäten:

• Einfügepunkt finden (ohne Einfügung)
• Elemente an der richtigen Position einfügen

1. Einfügepunkte finden

Diese Funktionen geben den Index zurück, an dem das neue Element eingefügt werden soll, um die Liste sortiert zu halten.

a) bisect.bisect(): Gibt den Einfügepunkt ganz rechts für das Element zurück. Wenn das Element bereits vorhanden ist, befindet sich der Einfügepunkt hinter den vorhandenen Einträgen.

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

Parameter:

• Liste: Sortierte Liste.
• Nummer: Element zum Einfügen.
• bitten: Index für die Suche starten (optional).
• Ende: Endindex für die Suche (optional).

b) bisect.bisect_left(): Gibt den Einfügepunkt ganz links für das Element zurück. Wenn das Element vorhanden ist, liegt der Einfügepunkt vor den vorhandenen Einträgen.

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

c) bisect.bisect_right(): Identisch mit bisect.bisect() gibt den Einfügepunkt ganz rechts zurück.

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

Beispiel: Finden Sie Einfügungsindizes für den Wert 4 in einer sortierten Liste mithilfe verschiedener Halbierungsfunktionen.

   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  

Erläuterung:

• halbieren(li 4): Gibt 5 zurück, da die Position ganz rechts nach den letzten 4 in der Liste (Index 4) gefunden wird, sodass der Einfügepunkt 5 ist.
• bisect_left(li 4): Gibt 2 zurück, da die Position ganz links vor den ersten 4 in der Liste (Index 2) gefunden wird.
• bisect_right(li 4 0 4): Funktioniert nur bei Unterlisten das[0:4] und gibt 4 zurück, da 4 nach den letzten 4 in der Unterliste eingefügt wird.

2. Elemente einfügen

Diese Funktionen fügen das Element an der richtigen Position ein, um die Sortierung beizubehalten.

a) bisect.insort(): Fügt das Element ganz rechts ein. Im Gegensatz zu bisect()-Funktionen wird hierdurch die Liste tatsächlich durch Einfügen des Elements geändert.

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

Parameter:

• Liste: Sortierte Liste.
• Nummer: Element zum Einfügen.
• betteln (optional): Startindex für das Einfügen (Standard 0).
• Ende (optional): Endindex zum Einfügen (Standard-len(list)).

b) bisect.insort_left(): Fügt das Element an der Position ganz links ein.

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

c) bisect.insort_right(): Fügt das Element ganz rechts ein (ähnlich wie insort()).

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

Beispiel: Fügen Sie den Wert 5 in eine sortierte Liste ein und behalten Sie dabei die Sortierung mithilfe verschiedener Einfügestrategien bei.

   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]  

Erläuterung:

• entstehen(l1 5) fügt 5 an der am weitesten rechts passenden Position ein – nach allen 4ern und vor 6.
• insort_left(l2 ​​5) Fügt 5 an der am weitesten links passenden Position ein – dasselbe wie insort hier, da 5 nicht in der Liste enthalten ist.
• insort_right(l3 5 0 4) Fügt 5 an Index 4 ein und arbeitet nur an der Unterliste l3[0:4] = [1 3 4 4] nach der letzten ≤ 5 in diesem Bereich, ohne den Rest der Liste zu beeinflussen.