python容器

Python3 中基本可以分为：

序列类型： 字符串、列表、元组、Unicode字符串，buffer对象，range对象
泛映射类型： 字典
集合： set()

序列类型数据结构共有的特点：

序列类型中的元素都有对应的位置，这个位置叫偏移量或者索引

list 列表

 

列表的特点

列表的元素可以是 Python 的任何类型的数据和对象
列表内的元素是可变的
列表中的具有相同值的元素允许出现多次

创建列表

 

# [] 推荐，高效

li = []
l2 = ['千锋', '杨哥']

# list() 从其他类型转换

list('hello')
['h', 'e', 'l', 'l', 'o']

 

# 从字符串转换 split()

'www.qfedu.com'.split('.')
['www', 'qfedu', 'com']

列表的嵌套

列表中可包含 python 中任何类型的元素(对象)，当然也可以包括一个或多个列表
nesting_li = [['one', 'two', 'three'], [1, 2,3]]

列表的操作

列表名[下标] 获取元素
列表名[下标][下标] 获取多层列表的元素
列表名[开始:结束:切片] 切片
slice（开始，结束，切片） 命名切片
in 判断元素是否存在于列表中。
len() 方法是序列类型函数，可以统计序列类型的数据结构的长度。
obj.append('a') 追加 向列表的最后位置，添加一个元素，接收一个参数
obj.insert(0,'b') 向原列表的指定位置插入一个元素，接收两个参数， 第一个是索引号，第二个是要插入的元素。
obj.extend() 可以把一个序列类型中的每个元素追加到原列表中， 接收的参数是一个序列类型的数据。
obj.remove('a') 移除列表中某个指定的元素，没有返回值，并且假如有 多个相同值的元素存在，每次只会移除排在最前面的那个元素。
obj.pop() 从原列表中删除一个元素，并且把这个元素返回。 接收零个或一个参数，参数是偏移量，int 类型。
obj.index('qf') 返回指定元素的索引号。
obj.count('qf') 是列表的内置方法，可以统计出相同值的元素在列表中总共 出现都少次。
使用有条件判断的列表推导式
a_list = [n for n in range(1,6) if n% 2 == 1]

tuple 元组

元组和列表一样，也是一种序列。
唯一的不同是，元组是相对不可变的
t1 = () # 创建 空 元素的元组
•创建非空元素的元组是用逗号，而不是用小括号
tuple() # 可以对其他序列类型的数据进行转换

dict 字典

在字典存放的每个元素都是以一对儿键值对。
在 Python 中 字典通常被称为 dict，键 称为 key，值称为value
字典中不可以存在相同的 key，但是 value 可以。

高效创建字典和转换

d1 = {}
dict()
函数接收一个序列类型的参数，这个序列类型中的每个元素必须是成对儿出现的。

用 zip() 并行迭代

zip() 函数可以对多个序列进行并行迭代
In [30]: en =['Monday','Tuesday','Thursday','Friday']
In [31]: cn = ['星期一','星期二','星期三','星期四']
In [33]: for chinese,week in zip(cn, en):
...: print(chinese,'的英文是:',week)
利用 zip() 函数可以对具有相同数量的元素的序列进行配对，返回的值不是元组，也不是列表，而是一个整合在一起的可迭代变量
In [40]: list((english,chineses))
Out[40]: [('Monday', 'Tuesday', 'Thursday'),('星期一', '星期二', '星期三')]
In [41]: dict(zip(english,chineses))
Out[41]: {'Monday': '星期一', 'Thursday': '星期三', 'Tuesday': '星期二'}
注意：zip() 函数会在最短序列迭代（循环）完毕时停止
在 Python 内部用一个哈希表来维护字典中的 key 到 value 的映射关系。
所以 key 必须是可哈希的。
判断一个对象是否可哈希，可以使用 hash() 函数
返回一个整数，就是可哈希，反之会抛出 TypeError 异常

获取 key 对应的 value

dict_obj = {'a': 1, 'b': 2}
dict_obj['a']
# key 必须存在，不存在，抛出异常
dict_obj.get('a')
# 获取到 'a' 对应的值(value)
dict_obj.get('c')
# key 不存在字典中，则返回None
dict_obj.get('c', '5')
# key 不存在，返回指定的value

获取字典所有的 key

dict_obj.keys()
info_dict = {"name": 'yangge', 'age': 18}
d_keys = info_dict.keys()
print(d_keys)
print(list(d_keys))

获取字典所有的 value

dict_obj.values()
info_dict = {"name": 'yangge', 'age': 18}
d_vals = info_dict.values()
print(d_vals)
print(list(d_vals))

赋值和更新字典

=
可以使用 等号 对字典的 key 进行直接赋值操作。
假如 key 不存在与字典中，这个 key 和 对应值也会被创建到字典中。
In [50]: d5 = {}
In [51]: d5['a'] = 1
In [52]: d5['b'] = 2
In [53]: d5
Out[53]: {'a': 1, 'b': 2}
In [54]: d5['li'] = [1,3,5]
In [55]: d5
Out[55]: {'a': 1, 'b': 2, 'li': [1, 3, 5]}
update()
是用于把一个已经存在的字典中的键值对，添加到当前操作的字典中方法。
In [59]: dict5
Out[59]: {'a': 1, 'b': 2, 'li': [1, 3, 5]}
In [60]: dict6 = {'a': 2,'d': 2,'e': 5}
In [61]: dict5.update(dict6)
In [62]: dict5
Out[62]: {'a': 2, 'b': 2, 'd': 2, 'e': 5,'li': [1, 3, 5]}
注意： 更新时，相同的 key ，它的值会被新的值替代，这个特性同样适用与 = 方式的更新

判断 key成员

'a' in dict5 # 默认就是判断 ‘a’ 是否存在于字典中的 keys()

删除和清空字典

 

删除指定的键值对

dict_obj = {'a': 1}
del dict_obj['a'] # 从字典中删除指定 key 的键值对
del dict_obj # 删除字典本身，字典自身就不存在于内存中了

清空

dict_obj={}
dict_obj.clear() # 字典本身还在内存中，只是内容没了
pop()
从字典中删除指定 key 的键值对，并返回这个 key 对应的值
In [49]: dic6 = {'b': 2, 'c': '3', 'd': 'newkey', 'li': [1, 3, 5]}
In [50]: li = dic6.pop('li')
In [51]: print(li)
Out [51]: [1, 3, 5]

setdefault 处理缺失的键

dict_obj.setdefatult(‘key’, ‘value’)
# key 不存在，设置 ’key’: ‘value’ 到字典中,并且返回设置后的键值对的 值；
# key 存在, 返回对应的 value
# 最后都会返回 value
groups = {}
for (key, value) in data:
groups.setdefault(key, []).append(value)

使用字典推导式

words = 'letters'
w_counts = {w: words.count(w) for w in words}
Python字典中的键 是否相同（只有相同才会覆盖）取决于两个条件：
1、两者的值是否相等（比较 __eq__() 方法)
2、比较两者的哈希值是否相同（比较 ___hash__() hash方法）

set 集合

 

高效创建集合和转换

set()
In [96]: s1 = set()
In [97]: s1
Out[97]: set()

添加元素

add
In [11]: s2 = {12,3,4,5,6,}
In [12]: s2.add('n')
In [13]: s2
Out[13]: {12, 3, 4, 5, 6, 'n'}

指定删除某个元素

remove
In [15]: s2.remove('n')
In [16]: s2
Out[16]: {4, 5, 6, 12}

随机干掉一个

pop
In [14]: s2.pop()
Out[14]: 3

集合运算

& 交集 获取两个集合都有的元素
| 并集 把两个集合的元素合并在一起，产生一个新的集合
- 差集 把相同的元素去掉，只留下两个对象的不同元素，并返回在第一个位置对象的所拥有的元素
^ 异或运算 获取两个集合的不同之处

集合推导式

>>> a_set = {n for n in range(1,6) if n % 3 ==1}
>>> a_set{1, 4}
>>>