En tuppel er en av fire innebygde datatyper i Python som brukes til å lagre datasamlinger. Tuppeloperasjoner er de som kan utføres på elementene i tuppeldatastrukturen. La oss se på noen av de mest brukte tuppeloperasjonene i Python.

1. Tell forekomster av et element i en tuppel

telle() metoden brukes til å telle den totale forekomsten av et element i tupelen. Hvis elementet ikke finnes i tuppelen, returnerer funksjonen 0.

tup1 = ( 1, 4, 7, 3, 6, 4, 1, 8, 4 )
# teller antall ganger 4 forekommer i tuppelen
skrive ut( tup1.count(4) )
# utskrifter
3

2. Finne posisjonen til et element i en tuppel

Du kan bruke indeks() metode for å finne indeksen/posisjonen til et element i tuppelen. Hvis det er mer enn én forekomst av et element i tuppelen, returnerer funksjonen indeksen for den første forekomsten.

tup1 = ( 1, 4, 7, 3, 6, 4, 1, 8, 4)
skrive ut( tup1.index(4) )
# utskrifter
1

Merk:

Hvis du prøver å finne indeksen til elementet som ikke er til stede i tuppelen, kaster funksjonen en ValueError som:

ValueError: tuple.index (x): x ikke i tuple

instagram viewer

3. Hvordan bli med to eller flere tuples

Du kan bli med to eller flere tuples ved å bruke + operatør.

tup1 = ( 1, 2, 3 )
tup2 = ( 4, 5, 6 )
tup3 = tup1 + tup2
skrive ut( tup3 )
# utskrifter
(1, 2, 3, 4, 5, 6)

4. Hvordan konvertere streng til en tuppel

Du kan bruke tuppel() konstruktør for å konvertere en streng til en tuppel ved å sende strengen som en parameter til tuple()-konstruktøren.

tup1 = tuppel( "BENYTTE SEG AV" )
skrive ut(tup1)
# utskrifter
('M', 'EN', 'K', 'E', 'U', 'S', 'E', 'O', 'F')

5. Hvordan konvertere liste til en tuppel

Vi kan følge tre tilnærminger for å konvertere en liste til en tuppel.

Tilnærming 1: Bruke tuple() Constructor

tuppel() konstruktør brukes til å konvertere en liste til en tuppel ved å sende listen som en parameter til tuple()-konstruktøren.

liste1 = [1, 2, 3, 4, 5, 6]
tup1 = tuppel (liste1)
skrive ut(tup1)
# utskrifter
(1, 2, 3, 4, 5, 6)

Tilnærming 2: Bruke en Loop Inside tuple()-konstruktør

Det er en liten variasjon av tilnærmingen ovenfor. Vi kjører en loop (ved hjelp av listeforståelse) inne i tuple()-konstruktøren for å lage tuppelen.

liste1 = [ 1, 2, 3, 4, 5, 6 ]
tup1 = tuple( element for element i liste1 )
skrive ut(tup1)
# utskrifter
(1, 2, 3, 4, 5, 6)

Tilnærming 3: Bruke (*listName,)

Dette pakker ut en liste inne i tuppelbokstaven på grunn av tilstedeværelsen av enkeltkomma (,). Denne metoden er den raskeste av de tre tilnærmingene.

liste1 = [1, 2, 3, 4, 5, 6]
tup1 = (*liste1,)
skrive ut(tup1)
# utskrifter
(1, 2, 3, 4, 5, 6)

6. Hvordan multiplisere Tuples

Du kan multiplisere innholdet i tupelen et hvilket som helst antall ganger ved å bruke * operatør.

tup1 = ( 1, 2, 3 )
tup2 = tup1 * 3
skrive ut( tup2 )
# utskrifter
(1, 2, 3, 1, 2, 3, 1, 2, 3)

7. Hvordan finne totalt antall elementer i en tuppel

len() funksjon er en av de mest brukte innebygde funksjonene i Python. Den brukes til å finne det totale antallet elementer i et objekt. Du kan bruke len()-funksjonen med tuple for å telle det totale antallet elementer i tupelen.

tup1 = ( 1, 2, 3 )
skrive ut( len( tup1 ) )
# utskrifter
3

8. Hvordan finne minimumselement i en tuppel

min() funksjon brukes til å finne et element med den laveste verdien i den gitte tuppelen.

tup1 = ( 1, 2, 3 )
print("Minimumselement i tuppelen er: ")
skrive ut( min( tup1 ) )
# utskrifter
Minimumselement i tuppelen er:
1

9. Hvordan finne maksimalt element i en tuppel

maks() funksjon brukes til å finne et element med høyest verdi i den gitte tuppelen.

tup1 = ( 1, 2, 3 )
print("Maksimalt element i tuppelen er: ")
skrive ut(maks(tup1))
# utskrifter
Maksimalt element i tuppelen er:
3

10. Hvordan finne summen av alle elementer i en tuppel

sum() funksjon brukes til å beregne den aritmetiske summen av alle elementene i tupelen.

tup1 = ( 1, 2, 3 )
skrive ut("Sum av elementer: ")
skrive ut( sum( tup1 ) )
# utskrifter
Summen av elementer:
6

11. any() Operasjon på Tuples

Hvis ett eller flere elementer i tuppelen har en boolsk verdi True, da noen() funksjonen returnerer ekte ellers kommer den tilbake Falsk.

tup1 = ( Falsk, Falsk, Falsk, ekte )
skrive ut( hvilken som helst ( tup1 ) )
# utskrifter
ekte

12. all() Operasjon på Tuples

Du kan bruke alle() funksjon for å sjekke om alle elementene i tuppelen har en boolsk verdi True. Selv om et element i tuppelen har en boolsk verdi False, returnerer funksjonen False.

tup1 = ( ekte, ekte, ekte, Falsk, ekte )
skrive ut( alle ( tup1 ) )
# utskrifter
Falsk

13. sorted() Operasjon på Tuples

Du kan bruke sortert() funksjon for å returnere en sortert liste i stigende rekkefølge.

tup1 = ( 6, 1, 8, 3, 7, 2 )
skrive ut( sortert (tup1) )
skrive ut( type(sortert(tup1)))
# utskrifter
[1, 2, 3, 6, 7, 8]
<klasse 'liste'>
# Merk at returtypen er liste

14. Hvordan blande en tuppel

Siden tupler er uforanderlige, kan de ikke stokkes direkte. Vi må bruke lister for å stokke en tuppel. Vi kan stokke en tuppel ved hjelp av typecasting i tre trinn:

Trinn 1: Typecast tuple til en liste

Trinn 2: Bland listen

Trinn 3: Typecast-liste tilbake til en tuppel

import tilfeldig
old_tuple = ( 45, 46, 47, 48, 49 )
# Utskrift av tuppel
skrive ut("Gammel tuppel:")
skrive ut(gammel_tuppel)
# Typecasting tuppel til liste
liste1 = liste(gammel_tuppel)
# Blandingsliste
tilfeldig.tilfeldig rekkefølge(liste 1)
# Typecasting-liste tilbake til tuple
ny_tuppel = tuppel (liste1)
# Skriver ut ny stokket tuppel
skrive ut("Ny stokket tuppel:")
skrive ut(new_tuple)
# utskrifter
Gammel tuppel:
(45, 46, 47, 48, 49)
Ny stokket tuppel:
(45, 49, 46, 47, 48)

Merk: Siden tuppelen stokkes tilfeldig, kan du få en annen utgang.

15. Hvordan konvertere liste over tuples til liste over lister

Ved å bruke listeforståelsen kan vi konvertere en liste over tupler til en liste med lister.

liste1 = [ ('EN', 'B'), ('C', 'D'), ('E', 'F') ]
skrive ut("Liste av tupler:")
skrive ut( liste1 )
# Listeforståelse
resultat = [ liste(element) til element i liste1 ]
skrive ut("Liste av lister:")
skrive ut(resultat)
# utskrifter
Liste av tupler:
[('EN', 'B'), ('C', 'D'), ('E', 'F')]
Liste av lister:
[['EN', 'B'], ['C', 'D'], ['E', 'F']]

16. Hvordan konvertere liste over tupler til liste over strenger

Ved hjelp av listeforståelse og bli med() metode kan vi konvertere en liste over tuples til en liste med strenger.

liste1 = [ ('M', 'EN', 'K', 'E'), ('U', 'S', 'E'), ('O', 'F') ]
skrive ut("Liste av tupler:")
skrive ut( liste1 )
# Listeforståelse med join()-metoden
resultat = [ ''.join (element) for element i liste1 ]
skrive ut("Liste av strenger:")
skrive ut(resultat)
# utskrifter
Liste av tupler:
[('M', 'EN', 'K', 'E'), ('U', 'S', 'E'), ('O', 'F')]
Liste av strenger:
['GJØRE', 'BRUK', 'AV']

I slekt: Hvordan bruke for løkker i Python

17. Hvordan snu en tuppel

Ved å bruke skjæringsteknikken kan vi snu tuppelen. En ny kopi av tuppelen opprettes under denne prosessen.

old_tuple = ('M', 'EN', 'K', 'E', 'U', 'S', 'E', 'O', 'F')
skrive ut("Gammel tuppel:")
skrive ut(gammel_tuppel)
# Reverserende tuppel ved hjelp av skjæring
new_tuple = old_tuple[::-1]
skrive ut("Ny tuppel:")
skrive ut(new_tuple)
# utskrifter
Gammel tuppel:
('M', 'EN', 'K', 'E', 'U', 'S', 'E', 'O', 'F')
Ny tuppel:
('F', 'O', 'E', 'S', 'U', 'E', 'K', 'EN', 'M')

Lære den pytoniske måten

Ved å bruke tuppeloperasjoner i Python kan du utføre en oppgave med minimale kodelinjer. Vær kreativ og utforsk potensialet til tuples videre for å lære Python på en mer pytonisk måte.