Python系列 （4）-list，tuple，dict，set

前言

本人自学了廖雪峰老师编写的Python教程，将在学习过程中的一些心得、方法 成体系的写成 本Python系列，所举的部分例子可能会和廖雪峰老师举的例子一致，本Python系列仅供大家学习参考，也相当于本人的学习笔记。

一、列表（list）

列表是一个 有序 的集合，可以随时添加、删除里面的元素

1、列表的创建

创建一个空列表

>>> a=[]

创建一个带有值的列表

>>> li = [1,2,'hello']
>>> li
[1, 2, 'hello']

list()函数创建

>>> li = list(range(10))
>>> li
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

2、列表的性质 ---- 增 删 改 查

2.1 、增

• append() 方法可在列表的末尾加入元素
• insert() 方法可以在列表的任意地方插入元素，第一个参数是要插入的索引位置，第二个参数是要插入的元素

示例：

>>> li
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]			# 原列表
>>> li.append('end')
>>> li
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 'end']
>>> li.insert(0,'hand')				# 索引0位置对应的是列表第一个元素
>>> li
['hand', 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 'end']
>>> li.insert(3,'index=3')			# 相对应，索引3就是第四个元素
>>> li
['hand', 0, 1, 'index=3', 2, 3, 4, 5, 6, 7, 8, 9, 'end']
>>> li.insert(-1,'倒数第二个元素')	# -1 对应倒数第二个元素
>>> li
['hand', 0, 1, 'index=3', 2, 3, 4, 5, 6, 7, 8, 9, '倒数第二个元素', 'end']

2.2 、删

• pop()方法

>>> li
['hand', 0, 1, 'index=3', 2, 3, 4, 5, 6, 7, 8, 9, '倒数第二个元素', 'end']
>>> li.pop()		# 不加参数 默认删掉最后一个
'end'
>>> li
['hand', 0, 1, 'index=3', 2, 3, 4, 5, 6, 7, 8, 9, '倒数第二个元素']
>>> li.pop(0)		# 传入的参数是索引，0为列表第一个元素
'hand'
>>> li
[0, 1, 'index=3', 2, 3, 4, 5, 6, 7, 8, 9, '倒数第二个元素']
>>> li.pop(2)
'index=3'
>>> li
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, '倒数第二个元素']
>>> li.pop(-1)		# 可以看到传入-1和不传入参数是一样的，说明pop()的默认参数是-1
'倒数第二个元素'
>>> li
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> li.pop(-2)		# -2 对应的是倒数第二个元素
8					#需要注意的是insert()的-1对应的是倒数第二个元素
>>> li
[0, 1, 2, 3, 4, 5, 6, 7, 9]

2.3 、改

• 改只有一种方法

>>> li
[0, 1, 2, 3, 4, 5, 6, 7, 9]
>>> li[0] = 'head'		# 将索引为0 的元素改成 'head'
>>> li
['head', 1, 2, 3, 4, 5, 6, 7, 9]
>>> li[-1] = 'end'
>>> li
['head', 1, 2, 3, 4, 5, 6, 7, 'end']
>>> li[3] = 'index=3'
>>> li
['head', 1, 2, 'index=3', 4, 5, 6, 7, 'end']

2.4 、查

• 根据索引查

>>> li
['head', 1, 2, 'index=3', 4, 5, 6, 7, 'end']
>>> li[3]		# 根据索引查
'index=3'
>>> li[-1]
'end'

• 列表的常用性质功能
  len() 函数
  count() 方法
  index() 方法
  reverse() 方法
  clear() 方法

示例：

>>> len(li)			# 查列表内元素的个数
9
>>> li.count('end')		# 查询列表内 某个元素 出现的个数
1
>>> li.index('end')		# 查询某个元素 在列表中的索引位置
8
>>> li.reverse()		# 反转列表
>>> li
['end', 7, 6, 5, 4, 'index=3', 2, 1, 'head']
>>> li.clear()			# 清空列表
>>> li
[]

3、遍历列表

>>> li
['end', 7, 6, 5, 4, 'index=3', 2, 1, 'head']
>>> for i in li:
...     print(i)

end
7
6
5
4
index=3
2
1
head

4、列表进阶

在此讲解列表的高级用法

4.1、切片

• 在python中，代码越少越好，而切片可以一次性取出很多元素，效率大大提高

>>> li
['head', 1, 2, 'index=3', 4, 5, 6, 7, 'end']
>>> li[0:3]				# 取索引0到2 对应的元素
['head', 1, 2]
>>> li[:3]				# 如果是从 索引0开始，这个0可以省略
['head', 1, 2]
>>> li[3:5]				# 取 索引3，4索引的元素
['index=3', 4]
# 从以上 你可以发现，正向切片的最后一个数是取不到的
>>> li[-3:]				# 取 倒数3个数
[6, 7, 'end']
>>> li[-3:-1]			# 取 索引为 倒数第3和倒数第2 的元素
[6, 7]

4.2、列表生成式

例一：来一个1-9的平方的列表：

>>> list(i * i for i in range(1,10))
[1, 4, 9, 16, 25, 36, 49, 64, 81]

例二：来一个0-100中奇数的列表：

>>> [i for i in range(101) if i % 2 == 1]
[1, 3, 5, 7, 9, 11, 13, 15, 17, 19, 21, 23, 25, 27, 29, 31, 33, 35, 37, 39, 41, 43, 45, 47, 49, 51, 53, 55, 57, 59, 61, 63, 65, 67, 69, 71, 73, 75, 77, 79, 81, 83, 85, 87, 89, 91, 93, 95, 97, 99]

• 可以看到，使用列表生成式 可以一行代码就生成出元素很多的列表，效率高了不少
• 可以用 list() 函数来生成列表
• 也可以直接用 [ ] 来生成列表
• 语法是 [ 表达式 for i in 迭代器 if 判断语句 ],if判断语句不是必须的
  就按照例二，来解释一下这个列表生成式，从0到100一次给i赋值，每一次赋值都去if语句判断一下，如果满足if条件，就执行for前面的表达式，并将结果加入到列表的最后。

例二的列表生成式可以等效为以下代码：

li = [ ]
for i in range(101):
	if i % 2 == 1:
		li.append(i)

• 列表生成式的使用 远不止这么简单，以上示例均是为了 让读者学习如何使用 列表生成式

4.3、双向‘列表’ deque

• 使用list存储数据时，按索引访问很快，但是插入和删除元素就很慢了。
  因为list是线性存储，数据量大的时候，插入和删除的效率很低。

• deque是为了高效实现插入和删除操作的双向列表，适用于队列和栈

from collections import deque
q = deque(['a','b','c'])                    # 创建一个列表实例
q.append('x')               # 末尾插入
q.appendleft('y')           # 左边（首部）插入
print(q)
q.pop()                     # 删除末尾元素
print(q)
q.popleft()                 # 删除首部元素
print(q)
q.remove('b')               # 删除'b'元素
print(q)
q.insert(1,'b')             # 在索引位置为1处，插入元素'b'
print(q)
q[0] = 'z'					# 把索引为0的元素改成 'z'

• 可见能够实现列表的增删改查

但是严格意义上来说，deque() 函数创建出的示例 不属于列表

>>> isinstance(q,list)
False
>>> type(q)
<class 'collections.deque'>

5、列表小结

• 列表可用来存储数据，按索引搜索速度快，但是插入和删除元素的速度就慢了，这都是因为 list 是线性存储，数据量一旦大了，插入和删除就更耗费时间，这段情况可用 deque 来解决！
• 列表的普通用法增删改查得会。
• 高级用法 切片 和 列表生成式 都能够省掉大量的代码，编程时应当优先考虑使用
• 列表是一个迭代器

二、元组

• 元组和列表类似，在形式上也仅仅只是把列表的[ ]改成了 ()
• 元组最大的特性就是不可变性，什么是不可变性呢？就是元组包含的元素很固定，不能像列表那样对元素增删改，相当不灵活，但有的时候又需要这种不灵活！

1、创建元组

>>> t = ()
>>> t
()

>>> t = (1,'a')
>>> t
(1, 'a')

# tuple() 传入一个迭代器为参数
>>> t = tuple([1,2,'a'])
>>> t
(1, 2, 'a')
>>> type(t)
<class 'tuple'>				# 数据类型是元组

>>> tuple(range(10))
(0, 1, 2, 3, 4, 5, 6, 7, 8, 9)

• 这里需要注意一个点，就是在创建元组的时候，如果只有一个元素，需要用英文逗号隔开，否则Python就不知道()是代表运算符中的优先级呢还是元组呢！
  示例

>>> t = (1,)
>>> t
(1,)

>>> t = (1)			
>>> t				# 不是元组了哟
1

2、合并元组

>>> t = ('a',)
>>> t
('a',)
>>> b = (2,'b')
>>> b
(2, 'b')

>>> c = t + b		# 合并元组（用这种方法来添加元素也不失为一种方法）
>>> c
('a', 2, 'b')

3、查找元素

>>> c
('a', 2, 'b')
>>> c[0]
'a'
>>> c[2]
'b'

# 切片方法和列表类似
>>> c[0:]
('a', 2, 'b')
>>> c[:2]
('a', 2)
>>> c[:3]
('a', 2, 'b')
>>> c[1:3]
(2, 'b')

4、遍历元组

>>> c
('a', 2, 'b')
>>> for i in c:
...     print(i)
...
a
2
b

5、强行给元组添加元素（末尾）

>>> c
('a', 2, 'b')
>>> for i in [x for x in range(10) if x % 2 == 0 ]:
...     t  = (i,)
...     c = c + t
...
>>> c
('a', 2, 'b', 0, 2, 4, 6, 8)

• 类似的删改都可以通过for循环，利用元组的合并特性来实现

三、字典

• 字典：顾名思义，就是像字典一样去查询，字典有一个索引表，我们查字典就是利用索引表，来算出要查看的内容的位置，然后去对应的页码查看即可。Python中的字典也是如此，根据Key算出Value存放的位置
• 所以在字典眼中，无论你这个表有多大，查询的时间都不会变~
• 和列表来对比一下，列表是从前往后，依此查询，直到查到为止，所以列表如果太大，查询的速度就有可能会很慢~

1、创建字典

>>> dic = {
     }			# 空字典
>>> dic
{
     }
>>> type(dic)
<class 'dict'>		# 数据类型 为 dict

>>> dic = {
     'lxn':90,'zhangsan':80,'lisi':70}
>>> dic
{
     'lxn': 90, 'zhangsan': 80, 'lisi': 70}

# 使用dict()创建字典
>>> dict([[1,'1'],[2,'2']])
{
     1: '1', 2: '2'}

>>> dict([(1,'1'),(2,'2')])
{
     1: '1', 2: '2'}

>>> dict(name='lxn',score=90)
{
     'name': 'lxn', 'score': 90}

>>> dict()			# 不传参是空字典
{
     }

2、字典的 增删改查

2.1 增

• key 应当是字典里没有的
• dic[key] = value 即可

>>> dic
{
     'lxn': 90, 'zhangsan': 80, 'lisi': 70}
>>> dic['laowang'] = 86
>>> dic
{
     'lxn': 90, 'zhangsan': 80, 'lisi': 70, 'laowang': 86}

2.2 删

• del dic[key] 或 pop() 方法

>>> dic
{
     'lxn': 90, 'zhangsan': 80, 'lisi': 70, 'laowang': 86}
>>> del dic['laowang']
>>> dic
{
     'lxn': 90, 'zhangsan': 80, 'lisi': 70}

>>> dic.pop('lisi')
79
>>> dic
{
     'lxn': 90, 'zhangsan': 80}

2.3 改

• key 应当是字典里是 有 的，和添加的区别就在于 Key 是否已经存在于字典中
• dic[key] = value 即可

>>> dic
{
     'lxn': 90, 'zhangsan': 80, 'lisi': 70}
>>> dic['lisi'] = 79
>>> dic
{
     'lxn': 90, 'zhangsan': 80, 'lisi': 79}

2.4 查

• dic[key] 即可，但是key不存在会报错

>>> dic['lxn']
90

• 可以使用get()方法，如果key不存在返回None（空值），不会报错！

>>> dic.get('lxn')
90
>>> print(dic.get('haha'))
None

3、遍历字典

遍历key

>>> for i in dic:
...     print(i)
...
lxn
zhangsan
lisi

遍历key 和 value

>>> for key,value in dic.items():
...       print('key--->%s  value--->%s' % (key,value))
...
key--->lxn  value--->90
key--->zhangsan  value--->80
key--->lisi  value--->79

4、判断 一个 key 是否在字典中

>>> 'lxn' in dic
True
>>> 'lixiaonan' in dic
False

也可以使用遍历：

>>> for i in dic:
...     if 'lxn' == i:
...             print('True')
...             break
...
True

5、字典的更新（可同时添加，修改）

• 用 update() 方法，传入参数是一个dict

>>> dic
{
     'lxn': 90, 'zhangsan': 80}
>>> dic.update({
     'lxn':100,'lisi':90})
>>> dic
{
     'lxn': 100, 'zhangsan': 80, 'lisi': 90}

6、获取 keys ,values, keys + values

• keys() 方法
• values() 方法
• items() 方法

# key
>>> dic.keys()
dict_keys(['lxn', 'zhangsan', 'lisi'])

# values
>>> dic.values()
dict_values([100, 80, 90])

# items
>>> dic.items()
dict_items([('lxn', 100), ('zhangsan', 80), ('lisi', 90)])

7、清空字典

• clear()方法

>>> dic
{
     'lxn': 100, 'zhangsan': 80, 'lisi': 90}

>>> dic.clear()
>>> dic
{
     }

四、set

• set() 函数创建一个无序不重复元素集
• 可进行关系测试，删除重复数据，还可以计算交集、差集、并集等。

1、过滤重复元素

>>> li = [8,2,'md5',4,5,1,0,8,'hash']
>>> set(li)
{
     0, 1, 2, 4, 5, 8, 'md5', 'hash'}

• 可以看到自然数在前面，而且是按自然数顺序排列，字符串在后面

2、交集，并集，差集

>>> a=set([3,2,5,4])
>>> b=set([3,1,2])

# 交集
>>> set(a & b)
{
     2, 3}

# 并集
>>> set(a | b)
{
     1, 2, 3, 4, 5}

# 差集
>>> set(a - b)
{
     4, 5}

写在最后

list , tuple ,dict , set 是Python中最为基础的数据类型，有着相当重要的地位，使用场景很多~