Sådan bruges Zip -funktion i Python

How Use Zip Function Python



Denne artikel vil dække en vejledning om zip -funktion, der er tilgængelig i Pythons standardmodulbibliotek. Denne metode giver dig mulighed for at kombinere og parre elementer af flere iterable objekter. Du kan derefter køre yderligere logik på disse par. I mange tilfælde er brug af en zip -funktion meget mere effektiv og renere end at bruge flere, indlejrede til sløjfer.

Om Zip -funktion

Som tidligere nævnt bruges zip -funktion til at oprette par fra elementer i flere iterable objekter. Overvej eksemplet herunder for at forstå den grundlæggende syntaks og brug af zip -funktion:







liste 1= ['til', 'b', 'c']
liste 2= ['æble', 'bold', 'kat']
lynlås= lynlås(liste 1,liste 2)
Print (liste(lynlås))

De to første udsagn i ovenstående kodeeksempel definerer to lister, der indeholder nogle elementer. Dernæst bruges zip -funktion ved at sende liste1 og liste2 variabler som argumenter. Dette er hovedsyntaksen for zip -funktionen. Du skal bare sende lister eller andre gyldige ordnede iterabler som argumenter, hvis elementer du vil kombinere. Endelig bruges udskriftserklæringen til at få output fra den zip -variable. Efter at have kørt ovenstående kodeeksempel, skal du få følgende output:



[('a', 'æble'), ('b', 'kugle'), ('c', 'kat')]

Bemærk, at zip -funktionen returnerer et objekt af typen zip og ikke en liste. Du skal konvertere den til en iterabel type, som vist i udskriftserklæringen ovenfor.



Kort sagt, zip -funktion henter elementer fra det samme indeks fra to lister og kombinerer dem som et par i en tuple. Så det ottende element fra liste1 kombineres med det ottende element i liste2, det første element fra liste1 kombineres med det første element i liste2 og så videre. Zip -funktionen bevæger sig fra venstre mod højre, og den tuple, der indeholder parrede elementer, har det samme indeks som elementerne, der er gemt i dem.





Brug af zip, når Iterables ikke har samme antal elementer

I ovenstående eksempel har begge lister det samme antal elementer. Hvis du har at gøre med en kode, hvor begge lister ikke har det samme antal elementer, stopper zip -funktionen ved det sidste element på listen med det laveste antal elementer.

I eksemplet herunder stopper zip -funktionen ved c -elementet, uanset at list2 har et element mere.



liste 1= ['til', 'b', 'c']
liste 2= ['æble', 'bold', 'kat', 'dukke']
lynlås= lynlås(liste 1,liste 2)
Print (liste(lynlås))

Efter at have kørt ovenstående kodeeksempel, skal du få følgende output:

[('a', 'æble'), ('b', 'kugle'), ('c', 'kat')]

Du kan bruge mere end to Iterables, når du bruger Zip -funktion

Normalt bruges zip -funktion til at sammenligne to iterable objekter. Du kan dog videresende et vilkårligt antal iterabler som argumenter til zip -funktionen. Princippet om at stoppe ved det sidste element i den korteste liste vil stadig være gældende.

liste 1= ['til', 'b', 'c']
liste 2= ['æble', 'bold', 'kat', 'dukke']
liste 3= ['5', '3']
lynlås= lynlås(liste 1,liste 2,liste 3)
Print (liste(lynlås))

Efter at have kørt ovenstående kodeeksempel, skal du få følgende output som resultat:

[('a', 'æble', '5'), ('b', 'kugle', '3')]

Oprettelse af individuelle lister fra et Zip Type -objekt

Hvis du allerede har et zip -objekt, kan du bruge det til at genbefolke individuelle lister, der tidligere blev brugt, da zip -funktionen først blev kaldt på dem.

liste 1= ['til', 'b', 'c']
liste 2= ['æble', 'bold', 'kat', 'dukke']
liste 3= ['5', '3']
lynlås= lynlås(liste 1,liste 2,liste 3)
l1,l2,l3= lynlås(*lynlås)
Print (liste(l1), liste(l2), liste(l3))

Efter at have kørt ovenstående kodeeksempel, skal du få følgende output som resultat:

['a', 'b'] ['æble', 'kugle'] ['5', '3']

I kodeeksemplet ovenfor tømmes zip -objektet ved hjælp af * operator. Deflaterede resultater føres derefter ind i en anden call to zip -funktion, der opretter originale lister. Bemærk, at du muligvis ikke får alle elementer tilbage i de originale lister, hvis lister med ulig længde blev brugt, da zip -objektet blev oprettet første gang.

Brug af zip, når du vil holde elementer fra længst Iterable

I flere eksempler ovenfor har du muligvis observeret, at zip -funktionen som standard stopper ved det sidste element i den korteste iterable. Hvad hvis du vil have det til at fortsætte iterating, indtil det når det sidste element i den længste iterable?

I et sådant tilfælde bliver du nødt til at bruge zip_longest () -metoden fra Pythons itertools -modul. Det fungerer på samme måde som zip -funktionen, med en lille forskel, at det stopper ved det sidste element i den længste gentagelige type.

fra it -værktøjer importerezip_longest
liste 1= ['til', 'b', 'c']
liste 2= ['æble', 'bold', 'kat', 'dukke']
liste 3= ['5', '3']
lynlås=zip_longest(liste 1,liste 2,liste 3)
Print (liste(lynlås))

Efter at have kørt ovenstående kodeeksempel, skal du få følgende output som resultat:

[('a', 'æble', '5'), ('b', 'kugle', '3'), ('c', 'kat', ingen), (ingen, 'dukke', ingen) ]

Manglende værdier udfyldes som Ingen type -objekter. Du kan også angive din egen værdi, der skal udfyldes, ved at sende et ekstra fillvalue -argument til zip_longest -metoden.

fra it -værktøjer importerezip_longest
liste 1= ['til', 'b', 'c']
liste 2= ['æble', 'bold', 'kat', 'dukke']
liste 3= ['5', '3']
lynlås=zip_longest(liste 1,liste 2,liste 3,fyldværdi='min_værdi')
Print (liste(lynlås))

Efter at have kørt ovenstående kodeeksempel, skal du få følgende output som resultat:

[('a', 'æble', '5'), ('b', 'kugle', '3'), ('c', 'kat', 'min_værdi'), ('min_værdi', 'dukke ',' min_værdi ')]

Konklusion

Zip -funktion kan efterlignes ved hjælp af nogle sløjfer og betingelser. Det hjælper dog med at holde koden organiseret og renere ved at fjerne unødvendig ordsprog og gentagne udsagn.