字符串及其操作02

内容简介：字符串及其操作02

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

列表

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

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

增删改查

查询（访问列表）

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

index

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

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

修改

l[2]
3
l[2] = 'ch'
l[2]
'ch'

增加

append

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

insert

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

l = ['a', 'a']
l.append(['b','b2'])
l
['a', 'a', ['b', 'b2']]
l.extend(['c','c2'])
# 将可迭代对象丢进去，然后依次进行遍历
l
['a', 'a', ['b', 'b2'], 'c', 'c2']

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

删除

remove

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

pop

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

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

其他操作

len

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

reverse

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

sort

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拷贝

浅拷贝

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]
# 赋值操作时引用传递，也叫浅复制

影子拷贝

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]

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

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

深拷贝

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]

字符串及其操作

定义

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

转义符

下标操作

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

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

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

for c in s:
     print(c)
t
e
s
t
 
p
y
t
h
o
n

字符串的操作

join

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

分割

split

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

rsplit

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

splitlines

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

partition

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

大小写转换

s = 'tEsT'
s.upper() 
'TEST'
# 返回一个大写的对象，并且不修改原对象

s.lower()
'test'
# 返回一个小写的对象，并且不修改原对象

s.casefold()
'test'
# 忽略大小写，默认为小写

s.swapcase()
'TeSt'
# 大小写互换

排版

s = 'i am TesT UnIVersity'
s.title()
'I Am Test University'
# 对每一个空格开头的首字母大写，其他字母一律小写

s.capitalize()
'I am test university'
# 对第一个首字母大写

s.center(100)
# 填充字符

修改

replace

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

s = ' hahah hahah '
s.strip()
'hahah hahah'
# strip 返回移出后的字符串，并且不对原字符串进行修改
s.lstrip()
'hahah hahah '
# lstrip 只移出左边的
s.rstrip()
' hahah hahah'
# rstrip 只移出右边的

ljust

s = 'test'
s.ljust(10, "#")
'test######'
# 从左边进行补位
s.rjust(10, '#')
'######test'
# 从右边进行补位

'Mysql begin to install ...'.center(100, '#')
'#####################################Mysql begin to install ...#####################################'

查找

find

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

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

s.count('v')
3
s
'i very very love python'
s.count('v', 3, 8)
1

startswith

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

以上所述就是小编给大家介绍的《字符串及其操作02》，希望对大家有所帮助，如果大家有任何疑问请给我留言，小编会及时回复大家的。在此也非常感谢大家对 码农网 的支持！

查看所有标签

猜你喜欢:

• 查找一个字符串中最长不含重复字符的子字符串，计算该最长子字符串的长度
• 字符串、字符处理总结
• 高频算法面试题（字符串）leetcode 387. 字符串中的第一个唯一字符
• php删除字符串最后一个字符
• （三）C语言之字符串与字符串函数
• 算法笔记字符串处理问题H：编排字符串（2064）

本站部分资源来源于网络，本站转载出于传递更多信息之目的，版权归原作者或者来源机构所有，如转载稿涉及版权问题，请联系我们。