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  

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

实例代码如下:

a = 1,3,56,'abc','aoe'
print(type(a))
print(a)
m = 1,
n = 1
print(type(m))
print(m)
print(type(n))
print(m*3)
print(m)
#运行结果
<class 'tuple'>
(1, 3, 56, 'abc', 'aoe')
<class 'tuple'>
(1,)
<class 'int'>
(1, 1, 1)
(1,)

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

tuple1 = (12, 34.56)
tuple2 = ('abc', 'xyz')
tuple3 = tuple1+tuple2
print(tuple3)
#运行结果
(12, 34.56, 'abc', 'xyz')

元组常用的方法/函数:

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

②最大值max(tuple)

③最小值min(tuple)

④长度len(tuple)

⑤重复tuple*n

tuple = (12, 34.56,13,5)
list = sorted(tuple)
print(type(tuple))
print(tuple)
print(type(list))
print(list)
print(len(tuple))
print(max(tuple))
print(min(tuple))
#运行结果
<class 'tuple'>
(12, 34.56, 13, 5)
<class 'list'>
[5, 12, 13, 34.56]
4
34.56
5

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

#python数据类型之元组练习
L1 = (1,2,3,'A','B','C')
L2 = (1,2,3,4,5,6)
L3 = ('A',)#元组只有一个元素时需要加逗号","
L4 = 'A','B','C','D','E'
print(L1[1])#打印元组L1中索引为1的元素
print(L1[2:5])#打印(截取)元组L1中索引从2到5,但不包含索引为5的元素
print(L1[2:])#打印(截取)元组L1中索引从2开始到结束的元素
print(L1[:5])#打印(截取)元组L1中索引从0开始到5,但不包含索引为5的元素
print(L1[-3])#打印元组L1中倒数第三个元素
print(L1[:-3])#打印元组L1中索引从0开始到倒数第3(不含倒数第3)的元素
print(L1)#打印元组L1
print(L1[0:])#打印元组L1
print(L1[:])#打印元组L1
print(L1[:6])#打印元组L1
print(L1+L2)#元组的组合
L5 = L1+L2#元组的拼接
print(L5)
print(L4)
print(L1*3)#元组的重复
print(len(L2))#打印元组L2的长度
del L2#元组的元素不可以修改,也不可以删除,可以将整个元组删除
#运行结果
2
(3, 'A', 'B')
(3, 'A', 'B', 'C')
(1, 2, 3, 'A', 'B')
A
(1, 2, 3)
(1, 2, 3, 'A', 'B', 'C')
(1, 2, 3, 'A', 'B', 'C')
(1, 2, 3, 'A', 'B', 'C')
(1, 2, 3, 'A', 'B', 'C')
(1, 2, 3, 'A', 'B', 'C', 1, 2, 3, 4, 5, 6)
(1, 2, 3, 'A', 'B', 'C', 1, 2, 3, 4, 5, 6)
('A', 'B', 'C', 'D', 'E')
(1, 2, 3, 'A', 'B', 'C', 1, 2, 3, 'A', 'B', 'C', 1, 2, 3, 'A', 'B', 'C')
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,元素2,...)
list = [1,2,3,[4,5,6,7,8,9],{"A":"abc","B":"789","C":"NBA"},(11,22,'monkey','pig')]
print(list[3])
print(list[3][-1])
print(list[3][1:5])
print(list[4])
print(list[4]["C"])
print(list[5])
print(list[5][1:4])
#运行结果
[4, 5, 6, 7, 8, 9]
9
[5, 6, 7, 8]
{'A': 'abc', 'B': '789', 'C': 'NBA'}
NBA
(11, 22, 'monkey', 'pig')
(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中

实例代码如下:

a = [1,2,3,'a','abc','dnf']
a.append(235)
print(a)
a.remove(235)
print(a)
a.insert(2,4)
print(a)
a.insert(6,'xyz')
print(a)
a.insert(8,'888')
print(a)
a[-1] = '999'
print(a)
print(a[3:7])
print(a[0:-1])
#运行结果:
[1, 2, 3, 'a', 'abc', 'dnf', 235]
[1, 2, 3, 'a', 'abc', 'dnf']
[1, 2, 4, 3, 'a', 'abc', 'dnf']
[1, 2, 4, 3, 'a', 'abc', 'xyz', 'dnf']
[1, 2, 4, 3, 'a', 'abc', 'xyz', 'dnf', '888']
[1, 2, 4, 3, 'a', 'abc', 'xyz', 'dnf', '999']
[3, 'a', 'abc', 'xyz']
[1, 2, 4, 3, 'a', 'abc', 'xyz', 'dnf']

1 a = [1,2,3,('a','b','c')]
 2 b = [4,5,6,['x','y','z']]
 3 c = [444,555,666,(7,8,9)]
 4 a.extend(b)
 5 print(a)
 6 c = b+c
 7 print(c)
 8 
 9 #运行结果
10 [1, 2, 3, ('a', 'b', 'c'), 4, 5, 6, ['x', 'y', 'z']]
11 [4, 5, 6, ['x', 'y', 'z'], 444, 555, 666, (7, 8, 9)]

#python数据类型之列表练习
L1 = [1,2,3,'A','B','C']
L2 = [1,2,3,4,5,6]
print(L1[1])#打印列表L1中索引为1的元素
print(L1[2:5])#打印(截取)列表L1中索引从2到5,但不包含索引为5的元素
print(L1[2:])#打印(截取)列表L1中索引从2开始到结束的元素
print(L1[:5])#打印(截取)列表L1中索引从0开始到5,但不包含索引为5的元素
print(L1[-3])#打印列表L1中倒数第三个元素
print(L1[:-3])#打印列表L1中索引从0开始到倒数第3(不含倒数第3)的元素
print(L1)#打印列表L1
print(L1[0:])#打印列表L1
print(L1[:])#打印列表L1
print(L1[:6])#打印列表L1
print(L1+L2)#列表的组合
print(L1*3)#列表的重复
print(len(L2))#打印列表的长度
L2[0] = 'AOE'#列表的值可以修改,将所索引为0的元素更改为'AOE'
del L2[5]#列表的元素可以删除,将索引为5的元素删除
print(L2)
#运行结果
2
[3, 'A', 'B']
[3, 'A', 'B', 'C']
[1, 2, 3, 'A', 'B']
A
[1, 2, 3]
[1, 2, 3, 'A', 'B', 'C']
[1, 2, 3, 'A', 'B', 'C']
[1, 2, 3, 'A', 'B', 'C']
[1, 2, 3, 'A', 'B', 'C']
[1, 2, 3, 'A', 'B', 'C', 1, 2, 3, 4, 5, 6]
[1, 2, 3, 'A', 'B', 'C', 1, 2, 3, 'A', 'B', 'C', 1, 2, 3, 'A', 'B', 'C']
6
['AOE', 2, 3, 4, 5]

 3.字典

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

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

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

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

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

访问全部元素:字典 

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

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

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

字典的增删改:

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

n = {"a":1,"b":2}
n["c"] = 3
n["a"] = 'x'
print(n)
#运行结果
{'a': 'x', 'b': 2, 'c': 3}

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

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

# dictionary = {键1:值1,键2:值2,键3:值3,.......}
m = {"a":1,"b":2,"c":3,"d":"nba"}
m["x"] = 2019
m['y'] = 'abc'
print(m["x"])
print(m["y"])
m["a"] = 123
m["b"] = "HK666"
print(m)
n = {"a":1,"b":2}
y = {"c":3,"d":"nba"}
n.update(y)
print(n)
z = {"a":1,"b":2}
del(z["a"])
print(z)
x = {"a":1,"b":2}
y = {"a":1,"b":2}
x.update(y)
print(x)
#运行结果:
2019
abc
{'a': 123, 'b': 'HK666', 'c': 3, 'd': 'nba', 'x': 2019, 'y': 'abc'}
{'a': 1, 'b': 2, 'c': 3, 'd': 'nba'}
{'b': 2}
{'a': 1, 'b': 2}

 字典常用的方法/函数

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

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

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

④清空字典dict.clear()

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

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

   删除整个字典del dict

dict_aoe = {'key1':'value1','key2':'value2','key3':'value3','key4':'value4'}
print(dict_aoe)
print(dict_aoe.keys())
print(dict_aoe.values())
print(dict_aoe.clear())
print(dict_aoe)
dict1 = {'key1':'value1','key2':'value2','key3':'value3','key4':'value4'}
del dict1['key1']
print(dict1)
del dict1
print(dict1)
#运行结果
{'key1': 'value1', 'key2': 'value2', 'key3': 'value3', 'key4': 'value4'}
dict_keys(['key1', 'key2', 'key3', 'key4'])
dict_values(['value1', 'value2', 'value3', 'value4'])
None
{}
{'key2': 'value2', 'key3': 'value3', 'key4': 'value4'}
NameError: name 'dict1' is not defined

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

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

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