python包含多个元组的元组_Python数据结构(元组,列表,字典)

Python内置了几种数据结构,元组,列表字典

1.元组

元组可以由不同的元素组成,所有元素通过圆括号( )包含起来,并通过逗号","隔开.如变量名 = (元素1,元素2,...),如果a =1,3,56,'abc','aoe',也默认a是元组

每个元素也可以是不同的数据类型,字符串,数字,元组,列表,字典

元组的元素不能修改,也不能删除,可以将元组整个删除,使用del 元组,如删除元组tuple使用del tuple

当元组只有一个元素时,第一个元素后面跟上逗号"," .如,tuple只有一个元素50时 ,tuple = (50,)

元组的元素以索引编号,从0开始

读取单个元素使用元组[m]的方式,m是索引编号,倒数第一个元素元组[-1]

读取多个元素使用"元组[m:n]"的方式,m和n就是索引的序号,代表读取元组从m到n的元素,但不包括n这个元素.例如:元组[1,-1]指索引从1开始到索引为-1但不包含-1的元素.

步长打印元组[m:n:k],以间隔逗号个数为k读取元组中索引从m到n但不包含n的元素tuple = (1,2,3,4,5,6,7) print(tuple[1:6:2]) 结果:[2,4,6] k=2即间隔两个逗号

读取元组中的列表中的单个元素,使用"元组[m][n]的方式,m是元组中列表的索引,n是列表中元素的索引编号.例如:元组[2][-2]指元组中索引为2的列表中倒数第2个元素.

读取元组中列表或元组中的多个元素,使用"元组[x][m:n]"的方式,x是元组中列表/元组的索引,m:n即列表/元组中从索引为m到n但不包含n的元素.

元组的合并:tuple = tuple1+tuple2

读取结果:看最终取自哪里,是单个还是多个元素,如果单个元素,那么读取结果是该元素(可以是字符串,数字,元组,列表,字典),如果是多个元素,那么若多个元素最终取自列表,读取结果是多个元素组成的列表,若多个元素最终取自元组,那么读取结果是多个元素组成的元组

实例代码如下:

1 a = 1,3,56,'abc','aoe'

2 print(type(a))3 print(a)4 m = 1,5 n = 1

6 print(type(m))7 print(m)8 print(type(n))9 print(m*3)10 print(m)11 #运行结果

13 (1, 3, 56, 'abc', 'aoe')14

15 (1,)16

17 (1, 1, 1)18 (1,)

1 变量名 =(元素1,元素2,...)2 tuple = (1,2,3,[4,5,6,7,8,9],{"A":"abc","B":"789","C":"NBA"},(11,22,'monkey','pig'))3 print(tuple[3])4 print(tuple[3][-1])5 print(tuple[3][1:5])6 print(tuple[4])7 print(tuple[4]["C"])8 print(tuple[5])9 print(tuple[5][1:4])10 #运行结果如下

11 [4, 5, 6, 7, 8, 9]12 9

13 [5, 6, 7, 8]14 {'A': 'abc', 'B': '789', 'C': 'NBA'}15 NBA16 (11, 22, 'monkey', 'pig')17 (22, 'monkey', 'pig')

1 tuple1 = (12, 34.56)2 tuple2 = ('abc', 'xyz')3 tuple3 = tuple1+tuple24 print(tuple3)5 #运行结果

6 (12, 34.56, 'abc', 'xyz')

元组常用的方法/函数:

①排序sorted(tuple):不支持字符串,元组元素不能修改,删除.使用sorted()排序后,得到的是一个列表,但是元组本身并没有因此变化

②最大值max(tuple)

③最小值min(tuple)

④长度len(tuple)

⑤重复tuple*n

1 tuple = (12, 34.56,13,5)2 list =sorted(tuple)3 print(type(tuple))4 print(tuple)5 print(type(list))6 print(list)7 print(len(tuple))8 print(max(tuple))9 print(min(tuple))10 #运行结果

12 (12, 34.56, 13, 5)13

14 [5, 12, 13, 34.56]15 4

16 34.56

17 5

1 a =(1,3,56,'abc','aoe')2 print(a)3 print(a*3)4 print(a)5 #运行结果

6 (1, 3, 56, 'abc', 'aoe')7 (1, 3, 56, 'abc', 'aoe', 1, 3, 56, 'abc', 'aoe', 1, 3, 56, 'abc', 'aoe')8 (1, 3, 56, 'abc', 'aoe')

1 #python数据类型之元组练习

2 L1 = (1,2,3,'A','B','C')3 L2 = (1,2,3,4,5,6)4 L3 = ('A',)#元组只有一个元素时需要加逗号","

5 L4 = 'A','B','C','D','E'

6 print(L1[1])#打印元组L1中索引为1的元素

7 print(L1[2:5])#打印(截取)元组L1中索引从2到5,但不包含索引为5的元素

8 print(L1[2:])#打印(截取)元组L1中索引从2开始到结束的元素

9 print(L1[:5])#打印(截取)元组L1中索引从0开始到5,但不包含索引为5的元素

10 print(L1[-3])#打印元组L1中倒数第三个元素

11 print(L1[:-3])#打印元组L1中索引从0开始到倒数第3(不含倒数第3)的元素

12 print(L1)#打印元组L1

13 print(L1[0:])#打印元组L1

14 print(L1[:])#打印元组L1

15 print(L1[:6])#打印元组L1

16 print(L1+L2)#元组的组合

17 L5 = L1+L2#元组的拼接

18 print(L5)19 print(L4)20 print(L1*3)#元组的重复

21 print(len(L2))#打印元组L2的长度

22 del L2#元组的元素不可以修改,也不可以删除,可以将整个元组删除

23 #运行结果

24 2

25 (3, 'A', 'B')26 (3, 'A', 'B', 'C')27 (1, 2, 3, 'A', 'B')28 A29 (1, 2, 3)30 (1, 2, 3, 'A', 'B', 'C')31 (1, 2, 3, 'A', 'B', 'C')32 (1, 2, 3, 'A', 'B', 'C')33 (1, 2, 3, 'A', 'B', 'C')34 (1, 2, 3, 'A', 'B', 'C', 1, 2, 3, 4, 5, 6)35 (1, 2, 3, 'A', 'B', 'C', 1, 2, 3, 4, 5, 6)36 ('A', 'B', 'C', 'D', 'E')37 (1, 2, 3, 'A', 'B', 'C', 1, 2, 3, 'A', 'B', 'C', 1, 2, 3, 'A', 'B', 'C')38 6

2.列表

列表和元组很相似,主要差别在于列表的元素可以增加,修改和删除,而元组是不行滴!

列表的元素由[ ]括起来,元素间用逗号","隔开.

列表中的元素可以是数字,字符串,列表,元组,列表,字典

列表的每个元素也可以是不同的数据类型,字符串,数字,元组,列表,字典

列表的元素以索引编号,从0开始

读取单个列使用"列表[m]"的方式,m是索引编号,倒数第一个元素"列表[-1]"

读取多个元素使用"列表[m:n]"的方式,m和n就是索引的序号,代表读取列表从m到n的元素,但不包括n这个元素.例如:列表[1,-1]指索引从1开始到索引为-1但不包含-1的元素.

步长打印列表[m:n:k],以间隔逗号个数为k读取列表中索引从m到n但不包含n的元素list = [1,2,3,4,5,6,7] print(list[1:6:2]) 结果:[2,4,6] k=2即间隔两个逗号

读取列表中的元组或列表中的单个元素,使用"列表[m][n]的方式,m是列表中列表/元组的索引,n是列表/元组中元素的索引编号.例如:列表[2][-2]指列表中索引为2的列表/元组中倒数第2个元素.

读取列表中中列表或元组中的多个元素.使用"列表[x][m:n]"的方式,x是列表中列表/元组的索引,m:n即列表/元组中从索引为m到n但不包含n的元素.

列表的合并:list1 = list1+list2(列表可以修改) ,或者list1.extend(list2)

1 变量名 =(元素1,元素2,...)2 list = [1,2,3,[4,5,6,7,8,9],{"A":"abc","B":"789","C":"NBA"},(11,22,'monkey','pig')]3 print(list[3])4 print(list[3][-1])5 print(list[3][1:5])6 print(list[4])7 print(list[4]["C"])8 print(list[5])9 print(list[5][1:4])10 #运行结果

11 [4, 5, 6, 7, 8, 9]12 9

13 [5, 6, 7, 8]14 {'A': 'abc', 'B': '789', 'C': 'NBA'}15 NBA16 (11, 22, 'monkey', 'pig')17 (22, 'monkey', 'pig')

列表常用方法/函数

1.增删改的相关语法:

①增加元素list.append(元素) :调用列表的添加方法加入元素,并将元素添加到列表最后.其中增加的元素可以是任何数据类型

②插入元素list.insert(索引位置,元素):调用列表的插入方法加入元素到指定的索引位置,之后的元素索引位置依次向后瞬移

③移除元素list.remove(元素):调用列表的移除方法删除元素,之后的元素索引位置依次向前瞬移

④修改元素list[n]=元素将列表中索引为n的元素赋值新元素

⑤删除元素del list[n] 删除列表中的元素.删除整个列表:del list

⑥列表的合并:

1.list1.extend(list2) 将list2中的元素扩展到list1中,并将list2的元素放到list1元素的后面

2.list1 = list1+list2 直接通过列表相加的方法并重新赋值到列表1中

实例代码如下:

1 a = [1,2,3,'a','abc','dnf']2 a.append(235)3 print(a)4 a.remove(235)5 print(a)6 a.insert(2,4)7 print(a)8 a.insert(6,'xyz')9 print(a)10 a.insert(8,'888')11 print(a)12 a[-1] = '999'

13 print(a)14 print(a[3:7])15 print(a[0:-1])16 #运行结果:

17 [1, 2, 3, 'a', 'abc', 'dnf', 235]18 [1, 2, 3, 'a', 'abc', 'dnf']19 [1, 2, 4, 3, 'a', 'abc', 'dnf']20 [1, 2, 4, 3, 'a', 'abc', 'xyz', 'dnf']21 [1, 2, 4, 3, 'a', 'abc', 'xyz', 'dnf', '888']22 [1, 2, 4, 3, 'a', 'abc', 'xyz', 'dnf', '999']23 [3, 'a', 'abc', 'xyz']24 [1, 2, 4, 3, 'a', 'abc', 'xyz', 'dnf']

1 1 a = [1,2,3,('a','b','c')]2 2 b = [4,5,6,['x','y','z']]3 3 c = [444,555,666,(7,8,9)]4 4a.extend(b)5 5 print(a)6 6 c = b+c7 7 print(c)8 8

9 9 #运行结果

10 10 [1, 2, 3, ('a', 'b', 'c'), 4, 5, 6, ['x', 'y', 'z']]11 11 [4, 5, 6, ['x', 'y', 'z'], 444, 555, 666, (7, 8, 9)]

1#python数据类型之列表练习

2 L1 = [1,2,3,'A','B','C']3 L2 = [1,2,3,4,5,6]4 print(L1[1])#打印列表L1中索引为1的元素

5 print(L1[2:5])#打印(截取)列表L1中索引从2到5,但不包含索引为5的元素

6 print(L1[2:])#打印(截取)列表L1中索引从2开始到结束的元素

7 print(L1[:5])#打印(截取)列表L1中索引从0开始到5,但不包含索引为5的元素

8 print(L1[-3])#打印列表L1中倒数第三个元素

9 print(L1[:-3])#打印列表L1中索引从0开始到倒数第3(不含倒数第3)的元素

10 print(L1)#打印列表L1

11 print(L1[0:])#打印列表L1

12 print(L1[:])#打印列表L1

13 print(L1[:6])#打印列表L1

14 print(L1+L2)#列表的组合

15 print(L1*3)#列表的重复

16 print(len(L2))#打印列表的长度

17 L2[0] = 'AOE'#列表的值可以修改,将所索引为0的元素更改为'AOE'

18 del L2[5]#列表的元素可以删除,将索引为5的元素删除

19 print(L2)20 #运行结果

21 2

22 [3, 'A', 'B']23 [3, 'A', 'B', 'C']24 [1, 2, 3, 'A', 'B']25 A26 [1, 2, 3]27 [1, 2, 3, 'A', 'B', 'C']28 [1, 2, 3, 'A', 'B', 'C']29 [1, 2, 3, 'A', 'B', 'C']30 [1, 2, 3, 'A', 'B', 'C']31 [1, 2, 3, 'A', 'B', 'C', 1, 2, 3, 4, 5, 6]32 [1, 2, 3, 'A', 'B', 'C', 1, 2, 3, 'A', 'B', 'C', 1, 2, 3, 'A', 'B', 'C']33 6

34 ['AOE', 2, 3, 4, 5]

3.字典

字典由一系列"键":"值"组成,每一组可以理解为一个元素,并通过{ }包含起来,创建字典语法格式:dictionary = {键1:值1,键2:值2,键3:值3,.......}

字典中的键是唯一的，如果重复最后的一个键值对会替换前面的，值不需要唯一,值可以取任何数据类型。

键必须不可变，所以可以用数字，字符串或元组充当，所以用列表就不行,因为列表是可变的嘛!

字典内的元素没有顺序,所以不能通过下标引用,必须通过键来访问

访问单个元素:字典["key"]

访问全部元素:字典

访问字典中没有的键会输出错误

字典的拼接:dict1.update(dict2),将字典dict2合并到字典dict1之中,如果dict2中存在与dict1中相同的键,那么该键会被替换成dict2的值.

1 m = {"a":1,"b":2,"c":3,"d":"nba"}2 print(m["a"])3 print(m["d"])4 #运行结果

5 1

6 nba

字典的增删改:

字典的增加和修改的语法一样,都是通过给某个键进行对应的赋值,当键对应的值存在时将原值替换为新的赋值,当键不存在时创建一个新的键值对.

1 n = {"a":1,"b":2}2 n["c"] = 3

3 n["a"] = 'x'

4 print(n)5 #运行结果

6 {'a': 'x', 'b': 2, 'c': 3}

字典的拼接:dict1.update(dict2),将字典dict2合并到字典dict1之中,如果dict2中存在与dict1中相同的键,那么该键会被替换成dict2的值.

与列表的合并区别在于,列表可以合并重复的数据并且不会被替代,而字典中如果有重复的键,就会被新的键对应的值所取代

1 #dictionary = {键1:值1,键2:值2,键3:值3,.......}

2 m = {"a":1,"b":2,"c":3,"d":"nba"}3 m["x"] = 2019

4 m['y'] = 'abc'

5 print(m["x"])6 print(m["y"])7 m["a"] = 123

8 m["b"] = "HK666"

9 print(m)10 n = {"a":1,"b":2}11 y = {"c":3,"d":"nba"}12 n.update(y)13 print(n)14 z = {"a":1,"b":2}15 del(z["a"])16 print(z)17 x = {"a":1,"b":2}18 y = {"a":1,"b":2}19 x.update(y)20 print(x)21 #运行结果:

22 2019

23 abc24 {'a': 123, 'b': 'HK666', 'c': 3, 'd': 'nba', 'x': 2019, 'y': 'abc'}25 {'a': 1, 'b': 2, 'c': 3, 'd': 'nba'}26 {'b': 2}27 {'a': 1, 'b': 2}

字典常用的方法/函数

①取出所有的键dict.keys()

②取出所有的值dict.values()

③取出所有的键值对dict.items()

④清空字典dict.clear()

⑤删除:只能删除单个键值或者整个字典

删除单个键值 del dict['key1']

删除整个字典del dict

1 dict_aoe = {'key1':'value1','key2':'value2','key3':'value3','key4':'value4'}2 print(dict_aoe)3 print(dict_aoe.keys())4 print(dict_aoe.values())5 print(dict_aoe.clear())6 print(dict_aoe)7 dict1 = {'key1':'value1','key2':'value2','key3':'value3','key4':'value4'}8 del dict1['key1']9 print(dict1)10 deldict111 print(dict1)12 #运行结果

13 {'key1': 'value1', 'key2': 'value2', 'key3': 'value3', 'key4': 'value4'}14 dict_keys(['key1', 'key2', 'key3', 'key4'])15 dict_values(['value1', 'value2', 'value3', 'value4'])16 None17 {}18 {'key2': 'value2', 'key3': 'value3', 'key4': 'value4'}19 NameError: name 'dict1' is not defined

====================================================

注意:由于列表和字典的可变性,对其执行相关操作(增加,删除,修改))后,列表已经发生变化

====================================================