Python Language
tupel

Introduktion

Syntax

• (1, a, "hej") # a måste vara en variabel

• () # en tom tupel

• (1,) # en tupel med 1 element. (1) är inte en tupel.

• 1, 2, 3 # 3-elementets tupel (1, 2, 3)

Anmärkningar

Indexera tuples

x = (1, 2, 3)
x[0]  # 1
x[1]  # 2
x[2]  # 3
x[3]  # IndexError: tuple index out of range

Indexering med negativa siffror börjar från det sista elementet som -1:

x[-1] # 3
x[-2] # 2
x[-3] # 1
x[-4] # IndexError: tuple index out of range

Indexera en rad element

print(x[:-1])   # (1, 2)
print(x[-1:])   # (3,)
print(x[1:3])   # (2, 3)

Tuples är oföränderliga

En av de huvudsakliga skillnaderna mellan list och tuple i Python är att tuples är oföränderliga, det vill säga man kan inte lägga till eller ändra objekt när tupeln har initialiserats. Till exempel:

>>> t = (1, 4, 9)
>>> t[0] = 2
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'tuple' object does not support item assignment

På samma sätt har .append inte .append och .extend metoder som list gör. Att använda += är möjligt, men det ändrar bindning av variabeln och inte själva tupeln:

>>> t = (1, 2)
>>> q = t
>>> t += (3, 4)
>>> t
(1, 2, 3, 4)
>>> q
(1, 2)

Var försiktig när du placerar muterbara föremål, som lists , i tuplorna. Detta kan leda till mycket förvirrande resultat när du ändrar dem. Till exempel:

>>> t = (1, 2, 3, [1, 2, 3])
(1, 2, 3, [1, 2, 3])
>>> t[3] += [4, 5]

Kommer både att ta upp ett fel och ändra innehållet i listan inom tupeln:

TypeError: 'tuple' object does not support item assignment
>>> t
(1, 2, 3, [1, 2, 3, 4, 5])

Du kan använda += operatören för att "bifoga" till en tupel - detta fungerar genom att skapa en ny tupel med det nya elementet du "bifogade" och tilldela det till dess aktuella variabel; den gamla tupeln ändras inte utan ersätts!

Detta undviker att konvertera till och från en lista, men det är långsamt och är en dålig praxis, särskilt om du ska lägga till flera gånger.

Tuple är elementvis klickbar och likvärdiga

hash( (1, 2) )  # ok
hash( ([], {"hello"})  # not ok, since lists and sets are not hashabe

Således kan en tupel läggas in i en set eller som en nyckel i en dict bara om var och en av dess element kan.

{ (1, 2) } #  ok
{ ([], {"hello"}) ) # not ok

tupel

Syntaktiskt är en tupel en kommaseparerad lista över värden:

t = 'a', 'b', 'c', 'd', 'e'

Även om det inte är nödvändigt, är det vanligt att stänga hinkarna i parentes:

t = ('a', 'b', 'c', 'd', 'e')

Skapa en tom tupel med parenteser:

t0 = ()
type(t0)            # <type 'tuple'>

För att skapa en tupel med ett enda element måste du inkludera ett slutligt komma:

t1 = 'a',
type(t1)              # <type 'tuple'>

Observera att ett enda värde inom parentes inte är en tupel:

t2 = ('a')
type(t2)              # <type 'str'>

För att skapa en singleton-tupel är det nödvändigt att ha en efterföljande komma.

t2 = ('a',)
type(t2)              # <type 'tuple'>

Observera att för singleton tuples rekommenderas det (se PEP8 om efterkommande komma ) att använda parenteser. Inget vitt utrymme efter det efterföljande kommaet (se PEP8 på vitutrymmen )

t2 = ('a',)           # PEP8-compliant
t2 = 'a',             # this notation is not recommended by PEP8
t2 = ('a', )          # this notation is not recommended by PEP8

Ett annat sätt att skapa en tupel är inbyggd funktion tuple .

t = tuple('lupins')
print(t)              # ('l', 'u', 'p', 'i', 'n', 's')
t = tuple(range(3))
print(t)              # (0, 1, 2)

Dessa exempel är baserade på material från boken Think Python av Allen B. Downey .

Packning och packning av tuples

Tuples i Python är värden separerade med komma-tecken. Det är valfritt att stänga av parenteser för att mata in tupplar, så de två uppgifterna

a = 1, 2, 3   # a is the tuple (1, 2, 3)

och

a = (1, 2, 3) # a is the tuple (1, 2, 3)

är likvärdiga. Uppgiften a = 1, 2, 3 kallas också förpackning eftersom den packar värden tillsammans i en tupel.

Observera att en tupel med ett värde också är en tupel. För att berätta för Python att en variabel är en tupel och inte ett enda värde kan du använda ett släp komma

a = 1  # a is the value 1
a = 1, # a is the tuple (1,)

Komma behövs också om du använder parenteser

a = (1,) # a is the tuple (1,)
a = (1)  # a is the value 1 and not a tuple

För att packa upp värden från en tupel och göra flera uppdrag använder du

# unpacking AKA multiple assignment
x, y, z = (1, 2, 3) 
# x == 1
# y == 2
# z == 3

Symbolen _ kan användas som en engångsvariabelns namn om man bara behöver vissa element i en tupel, som fungerar som en platshållare:

a = 1, 2, 3, 4
_, x, y, _ = a
# x == 2
# y == 3

Enkel element tuples:

x, = 1,  # x is the value 1
x  = 1,  # x is the tuple (1,)

I Python 3 kan en målvariabel med * prefix användas som en catch-all variabel (se Unpacking Iterables ):

first, *more, last = (1, 2, 3, 4, 5)
# first == 1
# more == [2, 3, 4]
# last == 5

Omvända element

Omvända element i en tupel

colors = "red", "green", "blue"
rev = colors[::-1]
# rev: ("blue", "green", "red")
colors = rev
# colors: ("blue", "green", "red")

Eller med omvänd (omvänd ger en iterable som konverteras till en tupel):

rev = tuple(reversed(colors))
# rev: ("blue", "green", "red")
colors = rev
# colors: ("blue", "green", "red")

Inbyggda Tuple-funktioner

Tuples stöder följande inbyggda funktioner

Jämförelse

Om element är av samma typ utför python jämförelsen och returnerar resultatet. Om element är olika typer, kontrollerar det om de är siffror.

• Om siffror, gör jämförelse.
• Om något av elementen är ett nummer, returneras det andra elementet.
• Annars sorteras typer alfabetiskt.

Om vi nådde slutet på en av listorna är den längre listan "större". Om båda listorna är samma returnerar det 0.

tuple1 = ('a', 'b', 'c', 'd', 'e')
tuple2 = ('1','2','3')
tuple3 = ('a', 'b', 'c', 'd', 'e')

cmp(tuple1, tuple2)
Out: 1

cmp(tuple2, tuple1)
Out: -1

cmp(tuple1, tuple3)
Out: 0

Tuple längd

Funktionen len returnerar den totala längden på tupeln

len(tuple1)
Out: 5

Max tupel

Funktionen max returnerar objekt från tupeln med maxvärdet

max(tuple1)
Out: 'e'

max(tuple2)
Out: '3'

Min tupel

Funktionen min returnerar objektet från tupeln med minvärdet

min(tuple1)
Out: 'a'

min(tuple2)
Out: '1'

Konvertera en lista till tuple

Den inbyggda funktionen tuple omvandlar en lista i en tupel.

list = [1,2,3,4,5]
tuple(list)
Out: (1, 2, 3, 4, 5)

Tuple sammankoppling

Använd + att sammanfoga två tuples

tuple1 + tuple2
Out: ('a', 'b', 'c', 'd', 'e', '1', '2', '3')