python - 数据结构

Posted 2021-03-11 小虫虫的大梦想

数据结构（Data Structures）人如其名，只是一种结构，能够将一些数据聚合在一起。换句话说，它们是用来存储一系列相关数据的集合。python中有四种内置的数据结构：

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

另外，讲解以下三部分内容：

• 序列
• 引用
• 字符串的常用方法

1. 列表

列表：用于保存一系列有序项目的集合。语法：用方括号括起来，中间用逗号隔开。如：

shoppinglist = [‘apple‘, ‘orange‘, ‘banana‘]

可以向列表中添加任何类型的对象，包括字符串、数字，甚至可以是其他列表

列表也是一个序列 

可对列表中的项目进行增删改查，所以说列表是一种可变的数据类型
 1 shoppinglist = [‘apple‘, ‘orange‘, ‘banana‘]
 2 
 3 print(shoppinglist)  # 打印整个列表
 4 
 5 for list1 in shoppinglist:  # 打印列表中的元素
 6     print(list1)
 7 
 8 shoppinglist.append(‘pear‘)  # 向列表后追加元素
 9 shoppinglist[0] = ‘aaa‘      # 修改列表中的第一个元素的值为aaa
10 shoppinglist.remove(shoppinglist[0])   # 删除列表中的第一个元素
11 del shoppinglist[0]                    # 方法二：删除列表中的第一个元素
12 
13 first_one = shoppinglist[0]  # 取出列表中的第一个元素
14 len(shoppinglist)    # 列表的长度（列表中元素的个数）
15 shoppinglist.sort()  # 排序，影响的是列表本身（与修改字符串的方式不同）（列表是可变的，字符串是不可变的）

资格测试
1 mylist = [‘apple‘, ‘orange‘, ‘banana‘]
2 
3 if ‘apple‘ in mylist:   # 判断apple是否在mylist中
4     print(‘yes‘)
5 else:
6     print(‘no‘)

 

2. 元组

用于将多个对象保存在一起。语法：用圆括号括起来，中间用逗号隔开。如：

zoo = (‘apple‘, ‘orange‘, ‘banana‘)

元组也是一个序列

 元组可以近似的看做一个列表，但元组不可改变。
1 zoo = (‘apple‘, ‘orange‘, ‘banana‘)
 2 
 3 print(zoo)       # 打印元组(‘apple‘, ‘orange‘, ‘banana‘)
 4 
 5 for i in zoo:    # 打印元组中的元素 apple  orange  banana
 6     print(i)
 7 
 8 print(len(zoo))  # 打印元组的长度 3
 9 
10 new_zoo = (‘pear‘, ‘mongo‘, zoo)
11 
12 # 元组中所包含的元组，不会失去其所拥有的身份
13 print(new_zoo)        # 打印新的元组 (‘pear‘, ‘mongo‘, (‘apple‘, ‘orange‘, ‘banana‘))
14 print(new_zoo[1])     # 方括号[]，索引运算符  mongo
15 print(new_zoo[2])     # (‘apple‘, ‘orange‘, ‘banana‘)
16 print(new_zoo[2][2])  # banana
17 print(len(new_zoo))   # 3
18 
19 # 空元组
20 myempty = ()
21 print(myempty)  # ()
22 
23 # 包含一个元素的元组
24 single = (2,)   # 必须在项目后面加上一个逗号来指定它，这样python才可以识别出这个表达式想表达的是元组还是对象
25 print(single)   # (2,)

 

3. 字典

键值对（key-value）结构。语法：用一对大括号括起来，键与值之间用冒号分隔，每一个键值对之间用逗号分隔。如：

ab = {‘zhangsan‘:‘[e-mail]‘,
      ‘lisi‘:‘[e-mail]‘,
      ‘wangmazi‘:‘[e-mail]‘}

键必须唯一，且不可变。值可以变。字典不能排序。

可以给字典添加键值对，删除键值对，修改键的值内容。是可变的数据类型。
1 ab = {‘zhangsan‘:‘[e-mail]‘,
 2       ‘lisi‘:‘[e-mail]‘,
 3       ‘wangmazi‘:‘[e-mail]‘}
 4 
 5 print(ab)                        # 打印整个字典
 6 
 7 print(ab[‘zhangsan‘])            # 打印字典中的某个元素（某个键的值）（用索引运算符，找到某个键对应的值）
 8 
 9 for key, value in ab.items():    # 打印字典中的所有元素（所有键值对）
10     print(key, value)
11 
12 ab[‘wangmazi‘] = ‘[e-mail]‘  # 修改键名为wangmazi的值
13 ab[‘wangwu‘] = ‘wangwu.126.com‘      # 添加一个键值对
14 del ab[‘wangwu‘]                     # 删除字典中键为wangwu的键值对
15 
16 print(len(ab))                       # 打印字典的长度（键值对的数量）
17 if ‘wangmazi‘ in ab:                 # 若字典中存在键名为wangmazi的键，则打印出它的值
18     print(ab[‘wangmazi‘])

 ps：

print(ab.items())  # dict_items([(‘zhangsan‘, ‘[e-mail]‘), (‘lisi‘, ‘[e-mail]‘), (‘wangmazi‘, ‘[e-mail]‘)])

ab.items()返回一个包含元组的列表。每一个元组中包含一个键值对。用for循环打印时，将每一个配对信息分配给key和value变量　　

 

4. 集合

 简单对象的无序集合。语法：set([列表])。如：

bri = set([‘apple‘, ‘orange‘, ‘banana‘])

当集合中的元素存在与否，比次序或出现次数更加重要时，使用集合。集合的作用：

• 测试某些元素的资格
• 检查是否是其他集合的子集
• 找到两个集合的交集等

 1 bri = set([‘apple‘, ‘orange‘, ‘banana‘])
 2 
 3 print(‘apple‘ in bri)   # True
 4 print(‘mongo‘ in bri)   # False
 5 
 6 bric = bri.copy()       # 复制一个集合
 7 
 8 bric.add(‘pear‘)        # 添加一个元素
 9 bric.remove(‘banana‘)   # 删除一个元素
10 
11 print(bric.issuperset(bri))   # bric是否是bri的父集ic
12 print(bric.issubset(bri))     # bric是否是bri的子集
13 print(bric & bri)             # 求交集
14 print(bric | bri)             # 求并集（无序）

 

关于序列、引用、字符串的常用方法：

1. 序列

序列的三种形态：列表、元组、字符串

序列的主要功能：

• 资格测试（也就是in与not in表达式）
• 索引操作

 下面主要讲解切片操作：

可以使用同样的的方式，访问列表、元组、字符串
 1 shoppinglist = [‘apple‘, ‘orange‘, ‘banana‘, ‘pear‘]
 2 name = ‘abcdefg‘
 3 
 4 # 索引或下标操作
 5 print(shoppinglist[0])   # apple
 6 print(shoppinglist[1])   # orange
 7 print(shoppinglist[2])   # banana
 8 print(shoppinglist[3])   # pear
 9 print(name[0])      # a
10 
11 print(shoppinglist[-1])  # pear  索引也可以使用负数，位置计数从末尾开始
12 print(shoppinglist[-2])  # banana
13 print(shoppinglist[-4])  # apple
14 print(name[-1])    # g
15 
16 # 切片操作
17 print(shoppinglist[1:3])    # [‘orange‘, ‘banana‘]   序列切片包括起始位置，不包括结束位置
18 print(shoppinglist[2:])     # [‘banana‘, ‘pear‘]
19 print(shoppinglist[:3])     # [‘apple‘, ‘orange‘, ‘banana‘]
20 print(shoppinglist[1:-1])   # [‘orange‘, ‘banana‘]
21 print(shoppinglist[:])      # [‘apple‘, ‘orange‘, ‘banana‘, ‘pear‘]
22 print(name[1:3])    # bc
23 
24 # 切片步长（默认为1）
25 print(shoppinglist[::1])    # [‘apple‘, ‘orange‘, ‘banana‘, ‘pear‘]
26 print(shoppinglist[::2])    # [‘apple‘, ‘banana‘]  步长为2时，得到0，2，4元素
27 print(shoppinglist[::3])    # [‘apple‘, ‘pear‘]    步长为3时，得到0,3元素
28 print(shoppinglist[::-1])   # [‘pear‘, ‘banana‘, ‘orange‘, ‘apple‘]
29 print(shoppinglist[::-2])   # [‘pear‘, ‘orange‘]
30 print(shoppinglist[0:3:2])  # [‘apple‘, ‘banana‘]

 

2. 引用

 如果你希望创建一个复杂对象（如：序列）的副本，必须使用切片操作。

直接赋值，指同一个对象
 1 shoppinglist = [‘apple‘, ‘orange‘, ‘banana‘]
 2 
 3 mylist = shoppinglist   # mylist只是shoppinglist的别名，它们指的是同一个对象
 4 
 5 print(shoppinglist)          # [‘apple‘, ‘orange‘, ‘banana‘]
 6 print(mylist)                # [‘apple‘, ‘orange‘, ‘banana‘]
 7 
 8 mylist.remove(mylist[0])     # 移除mylist中的第一个元素
 9 
10 print(shoppinglist)          # [‘orange‘, ‘banana‘]   （shoppinglist同时也少一个元素）  
11 print(mylist)                # [‘orange‘, ‘banana‘]

切片赋值，指向不同对象
1 shoppinglist = [‘apple‘, ‘orange‘, ‘banana‘]
 2 
 3 mylist = shoppinglist[:]   # 通过生成一份完整的切片，制作一份列表的副本，它们指的不是同一个对象
 4 
 5 print(shoppinglist)          # [‘apple‘, ‘orange‘, ‘banana‘]
 6 print(mylist)                # [‘apple‘, ‘orange‘, ‘banana‘]
 7 
 8 mylist.remove(mylist[0])     # 移除mylist中的第一个元素
 9 
10 print(shoppinglist)          # [‘apple‘, ‘orange‘, ‘banana‘]  （shoppinglist并无变化）
11 print(mylist)                # [‘orange‘, ‘banana‘]

简单对象可以直接赋值，指向不同对象
 1 a = 5
 2 b = a      # 指向不同对象
 3 
 4 print(a)   # 5
 5 print(b)   # 5
 6 
 7 b = 3
 8 
 9 print(a)   # 5
10 print(b)   # 3

 

3. 字符串的常用方法

 字符串都是str类下的对象，有自己的方法，可以检查字符串中的一部分或是去掉空格等很多事情

 1 mystring = ‘method‘
 2 
 3 if mystring.startswith(‘me‘):   # start()方法，查找字符串是否以指定内容开头
 4     print(‘ok‘)
 5 
 6 if mystring.find(‘th‘) != -1:   # find()方法，查找子字符串。找到返回2，找不到返回-1
 7     print(‘ok‘)
 8 
 9 if ‘t‘ in mystring:             # in 运算符，检查给定的字符串是否是查询字符串中的一部分
10     print(‘ok‘)
11 
12 delimeter = ‘_‘
13 mylist = [‘apple‘, ‘orange‘, ‘banana‘]
14 print(delimeter.join(mylist))     # join() 方法，连接序列中的元素 apple_orange_banana
15 print(delimeter.join(mystring))   # m_e_t_h_o_d