c++检测a字符串是否包含b字符串_Python全栈之路-3-字符串

本文代码

地址​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