Python的元组与列表类似，不同之处在于元组的元素不能修改
【1】元组使用小括号，列表使用方括号
【2】元组创建很简单，只需要在括号中添加元素，并使用逗号隔开即可
【3】元组(tuple): 不可变数据类型
【4】元组内可以存储任意数据类型
【5】如果只创建一个元素的元组，那么这个元素后面必须要加逗号才行
编写一个 Python 程序来创建元组。
#Create an empty tuple
x = ()
print(x)
#Create an empty tuple with tuple() function built-in Python
tuplex = tuple()
print(tuplex)
print(type(tuplex))
'''
()
()
'''
编写一个 Python 程序来创建具有不同数据类型的元组。
#Create a tuple with different data types
tuplex = ("tuple", False, 3.2, 1)
print(tuplex)
'''
('tuple', False, 3.2, 1)
'''
#Create a tuple with different data types
tuplex = (1) # 后面不加逗号，则不是元组
print(tuplex)
tuplex = (1,)
print(tuplex)
'''
1
(1,)
'''
【1】元组是不可变的，因此不能在元组当中添加新元素
【2】可以使用+来添加新元素，但是这样会新建一个元组
tuplex = (4, 6, 2, 8, 3, 1)
print(tuplex)
#元组是不可变的，因此不能在元组当中添加新元素
#可以使用+来添加新元素，但是这样会新建一个元组
tuplex = tuplex + (9,)
print(tuplex)
'''
(4, 6, 2, 8, 3, 1)
(4, 6, 2, 8, 3, 1, 9)
'''
#在特殊位置插入元素
print(tuplex)
tuplex = tuplex[:5] + (15, 20, 25) + tuplex[:5]
print(tuplex)
'''
(4, 6, 2, 8, 3, 1, 9)
(4, 6, 2, 8, 3, 15, 20, 25, 4, 6, 2, 8, 3)
'''
#将元组变成列表
listx = list(tuplex)
print(listx)
#在列表里面添加元素
listx.append(31)
#将列表转换为元组
tuplex = tuple(listx)
print(tuplex)
'''
[4, 6, 2, 8, 3, 15, 20, 25, 4, 6, 2, 8, 3]
(4, 6, 2, 8, 3, 15, 20, 25, 4, 6, 2, 8, 3, 31)
'''
编写一个 Python 程序以将元组转换为字符串
tup = ('e', 'x', 'e', 'r', 'c', 'i', 's', 'e', 's')
str = ''.join(tup)
print(str)
语法： ‘se’.join(seq)
参数说明
【1】se：分隔符，可以为空
【2】seq：要连接的元素序列、字符串、元组、字典
上面的语法即：以se作为分隔符，将seq所有的元素合并成一个新的字符串
【3】返回值：返回一个以分隔符sep连接各个元素后生成的字符串
编写一个Python程序来解压缩几个变量中的元组。
#create a tuple
tuplex = 4, 8, 3
print(tuplex)
n1, n2, n3 = tuplex
#表示将元组里面的每个元素分别赋值给n1,n2,n3
#但是如果变量与元组里面的元素个数不对应的话，会报错
print(n1)
print(n2)
print(n3)
print(n1 + n2 + n3)
'''
(4, 8, 3)
4
8
3
15
'''
【1】n1, n2, n3 = tuplex
表示将元组里面的每个元素分别赋值给n1,n2,n3
但是如果变量与元组里面的元素个数不对应的话，会报错
tuplex = 4, 8, 3
print(tuplex)
n1, n2, = tuplex
print(n1)
print(n2)
'''
(4, 8, 3)
---------------------------------------------------------------------------
ValueError Traceback (most recent call last)
~\AppData\Local\Temp/ipykernel_58052/1820726987.py in
1 tuplex = 4, 8, 3
2 print(tuplex)
----> 3 n1, n2, = tuplex
4 print(n1)
5 print(n2)
ValueError: too many values to unpack (expected 2)
'''
编写一个Python程序，从元组的最后一个元素中获取第4个元素和第4个元素。
tuplex = ("w", 3, "r", "e", "s", "o", "u", "r", "c", "e")
print(tuplex)
#去从头开始数第4个元素：
item = tuplex[3]
print(item)
#去从结尾开始数第4个元素
item1 = tuplex[-4]
print(item1)
'''
('w', 3, 'r', 'e', 's', 'o', 'u', 'r', 'c', 'e')
e
u
'''
编写一个Python程序来查找元组的重复项。
tuplex = 2, 4, 5, 6, 2, 3, 4, 4, 7
print(tuplex)
#return the number of times it appears in the tuple.
count = tuplex.count(4) # 这里的4是int类型的,表示计算4出现的次数
print(count)
'''
(2, 4, 5, 6, 2, 3, 4, 4, 7)
3
'''
Python count()方法
描述
Python count() 方法用于统计字符串里某个字符出现的次数。可选参数为在字符串搜索的开始与结束位置。
count()方法语法：
str.count(sub, start=0,end=len(string))
参数
sub – 搜索的子字符串
start – 字符串开始搜索的位置。默认为第一个字符,第一个字符索引值为0。
end – 字符串中结束搜索的位置。字符中第一个字符的索引为 0。默认为字符串的最后一个位置。
返回值：该方法返回子字符串在字符串中出现的次数。
9、检查元组中是否存在元素tuplex = ("w", 3, "r", "e", "s", "o", "u", "r", "c", "e")
print("r" in tuplex)
print(5 in tuplex)
'''
True
False
'''
#Convert list to tuple
listx = [5, 10, 7, 4, 15, 3]
print(listx)
tuplex = tuple(listx) #将列表转换成元组
print(tuplex)
'''
[5, 10, 7, 4, 15, 3]
(5, 10, 7, 4, 15, 3)
'''
编写一个 Python 程序以从元组中删除项。
由于元组本身是不可变的，因此不能直接删除元组当中的元素：
可以使用两个方法对元组当中的元素进行删除：
1、通过切片方式构造新的元组
#create a tuple
tuplex1 = "w", 3, "r", "s", "o", "u", "r", "c", "e"
print(tuplex1)
tuplex1= tuplex1[:2] + tuplex1[3:]
print(tuplex1)
'''
('w', 3, 'r', 's', 'o', 'u', 'r', 'c', 'e')
('w', 3, 's', 'o', 'u', 'r', 'c', 'e')
'''
2、将元组转换成列表，对列表中的元素进行删除之后，再转换成元组
t1= "w", 3, "r", "s", "o", "u", "r", "c", "e"
print(t1)
t=list(t1)
t.remove("c")
tuplex = tuple(t)
print(tuplex)
'''
('w', 3, 'r', 's', 'o', 'u', 'r', 'c', 'e')
('w', 3, 'r', 's', 'o', 'u', 'r', 'e')
'''
编写一个 Python 程序来对元组进行切片。
#创建一个元组
tuplex = (2, 4, 3, 5, 4, 6, 7, 8, 6, 1)
#used tuple[start:stop] the start index is inclusive and the stop index
_slice = tuplex[3:5]
#is exclusive
print(_slice) # (5, 4)
#if the start index isn't defined, is taken from the beg inning of the tuple
_slice = tuplex[:6]
print(_slice) # (2, 4, 3, 5, 4, 6)
#if the end index isn't defined, is taken until the end of the tuple
_slice = tuplex[5:]
print(_slice) # (6, 7, 8, 6, 1)
#if neither is defined, returns the full tuple
_slice = tuplex[:]
print(_slice) # (2, 4, 3, 5, 4, 6, 7, 8, 6, 1)
#The indexes can be defined with negative values
_slice = tuplex[-8:-4]
print(_slice) # (3, 5, 4, 6)
#create another tuple
tuplex = tuple("HELLO WORLD")
print(tuplex) # ('H', 'E', 'L', 'L', 'O', ' ', 'W', 'O', 'R', 'L', 'D')
#step specify an increment between the elements to cut of the tuple
#tuple[start:stop:step]
_slice = tuplex[2:9:2]
print(_slice)# ('L', 'O', 'W', 'R')
#returns a tuple with a jump every 3 items
_slice = tuplex[::4]
print(_slice) # ('H', 'O', 'R')
#when step is negative the jump is made back
_slice = tuplex[9:2:-4]
print(_slice) # ('L', ' ')
编写一个 Python 程序来查找元组项的索引。
#create a tuple
tuplex = tuple("index tuple")
print(tuplex)
#('i', 'n', 'd', 'e', 'x', ' ', 't', 'u', 'p', 'l', 'e')
index = tuplex.index("p")
print(index) # 8
#define the index from which you want to search
index = tuplex.index("p", 5)
print(index) # 8
#define the segment of the tuple to be searched
index = tuplex.index("e", 3, 6)
print(index) # 3
#if item not exists in the tuple return ValueError Exception
index = tuplex.index("y")
L = [(), (), ('',), ('a', 'b'), ('a', 'b', 'c'), ('d')]
L = [t for t in L if t ]# 如果是空元组，则返回False
print(L)
def string_list_to_tuple(str1):
result = tuple(x for x in str1 if not x.isspace())
# 如果x不是空格就加到result元素当中
return result
str1 = "python 3.0"
print("Original string:")
print(str1)
print(type(str1))
print("\nConvert the said string to a tuple:")
print(string_list_to_tuple(str1))
print(type(string_list_to_tuple(str1)))
用途：isspace用于判断一个字符串中，是否只包含空格，如果是返回True否则返回False
语法：isspace()
用法：xxx.isspace() 。其中，xxx代表的是一个完整的字符串。
编写一个 Python 程序来计算给定元组的元素总和。
原始列表：
（1， 2， 3， 4）
（3， 5， 2， 1）
（2， 2， 3， 1）
所述元组的元素总和：
（6， 9， 8， 6）
x = (1,2,3,4)
y = (3,5,2,1)
z = (2,2,3,1)
print("Original lists:")
print(x)
print(y)
print(z)
print("\nElement-wise sum of the said tuples:")
result = tuple(map(sum, zip(x, y, z)))
print(result)
直接实践看用法：
对于我们的两个list，a和b，list(zip(a, b))生成了一个列表。在这个列表中，每个元素是一个tuple；对于第i个元组，它其中的内容是(a[i-1], b[i-1])。这样的 *** 作，与压缩软件的“压缩”十分接近。如果我们继续在zip()中加入更多的参数，比如zip(a, b, c, d)，那么在将它转换成list之后，结果当然就是[(a[0], b[0], c[0], d[0]), (a[1], b[1], c[1], d[1]), …, (a[n-1], b[n-1], c[n-1], d[n-1])]。
事实上，在 Python 3 中，为了节省空间，zip()返回的是一个tuple的迭代器，这也是我们为什么要调用list()将它强制转换成list的原因。不过，Python 2中，它直接返回的就是一个列表了。
18、查找元组的长度#create a tuple
tuplex = tuple("w3resource")
print(tuplex)
#use the len() function to known the length of tuple
print(len(tuplex))
#create a list
l = [("x", 1), ("x", 2), ("x", 3), ("y", 1), ("y", 2), ("z", 1)]
d = {}
for a, b in l:
d.setdefault(a, []).append(b)
print (d)
字典中有一个方法, 如果对于字典中已经有这个key , 直接 return 这个 key 对对应的值,
如果没有 key,会加入这个key。
setdefault(key[, default]) 可以指定一个默认值, 如果没有指定, 则认为是None 返回, 如果指定了default 则直接返回default值
如果有这个key,直接返回字典中对应的key 的值 ,即使设置了default ,也不会返回default, 而是返回 key 对应的value值。
#定义一个空字典
dict = {}
print(dict.setdefault('name','Bill'))
#向字典中添加一个名为name的key，默认值是Bill，输出结果：Bill
print(dict)
#输出结果：{'name': 'Bill'}
print(dict.setdefault('name','Mike'))
#并没有改变name的值，输出结果：Bill
print(dict)
#输出结果：{'name': 'Bill'}
#向字典中添加一个名为age的key，默认值是None，输出结果：None
print(dict.setdefault('age'))
print(dict)
#输出结果：{'name': 'Bill', 'age': None}
编写一个 Python 程序，将给定的正整数元组转换为整数。
原始元组：
（1， 2， 3）
将所述正整数元组转换为整数：
123
原始元组：
（10， 20， 40， 5， 70）
将所述正整数元组转换为整数：
102040570
def tuple_to_int(nums):
result = int(''.join(map(str,nums)))
return result
nums = (1,2,3)
print("Original tuple: ")
print(nums)
print("Convert the said tuple of positive integers into an integer:")
print(tuple_to_int(nums))
欢迎分享，转载请注明来源：内存溢出
微信扫一扫
支付宝扫一扫
评论列表（0条）