python中的字符串

1、字符串定义

字符串是由0个或多个字符组成的有序字符序列；
由一对单引号或一对双引号表示单行字符串；
由一对单三引号或一对双三引号表示多行字符串。

2、字符串的格式化输出

2.1、字符串的占位拼接

2.1.1、字符串与字符串的占位拼接

语法

str1 = '上海市松江区'
str2 = '邮寄地址为：%s' % str1
print(str2)  # 输出：邮寄地址为：上海市松江区
其中 %s的含义：我先占个位置，等下有一个变量过来，我把它变成字符串放到占位的位置

– % 表示：我要占位

– s 表示：将变量变成字符串放入占位的地方

2.1.2、字符串与数字的占位拼接

语法

year = 2023
avg_salary = 8888
message = '据统计，上海市%s年的应届毕业生平均工资为：%s元' % (year, avg_salary)
print(message)  # 输出：据统计，上海市2023年的应届毕业生平均工资为：8888元

注意事项：

– 多个变量占位要用英文的括号括起来

– 变量之间使用英文的逗号，并且按照占位的顺序填入

– 这种方式实际上是将数字类型的变量转换成字符串类型，再进行拼接

python中常见的三种数据类型占位

格式化符号含义
%s 将内容转换成字符串，放入占位位置
%d 将内容转换成整数，放入占位位置
%s 将内容转换成浮点型，放入占位位置

格式化符号	含义
%s	将内容转换成字符串，放入占位位置
%d	将内容转换成整数，放入占位位置
%s	将内容转换成浮点型，放入占位位置

2.1.3、占位符格式化精度的控制

price = 19.98
print("%s" % price)  # 输出：19.980000
此时浮点数19.98变成了19.980000，我们可以使用"m.n"来控制数据的宽度和精度，其中：

– m：控制宽度，一般不使用，设置的宽度小于数字本身不生效

– n：控制精度，即小数点后保留几位数字，会进行小数的四舍五入

示例：

– %5d：表示将整数的宽度控制在5位
print('%5d' % 11)   # 输出：[空格][空格][空格]11,在左边用三个空格来补足宽度
– %5.2f：表示将浮点数的宽度控制位5，将小数的位数设置为2位，小数点和小数部分也计入宽度，宽度不足5的部分在左侧用空格补齐
print('%7.2f' %3.14159)  # 输出：[空格][空格][空格]3.14
– %.3f：表示不限制宽度，只设置小数位数为3位
print("%.2f" % 3.14159)  # 输出：3.142

2.2、使用f进行字符串格式化

语法

f'内容{变量}'

示例

city = '上海市'
year = 2023
avg_salary = 8888
message = f'据统计，{city}{year}的应届毕业生平均工资为：{avg_salary}元' 
print(message)  # 输出：据统计，上海市2023年的应届毕业生平均工资为：8888元

– 对于各种类型的变量均原样输出

2.3、对表达式进行字符串格式化

*示例

print('1 * 1 的结果是：%d' % （1 * 1)                   # 输出：1 * 1 的结果是：1
print(f'1 * 1 的结果是：{1* 1}')                        # 输出：1 * 1 的结果是：1
print('python中字符串的类型名是：%s' % type('字符串'))    # 输出：python中字符串的类型名是：<class 'str'>

2.4、字符串的format格式化

2.4.1 用法

<模版字符串>.format(<逗号分隔的参数>)

2.4.2、format中的槽

msg = '{}宣布：从{}开始降息{}个基点'.format('美联储', '2024-11-8', 25)
print(msg)                # 输出：美联储宣布：从2024-11-8开始降息25个基点# 槽的顺序是默认从左到右递增，下标从0开始，也可以指定槽的顺序msg = '{2}宣布：从{0}开始降息{1}个基点'.format('2024-11-8', 25, '美联储')
print(msg)                # 输出：美联储宣布：从2024-11-8开始降息25个基点

2.4.3、format槽内部对格式化的配置方式

{<参数序号>:<格式化控制标记>}

: <填充> <对齐> <宽度> <,> <.精度> <类型>
引导符用于填充的
单个字符 <：左对齐
>：右对齐
^：居中对齐槽设定的
输出宽度数字的千位
分隔符小数精度 or
字符串最大输出长度整数类型、
浮点数类型
%、e、b等
示例
print('{0:=^20}'.format('python'))      # 输出：=======python=======
# 要输出的字符串python居中对齐，两端用=填充，整个输出宽度为20个字符，python字符串为6个字符，两端各填充7个=字符print('{:20}'.format('python'))         # 输出：‘python              ’
# 默认左对齐print('{0:,.2f}'.format(31415.9267))    # 输出：31,415.93
# ，为千分位分隔符，.2f 输出时浮点数的小数点后通过4舍5入的方式保留2位

:	<填充>	<对齐>	<宽度>	<,>	<.精度>	<类型>
引导符	用于填充的单个字符	<：左对齐 >：右对齐 ^：居中对齐	槽设定的输出宽度	数字的千位分隔符	小数精度 or 字符串最大输出长度	整数类型、浮点数类型 %、e、b等

3、字符串运算符

3.1、‘==’ 和 is 运算符

不同点：

– ‘==’ 比较的是内容

– is 比较的是id地址

示例：

s1, s2, s3 = 'abc', "abc", '''abc'''
s4 = '''
abc
'''# 三引号的内容如果不在同一行，则其占用的内存空间与单双引号的不同print(s1)         # 输出：abc
print(s2)         # 输出：abc
print(s3)         # 输出：abc
print(s4)         # 输出：一行空格，一行abc，再一行空格	 	  print('s1的id是：%s' % id(s1))		# s1的id是：140733124186416
print('s2的id是：%s' % id(s2))		# s2的id是：140733124186416
print('s3的id是：%s' % id(s3))		# s3的id是：140733124186416
print('s4的id是：%s' % id(s4))		# s4的id是：3019309783408print(s1 == s2)		--> True
print(s1 is s2)		--> True
print(s1 == s3)		--> True
print(s1 is s3)		--> True
print(s1 == s4)		--> False
print(s1 is s4)		--> Falses5 = input('请输入：')
s6 = input('请输入：')
# 如果通过键盘输入相同的字符串abc
print(s5 == s6)		--> True
print(s5 is s6)		--> False
'''
常量赋值s1, s2 = 'abc', "abc"时id是一样的
input函数底层做了处理，通过键盘输入相同的字符串其id却并不相同
'''

3.2、”+“ 拼接字符串

使用”+“可以拼接两个字符串s1和s2，但不能将字符串和数字拼接

3.3、‘*’ 运算符

n * s1 or s1 * n：复制n次字符串s1

3.4、in 运算符

x in s：如果x是s的子串，返回True，否则返回False
x not in s：如果x不是s的子串，返回True，否则返回False

4、字符串的序号及使用

4.1、字符串的序号是从左到右正向递增和从右到左反向递减

在这里插入图片描述

4.2、字符串的使用

使用[]获取字符串中的一个或多个字符

4.2.1、索引

索引返回字符串中的单个字符
使用方法：<字符串>[m]

示例：

s = '零一二三四五六七八九'
print(s[0])		--> '零'
print(s[-1])	--> '九'

4.2.2、切片

字符串切片会返回字符串中的一段字符子串
使用方法：

<字符串>[m:n]；返回字符串中从序号m开始至n-1的字符子串

示例：

s = '零一二三四五六七八九'
print(s[1:4])	--> '一二三'
print(s[0:-1])	--> '零一二三四五六七八九'

4.2.3、根据步长切片

用法：<字符串>[m:n:k]

– m缺省表示从序号0开始；

– n缺省表示至结尾;

– k表示方向和步长，缺省表示步长为1；

– 起始序号和方向需一致

示例：

s = '零一二三四五六七八九'
print(s[:5])		--> '零一二三四'
print(s[3:])		--> '三四五六七八九'
print(s[1:6:2])		--> '一三五'

4.2.4、字符串的逆序

方法：

<字符串>[::-1]

示例：

s = '零一二三四五六七八九'
print(s[::-1])		--> '九八七六五四三二一零'
print(s[1:4:-1])	--> 无输出
print(s[4:1:-1])	--> '四三二'
print(s[-1:-5:-1])	--> '九八七六'
print(s[1:-1])		--> '一二三四五六七八'

5、字符串的内置函数

5.1、大小写相关函数

str.capitalize()：将字符串str的首字母转成大写并返回字符串副本
```
s = 'python'
print(s.capitalize())	--> 'Python'
```

str.title()：返回每个单词的首字母大写的字符串

s = 'python is everywhere'
ts = s.title()
print(ts)				--> 'Python Is Everywhere'
print(ts.istitle())		--> True  # istitle()判断一个由多个单词组成的字符串的每个单词首字符是否是大写

str.upper()、str.lower()

upper()  # 返回全大写的字符串
lower()  # 返回全小写的字符串s = 'python is everywhere's1 = s.upper()
print(s1)		--> 'PYTHON IS EVERYWHERE's2 = s1.lower()
print(s1)		--> 'python is everywhere'

5.2、查找替换相关函数

find(str, beg=0, end=len(s))：

检查字符串str是否包含在字符串s中，如果指定beg和end的范围，则在指定范围内检查，如包含则返回开始的索引值，否则返回-1

s = 'python is everywhere'
print(s.find('is'))				--> 7
print(s.find('i s'))			--> -1
print(s.find('is', 8))			--> -1  # 指定了开始查找的位置索引8
print(s.find('e'))				--> 10  # 有多个匹配时返回第一次匹配的索引值

rfind()：从右侧开始查找；lfind()：从左侧开始查找

file_path = 'E:\\PythonPractice\\python\\字符串类型及操作v2.5.pdf'
# 获取file_path中的文件名
pos = file_path.rfind('\\')
file_name = file_path[pos+1:]

s.Index(str, beg=0, end=len(s))

和find()函数一样，不同的是如果str不在字符串s中，会报异常：valueerror:substring not found

s.replace(old, new [, max])

返回s中的子串old部分被new替换后的整个字符串

s = 'python'
s = s.replace('n', 'n之禅')
print(s)		--> 'python之禅's = 'python is everywhere'
s = s.replace(' ', '', 1)
print(s)		--> 'pythonis everywhere'

5.3、编码解码函数

encode(encoding=‘utf-8’, errors=‘strict’)：编码函数

以encoding指定的编码格式编码字符串，python默认的编码格式为utf-8，如果出错默认报错：valueerror，除非errors指定的是’ignore’或者’replace’

decode()：解码，使用哪种格式编码的就需要用哪种格式解码

news = '财政部安排化债举措'byte_news = news.encode('utf-8')
print(byte_news)
'''
输出：
b'\xe8\xb4\xa2\xe6\x94\xbf\xe9\x83\xa8\xe5\xae\x89\xe6\x8e\x92\xe5\x8c\x96\xe5\x80\xba\xe4\xb8\xbe\xe6\x8e\xaa'
'''decode_news = byte_news.decode('utf-8')
print(decode_news)		--> '财政部安排化债举措'

5.4、startswith()和endswith()函数

5.4.1、startswith()：

用于检查字符串是否以指定的子字符串开始。如果字符串以指定的子字符串开始，则返回 True；否则返回 False。

语法：

str.startswith(prefix[, start[, end]])
'''
-- prefix：要检查的子字符串。
-- start（可选）：开始检查的起始位置，默认为0。
-- end（可选）：结束检查的结束位置，默认为字符串的末尾。
'''

示例：

# 检查字符串是否以指定的子字符串开始
s = "Hello, World!"
print(s.startswith("Hello"))  # True
print(s.startswith("World"))  # False# 使用start和end参数
print(s.startswith("World", 7))  # True，从索引7开始检查
print(s.startswith("World", 6, 10))  # False，从索引6开始到索引10结束# 检查是否以元组中的任意子字符串开始
print(s.startswith(("Hello", "Hi")))  # True，因为以"Hello"开始'''
-- 如果 prefix 是一个元组，startswith() 方法会检查字符串是否以元组中的任意一个子字符串开始。
-- 如果 prefix 是空字符串，startswith() 总是返回 True。
-- startswith() 方法是大小写敏感的。
'''

5.6、endswith()

用于检查字符串是否以指定的子字符串结束。如果字符串以指定的子字符串结束，则返回 True；否则返回 False。

语法：

str.endswith(suffix[, start[, end]])
'''
-- suffix：要检查的子字符串或子字符串的元组。
-- start（可选）：开始检查的起始位置，默认为0。
-- end（可选）：结束检查的结束位置，默认为字符串的长度。
'''

示例：

# 检查字符串是否以指定的子字符串结束
s = "Hello, World!"
print(s.endswith("!"))  # True
print(s.endswith("World"))  # False# 使用start和end参数
print(s.endswith(", ", 5))  # True，从索引5开始检查
print(s.endswith(", ", 0, 2))  # False，从索引0开始到索引2结束# 检查是否以元组中的任意子字符串结束
print(s.endswith(("!", "World")))  # True，因为以"!"结束'''
-- 如果 suffix 是一个元组，endswith() 方法会检查字符串是否以元组中的任意一个子字符串结束。
-- 如果 suffix 是空字符串，endswith() 总是返回 True。
-- endswith() 方法是大小写敏感的。
'''

5.7、isalpha() 和 isdigit()函数

isalpha()：判断一个字符串是否全为字母组成，是返回True，否则返回False
isdigit()：判断一个字符串是否全为数字组成，是返回True，否则返回False
```
s = 'python.123'
print(s.isalpha())		# False
print(s.digit())		# False
```

5.8、join()函数

作用：

用于将序列中的元素连接成一个新的字符串。序列中的元素可以是字符串，也可以是任何可被转换为字符串的对象。join() 方法会将序列中的元素按照顺序连接起来，并可以在它们之间插入指定的分隔符。

语法：

str.join(iterable)
'''
-- str：用于连接其他元素的分隔符字符串。
-- iterable：一个可迭代对象，其元素将被连接
'''

示例：

# 连接字符串列表
words = ['Hello', 'World']
print(' '.join(words))  # 输出: Hello World# 连接字符串元组
tup = ('apple', 'banana', 'cherry')
print('-'.join(tup))  # 输出: apple-banana-cherry# 连接数字列表，数字会被转换为字符串
numbers = [1, 2, 3, 4]
print(', '.join(map(str, numbers)))  # 输出: 1, 2, 3, 4# 连接空列表
empty_list = []
print(' '.join(empty_list))  # 输出: （空字符串）# 连接单个元素的列表
single_element = ['single']
print(' '.join(single_element))  # 输出: single# 连接空字符串
print(''.join(['a', 'b', 'c']))  # 输出: abc

5.9、移除指定字符函数strip()

strip()：用于移除字符串开头和结尾的指定字符（默认为空白符，包括空格、换行符\n、制表符\t等）。如果需要移除字符串中间的字符，可以使用replace()方法。strip()方法不会修改原始字符串，而是返回一个新的字符串。如果字符串的开头和结尾没有指定的字符，则返回原始字符串。如果字符串是None，则strip()会抛出AttributeError异常。
lstrip()：用于移除字符串左侧（开头）的指定字符（默认为空白符）。如果字符串开头没有指定的字符，则返回原始字符串。这个方法不会修改原始字符串，而是返回一个新的字符串。如果字符串是None，则lstrip()会抛出AttributeError异常。
rstrip()：用于移除字符串右侧（结尾）的指定字符（默认为空白符）。如果字符串结尾没有指定的字符，则返回原始字符串。这个方法不会修改原始字符串，而是返回一个新的字符串。如果字符串是None，则rstrip()会抛出AttributeError异常。

移除空白字符：

s = "  Hello, World!  "
print(s.strip()) 	# 输出: "Hello, World!"s = "  Hello, World!  "
print(s.lsrip())	# 输出："hello, world  "	s = "  Hello, World!  "
print(s.rsrip())	# 输出："  hello, world"

移除指定字符

s = "--Hello, World!--"
print(s.strip('-')) 	# 输出: "Hello, World!"s = "--Hello, World!--"
print(s.lstrip('-')) 	# 输出: "Hello, World!--"s = "--Hello, World!--"
print(s.rstrip('-')) 	# 输出: "--Hello, World!"

移除组合字符

s = "--Hello, World!--"
print(s.strip('-H')) 	# 输出: "ello, World!"s = "--Hello, World!--"
print(s.lstrip('-H'))	 	# 输出: "ello, World!--"s = "--Hello, World!--"
print(s.strip('-H')) 	# 输出: "--Hello, World!"

应用案例

rstrip()方法常用于处理从文件或用户输入中读取的数据，这些数据可能包含不必要的空白字符或特定字符，需要被清理。例如，当你从文本文件中读取一行数据时，可能会在末尾包含换行符\n，使用rstrip()可以轻松地移除这些字符。
```
line = "Hello, World!\n"
clean_line = line.rstrip('\n')
print(clean_line)		# 输出: "Hello, World!"
```

5.9、split()分隔字符串函数

str.split(sep=None)的作用：

返回一个列表，由str根据sep被分割的部分组成

示例：

s = 'python is everywhere'
print(s.split(' '))		# 输出：['python', 'is', 'everywhere']s = 'python is everywhere,but only python is not enough'
print(s.split(','))		# 输出：['python is everywhere', 'but only python is not enough']

5.10、str.count(sub)函数

作用：

返回子串sub在str中出现的次数

示例：

s = 'python is everywhere'
print(s.count('e'))		# 计算'e'在s中出现的次数，结果为：4
print(s.count(' '))		# 计算空格在s中出现的次数，结果为：2