Python TUPLE – Packa, packa upp, jämför, skiva, radera, nyckel

⚡ Smart sammanfattning

Python Tuple is an ordered, immutable collection of values written in parentheses. The examples below cover tuple packing and unpacking, comparing tuples, using tuples as dictionary keys, deleting, slicing, and the advantages of tuples over lists.

  • 📦 Definition: A tuple is an ordered, immutable collection created with parentheses.
  • 🔁 Packing/Unpacking: Group values into a tuple, then extract them back into variables.
  • ⚖️ Jämförande: Tuples are compared element by element from left to right.
  • 🔑 Dictionary Keys: Because tuples are hashable, they can act as composite dictionary keys.
  • ✂️ Skiva: Fetch sub-elements from a tuple using slice notation.
  • 🚀 fördelar: Tuples are faster and write-protected compared to lists.

Python tupel

Vad är Tuple Matching i Python?

Tuple Matching in Python är en metod för grouping tuplarna genom att matcha det andra elementet i tuplerna. Detta uppnås genom att använda en ordbok genom att kontrollera det andra elementet i varje tupel i Python-programmering. Vi kan dock skapa nya tupler genom att ta delar av befintliga tupler.

Tuppelsyntax

Tup = ('Jan','feb','march')

För att skriva en tom tupel måste du skriva som två parenteser som inte innehåller något-

tup1 = ();

För att skriva tupel för ett enskilt värde måste du inkludera ett kommatecken, även om det finns ett enda värde. Även i slutet måste du skriva semikolon som visas nedan.

Tup1 = (50,);

Tupelindex börjar på 0, och de kan sammanfogas, skivas och så vidare.

Tuppeluppgift

Python har tuppeltilldelningsfunktion som gör att du kan tilldela mer än en variabel åt gången. Här har vi tilldelat tuppel 1 med personens information som namn, efternamn, födelseår etc. och en annan tuppel 2 med värdena i som nummer (1,2,3,...,7).

Till exempel,

(namn, efternamn, födelseår, favoritfilm och år, yrke, födelseort) = Robert

Här är koden,

tup1 = ('Robert', 'Carlos','1965','Terminator 1995', 'Actor','Florida');
tup2 = (1,2,3,4,5,6,7);
print(tup1[0])
print(tup2[1:4])
  • Tupel 1 innehåller lista med information om Robert
  • Tuple 2 innehåller en lista med nummer
  • Vi kallar värdet för [0] i tuppel och för tuppel 2 kallar vi värdet mellan 1 och 4
  • Kör koden- Det ger namnet Robert för första tuppel medan för andra tuppel ger det nummer (2,3 och 4)

Packning och packning

Vid packning lägger vi värde i en ny tupel medan vi vid uppackning ex...tracomvandla dessa värden till variabler.

x = ("Guru99", 20, "Education")    # tuple packing
(company, emp, profile) = x    # tuple unpacking
print(company)
print(emp)
print(profile)

Jämför tupler

En jämförelseoperatör i Python kan arbeta med tuplar.

Jämförelsen börjar med ett första element av varje tupel. Om de inte jämförs med =,< eller > går det vidare till det andra elementet och så vidare.

Det börjar med att jämföra det första elementet från var och en av tuplarna

Låt oss studera detta med ett exempel-

#fall 1

a=(5,6)
b=(1,4)
if (a>b):print("a is bigger")
else: print("b is bigger")

#fall 2

a=(5,6)
b=(5,4)
if (a>b):print("a is bigger")
else: print ("b is bigger")

#fall 3

a=(5,6)
b=(6,4)
if (a>b):print("a is bigger")
else: print("b is bigger")

Fall 1: Jämförelse börjar med ett första element i varje tupel. I detta fall 5>1, så utgången a är större

Fallet 2: Jämförelse börjar med ett första element i varje tupel. I det här fallet 5>5 vilket inte är avgörande. Så det går vidare till nästa element. 6>4, så utgången a är större

Fallet 3: Jämförelse börjar med ett första element i varje tupel. I detta fall 5>6 vilket är falskt. Så det går in i else-blocket och skriver ut "b är större."

Använda tupler som nycklar i ordböcker

Eftersom tuples är hashbara och list inte är det, måste vi använda tuple som nyckel om vi behöver skapa en sammansatt nyckel att använda i en ordbok.

Exempelvis: Vi skulle stöta på en sammansatt nyckel om vi behöver skapa en telefonkatalog som mappar, förnamn, efternamn, par av telefonnummer etc. Om vi ​​antar att vi har deklarerat variablerna som sista och första nummer, skulle vi kunna skriva en ordboksuppgift enligt nedan:

directory[last,first] = number

Innanför parenteserna är uttrycket en tupel. Vi skulle kunna använda tuppeltilldelning i en for-loop för att navigera i den här ordboken.

for last, first in directory:
print first, last, directory[last, first]

Denna loop navigerar nycklarna i katalogen, som är tupler. Den tilldelar elementen i varje tupel till sista och första och skriver sedan ut namnet och motsvarande telefonnummer.

Tuples och ordbok

Dictionary kan returnera listan med tupler genom att anropa objekt, där varje tupel är ett nyckelvärdespar.

a = {'x':100, 'y':200}
b = list(a.items())
print(b)

Ta bort Tuples

Tuples är oföränderliga och kan inte raderas. Du kan inte ta bort eller ta bort objekt från en tupel. Men att ta bort tuple helt är möjligt genom att använda nyckelordet

del

Skivning av Tuple

För att hämta specifika uppsättningar av underelement från tuple eller lista använder vi denna unika funktion som kallas slicing. Skivning är inte bara tillämplig på tupel utan också för array och list.

x = ("a", "b","c", "d", "e")
print(x[2:4])

Utdata från denna kod kommer att vara ('c', 'd').

Här är Python 2 Code för alla ovanstående exempel

tup1 = ('Robert', 'Carlos','1965','Terminator 1995', 'Actor','Florida');
tup2 = (1,2,3,4,5,6,7);
print  tup1[0]
print  tup2[1:4]

#Packing and Unpacking
x = ("Guru99", 20, "Education")    # tuple packing
(company, emp, profile) = x    # tuple unpacking
print company
print emp
print profile

#Comparing tuples
#case 1
a=(5,6)
b=(1,4)
if (a>b):print "a is bigger"
else: print "b is bigger"

#case 2
a=(5,6)
b=(5,4)
if (a>b):print "a is bigger"
else: print "b is bigger"

#case 3
a=(5,6)
b=(6,4)
if (a>b):print "a is bigger"
else: print "b is bigger"

#Tuples and dictionary
a = {'x':100, 'y':200}
b = a.items()
print b 

#Slicing of Tuple
x = ("a", "b","c", "d", "e")
print x[2:4]

Inbyggda funktioner med Tuple

För att utföra olika uppgifter låter tuple dig använda många inbyggda funktioner som all(), any(), enumerate(), max(), min(), sorted(), len(), tuple(), etc.

Fördelar med tupel över lista

  • Iteration genom tupler är snabbare än med list, eftersom tupler är oföränderliga.
  • Tuples som består av oföränderliga element kan användas som nyckel för ordbok, vilket inte är möjligt med list
  • Om du har data som är oföränderlig, kommer implementering av den som tupel att garantera att den förblir skrivskyddad

Vanliga frågor

A tuple is immutable and written with parentheses, while a list is mutable and written with square brackets. Tuples are faster and can be dictionary keys; lists are better when you need to add, remove, or change items.

No. Tuples are immutable, so you cannot change, add, or remove their elements after creation. If you need a modified version, create a new tuple, or convert the tuple to a list, change it, and convert it back.

Add a trailing comma after the value, such as t = (50,). Without the comma, Python treats the parentheses as a normal grouping and creates an integer, not a tuple. The comma is what makes it a single-element tuple.

Use tuple() to turn a list into a tuple, for example tuple([1, 2, 3]). To go the other way, use list() on the tuple. Conversion is handy when you must temporarily modify data that is otherwise fixed.

Yes. A tuple can hold mixed types such as strings, integers, and floats, and it can contain other tuples or lists. Nested tuples let you model rows, coordinates, or records where each position has a clear meaning.

A named tuple, from the collections module, gives each position a name so you can read fields by label instead of index. It keeps tuple immutability and speed while making code far more readable, like a lightweight class.

Tuples store fixed, ordered data such as array shapes, coordinates, and dataset records. Libraries like NumPy and pandas use tuples for shapes and index keys. Their immutability keeps machine learning data safe to pass around without accidental changes.

Yes. These AI assistants can generate tuple packing, unpacking, and slicing code from a plain-English prompt, then explain each line. They also suggest when a tuple fits better than a list. Always review and test generated code before using it.

Sammanfatta detta inlägg med: