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.
Tartalomjegyzék
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.
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.
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.
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!👩🏽💻