Руководство Python Tuples
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): 0x9096778f103. Получить доступ к элементам 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? False6. Функции связанные с 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)Смотрите так же:
- Comparing and Sorting in Python
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Смотрите так же:
- Comparing and Sorting in Python
Pуководства Python
- Введение в Python
- Установить Python в Windows
- Установите Python в Ubuntu
- Установите PyDev для Eclipse
- Соглашения и версии грамматики в Python
- Руководство Python для начинающих
- Документация по поиску Python
- Ветвление операторы в Python
- Петли в Python
- Руководство Python Function
- Класс и объект в Python
- Наследование и полиморфизм в Python
- Руководство по исключению Python
- Руководство Python String
- Руководство Python Lists
- Руководство Python Tuples
- Руководство Python Dictionary
- Руководство Python Date Time
- Подключиться к базе данных MySQL на Python с помощью PyMySQL
Show More