Python 容器（List、Set、Hash、Dict）

容器

• 列表（list）
• 元组（tuple）
• 集合（set）
• 字典（dict）

1、列表

线性表：

• 数组：连续内存的实现

• 栈：先进后出，后进先出

• 队列：先进先出，后进后出

• 链表：

  • 单向链表：为指针指向首地址
  • 双向链表：收尾指向

• Python 没有数组，数据查询速度快，增删改查效率慢

• Python 的列表是基于双向链表实现，列表查询速度快，增删改查速度慢。

• 列表底层是基于双向链表实现的，里面的元素的有序的、可以重复的。

（1）列表的定义

# 若数据类型语言
>>> ls = [1, 2, 'zhangwanqiang', 'man']
>>> type(ls)
<class 'list'>
>>> ls
[1, 2, 'zhangwanqiang', 'man']

# 全局函数
>>> ls1 = list(['zhangwanqiag', 18, 'man'])
>>> type(ls1)
<class 'list'>
>>> ls1
['zhangwanqiag', 18, 'man']

（2）元素的访问

>>> ls1
['zhangwanqiag', 18, 'man']
>>> ls[1]
2
>>> ls1[2]
'man'

全局函数：

>>> ls1[2]
'man'
>>> len(ls)
4
>>> len(ls1)
3

（3）遍历列表

>>> for i in ls:
...     print(i)
...
1
2
zhangwanqiang
man
>>>
>>>
>>> index = 0
>>> while index < len(ls):
...     print(ls[index])
...     index += 1
...
1
2
zhangwanqiang
man

（4）列表的常见方法

--- append # 列表尾部插入元素
>>> ls
[1, 2, 'zhangwanqiang', 1]
>>> ls.append('man')
>>> ls
[1, 2, 'zhangwanqiang', 1, 'man']

--- insert # 指定位置插入元素
>>> ls
[1, 2, 'zhangwanqiang', 1, 'man']
>>> ls.insert(2, 'good')
>>> ls
[1, 2, 'good', 'zhangwanqiang', 1, 'man']

--- sort # 对列表元素进行排序
>>> ls2 = [21, 45, 32, 100]
>>> ls3 = ['s', 'k', 'r', 's', 'a', 'g']
>>> ls2.sort()
>>> ls3.sort()
>>> ls2
[21, 32, 45, 100]
>>> ls3
['a', 'g', 'k', 'r', 's', 's']

--- index # 查看指定元素索引位置
>>> ls
[1, 2, 'good', 'zhangwanqiang', 1, 'man']
>>> ls.index(1)
0

--- reverse # 反转列表元素
>>> ls
[1, 2, 'good', 'zhangwanqiang', 1, 'man']
>>> ls.reverse()
>>> ls
['man', 1, 'zhangwanqiang', 'good', 2, 1]

--- remove # 移除指定元素
>>> ls
['man', 1, 'zhangwanqiang', 'good', 2, 1]
>>> ls.remove('good')
>>> ls
['man', 1, 'zhangwanqiang', 2, 1]

--- count # 统计列表元素个数
>>> ls
['man', 1, 'zhangwanqiang', 2, 1]
>>> ls.count(1)
2

--- clear # 清除列表
>>> ls1
['zhangwanqiag', 18, 'man']
>>> ls1.clear()
>>> ls1
[]

--- copy  # 浅拷贝
>>> ls
['man', 1, 'zhangwanqiang', 2, 1]
>>> ls10 = ls.copy()
>>> ls10
['man', 1, 'zhangwanqiang', 2, 1]
>>> ls.append(123456)
>>> ls
['man', 1, 'zhangwanqiang', 2, 1, 123456]
>>> ls10
['man', 1, 'zhangwanqiang', 2, 1]

--- exdend # 合并列表
>>> ls2
[21, 32, 45, 100]
>>> ls3
['a', 'g', 'k', 'r', 's', 's']
>>> ls2.extend(ls3)
>>> ls2
[21, 32, 45, 100, 'a', 'g', 'k', 'r', 's', 's']
>>> ls3
['a', 'g', 'k', 'r', 's', 's']

--- 删除最后一个元素
>>>
>>> ls3
['a', 'g', 'k', 'r', 's', 's']
>>> ls3.pop()
's'
>>> ls
['man', 1, 'zhangwanqiang', 2, 1, 123456]

2、元组

元组的特点：

• 有序的、可重复的。
• 固定的，一旦定义了元素不可改变。

（1）元组的创建

--- 若数据类型语言
>>> t = (1, 2, 3, 'zhang')
>>> type(t)
<class 'tuple'>

--- 全局函数
>>> tt = tuple((1,45,76, 'wan', 'qiang'))
>>> type(tt)
<class 'tuple'>

（2）常见方法

>>> t
(1, 2, 3, 'zhang')
--- index # 查看元素的索引位置
>>> t.index(3)
2
---- count # 查看元素的个数
>>> t.count(1)
1

3、集合

• 集合底层是基于hash表实现的，里面的元素是唯一的、无序的。

（1）集合的创建

--- 若数据类型
 s = set({1, 3, 'zhang', 34})
>>> type(s)
<class 'set'>

--- 全局函数
>>> ss = {22, 'wan'}
>>> type(ss)
<class 'set'>

（2）集合的常见方法

--- clear # 清除集合中的元素
--- remove # 移除集合中指定的元素
--- copy # 浅拷贝

--- add # 集合中插入元素
>>> s
{1, 34, 3, 'zhang'}
>>> s.add(10101)
>>> s
{1, 34, 3, 'zhang', 10101}

--- difference # 差集
>>> s
{1, 34, 3, 2, 'zhang', 10101}
>>> ss
{1, 2, 3, 22, 'wan'}
>>> ss.difference(s)
{'wan', 22}

--- intersection # 交集
>>> s
{1, 34, 3, 2, 'zhang', 10101}
>>> ss
{1, 2, 3, 22, 'wan'}
>>> ss.intersection(s)
{1, 2, 3}

--- union # 并集
>>> s
{1, 34, 3, 2, 'zhang', 10101}
>>> ss
{1, 2, 3, 22, 'wan'}
>>> ss.union(s)
{1, 2, 3, 34, 'zhang', 10101, 22, 'wan'}

--- 合并元素
>>> s
{1, 34, 3, 2, 'zhang', 10101}
>>> ss
{1, 2, 3, 22, 'wan'}
>>> s.update(ss)
>>> s
{1, 34, 3, 2, 'zhang', 10101, 22, 'wan'}
>>> ss
{1, 2, 3, 22, 'wan'}

--- 移除元素
>>> s
{1, 34, 3, 2, 'zhang', 10101, 22, 'wan'}
>>> s.discard('wan')
>>> s
{1, 34, 3, 2, 'zhang', 10101, 22}
>>> s.discard('wan')
>>> s
{1, 34, 3, 2, 'zhang', 10101, 22}

4、字典

特点：

• 键值对的方式存储

（1）字典的创建

--- 若数据类型
>>> d = {'name':'z3', 'age':'17', 'gender':'man'}
>>> type(d)
<class 'dict'>

--- 全局函数
>>> dd = dict({'name':'lisi', 'age':'16', 'gender':'g'})
>>> type(dd)
<class 'dict'>

（2）元素的访问

>>> d['name']
'z3'

（3）常见方法

--- clean # 清除元素
--- copy # 浅拷贝
--- get # 返回key对应的值
>>> d
{'name': '456', 'age': '17', 'gender': 'man', 'niu': '666'}
>>> d.get('name')
'456'

--- keys # 返回所有的键
>>> d
{'name': '456', 'age': '17', 'gender': 'man', 'niu': '666'}
>>> d.keys()
dict_keys(['name', 'age', 'gender', 'niu'])

--- values # 返回所有的值
>>> d
{'name': '456', 'age': '17', 'gender': 'man', 'niu': '666'}
>>> d.values()
dict_values(['456', '17', 'man', '666'])

--- items # 返回一个键值对
>>> d
{'name': '456', 'age': '17', 'gender': 'man', 'niu': '666'}
>>> d.items()
dict_items([('name', '456'), ('age', '17'), ('gender', 'man'), ('niu', '666')])

--- pop # 删除key对应的键值对
>>> d
{'name': '456', 'age': '17', 'gender': 'man', 'niu': '666'}
>>> d.pop('gender')
'man'
>>> d
{'name': '456', 'age': '17', 'niu': '666'}

--- popitem # 移除一个键值对，移除规则是（LIFO）
{'name': '456', 'age': '17', 'niu': '666'}
>>> d.popitem()
('niu', '666')
>>> d
{'name': '456', 'age': '17'}

（4）遍历元素

--- 方法一
>>> d
{'name': '456', 'age': '17'}
{'name': '456', 'age': '17'}
>>> for key in d:
...     print(key, d.get(key))
...
name 456
age 17

--- 方法二
>>> d
{'name': '456', 'age': '17'}
>>> for key in d.keys():
...     print(key, d.get(key))
...
name 456
age 17

--- 方法三
>>> d
{'name': '456', 'age': '17'}
>>> for k, v in d.items():
...     print(k, v)
...
name 456
age 17