Python学习笔记 - 基本数据结构：元组，列表，字典，集合

序列

序列是具有先后关系的一组元素
序列是一维元素向量，元素类型可以不同
序列是一个基类类型，字符串、元组、列表都属于序列。

序列处理函数及方法主要有：

# 判断某一元素x是否在序列s中
x in s
x not in s
# 连接两个序列
s + t
# 将序列s复制n次
s * n 或 n * s
# 索引
s[i]
# 切片
s[i:j]
#带有步长的切片
s[i:j:k]

# 返回序列s的长度
len(s)
# 返回序列的最小或最大元素
min(s)
max(s)
# 返回序列从i到j位置中第一次出现元素x的位置
s.index(x)
s.index(x,i,j)
# 返回序列s中出现x的总次数
s.count(x)

元组

元组是一种序列类型，一旦创建就不能被修改
元组继承了序列类型的全部通用操作

# 创建元组
In [1]: tup = 3,4,5
In [2]: tup
Out[2]: (3, 4, 5)

# 创建元素是元组的元组
In [3]: nested_tup = (4,5,6),(7,8)
In [4]: nested_tup
Out[4]: ((4, 5, 6), (7, 8))

# 使用tuple函数将任意序列或迭代器转换为元组
In [6]: tuple([1,2,3])
Out[6]: (1, 2, 3)
In [7]: tuple('string')
Out[7]: ('s', 't', 'r', 'i', 'n', 'g')

# 元组的拷贝
In [15]: t * 3
Out[15]: (3, 4, 5, 'a', 'b', 3, 4, 5, 'a', 'b', 3, 4, 5, 'a', 'b')

# 元组拆包
In [16]: t = (4,5,6)
In [17]: a,b,c = t
In [18]: t[2]
Out[18]: 6
# 元组拆包：嵌套元素
In [19]: t = 4,5,(6,7)
In [20]: a,b,(c,d) = t
In [21]: c
Out[21]: 6

# 拆包的应用：遍历
In [22]: seq = [(1,2,3),(4,5,6),(7,8,9)]
In [23]: seq
Out[23]: [(1, 2, 3), (4, 5, 6), (7, 8, 9)]
In [24]: for a,b,c in seq:
...:     print('a={0},b={1},c={2}'.format(a,b,c))
...:
a=1,b=2,c=3
a=4,b=5,c=6
a=7,b=8,c=9

# 拆包的应用：获取任意长度位置的参数列表
In [25]: values = 1,2,3,4,5
In [26]: a,b,*rest = values
In [27]: rest
Out[27]: [3, 4, 5]

列表

列表创建后可以随意被修改
列表中各元素类型可以不同，无长度限制

# 创建列表
In [34]: ls1 = [1,2,3,None]
In [35]: ls2 = list((2,3,4))
In [36]: ls2
Out[36]: [2, 3, 4]

In [37]: ls3 = list(range(6))
In [38]: ls3
Out[38]: [0, 1, 2, 3, 4, 5]

# 修改列表元素
In [39]: ls3[2] = 'a'
In [40]: ls3
Out[40]: [0, 1, 'a', 3, 4, 5]

In [26]: list1 = [1,9,4,6,3,2,8]
In [27]: list1[2:5] = [12]   # 注意
In [28]: list1
Out[28]: [1, 9, 12, 2, 8]

# 拓展：如果使用numpy
In [32]: import numpy as np
In [33]: a = np.array([1,2,344,21])
In [34]: a
Out[34]: array([  1,   2, 344,  21])
In [35]: a[1:3] = 3
In [36]: a
Out[36]: array([ 1,  3,  3, 21])

# 增加或移除元素
In [42]: ls4.append(9)
In [43]: ls4
Out[43]: [1, 2, 3, 4, 9]

In [44]: ls4.insert(2,'a')
In [45]: ls4
Out[45]: [1, 2, 'a', 3, 4, 9]

In [46]: ls4.pop(2)
Out[46]: 'a'
In [47]: ls4
Out[47]: [1, 2, 3, 4, 9]

In [48]: ls4.remove(4)
In [49]: ls4
Out[49]: [1, 2, 3, 9]

# 连接和联合列表
In [50]: a = [1,2,3,4]
In [51]: b = ['a','b',6]
In [52]: a + b
Out[52]: [1, 2, 3, 4, 'a', 'b', 6]

In [53]: a.extend([9,8,7])
In [54]: a
Out[54]: [1, 2, 3, 4, 9, 8, 7]

# 排序
In [55]: a.sort()
In [56]: a
Out[56]: [1, 2, 3, 4, 7, 8, 9]

# 规定排序方法
In [57]: b = ['tom','mary','me','ross']
In [58]: b.sort(key = len)
In [59]: b
Out[59]: ['me', 'tom', 'mary', 'ross']

# 二分搜索和已排序列表的维护
# bisect.bisect()：找到元素应当被插入的位置，并保持序列排序
# bisect.insort()：将元素插入到相应位置
In [60]: import bisect
In [61]: c = [1,2,2,2,3,4,7]
In [62]: bisect.bisect(c,2)
Out[62]: 4
In [63]: bisect.bisect(c,6)
Out[63]: 6

In [64]: bisect.insort(c,6)
In [65]: c
Out[65]: [1, 2, 2, 2, 3, 4, 6, 7]

字典

字典类型是“映射”的体现，字典是键值对的集合，键值对之间无序

# 创建字典
In [66]: d1 = {'a':1,'b':2,'c':[1,2,3]}
In [67]: d1
Out[67]: {'a': 1, 'b': 2, 'c': [1, 2, 3]}

# **从字典推导式创建字典**
In [4]: strings = ['a','b','ab','cdf']
In [5]: dict = {key:value for key,value in enumerate(strings)}
In [6]: dict
Out[6]: {0: 'a', 1: 'b', 2: 'ab', 3: 'cdf'}

# 使用zip函数创建字典：字典本质上是2-元组（含有2个元素的元组）的集合
In [10]: m = dict(zip(range(4),reversed(range(4))))
In [11]: m
Out[11]: {0: 3, 1: 2, 2: 1, 3: 0}

# 拓展：zip函数：将序列元素配对，新建一个元组构成的列表
In [1]: a = ['tom','mary','ross','amy']
In [2]: b = [1,2,3,4]
In [3]: c = [True,True,False]
In [4]: d = zip(a,b,c)
In [5]: d
Out[5]: <zip at 0x233efc76208>
In [6]: list(d)
Out[6]: [('tom', 1, True), ('mary', 2, True), ('ross', 3, False)]

# 访问元素
In [68]: d1[7] = 'tom'
In [69]: d1
Out[69]: {'a': 1, 'b': 2, 'c': [1, 2, 3], 7: 'tom'}

In [70]: d1['b']
Out[70]: 2

In [71]: 'b' in d1
Out[71]: True

In [72]: del d1['b']
In [73]: d1
Out[73]: {'a': 1, 'c': [1, 2, 3], 7: 'tom'}

In [74]: d1.pop(7)
Out[74]: 'tom'
In [75]: d1
Out[75]: {'a': 1, 'c': [1, 2, 3]}

# 获取键、值的迭代器
In [76]: d1.keys()
Out[76]: dict_keys(['a', 'c'])
In [77]: list(d1.keys())
Out[77]: ['a', 'c']

In [78]: list(d1.values())
Out[78]: [1, [1, 2, 3]]

In [81]: d1.items()
Out[81]: dict_items([('a', 1), ('c', 'mary'), (9, 'ross')])

# 合并字典，注意如果新字典中存在原字典中已存在的键，则原值被覆盖
In [79]: d1.update({'c':'mary',9:'ross'})
In [80]: d1
Out[80]: {'a': 1, 'c': 'mary', 9: 'ross'}

# 随机取出一个键值对，以元组形式返回
In [82]: d1.popitem()
Out[82]: (9, 'ross')

# d.get(k, <default>)若键k存在，则返回相应值，否则返回默认值
In [83]: d1.get(2,'not exist')
Out[83]: 'not exist'
# d.pop(k, <default>)若键k存在，则取出相应值，否则返回默认值
In [84]: d1.pop('a','ok')
Out[84]: 1
In [85]: len(d1)
Out[85]: 1

集合

元素之间无序，元素唯一，集合元素不可更改
建立空集合类型，必须使用set()

# 创建集合
In [87]: a = set([2,2,2,1,3,3])
In [88]: a
Out[88]: {1, 2, 3}

# 集合操作：|：或   - ：差   &：与    ^：异或  <=,<：判断子集关系  >=,>：判断包含关系
# 返回一个新集合
In [89]: b = {7,8,9,6}
In [90]: a.union(b)
Out[90]: {1, 2, 3, 6, 7, 8, 9}
In [92]: a | b
Out[92]: {1, 2, 3, 6, 7, 8, 9}

# 增强操作符：|=：或   -=：差  &=：与  ^=：异或
# 更新操作符左边的集合
In [93]: i = {1,2,3,4,5}
In [94]: j = {2,3,7,8}
In [95]: i |= j
In [96]: i
Out[96]: {1, 2, 3, 4, 5, 7, 8}

# 查看一个集合是否是另一个集合的子集（包含于）或超集（包含）
In [99]: a = {1,2,3,4,5}
In [100]: {1,2}.issubset(a)
Out[100]: True

In [101]: {1,2}.issuperset({1,2})
Out[101]: True

# 集合处理方法
In [102]: s = {1,2,3}
In [103]: s.add(9)
In [104]: s
Out[104]: {1, 2, 3, 9}

In [105]: s.discard(3)
In [106]: s
Out[106]: {1, 2, 9}

# 随机返回集合中的一个元素
In [108]: s.pop()
Out[108]: 1

In [109]: s.copy()
Out[109]: {2, 9}

In [110]: len(s)
Out[110]: 2

In [111]: 2 in s
Out[111]: True

集合s：s.pop() 随机返回一个元素，并删除此元素，更新集合
列表l：l.pop(i) 将位置i的元素取出并删除
字典d：d.pop(k, default) 若键存在，则取出并删除，若不存在返回默认值；d.popitem() 随机取出一个键值对，返回并删除