Hogyan készítsünk sorokat a Pythonban, és miért használjuk őket?

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 típusú.

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.

  Hogyan oltsunk el tábortüzet a Minecraftban

#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ő: [<start>: <end>: <skip>]. A következő példa a szeletelést mutatja be:

# 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.

  A víruskeresőd valóban kémkedik utánad?

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.

  Átfogó útmutató marketingesek számára

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.