A Tuple egy beépített adattípus a Pythonban, amely adatgyűjtemény tárolására szolgál. Hasonló a listához, de valamivel gyorsabb.
Korlátai azonban bizonyos helyzetekben kívánatosabbá teszik a listákat. Ebben a cikkben mindent elmagyarázok, amit tudnia kell a sorok használatának megkezdéséhez.
Mi az a Tuple?
Amint korábban említettük, a tuple a Python egyik beépített adattípusa, amelyet adatgyűjtemények tárolására használnak. Hasonló a Python-listához, mivel iterálható, tömbszerű formátumban tárolja az adatokat. A listától eltérően azonban a tuple megváltoztathatatlan. Azaz, ha egyszer létrejött, értékeit nem lehet megváltoztatni.
További elemek nem adhatók hozzá, és a meglévő elemek nem távolíthatók el. Ezért a tuple ideális olyan adatok tárolására, amelyek nem változnak. Ez akár különböző típusú adatok gyűjteménye is lehet. A következő részben a Pythonban a sorok létrehozásának különböző módjait tárgyaljuk.
Hogyan lehet Tuple-t létrehozni Pythonban?
A Pythonban legalább háromféleképpen hozhat létre sorokat. Ebben a részben a három leggyakoribb módszert ismertetjük, amelyeket valószínűleg használ és fog látni, amikor másoktól kódot olvas.
A következő kódpéldák futtatásához telepíteni kell a Pythont. Ha még nincs telepítve a Python, itt található egy hasznos útmutató a Python telepítéséhez. Alternatív megoldásként futtathatja kódját egy online Python futási környezetben, például a Google Colabban.
#1. A Tuple Literal használata (zárójelek)
A Pythonban definiált sorok legáltalánosabb módja az, hogy értékgyűjteményt zárójelek közé helyezünk. Ezeket az értékeket vesszővel választjuk el. A következő példa szemlélteti ezt a módszert:
# Creates a tuple by placing values between parentheses values = (1, 2, 3) # Printing out the tuple to the screen print(values) # Printing out the type of values variable print(type(values))
A kód futtatása a következőket eredményezi:
Amint a kimenetből látható, a sor azokat az értékeket tartalmazza, amelyekkel inicializáltuk. Ez is
Amikor sorokat hoz létre Pythonban, nincs szükség zárójelekre. Ezért ez az = 1, 2, 3 érték ugyanúgy érvényes, mint az = (1, 2, 3). Javasoljuk azonban, hogy zárójeleket használjon a kód érthetőbbé tétele érdekében.
Egy elemű sorok létrehozása Pythonban kissé bonyolult. Ahelyett, hogy csak egy elemet helyezne zárójelek közé, egy vesszőt is meg kell adnia a végén. Íme egy példa szemléltetésül:
# Without trailing comma, this won't create a tuple not_a_tuple = (1) # With trailing comma, this will create a tuple a_tuple = (1,) # Printing not_a_tuple print(not_a_tuple) # Printing not_a_tuple's data type print(type(not_a_tuple)) # Printing a_tuple print(a_tuple) # Printing a_tuple's data type print(type(a_tuple))
A fenti kód futtatásával látni fogja, hogy a not_a_tuple 1-es int értékké válik. Ezt fontos szem előtt tartani a sorok létrehozásakor.
#2. A konstruktor függvény használata
A Pythonban a sorok létrehozásának második módszere a tuple konstruktor függvényt használja. Ebben a módszerben meghívja a függvényt, és argumentumként egy iterálható objektumot, például egy listát ad át. Ez lesz konvertálva egy sor. Íme egy példa:
# Creating tuple from a list of values values = tuple([1, 2, 3]) # Printing out the values print(values) # Printing out the data type of the values identifier print(type(values))
Mint látható, a függvény használatával ugyanazt az eredményt érjük el, mint a literál használatával. A függvény azonban lehetővé teszi egy dinamikus érték alapján egy sor létrehozását, például egy listát, amelynek értékei csak futás közben ismertek. Az első módszerrel a kód írása közben ismernie kell azokat az értékeket vagy azonosítókat, amelyekből a sor áll.
#3. Üres sor létrehozása
Amikor sorokkal dolgozik a kódban, előfordulhat, hogy üres sorokat kell létrehoznia. Az üres sorok a várt módon jönnek létre. Létrehozásakor használhatja a tuple konstruktort vagy a literált to. Íme egy példa, amely bemutatja, hogyan kell használni bármelyik módszert:
# Using the tuple literal empty_tuple_1 = () # Using the constructor empty_tuple_2 = tuple()
Az üres sorok akkor hasznosak, ha üres eredményhalmazt ábrázolnak. Vegye figyelembe a következő funkciót:
def create_range(start, end):
return tuple(range(start, end))
Ez a függvény létrehoz egy sor értéket az elejétől az átadott végértékig. Ha a függvény eredményeit szeretné átismételni, akkor valami ilyesmit használjon:
my_values = create_range(0, 5)
for value in my_values:
pass
Ha 5-öt és 5-öt ad meg a create_range függvénynek, az eredmény egy üres sor lesz. És ha megpróbálná átírni, akkor nulla iterációja lenne, és a kód a szokásos módon haladna.
Másrészt, ha nem lennének üres sorok, és ehelyett a None értéket kapja, akkor az iteráció során hiba lép fel. A program összeomlásának megelőzése érdekében végre kell hajtania egy tesztet az éles esetre, amelyet a create_range függvény a None-t ad vissza, vagy bármilyen más értéket, amely egy üres sorra utal.
Ez rendetlen kódhoz vezetne. Ideális esetben szeretné elkerülni a különleges eseteket, amennyire csak lehetséges. Ez azt jelenti, hogy az összes függvény visszatérési értékének azonos felülettel kell rendelkeznie, hogy a kód a lehető legjobban működjön általános esetben. Ebben az esetben ez azt jelenti, hogy mindig egy sor visszaadását jelenti, bár időnként üres lesz.
Az elemek elérése
A Pythonban kétféleképpen érheti el a sor elemeit. Az első módszer az index, a második pedig az elemek strukturálása. Először is megvizsgáljuk, hogyan lehet index szerint elérni az elemeket.
Elemek elérése index alapján
Az elemek index általi elérése hasonló ahhoz, ahogyan a listaelemeket index szerint érné el. Ez szögletes zárójelben történik. A sorok nulla alapú indexelési rendszert használnak, ami azt jelenti, hogy az első elem indexe 0, az utána pedig 1 index az utolsó elemig.
Az alábbi példa bemutatja, hogyan lehet index szerint elérni az elemeket:
# Creating a tuple values = (1, 2, 3, 4) # Accessing the first element first_element = values[0] # Accessing the fourth element(index 3) fourth_element = values[3]
Használhat negatív indexelést is. A -1 indexű elem az utolsó elem, a -2 indexű elem pedig a második az utolsó elemtől.
# Creating the tuple values = (1, 2, 3, 4) # Accessing the last element last_element = values[-1] # Accessing the second from last element second_from_last_element = values[-2]
Ezen túlmenően az elemek algyűjteményeihez is hozzáférhet egy tuple-ból, ha felvágja azt. Ez hasonló a lista feldarabolásához. A jelölés a következő:
# Creating the tuple values = (1, 2, 3, 4, 5, 6, 7) # Getting the first three elements values[1: 3] # Getting every other element values[::2]
Iteráció az elemek felett
A tuple egy iterálható objektum a Pythonban. Ezért az elemei között ismételhet egy for ciklust használva, amint az a következő példában látható:
values = (1, 2, 3, 4)
for value in values:
print(value)
Az elemek elérésének ez a módja akkor ideális, ha a sor összes eleméhez hozzá szeretne férni.
Elemek elérése strukturálással
A destrukció magyarázatához vegyük figyelembe a következő forgatókönyvet, ahol a különböző elemeket egy sorba próbáljuk beszerezni.
# Creating the tuple to record a user's information person_record = (1, 'John Doe', '[email protected]') # Accessing the different elements in the tuple to use in our code id = person_record[1] name = person_record[2] email = person_record[3]
A Python lehetővé teszi számunkra, hogy kényelmesebb módszert használjunk az értékek eléréséhez, az alábbiak szerint:
# Creating the tuple to record a user's information person_record = (1, 'John Doe', '[email protected]') id, name, email = person_record
Ezt nevezik destrukturálásnak. Ez az első változó, ebben az esetben az id, a sor első értékéhez, a második változóhoz pedig a második elemhez lesz rendelve. Ez a sor végéig folytatódik. A fenti példa ezzel egyenértékű:
id, name, email = (1, 'John Doe', '[email protected]')
Ebben az esetben ahelyett, hogy a leírót változóban tárolnánk, azonnal strukturáljuk. Ha ezt kombinálod azzal a tudattal, hogy nem kell zárójelet használnod a sorok létrehozásakor, akkor így írhatod a kódot.
id, name, email = 1, 'John Doe', '[email protected]'
Mindezek végén azonosító, név és email változók lesznek, amelyek értéke 1, ‘John Doe’ és ‘[email protected]‘. Ez egy kényelmes és tömör módja a változók létrehozásának a Pythonban, amelyeket az éles kódban látni fog. Segít tudni, hogy ennek az elegáns szintaxisnak a középpontjában a sorok fogalma áll.
A Tuple és a List közötti különbségek
Bár a kettő hasonló, néhány lényeges különbség miatt mindegyik jobban megfelel egy adott használati esetnek. Ezeknek a különbségeknek a megértése segít kiválasztani a legjobb adattípust, és jobb és hatékonyabb kódot írni.
AspectTupleListMemóriatár Tárolás a szomszédos memóriában Tárolás a memória különböző részeinMutabilityMutability (nem módosítható)Mutable (változható)SpeedAccess gyorsabbA hozzáférés lassabbAdattípus Általában különböző típusú adatokat tárol.Általában azonos típusú adatokat tárol Használja az eseteket, mint általában hasonló értékek tárolására használt jelek.Általában hasonló értékek, például jelek gyűjteményének tárolására szolgál.
A Tuple előnyei
#1. Gyorsabb
Mivel a sor értékei a szomszédos memóriában tárolódnak, az értékek elérése gyorsabb a listához képest. Mivel azonban egyszer létrehozták, nem módosíthatók, a sorok nem mindig a legjobb adatstruktúra az értékgyűjtemények tárolására.
Ideális felhasználási esetük sok olyan adat tárolása a memóriában, amelyek nem változnak, de a program végrehajtása során többször is hozzáférnek. Ebben az esetben a programodnak óriási haszna lesz a sorok teljesítményének növeléséből.
#2. Több értéket ad vissza
A sorok segítségével több értéket is visszaadhat egy függvényből, és megsemmisítheti az eredményt. Például:
from random import randint
def create_two_numbers():
first_num = randint(0, 9)
second_num = randint(0, 9)
return first_num, second_num
first_num, second_num = create_two_numbers()
Ebben a példában van egy függvényünk, amely két véletlen számot hoz létre, és mindkettőt egy sorban adja vissza. A return első_szám, második_szám utasítás megegyezik a return (első_szám, második_szám) írásával. Ez azért van, mert a zárójelek nem kötelezőek sorok létrehozásakor. Az eredmény eléréséhez megsemmisítjük azt.
#3. Az értékek írásvédettek
A sorok megváltoztathatatlanok, miután létrehozták. Ezért ideálisak olyan adatok tárolására a memóriában, amelyek nem változnak a program végrehajtása során. Biztosítják, hogy véletlenül se írja felül az adatokat valahol máshol a kódban.
#4. Több adattípus tárolása
A sorok lehetővé teszik több adattípus értékének tárolását. Ez lehetővé teszi adatrekordok létrehozását, például a felhasználó adatainak egy sorban való tárolását. Bonyolultabb elemeket is tárolhat, például függvényeket, szótárakat, egyéb sorokat, sőt listákat is.
Gyakori Tuple Methods
#1. számol()
A tuple objektum tartalmazza a count metódust, amely megszámolja, hogy egy elem hányszor fordul elő. Például:
# Creating a tuple with several numbers values = (1, 2, 3, 4, 5, 4, 4, 6) # Counting the number of fours n_fours = values.count(4) # Prining out the number of fours print(n_fours)
Ebből a példából láthatjuk, hogy a 4-es szám pontosan háromszor fordul elő a sorunkban.
#2. index()
Az index módszerrel megkereshetjük egy érték első előfordulásának indexét egy sorban. Ha az érték nem létezik, a rendszer ValueError kivételt dob fel. Íme néhány kód az index módszer működésének szemléltetésére:
# Creating a tuple with several numbers
values = (1, 2, 3, 4, 5, 4, 4, 6)
# Search for index of 4
index_of_four = values.index(4)
print("Index of four:", index_of_four)
# Search for index of 9
index_of_nine = values.index(9)
print("Index of nine:", index_of_nine)
És amikor a fenti kódot futtatjuk, ez a kimenet:
Ebben az esetben a 4-es index 3, és a kód probléma nélkül futott. De amikor a 9-es indexet kellett megtalálni, a program kivételt hozott. Fontos kezelni az ilyen kivételeket, ha olyan Python-programokat ír, amelyek az index módszert használják.
#3. len()
Mint minden iterálható objektum a Pythonban, a sorok is rendelkeznek egy hossz tulajdonsággal, amelyhez akkor férhet hozzá, ha a leírót argumentumként adja meg a len() függvénynek.
# Creating a tuple values = (1, 2, 3, 4) # Getting the length length = len(values) # Print the output print(length)
Ez a fenti kód futtatásának eredménye.
#4. min() és max()
A min és max metódusok úgy működnek, hogy egy iterálható elemen keresztül hurkolnak, és összehasonlítják, hogy nagyobb vagy kisebb-e az előtte lévőnél. Végül a max az iterálható legnagyobb elemet adja vissza, míg a min a legkisebbet.
A számokkal a művelet nyilvánvaló. A karakterláncok esetében a Python ábécé sorrendet használ. A legkisebb szó, amelyet min visszaad, az első szó, ha a karakterláncokat ábécé sorrendben írtuk. Míg a legnagyobb szó az utolsó szó. Ha az iterable különböző adattípusok keverékét tartalmazza, akkor mindkét művelet meghiúsul, mert a Python nem tudja, hogyan kell összehasonlítani a különböző adattípusokat.
Íme egy kódpélda:
# Creating tuple with values values = (1, 2, 3, 4, 5) # Getting the largest value largest = max(values) # Getting the smallest value smallest = min(values) # Output the results print(largest) print(smallest)
#5. rendezve()
A Python rendezett függvénye bevesz egy iterálható objektumot, és visszaadja a rendezett elemek listáját. Meghívhatja a rendezett függvényt, átadhat egy sort argumentumként, és a sor elemeit listába rendezheti. A rendezett lista sorrá konvertálásához használhatja a konstruktor függvényt. Íme egy példa:
# Creating a tuple with values in random order values = (1, 5, 3, 3, 2, 4) # Using sorted to sort the values into a list sorted_list = sorted(values) # Converting the list into a tuple sorted_tuple = tuple(sorted_list) # Printing the output print(sorted_tuple)
#6. Tuples összeadás és szorzás
Az összeadás művelet két soron egyszerűen összefűzi őket. A szorzási művelet annyiszor ismétli meg a sor elemeit, ahányszor szoroztunk. Íme egy példa a két példa illusztrálására.
# Create a tuple with some values
values = (1, 2, 3, 4, 5)
# Create a new tuple using addition
added = values + values
# Create a new tuple using multiplication
multiplied = values * 2
print("values + values =", added)
print("values * 2 =", multiplied)
Végső szavak
Ebből a cikkből megtudta, hogy:
- A tuples listaszerű objektumok értékgyűjtemények tárolására szolgál.
- A listákkal ellentétben ezek megváltoztathatatlanok.
- Gyorsabbak és hatékonyabbak, mint a listák.
- Zárójelek használatával és az értékek vesszővel történő elválasztásával hozhatók létre.
- A tuple konstruktor függvény segítségével is megszerkeszthetők.
- Egyedi értékeket nulla alapú indexrendszerrel érhet el.
- Az értékeket a leíróból is megsemmisítheti.
- A for-ciklus használatával is iterálhat az értékek felett.
- Különböző módszerek, amelyeket egy sorral használhat.
Ezután érdemes több Python-tartalmat megnézni, például a Python-lista-módszereket és a Python-szótár-módszereket.
