IL bisecare Il modulo in Python fornisce funzioni semplici e veloci (basate sulla ricerca binaria) per cercare un elemento in un elenco ordinato, trovare la posizione corretta per inserire nuovi elementi e inserire nuovi elementi garantendo che l'elenco rimanga ordinato.

Perché abbiamo bisogno del modulo Bisect?

1. Utile per operazioni di ricerca binaria per cercare in un elenco ordinato e per individuare punti di inserimento.
2. Fornisce metodi efficienti per inserire elementi in un elenco ordinato mantenendo l'ordine.
3. Evita la necessità di smistamento manuale dopo ogni inserimento risparmiando tempo e fatica.
4. Offre funzioni come bisect() bisect_left() bisect_right() e insort() per un codice pulito e ottimizzato.
5. Ideale per attività come il mantenimento dei dati classificati nelle classifiche o qualsiasi scenario che coinvolga l'inserimento/ricerca di dati ordinati.

Funzioni principali del modulo Bisect

Il modulo bisect offre principalmente due tipi di funzionalità:

• Trovare il punto di inserimento (senza inserimento)
• Inserimento degli elementi nella posizione corretta

1. Trovare i punti di inserimento

Queste funzioni restituiscono l'indice in cui inserire il nuovo elemento per mantenere ordinato l'elenco.

a) bisect.bisect(): Restituisce il punto di inserimento più a destra per l'elemento. Se l'elemento esiste già il punto di inserimento sarà dopo le voci esistenti.

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

Parametro:

• lista: Elenco ordinato.
• numero: Elemento da inserire.
• elemosinare: Indice iniziale per la ricerca (facoltativo).
• FINE: Indice finale per la ricerca (facoltativo).

b) bisect.bisect_left(): Restituisce il punto di inserimento più a sinistra per l'elemento. Se l'elemento esiste, il punto di inserimento sarà prima delle voci esistenti.

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

c) bisect.bisect_right(): Identico a bisect.bisect() restituisce il punto di inserimento più a destra.

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

Esempio: Trova gli indici di inserimento per il valore 4 in un elenco ordinato utilizzando diverse funzioni di bisezione.

   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  

Spiegazione:

• bisecare(li 4): Restituisce 5 perché trova la posizione più a destra dopo gli ultimi 4 nell'elenco (indice 4), quindi il punto di inserimento è 5.
• bisect_left(li 4): Restituisce 2 perché trova la posizione più a sinistra prima dei primi 4 nell'elenco (indice 2).
• bisect_right(li 4 0 4): Funziona solo sulla sottolista quello[0:4] e restituisce 4 perché inserisce 4 dopo gli ultimi 4 nella sottolista.

2. Inserimento di elementi

Queste funzioni inseriscono l'elemento nella posizione corretta per mantenere l'ordinamento.

a) bisect.insort(): Inserisce l'elemento nella posizione più a destra. A differenza delle funzioni bisect(), questa modifica effettivamente l'elenco inserendo l'elemento.

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

Parametro:

• lista: Elenco ordinato.
• numero: Elemento da inserire.
• supplicare (facoltativo): Indice iniziale per l'inserimento (default 0).
• fine (facoltativo): Indice finale per l'inserimento (len(list) predefinito).

b) bisect.insort_left(): Inserisce l'elemento nella posizione più a sinistra.

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

c) bisect.insort_right(): Inserisce l'elemento nella posizione più a destra (simile a insort()).

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

Esempio: Inserisci il valore 5 in un elenco ordinato mantenendolo ordinato utilizzando diverse strategie di inserimento.

   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]  

Spiegazione:

• insort(l1 5) inserisce 5 nella posizione adatta più a destra – dopo tutti i 4 e prima del 6.
• insort_left(l2 ​​5) inserisce 5 nella posizione adatta più a sinistra – come insort qui poiché 5 non è nell'elenco.
• insort_right(l3 5 0 4) inserisce 5 nell'indice 4 lavorando solo sulla sottolista l3[0:4] = [1 3 4 4] dopo l'ultimo ≤ 5 in quell'intervallo senza influenzare il resto della lista.