ITTEROOLS.Prodotto

ITERTEROOLS è un pacchetto che offre diverse metodologie in Python. L'iterazione degli attributi è reso più semplice usando questi metodi. La funzione Product () del pacchetto ITTeTools produce il prodotto cartesiano degli elenchi o dei set forniti. Il parametro di ripetizione, che è parte aggiuntiva della funzione, fornisce la combinazione cartesiana del valore con se stesso sulle iterazioni indicate nell'argomento ripetuta. Dimostriamo i metodi di utilizzo della funzione del prodotto () del modulo ITERTools.

Esempio 1:
In questo esempio, creiamo due elenchi e quindi troviamo il prodotto cartesiano di quelle liste definite.

Dal prodotto import
Elenco = [21, 44, 63, 74, 15]
Print ("L'elenco effettivo è:", elenco)
print ("Il prodotto cartesiano di quell'elenco:", elenco (prodotto (elenco, ripetizione = 3)))
List_1 = [51, 12, 23]
List_2 = ['xa', 'yb', 'zc']
print ("Il prodotto cartesiano di entrambi gli elenchi:", elenco (prodotto (list_1, list_2)))

Iniziamo il codice integrando il metodo Product () che è associato al framework ITERTERS. Quindi, indichiamo alcuni elementi sotto forma di un elenco. Questi valori sono archiviati in una variabile "elenco". Ora utilizziamo la funzione print () per visualizzare l'elenco effettivo. La funzione Product () è costituita da due argomenti che includono l'elenco e l'attributo "ripetizione". Il valore di questo attributo è impostato su 3 qui per ottenere il prodotto cartesiano dell'elenco definito con se stesso. Questo prodotto dell'elenco è mostrato sullo schermo utilizzando la funzione di stampa ().

Inoltre, creiamo due nuovi elenchi. Il primo elenco contiene tre valori numerici e il secondo elenco contiene i set alfabetici. Ora, chiamiamo il metodo Product (). Passiamo entrambi gli elenchi come argomenti della funzione. In questo modo, troviamo il prodotto cartesiano tra queste due liste. Il metodo Print () viene utilizzato per visualizzare il prodotto cartesiano.

Esempio n. 2:
Qui, utilizziamo il metodo cartesiano_product () per acquisire il prodotto cartesiano di due array.

Dal prodotto import
def cartesian_product (a_1, a_2):
Elenco di ritorno (Prodotto (A_1, A_2))
Se __Name__ == "__main__":
a_1 = [101, 938, 854]
A_2 = [370, 691, 287]
print (cartesian_product (a_1, a_2))

Incorporiamo la libreria dei prodotti dal pacchetto ITTERTOOLS. Quindi, definiamo la funzione cartesian_product (). All'interno di questa funzione, passiamo due array come parametro della funzione. Questo metodo restituisce i valori di entrambi gli array prendendo il prodotto dei valori. Utilizziamo anche il metodo Product () all'interno dell'istruzione di ritorno.

Ora è ora di chiamare la funzione del driver. All'interno del corpo della funzione principale, creiamo due array e definiamo alcuni valori casuali in questi array. Chiamiamo la funzione cartesian_product () per acquisire il prodotto cartesiano di quegli array citati. Utilizziamo la funzione print () per rappresentare il loro prodotto.

Esempio n. 3:
In questa illustrazione, per semplicità ed efficienza, la funzione del prodotto () viene utilizzata al posto del loop.

tempo di importazione
Importa iTtools
l_1 = [4,8,2]
L_2 = [1,7,3]
L_3 = [5,6,2]
s_1 = time.tempo()
iter_list = iTTeTools.Prodotto (L_1, L_2, L_3)
a_1 = tempo.tempo()
Stampa ("Risultato degli ITTEROOLS.Prodotto () Funzione: ")
stampa (elenco (iter_list))
list_new = []
s_2 = time.tempo()
per l in l_1:
per m in l_2:
per n in l_3:
list_new.append ((l, m, n))
a_2 = tempo.tempo()
Stampa ("risultato utilizzando per loop:")
Stampa (List_New)
Stampa (F "tempo impiegato per ottenere iTertools.Product (): a_1-s_1 ")
print (f "tempo impiegato per l'uso di 'per' loop: a_2-s_2")

Per iniziare il programma, introduciamo due moduli richiesti. Il framework "time" è integrato per determinare la rapidità delle esecuzioni e il modulo "iTertools" viene importato per gestire la funzionalità del prodotto () e per un loop. Successivamente, dichiariamo tre variabili che includono "L_1", "L_2" e "L_3". Queste variabili vengono utilizzate per archiviare valori diversi. Tutti questi elenchi contengono tre cifre.

Per acquisire la rapidità dell'implementazione, chiamiamo il metodo Time (). Il tempo calcolato viene archiviato in una variabile "S_1". Questo metodo è preso dal file di intestazione del tempo. Nel passaggio successivo, utilizziamo il metodo Product () del pacchetto ITTERTOOLS. Passiamo le tre liste definite come argomenti della funzione del prodotto. Chiamiamo il metodo Print () per visualizzare il prodotto degli elenchi utilizzando il metodo Product ().

Insieme a questo, utilizziamo il metodo Print () per stampare l'elenco. Ora inizializziamo una nuova variabile definita "list_new". Questo elenco è impostato come vuoto. Usiamo la funzione time () per determinare l'efficienza dell'implementazione del sistema. La variabile "S_2" contiene il tempo determinato. Il file di intestazione del tempo è dove viene adottata questa metodologia. Esclude L_3 per i valori di N 2 e 3 nella prima esecuzione del ciclo "per" con l = 4, m = 8 e n = 2. Il processo viene ripetuto mentre si specifica M = 7. Si ferma la L_3 per i valori dei parametri K 2 e 3 nella seconda serie del ciclo "per" con l = 1, m = 7 e n = 3. Il processo viene quindi ripetuto quando si imposta il m = 7. Per l = 5, questo viene eseguito di conseguenza.

Utilizziamo il metodo Append () e passiamo le tre iterazioni come parametri poiché aggiungiamo il risultato di queste iterazioni. Chiamiamo l'approccio del tempo () per valutare la velocità con cui si verificano queste iterazioni. La variabile "A_2" contiene il tempo stimato. Ora, abbiamo usato la funzione print () per presentare il prodotto degli elenchi applicando un ciclo "per".

Inoltre, mostriamo l'elenco utilizzando la funzione print (). Per visualizzare i tempi calcolati per entrambe le procedure, alla fine invochiamo il metodo Print (). La funzione Prodotto ITTeTools () e i tempi di inizio e fine del loop iterazioni sono mostrati dalle variabili S_1, S_2 e A_1 e A_2, rispettivamente. I tempi di esecuzione della funzione per loop e prodotto () sono presentati come a_1 - s_1 e a_2 - s_2, di conseguenza.

Conclusione

In questo articolo, abbiamo parlato di come utilizzare il metodo Product () del modulo ITERTURS in Python. Gli utenti possono attraversare il prodotto cartesiano di un insieme di iterabili con questo metodo. Il codice è semplificato ed efficace utilizzando il metodo Product (). Nel primo esempio di questa guida, abbiamo creato un elenco e ottenuto il prodotto cartesiano dell'elenco stesso. In un altro caso, abbiamo dichiarato due array e ottenuto il prodotto cartesiano di quegli array. Abbiamo usato la funzione prodotto () anziché il ciclo "per".