Gyűjtemények létrehozása és használata a Pythonban

A tuple változhatatlan Python-objektumok gyűjteménye. Bármely tetszőleges típusú adatot tartalmazhat (egész szám, karakterlánc, lebegő, lista stb.), Ami rugalmas és hatékony adatstruktúrává teszi. A Python törzsnyelv része, és széles körben használják a Python programokban és projektekben.

Tuple létrehozása

A Pythonban egy duplát lehet létrehozni úgy, hogy az összes vesszővel elválasztott elemet bezárja a zárójelbe ().

t1 = (1, 2, 3, 4)
t2 = ("Make", "Use", "Of")
t3 = (1,2, 5,9, 5,4, 9,3)

A kettő elemei változhatatlanok és rendezettek. Ismétlődő értékeket tesz lehetővé, és tetszőleges számú elemet tartalmazhat. Akár egy üres duplát is létrehozhat. A tuple elemei bármilyen típusúak lehetnek (egész szám, float, stringek, tuple stb.).

Üres Tuple létrehozása

Az üres nyitó és záró zárójelek használatával üres sor hozható létre.

emptyTuple = ()

Tuple létrehozása egyetlen elemmel

Ha csak 1 elemből álló tupelt szeretne létrehozni, hozzá kell adnia a vessző az elem után, hogy a Python kettősként ismerje fel.

 # t1 kettős
t1 = (3,14,)
nyomtatás (típus (t1))
# nyomat

 A # t2 nem kettős
t2 = (3,14)
nyomtatás (típus (t2))
# nyomat

Jegyzet: típus() A Function a paraméterként átadott objektum osztálytípusát adja vissza.

Ha nem használ vesszőt az elem után, akkor a t2 osztálytípusa „lebegő” lesz, ezért kötelező egyetlen vesszőt használni az elem után, ha egyetlen értékű duplát hoz létre.

Tuple létrehozása különböző adattípusokkal

A sorozat elemei bármilyen típusúak lehetnek. Ez a funkció sokoldalúvá teszi a duplát.

tup1 = ('MUO', igaz, 3,9, 56, [1, 2, 3])
nyomtatás (tup1)
# nyomat
('MUO', igaz, 3,9, 56, [1, 2, 3])

Tuple létrehozása a tuple () Constructor használatával

Szalagok is létrehozhatók a kettő () konstruktőr. A tuple () konstruktor segítségével a szekvenciákat, például a listát / szótárt, konvertálhatod duplává.

tup1 = tuple ((1, 2, 3))
nyomtatás (tup1)
# nyomat
(1, 2, 3)

Beágyazott Tuple létrehozása

A csomók könnyen beágyazódhatnak a többi csomóba. A duplát akármilyen szintre beágyazhatja.

tup1 = (1, 2, 3)
tup2 = ('Hello', tup1, 45)
nyomtatás (tup2)
# nyomat
(„Helló”, (1, 2, 3), 45)

Elemek elérése Tuple-ban

A szögletes zárójelben lévő indexszám segítségével elérheti a két elemet. Az index száma 0-tól kezdődik. Tuple támogatja a negatív indexelést is:

• -1: rámutat az utolsó elemre
• -2: rámutat a második utolsó elemre és így tovább

tup1 = ('M', 'A', 'K', 'E', 'U', 'S', 'E', 'O', 'F')
nyomtatás (tup1 [0])
nyomtatás (tup1 [5])
nyomtatás (tup1 [-1])
nyomtatás (tup1 [-9])
# nyomat
M
S
F
M

Tuple szeletelése

A kettősponttal elérheti az elemek egy sorát egy duplában : operátor. A Tuple negatív indexek alkalmazásával is támogatja a szeletelést.

tup1 = ('M', 'A', 'K', 'E', 'U', 'S', 'E', 'O', 'F')
# Elemeket nyomtat az 1. indexből (tartalmazza) a 6. indexbe (kizárva)
nyomtatás (tup1 [1: 6])
# Elemeket nyomtat a kezdettől a 8. indexig (kizárva)
nyomtatás (tup1 [: 8])
# Elemeket nyomtat a 3. indextől (mellékelve) a végéig
nyomtatás (tup1 [3:])
# Elemeket nyomtat a -4 indextől (beleértve) a -1 indexig (kizárva)
nyomtatás (tup1 [-4: -1])
# nyomat
(„A”, „K”, „E”, „U”, „S”)
(„M”, „A”, „K”, „E”, „U”, „S”, „E”, „O”)
(„E”, „U”, „S”, „E”, „O”, „F”)
(„S”, „E”, „O”)

Annak ellenőrzése, hogy van-e elem Tuple-ben

A. Használatával ellenőrizheti, hogy létezik-e egy elem a duplán ban ben kulcsszó.

tup1 = ('M', 'A', 'K', 'E', 'U', 'S', 'E', 'O', 'F')
ha 'M' a tup1-ben:
 print ("Igen, az M elem létezik a duplán")
más:
 print ("Az elem nem található a duplán !!")
# nyomat
Igen, az M elem létezik a duplában

Tollok frissítése

Bármennyire is változhatatlanok a számok, nem lehet megváltoztatni értéküket. A Python TypeError-t dob, ha megpróbálja frissíteni a duplát.

tup1 = ('M', 'A', 'K', 'E', 'U', 'S', 'E', 'O', 'F')
tup1 [0] = 'Z'
# A következő hibát dobta
tup1 [0] = 'Z'
TypeError: A 'tuple' objektum nem támogatja az elem hozzárendelését

De van egy hack, ha frissíteni szeretné a dupláját.

A Tuple elemei értékének módosítása a listák használatával

A tuple elemének értékét a segítségével módosíthatja listák a Pythonban. Először át kell alakítania a duplát listává. Ezután módosítsa a listát tetszés szerint. Végül alakítsa vissza a listát duplává.

tup1 = (1, 2, 3)
nyomtatás ("Ez a régi Tuple:")
nyomtatás (tup1)
temp = lista (tup1)
hőmérséklet [0] = 4
tup1 = tuple (hőmérséklet)
nyomtatás ("Ez a frissített Tuple:")
nyomtatás (tup1)
# nyomat
Ez a régi Tuple:
(1, 2, 3)
Ez a frissített Tuple:
(4, 2, 3)

Új elemek hozzáadása a Tuple listák használatával

Mivel a sorok nem változtathatók meg, nem lehet új elemeket hozzáadni egy duplához. A Python hibát fog dobni:

AttributeError: A 'tuple' objektumnak nincs attribútuma 'append

Ismét használhatja a hackünket (listák használatával) ennek kezelésére. Először konvertálja a duplát listává. Ezután adjon hozzá új elemeket a listához. Végül konvertálja a listát duplává.

Jegyzet: az append () metódust használják a Pythonban új elem hozzáadása a lista végéhez.

tup1 = (1, 2, 3)
nyomtatás ("Ez a régi Tuple:")
nyomtatás (tup1)
temp = lista (tup1)
hőmérsékleti függelék (4)
tup1 = tuple (hőmérséklet)
nyomtatás ("Ez a frissített Tuple:")
nyomtatás (tup1)
# nyomat
Ez a régi Tuple:
(1, 2, 3)
Ez a frissített Tuple:
(1, 2, 3, 4)

Törölje a műveletet a halmazokon

Mivel a sorok nem változtathatók meg, egyetlen elemet sem lehet törölni a duplából. Ha törölni kívánja a teljes duplát, akkor a használatával megtehető del kulcsszó.

tup1 = (1, 2, 3)
del tup1

De ugyanazt a hacket használhatja (listák használatával), mint amit a tuple elemek megváltoztatásához és hozzáadásához használt.

Elemek törlése Tuple listák használatával

Az elemeket a listából 3 egyszerű lépésben lehet törölni:

1. lépés: Konvertálja a duplát listává.

2. lépés: Törölje az elemeket a listából a eltávolítás () módszer

3. lépés: Konvertálja a listát duplává.

tup1 = (1, 2, 3)
nyomtatás ("Ez a régi Tuple:")
nyomtatás (tup1)
temp = lista (tup1)
temp.remove (1)
tup1 = tuple (hőmérséklet)
nyomtatás ("Ez a frissített Tuple:")
nyomtatás (tup1)
# nyomat
Ez a régi Tuple:
(1, 2, 3)
Ez a frissített Tuple:
(2, 3)

Szalagok be- és kicsomagolása

A duplakészítés közben értékeket rendelünk hozzá. Ezt nevezik Csomagol egy Tuple-t.

# Példa egy pár csomagolására
tup1 = (1, 2, 3)

Míg az értékek visszavonását változókba hívjuk Tuple kipakolása.

# Példa egy duplacsomagolásra
tup1 = (1, 2, 3)
(egy, kettő, három) = tup1
nyomtatás (egy)
nyomtatás (kettő)
nyomtatás (három)
# nyomat
1
2
3

Hurok a Python Tuples-szel

A sorrendek iterálható tárolók, akárcsak a Python listái. Könnyedén továbbléphet a kételemeken.

A hurok használata

A Python for loop úgy működik, hogy iterál a tároló elemein.

# Hurkolás a hurokhoz
tup1 = (1, 2, 3)
a tup1 elemhez:
nyomtatás (elem) 
# nyomat
1
2
3

Összefüggő: Hogyan kell használni a Python hurkokhoz

Indexszámok használata

A sorok indexeivel iterálhat a duplán. Használja a len () függvény a tuple méretének megtalálásához.

tup1 = (1, 2, 3)
index tartományban (len (tup1)):
nyomtatás (tup1 [index])
# nyomat
1
2
3

A kód hatékonyságának javítása

Mivel a kettős adatszerkezet megváltoztathatatlan, annak gyorsabb a feldolgozási sebesség mint a felsorolások. Így optimalizálja a Python programokat / projekteket. Ezen erőteljes és sokoldalú adatstruktúra (sorrend) használata a Python programokban a kód hatékonyságát egy újabb szintre emeli.

Tanulás Python? A következő módon kezelhetjük a húrokat

A karakterláncok használata és kezelése a Pythonban nehéznek tűnhet, de megtévesztően egyszerű.

A szerzőről