python元组

python元组

Python 的元组与列表类似，不同之处在于元组的元素不能修改。

列表使用方括号 [ ]，而元组使用小括号 ( )。

1 创建元组

元组的创建很简单，只需要在小括号()中添加元素，并使用逗号隔开即可。

创建元组不使用括号也可以，但是在输出时会自动有()。

元组里的元素不需要类型相同。

注意：元组中只包含一个元素时，需要在元素后面添加逗号，否则括号会被当作运算符使用。

例如：

tup1 = ('Google', 'Runoob', 1997, 2000)
tup2 = (1, 2, 3, 4, 5 )
tup3 = "a", "b", "c", "d"   #  不使用括号创建元组

print(tup1)
print(tup2)
print(tup3)

('Google', 'Runoob', 1997, 2000)
(1, 2, 3, 4, 5)
('a', 'b', 'c', 'd')

创建单个元素的元组。例如：

tup1 = (10)  # 不加逗号，类型为整型
tup2 = (10,)  # 加逗号，类型为元组
print(type(tup1))
print(type(tup2))

tup3 = ("tup3") # 不加逗号，类型为字符串
tup4 = ("tup4", ) # 加逗号，类型为元组
print(type(tup3))
print(type(tup4))

<class 'int'>
<class 'tuple'>
<class 'str'>
<class 'tuple'>

2 访问元组

元组与字符串类似，也有索引，并且下标索引从 0 开始，以-1结束。可以使用下标索引来访问元组中的值。

元组的索引也是有两个方向的，一个方向是从头到尾，索引依次为0、1、2…；另一个方向是从尾到头，索引依次为-1、-2、-3…

利用索引，也可以对元组进行截取，组合等操作。

例如：

1、访问元组中的元素

tup1 = ('Google', 'Runoob', 1997, 2000)
tup2 = (1, 2, 3, 4, 5, 6, 7 )

print(tup1[0])
print(tup2[-1])
print("tup1[1]: ", tup1[1]) 

Google
7
tup1[1]:  Runoob

2、截取元组中的部分元素

元组元素的截取也是左闭右开。

# 截取从第2个元素到最后一个元素（包含最后一个元素）
print(tup2[1:]) 

# 截取从第一个元素到倒数第2个元素（包含倒数第2个元素）
print(tup2[:-1])

# 截取从一个指定索引到另一个指定索引的元素
print("tup2[1:5]: ", tup2[1:5])

(2, 3, 4, 5, 6, 7)
(1, 2, 3, 4, 5, 6)
tup2[1:5]:  (2, 3, 4, 5)

3 修改元组

元组中的元素值是不允许修改的，如果强行修改会报错，但是，元组可以进行拼接组合。

元组的拼接组合，实际上是创建了一个新的元组，是把旧的两个元组拼接在一起后放在了一个新的元组里。

例如：

tup1 = ('Google', 'Runoob', 1997, 2000)
tup2 = (1, 2, 3, 4, 5, 6, 7 )

# 修改元组操作是非法的
#tup1[0] = "a"

元组的拼接组合：

tup3 = tup1 + tup2
print(tup3)

print(tup1*2)

tup4 = tup2[1:-1] + tup1[0:2]
print(tup4)

('Google', 'Runoob', 1997, 2000, 1, 2, 3, 4, 5, 6, 7)
('Google', 'Runoob', 1997, 2000, 'Google', 'Runoob', 1997, 2000)
(2, 3, 4, 5, 6, 'Google', 'Runoob')

4 删除元组

元组中的元素值是不允许删除的，但我们可以使用del语句来删除整个元组。例如：

tup = ("1", "2", "3", "4")
print(tup)
del tup
print(tup)

('1', '2', '3', '4')



---------------------------------------------------------------------------

NameError                                 Traceback (most recent call last)

<ipython-input-68-7a3889278233> in <module>
      2 print(tup)
      3 del tup
----> 4 print(tup)


NameError: name 'tup' is not defined

5 元组运算符

与字符串一样，元组之间可以使用 + 号和 * 号进行运算。这就意味着他们可以组合和复制，运算后会生成一个新的元组。

1、计算元素个数 len

2、连接 +

3、复制 *

4、元素是否在元组中 in/ not in

5、迭代 for

例如：

tup1 =  (1, 2, 3, "a", "b", "c")
tup2 = (0, 0, 0)

print(len(tup1))
print(tup1 + tup2)
print(tup2*3)

print("a在tup1中？", "a" in tup1)
print("a不在tup1中？", "a" not in tup1)

for x in tup1: 
    print (x)

6
(1, 2, 3, 'a', 'b', 'c', 0, 0, 0)
(0, 0, 0, 0, 0, 0, 0, 0, 0)
a在tup1中？ True
a不在tup1中？ False
1
2
3
a
b
c

6 关于元组不可变

元组的不可变指的是元组所指向的内存中的内容不可变。

拼接元组，是重新赋值的元组tup，绑定到新的对象了，不是修改了原来的对象。

无论是使用+拼接得到的元组，还是使用*复制得到的元组，它们的内存地址都是改变了的。

例如：

tup = ("a", "b", "c")
print(id(tup)) # 查看tup的内存地址

tup = tup + tup # 查看修改后的内存地址
print(id(tup))

tup = tup * 2
print(id(tup)) # 查看修改后的内存地址

1770401652288
1770402217600
1770402400000

7 元组内置函数

Python元组包含了以下内置函数：

1、len(tuple)：计算元组元素个数。

2、max(tuple)：返回元组中元素最大值。

3、min(tuple)：返回元组中元素最小值。

4、tuple(iterable)：将可迭代系列转换为元组。

例如：

t = ("a", "b", "c", "d")
list = [1, 2, 3]
print(len(t))
print(max(t))
print(min(t))
print(tuple(list))

4
d
a
(1, 2, 3)