【python】中剩余数据类型（列表、元组、字典、集合）

---

---

一、列表(相当于数据库)

当我们有一百个变量要储存起来的时候,总不能弄一百个变量啊,怎么办的,用列表.

我们可以对列表这样去理解, 就把它当成一个大桶, 当我们有一堆东西需要找个地方临时存放在一起, 以便后续进行排序, 筛选,提取等操作时, 就弄一个列表, 先放进去.
列表中每个元素之间用逗号分割
列表中的元素,没有数据类型的限制,可以为任何数据类型

1.1 列表的索引和切片

列表和字符串一样,是一种可迭代对象.

因此可以和字符串一样进行索引和切片.语法方面是一样的.
L[起始位置:终止位置:步长] # 包含起始位置,不包含终止位置

L = ['python','java','C','PHP']
print(L[0])
>>python
#二维列表
L = [
    ['Apple', 'Google', 'Microsoft'],
    ['Java', 'Python', 'Ruby', 'PHP'],
    ['Adam', 'Bart', 'Lisa']
]
L[1][1]
>>'Python'

1.2 修改列表的元素值

通过元素的索引位置来索引元素

L = ['python',
     'java',
     'C',
     'PHP']
L[2:] = 'C++','php'
L
>>['python', 'java', 'C++', 'php']

1.3 列表的常用方法

1.3.1 append

通过append可以向列表添加元素

L = ['Superman','Hulk','Spiderman']
L.append('Leifengxia')
L
>>['Superman', 'Hulk', 'Spiderman', 'Leifengxia']

1.3.2 extend

通过extend可以将另一个集合中的元素逐一添加到列表中

a = [1,2]
b = [3,4]
a.append(b)
a
>>[1, 2, [3, 4]]
a = [1,2]
b = [3,4]
a.extend(b)
a
>>[1, 2, 3, 4]

显而易见，extend会把列表里每个元素都添加到列表里，而append只能将整个列表作为一个元素进行添加。

1.3.3 insert

insert(index, object) 在指定位置index前插入元素object

a = ['插','入','素']
a.insert(2,'元')
a
>>['插', '入', '元', '素']

1.3.4 查找元素 in not in index count

#in
test = ['插', '入', '元', '素']
'元' in test
>>True
#not in
test = ['插', '入', '元', '素']
'元' not in test
>>False
#index
test = ['插', '入', '元', '素']
test.index('入')
>>1
test = ['插', '入', '元', '素']
test.index('狗')
---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
<ipython-input-79-0e6c4a720c95> in <module>
----> 1 test.index('狗')

ValueError: '狗' is not in list

注意：字符串里面也有index()查找功能，字符串里find()也是查找，二者都是返回元素所在位置，但不同的是若所找内容不在字符串里，find()会返回-1，但是index()会报错。
列表里没有find()，只有index()，用法与字符串一样，若所找内容不在列表里，则会报错。

1.3.5 删除元素del pop remove

del（关键字）：根据下标进行删除
pop（弹出）：删除最后一个元素（能获取弹出的内容，默认弹出最后一个内容）
remove（移除）：根据元素的值进行删除（不能用索引）

movieName = ['加勒比海盗','骇客帝国','第一滴血','指环王','霍比特人','速度与激情']
name = movieName.pop()
name
>>'霍比特人'

movieName = ['加勒比海盗','骇客帝国','第一滴血','指环王','霍比特人','速度与激情']
movieName.remove('第一滴血')
movieName
>>['加勒比海盗', '骇客帝国', '指环王', '霍比特人', '速度与激情']

# del 关键字, 删除数据
movieName = ['加勒比海盗','骇客帝国','第一滴血','指环王','霍比特人','速度与激情']
del movieName[2]
movieName
>>['加勒比海盗', '骇客帝国', '指环王', '霍比特人', '速度与激情']

1.3.6 对元素排序sort reverse

排序(sort, reverse)

sort方法是将list按特定顺序重新排列，默认为由小到大，参数reverse=True可改为倒序，由大到小。

reverse(翻转)方法是将list逆置

a = [1, 4, 2, 3]
a
a.sort()
a
a.sort(reverse=True)
a
>>[1, 4, 2, 3]
[1, 2, 3, 4]
[4, 3, 2, 1]

a = [1, 4, 2, 3]
a.reverse()
a
>>[3, 2, 4, 1]

1.3.7 枚举: 将索引和数据打包成一个元组对

colors = ['red', 'green', 'blue', 'yellow']
list(enumerate(colors))
>>[(0, 'red'), (1, 'green'), (2, 'blue'), (3, 'yellow')]

for i,j in enumerate(colors):
    print(i,j)
>>0 red
1 green
2 blue
3 yellow

二、元组(Tuple)

与列表类似，不同的是元组用的是‘( )’，而列表用的是‘[ ]’
二者最大的不同就是元祖是不可变的，也就是说元组一旦被定义就不能随意进行更改，因此不能进行列表里的“增删改”，仅能进行“查”

tuple的陷阱：

当你定义一个tuple时，在定义的时候，tuple的元素就必须被确定下来

tp = (1, 2)
tp
>>(1, 2) #这样是没有问题的
#但是元组里只有一个元素时，必须加','
tp3 = (1)
tp3
>>1  #这样定义出来的是数字, 而不是元组
tp4 = (1,)
tp4
>>(1,)

tuple的第二个陷阱

aTuple = (1,2,3,4)
aTuple = aTuple[:2]
aTuple
>>(1,2)

我们发现这时的元组已经被改动，那么这是什么原因呢？
是因为索引其实没有改变元组本身，而是将元组改变了内存地址，所以会发生变化
如下：

id(aTuple)
>>4570135632 #(1,2,3,4)的内存地址
id(aTuple)
>>4560477792 #(1,2)的内存地址

以下也是同样道理：

tp5 = ('a', 'b', ['A', 'B'])
tp5[2][0] = 'X'
tp5
>>('a', 'b', ['X', 'B'])
id(tp5)
>>1852544410104 #('a', 'b', ['A', 'B'])的内存地址
id(tp5)
>>1852544253600 #('a', 'b', ['X', 'B'])的内存地址

表面上看，tuple的元素确实变了，但其实变的不是tuple的元素，而是list的元素。tuple一开始指向的list并没有改成别的list，所以，tuple所谓的“不变”是说，tuple的每个元素，指向永远不变。即指向’a’，就不能改成指向’b’，指向一个list，就不能改成指向其他对象，但指向的这个list本身是可变的！

三、字典dict

Python内置了字典：dict的支持，dict全称dictionary，在其他语言中也称为map，使用键-值（key-value）存储，具有极快的查找速度。

3.1 创建字典

字典由键（key）和对应值（value）成对组成。字典也被称作关联数组或哈希表。基本语法如下：

dict ={“key1”:“value1”,
“key2”:“value2”,
“key3”:“value3”}

注意：
每个键与值用冒号隔开（:），每对用逗号，每对用逗号分割，整体放在花括号中（{}）。
键必须独一无二，值则不必。

value可以取任何数据类型
key必须是不可变的，如字符串，数值，布尔或元组，但是列表，字典不行。

字典是无序的,所以没有之前学的那种数值索引

d = {'C罗纳尔多': 94, 
     '梅西': 93, 
     '内马尔': 92, 
     '苏亚雷斯':92, 
     '诺伊尔':92, 
     '莱万多夫斯基':91, 
     '拉莫斯':90}
d['内马尔']  # 用key来查找对应的value
>>92

3.2 字典赋值或更改

d = {'C罗纳尔多': 94, '梅西': 93, '内马尔': 92, '苏亚雷斯':92, '诺伊尔':92, '莱万多夫斯基':91, '拉莫斯':90}
# 修改字典中的value
d['梅西'] = 95
d
>>{'C罗纳尔多': 94,'梅西': 95,'内马尔': 92,'苏亚雷斯': 92,'诺伊尔': 92,'莱万多夫斯基': 91,'拉莫斯': 90}
# 添加新的
d['武磊'] = 78 
d
>>{'C罗纳尔多': 94,'梅西': 95,'内马尔': 92,'苏亚雷斯': 92,'诺伊尔': 92,'莱万多夫斯基': 91,'拉莫斯': 90,'武磊': 78}

3.3 判断key是否存在

可以通过 in判断key是否存在

d = {'C罗纳尔多': 94, '梅西': 93, '内马尔': 92, '苏亚雷斯':92, '诺伊尔':92, '莱万多夫斯基':91, '拉莫斯':90}
'李毅' in d
>>False
'李毅' not in d
>>True
'梅西' in d
>>True

通过dict提供的get()方法，如果key不存在，可以返回None，或者自己指定的value：

d = {'C罗纳尔多': 94, '梅西': 93, '内马尔': 92, '苏亚雷斯':92, '诺伊尔':92, '莱万多夫斯基':91, '拉莫斯':90}
d.get('梅西')
>>93
d.get('李毅','不存在')
>>不存在

3.4 删除字典元素

d.pop(‘key’) 必须要传值，因为字典是无序的
d.popitem() 随机删除一个
del d[‘key’]
d.clear() 清空字典

d.pop(‘key’)可以填第二个参数，若字典中没有该元素且没有填第二个参数，则会报错。否则返回第二个参数值，若字典中有该元素，则弹出该键对应值。

3.5 字典常见操作

d = {'C罗纳尔多': 94, '梅西': 93, '内马尔': 92, '苏亚雷斯':92, '诺伊尔':92, '莱万多夫斯基':91, '拉莫斯':90}
# 获取字典key
d.keys()
>>dict_keys(['C罗纳尔多', '梅西', '内马尔', '苏亚雷斯', '诺伊尔', '莱万多夫斯基', '拉莫斯'])
# 获取字典values
d.values()
>>dict_values([94, 93, 92, 92, 92, 91, 90])
 # 输出一个list格式（非真正意义上的list）
d.items()
>>dict_items([('C罗纳尔多', 94), ('梅西', 93), ('内马尔', 92), ('苏亚雷斯', 92), ('诺伊尔', 92), ('莱万多夫斯基', 91), ('拉莫斯', 90)])

3.6 遍历字典

d = {'C罗纳尔多': 94, '梅西': 93, '内马尔': 92, '苏亚雷斯':92, '诺伊尔':92, '莱万多夫斯基':91, '拉莫斯':90}
# 默认: 直接对字典进行遍历,临时变量会接收到字典的key
for key in d: 
    print(key, ':::', d[key])
>>C罗纳尔多 ::: 94
梅西 ::: 93
内马尔 ::: 92
苏亚雷斯 ::: 92
诺伊尔 ::: 92
莱万多夫斯基 ::: 91
拉莫斯 ::: 90
# 用两个变量分别接受两个值
for key,value in d.items(): 
    print(key, value)
>>C罗纳尔多 94
梅西 93
内马尔 92
苏亚雷斯 92
诺伊尔 92
莱万多夫斯基 91
拉莫斯 90

3.7 将其他数据处理成字典

names = ['罗纳尔多', '梅西', '内马尔','苏亚雷斯', '诺伊尔', '莱万多夫斯基', '拉莫斯' ]
scores = [94, 93, 92, 92, 92, 91, 90]
# 生成一个空字典
test = {}
for i in range(len(names)):# i 相当于列表的索引
    test[names[i]] = scores[i]
test
>>{'罗纳尔多': 94,
 '梅西': 93,
 '内马尔': 92,
 '苏亚雷斯': 92,
 '诺伊尔': 92,
 '莱万多夫斯基': 91,
 '拉莫斯': 90}

四、集合 Set

集合（set）是一个无序的不重复元素序列。

set和dict类似，也是一组key的集合，但不存储value。由于key不能重复，所以，在set中，没有重复的key。

其实集合就是一个没有value的dict

s = set([1,2,3])
s
>>{1, 2, 3}
# 集合常用功能: 去重
L = [1,2,3,3,2,1,4,5,3]
set(L)
>>{1, 2, 3, 4, 5}
#可以通过add(key)方法添加元素到set中，但对于已经存在的值不会有效果
s = set([1,2,3])
s.add(666)
s
>>{1, 2, 3, 666}
s.remove(666)
>>{1, 2, 3}

两个set可以做数学意义上的交集、并集等操作
& 交集 两个都有的元素
| 并集 两个有一个以上有
-差集

s1 = set([1, 2, 3])
s2 = set([2, 3, 4])
s1 & s2
>>{2, 3}
s1 | s2
>>{1, 2, 3, 4}
s1 - s2
>>{1}