A kettévág A Python modulja egyszerű és gyors (bináris keresés alapú) függvényeket biztosít egy elem megkereséséhez egy rendezett listában, hogy megtalálja a megfelelő pozíciót az új elemek beszúrásához és új elemek beszúrásához, biztosítva, hogy a lista rendezett maradjon.

Miért van szükségünk Bisect modulra?

1. Hasznos bináris keresési műveleteknél, rendezett listában való kereséshez és beszúrási pontok megtalálásához.
2. Hatékony módszereket biztosít az elemek beszúrására egy rendezett listába a sorrend fenntartása mellett.
3. Időt és erőfeszítést takarít meg, így elkerülhető a kézi válogatás minden egyes beillesztés után.
4. Olyan függvényeket kínál, mint a bisect() bisect_left() bisect_right() és az insort() a tiszta optimalizált kód érdekében.
5. Ideális olyan feladatokhoz, mint a ranglistákon rangsorolt ​​adatok karbantartása, vagy bármilyen, rendezett adatbeszúrást/keresést magában foglaló forgatókönyv.

A Bisect modul alapvető funkciói

A bisect modul alapvetően kétféle funkciót kínál:

• A beszúrási pont megkeresése (beszúrás nélkül)
• Az elemek beillesztése a megfelelő helyre

1. Beillesztési pontok keresése

Ezek a függvények azt az indexet adják vissza, ahová az új elemet be kell illeszteni, hogy a lista rendezett maradjon.

a) felező.felező(): Az elem jobb szélső beszúrási pontját adja vissza. Ha az elem már létezik, a beszúrási pont a meglévő bejegyzések után lesz.

felező.felező(lista száma beg=0 vége=len(lista))

Paraméter:

• lista: Rendezett lista.
• szám: Beillesztendő elem.
• könyörög: Indítsa el az indexet a kereséshez (opcionális).
• vége: Végindex a kereséshez (opcionális).

b) bisect.bisect_left(): Az elem bal szélső beszúrási pontját adja vissza. Ha az elem létezik, a beszúrási pont a meglévő bejegyzések elé kerül.

cp parancsot linuxban

bisect.bisect_left(lista száma beg=0 end=len(lista))

c) bisect.bisect_right(): Azonos a bisect-vel.bisect() a jobb szélső beszúrási pontot adja vissza.

bisect.bisect_right(lista száma beg=0 end=len(lista))

Példa: Keresse meg a 4-es érték beszúrási indexeit egy rendezett listában különböző felezőfüggvények segítségével.

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 

Magyarázat:

• felező (li 4): 5-öt ad vissza, mert a lista utolsó 4-e után a jobb szélső pozíciót találja (4. index), így a beszúrási pont 5.
• bisect_left(li 4): 2-t ad vissza, mert megtalálja a bal szélső pozíciót az első 4 előtt a listában (2. index).
• bisect_right(li 4 0 4): Csak az allistán működik hogy[0:4] és 4-et ad vissza, mert 4-et szúr be az utolsó 4 után az allistába.

2. Elemek beszúrása

Ezek a funkciók beillesztik az elemet a megfelelő helyre a rendezés fenntartása érdekében.

a) bisect.insort(): Az elemet a jobb szélső pozícióba szúrja be. A bisect() függvényekkel ellentétben ez valójában az elem beszúrásával módosítja a listát.

bisect.insort(lista száma beg=0 end=len(lista))

Paraméter:

kapszulázási program

• lista: Rendezett lista.
• szám: Beillesztendő elem.
• könyörög (nem kötelező): Indítási index a beszúráshoz (alapértelmezett 0).
• vége (nem kötelező): Végindex a beszúráshoz (alapértelmezett len(lista)).

b) bisect.insort_left(): Az elemet a bal szélső pozícióba szúrja be.

bisect.insort_left(lista száma beg=0 end=len(lista))

c) bisect.insort_right(): Az elemet a jobb szélső pozícióba szúrja be (hasonlóan az insort()-hoz).

bisect.insort_right(lista száma beg=0 end=len(lista))

Példa: Szúrja be az 5-ös értéket egy rendezett listába, miközben különböző beillesztési stratégiákkal rendezve tartja.

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] 

Magyarázat:

• felmerül (l1 5) beilleszti az 5-öt a jobb oldali legmegfelelőbb pozícióba – minden 4 másodperc után és a 6 előtt.
• insort_left(l2 ​​5) beszúrja az 5-öt a bal legmegfelelőbb pozícióba – ugyanaz, mint itt, mivel az 5-ös nincs a listában.
• insort_right(l3 5 0 4) beszúr 5-öt a 4. indexbe, amely csak az l3[0:4] = [1 3 4 4] allistán dolgozik az utolsó ≤ 5 után ebben a tartományban, anélkül, hogy ez befolyásolná a lista többi részét.