字符串及其操作02

列表、字符串及其一些简单操作

列表

  • 一种数据结构
  • 列表是一个序列,用于顺序的存储数据
  • 序列是Python中最基本的数据结构 序列中的每个元素都分配一个数字–它的位置或索引,第一个是0,第二个是1,以此类推


1
2
3
4
5
6
7
8
l = list()
# 使用list函数定义空列表
l = []
# 使用中括号定义空列表
l = [1, 2, 3]
# 使用中括号定义带初始值的列表
l = list(rang(1, 10))
# 使用list函数把可迭代对象转化为列表

增删改查

查询(访问列表)

1
2
3
4
5
6
7
8
lst = list(range(1, 10))
lst
[1, 2, 3, 4, 5, 6, 7, 8, 9]
lst[0]
1
lst[-1]
9
# 当索引为负数的时候,是从右边开始数的,并且索引从-1开始计算

index

1
2
3
4
5
6
7
8
9
10
11
l = ['a', 'b', 'c', 'd', 'e']
l
['a', 'b', 'c', 'd', 'e']
l.index('a')
# index 方法根据值返回第一个索引
0
l.index('a', 0, 4)
0
# 从索引的第0位开始到第4位找 a的索引位置
l.index('a', 2)
# 从第2个索引位置开始,到最后一个位置结束找 'a'的索引位置

count

1
2
3
l.count('a')
1
# count 方法返回元素在列表里的个数

修改

1
2
3
4
5
l[2]
3
l[2] = 'ch'
l[2]
'ch'

增加

append

1
2
3
4
5
l = list(range(1, 10))
l.append('python')
l
[1, 2, 3, 4, 5, 6, 7, 8, 9, 'python']
# 追加, append 是原地修改list, 返回值是None

insert

1
2
3
4
5
6
7
8
9
l.insert(1, 'ch')
# 在索引1位之前插入'ch'
l
[1, 'ch', 2, 3, 4, 5, 6, 7, 8, 9, 'python']
l.insert(100,'error')
l.insert(-100,'error')
l
['error', 1, 'ch', 2, 3, 4, 5, 6, 7, 8, 9, 'python', 'error']
# list.insert 方法,当越界的时候,自动往最左或最右插入该值

  • append操作单个元素,只需要追加一个元素到列表的最后,无需关心列表本身,因此他的时间复杂度是O(1)
  • insert操作单个元素,但是需要遍历整个列表,时间复杂度是O(n)

extend

1
2
3
4
5
6
7
8
l = ['a', 'a']
l.append(['b','b2'])
l
['a', 'a', ['b', 'b2']]
l.extend(['c','c2'])
# 将可迭代对象丢进去,然后依次进行遍历
l
['a', 'a', ['b', 'b2'], 'c', 'c2']

1
2
3
4
5
6
7
8
l.clear()
l = [1, 2]
l + ['ch']
[1, 2, 'ch']
# 对list进行相加的操作的时候,返回的结果是相加后的结果,但是list本身不会被修改
new_1 = l + ['ch']
new_l
[1, 2, 'ch']

删除

remove

1
2
3
4
5
6
l = list(range(1, 10))
l.remove(4)
# remove 返回值None,原地修改list
# 删除顺序是从左往右依次删除第一个匹配到的值
l
[1, 2, 3, 4, 6, 7, 8, 9]

pop

1
2
3
4
5
6
7
8
l = list(range(1, 10))
l
[1, 2, 3, 4, 5, 6, 7, 8, 9]
l.pop()
9
# 删除最后一个元素,不传递index参数的时候,时间复杂度是O(1)
# 传递index参数的时候,时间复杂度是O(n)
# pop 删除元素,并返回该元素

clear

1
2
3
4
l = list(range(1, 10))
l.clear()
l
[]

其他操作

len

1
2
3
4
l = list(range(1, 10))
len(l)
9
# len 用来计算list的长度

reverse

1
2
3
4
5
l = list(range(1, 10))
l.reverse()
# 反转列表,返回None,原地修改列表
l
[10, 9, 8, 7, 6, 5, 4, 3, 2, 1]

sort

1
2
3
4
5
6
7
8
9
l = [2, 1, 5, 6, 7, 3, 8]
l.sort()
# 对列表进行排序,原地修改列表,返回None
l
[1, 2, 3, 5, 6, 7, 8]
l.sort(reverse=True)
# 带参数可以直接进行反转
l
[8, 7, 6, 5, 3, 2, 1]

list拷贝

浅拷贝

1
2
3
4
5
6
7
8
l = list(range(1, 10))
l2 = l
l2[2] = 'ch'
l2
[1, 2, 'ch', 4, 5, 6, 7, 8, 9]
l
[1, 2, 'ch', 4, 5, 6, 7, 8, 9]
# 赋值操作时引用传递,也叫浅复制

影子拷贝

1
2
3
4
5
6
7
l = list(range(1, 10))
l3 = l.copy()
l3[2] = 'test'
l3
[1, 2, 'test', 4, 5, 6, 7, 8, 9]
l
[1, 2, 3, 4, 5, 6, 7, 8, 9]

但是还有一种情况,影子拷贝不适用

1
2
3
4
5
6
7
l = [1, [2, 3], 4]
l4 = l.copy()
l4[1][0] = 'ch'
l4
[1, ['ch', 3], 4]
l
[1, ['ch', 3], 4]

深拷贝

1
2
3
4
5
6
7
8
9
10
import copy
# 引入copy模块,进行深拷贝
l = [1, [2, 3], 4]
l5 = copy.deepcopy(l)
l5[1][0] = 'test'
l5
[1, ['test', 3], 4]
l
[1, [2, 3], 4]

字符串及其操作


定义

1
2
3
4
5
6
7
8
9
10
11
s = 'hello world'
s = "papapa"
# 一个单/双引号只能定义单行字符串
s = '''
这里我想要表达的是
miracle young 老师真棒
真的厉害
很满意
'''
# 三引号可以定义多行字符串

转义符

下标操作

1
2
3
4
5
s = 'test python'
s[1]
'e'
s[1] = 'h'
# 字符串是不可变的

目前只有list是可变的,其他都是不可变的

字符串是迭代器,是可迭代对象

1
2
3
4
5
6
7
8
9
10
11
12
13
for c in s:
print(c)
t
e
s
t
p
y
t
h
o
n

字符串的操作

join

1
2
3
4
l = 'i am chenhao'
' '.join(l)
'i a m c h e n h a o'
# join将传入的可迭代对象进行拼接,拼接的间隔符号由前面的字符串决定。返回拼接结果,拼接源对象并不会被修改。

分割

split

1
2
3
4
5
6
7
l = 'i am chenhao'
l.split()
['i', 'am', 'chenhao']
# split 默认使用空格进行切割,当传入参数后,按照参数的形式作为切割符号,参数可以是任意字符串。
l.split(maxsplit=1)
['i', 'am chenhao']
# 最大切割只为1次

rsplit
跟split一样,只是从右往左进行切割

splitlines

1
2
3
4
5
6
7
s = '''
i am miracleYoung
i love my wife
'''
s.splitlines()
['i am miracleYoung', 'i love my wife']
# 按行分割,并且默认返回结果不带换行符,是一个list对象

partition

1
2
3
4
5
6
'i am miracle young'.partition(' ')
('i', ' ', 'am miracle young')
# 总是返回一个三元组,(由3个元素构成的元组),
# 按照传入的分隔符分割一次,得到head,tail,返回结果是head,sep,tail
'i am miracle young'.rpartition(' ')
# 从右往左匹配开始分隔

大小写转换

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
s = 'tEsT'
s.upper()
'TEST'
# 返回一个大写的对象,并且不修改原对象
s.lower()
'test'
# 返回一个小写的对象,并且不修改原对象
s.casefold()
'test'
# 忽略大小写,默认为小写
s.swapcase()
'TeSt'
# 大小写互换

排版

1
2
3
4
5
6
7
8
9
10
11
s = 'i am TesT UnIVersity'
s.title()
'I Am Test University'
# 对每一个空格开头的首字母大写,其他字母一律小写
s.capitalize()
'I am test university'
# 对第一个首字母大写
s.center(100)
# 填充字符

修改

replace

1
2
3
4
5
6
7
8
9
10
s = 'i love miracle young'
s.replace('love', 'give up')
# replace 返回一个新的字符串,使用new 替换old
'i give up miracle young'
ss = 'i am very very very love miracle young'
ss.replace('very', 'not')
# replace 默认有多少替换多少
'i am not not not love miracle young'
ss.replace('very', 'not', 2)
'i am not not very love miracle young'

strip

1
2
3
4
5
6
7
8
9
10
s = ' hahah hahah '
s.strip()
'hahah hahah'
# strip 返回移出后的字符串,并且不对原字符串进行修改
s.lstrip()
'hahah hahah '
# lstrip 只移出左边的
s.rstrip()
' hahah hahah'
# rstrip 只移出右边的

ljust

1
2
3
4
5
6
7
8
9
10
s = 'test'
s.ljust(10, "#")
'test######'
# 从左边进行补位
s.rjust(10, '#')
'######test'
# 从右边进行补位
'Mysql begin to install ...'.center(100, '#')
'#####################################Mysql begin to install ...#####################################'

查找

find

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
s = 'i love ch'
s.find('lve')
-1
# 查找不到的不会报错,-1
s = 'i very very love python'
s.find('very')
2
s.find('very', 3)
7
s.rfind('very', 6)
# 从右边开始找
7
s.rfind('very', 0, 11)
7

index

1
2
3
4
5
6
7
8
s = 'i very very love python'
s.index('very')
2
s.index('very', 0, 11)
2
s.index('very', 4, 7)
# index如果找到不到的话会返回一个ValueError
s.rindex('very')

count

1
2
3
4
5
6
s.count('v')
3
s
'i very very love python'
s.count('v', 3, 8)
1

startswith

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
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
s = 'i very very love python'
list(enumerate(s))
# enumerate ,解构,定义每一个索引的位置对应的字符
[(0, 'i'),
(1, ' '),
(2, 'v'),
(3, 'e'),
(4, 'r'),
(5, 'y'),
(6, ' '),
(7, 'v'),
(8, 'e'),
(9, 'r'),
(10, 'y'),
(11, ' '),
(12, 'l'),
(13, 'o'),
(14, 'v'),
(15, 'e'),
(16, ' '),
(17, 'p'),
(18, 'y'),
(19, 't'),
(20, 'h'),
(21, 'o'),
(22, 'n')]
s.startswith('i')
True
s.startswith('v')
False
s.startswith('v', 2, 7)
True
s.endswith('n')
True
s.isalnum()
# 是否有空格
False
s.replace(' ','').isalnum()
True
s.isdecimal()
# 是否只有数字
False
s.replace(' ', '_').isidentifier()
True
'a_1'.isidentifier()
# 包含字母,数字,下划线,即可,开头不能为数字,用于检测密码复杂度
True
s.istitle()
# 首字母是否大写
False
s.islower()
# 是否全部为小写
True

火柴 wechat
扫描上方二维码关注我的博客!
0%