Python 字符串

最新推荐文章于 2024-11-12 23:15:59 发布

PlutoZuo

最新推荐文章于 2024-11-12 23:15:59 发布

阅读量125

点赞数

分类专栏： Python 文章标签： python 开发语言

本文链接：https://blog.csdn.net/PlutoZuo/article/details/133041647

版权

Python 专栏收录该内容

223 篇文章 25 订阅

订阅专栏

Python 字符串

文章目录

Python 字符串

1、字符串的表达方式

1.1 字符串介绍

字符串可以理解为一段普通的文本内容，在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" """  # 三个双引号

1.2 小总结

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

1.3 转义字符

转义字符是很多程序语言、数据格式和通信协议的形式文法的一部分，使用\来表示一个转义字符。常见的转义字符以及它所代表的含义如下表:

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

2、字符串的下标和切片

2.1 下标/索引

所谓“下标”又叫“索引”，就是编号，就好比超市中的存储柜的编号，通过这个编号就能找到相应的存储空间。

如果有字符串:name = ‘abcdef’，在内存中的实际存储如下:

如果想取出部分字符，那么可以通过下标的方法，（注意在计算机中，下标从 0 开始）

name = 'abcdef'

print(name[0])
print(name[1])
print(name[2])


"""
输出结果：

a
b
c
"""

2.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)

2.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中，字符串是不可变的！所有的字符串相关方法，都不会改变原有的字符串，都是返回一个结果，在这个新的返回值里，保留了执行后的结果！

3.1 len

len函数可以获取字符串的长度。

mystr = '今天天气好晴朗，处处好风光呀好风光'
print(len(mystr))  # 17 获取字符串的长度

3.2 查找

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

3.2.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,10)) # -1 从下标1开始到12查找"风光",未找到，返回 -1

3.2.2 rfind

类似于 find()函数，不过是从右边开始查找。

mystr = '今天天气好晴朗，处处好风光呀好风光'
print(mystr.rfind('好')) # 14

3.2.3 index

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

语法格式：

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

3.2.4 rindex

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

3.3 判断

python提供了非常丰富的方法，可以用来对一个字符串进行判断。

3.3.1 startwith

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

S.startswith(prefix[, start[, end]]) -> bool

 #示例：

mystr = '今天天气好晴朗，处处好风光呀好风光'
print(mystr.startswith('今'))  # True
print(mystr.startswith('今日')) # False

3.3.2 endswith

判断字符串是否以指定内容结束。

mystr = '今天天气好晴朗，处处好风光呀好风光'
print(mystr.endswith('好风光')) #True
print(mystr.endswith('好日子')) #False

3.3.3 isalpha

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

mystr = 'hello'
print(mystr.isalpha())  # True
mystr = 'hello world'
print(mystr.isalpha()) # False 因为中间有空格

3.3.4 isdigit

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

mystr = '1234'
print(mystr.isdigit()) # True
mystr = '123.4'
print(mystr.isdigit()) # False
mystr = '-1234'
print(mystr.isdigit()) # False

3.3.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

3.3.6 isspace

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

mystr = ''
print(mystr.isspace()) # False mystr是一个空字符串
mystr = '  '
print(mystr.isspace()) # True 只有空格
mystr = ' d'
print(mystr.isspace()) # False 除了空格外还有其他内容

3.4 count

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

语法格式:

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

#示例：

mystr = '今天天气好晴朗，处处好风光呀好风光'
print(mystr.count('好'))  # 3. '好'字出现三次

3.5 替换

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

mystr = '今天天气好晴朗，处处好风光呀好风光'
newstr = mystr.replace('好', '坏')
print(mystr)  # 今天天气好晴朗，处处好风光呀好风光  原字符串未改变！
print(newstr)  # 今天天气坏晴朗，处处坏风光呀坏风光 得到的新字符串里，'好'被修改成了'坏'

newstr = mystr.replace('好','坏',2)  # 指定了替换的次数
print(newstr) # 今天天气坏晴朗，处处坏风光呀好风光 只有两处的'好'被替换成了'坏'

3.6 内容分割

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

3.6.1 split

以指定字符串为分隔符切片，如果 maxsplit有指定值，则仅分隔 maxsplit+1 个子字符串。返回的结果是一个列表。

mystr = '今天天气好晴朗，处处好风光呀好风光'
result = mystr.split() # 没有指定分隔符，默认使用空格，换行等空白字符进行分隔
print(result) #['今天天气好晴朗，处处好风光呀好风光'] 没有空白字符，所以，字符串未被分隔

result = mystr.split('好')  # 以 '好' 为分隔符
print(result) # ['今天天气', '晴朗，处处','风光呀,'风光']

result = mystr.split("好",2) # 以 '好' 为分隔符，最多切割成3份
print(result) # ['今天天气', '晴朗，处处', '风光呀好风光']

3.6.2 rsplit

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

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

3.6.3 splitlines

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

mystr = 'hello \nworld'
print(mystr.splitlines())

3.6.4 partition

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

mystr = '今天天气好晴朗，处处好风光呀好风光'
print(mystr.partition('好'))  # ('今天天气', '好', '晴朗，处处好风光呀好风光')

3.6.5 rpartition

类似于 partition()函数,不过是从右边开始.

mystr = '今天天气好晴朗，处处好风光呀好风光'
print(mystr.rpartition('好'))   # ('今天天气好晴朗，处处好风光呀', '好', '风光')

3.7 修改大小写

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

3.7.1 capitalize

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

mystr = 'hello world'
print(mystr.capitalize()) # Hello world

3.7.2 title

每个单词的首字母大写。

mystr = 'hello world'
print(mystr.title()) # Hello World

3.7.3 lower

所有都变成小写。

mystr = 'hElLo WorLD'
print(mystr.lower()) # hello world

3.7.4 upper

所有都变成大写。

mystr = 'hello world'
print(mystr.upper())  #HELLO WORLD

3.8 空格处理

Python为我们提供了各种操作字符串里表格的方法。

3.8.1 ljust

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

str = 'hello'
print(str.ljust(10))  # hello     在右边补了五个空格

3.8.2 rjust

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

str = 'hello'
print(str.rjust(10))  #      hello在左边补了五个空格

3.8.3 center

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

str = 'hello'
print(str.center(10))  #  hello   两端加空格，让内容居中

3.8.4 lstrip

删除 mystr 左边的空白字符。

mystr = '    he   llo      '
print(str.lstrip())  #he   llo      只去掉了左边的空格，中间和右边的空格被保留

3.8.5 rstrip

删除 mystr 右边的空白字符。

mystr = '    he   llo      '
print(str.rstrip())  #    he   llo右边的空格被删除

3.8.6 strip

删除两断的空白字符。

mystr = '    he   llo      '
print(str.rstrip())  #    he   llo右边的空格被删除

3.9 字符串拼接

把参数进行遍历，取出参数里的每一项，然后再在后面加上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

3.10 字符串运算符

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

4、成员运算符

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

4.1 in运算符

思考：怎样判断一个字符是否在指定的字符串里？

msg = 'hello'
char = input('请输入一个字符:')

使用字符串的 find 方法可以判断字符是否存在

if msg.find(char) != -1:
    print('您输入的字符存在')
else:
    print('您输入的字符不存在')

使用 in 运算符可以更加方便的查看字符是否存在

if char in msg:
    print('您输入的字符存在')
else:
    print('您输入的字符不存在')

4.2 not in 运算符

和 in 运算符的使用方式一致，只不过 not in 用来判断元素是否不在指定的字符串里。

注意

不是所有的数据都能使用身份运算符，身份运算符后面只能是一个可迭代对象。

'h' in 'hello'  
'zhangsan' in ['lisi','henry','merry','jack']

1 in 123 # 报错，数字 123 不是一个可迭代对象

5、字符串的format方法

5.1 概念

str.format() 方法通过字符串中的大括号{} 来识别替换字段 replacement field，从而完成字符串的格式化。

替换字段由字段名 field name 和转换字段 conversion field 以及格式说明符 format specifier 组成，即一般形式为 {字段名!转换字段:格式说明符}。

字段名分为简单字段名 simple field name 和复合字段名 compound field name。而转换字段和格式说明符都是可选的。

5.2 字段名

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

5.2.1 简单字段名

简单字段名由三中写法:

省略字段名:{}

使用非负十进制整数{0}

变量名{name}

5.2.1.1 省略字段名

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

替换字段形式：{}

注意：大括号个数可以少于位置参数的个数，反之不然。

省略字段名传递位置参数

print('我叫{}，今年{}岁。'.format('小明', 18))
"""
我叫小明，今年18岁。
"""

大括号个数可以少于位置参数的个数

print('我爱吃{}和{}。'.format('香蕉', '苹果', '大鸭梨'))
"""
我爱吃香蕉和苹果。
"""

大括号个数多于位置参数的个数则会报错

print('我还吃{}和{}。'.format('西红柿'))

"""
IndexError: tuple index out of range
"""

5.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
"""

5.2.1.3 变量字段名

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

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

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

print('我大哥是{name}，今年{age}岁。'.format(name='阿飞', age=20))
"""
我大哥是阿飞，今年20岁。
"""

#关键字参数的顺序可以随意调换

print('我大哥是{name}，今年{age}岁。'.format(age=20, name='阿飞'))
"""
我大哥是阿飞，今年20岁。
"""

5.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
"""

5.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)
"""
我是黑寡妇，我怕男人。我是鹰眼，我用箭。
"""

5.2.2 符合字段名

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

复合字段名

支持两种操作符：

. 点号

[] 中括号

5.2.2.1 使用. 点号

传递位置参数

替换字段形式：{数字.属性名}

只有一个替换字段的时候可以省略数字

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))  # 只有一个替换字段时，可以省略数字

5.2.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。
"""

号

传递位置参数

替换字段形式：{数字.属性名}

只有一个替换字段的时候可以省略数字

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))  # 只有一个替换字段时，可以省略数字

5.2.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。
"""