关于序列

  • 序列：有顺序的元素排列；第一个元素的索引为0
  • 列表list，元组tuple，字符串str都属于序列；但一般情况下，只有list可修改，后二者不可修改

一、序列通用操作

1、索引–访问元素里的单个元素

  • indexing
  • 第一个元素的索引为0；
  • 倒数第n个元素的索引为-n
1
2
3
4

greet = 'Hello'
greet[0]
greet[-1]
'Hello'[0]

2、切片–访问某个范围的多个元素

  • slicing
  • 需要提供两个索引指定范围的边界。
  • 第一个索引是起始点的编号，第二个索引是边界终点的编号**+1**
1
2
3
4
5
6
7
8
9

numbers = [1,2,3,4,5,6,7,8,9,10]
numbers[1:3]
# [2, 3]
numbers[-5:-3]
# [6, 7]

numbers[3:] 
numbers[:9]
numbers[:]

3、序列相加/相乘

1
2
3
4
5

# 序列相加（连接）
[1,2,3] + [4,5,6]

# 序列相乘
'hello' * 3

4、确认是否包含某元素

1
2
3
4
5

'A' in 'ABC'
# True

'li' in ['li', 'wang','zhou']
# True

5、补充：关于set集合

  • 集合set内没有重复元素，且没有顺序，所以本质上不属于序列；
  • 可使用set()函数创建集合，或者使用{}创建；
  • 主要用于成员资格检查（类似上面的第4点），以及集合的交、并、补等操作
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

##创建集合
set(range(5))
# {0, 1, 2, 3, 4}
{4,6,1,9,0}
# {0, 1, 4, 6, 9}

##成员资格检查
0 in {4,6,1,9,0}
# True

##集合操作
a = {1,2,3}
b = {1,2,4}
c = {1,2}
###(1)交集
a.intersection(b)
a & b
# {1, 2}
###(2)是否子集
c.issubset(a)
c <= a
# True
###(3)差集
a.difference(b)
a-b
# {3}
###(4)全集
a.union(b)
a | b
# {1, 2, 3, 4}

二、列表的特有操作

1、利用索引与切片直接修改列表

  • 索引
1
2

x = [1,2,3]
x[1] = 1
  • 切片
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

#由于字符串不能修改，需要先将字符串转为列表
names = list('python')
names[1:3] = list('YT')

#由于赋值的字符串的长度可以与被修改的字符串长度不同，所以可以引申用法
## 变相的插入
names = list('python')
names[1:1] = list('AAA')
## 变相的删除
names = list('python')
names[1:3] = []

2、列表的方法–增删改查

  • 增
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

# (1) append: 增加元素到末尾
numbers = [1, 2, 3]
numbers.append(4)
##原地修改，无返回值

# (2) extend: 增加列表里的元素到末尾
numbers = [1, 2, 3]
numbers.extend([4, 5, 6])
##原地修改，无返回值

# (3) insert: 在指定索引位置插入元素
numbers = [1, 2, 3]
numbers.insert(2, "four")
# [1, 2, 'four', 3]
##原地修改，无返回值
  • 删
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

# (1) pop: 删除最后一个元素
numbers = [1, 2, 3]
numbers.pop()
##原地修改，并返回被删除的值

# (2) remove: 删除指定元素的值
numbers = [1, 2, 3]
numbers.remove(1)
# [2, 3]
##原地修改，无返回值

# 关于list列表的删除操作，有一个函数`del`支持根据索引删除元素
numbers = [1, 2, 3]
del numbers[1]
# [1, 3]
  • 改
1
2
3
4
5
6
7
8
9

# (1) reverse: 逆转当前列表元素的顺序
numbers = [1, 2, 3]
numbers.reverse()
##原地修改，无返回值

# (2) sort: 顺序排列当前列表的元素, 默认升序排列
numbers = [2, 1, 3]
numbers.sort()
numbers.sort(reverse=True)
  • 查
1
2
3
4
5
6
7

# (1) count: 查看某一元素的频率
numbers = [1, 2, 2, 3, 3, 3]
numbers.count(2)

# (2) index: 查看某一元素值的索引
numbers = [1, 2, 3]
numbers.index(2)

3、filter()搭配lamda列表筛选

filter()函数包含如下两个参数

  • 第一个参数是函数：以列表的元素作为逐一遍历，返回一一对应的逻辑值True/False
  • 第二个参数是想要筛选的目标列表
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

## 示例1
def is_odd(n):   #判断是否为奇数
    return n % 2 == 1 
 
list(filter(is_odd, [1, 2, 3, 4, 5]))
# [1, 3, 5]

## 示例2
import re
data_list = ['cat_1', 'dog_1', 'dog_2', 'cat_2', 'dog_3', 'cat_3']
list(filter(lambda x: re.match('dog.*', x) != None, data_list))
# ['dog_1', 'dog_2', 'dog_3']

三、元组的特有操作

  • 创建元组
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

#创建3个元素的元组
(1, 2, 3)

#创建1个元素的元组
(1,)

#创建空元组
()

#将列表转为元组
tuple([1,2,3])

四、字符串操作

字符串本身也是一种序列，且不可修改

1、字符串格式化

  • %百分号
1
2
3
4
5
6
7

test = 'Hello, %s!'
test % 'Li'
# 'Hello, Li!'

test_num = '%s price is %.2f'
test_num % ('Tomato', 3.23333)
# 'Tomato price is 3.23'
  • format方法：{}花括号
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

test = 'Hello, {} and {}'
test.format('Li', 'Wang')
# 'Hello, Li and Wang'

##可以指定顺序
'Hello, {2} , {0} and {1}'.format("Li","Wang","Sun")
# 'Hello, Sun , Li and Wang'

##可以通过关键字参数调整顺序
'{something} price is {price:.2f}'.format(something='Tomato', price=3.23333)
# 'Tomato price is 3.23'
  • f关键字
1
2
3
4
5

name  = "Li"
time = "Morning"

f"Good {time}, Mr.{name}"
# 'Good Morning, Mr.Li'

2、字符串常用方法

  • 替换
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

# (1) replace: 全部替换
'This is a test'.replace('is', 'eez')

# (2) translate: 一一对应替换
table = str.maketrans('ATCG','TAGC')
'ATTCCCGGGG'.translate(table)
## 'TAAGGGCCCC'

table = str.maketrans('ATCG','TAGC','N') #第3个参数表示删除字符
'ANTTNCCCNGGGG'.translate(table)
## 'TAAGGGCCCC'
  • 序列与字符串的转换
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

# (1) join: 将列表转为字符串
''.join(["A","B","C"]) 
## 'ABC'
','.join(["A","B","C"]) 
## 'A,B,C'

# (2) split: 将字符串转为列表
'1+2+3+4'.split('+')
## ['1', '2', '3', '4']
'1 2 3 4'.split() #默认为空格为分隔符
## ['1', '2', '3', '4']
  • 字符串两端的修剪
1
2
3
4
5
6

# (1) strip: 去除字符串两端的空格或者其它字符
' ABC   '.strip()
'* ABC !'.strip(' *!')

# (2) center: 在字符串两端添加空格或者其它字符至指定的长度
'ABC'.center(10,'*')
  • 子串的定位
1
2
3

# find: 返回子串的第一个索引。若没有找到，则返回 -1
'This is a test'.find('is')
## 2
  • 大小写转换
1
2
3
4
5

'ABC'.lower()
## 'abc'

'abc'.upper()
## 'ABC'

五、字典

  • 字典dictionary就是键值对（键-key与值-value一一对应）
  • 字典是无序的，不属于上述所说的序列
  • 字典的键不能重复

1、创建字典

1
2
3
4
5
6
7
8

# (1) 直接创建
test = {"A":1, "B":2, "C":3}

# (2) 向dict()函数提供包含键值对信息的列表嵌套元组/列表
test = dict([("A", 1), ("B", 2), ("C", 3)])

# (3) 使用dict()函数的关键字实参
test = dict(A=1, B=2, C=3)

2、适用字典的序列操作

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

test = dict(A=1, B=2, C=3)
# (1) 长度
len(test)

# (2) 查看某个键的值
test["A"]

# (3) 修改某个键的值
test["A"] = 0

# (4) 新增键值对
test["D"] = 4

# (5) 删除键值对
del test["A"]

# (6) 查看字典里是否包含某一个键
"A" in test
"B" in test

# (7) 字符串的format_map方法即使用字典对字符串进行格式化操作
test = dict(A=1, B=2, C=3)
'This is just {A}{B}{C}, not {C}{B}{A}'.format_map(test)

3、字典的方法

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

test = dict(A=1, B=2, C=3)
# (1) items 键值对字典视图,可通过list函数转为列表
test.items()
list(test.items())

# (2) keys 键的字典视图,可通过list函数转为列表
test.keys()
list(test.keys())

# (3) values 值的字典视图,可通过list函数转为列表
test.values()
list(test.values())

# (4) get 查找字典里某一个键的值，如果没有不会报错
test = dict(A=1, B=2, C=3)
test.get('A')
test.get('D')  #返回空值
test.get('D', "N/A") #返回指定值

# (5) pop 在键值对取出指定键值对
test = dict(A=1, B=2, C=3)
a = test.pop('A')
a
# 1
test
# {'B': 2, 'C': 3}

# (6) updata 合并两个字典为一个字典
dict1 = {'a': 10, 'b': 8} 
dict2 = {'d': 6, 'c': 4} 
dict2.update(dict1, ) #原地修改，无返回值
dict2
# {'d': 6, 'c': 4, 'a': 10, 'b': 8}