Python Tuple
1、创建空元组
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)) ''' () () <class 'tuple'> '''
2、使用不同的数据类型创建元组
编写一个 Python 程序来创建具有不同数据类型的元组。
#Create a tuple with different data types tuplex = ("tuple", False, 3.2, 1) print(tuplex) ''' ('tuple', False, 3.2, 1) '''
3、创建只有一个元素的元组
#Create a tuple with different data types tuplex = (1) # 后面不加逗号，则不是元组 print(tuplex) tuplex = (1,) print(tuplex) ''' 1 (1,) '''
4、在元组中添加项
【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) '''
5、元组转换为字符串
编写一个 Python 程序以将元组转换为字符串
tup = ('e', 'x', 'e', 'r', 'c', 'i', 's', 'e', 's') str = ''.join(tup) print(str)
【1】join函数
语法： ‘se’.join(seq)
参数说明
【1】se：分隔符，可以为空
【2】seq：要连接的元素序列、字符串、元组、字典
上面的语法即：以se作为分隔符，将seq所有的元素合并成一个新的字符串
【3】返回值：返回一个以分隔符sep连接各个元素后生成的字符串
6、解压缩几个变量中的元组
编写一个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 <module> 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) '''
7、获取元组的项
编写一个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 '''
8、元组重复项的计数
编写一个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 '''
2】count函数
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 '''
10、将列表转换为元组
#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) '''
11、从元组中删除项
编写一个 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') '''
12、对元组进行切片
编写一个 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', ' ')
13、查找元组项的索引
编写一个 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")
15、从元组列表中删除空元组
L = [(), (), ('',), ('a', 'b'), ('a', 'b', 'c'), ('d')] L = [t for t in L if t ]# 如果是空元组，则返回False print(L)
16、将给定的字符串列表转换为元组
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)))
【3】isspace函数
用途：isspace用于判断一个字符串中，是否只包含空格，如果是返回True否则返回False
语法：isspace()
用法：xxx.isspace() 。其中，xxx代表的是一个完整的字符串。
17、计算给定元组的元素总和
编写一个 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)
【4】zip函数
直接实践看用法：
对于我们的两个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))
19、将元组列表转换为字典
#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)
【5】setdefault函数
字典中有一个方法, 如果对于字典中已经有这个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}
20、将给定的正整数元组转换为整数
编写一个 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))
