本文代码
地址github.com字符串
字符串是非常常用的数据类型,我们可以使用单引号和双引号来创建字符串,创建字符串非常简单,只需为变量赋予一个字符串值即可
# a和b分别为用单引号和双引号创建的字符串
a = 'Hello World!'
b = "Welcome to Python World!"
# c和d分别为使用三个单引号和三个双引号创建的字符串,且c和d可以保留字符串的原始形式,比如换行符等
c = '''
Hello
World!
'''
d = """
Welcome
to
Python
World!
"""
print(a)
print(b)
print(c)
print(d)
Hello World!
Welcome to Python World!
Hello
World!
Welcome
to
Python
World!
转移字符与原始字符
可以在字符串中使用来表示转义字符,如下为常见的转义字符
# 输出转义后的字符串
print("Hello World")
print(''Hello World'')
print(""Hello World"")
print("HellonWorld")
print("HellotWorld")
Hello World
'Hello World'
"Hello World"
Hello
World
Hello World
在Python中以r
或R
开头的字符串被称为原始字符串,在原始字符串中转义字符不再具有特殊意义,而是保持其原始意义
# 输出原始字符串,此时转义字符不再具有特殊意义
print(r"Hello World")
print(r''Hello World'')
print(R""Hello World"")
print(R"HellonWorld")
print(R"HellotWorld")
Hello World
'Hello World'
"Hello World"
HellonWorld
HellotWorld
Python字符串运算符
# 直接拼接两个字符串
a = "Hello " + "World"
print(a)
# 字符串重复若干次
b = "Hello " * 3
print(b)
# 拼接给定字符串后再赋值
a += "!"
print(a)
# 重复若干次之后再赋值
a *= 3
print(a)
Hello World
Hello Hello Hello
Hello World!
Hello World!Hello World!Hello World!
a = "Hello World"
b = "Welcome to Python World"
# 字符串比较
print("a > b ?: {}".format(a>b))
print("a >= b ?: {}".format(a>=b))
print("a < b ?: {}".format(a<b))
print("a <= b ?: {}".format(a<=b))
print("a == b ?: {}".format(a==b))
a > b ?: False
a >= b ?: False
a < b ?: True
a <= b ?: True
a == b ?: False
a = "Hello"
b = "World"
c = "Welcome to Python World"
# a是否出现在c中
print(a in c)
# b是否出现在c中
print(b in c)
# a是否没有出现在c中
print(a not in c)
# b是否没有出现在c中
print(b not in c)
False
True
True
False
我们可以通过下标访问字符串,下标索引从0开始,-1表示从末尾位置开始,下标大小必须小于字符串长度,索引格式为变量[start:stop:step]
,stop
和step
是可选的,我们通过如下例子来理解字符串的下标访问
a = "Welcome to Python World!"
# 第一个字符
print(a[0])
# 最后一个字符
print(a[-1])
# 下标从2开始,到12结束
print(a[2:13])
# 下标从2开始,到12结束,步长为2
print(a[2:13:2])
# 下标从2开始,一直到末尾,省略末尾索引表示一直到字符串末尾
print(a[2:])
# 下标从0开始,到12结束,省略开头索引表示索引从0开始
print(a[:13])
# 同时省略开头和结尾表示下标从0开始一直到末尾
print(a[:])
# 反向索引,从倒数第11个字符开始,到倒数第4个字符结束
print(a[-11:-3])
# 从倒数第一个字符开始,到倒数末尾字符结束,这里实现的是字符串reverse操作
print(a[::-1])
W
!
lcome to Py
loet y
lcome to Python World!
Welcome to Py
Welcome to Python World!
thon Wor
!dlroW nohtyP ot emocleW
格式化字符串
格式字符串包含有以花括号{}
括起来的替换字段,不在花括号之内的内容被视为字面文本,会不加修改地复制到输出中.
# {}将会按顺序被format中的参数替换
print("{} -> {}".format("apple", "banana"))
apple -> banana
# 可以通过整数索引显式指定参数的替换顺序,参数索引从0开始
print("{1} -> {0}".format("apple", "banana"))
banana -> apple
# 可以显式使用字段名进行替换
print("{year} -> {month}".format(year=2020, month=12))
2020 -> 12
格式化输出时可以指定对齐方式,对齐表示如下
data = [1, 10, 100, 1000, 10000]
for i in data:
print("{:<}".format(i)) # 左对齐
1
10
100
1000
10000
for i in data:
print("{:>5}".format(i)) # 右对齐,对齐时可以显式指定输出宽度,这里指定输出宽度为5
1
10
100
1000
10000
for i in data:
print("{:^5}".format(i)) # 居中对齐,对齐时可以显式指定输出宽度,这里指定输出宽度为5
1
10
100
1000
10000
# 指定输出小数点位数
a = 3.1415926
# 保留2位小数
print("{:.2f}".format(a))
3.14
# 输出百分号
a = 0.93333333
print("{:.2%}".format(a))
93.33%
# 指定数字输出进制
a = 30
# 默认以十进制格式输出
print("{}".format(a))
# 以二进制格式输出
print("{:#b}".format(a))
# 以八进制格式输出
print("{:#o}".format(a))
# 以十六进制格式输出
print("{:#x}".format(a))
30
0b11110
0o36
0x1e
字符串常用方法
count(sub, [start[,end]])
返回子字符串sub
在[start, end]
范围内出现的次数,start
和end
都是可选参数
a = "Helloo Woorld Helloo Woorld"
# 计算子字符串所有出现的次数
print(a.count("oo"))
# 给定起始范围
print(a.count("oo", 10))
# 给定起始和结束范围
print(a.count("oo", 10, 20))
4
2
1
encode(encoding="utf-8")
将字符串以一定的编码方式存储为字节串,默认为utf-8
编码
a = "Python是最简单的编程语言"
# 将Python字符串编码为字节串
b = a.encode(encoding="utf-8")
decode(encoding="utf-8")
以一定的编码方式从字节串解码出字符串,默认为utf-8
编码
# 从字节串中解码出字符串
c = b.decode(encoding="utf-8")
print(c)
Python是最简单的编程语言
startswith(prefix[,start[,end]])
如果字符串以指定的prefix
开始则返回True
,否则返回False
a = "Python World"
print(a.startswith("shit"))
# 整个字符串是否以给定字符串开始
print(a.startswith("Pyt"))
# 给定范围是否以给定字符串开始
print(a.startswith("Pyt", 3, 7))
False
True
False
endswith(suffix[,start[,end]])
如果字符串以指定的suffix
结束返回True
,否则返回False
a = "Python World"
print(a.endswith("shit"))
# 整个字符串是否以给定字符串结尾
print(a.endswith("rld"))
# 给定范围是否以给定字符串结尾
print(a.endswith("rld", 3, 7))
False
True
False
find(sub[,start[,end]])
返回子字符串sub
在s[start:end]
切片内被找到的最小索引,如果找到返回索引,未找到返回-1
a = "Pythoon Woorld"
print(a.find("shit"))
# 从整个字符串寻找
print(a.find("oo"))
# 从给定范围寻找
print(a.find("oo", 5, 15))
-1
4
9
rfind(sub[,start[,end]])
返回子字符串sub
在字符串内被找到的最大索引,如果找到返回索引,未找到返回-1,rfind
与find
的区别在于find
从前往后查找,rfind
从后往前查找
a = "Pythoon Woorld"
print(a.rfind("shit"))
# 从整个字符串寻找
print(a.rfind("oo"))
# 从给定范围寻找
print(a.rfind("oo", 2, 8))
-1
9
4
index(sub[,start[,end]])
类似于find
,找不到子字符串时将抛出ValueError
异常
a = "Pythoon Woorld"
# 从整个字符串寻找
print(a.index("oo"))
# 从给定范围寻找,找不到将抛出异常
print(a.index("oo", 5, 15))
4
9
rindex(sub[,start[,end]])
类似于rfind()
,但在子字符串sub
未找到时会引发ValueError
a = "Pythoon Woorld"
# 从整个字符串寻找,从右向左查找
print(a.rindex("oo"))
# 从给定范围寻找,找不到将抛出异常
print(a.rindex("oo", 2, 8))
9
4
# 如果只是判断子字符串是否在字符串中而不需要知道所在索引,使用in更好
"py" in "python"
True
join(iterable)
返回一个由iterable
可迭代对象中的字符串拼接而成的字符串
a = ["Welcome", "to", "Python", "World", "!"]
# 用空格拼接每个字符串
print(" ".join(a))
# 用#拼接每个字符串
print("#".join(a))
Welcome to Python World !
Welcome#to#Python#World#!
split(sep, maxsplit=-1)
返回一个由字符串内字符串组成的列表,使用sep
作为分隔字符串。 如果给出了maxsplit
选项,则最多进行maxsplit
次拆分
a = "Welcome to Python World"
b = "Welcome@to@Python@World"
# 默认使用空白符进行分割
c = a.split()
print(c)
# 显式给定分隔符
d = b.split("@")
print(d)
# 指定分割次数
e = b.split("@", maxsplit=2)
print(e)
['Welcome', 'to', 'Python', 'World']
['Welcome', 'to', 'Python', 'World']
['Welcome', 'to', 'Python@World']
upper()
返回原字符串的大写副本
a = "Welcome to Python World!"
print(a.upper())
WELCOME TO PYTHON WORLD!
lower()
返回原字符串的小写副本
a = "Welcome to Python World!"
print(a.lower())
welcome to python world!
lstrip()
返回原字符串的副本,移除其中的前导字符
a = " #Hello World"
# 默认移除空白符
print(a.lstrip())
# 显式指定要移除的字符
print(a.lstrip(" #"))
#Hello World
Hello World
rstrip()
返回原字符串的副本,移除其中的后缀字符
a = "Hello World@ "
# 默认移除空白符
print(a.rstrip())
# 显式指定要移除的字符
print(a.rstrip(" @"))
Hello World@
Hello World
strip()
返回原字符串的副本,移除其中的前导和后缀字符
a = " #Hello World!@ "
# 默认移除空白符
print(a.strip())
# 显式指定要移除的字符
print(a.strip(" #"))
print(a.strip(" @"))
print(a.strip(" #@"))
#Hello World!@
Hello World!@
#Hello World!
Hello World!
replace(old, new[count])
返回字符串的副本,其中出现的所有子字符串old
都将被替换为new
,如果给出了可选参数count
,则只替换前count
次出现
a = "Pythoon Woorld Good"
# 替换所有出现
print(a.replace("oo", "xx"))
# 指定替换次数
print(a.replace("oo", "xx", 2))
Pythxxn Wxxrld Gxxd
Pythxxn Wxxrld Good