betacode

Руководство Python Tuples

View more Tutorials:

Следуйте за нами на нашей фан-странице, чтобы получать уведомления каждый раз, когда появляются новые статьи. Facebook

1- Python Tuples

В Python, Tuples (кортежи) являются рядом (sequence) значений, содержащие много элементов (element), в основном похоже на List (список). Но в отличии от List, Tuples является неизменяемым видом данных (immutable), все обновления на Tuple создают новый объект в памяти (memory).
Чтобы написать Tuple, вам нужно расположить элементы в скобках ( ) и отделить друг от друга запятой. Элементы в списке индексированы (index) начиная от индекса 0.
tupleExample.py

fruitTuple = ("apple", "apricot", "banana","coconut", "lemen")
otherTuple = (100, "one", "two", 3)
print ("Fruit Tuple:")
print (fruitTuple)
print (" --------------------------- ")
print ("Other Tuple:")
print (otherTuple)
Output:

Fruit Tuple:
('apple', 'apricot', 'banana', 'coconut', 'lemen')
 ---------------------------
Other List:
(100, 'one', 'two', 3)

2- Сравнить List и Tuple

Смотрите так же:
List и Tuple оба являются последовательностью (sequence) элементов. Они имеют следующие отличия:
  • При написании List вы используете квадратные скобки [ ], а при написании Tuple вы используете круглые скобки (  ).

# Это Tuple.
aTuple = ("apple", "apricot", "banana")

# Это List (Список).
aList =  ["apple", "apricot", "banana"]
  • List это изменяемый вид данных (mutable), вы можете использовать такой метод как append() чтобы добавить элемент в List, или использовать метод remove() чтобы удалить элементы из List, не создавая еще один объект 'List' в памяти.
listMemoryTest.py

list1 =  [1990, 1991, 1992] 
print ("list1: ", list1)

# Адрес list1 в памяти.
list1Address = hex ( id(list1) ) 
print ("Address of list1: ", list1Address ) 
print ("\n")
print ("Append element 2001 to list1")

# Соединить (append) элемент list1.
list1.append(2001) 
print ("list1 (After append): ", list1)

# Адрес list1 в памяти.
list1Address = hex ( id(list1) ) 
print ("Address of list1 (After append): ", list1Address )
  • Tuple это неизменямый (immutable) объект, он не имеет методы append(), remove(),.. как list. Некоторые методы или операторы, которые вы думаете использованы для обновленияъ Tuple, на самом деле он основывается на начальном Tuple, чтобы создать новый Tuple.
tupleMemoryTest.py

tuple1 =  (1990, 1991, 1992)

# Адрес tuple1 в памяти.
tuple1Address = hex ( id(tuple1) ) 
print ("Address of tuple1: ", tuple1Address )

# Соединить tuple в tuple1.
tuple1 = tuple1 + (2001, 2002)

# Адрес tuple1 в памяти.
tuple1Address = hex ( id(tuple1) )  
print ("Address of tuple1 (After concat): ", tuple1Address )
Output:

Address of tuple1: 0x9096751d80
Address of tuple1 (After concat): 0x9096778f10

3- Получить доступ к элементам Tuples

Получить доступ к элементам
Использовать цикл for, чтобы получить доступ к элементам Tuple:
elementAccessExample.py

fruits = ("apple", "apricot", "banana", "coconut", "lemen", "plum", "pear")

for fruit in fruits :
    print ("Fruit: ", fruit)
Output:

Fruit: apple
Fruit: apricot
Fruit: banana
Fruit: coconut
Fruit: lemen
Fruit: plum
Fruit: pear
Доступ через индекс (index):
Вы так же можете получить доступ к элементам Tuple через индекс. Элементы Tuple индексированы слева направо, начиная с 0.
indexAccessExample.py

fruits = ("apple", "apricot", "banana", "coconut", "lemen", "plum", "pear") 
print ( fruits )

# Число элементов.
print ("Element count: ", len(fruits) ) 

for i in range (0, len(fruits) ) : 
    print ("Element at ", i, "= ", fruits[i] )
    
# Один дочерний Tuple содержит элементы с индексом от 1 до 4 (1, 2, 3)
subTuple = fruits[1: 4]    
# ('apricot', 'banana', 'coconut')
print ("Sub Tuple [1:4] ", subTuple )
Output:

('apple', 'apricot', 'banana', 'coconut', 'lemen', 'plum', 'pear')
Element count: 7
Element at 0 = apple
Element at 1 = apricot
Element at 2 = banana
Element at 3 = coconut
Element at 4 = lemen
Element at 5 = plum
Element at 6 = pear
Sub Tuple [1:4]  ('apricot', 'banana', 'coconut')
Вы так же можете получить доступ к элементам Tuple по отрицательному индексу (Negative index), элементы индексированы справа налево со значениями  -1, -2, ...
indexAccessExample2.py

fruits = ("apple", "apricot", "banana", "coconut", "lemen", "plum", "pear")
print ( fruits )
print ("Element count: ", len(fruits) )

print ("fruits[-1]: ", fruits[-1])
print ("fruits[-2]: ", fruits[-2]) 
subTuple1 = fruits[-4: ]

print ("\n")
print ("Sub Tuple fruits[-4: ] ")
print (subTuple1) 
subTuple2  = fruits[-4:-2]
print ("\n")
print ("Sub Tuple fruits[-4:-2] ")
print (subTuple2)
Output:

('apple', 'apricot', 'banana', 'coconut', 'lemen', 'plum', 'pear')
Element count: 7
fruitList[-1]:  pear
fruitList[-2]:  plum  
 
Sub Tuple fruits[-4: ]  
('coconut', 'lemen', 'plum', 'pear')

Sub Tuple fruits[-4:-2]  
('coconut', 'lemen')

4- Обновление Tuples

Заметьте что Tuple неизменяемый (immutable), поэтому он только имеет методы или операторы для доступа, или создания нового Tuple из начального Tuple.
updateTupleExample.py

tuple1 = (1990, 1991, 1992) 
print ("tuple1: ", tuple1)  
print ("Concat (2001, 2002) to tuple1") 
 
tuple2 = tuple1 + (2001, 2002)  
print ("tuple2: ", tuple2)

# Дочерний Tuplе, содержит элементы с индексом от 1 до 4 (1,2,3)
tuple3 = tuple2[1:4] 
print ("tuple2[1:4]: ", tuple3)

# Дочерний Tuplе, содержит элементы с индексом от 1 до конца
tuple4 = tuple2[1: ] 
print ("tuple2[1: ]: ", tuple4)
Output:

tuple1: (1990, 1991, 1992)
Concat (2001, 2002) to tuple1
tuple2: (1990, 1991, 1992, 2001, 2002)
tuple2[1:4]: (1991, 1992, 2001)
tuple2[1: ]: (1991, 1992, 2001, 2002)

5- Базовые операторы для Tuples

Как и String, Tuple имеет 3 оператора +, * , in.
Оператор Описание Пример
+ Оператор использующийся для соединения (concatenate) 2 Tuple, чтобы создать новый Tuplе (1, 2, 3) + ("One","Two")
--> (1, 2, 3, "One", "Two")
* Оператор использующийся для соединения многих копий одного Tuple. И создает новый Tuple (1, 2) * 3
--> (1, 2, 1, 2, 1, 2)
in Проверяет находится ли элемент в одном Tuple или нет, результат возвращает True или False. "Abc" in ("One", "Abc")
--> True
tupleOperatorsExample.py

tuple1 = (1, 2, 3)
tuple2 = ("One", "Two")
print ("tuple1: ", tuple1)
print ("tuple2: ", tuple2)
print ("\n")

tuple12 = tuple1 + tuple2
print ("tuple1 + tuple2: ", tuple12)
tuple2x3 = tuple2 * 3
print ("tuple2 * 3: ", tuple2x3)
hasThree = "Three" in tuple2
print ("'Three' in tuple2? ", hasThree)
Output:

tuple1: (1, 2, 3)
tuple2: ('One', 'Two')

tuple1 + tuple2: (1, 2, 3, 'One', 'Two')
list2 * 3: ('One', 'Two', 'One', 'Two', 'One', 'Two')
'Three' in tuple2? False

6- Функции связанные с Tuples

Функция Описание
cmp(list1, list2) Сравнивает элементы 2-х Tuple. Данная функция была удалена из Python3.
len(list) Возвращает количество элементов списка 
max(list) Возвращает элемент с самым большим значением в Tuple.
min(list) Возвращает элемент с самым минимальным значением в Tuple.
tuple(seq) Конвертирует List в Tuple.
tupleFunctionsExample.py

tuple1 = (1991, 1994, 1992)
tuple2 = (1991, 1994, 2000, 1992)
print ("tuple1: ", tuple1)
print ("tuple2: ", tuple2)

# Возвращает количество элементов в списке.
print ("len(tuple1): ", len(tuple1) )
print ("len(tuple2): ", len(tuple2) )

# Самое большое значение в Tuple.
maxValue = max(tuple1)
print ("Max value of tuple1: ", maxValue)

# Самое малое  значение в Tuple
# ​​​​​​​
minValue = min(tuple1)
print ("Min value of tuple1: ", minValue)

# (all)
# List
list3 = [2001, 2005, 2012]
print ("list3: ", list3)

# Конвертирует List в tuple.
tuple3 = tuple (list3)
print ("tuple3: ", tuple3)
Output:

tuple1: (1991, 1994, 1992)
tuple2: (1991, 1994, 2000, 1992)
len(tuple1): 3
len(tuple2): 4
Max value of tuple1: 1994
Min value of tuple1: 1991
list3: [2001, 2005, 2012]
tuple3: (2001, 2005, 2012)
Смотрите так же:
  • TODO Link?

7- Методы

Метод Описание
tuple.count(obj) Возвращает количество раз появления 'obj' в Tuple
tuple.index(obj, [start, [stop]]) Возвращает самый малый индекс в списке, где находится элемент со значением obj. Выбрасывает ValueError если не находит.

Если имеется параметр start, stop, поиск только от индекса start до индекса stop (И не включает stop).
Пример:
tupleMethodsExample.py

years =  ( 1990 ,  1991 ,  1993 ,  1991 ,  1993 ,  1993 ,  1993 )
print ("Years: ", years)
print ("\n") 

# Возвращает количество появления 1993
print ("years.count(1993): ",years.count(1993) ) 

# Находит местоположение появления 1993
print ("years.index(1993): ", years.index(1993) )

# Находит местоположение появления 1993, начиная от индекса 3
print ("years.index(1993, 3): ", years.index(1993, 3) )

# Находит местоположение появления 1993, от индекса 4 до 5 (Не включая 6)
print ("years.index(1993, 4, 6): ", years.index(1993, 4, 6) )
Output:

Years: (1990, 1991, 1993, 1991, 1993, 1993, 1993)

years.count(1993): 4
years.index(1993): 2
years.index(1993, 3): 4
years.index(1993, 4, 6): 4
Смотрите так же:
  • TODO Link?

View more Tutorials:

Maybe you are interested

Это онлайн курс вне вебсайта o7planning, который мы представляем, он включает бесплатные курсы или курсы со скидкой.