A tuple a Pythonban az adatgyűjtemények tárolására használt négy beépített adattípus egyike. A sorműveletek azok, amelyeket a sor adatstruktúra elemein lehet végrehajtani. Nézzünk meg néhányat a Python legszélesebb körben használt sorműveletei közül.

1. Számolja meg egy elem előfordulását a Tuple-ban

számol() A metódus egy elem összes előfordulásának számlálására szolgál a sorban. Ha az elem nem található a sorban, akkor a függvény 0-t ad vissza.

tup1 = ( 1, 4, 7, 3, 6, 4, 1, 8, 4 )
# azt számolja, hogy hányszor fordul elő 4 a sorban
nyomtatás( tup1.count(4) )
# nyomat
3

2. Egy elem helyzetének megkeresése egy sorban

Használhatja a index() módszer egy elem indexének/pozíciójának megkeresésére a sorban. Ha egy elemnek több előfordulása van a sorban, akkor a függvény az első előfordulás indexét adja vissza.

tup1 = ( 1, 4, 7, 3, 6, 4, 1, 8, 4)
nyomtatás( tup1.index(4) )
# nyomat
1

Jegyzet:

Ha megpróbálja megkeresni annak az elemnek az indexét, amely nem szerepel a sorban, akkor a függvény ValueError-t dob ​​a következőképpen:

instagram viewer

ValueError: tuple.index (x): x nincs tuple-ben

3. Hogyan csatlakozz két vagy több tuple-hez

Két vagy több sorhoz csatlakozhat a + operátor.

tup1 = ( 1, 2, 3 )
tup2 = ( 4, 5, 6 )
tup3 = tup1 + tup2
nyomtatás(tup3)
# nyomat
(1, 2, 3, 4, 5, 6)

4. Hogyan alakítsuk át a karakterláncot Tuple-vé

Használhatja a tuple() konstruktort, hogy egy karakterláncot leíróvá alakítson úgy, hogy a karakterláncot paraméterként adja át a tuple() konstruktornak.

tup1 = tuple( "KIHASZNÁLNI" )
nyomtatás(tup1)
# nyomat
('M', 'A', 'K', 'E', 'U', 'S', 'E', 'O', 'F')

5. Hogyan alakítsuk át a listát Tuple-vé

Három megközelítést követhetünk a lista sorrá konvertálására.

1. megközelítés: A tuple() konstruktor használata

tuple() A constructor segítségével egy listát egy listává alakíthatunk át úgy, hogy a listát paraméterként adjuk át a tuple() konstruktornak.

lista1 = [1, 2, 3, 4, 5, 6]
tup1 = tuple (lista1)
nyomtatás(tup1)
# nyomat
(1, 2, 3, 4, 5, 6)

2. megközelítés: ciklus használata a tuple() konstruktoron belül

Ez egy kis változata a fenti megközelítésnek. hurkot futunk (listaértés segítségével) a tuple() konstruktoron belül a tuple létrehozásához.

lista1 = [ 1, 2, 3, 4, 5, 6 ]
tup1 = tuple(elem az elemhez a list1-ben)
nyomtatás(tup1)
# nyomat
(1, 2, 3, 4, 5, 6)

3. megközelítés: A (*listName,)

Ez kicsomagolja a listát a sor literálon belül az egyetlen vessző (,). Ez a módszer a leggyorsabb a három megközelítés közül.

lista1 = [1, 2, 3, 4, 5, 6]
tup1 = (*lista1,)
nyomtatás(tup1)
# nyomat
(1, 2, 3, 4, 5, 6)

6. Hogyan szorozzuk a sorokat

A sor tartalmát tetszőleges számú alkalommal megszorozhatja a * operátor.

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

7. Hogyan lehet megtalálni az elemek teljes számát egy sorban

len() A függvény a Python egyik leggyakrabban használt beépített funkciója. Az objektumban lévő elemek teljes számának megkeresésére szolgál. A len() függvény segítségével megszámolhatja a sor elemeinek teljes számát.

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

8. Hogyan lehet megtalálni a minimális elemet egy tuple-ben

min() A függvény a legalacsonyabb értékű elem megkeresésére szolgál az adott sorban.

tup1 = ( 1, 2, 3 )
print("Minimális elem ban ben a tuple van: ")
nyomtatás( min( fel1 ) )
# nyomat
Minimális elem ban ben a tuple van:
1

9. Hogyan találjuk meg a maximális elemet egy sorban

max() A függvény a legmagasabb értékű elem megkeresésére szolgál az adott sorban.

tup1 = ( 1, 2, 3 )
print("Maximális elem ban ben a tuple van: ")
nyomtatás(max.(tup1))
# nyomat
Maximális elem ban ben a tuple van:
3

10. Hogyan találjuk meg az összes elem összegét egy sorban

összeg() A függvény a sor összes elemének számtani összegét számítja ki.

tup1 = ( 1, 2, 3 )
nyomtatás("Elemek összege: ")
nyomtatás( összeg( tup1 ) )
# nyomat
Elemek összege:
6

11. any() művelet a Tuple-eken

Ha a sor egy vagy több elemének igaz logikai értéke van, akkor Bármi() függvény visszaadja Igaz különben visszatér Hamis.

tup1 = ( Hamis, Hamis, Hamis, Igaz )
nyomtatás( any ( tup1 ) )
# nyomat
Igaz

12. all() Művelet a Tuple-eken

Te tudod használni összes() függvény segítségével ellenőrizheti, hogy a sor összes eleme rendelkezik-e True logikai értékkel. Még ha a sor bármely elemének logikai értéke is False, a függvény False értéket ad vissza.

tup1 = ( Igaz, Igaz, Igaz, Hamis, Igaz )
nyomtatás(mind(tup1))
# nyomat
Hamis

13. sorted() Művelet a Tuple-eken

Használhatja a rendezve() függvényt, hogy növekvő sorrendben rendezett listát adjon vissza.

tup1 = ( 6, 1, 8, 3, 7, 2 )
nyomtatás( rendezve (tup1) )
nyomtatás( típus(rendezett( tup1 )) )
# nyomat
[1, 2, 3, 6, 7, 8]
<osztály 'lista'>
# Vegye figyelembe, hogy a visszatérési típus lista

14. Hogyan keverjük össze a Tuple-t

Mivel a sorok megváltoztathatatlanok, nem keverhetők közvetlenül. Listákat kell használnunk a sor keveréséhez. Keverhetünk egy sort a segítségével gépírás három lépésben:

1. lépés: Írja be a tuple-t egy listába

2. lépés: Keverje össze a listát

3. lépés: Typecast lista vissza egy sorba

import véletlen
old_tuple = ( 45, 46, 47, 48, 49 )
# Sor nyomtatása
nyomtatás("Régi sor:")
nyomtatás(régi_sor)
# Typecasting tuple listába
lista1 = lista(régi_sor)
# Keverési lista
véletlen.keverés(lista1)
# Typecasting lista vissza a sorba
new_tuple = sor (lista1)
# Új kevert sor nyomtatása
nyomtatás("Új kevert sor:")
nyomtatás(új_sor)
# nyomat
Régi sor:
(45, 46, 47, 48, 49)
Új kevert sor:
(45, 49, 46, 47, 48)

Jegyzet: Mivel a sor véletlenszerűen keveredik, előfordulhat, hogy más kimenetet kap.

15. Hogyan konvertálhatjuk a Tuples listát listák listájára

A listaértelmezés segítségével a sorok listáját listák listájává alakíthatjuk.

lista1 = [ ('A', 'B'), ('C', 'D'), ('E', 'F') ]
nyomtatás("Lista sorból:")
nyomtatás( lista1 )
# Lista értés
eredmény = [ lista(elem) számára elem a listában1 ]
nyomtatás("Lista listákból:")
nyomtatás(eredmény)
# nyomat
Lista sorokból:
[('A', 'B'), ('C', 'D'), ('E', 'F')]
Lista listákból:
[['A', 'B'], ['C', 'D'], ['E', 'F']]

16. Hogyan alakítsuk át a sorok listáját karakterláncok listájára

A lista értés és csatlakozik() metódussal a sorok listáját karakterláncok listájává alakíthatjuk át.

lista1 = [ ('M', 'A', 'K', 'E'), ('U', 'S', 'E'), ('O', 'F') ]
nyomtatás("Lista sorból:")
nyomtatás( lista1 )
# Lista értelmezés a join() metódussal
eredmény = [ ''.join (elem) az elemhez a list1-ben ]
nyomtatás("Lista húrok:")
nyomtatás(eredmény)
# nyomat
Lista sorokból:
[('M', 'A', 'K', 'E'), ('U', 'S', 'E'), ('O', 'F')]
Lista húrok közül:
['MAKE', 'HASZNÁLAT', 'NAK,-NEK']

Összefüggő: A ciklusok használata Pythonban

17. Hogyan lehet megfordítani a Tuple-t

A szeletelési technikával megfordíthatjuk a sort. A folyamat során a sor új másolata jön létre.

old_tuple = ('M', 'A', 'K', 'E', 'U', 'S', 'E', 'O', 'F')
nyomtatás("Régi sor:")
nyomtatás(régi_sor)
# Sor visszafordítása szeletelés segítségével
új_tuple = régi_tuple[::-1]
nyomtatás("Új tuple:")
nyomtatás(új_sor)
# nyomat
Régi sor:
('M', 'A', 'K', 'E', 'U', 'S', 'E', 'O', 'F')
Új tuple:
('F', 'O', 'E', 'S', 'U', 'E', 'K', 'A', 'M')

A Pythonic Way megtanulása

A Python sorszámú műveleteinek használatával minimális kódsorral hajthat végre egy feladatot. Legyen kreatív, és fedezze fel a sorokban rejlő lehetőségeket, hogy Python nyelven tanulja meg a Python nyelvét.