python基本数据类型-字符串

str基础知识

1. str定义

字符串用于存储文本。

python 中，单引号、双引号跨起来的字符串是一样的

例如：

a='abcd'

b="abcd" //推荐

三引号字符串一般称为文档字符串，用来做类、函数、多行注释等的说明。

a='''abcd'''

b="""abcd"""

三引号字符串的功能：

1.多行注释

2.作为类或函数的说明文档！

单引号、双引号嵌套问题：

Python 对于字符串的识别是按“就近匹配”的原则

print("abcd'1234'defa")
abcd'1234'defa
print('abcd"1234"defa')
abcd"1234"defa
print("abcd"1234"defa")
SyntaxError: invalid syntax
#用转义字符\后，"就只表示引号
print("abcd"1234"defa")
abcd"1234"defa
print('abcd'1234'defa')
abcd'1234'defa

2. str切片

s[i] 获取索引 i 处的字符

s[i:] 获取从 i 到结束的子串

s[:j] 获取从开始到j的子串(不包括j)

s[i:j] 获取从 i 到 j 的子串 (不包括j) 默认值：i=0, j=len(s)

s[i:j:k] 以步长 k 获取子串

s[:] 复制整个字符串

s[::-1] 反转字符串

负索引：
-1表示最后一个字符

s[-3:]获取最后三个字符

边界：

索引超出范围时自动截断到有效范围

s[1:8]
'pple'

当 i > j 时返回空字符串（除非指定负步长）

s='apple'
s[5:1]
''
s[5:1:-1]
'elp'

3. str支持的运算符

1> +

格式：str1+str2

功能：把str2拼接/追加在str1后面！

>>> str1="abcd"
>>> str2="1234"
>>> str1+str2
'abcd1234'

str+int/float/bool等都不支持。如果相加，通过str函数转换！

>>> "abcd"+1234
Traceback (most recent call last):
  File "<pyshell#3>", line 1, in <module>
    "abcd"+1234
TypeError: can only concatenate str (not "int") to str

>>> "abcd"+str(1234)
'abcd1234'
>>> name="张三"
>>> age=20
>>> "姓名："+name+",年龄："+str(age)
'姓名：张三,年龄：20'

2>*

格式：str*正int

功能：把该字符串重复n次！

>>> "abcd"*3
'abcdabcdabcd'

3>in

情况1：判断某字符在不在某字符串中，在返回True,不在返回False

格式：某字符 in 字符串

>>> "s" in "abcd1234"
False

情况2：判断某子字符串在不在某字符串：格式：某子字符串 in 字符串

>>> "cd12" in "abcd1234"
True

4>not in

判断某字符（子字符串）不在某字符串中，不在返回True,在返回False

>>> "cd12" not in "abcd1234"
False

4. 常用转义字符

常见的转义字符

转义字符 含义

\ \

" "

' '

\t Tab键：水平制表符

\n 换行

\r 回车键:光标移动到本行的开始处！

>>> "abcd"1234"def"
'abcd"1234"def'
>>> 'abcd'1234'def'
"abcd'1234'def"
>>> 'abcd\\1234def'
'abcd\\1234def'
>>> print('abcd\\1234def')
abcd\1234def
>>> print("abcd\t1234")
abcd	1234
>>> print("abcd\n1234")
abcd
1234
>>> print("abcd\r123456")
abcd123456

使用原始字符串，可以避免反斜杠（\）被当作转义字符解析

（在字符串的引号前面加上r，表示该字符串是一个原始字符串【不接受转义字符】）

>>> print("D:\three\two\one\now")
D:        hree        wo\one
ow
#短:手动加\
>>> print("D:\three\two")
D:\three\two
# 长：r"",使用原始字符串
>>> print(r"D:\three\two\one\now")
D:\three\two\one\now

\不能放在末尾，放在末尾表示这行代码还没结束。

5. 输出字符串

1.字符串拼接

>>> name='Jack'
>>> age=10
# 注：非字符串类型需转换
>>> print(name+" is "+str(age)+" years old")
Jack is 10 years old

2.格式化输出字符串

1.f-string (Python 3.6+ 推荐)
>>> name='Jack'
>>> score=99.8
>>> print(f"名字{name},分数{score:.3f}")
名字Jack,分数99.800

2.str.format()

>>> name='Tom'
>>> score=78.95432
>>> print("姓名：{},分数：{:.3f} ".format(name,score))
姓名：Tom,分数：78.954 

3.% 操作符 (旧式风格)
>>> name='Alice'
>>> age=20
>>> per=99.6786
>>> print("姓名：%s,年龄：%d,百分比：%.2f%%"%(name,age,per))
姓名：Alice,年龄：20,百分比：99.68%

>>> print("百分比：%.2f%%"%99.678)
百分比：99.68%
>>> name='lisa'
>>> print("%s"%name)
lisa

>>> multi_line=""" 第一行
第二行
第三行"""
>>> print(multi_line)
 第一行
第二行
第三行

str中常用方法

1.大小写字母转换

capitalize()

函数：String obj.capitalize();

功能：把字符串对象 obj 的中的首字符变大写，其他字符都变小写。

x="I love SprinG"
>>> x.capitalize()
'I love spring'
#x的值不变
>>> x
'I love SprinG'

title()

返回将字符串中每个单词首字母大写，其他字母小写的新字符串；

>>> x.title()
'I Love Spring'
#x的值不变
>>> x
'I love SprinG'

swapcase()

返回将字符串大小写翻转的新字符串

>>> x.swapcase()
'i LOVE sPRINg'
#x的值不变
>>> x
'I love SprinG'

lower() upper()

函数：String obj.lower(); 把字符串 obj 中的所有字符全部变小写！

函数：String obj.upper(); 把字符串 obj 中的所有字符全部变大写！

x的值不变

a="wrheuAKSiooJJH"
ret=a.lower()
print(ret) #wrheuaksioojjh

a="wrheuAKSiooJJH"
ret=a.upper()
print(ret) #WRHEUAKSIOOJJH

casefold()

返回全部小写的新字符串，x的值不变

>>> x="I love SprinG"
>>> x.casefold()
'i love spring'
>>> x
'I love SprinG'

casefold()和lower()区别：casefold()能处理其他语言

2.左中右对齐

center()

center(width,fillchar=’’) 居中

width指定字符串的个数；

注：都要指定width，如果指定width小于等于字符串宽度，就不要考虑对齐问题，正常输出。

fillchar 指定填充的字符，若未指定，用空格填充。

ljust()

ljust(width,fillchar())左对齐

rjust()

rjust(width,fillchar())右对齐

>>> x="我爱，春天!"
>>> x.center(15)
'     我爱，春天!    '
>>> x.ljust(15)
'我爱，春天!         '
>>> x.rjust(15)
'         我爱，春天!'

>>> x.center(15,"1")
'11111我爱，春天!1111'

zfill()

String obj.zfill(int width);

功能：使字符串 obj 扩充为指定长度！如果 width<=len(obj)，那么就原值！如果width>len(obj)，那么字符串 obj 左边补 N 个"0"字符！

>>> x.zfill(15)
'000000000我爱，春天!'
#如果有负号，0添加在负号后面
>>> "-520".zfill(5)
'-0520'

3.查找

1.count()

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

解释：返回子字符串 sub 在范围 [start, end] 内非重叠出现的次数。可选参数 start 和 end 的解释方式与切片表示法相同。

如果 sub 是空字符串，则返回字符之间空字符串的数量（即字符串长度加一）

不重叠计数：当一个子串被匹配后，搜索会从该子串之后的位置继续，而不会重叠使用已经匹配过的字符。

s = "abababa"
print(s.count("aba"))  # 输出: 2
>>> 'abc'.count('')
4

2.find() rfind()

str.find(sub[, start[, end]])-->int

解释： 返回在字符串切片 s[start:end] 中找到子字符串 sub 的最低索引（即第一次出现的位置）。可选参数 start 和 end 的用法与切片操作中的含义相同。如果未找到子字符串 sub，则返回 -1。

注意：find() 方法仅在需要知道子字符串 sub 的位置时才使用。如果只是想检查 sub 是否是字符串的子串，请使用 in 操作符。

str.rfind(sub[, start[, end]])-->int

解释： 返回在字符串切片 s[start:end] 中找到子字符串 sub 的最高索引（即最后一次出现的位置）。可选参数 start 和 end 的解释方式与切片表示法相同。如果未找到子字符串 sub，则返回 -1。

s='python python'
s.find('yth',0)
1
s.find('yy')
-1
s.rfind('yth',0)
8
s.rfind('yth',0,5)

3.index() rindex()

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

str.rindex(sub[, start[, end]])-->int

类似于 find() rfind() ，但当子字符串 sub 未找到时抛出 ValueError 异常。

4.替换

1.replace()

str.replace(old, new, count=-1)-->str

解释：返回一个字符串的副本（原字符串不变），其中所有子串 old 都被替换为 new。如果指定了 count 参数，则仅替换前 count 次出现的子串。如果未指定 count 或值为 -1，则替换所有出现的子串。

s='apple banana apple'
print(s.replace("apple","orange",1))
orange banana apple
print(s.replace("apple","orange"))
orange banana orange

2.static str.maketrans(x[, y[, z]]) str.translate(table)

解释： 此静态方法返回一个可用于 str.translate() 的转换表。

• 如果只有一个参数 (x) ：
  必须是字典类型，映射：

• • Unicode 码位（整数）或字符（长度为1的字符串）
    → Unicode 码位、任意长度的字符串或 None
    注意： 键为字符时，会被自动转换为码位

• 如果有两个参数 (x, y) ：
  必须是等长的字符串，在结果转换表中：
  x 中的每个字符 → 映射到 y 中相同位置的字符
• 如果有三个参数 (x, y, z) ：
  前两个参数同上，第三个参数必须是字符串：
  z 中的每个字符 → 映射到 None（表示删除）

str.translate(table)

解释：返回字符串的一个副本，其中每个字符都通过给定的转换表进行了映射。转换表必须是一个实现了 __getitem__() 索引操作的对象（通常是一个映射或序列）。当使用 Unicode 码位（整数）作为索引时，表对象可以执行以下任一操作：

1. 返回一个 Unicode 码位或字符串 → 将字符映射到一个或多个其他字符
2. 返回 None → 从返回字符串中删除该字符
3. 抛出 LookupError 异常 → 将字符映射为自身（保持不变）

您可以使用 str.maketrans() 根据不同的字符到字符映射格式创建转换表。

另请参阅 codecs 模块，该模块提供了更灵活的自定义字符映射方法。

注：它只能处理单个字符的转换，不能处理子字符串的替换。

# 单参（字典形式）
table=str.maketrans({'a':'A','b':None,99:'XYZ'})
"abcc".translate(table)
'AXYZXYZ'
# 双参（字符替换）
>>> table2=str.maketrans('abc','ABC')
>>> "adcc".translate(table2)
'AdCC'
#三参（替换+删除）
>>> table3=str.maketrans('abc','ABC',',.')
>>> "a,b.c..c".translate(table3)
'ABCC'

# 以下两种方式等价 （键为字符时，会被自动转换为码位） 
t1 = str.maketrans({'a': 'X'})  
t2 = str.maketrans({ord('a'): 'X'})  

#maketrans只有一个参数时，键必须是长度为1的字符串
>>> table4=str.maketrans({'99':'xyz'})
Traceback (most recent call last):
  File "<pyshell#49>", line 1, in <module>
    table4=str.maketrans({'99':'xyz'})
ValueError: string keys in translate table must be of length 1

translate() 方法的工作原理

str.translate() 方法：

• 逐字符处理：每次只处理字符串中的一个字符
• 查找转换表：对于每个字符，查找其在转换表中的对应值
• 执行操作：

• • 如果找到映射 → 进行替换/删除
  • 如果没找到 → 保留原字符

>>> "aew99".translate(str.maketrans({97:'A','9':'xyz'}))
'Aewxyzxyz'

3.str.expandtabs(tabsize=8)

将字符串中的制表符 \t 动态替换为空格，替换规则：

• 当前列从 0 开始计数
• 遇到 \t 时，插入空格直到下一个制表位（位置 = n * tabsize）
• 遇到 \n 或 \r 时重置当前列为 0
• 其他字符使当前列 +1

>>> '01\t012\t0123\t01234'.expandtabs()
'01      012     0123    01234'

>>> '01\t012\t0123\t01234'.expandtabs(4)
'01  012 0123    01234'

>>> print("Name\tAge\nJohn\t25\nAnna\t30".expandtabs(10))
Name      Age
John      25
Anna      30

5.判断

startswith() endswith()

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

判断 obj 是否是以子字符串 s 开头！如果是，返回 True

S.endswith(suffix[, start[, end]]) -> bool

判断字符串 obj 是否以字符串 s 结尾。如果是，返回 True；如果否，返回 False！

>>> a="sadas"
>>> a.startswith("aa")
False
>>> a.startswith("ad",1,3)
True

>>> a.endswith('as')
True

形参s支持以元组的形式传入多个待匹配的字符串的

>>> 'sdf'.startswith(('a','s','df'))
True

islower() isupper()

boolean obj.islower(); 判断字符串 obj 是否是全小写！

boolean obj.isupper(); 判断字符串 obj 是否是全大写！

>>> "hello".islower()
True
>>> "hello".isupper()
False

istitle()

判断一个字符串中的所有单词是否都是以大写字母开头，其余字母均为小写

>>> x="I Love Python"
>>> x.istitle()
True

isspace()

若字符串中的所有字符均为空格字符，返回“True”，否则返回“False”

此函数用于检查参数是否包含所有空格字符，例如：

' ' - 空

‘\ t’-水平标签

‘\ n’-换行符

‘\ v’-垂直标签

‘\ f’-提要

‘\ r’-回车

>>> "fds fd".isspace()
False
>>> "\v\n\f\r".isspace()
True

isdecimal()

判断字符串是否只包含十进制数字字符，如果所有字符都是十进制数字且字符串至少有一个字符，则返回True,否则返回False

范围：

• 阿拉伯数字 0-9（包括全角版本，如 １２３）
• 不包括：上标/下标数字、分数、罗马数字、汉字数字等。

"123".isdecimal()        # True
"１２３".isdecimal()      # True（全角数字）
"²".isdecimal()          # False（上标数字）
"½".isdecimal()          # False（分数）
"三".isdecimal()         # False（汉字数字）

isdigit()

检查字符串是否只包含数字字符，范围比 isdecimal() 更广

范围：

• 所有 isdecimal() 包含的内容（0-9 及全角数字）
• 上标/下标数字（如 ², ₃）
• 特殊数字符号（如 ①, ❷）

"123".isdigit()          # True
"²".isdigit()            # True（上标2）
"₃".isdigit()            # True（下标3）
"①".isdigit()            # True（带圈数字）
"½".isdigit()            # False（分数）
"三".isdigit()           # False（汉字数字）

isnumeric()

用于检查字符串中的所有字符是否都是数字字符。

• 支持 Unicode 数字字符（包括全角数字、罗马数字，中文数字，分数，其他数字符号等）
• 不包括负数符号、小数点、指数符号等
• 空字符串返回 False

>>> "一IV⑤½".isalnum()
True
>>> "一IV  ⑤½".isalnum()
False

isdecimal()、isdigit() 和 isnumeric() 三个方法都是用来判断数字的。

isdecimal() 方法是最严格的，只有真正意义上的数字才能得到 True；isnumeric() 方法是最宽松的，罗马数字、中文数字都是True。

isalpha()

判断一个字符串中是否只是由字母组成（纯英文字母）

>>> x="I Love Python"
>>> x.isalpha()
False#因为有空格

isalnum()

isalnum() 方法用于检查字符串中的所有字符是否都是字母或数字或字母+数字，是则返回 True，否则返回 False。

判断指定字符串是否由字母和数字组合

字母包括：英文字母（A-Z, a-z）、其他语言的文字（如中文、日文、韩文等）

数字包括：0-9

不包括：空格、标点符号、特殊字符

空字符串返回 False

>>> "hello123".isalnum()
True
>>> "我们24".isalnum()
True
>>> "hello".isalnum()
True
>>> "123".isalnum()
True
>>> "123!".isalnum()
False

isascii()

判断一个字符串中是否只是由 ASCII 字符组成（字符串为空或全部为ascii字符，返回true）

>>> x="I Love Python"
>>> x.isascii()
True

isprintable()

判断一个字符串中是否所有字符都是可打印的.

>>> "www\n".isprintable()
False

isidentifier()

方法用于判断该字符串是否一个合法的 Python 标识符

>>> "i aa".isidentifier()
False#有空格
>>> "66aa".isidentifier()
False
>>> "ww".isidentifier()
True

iskeyword()

keyword 模块的 iskeyword() 函数

判断一个字符串是否为 Python 的保留标识符

>>> import keyword
>>> keyword.iskeyword("for")
True

6.截取

1.str.strip([chars])

返回字符串的副本，移除首尾的指定字符。
参数 chars 是一个指定待移除字符集的字符串。
若省略或为 None，则默认移除空白字符。
需注意：chars 参数并非作为前缀或后缀整体移除，而是会移除其包含字符的所有排列组合。

str.lstrip([chars])

只移除左侧的

str.rstrip([chars])

只移除右侧的

>>> 'asda1234saa'.strip('asd')
'1234'
>>> '  \n  \t123\n  \t'.strip()
'123'
>>> 'asda1234saa'.lstrip('asd')
'1234saa'
>>> 'asda1234saa'.rstrip('asd')
'asda1234'

2.removeprefix(prefix)

str.removeprefix(prefix, /)
若字符串以指定前缀开头，则返回 string[len(prefix):] 的子串；否则返回原字符串的副本

str.removesuffix(suffix, /)
若字符串以指定后缀结尾且该后缀非空，则返回 string[:-len(suffix)] 的子串；否则返回原字符串的副本

python3.9版本中新增的字符串方法，低于3.9的版本使用会报错。

'TestHook'.removeprefix('Test')
'Hook'
'BaseTestCaseTest'.removeprefix('Test')
'BaseTestCaseTest'

'MiscTests'.removesuffix('Tests')
'Misc'
'TmpDirMixin'.removesuffix('Tests')
'TmpDirMixin'

7.拆分

1.str.split(sep=None,maxsplit=-1)

用sep字符串来把字符串obj分割为一个列表！
sep: 指定用什么字符串进行分割；即分隔符字符串！默认值是空格、\n、\t!

maxsplit:指定分割次数（即砍几刀，即砍count刀）。如果没有指定count的值，那么就是全部分割；如果指定了count，那么最终形成的列表的元素的个数=count+1

如果指定了 sep，则连续的分隔符不会组合在一起，并被视为分隔空字符串（例如，'1,，2'.split(',') 返回 ['1'， ''， '2']）。sep 参数可以由多个字符组成，作为一个单一的分隔符（若要使用多个分隔符进行分割，请使用 re.split()）。使用指定的分隔符分割一个空字符串会返回 ['']。

>>> '1,,2,3'.split(',')
['1', '', '2', '3']
>>> '1,,2,3,4'.split(',',2)
['1', '', '2,3,4']

>>> '1,,2,3'.split(',,')
['1', '2,3']

>>> ''.split(',')
['']

如果未指定 sep 或其值为 None，则应用不同的分割算法：连续的空白字符被视为一个单一的分隔符，如果字符串有开头或结尾的空白字符，则分割后结果不会在开头或结尾包含空字符串。因此，使用 None 分隔符分割一个空字符串或仅由空白字符组成的字符串会返回 []

>>> ' 1\t2 \n3  4  '.split()
['1', '2', '3', '4']

>>> '    \n\t  '.split()
[]

如果未指定 sep 或其值为 None 且 maxsplit 为 0，则仅考虑连续的空白字符的开头部分。

"".split(None, 0)

"   ".split(None, 0)

"   foo   ".split(maxsplit=0)

str.rsplit(sep=None,maxsplit=-1)

从右侧开始分割

>>> '1,,2,3,4'.rsplit(',',2)
['1,,2', '3', '4']

2.str.splitlines(keepends=False)

返回字符串按行边界分割后的列表（行边界符默认不保留）：

• 行边界符集合：包括 \n, \r, \r\n 等（符合通用换行符超集规范）
• keepends 参数：

• • 若为 False（默认），结果列表不包含行边界符
  • 若为 True，则在每行末尾保留对应的行边界符

>>> "abcdsadsad\nsadsad\nsdsa".splitlines()
['abcdsadsad', 'sadsad', 'sdsa']
>>> "as\ngsd\ngfds".splitlines(True)
['as\n', 'gsd\n', 'gfds']
>>> "as\ngsd\ngfds".splitlines(keepends=True)
['as\n', 'gsd\n', 'gfds']

3.str.partition(sep)

在字符串中首次出现分隔符的位置进行分割，返回一个包含以下三部分的三元组：

1. 分隔符之前的子串
2. 分隔符本身
3. 分隔符之后的子串

若未找到分隔符，则返回：
(原字符串, "", "")

str.rpartition(sep) 从右往左分割

>>> "www.abc.com".partition(".")
('www', '.', 'abc.com')
>>> "www.abc.com".rpartition(".")
('www.abc', '.', 'com')
>>> "www.abc.com".partition("/")
('www.abc.com', '', '')

8.拼接

str.join(iterable)

返回一个由可迭代对象中字符串连接而成的新字符串，调用该方法的字符串将作为元素间的分隔符。iterable：一个序列（字符串、列表、元组）
若可迭代对象包含非字符串值（包括 bytes 对象），将引发 TypeError。iterable中元素的值必须都是字符串

>>> '-'.join(['a','s','d'])
'a-s-d'
>>> '-'.join(['a','s',5])
Traceback (most recent call last):
  File "<pyshell#23>", line 1, in <module>
    '-'.join(['a','s',5])
TypeError: sequence item 2: expected str instance, int found