字符串

​ 字符串是 Python 中最常用的数据类型。可以使用单引号，双引号，3对双引号创建一个字符串。Python 中没有单独的字符类型 char，一个字符就是长度为 1 的字符串。字符串中的字符不可改变。

str_1 = 'hello, python'
str_2 = "hello, python"
str_3 = """hello, python"""

索引

​ 字符串是一个有序集合，字符串中的字符是在内存中按照一定顺序存放的。每个字符都存在其特定的地址，这就是索引。字符相对位置从左向右、从 0 开始，最后是 -1。

切片

​ 切片是使用频率很高的操作。基本操作为：s[a:b] 表示为将字符串 s 从 a 截取至 b-1（左闭右开）。切片操作允许索引越界。

s = "123456789"
# 指定开始位置和结束位置
print(s[2:4])
# 单指定开始位置
print(s[3:])
# 单指定结束位置
print(s[:-3])
# 越界操作
print(s[1:100])

​ 输出样例：

34
456789
123456
23456789

• [::] 的应用

​ 两个 : 操作符将括号内分为三段即：[1:2:3]。①表示开始索引、②表示结束索引、③表示间隔。要是开始索引也没有结束索引，等价于整个列表。

s = "123456789"
print(s[::2])

​ 输出样例：

13579

转义字符

转义字符	描述
\	反斜杠符号（在行尾时为续行符）
’	单引号
"	双引号
\a	响铃
\b	退格(Backspace)
\000	空
\n	换行
\v	纵向制表符
\t	横向制表符
\r	回车
\f	换页
\oyy	八进制数，yy 代表的字符，例如：\o12 代表换行，其中 o 是字母，不是数字 0
\xyy	十六进制数，yy代表的字符，例如：\x0a代表换行
\other	其它的字符以普通格式输出

格式化符号

符号	描述
%c	格式化字符及其ASCII码
%s	格式化字符串
%d	格式化整数
%u	格式化无符号整型
%o	格式化无符号八进制数
%x	格式化无符号十六进制数
%X	格式化无符号十六进制数（大写）
%f	格式化浮点数字，可指定小数点后的精度
%e	用科学计数法格式化浮点数
%E	作用同%e，用科学计数法格式化浮点数
%g	%f和%e的简写
%G	%f 和 %E 的简写
%p	用十六进制数格式化变量的地址

f-string

​ f-string 是 Python3.6 之后添加的，字面量格式化字符串。f-string 格式化字符串以 f 开头，后面跟着字符串，字符串中的表达式用大括号 {} 包含，会将变量或表达式计算后替换。

name = "Jasper"
age = 6
print(f"My name is {name}, and I'm {age} year old!" )
print("My name is {0}, and I'm {1} year old!".format(name, age))
print("My name is {name}, and I'm {age} year old!".format(name = name, age = age))

​ 输出样例：

My name is Jasper, and I'm 6 year old!
My name is Jasper, and I'm 6 year old!
My name is Jasper, and I'm 6 year old!

字符串操作

​ 操作不会自动覆盖原先变量，需要进行赋值。

判断&检测

• string.startswith(substr, beg = 0, end = len(string))：判断指定的 string 范围内开头是否为 substr。

s = "12121"
print(s.startswith("12"))
print(s.startswith("212"))

True
False

• string.endswith(suffix, beg = 0, end = len(string))：判断指定的 string 范围内结尾是否为 suffix。

s = "12121"
print(s.endswith("21"))
print(s.endswith("221"))

True
False

• string.find(str, beg = 0, end = len(string))：检测指定的 string 范围内是否存在字串 str，返回第一次出现的索引。

s = "12121"
print(s.find("212"))
print(s.find("212", 0, 3))

1
-1

• string.rfind(str, beg = 0, end = len(string))：和 find() 类似，不过是找最后一次出现的索引。

s = "121121"
print(s.rfind("2"))
print(s.rfind("2", 0, 4))

4
1

• string.index(str, beg = 0, end = len(string))：和 find() 类似，但是在不存在的时候会报异常。

s = "12121"
print(s.index("212"))
#print(s.index("212", 0, 3))

1
# ValueError: substring not found

• string.rindex(str, beg = 0, end = len(string))：和 index() 类似，不过是从最后开始找。

s = "1121211"
print(s.index("212"))
#print(s.index("212", 0, 3))

2
# ValueError: substring not found

• string.isalnum()：如果 string 中至少有一个字符，且所有字符都是字母或数字返回 True，否则返回 False。

s = ""
print(s.isalnum())
s = "121aBc"
print(s.isalnum())
s = "121aBc()"
print(s.isalnum())

False
True
False

• string.isalpha()：如果 string 中至少有一个字符，且所有字符都是字母或中文返回 True，否则返回 False。

s = ""
print(s.isalpha())
s = "aBc哈哈哈"
print(s.isalpha())
s = "aBc哈哈哈12"
print(s.isalpha())

False
True
False

• string.isdigit()：如果 string 中只包含数字返回 True，否则返回 False。

s = ""
print(s.isdigit())
s = "一二三"
print(s.isdigit())
s = "123"
print(s.isdigit())
s = "123aBc"
print(s.isdigit())

False
False
True
False

• string.isnumeric()：如果 string 中只包含数字字符返回 True，否则返回 False。数字字符包含中文。

s = ""
print(s.isnumeric())
s = "一二三"
print(s.isnumeric())
s = "123一二三"
print(s.isnumeric())
s = "123aBc"
print(s.isnumeric())

False
True
True
False

• string.islower()：如果 string 中至少包含一个可区分大小写字符，且这些字符都是小写就返回 True，否则返回 False。

s = ""
print(s.islower())
s = "123abc"
print(s.islower())
s = "aBc"
print(s.islower())

False
True
False

• string.isupper()：如果 string 中至少包含一个可区分大小写字符，且这些字符都是大写就返回 True，否则返回 False。

s = ""
print(s.isupper())
s = "123ABC"
print(s.isupper())
s = "aBc"
print(s.isupper())

False
True
False

• string.isspace()：如果 string 中只包含空格，则返回 True，否则返回 False。

s = ""
print(s.isspace())
s = "  "
print(s.isspace())
s = "  a  "
print(s.isspace())

False
True
False

• string.istitle()：如果 string 是标题化的，返回 True，否则返回 False。

s = "this is a title"
print(s.istitle())
s = "This Is A Title"
print(s.istitle())

False
True

• string.isdecimal()：检查字符串是否只包含十进制字符，如果是返回 true，否则返回 false。

s = "123456"
print(s.isdecimal())
s = "abc123456"
print(s.isdecimal())

True
False

转换

• string.capitalize()：将字符串的第一个字符转换为大写。

s = "abcd"
print(s.capitalize())

Abcd

• string.lower()：将字符串中所有的大写字符转化为小写字符。

s = "AbCdEf"
print(s.lower())

abcdef

• string.upper()：将字符串中所有的小写字符转化为大写字符。

s = "AbCdEf"
print(s.upper())

ABCDEF

• string.swapcase()：将 string 中的大写转化为小写，小写转化为大写。

s = "AbCdEf"
print(s.swapcase())

aBcDeF

• string.expandtabs(tabsize = 8)：将字符串中的 tab 符号转化为空格。（以下实例为菜鸟教程上的）

str = "runoob\t12345\tabc"
print('原始字符串: {}'.format(str))# 默认 8 个空格
# runnob 有 6 个字符，后面的 \t 填充 2 个空格
# 12345 有 5 个字符，后面的 \t 填充 3 个空格
print('替换 \\t 符号: {}'.format(str.expandtabs()))# 2 个空格
# runnob 有 6 个字符，刚好是 2 的 3 倍，后面的 \t 填充 2 个空格
# 12345 有 5 个字符，不是 2 的倍数，后面的 \t 填充 1 个空格
print('使用 2 个空格替换 \\t 符号: {}'.format(str.expandtabs(2)))# 3 个空格
print('使用 3 个空格: {}'.format(str.expandtabs(3)))
# 4 个空格
print('使用 4 个空格: {}'.format(str.expandtabs(4)))
# 5 个空格
print('使用 5 个空格: {}'.format(str.expandtabs(5)))
# 6 个空格
print('使用 6 个空格: {}'.format(str.expandtabs(6)))

原始字符串: runoob	12345	abc
替换 \t 符号: runoob  12345   abc
使用 2 个空格替换 \t 符号: runoob  12345 abc
使用 3 个空格: runoob   12345 abc
使用 4 个空格: runoob  12345   abc
使用 5 个空格: runoob    12345     abc
使用 6 个空格: runoob      12345 abc

• string.title()：返回标题化的字符串。标题化：所有单词首字母为大写，其余为小写。

s = "this is a title"
print(s.title())

This Is A Title

• string.maketrans(intab, outtab)：创建字符映射的转换表，对于接受两个参数的最简单的调用方式，第一个参数是字符串，表示需要转换的字符，第二个参数也是字符串表示转换的目标。
• translate(table, deletechars = "")：根据 str 给出的表(包含 256 个字符)转换 string 的字符, 要过滤掉的字符放到 deletechars 参数中。（以下实例为菜鸟教程上的）

from string import maketrans   # 必须调用 maketrans 函数。intab = "aeiou"
outtab = "12345"
trantab = maketrans(intab, outtab)str = "this is string example....wow!!!";
print str.translate(trantab);

th3s 3s str3ng 2x1mpl2....w4w!!!

• string.replace(str1, str2, max_num)：将 string 中的 str1 字串替换为 str2。

s = "aabbaabb"
print(s.replace("aa", "***"))
print(s.replace("aa", "***", 1))

***bb***bb
***bbaabb

剪切&填充

• string.center(width, fillchar = " ")：返回指定宽度的居中字符串，使用 fillchar 填充。

s = "abcd"
print(s.center(2,"*"))
print(s.center(9,"*"))
print(s.center(10,"*"))

abcd
***abcd**
***abcd***

• string.ljust(width, fillchar = " ")：返回指定宽度的左对齐字符串，使用 fillchar 填充。

s = "1234"
print(s.ljust(2, "*"))
print(s.ljust(10, "*"))

1234
1234******

• string.rjust(width, fillchar = " ")：返回指定宽度的右对齐字符串，使用 fillchar 填充。

s = "1234"
print(s.rjust(2, "*"))
print(s.rjust(10, "*"))

1234
******1234

• string.zfill(width)：返回指定宽度的右对齐字符串，前面填充 0。

s = "1234"
print(s.zfill(2))
print(s.zfill(10))

1234
0000001234

• string.lstrip(str = " ")：截取 string 左边的空格或指定字符，每个字符都进行判定。

s = "   111222333"
print(s.lstrip())
print(s.lstrip(" 12"))
print(s.lstrip("12"))

111222333
333111222333

• string.rstrip(str = " ")：截取 string 右边的空格或指定字符，每个字符都进行判定。

s = "111222333   "
print(s.rstrip())
print(s.rstrip(" 32"))
print(s.rstrip("32"))

111222333
111
111222333   

• string.strip(str = " ")：同时在 string 执行 lstrip 和 rstrip。

s = "111222333   "
print(s.rstrip())
print(s.rstrip(" 32"))
print(s.rstrip("32"))

111222333
111
111222333   

拼接

• string.split(str = "", num = string.count(str))：以 str 为分隔符截取字符串，如果 num 有指定值，则仅截取 num+1 个子字符串。

s = "1,2,3,4,5,6"
print(s.split(","))
print(s.split(",", 3))

['1', '2', '3', '4', '5', '6']
['1', '2', '3', '4,5,6']

• string.splitlines([keepends])：按照行(‘\r’, ‘\r\n’, \n’)分隔，返回一个包含各行作为元素的列表，如果参数 keepends 为 False，不包含换行符，如果为 True，则保留换行符。（以下实例为菜鸟教程上的）

str1 = 'ab c\n\nde fg\rkl\r\n'
print str1.splitlines();str2 = 'ab c\n\nde fg\rkl\r\n'
print str2.splitlines(True)

['ab c', '', 'de fg', 'kl']
['ab c\n', '\n', 'de fg\r', 'kl\r\n']

• string.join(seq)：以 string 为分割符，将 seq 中所有的元素合并为一个新的字符串。（seq 中元素必须都是字符串）

s = "1234"
print(','.join(s))
lst = ["1","2","3","4"]
print('*'.join(lst))

1,2,3,4
1*2*3*4

统计

• string.count(str, beg = 0, end = len(string))：统计在 str 出现次数。

s = "12121"
print(s.count("1"))
print(s.count("1", 0, 4))

3
2

• len(string)：返回字符串长度。

s = "1234"
print(len(s))

4

• max(string)：返回 string 中最大的字母。（小写字母 大于 大写字母）

s = "abcABCZ"
print(max(s))

c

• min(string)：返回 string 中最小的字母。（小写字母 大于 大写字母）

s = "abcABCZ"
print(min(s))

A

格式转化

​ sting 与 int、float、bool 相互转化：（float 转化 int 会报错）

①string $\iff$ int

a, s = 111, "222"
# int -> string
print(str(a), type(str(a)))
# string -> int
print(int(s), type(int(s)))

111 <class 'str'>
222 <class 'int'>

②string $\iff$ float

a, b, s1, s2 = 11, 11.1, "22", "22.2"
# float -> string
print(str(a), type(str(a)))
print(str(b), type(str(b)))
# string -> float
print(float(s1), type(float(s1)))
print(float(s2), type(float(s2)))

11 <class 'str'>
11.1 <class 'str'>
22.0 <class 'float'>
22.2 <class 'float'>

③string $\iff$ bool

• 只有空字符会转化为 False，其余都是 True。

s1, s2, s3, s4, f = "", " ", "True", "False", True
# bool -> string
print(str(f), type(str(f)))
print(bool(s1), type(bool(s1)))
print(bool(s2), type(bool(s2)))
print(bool(s3), type(bool(s3)))
print(bool(s4), type(bool(s4)))

True <class 'str'>
False <class 'bool'>
True <class 'bool'>
True <class 'bool'>
True <class 'bool'>

练习

1.将字符串 “abcd” 转成大写。

2.计算字符串 “cd” 在 字符串 "abcd"中出现的位置。

3.字符串 “a,b,c,d” ，请用逗号分割字符串，分割后的结果是什么类型的？

4.string = “Python is good”, 请将字符串里的Python替换成 python,并输出替换后的结果。

5.有一个字符串 string = “python修炼第一期.html”，请写程序从这个字符串里获得.html前面的部分，要用尽可能多的方式来做这个事情。

6.如何获取字符串的长度？

7.“this is a book”，请将字符串里的book替换成apple。

8.“this is a book”，请用程序判断该字符串是否以this开头。

9.“this is a book”，请用程序判断该字符串是否以apple结尾。

10.“This IS a book”，请将字符串里的大写字符转成小写字符。

11.“This IS a book”，请将字符串里的小写字符，转成大写字符。

12.“this is a book\n”，字符串的末尾有一个回车符，请将其删除。

13.统计字符串a="Krungthepmahanakhon Amonrattanakosin Mahintharayutthaya Mahadilokphop Noppharatratchathaniburirom Udomratchaniwetmahasathan Amonphimanawatansathit Sakkathattiyawitsanukamprasit"中每个字符的次数。(忽略空格，不区分大小写，即A和a表示同一个。)

参考答案，仅供参考

1.将字符串 “abcd” 转成大写。

s = "abcd"
print(s.upper())

2.计算字符串 “cd” 在 字符串 "abcd"中出现的位置。

s = "abcd"
print(s.find("cd"))

3.字符串 “a,b,c,d” ，请用逗号分割字符串，分割后的结果是什么类型的？

s = "a,b,c,d"
a = s.split(",")
print(a, type(a))

4.string = “Python is good”, 请将字符串里的Python替换成 python,并输出替换后的结果。

s = "Python is good"
a = s.replace("Python", "python")
print(a)

5.有一个字符串 string = “python修炼第一期.html”，请写程序从这个字符串里获得.html前面的部分，要用尽可能多的方式来做这个事情。

s = "python修炼第一期.html"
print(s.rstrip(".html"))
print(s.replace(".html", ""))
print(s[0:s.find(".html")])
print(s.split(".html")[0])

6.如何获取字符串的长度？

s = "1234"
print(len(s))

7.“this is a book”，请将字符串里的book替换成apple。

s = "this is a book"
print(s.replace("book", "apple"))

8.“this is a book”，请用程序判断该字符串是否以this开头。

s = "this is a book"
print(s.startswith("this"))

9.“this is a book”，请用程序判断该字符串是否以apple结尾。

s = "this is a book"
print(s.endswith("apple"))

10.“This IS a book”，请将字符串里的大写字符转成小写字符。

s = "This IS a book"
print(s.lower())

11.“This IS a book”，请将字符串里的小写字符，转成大写字符。

s = "This IS a book"
print(s.upper())

12.“this is a book\n”，字符串的末尾有一个回车符，请将其删除。（这个好像和题 5 差不多）

s = "this is a book\n"
print(s.rstrip("\n"))
print(s.replace("\n", ""))
print(s[0:s.find("\n")])
print(s.split("\n")[0])

13.统计字符串a="Krungthepmahanakhon Amonrattanakosin Mahintharayutthaya Mahadilokphop Noppharatratchathaniburirom Udomratchaniwetmahasathan Amonphimanawatansathit Sakkathattiyawitsanukamprasit"中每个字符的次数。(忽略空格，不区分大小写，即A和a表示同一个。)

s = "Krungthepmahanakhon Amonrattanakosin Mahintharayutthaya Mahadilokphop Noppharatratchathaniburirom Udomratchaniwetmahasathan Amonphimanawatansathit Sakkathattiyawitsanukamprasit"
letter = 0
space = 0
digit = 0
other = 0
for i in s:if i.isalpha():#判断字母letter += 1elif i.isspace():#判断空格space += 1elif i.isdigit():#判断数字digit += 1else:other += 1
print("字母:{},空格:{},数字:{},其他:{}".format(letter, space, digit, other))