元组定义
元组写在小括号()里，成员之间用逗号隔开。
元组可以用多种方式构建:
使用一对括号表示空元组: ()
使用括号，用逗号分隔项目: (), (a, b, c)
使用类型构造函数: tuple() 或 tuple(iterable)
例如：
1
2
3
4
5
6
7
8
9
10
|
t1 = (1,2,3,4) # 元组t1有四个成员，分别是数字1，数字2，数字3和数字4
t2 = () # 元组t2是空元组。
a = "hello"
t3 = tuple() # 构造函数生成空元组
t4 = tuple(a) # 根据字符串，转换成元组
print(t1)
print(t2)
print(t3)
print(t4)
|
执行以上程序会输出如下结果：
1
2
3
4
|
(1, 2, 3, 4)
()
()
('h', 'e', 'l', 'l', 'o')
|
其中，用逗号分割的元组，最后一个逗号是可选的。
(1,2,3,4)和(1,2,3,4,)都是合法的元组。
如果元组仅仅有一个成员时，写法有点特殊，必须在成员后面加上逗号。因为如果没有逗号的话，python解释器就不知道这个一个函数调用还是一个元组。
元组的成员的类型可以不相同，它支持数字，字符串甚至可以包含列表。
例如：
1
2
3
4
5
6
7
8
9
10
|
t1 = (1,2,'ab',4) # t1有四个成员，分别是数字1，数字2，字符串'ab'和数字4
t2 = (1,) # t2是仅有一个成员的元组。
t3 = (1) # t3只是一个数字1，int类型。
print(t1)
print(t2)
print(t3)
print(type(t1))
print(type(t2))
print(type(t3))
|
执行以上程序会输出如下结果：
1
2
3
4
5
6
|
(1, 2, 'ab', 4)
(1,)
1
<class 'tuple'>
<class 'tuple'>
<class 'int'>
|
索引操作
按照索引访问元组,格式如下。
元组[i]
i是索引值。i是正数，从左向右计算，第一个是0，第二个是1，依次类推。i是负数，从右向左计算，第一个是-1，第二个是-2，依次类推。
例如：
1
2
3
4
5
6
7
|
t1 = (1,2,'ab',4)
a = t1[0] # i是正数，从左向右计算，0表示是第一个。
b = t1[-1] # i是负数，从右向左计算。-1表示第一个。
c = t1[2]
print(a)
print(b)
print(c)
|
执行以上程序会输出如下结果：
切片操作
和字符串一样，元组同样支持切片。元组被截取后返回一个包含所需成员的新元组。
切片操作格式如下：
元组[start:end]
start，end都是整数。索引值以 0 为开始值，如果是负数，则从尾部开始。-1为最末尾。
省略start，默认从0开始。
省略end，则获取剩余所有。
同时省略start和end，则复制当前的列表。
例如：
1
2
3
4
5
6
7
|
t1 = (1,2,'ab',4, 5)
print(t1) # 打印t1元组
print(t1[0:3])
print(t1[3:])
print(t1[2:4])
print(t1[:4])
print(t1[:])
|
执行以上程序会输出如下结果：
1
2
3
4
5
6
|
(1, 2, 'ab', 4, 5)
(1, 2, 'ab')
(4, 5)
('ab', 4)
(1, 2, 'ab', 4)
(1, 2, 'ab', 4, 5)
|
元组与列表类似，不同之处在于元组的成员不能修改，所以没有append()，insert()这样的方法。
例如：
1
2
|
t1 = (1,2,'ab',4)
t1.append(5) #
|
执行以上程序会输出如下结果：
1
2
3
4
|
Traceback (most recent call last):
File "main.py", line 4, in <module>
t1.append(5)
AttributeError: 'tuple' object has no attribute 'append'
|
虽然tuple的成员不可改变，但它可以包含可变的对象，比如list列表。被包含的可变对象的成员可以改变。
例如：
1
2
3
4
5
|
t1 = (1,2,['a','b']) # 第三个成员是列表['a','b'],列表是可变对象
print(t1)
print(t1[2]) # (1, 2, ['a', 'b'])
t1[2][0] = 'c' # 改变['a','b']第一项的值,'a'变为'c'
print(t1) # (1, 2, ['c', 'b'])
|
执行以上程序会输出如下结果：
1
2
3
|
(1, 2, ['a', 'b'])
['a', 'b']
(1, 2, ['c', 'b'])
|
只有一个成员的元组，要在后面加上逗号，要不然python解释器不能将其识别为元组。
例如：
1
2
3
4
|
t1 = (1, ) # 元组t1有一个成员数字1
t2 = (1) # t2不是元组，int类型数字1
print(type(t1)) # <class 'tuple'>
print(type(t2)) # <class 'int'>
|
元组的括号并不是必须的，也可以省略括号。实际上是逗号构成了一个元组，而不是括号。
例如：
1
2
3
4
5
6
7
8
|
t1 = ('a','b','c')
t2 = 'a','b','c' # t2也是元组，相当于('a','b','c')
t3 = (1,)
t4 = 1, # t4也是只有一个成员的元组，省略了括号而已
print(type(t1))
print(type(t2))
print(type(t3))
print(type(t4))
|
执行以上程序会输出如下结果：
1
2
3
4
|
<class 'tuple'>
<class 'tuple'>
<class 'tuple'>
<class 'tuple'>
|
其他获取成员的方法和list是一样的。
例如：
1
2
3
4
5
6
7
8
|
t = ('a','b','c','d','e')
print(t) # 打印元组t
t1 = t[1] # 第二个成员，字符'b'
t2 = t[1:3] # 第二，第三个成员 ('b','c')
t3 = t[:3] # 第一，第二，第三个成员 ('a'，'b','c')
t4 = t[0:-2] # 第一，第二，第三个成员 ('a'，'b','c')
t5 = t[1:] # 第二个成员以后('b','c','d','e')
t6 = t[1:4:2] # 第2-5成员，并且步长为2 ('b','d')
|
元组连接，复制
连接运算符 + 将两个元组连接为一个元组,生成一个新元组。
1
2
3
4
|
t1 = ('a','b')
t2 = ('c','d')
t =t1 + t2
print(t) #元组t，('a','b','c','d')
|
重复操作运算符 *。星号后面的数字是重复的次数。数字必须是正整数。
1
2
|
t1 = ('a','b')
t = t1*2 #重复2次t1，('a','b','a','b')
|
元组常用的方法
tuple.count(x)
返回元素 x 在元组中出现的次数。
例如：
1
2
3
4
|
t = ('a','b','c','d','c')
print(t.count('a')) # 1
print(t.count('c')) # 2
print(t.count('e')) # 0
|
转载请注明本网址。