Python Tuple vs List: Hasonlóságok és különbségek, magyarázat

Ebből az útmutatóból megismerheti a Python sorok és listák közötti hasonlóságokat és különbségeket. Azt is meg fogja érteni, mikor érdemes sorszámot használni.

A lista és a sorok egyaránt beépített adatszerkezetek a Pythonban. Használhatók elemgyűjtemény tárolására.

Az indexelés és szeletelés támogatásától a heterogén adattípusok tárolásáig a sorok és listák hasonló funkcionalitásúnak tűnhetnek. Ezért a kettő közötti hasonlóságok és különbségek megértése segíthet eldönteni, hogy melyik adatstruktúrát használja.

Kezdjük.

👩🏽‍💻 Elindíthat egy Python REPL-t, és követheti ezt az oktatóanyagot. A etoppc.com online Python szerkesztőjét is használhatja a kódoláshoz.

Python Tuple vs List: Mik a hasonlóságok?

Kezdjük azzal, hogy megtanuljuk a listák és a sorok közötti hasonlóságokat. A jobb tanulás érdekében példákat mutatunk be listákra és sorokra.

#1. Python Iterables

Pythonban a listák szögletes zárójelek, míg a sorok zárójelben vannak. Létrehozhat egy sort is vesszővel elválasztott értékek halmazaként – zárójelek nélkül.

Mindkettő iterálható; így a for hurok használatával át lehet őket hurkolni.

Az alábbi kódcella megmutatja, hogyan lehet ismételni egy listán.

nums = [2,6,7,10]
print(f"Type of nums is {type(nums)}")
for num in nums:
  print(num)

# Output
Type of nums is <class 'list'>
2
6
7
10

Ahogy az alábbiakban elmagyarázzuk, egy soron keresztül is iterálhat ciklus segítségével

nums = (2,6,7,10)

# Note: nums = 2,6,7,10 is a valid tuple as well. If needed, run a quick check!

print(f"Type of nums is {type(nums)}")
for num in nums:
  print(num)

# Output
Type of nums is <class 'tuple'>
2
6
7
10

#2. Más szekvenciákból történő létrehozás támogatása

A következő hasonlóság a listák és a sorok között az, hogy létrehozhatók létező sorozatokból, például karakterláncokból.

sample_str = "Coding!"

A következő kódcella megmutatja, hogy a list(string) hogyan ad vissza egy listát, amelynek listaelemei a karakterlánc karakterei.

list_from_str = list(sample_str)
print(list_from_str)

# Output
['C', 'o', 'd', 'i', 'n', 'g', '!']

Hasonlóképpen, egy sor létrehozható karakterláncból vagy más sorozatból a tuple(sequence) használatával. Az alábbi kódcella megmutatja, hogyan teheti ezt meg.

tuple_from_str = tuple(sample_str)
print(tuple_from_str)

# Output
('C', 'o', 'd', 'i', 'n', 'g', '!')

#3. Indexelés és szeletelés támogatása

A Python támogatja a nulla indexelést, amelyben az első elem a nulla indexen, a második az egyes indexen van, és így tovább. A Python támogatja a negatív indexelést is, ahol az utolsó elem a -1 indexen, a másodiktól az utolsóig a -2 indexen van, és így tovább.

list_from_str = ['C', 'o', 'd', 'i', 'n', 'g', '!']
print(list_from_str[1])
# o

A -2 indexű elem az utolsó előtti elem, „g”.

tuple_from_str = ('C', 'o', 'd', 'i', 'n', 'g', '!')
print(tuple_from_str[-2])
# g

A szeletelést akkor használhatja, ha a lista vagy sor egy kis részével szeretne dolgozni. lista[start:end] a lista egy szeletét adja vissza, amely az index kezdetétől kezdődik és egészen a végéig tart – 1. A kezdet alapértelmezett értéke 0, a vége pedig az iterálható utolsó eleme.

  Az AirPod csatlakoztatása iPhone-hoz

A sorokat ugyanazzal a szintaxissal szeletelheti. Hozzunk létre szeleteket a korábban létrehozott listából és sorból.

list_from_str = ['C', 'o', 'd', 'i', 'n', 'g', '!']
print(list_from_str[0:5])

['C', 'o', 'd', 'i', 'n']

A kezdő és záró értékek mellett lépésértéket is megadhat. A tuple(start:end:step) a sor egy szeletét adja vissza az elejétől a végéig – 1, lépésenként.

tuple_from_str = ('C', 'o', 'd', 'i', 'n', 'g', '!')
print(tuple_from_str[::2])

('C', 'd', 'n', '!')

Itt a lépésértéket 2-re állítjuk. Tehát a szelet minden második elemet tartalmaz.

#4. Több adattípus gyűjteménye

Az általunk vizsgált példákban a lista minden eleme és a sorok azonos adattípusúak voltak.

Különféle adattípusok értékeit azonban tárolhatja egyetlen listán vagy egy soron belül.

A student_list alatti kódrészlet tartalmazza a tanuló nevét karakterláncként, életkorát egész számként, a jelöléseket pedig lebegőjelként.

student_list = ["John",22,96.5]
for item in student_list:
  print(f"{item} is of type {type(item)}")

# Output
John is of type <class 'str'>
22 is of type <class 'int'>
96.5 is of type <class 'float'>

Hasonló példát hozhatunk egy sorra is.

student_tuple = ("Jane",23,99.5)
for item in student_tuple:
  print(f"{item} is of type {type(item)}")

# Output
Jane is of type <class 'str'>
23 is of type <class 'int'>
99.5 is of type <class 'float'>

#5. Támogatás a tagsági teszteléshez

Mind a listák, mind a sorok lehetővé teszik bizonyos elemek meglétének tagsági tesztelését. Ha ellenőrizni szeretné, hogy egy adott elem szerepel-e egy listában vagy egy sorban, használhatja az in operátort.

Az iterálható kifejezés eleme igazra értékeli, ha az iterálható tartalmazza az elemet; különben hamis.

"Alex" in student_list
# False

"Jane" in student_tuple
# True

Eddig megtanulta a hasonlóságokat a listák és a Python sorai között. Ezután ismerjük meg a két adatstruktúra közötti legfontosabb különbségeket.

Python Tuple vs List: Mik a különbségek?

#1. Listák változékonysága és Tuples változhatatlansága Pythonban

A leglényegesebb különbség a lista és a Python sorai között az, hogy a sor megváltoztathatatlan. Ez azt jelenti, hogy nem módosíthat egy sort a helyén.

▶️ Íme egy példa.

tuple1 = ("Java","Python","C++")
tuple1[0] = "Rust"

# Output
----> 2 tuple1[0] = "Rust"

TypeError: 'tuple' object does not support item assignment

A lista egy változtatható adatstruktúra, így a listát úgy tudjuk módosítani, hogy egy adott indexen lévő elemet módosítunk, mint a következő kódcellában.

list1 = ["Java","Python","C++"]
list1[0] = "Rust"
print(list1)

# Output
['Rust', 'Python', 'C++']

#2. Változó hosszúságú listák vs fix hosszúságú sorok

A Python lista egy változó hosszúságú adatstruktúra.

  Hogyan készítsünk privát táblát a Pinteresten

A következőket teheti:

  • Adjon hozzá egy elemet a lista végéhez
  • Adjon hozzá elemeket egy másik listáról az aktuális lista végére
  • Egy adott indexhez tartozó elemek eltávolítása a listáról
list1 = [2,3,4,5]

# add an item to the end
list1.append(9)
print(list1)

# add items from list2 to the end of list1
list2 = [0,7]
list1.extend(list2)
print(list1)

# remove an item from list1
list1.pop(0)
print(list1)

▶️ A fenti kódrészlet kimenete.

# Output
[2, 3, 4, 5, 9]
[2, 3, 4, 5, 9, 0, 7]
[3, 4, 5, 9, 0, 7]

A sorok rögzített hosszúságú adatstruktúrák. Tehát nem vehet fel vagy távolíthat el elemeket egy meglévő sorból. De újradefiniálhatja a leírót, hogy különböző elemeket tartalmazzon.

tuple1 = (2,4,6,8)
tuple1 = (1,8,9)
print(tuple1)

# Output
(1, 8, 9)

#3. Méret a memóriában

Most az előző részben tanultakra építünk: a lista egy változó hosszúságú adatstruktúra.

Amikor először definiálja a listát, egy adott méret van hozzárendelve a memóriában. Most, amikor az append() vagy extend() metódusokkal módosít egy listát, további memóriát kell lefoglalni a hozzáadott elemek tárolására. Ez az elosztás szinte mindig több, mint amennyi elemet hozzáad.

Így nyomon kell követni a listán szereplő elemek számát és a lefoglalt helyet. Ezenkívül, mivel a listák változó hosszúságúak, van egy mutató, amely a listaelemek címére mutat. Ennek eredményeként a k hosszúságú listák több memóriát foglalnak el, mint az azonos k elemű sorok.

Íme egy egyszerű illusztráció.

Használhatja a beépített sys modul getsizeof() metódusát egy Python objektumon, hogy lekérje egy objektum méretét a memóriában.

import sys

list1 = [4,5,9,14]
list_size = sys.getsizeof(list1)
print(f"Size of list:{list_size}")

tuple1 = (4,5,9,14)
tuple_size = sys.getsizeof(tuple1)
print(f"Size of tuple:{tuple_size}")

Egy lista több memóriát foglal el, mint egy sor azonos számú és értékű elemhez, amint azt az alábbi kimenet is igazolja.

# Output
Size of list:104
Size of tuple:88

Mikor érdemes Python Tuple-t használni?

A Python listák és sorok közötti különbségekből és hasonlóságokból tudja, hogy ha módosítható gyűjteményre van szüksége, akkor listát kell használnia.

De mikor érdemes inkább tuple-t használni?

Ebben a részben ezzel foglalkozunk.

#1. Csak olvasható gyűjtemény

Ha azt szeretné, hogy egy gyűjtemény változhatatlan legyen, akkor azt egy sorként kell meghatároznia. Tegyük fel, hogy a szín = (243,55,103) egy sor, amely a színárnyalatnak megfelelő RGB értékeket tartalmazza. Ha a színt sorként határozzuk meg, akkor az nem módosítható.

Lényegében, amikor csak olvasható gyűjteményre van szükség: az értékeket nem szabad módosítani a program során, érdemes megfontolni egy tuple használatát. Ez megakadályozza az értékek nem kívánt módosítását.

#2. Szótár kulcsai

Létrehozhat például egy szótárt a listaelemek kulcslistája kulcsok használatával. A dict.fromkeys() metódussal szótárt hozhat létre listából.

key_list = list("ABCD")
dict.fromkeys(key_list)

{'A': None, 'B': None, 'C': None, 'D': None}

Tegyük fel, hogy módosítja a listát úgy, hogy az első elemként „D” legyen (index 0) – a szótár létrehozása előtt.

  Hogyan töltheti le adatait az Apple-ről

Nos, mi történik a szótár „A” kulcsával?

Ha megpróbál létrehozni egy szótárt a key_listből, és hozzáfér az ‘A’ kulcsnak megfelelő értékhez, KeyError hibaüzenetet fog kapni.

key_list[0] = 'D'

dict.fromkeys(key_list)['A']

---------------------------------------------------------------------------
KeyError                                  Traceback (most recent call last)
<ipython-input-31-c90392acc2cf> in <module>()
----> 1 dict.fromkeys(key_list)['A']

KeyError: 'A'

A szótár kulcsainak egyedinek kell lenniük. Tehát nem lehet második „D” kulcs.

dict.fromkeys(key_list)
{'B': None, 'C': None, 'D': None} # A is no longer a key.

Ha ehelyett egy tuple-t használunk, az ilyen módosítások lehetetlenek, és kevésbé valószínű, hogy hibákba ütközünk. Ezért érdemes inkább szótárt létrehozni egy sor elemeit kulcsként használni.

key_tuple = tuple("ABCD")
dict.fromkeys(key_tuple)
{'A': None, 'B': None, 'C': None, 'D': None}

key_tuple[0] = 'D'
---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-12-2cecbefa7db2> in <module>()
----> 1 key_tuple[0] = 'D'

TypeError: 'tuple' object does not support item assignment

#3. A függvény argumentumai

A sorok megváltoztathatatlansága arra is alkalmassá teszi őket, hogy függvényargumentumként adják át őket.

Tekintsük a következő find_volume() függvényt, amely egy téglatest térfogatát adja vissza a következő méretekkel: hossz, szélesség és magasság.

def find_volume(dimensions):
  l,b,h = dimensions
  return l*b*h

Tegyük fel, hogy ezek a dimenziók elérhetők a dimenziók nevű listában. A find_volume() függvény hívása a dimenziókkal mint argumentum a kötetet adja vissza.

dimensions = [2,8,5]
find_volume(dimensions)
80

A listában tárolt méreteket bármikor módosíthatja.

dimensions = [20,8,5]
find_volume(dimensions)
800

Néha azonban az értékeknek állandónak kell maradniuk, és ellenállniuk kell a módosításoknak. Ekkor érdemes megfontolni az argumentumok sorként való tárolását és a függvényhívásban való felhasználását.

#4. Értékek visszaadása a függvényekből

A Pythonban a függvények visszatérési értékeiben sorokkal találkozhatunk. Ha egy függvényből több értéket ad vissza, a Python implicit módon sorként adja vissza azokat.

Tekintsük a következő return_even() függvényt:

def return_even(num):
  even = [i for i in range(num) if (i%2==0)]
  return even,len(even)
  • Argumentumként egy szám számot vesz fel
  • Visszaadja az intervallum páros számainak listáját [0,num) and the length of that list.

Let’s set the value of num 20 and call the function.

num = 20

Calling return_even() returns the two values in a tuple. You can call the type() function with the function call as the verification argument.

type(return_even(num)) # <class 'tuple'>

You can print out the return value to verify that it’s a tuple containing the list of even numbers as the first item and the length of the list as the second item.

print(return_even(num))
([0, 2, 4, 6, 8, 10, 12, 14, 16, 18]10)

Mivel két elem van a tuple-ben, ezeket két változóra bonthatja ki az alábbiak szerint.

even_nums, count = return_even(num)

print(even_nums)
print(count)

[0, 2, 4, 6, 8, 10, 12, 14, 16, 18]
10

Következtetés

Remélem, ez az oktatóanyag átfogó összehasonlítást nyújtott a Python tuple és a lista között.

Zárjuk le az oktatóprogramot egy gyors összefoglalóval:

  • A lista és a sorok a Python beépített adatstruktúrái.
  • Hasonlóságok: iterálható elemek, indexelés, szeletelés támogatása, különböző adattípusok és operátor a tagság teszteléséhez.
  • Főbb különbség: A listák változtathatók, a sorok pedig megváltoztathatatlanok.
  • Egyéb különbségek: Fix hosszúságú sorok és változó hosszúságú listák, kisebb méret a sorok memóriájában.
  • Mikor érdemes tuplet használni? Változatlan gyűjteményekhez, szótárkulcsokhoz és függvényargumentumokhoz.

Ezután nézze meg a Python-projekteket a gyakorláshoz és a tanuláshoz. Vagy tanuljon meg módszereket a duplikált elemek eltávolítására a Python-listákról. Boldog tanulást! akkor jó kódolást!👩🏽‍💻