Python中的字符串的基本使用

字符串

  • 字符串的表示方式
  • 字符串的下标和切片
  • 字符串常见操作
  • 字符集和编码
  • 成员运算符
  • 字符串的format方法
1
2
3
4
5
a = "I'm Tom"  # 一对双引号 
b = 'Tom said:"I am Tom"' # 一对单引号
c = 'Tom said:"I\'m Tom"' # 转义字符
d = '''Tom said:"I'm Tom"''' # 三个单引号
e = """Tom said:"I'm Tom" """ # 三个双引号

小总结:

  • 双引号或者单引号中的数据,就是字符串
  • 如果使用一对引号来定义字符串,当出现符号冲突时可以使用转义字符
  • 使用三个单引号、双引号定义的字符串可以包裹任意文本

转义字符

使用\来表示一个转义字符

转义字符 含义
\r 将当前位置移到本行开头
\n 将当前位置移到下一行开头
\t 用来表示一个制表符
\ 代表一个反斜线字符\
' 用来显示一个单引号
" 用来显示一个双引号

下标和切片

下标/索引

  • 字符串的下标初始值为0,最后一个下角标的值为-1,依次往前往后即可。
  • 算字符串的长度用len(name)
1
2
name = 'abcdef'
name
'abcdef'
1
name[0]
'a'
1
name[-1]
'f'
1
len(name)
6
1
name[5]
'f'
1
name[4]
'e'

遍历

可用while和for进行字符串的遍历操作

1
2
for n in name:
print(n)
a
b
c
d
e
f
1
2
3
4
5
n = len(name)
i = 0
while i < n:
print(name[i])
i += 1
a
b
c
d
e
f

切片

切片是指对操作的对象截取其中一部分的操作。字符串、列表、元组都支持切片操作。

切片的语法:[起始:结束:步长],也可以简化使用 [起始:结束]

左闭右开

  • 索引是通过下标取某一个元素
  • 切片是通过下标去某一段元素
1
2
s = 'Hello World!'
s
'Hello World!'
1
s[4]
'o'
1
s[3:7]  # lo W 包含下标 3,不含下标 7
'lo W'
1
s[:] # Hello World! 取出所有元素(没有起始位和结束位之分),默认步长为1
'Hello World!'
1
s[1:] # ello World! 从下标为1开始,取出 后面所有的元素(没有结束位)
'ello World!'
1
s[:4] # Hell 从起始位置开始,取到 下标为4的前一个元素(不包括结束位本身)
'Hell'
1
s[:-1] # Hello World 从起始位置开始,取到 倒数第一个元素(不包括结束位本身)
'Hello World'
1
s[-4:-1] # rld 从倒数第4个元素开始,取到 倒数第1个元素(不包括结束位本身)
'rld'
1
s[1:5:2]  # el 从下标为1开始,取到下标为5的前一个元素,步长为2(不包括结束位本身)
'el'
1
s[7:2:-1]  # ow ol 从下标为7的元素开始(包含下标为7的元素),倒着取到下标为2的元素(不包括下标为2的元素) 
'oW ol'
1
s[::-1] # !dlroW olleH 从后向前,按步长为1进行取值
'!dlroW olleH'
1
s
'Hello World!'
1
s[::2] # 按步长2取出值
'HloWrd'
1
s[::-2] # 逆向按步长2取出值
'!lo le'

字符串常见操作

字符串的常见操作包括:

  • 获取长度:len
  • 查找内容:find,index,rfind,rindex
  • 判断:startswith,endswith,isalpha,isdigit,isalnum,isspace
  • 计算出现次数:count
  • 替换内容:replace
  • 切割字符串:split,rsplit,splitlines,partition,rpartition
  • 修改大小写:capitalize,title,upper,lower
  • 空格处理:ljust,rjust,center,lstrip,rstrip,strip
  • 字符串拼接:join

注意:
在Python中,字符串是不可变的!所有的字符串相关方法,都不会改变原有的字符串,都是返回一个结果,在这个新的返回值里,保留了执行后的结果!

len(str)

可以获取字符串的长度

1
2
mystr = '今天天气好冷啊,密密麻麻的乌云'
len(mystr)
15

查找

查找相关的方法,使用方式大致相同,但是略有区别。

1、find

查找指定内容在字符串中是否存在,如果存在就返回该内容在字符串中第一次出现的开始位置索引值,如果不存在,则返回-1.

格式:
S.find(sub[, start[, end]]) -> int

1
mystr.find('啊')
6
1
mystr.find('暖')
-1

2、rfind

类似于find不过是从右边开始查找

1
mystr.rfind('密')
9
1
mystr.find('密')
8

3、index

跟find()方法一样,只不过,find方法未找到时,返回-1,而index方法未找到时,会报一个异常。

语法格式:

S.index(sub[, start[, end]]) -> int

1
mystr.index('啊')
6
1
mystr.index('暖')
---------------------------------------------------------------------------

ValueError                                Traceback (most recent call last)

<ipython-input-43-324b99e3fcdd> in <module>
----> 1 mystr.index('暖')


ValueError: substring not found

4、rindex

类似于 index(),不过是从右边开始。

判断

1、startswith

判断字符串是否以指定内容开始。 语法格式:

S.startswith(prefix[, start[, end]]) -> bool
1
mystr.startswith('今天')
True
1
mystr.startswith('明')
False

2、endswith

1
mystr.endswith('乌云')
True

3、isalpha

判断字符串是否是纯字母。

1
2
str1 = 'hello'
str1.isalpha()
True
1
2
str2 = 'hello word'
str2.isalpha()# 字符串中有空格
False

4、isdigit

判断一个字符串是否是纯数字,只要出现非0~9的字符,结果就是False.

1
2
str3 = '1234'
str3.isdigit()
True
1
2
str4 = '-1234'
str4.isdigit()
False

5、isalnum()

判断是否由数字和字母组成。只要出现了非数字和字母,就返回False.

1
str1.isalnum()
True
1
str2.isalnum()
False
1
str3.isalnum()
True
1
2
str5 = 'abcd1234'
str5.isalnum()
True

6、isspace()

如果 mystr 中只包含空格,则返回 True,否则返回 False.

1
2
str6 = ''
str6.isspace() # str6是一个空字符
False
1
2
str7 = '   '
str7.isspace()
True

count

返回 str在start和end之间 在 mystr里面出现的次数。

1
mystr
'今天天气好冷啊,密密麻麻的乌云'
1
mystr.count('密')
2

替换 replace

替换字符串中指定的内容,如果指定次数count,则替换不会超过count次。

1
2
3
mystr = '今天天气好晴朗,处处好风光呀好风光'
newstr = mystr.replace('好', '坏')
newstr
'今天天气坏晴朗,处处坏风光呀坏风光'
1
2
newstr = mystr.replace('好','坏',2)  # 指定了替换的次数
newstr
'今天天气坏晴朗,处处坏风光呀好风光'

内容分割

主要涉及到split,splitlines,partition和rpartition四个方法。

1、split

  • 以指定字符串为分隔符切片,如果 maxsplit有指定值,则仅分隔 maxsplit+1 个子字符串。
  • 返回的结果是一个列表
1
2
result = mystr.split() # 没有指定分隔符,默认使用空格,换行等空白字符进行分隔
result
['今天天气好晴朗,处处好风光呀好风光']
1
2
result = mystr.split('好')  # 以 '好' 为分隔符
result
['今天天气', '晴朗,处处', '风光呀', '风光']
1
2
result = mystr.split('好', 2) # 以 '好' 为分隔符,最多切割成3份
result
['今天天气', '晴朗,处处', '风光呀好风光']

2、rsplit()

用法和split基本一致,只不过是从右往左分隔。

1
mystr.rsplit('好',1)
['今天天气好晴朗,处处好风光呀', '风光']

3、splitlines

按照行分隔,返回一个包含各行作为元素的列表。

1
2
mystr = 'hello \nworld'
print(mystr.splitlines())
['hello ', 'world']

4、partition

把mystr以str分割成三部分,str前,str和str后,三部分组成一个元组

1
2
mystr = '今天天气好晴朗,处处好风光呀好风光'
mystr.partition('好')
('今天天气', '好', '晴朗,处处好风光呀好风光')

5、rpartition

和partition一样,只不过从右边开始

1
2
mystr = '今天天气好晴朗,处处好风光呀好风光'
mystr.rpartition('好')
('今天天气好晴朗,处处好风光呀', '好', '风光')

修改大小写

修改大小写的功能只对英文有效,主要包括,首字母大写capitalize,每个单词的首字母大写title,全小写lower,全大写upper.

1、capitalize

第一个单词的首字母大写。

1
2
mystr = 'hello world'
mystr.capitalize()
'Hello world'

2、title()

每个单词的首字母大写

1
mystr.title()
'Hello World'

3、lower()

全部变成小写

1
2
mystr2 = 'hElLo WorLD'
mystr2.lower()
'hello world'

4、upper()

全部变成大写

1
mystr.upper()
'HELLO WORLD'

空格处理

1、ljust()

返回指定长度的字符串,并在右侧使用空白字符补全(左对齐)。

1
2
str = 'hello'
str.ljust(10)
'hello     '
1
len(str.ljust(10))
10

2、rjust

返回指定长度的字符串,并在左侧使用空白字符补全(右对齐)。

1
2
str = 'hello'
str.rjust(10)
'     hello'

3、center

返回指定长度的字符串,并在两端使用空白字符补全(居中对齐)

1
2
str = 'hello'
str.center(10)
'  hello   '

4、lstrip()

删除 mystr 左边的空白字符。

1
2
mystr = '    he   llo      '
mystr.lstrip()
'he   llo      '

5、rstrip()

删除 mystr 右边的空白字符。

1
mystr.rstrip()
'    he   llo'

6、strip()

删除两端的空白字符。

1
mystr.strip()
'he   llo'

字符串拼接

  • 把参数进行遍历,取出参数里的每一项,然后再在后面加上mystr
  • 格式:S.join(iterable)
1
2
3
mystr = 'a'
print(mystr.join('hxmdq')) #haxamadaq 把hxmd一个个取出,并在后面添加字符a. 最后的 q 保留,没有加 a
print(mystr.join(['hi','hello','good'])) #hiahelloagood
haxamadaq
hiahelloagood

作用:可以把列表或者元组快速的转变成为字符串,并且以指定的字符分隔。

1
2
txt = '_'
txt.join(['hi','hello','good'])#hi_hello_good
'hi_hello_good'
1
txt.join(('good','hi','hello')) #good_hi_hello
'good_hi_hello'
1
','.join(('good','hi','hello'))
'good,hi,hello'

字符串运算符

  • 字符串和字符串之间能够使用加法运算符,作用是将两个字符串拼接成为一个字符串。例如:’hello’ + ‘world’的结果是 ‘helloworld’
  • 字符串和数字之间可以做乘法运算,结果是将指定的字符串重复多次。例如:’hello’*2的结果是hellohello
  • 字符串和字符串之间,如果使用比较运算符进行计算,会获取字符对应的编码,然后进行比较。
  • 除上述几种运算符以外,字符串默认不支持其他运算符。

字符集和编码

字符集

计算机只能处理数字(其实就是数字0和数字1),如果要处理文本,就必须先把文本转换为数字才能处理。最早的计算机在设计时采用8个比特(bit)作为一个字节(byte),所以,一个字节能表示的最大的整数就是255(二进制11111111=十进制255),0 - 255被用来表示大小写英文字母、数字和一些符号,这个编码表被称为ASCII编码。

ASCII码表使用7位二进制表示一个字符,它的区间范围时0~127,一共只能表示128个字符,仅能支持英语。随着计算机科学的发展,西欧语言、希腊语、泰语、阿拉伯语、希伯来语等语言的字符也被添加到码表中,形成了一个新的码表ISO8859-1(又被称为Latin1)码表。ISO8859-1使用8位二进制表示一个字符串,完全兼容ASCII码表。

Unicode(统一码、万国码、单一码)是计算机科学领域里的一项业界标准,包括字符集、编码方案等。Unicode 是为了解决传统的字符编码方案的局限而产生的,它为每种语言中的每个字符设定了统一并且唯一的二进制编码,以满足跨语言、跨平台进行文本转换、处理的要求。

字符和编码相互转换

1
2
3
print(ord('a'))  # 使用ord方法,可以获取一个字符对应的编码
print(ord('A'))
print(chr(100)) # 使用chr方法,可以获取一个编码对应的字符
97
65
d

编码规则

  • 使用Unicode为每种语言的每个字符都设定了唯一的二进制编码,但是它还是存在一定的问题,不够完美。

  • 例如,汉字 “你” 转换成为一个字符结果是0x4f60,转换成为二进制就是 01001111 01100000,此时就有两个问题:

  • 1001111 01100000 到底是一个汉字 “你” ,还是两个 Latin1 字符?

  • 如果Unicode进行了规定,每个字符都使用n个八位来表示,对于Latin1字符来说,又会浪费很多存储空间。

  • 为了解决这个问题,就出现了一些编码规则,按照一定的编码规则对Unicode数字进行计算,得出新的编码。在中国常用的字符编码有 GBK,Big5和utf8这三种编码规则。

  • 使用字符串的encode方法,可以将字符串按照指定的编码格式转换称为二进制;使用decode方法,可以将一个二进制数据按照指定的编码格式转换成为字符串。

1
2
3
s1 = '你'.encode('utf8')  # 将字符 你 按照utf8格式编码称为二进制
print(type(s1)) # <class 'bytes'>
print(s1) # b'\xe4\xbd\xa0'
<class 'bytes'>
b'\xe4\xbd\xa0'
1
2
s2 = s1.decode('utf8') # 将二进制按照utf8格式解码称为字符串
print(s2)
1
2
s3 = '你'.encode('gbk') # 将字符 你 按照gbk格式转换称为二进制
print(s3) # b'\xc4\xe3'
b'\xc4\xe3'
1
2
s4 = s3.decode('gbk')  # 将二进制按照gbk格式解码称为字符
print(s4)

成员运算符

成员运算符 (in 和 not in) 可以用来快速的判断元素是否在指定的可迭代对象里,语法格式 要判断的元素 in 可迭代对象。

1
2
str1 = 'hello'
'h' in str1
True
1
'll' in str1
True
1
'll' not in str1
False

字符串的format方法

  • str.format() 方法通过字符串中的大括号{} 来识别替换字段 replacement field,从而完成字符串的格式化。
  • 替换字段 由字段名 field name 和转换字段 conversion field 以及格式说明符 format specifier 组成,即一般形式为 {字段名!转换字段:格式说明符}。
  • 字段名分为简单字段名 simple field name 和复合字段名 compound field name。而转换字段和格式说明符都是可选的。

字段名

form的完整格式是{字段名!转换字符:格式说明符}。其中字段名是必须的,而且可以分为简单字段名和复合字段名。

简单字段名

简单字段名由三中写法:

  • 省略字段名:{}
  • 使用非负十进制整数{0}
  • 变量名{name}

1、省略字段名

大括号内省略字段名,传递位置参数。

  • 替换字段形式: {}
  • 注意:大括号个数可以少于位置参数的个数,反之不然。
1
print('我叫{},今年{}岁。'.format('小明', 18))
我叫小明,今年18岁。
1
print('我叫{},今年{}岁。'.format('小明', 18,'男'))
我叫小明,今年18岁。
1
print('我叫{},今年{}岁。性别:{}'.format('小明', 18))
---------------------------------------------------------------------------

IndexError                                Traceback (most recent call last)

<ipython-input-116-e25ae2723595> in <module>
----> 1 print('我叫{},今年{}岁。性别:{}'.format('小明', 18))


IndexError: Replacement index 2 out of range for positional args tuple

2、数字字段名

可以通过数字形式的简单字段名传递位置参数。

  • 数字必须是大于等于 0 的整数。
  • 带数字的替换字段可以重复使用。
  • 数字形式的简单字段名相当于把 format 中的所有位置参数整体当作一个元组,通过字段名中的数字进行取值。即 {0} 等价于 tuple[0],所以大括号内的数字不能越界。
1
2
# 通过数字形式的简单字段名传递位置参数
print('身高{0},家住{1}。'.format(1.8, '铜锣湾'))
身高1.8,家住铜锣湾。
1
print('我爱{0}。\n她今年{1}。\n我也爱{0}。'.format('榴莲', 17))
我爱榴莲。
她今年17。
我也爱榴莲。
1
2
3
# 体会把所有位置参数整体当成元组来取值
print('阿香爱吃{1}、{3}和{0}。'.format(
'榴莲', '臭豆腐', '皮蛋', '鲱鱼罐头', '螺狮粉'))
阿香爱吃臭豆腐、鲱鱼罐头和榴莲。
1
2
# 尝试一下越界错误
print('{1}'.format('错误用法'))
---------------------------------------------------------------------------

IndexError                                Traceback (most recent call last)

<ipython-input-121-1042e559029b> in <module>
      1 # 尝试一下越界错误
----> 2 print('{1}'.format('错误用法'))


IndexError: Replacement index 1 out of range for positional args tuple

3、变量字段名

使用变量名形式的简单字段名传递关键字参数。

关键字参数的位置可以随意调换。

1
2
# 使用变量名形式的简单字段名传递关键字参数
print('我是{name},今年{age}岁'.format(name='yaya',age=12))
我是yaya,今年12岁
1
2
# 关键字参数的顺序可以随意调换
print('我大哥是{name},今年{age}岁。'.format(age=20, name='阿飞'))
我大哥是阿飞,今年20岁。

简单字段名的混合使用

  • 混合使用数字形式和变量名形式的字段名,可以同时传递位置参数和关键字参数。
  • 关键字参数必须位于位置参数之后。
  • 混合使用时可以省略数字。
  • 省略字段名 {} 不能和数字形式的字段名 {非负整数} 同时使用。
1
2
print('这是一个关于{0}、{1}和{girl}的故事。'.format(
'小明', '阿飞', girl='阿香'))
这是一个关于小明、阿飞和阿香的故事。
1
2
3
# 关键字参数必须位于位置参数之后。
print('这是一个关于{0}、{1}和{girl}的故事。'.format(
'小明',girl='阿香', '阿飞'))
  File "<ipython-input-127-ea615a8bf4bc>", line 3
    '小明',girl='阿香', '阿飞'))

^
SyntaxError: positional argument follows keyword argument
1
2
3
# 数字也可以省略
print('这是一个关于{}、{}和{girl}的故事。'.format(
'小明', '阿飞', girl='阿香'))
这是一个关于小明、阿飞和阿香的故事。
1
2
3
# 省略字段名 {} 不能和数字形式的字段名 {非负整数} 同时使用。
print('这是一个关于{0}、{}和{girl}的故事。'.format(
'小明', '阿飞', girl='阿香'))
---------------------------------------------------------------------------

ValueError                                Traceback (most recent call last)

<ipython-input-129-6cd168e3f318> in <module>
      1 # 省略字段名 {} 不能和数字形式的字段名 {非负整数} 同时使用。
----> 2 print('这是一个关于{0}、{}和{girl}的故事。'.format(
      3     '小明', '阿飞', girl='阿香'))


ValueError: cannot switch from manual field specification to automatic field numbering

使用元组和字典传参

  • str.format() 方法还可以使用 元组 和 字典 的形式传参,两者可以混合使用。
  • 位置参数、关键字参数、元组 和 字典 也可以同时使用,但是要注意,位置参数要在关键字参数前面,元组 要在 字典 前面。
1
2
3
4
# 使用元组传参
infos = ('钢铁侠', 66, '小辣椒')
print(type(infos))
print('我是{},身价{}亿。'.format(*infos))
<class 'tuple'>
我是钢铁侠,身价66亿。
1
print('我是{2},身价{1}亿。'.format(*infos))
我是小辣椒,身价66亿。
1
2
3
# 使用字典传参
venom = {'name': '毒液', 'weakness': '火'}
print('我是{name},我怕{weakness}。'.format(**venom))
我是毒液,我怕火。
1
2
3
4
5
# 同时使用元组和字典传参
hulk = '绿巨人', '拳头'
captain = {'name': '美国队长', 'weapon': '盾'}
print('我是{}, 我怕{weapon}。'.format(*hulk, **captain))
print('我是{name}, 我怕{1}。'.format(*hulk, **captain))
我是绿巨人, 我怕盾。
我是美国队长, 我怕拳头。
1
2
3
4
5
6
7
8
9
10
# 同时使用位置参数、元组、关键字参数、字典传参
# 注意:
# 位置参数要在关键字参数前面
# *元组要在**字典前面
tup = '鹰眼',
dic = {'weapon': '箭'}
text = '我是{1},我怕{weakness}。我是{0},我用{weapon}。'
text = text.format(
*tup, '黑寡妇', weakness='男人', **dic)
print(text)
我是黑寡妇,我怕男人。我是鹰眼,我用箭。
1
2
3
text = '我是{0},我怕{weakness}。我是{1},我用{weapon}。'
text.format(
'黑寡妇', weakness='男人',*tup, **dic)
'我是黑寡妇,我怕男人。我是鹰眼,我用箭。'

复合字段名

同时使用了数字和变量名两种形式的字段名就是复合字段名。

复合字段名

支持两种操作符:

  • . 点号
  • [] 中括号

1、使用点号(.)

传递位置参数

  • 替换字段形式:{数字.属性名}
  • 只有一个替换字段的时候可以省略数字
1
2
3
4
5
6
7
8
9
class Person(object):
def __init__(self,name,age,gender):
self.name = name
self.age = age
self.gender = gender
p = Person('zhangsan',18,'female')

print('姓名是{0.name},年龄是{0.age},性别是{0.gender}'.format(p))
print('姓名是{.name}'.format(p)) # 只有一个替换字段时,可以省略数字
姓名是zhangsan,年龄是18,性别是female
姓名是zhangsan

2、使用中括号[]

  • 用列表传递位置参数
  • 用元组传递位置参数
  • 用字典传递位置参数
1
2
3
4
5
6
# 中括号用法:用列表传递位置参数
infos = ['阿星', 9527]
food = ('霸王花', '爆米花')
print('我叫{0[0]},警号{0[1]},爱吃{1[0]}。'.format(
infos, food))

我叫阿星,警号9527,爱吃霸王花。
1
2
3
4
# 中括号用法:用元组传递位置参数
food = ('猴哥', '香蕉')
print('我叫{0[0]},年龄{1},爱吃{0[1]}。'.format(
food, 66))
我叫猴哥,年龄66,爱吃香蕉。
1
2
3
4
5
# 中括号用法:用字典传递位置参数
dic = dict(name='阿星', pid=9527)
# 单个字段时可以省略数字
print('我是{[name]}!'.format(
dic))
我是阿星!
1
2
3
# 多个替换字段,不能省略数字
print('我是{0[name]},警号{0[pid]}。'.format(
dic))
我是阿星,警号9527。

转换字段

转换字段 conversion field 的取值有三种,前面要加 !:

  • s:传递参数之前先对参数调用 str()
  • r:传递参数之前先对参数调用 repr()
  • a:传递参数之前先对参数调用 ascii()

ascii() 函数类似 repr() 函数,返回一个可以表示对象的字符串。 但是对于非 ASCII 字符,使用 \x,\u 或者 \U 转义。

1
2
3
4
# 转换字段
print('I am {!s}!'.format('Bruce Lee 李小龙'))
print('I am {!r}!'.format('Bruce Lee 李小龙'))
print('I am {!a}!'.format('Bruce Lee 李小龙'))
I am Bruce Lee 李小龙!
I am 'Bruce Lee 李小龙'!
I am 'Bruce Lee \u674e\u5c0f\u9f99'!

处理页面标签类

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
import re

#处理页面标签类
class Tool:
#去除img标签,7位长空格
removeImg = re.compile('<img.*?>| {7}|')
#删除超链接标签
removeAddr = re.compile('<a.*?>|</a>')
#把换行的标签换为\n
replaceLine = re.compile('<tr>|<div>|</div>|</p>')
#将表格制表<td>替换为\t
replaceTD= re.compile('<td>')
#把段落开头换为\n加空两格
replacePara = re.compile('<p.*?>')
#将换行符或双换行符替换为\n
replaceBR = re.compile('<br><br>|<br>')
#将其余标签剔除
removeExtraTag = re.compile('<.*?>')
def replace(self,x):
x = re.sub(self.removeImg,"",x)
x = re.sub(self.removeAddr,"",x)
x = re.sub(self.replaceLine,"\n",x)
x = re.sub(self.replaceTD,"\t",x)
x = re.sub(self.replacePara,"\n ",x)
x = re.sub(self.replaceBR,"\n",x)
x = re.sub(self.removeExtraTag,"",x)
#strip()将前后多余内容删除
return x.strip()

Python中的字符串的基本使用

http://fahsa.cn/python/test-str/

作者

Fahsa

发布于

2021-01-10

更新于

2021-01-11

许可协议

评论