字符串的表示方式
字符串介绍
字符串可以理解为一段普通的文本内容,在python里,使用引号来表示一个字符串,不同的引号表示的效果会有区别。
字符串表示方式
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 | 用来表示一个制表符 |
\\ | 代表一个反斜线字符\ |
\' | 用来显示一个单引号 |
\" | 用来显示一个双引号 |
2. 字符串的下标和切片
下标和切片
1. 下标/索引
所谓“下标”又叫“索引”,就是编号,就好比超市中的存储柜的编号,通过这个编号就能找到相应的存储空间
字符串中"下标"的使用
如果有字符串:name = 'abcdef',在内存中的实际存储如下:
![](https://i-blog.csdnimg.cn/blog_migrate/ac63532fdc34eafbcabcb25eb94e0873.png)
如果想取出部分字符,那么可以通过下标的方法,(注意在计算机中,下标从 0 开始)
name = 'abcdef'
print(name[0])
print(name[1])
print(name[2])
运行结果:
a
b
c
2. 遍历
所谓遍历,可以理解为按照一定的规则(一般情况下就是数据的下标),访问每一个数据。不是所有的数据都能够被遍历,字符串是可迭代对象,能够进行遍历。
可以使用while和for语句,对字符串里的元素进行遍历。
while语句遍历:
msg = 'hello world'
i = 0
while i < len(msg):
print(msg[i])
i += 1
for语句遍历:
msg = 'hello world'
for x in msg:
print(x)
3. 切片
切片是指对操作的对象截取其中一部分的操作。字符串、列表、元组都支持切片操作。
切片的语法:[起始:结束:步长],也可以简化使用 [起始:结束]
注意:选取的区间从"起始"位开始,到"结束"位的前一位结束(不包含结束位本身),步长表示选取间隔。
# 索引是通过下标取某一个元素# 切片是通过下标去某一段元素
s = 'Hello World!'
print(s)
print(s[4]) # o 字符串里的第4个元素
print(s[3:7]) # lo W 包含下标 3,不含下标 7
print(s[:]) # Hello World! 取出所有元素(没有起始位和结束位之分),默认步长为1
print(s[1:]) # ello World! 从下标为1开始,取出 后面所有的元素(没有结束位)
print(s[:4]) # Hell 从起始位置开始,取到 下标为4的前一个元素(不包括结束位本身)
print(s[:-1]) # Hello World 从起始位置开始,取到 倒数第一个元素(不包括结束位本身)
print(s[-4:-1]) # rld 从倒数第4个元素开始,取到 倒数第1个元素(不包括结束位本身)
print(s[1:5:2]) # el 从下标为1开始,取到下标为5的前一个元素,步长为2(不包括结束位本身)
print(s[7:2:-1]) # ow ol 从下标为7的元素开始(包含下标为7的元素),倒着取到下标为2的元素(不包括下标为2的元素) # python 字符串快速逆置
print(s[::-1]) # !dlroW olleH 从后向前,按步长为1进行取值
3. 字符串的常见操作
字符串的常见操作包括:
获取长度: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
功能:获取字符串的长度。
返回值:长度
mystr = '今天天气好晴朗,处处好风光呀好风光'
print(len(mystr)) # 17 获取字符串的长度
二、 查找
查找相关的方法,使用方式大致相同,但是略有区别。
1. find
功能:查找指定内容在字符串中是否存在,
返回值:存在就返回该内容在字符串中第一次出现的开始位置索引值,
不存在,则返回-1.
语法格式:
S.find(sub[, start[, end]]) -> int
示例:
mystr = '今天天气好晴朗,处处好风光呀好风光'
print(mystr.find('好风光')) # 10 '好风光'第一次出现时,'好'所在的位置
print(mystr.find('你好')) # -1 '你好'不存在,返回 -1
print(mystr.find('风', 12)) # 15 从下标12开始查找'风',找到风所在的位置试15
print(mystr.find('风光',1,12)) # -1 从下标1开始到12查找"风光",未找到,返回 -1
2. rfind
功能:类似于 find()函数,不过是从右边开始查找。
mystr = '今天天气好晴朗,处处好风光呀好风光'
print(mystr.rfind('好')) # 14
3.index
功能:跟find()方法一样,只不过,
返回值:存在就返回该内容在字符串中第一次出现的开始位置索引值,
未找到时,会报一个异常。
语法格式:
S.index(sub[, start[, end]]) -> int
4.rindex
功能:类似于 index(),不过是从右边开始。
三、判断
python提供了非常丰富的方法,可以用来对一个字符串进行判断。
1. startswith
功能:判断字符串是否以指定内容开始。
语法格式:
S.startswith(prefix[, start[, end]]) -> bool
示例:
mystr = '今天天气好晴朗,处处好风光呀好风光'
print(mystr.startswith('今')) # True
print(mystr.startswith('今日')) # False
2. endswith
功能:判断字符串是否以指定内容结束。
mystr = '今天天气好晴朗,处处好风光呀好风光'
print(mystr.endswith('好风光')) #True
print(mystr.endswith('好日子')) #False
3. isalpha
功能:判断字符串是否是纯字母。
mystr = 'hello'
print(mystr.isalpha()) # True
mystr = 'hello world'
print(mystr.isalpha()) # False 因为中间有空格
4. isdigit
功能:判断一个字符串是否是纯数字,只要出现非0~9的数字,结果就是False.
mystr = '1234'
print(mystr.isdigit()) # True
mystr = '123.4'
print(mystr.isdigit()) # False
mystr = '-1234'
print(mystr.isdigit()) # False
5. isalnum
功能呢:判断是否由数字和字母组成。只要出现了非数字和字母,就返回False.
mystr = 'abcd'
print(mystr.isalnum()) # True
mystr = '1234'
print(mystr.isalnum()) # True
mystr = 'abcd1234'
print(mystr.isalnum()) # True
mystr = 'abcd1234_'
print(mystr.isalnum()) # False
6. isspace
功能:如果 mystr 中只包含空格,则返回 True,否则返回 False.
mystr = ''
print(mystr.isspace()) # False mystr是一个空字符串
mystr = ' '
print(mystr.isspace()) # True 只有空格
mystr = ' d'
print(mystr.isspace()) # False 除了空格外还有其他内容
四、count
功能:计算 str在start和end之间 在 mystr里面出现的次数。
语法格式:
S.count(sub[, start[, end]]) -> int
示例:
mystr = '今天天气好晴朗,处处好风光呀好风光'
print(mystr.count('好')) # 3. '好'字出现三次
五、替换
功能:替换字符串中指定的内容,如果指定次数count,则替换不会超过count次。
mystr = '今天天气好晴朗,处处好风光呀好风光'
newstr = mystr.replace('好', '坏')
print(mystr) # 今天天气好晴朗,处处好风光呀好风光 原字符串未改变!
print(newstr) # 今天天气坏晴朗,处处坏风光呀坏风光 得到的新字符串里,'好'被修改成了'坏'
newstr = mystr.replace('好','坏',2) # 指定了替换的次数
print(newstr) # 今天天气坏晴朗,处处坏风光呀好风光 只有两处的'好'被替换成了'坏'
六、内容分隔
内容分隔主要涉及到split,splitlines,partition和rpartition四个方法。
split
功能:以指定字符串为分隔符切片,如果 maxsplit有指定值,则仅分隔 maxsplit+1 个子字符串。
返回值:返回的结果是一个列表。
mystr = '今天天气好晴朗,处处好风光呀好风光'
result = mystr.split() # 没有指定分隔符,默认使用空格,换行等空白字符进行分隔
print(result) #['今天天气好晴朗,处处好风光呀好风光'] 没有空白字符,所以,字符串未被分隔
result = mystr.split('好') # 以 '好' 为分隔符
print(result) # ['今天天气', '晴朗,处处','风光呀,'风光']
result = mystr.split("好",2) # 以 '好' 为分隔符,最多切割成3份
print(result) # ['今天天气', '晴朗,处处', '风光呀好风光']
rsplit
功能:用法和split基本一致,只不过是从右往左分隔。
mystr = '今天天气好晴朗,处处好风光呀好风光'
print(mystr.rsplit('好',1)) #['今天天气好晴朗,处处好风光呀', '风光']
splitlines
功能:按照行分隔,返回一个包含各行作为元素的列表。
mystr = 'hello \nworld'
print(mystr.splitlines())
partition
功能:把mystr以str分割成三部分,str前,str和str后,三部分组成一个元组
mystr = '今天天气好晴朗,处处好风光呀好风光'
print(mystr.partition('好')) # ('今天天气', '好', '晴朗,处处好风光呀好风光')
rpartition
功能:类似于 partition()函数,不过是从右边开始.
mystr = '今天天气好晴朗,处处好风光呀好风光'
print(mystr.rpartition('好')) # ('今天天气好晴朗,处处好风光呀', '好', '风光')
七、修改大小写
修改大小写的功能只对英文有效,主要包括,首字母大写capitalize,每个单词的首字母大写title,全小写lower,全大写upper.
capitalize
功能:第一个单词的首字母大写。
mystr = 'hello world'
print(mystr.capitalize()) # Hello world
title
功能:每个单词的首字母大写。
mystr = 'hello world'
print(mystr.title()) # Hello World
lower
功能:所有都变成小写。
mystr = 'hElLo WorLD'
print(mystr.lower()) # hello world
upper
功能:所有都变成大写。
mystr = 'hello world'
print(mystr.upper()) #HELLO WORLD
八、空格处理
Python为我们提供了各种操作字符串里表格的方法。
1. ljust
返回指定长度的字符串,并在右侧使用空白字符补全(左对齐)。
str = 'hello'
print(str.ljust(10)) # hello 在右边补了五个空格
2. rjust
返回指定长度的字符串,并在左侧使用空白字符补全(右对齐)。
str = 'hello'
print(str.rjust(10)) # hello在左边补了五个空格
3. center
返回指定长度的字符串,并在两端使用空白字符补全(居中对齐)
str = 'hello'
print(str.center(10)) # hello 两端加空格,让内容居中
4. lstrip
功能:删除 mystr 左边的空白字符。
mystr = ' he llo '
print(str.lstrip()) #he llo 只去掉了左边的空格,中间和右边的空格被保留
5. rstrip
功能:
删除 mystr 右边的空白字符。
mystr = ' he llo '
print(str.rstrip()) # he llo右边的空格被删除
6. strip
功能:删除两断的空白字符。
str = ' he llo '
print(str.strip()) #he llo
字符串拼接
把参数进行遍历,取出参数里的每一项,然后再在后面加上mystr
语法格式:
S.join(iterable)
示例:
mystr = 'a'
print(mystr.join('hxmdq')) #haxamadaq 把hxmd一个个取出,并在后面添加字符a. 最后的 q 保留,没有加 a
print(mystr.join(['hi','hello','good'])) #hiahelloagood
作用:可以把列表或者元组快速的转变成为字符串,并且以指定的字符分隔。
txt = '_'
print(txt.join(['hi','hello','good'])) #hi_hello_good
print(txt.join(('good','hi','hello'))) #good_hi_hello
字符串运算符
字符串和字符串之间能够使用加法运算符,作用是将两个字符串拼接成为一个字符串。例如:'hello' + 'world'的结果是 'helloworld'
字符串和数字之间可以做乘法运算,结果是将指定的字符串重复多次。例如:'hello'*2的结果是hellohello
字符串和字符串之间,如果使用比较运算符进行计算,会获取字符对应的编码,然后进行比较。
除上述几种运算符以外,字符串默认不支持其他运算符。
4.字符集和编码
字符集
计算机只能处理数字(其实就是数字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 是为了解决传统的字符编码方案的局限而产生的,它为每种语言中的每个字符设定了统一并且唯一的二进制编码,以满足跨语言、跨平台进行文本转换、处理的要求。
字符和编
码相互转换
使用chr和ord方法,可以实现字符和编码之间的相互转换。
print(ord('a')) # 使用ord方法,可以获取一个字符对应的编码
print(chr(100)) # 使用chr方法,可以获取一个编码对应的字符
编码规则
使用Unicode为每种语言的每个字符都设定了唯一的二进制编码,但是它还是存在一定的问题,不够完美。
例如,汉字 “你” 转换成为一个字符结果是0x4f60,转换成为二进制就是 01001111 01100000,此时就有两个问题:
1001111 01100000 到底是一个汉字 “你” ,还是两个 Latin1 字符?
如果Unicode进行了规定,每个字符都使用n个八位来表示,对于Latin1字符来说,又会浪费很多存储空间。
为了解决这个问题,就出现了一些编码规则,按照一定的编码规则对Unicode数字进行计算,得出新的编码。在中国常用的字符编码有 GBK,Big5和utf8这三种编码规则。
使用字符串的encode方法,可以将字符串按照指定的编码格式转换称为二进制;使用decode方法,可以将一个二进制数据按照指定的编码格式转换成为字符串。
s1 = '你'.encode('utf8') # 将字符 你 按照utf8格式编码称为二进制
print(type(s1)) # <class 'bytes'>
print(s1) # b'\xe4\xbd\xa0'
s2 = s1.decode('utf8') # 将二进制按照utf8格式解码称为字符串
print(s2)
s3 = '你'.encode('gbk') # 将字符 你 按照gbk格式转换称为二进制
print(s3) # b'\xc4\xe3'
s4 = s3.decode('gbk') # 将二进制按照gbk格式解码称为字符
print(s4)
思考:文字产生乱码的原因以及解决方案。
5.成员运算符
成员运算符 (in 和 not in) 可以用来快速的判断元素是否在指定的可迭代对象里,语法格式 要判断的元素 in 可迭代对象。
in运算符
思考:怎样判断一个字符是否在指定的字符串里?
msg = 'hello'
char = input('请输入一个字符:')
# 使用字符串的 find 方法可以判断字符是否存在
if msg.find(char) != -1:
print('您输入的字符存在')
else:
print('您输入的字符不存在')
# 使用 in 运算符可以更加方便的查看字符是否存在
if char in msg:
print('您输入的字符存在')
else:
print('您输入的字符不存在')
not in 运算符
和 in 运算符的使用方式一致,只不过 not in 用来判断元素是否 不在 指定的字符串里。
注意
不是所有的数据都能使用身份运算符,身份运算符后面只能是一个可迭代对象。
'h'in'hello''zhangsan'in ['lisi','henry','merry','jack']
1in123# 报错,数字 123 不是一个可迭代对象
6. 字符串的format方法
1. 概念:
str.format() 方法通过字符串中的大括号{} 来识别替换字段 replacement field,从而完成字符串的格式化。
替换字段 由字段名 field name 和转换字段 conversion field 以及格式说明符 format specifier 组成,即一般形式为 {字段名!转换字段:格式说明符}。
字段名分为简单字段名 simple field name 和复合字段名 compound field name。而转换字段和格式说明符都是可选的。
2. 字段名
format的完整格式是{字段名!转换字符:格式说明符}。其中字段名是必须的,而且可以分为简单字段名和复合字段名。
2.1 简单字段名
简单字段名由三中写法:
省略字段名:{}
使用非负十进制整数{0}
变量名{name}
2.1.1 省略字
段名
大括号内省略字段名,传递位置参数。
替换字段形式: {}
注意:大括号个数可以少于位置参数的个数,反之不然。
# 省略字段名传递位置参数
print('我叫{},今年{}岁。'.format('小明', 18))
"""
我叫小明,今年18岁。
"""# 大括号个数可以少于位置参数的个数
print('我爱吃{}和{}。'.format('香蕉', '苹果', '大鸭梨'))
"""
我爱吃香蕉和苹果。
"""# 大括号个数多于位置参数的个数则会报错# print('我还吃{}和{}。'.format('西红柿'))"""
IndexError: tuple index out of range
"""
2.1.2 数字字段名
可以通过数字形式的简单字段名传递位置参数。
数字必须是大于等于 0 的整数。
带数字的替换字段可以重复使用。
数字形式的简单字段名相当于把 format 中的所有位置参数整体当作一个元组,通过字段名中的数字进行取值。即 {0} 等价于 tuple[0],所以大括号内的数字不能越界。
# 通过数字形式的简单字段名传递位置参数
print('身高{0},家住{1}。'.format(1.8, '铜锣湾'))
"""
身高1.8,家住铜锣湾
"""# 数字形式的简单字段名可以重复使用。
print('我爱{0}。\n她今年{1}。\n我也爱{0}。'.format('阿香', 17))
"""
我爱阿香。
她今年17。
我也爱阿香。
"""# 体会把所有位置参数整体当成元组来取值
print('阿香爱吃{1}、{3}和{0}。'.format(
'榴莲', '臭豆腐', '皮蛋', '鲱鱼罐头', '螺狮粉'))
"""
阿香爱吃臭豆腐、鲱鱼罐头和榴莲。
"""# 尝试一下越界错误# print('{1}'.format('错误用法'))"""
IndexError: tuple index out of range
"""
2.1.3 变量字段名
使用变量名形式的简单字段名传递关键字参数。
关键字参数的位置可以随意调换。
# 使用变量名形式的简单字段名传递关键字参数
print('我大哥是{name},今年{age}岁。'.format(name='阿飞', age=20))
"""
我大哥是阿飞,今年20岁。
"""# 关键字参数的顺序可以随意调换
print('我大哥是{name},今年{age}岁。'.format(age=20, name='阿飞'))
"""
我大哥是阿飞,今年20岁。
"""
2.1.4 简单字段名的混合使用
混合使用数字形式和变量名形式的字段名,可以同时传递位置参数和关键字参数。
关键字参数必须位于位置参数之后。
混合使用时可以省略数字。
省略字段名 {} 不能和数字形式的字段名 {非负整数} 同时使用。
# 混合使用数字形式和变量名形式的字段名# 可以同时传递位置参数和关键字参数
print('这是一个关于{0}、{1}和{girl}的故事。'.format(
'小明', '阿飞', girl='阿香'))
"""
这是一个关于小明、阿飞和阿香的故事。
"""# 但是关键字参数必须位于位置参数之后# print('这是一个关于{0}、{1}和{girl}的故事。'.format(# '小明', girl='阿香' , '阿飞'))"""
SyntaxError: positional argument follows keyword argument
"""
# 数字也可以省略
print('这是一个关于{}、{}和{girl}的故事。'.format(
'小明', '阿飞', girl='阿香'))
# 但是省略字段名不能和数字形式的字段名同时出现#
print('这是一个关于{}、{1}和{girl}的故事。'.format(# '小明', '阿飞', girl='阿香'))"""
ValueError: cannot switch from automatic field numbering to manual field specification
"""
2.1.5 使用元组和字典传参
str.format() 方法还可以使用 *元组 和 **字典 的形式传参,两者可以混合使用。位置参数、关键字参数、*元组 和 **字典 也可以同时使用,但是要注意,位置参数要在关键字参数前面,*元组 要在 **字典 前面。
# 使用元组传参
infos = '钢铁侠', 66, '小辣椒'
print('我是{},身价{}亿。'.format(*infos))
"""
我是钢铁侠,身家66亿。
"""
print('我是{2},身价{1}亿。'.format(*infos))
"""
我是小辣椒,身家66亿。
"""# 使用字典传参
venom = {'name': '毒液', 'weakness': '火'}
print('我是{name},我怕{weakness}。'.format(**venom))
"""
我是毒液,我怕火。
"""# 同时使用元组和字典传参
hulk = '绿巨人', '拳头'
captain = {'name': '美国队长', 'weapon': '盾'}
print('我是{}, 我怕{weapon}。'.format(*hulk, **captain))
print('我是{name}, 我怕{1}。'.format(*hulk, **captain))
"""
我是绿巨人, 我怕盾。
我是美国队长, 我怕拳头。
"""# 同时使用位置参数、元组、关键字参数、字典传参# 注意:# 位置参数要在关键字参数前面# *元组要在**字典前面
tup = '鹰眼',
dic = {'weapon': '箭'}
text = '我是{1},我怕{weakness}。我是{0},我用{weapon}。'
text = text.format(
*tup, '黑寡妇', weakness='男人', **dic)
print(text)
"""
我是黑寡妇,我怕男人。我是鹰眼,我用箭。
"""
2.2 复合字段名
同时使用了数字和变量名两种形式的字段名就是复合字段名。
复合字段名
支持两种操作符:
. 点号
[] 中括号
2.2.1 使用. 点号
传递位置参数
替换字段形式:{数字.属性名}
只有一个替换字段的时候可以省略数字
classPerson(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)) # 只有一个替换字段时,可以省略数字
2.2. 使用[]中括号
用列表传递位置参数
用元组传递位置参数
用字典传递位置参数
# 中括号用法:用列表传递位置参数
infos = ['阿星', 9527]
food = ['霸王花', '爆米花']
print('我叫{0[0]},警号{0[1]},爱吃{1[0]}。'.format(
infos, food))
"""
我叫阿星,警号9527,爱吃霸王花。
"""# 中括号用法:用元组传递位置参数
food = ('僵尸', '脑子')
print('我叫{0[0]},年龄{1},爱吃{0[1]}。'.format(
food, 66))
"""
我叫僵尸,年龄66,爱吃脑子。
"""# 中括号用法:用字典传递位置参数
dic = dict(name='阿星', pid=9527)
print('我是{[name]}!'.format(
dic))
# 多个替换字段,不能省略数字
print('我是{0[name]},警号{0[pid]}。'.format(
dic))
"""
我是阿星!
我是阿星,警号9527。
"""
3. 转换字段
转换字段conversion field 的取值有三种,前面要加 !:
s:传递参数之前先对参数调用 str()
r:传递参数之前先对参数调用 repr()
a:传递参数之前先对参数调用 ascii()
ascii() 函数类似 repr() 函数,返回一个可以表示对象的字符串。 但是对于非 ASCII 字符,使用 \x,\u 或者 \U 转义。
# 转换字段
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'!
"""
4. 格式说明符
格式说明符使用过于复杂,且实际使用场景不多,暂不讨论。