python列表和元组的数据结构_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 [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 [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, )若键k存在，则返回相应值，否则返回默认值

In [83]: d1.get(2,'not exist')

Out[83]: 'not exist'

# d.pop*k, )若键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