# 字符串概念：由单个字符串组成的一个集合
# 普通字符串（非原始字符串）
str = "abc"
print(str) # abc
# 原始字符串（前面加r)
str = r"abc"
print(str) # abc
# 上面2个字符串区别，普通字符串可以加入转义字符，可以使用%来填坑
str = "ab\tc";
print(str) # ab c
# 原始字符串里面的输出按原型打印
str = r"ab\tc";
print(str) # ab\tc
# 字符串的一般操作
#---------------------------- 字符串拼接的4种方式 -----------------------------------#
str1 = "hello "
str2 = "world!"
# 方式一：+
str = str1 + str2 # hello world!
# 多个字符串连接
str = "hello ""world!" # hello world!
# 填坑发
str = "hello %s"%str2 # hello world!
# 字符串乘法
str = "hello world! "*3 # hello world! hello world! hello world!
print(str)
#---------------------------- 字符串切片（获取一个字符串的某个片段）-------------------#
# name[起始:结束:步长]
name = "hello world"
print(name[0:6:1]) # hello
print(name[-1:-6:-1])# dlrow 用作反转字符串
# ----------------------------------------字符串函数操作--------------------------------#
# 作用
# 计算字符串的字符个数
# 语法
# len(name)
# 参数
# 字符串
# 返回值
# 整型
# 字符个数
name = "hello world"
print(len(name)) # 11
#字符串类的操作函数
# find
# 作用
# 查找子串索引位置
# 语法
# find(sub, start=0, end=len(str))
# 参数
# 参数1-sub
# 需要检索的字符串
# 参数2-start
# 检索的起始位置
# 可省略, 默认0
# 参数3-end
# 检索的结束位置
# 可省略, 默认len(str)
# 返回值
# 找到了
# 指定索引
# 整型
# 找不到
# -1
# 注意
# 从左到右进行查找
# 找到后立即停止
name = "hello world"
print(name.find("o"))
# rfindo
# 功能使用, 同find
# 区别
# 从右往左进行查找
name = "hello world"
print(name.rfind("o"))
# index
# 作用
# 获取子串索引位置
# 语法
# index(sub, start=0, end=len(str))
# 参数
# 参数1-sub
# 需要检索的字符串
# 参数2-start
# 检索的起始位置
# 可省略, 默认0
# 参数3-end
# 检索的结束位置
# 可省略, 默认len(str)
# 返回值
# 找到了
# 指定索引
# 整型
# 找不到
# 异常
# 注意
# 从左到右进行查找
# 找到后立即停止
name = "hello,world"
print(name.index("e")) # 1 如果没有找到，则程序会报错
# rindex
# 功能使用, 同index
# 区别
# 从右往左进行查找
# count
# 作用
# 计算某个子字符串的出现个数
# 语法
# count(sub, start=0, end=len(str))
# 参数
# 参数1-sub
# 需要检索的字符串
# 参数2-start
# 检索的起始位置
# 可省略, 默认0
# 参数3-end
# 检索的结束位置
# 可省略, 默认len(str)
# 返回值
# 子字符串出现的个数
# 整型
name = "hello,world"
print(name.count("o")) # 2
# replace
# 作用
# 使用给定的新字符串 替换原字符串中的 旧字符串
# 语法
# replace(old, new[, count])
# 参数
# 参数1-old
# 需要被替换的旧字符串
# 参数2-new
# 替换后的新字符串
# 参数3-count
# 替换的个数
# 可省略, 表示替换全部
# 返回值
# 替换后的结果字符串
# 注意
# 并不会修改原字符串本身
name = ‘hello,world‘
print(name.replace("world","你好")) # hello,你好
# capitalize
# 作用
# 将字符串首字母变为大写
# 语法
# capitalize()
# 参数
# 无
# 返回值
# 首字符大写后的新字符串
# 注意
# 并不会修改原字符串本身
name = "hello,world"
print(name.capitalize()) # Hello,world
# title
# 作用
# 将字符串每个单词的首字母变为大写
# 语法
# title()
# 参数
# 无
# 返回值
# 每个单词首字符大写后的新字符串
# 注意
# 并不会修改原字符串本身
name = "hello,world"
print(name.title()) # Hello,World
# lower
# 作用
# 将字符串每个字符都变为小写
# 语法
# lower()
# 参数
# 无
# 返回值
# 全部变为小写后的新字符串
# 注意
# 并不会修改原字符串本身
name = "HellO,WORLD"
print(name.lower()) #hello,world
# upper
# 作用
# 将字符串每个字符都变为大写
# 语法
# upper()
# 参数
# 无
# 返回值
# 全部变为大写后的新字符串
# 注意
# 并不会修改原字符串本身
name = "hello,world"
print(name.upper()) # HELLO,WORLD
# ljust
# 作用
# 根据指定字符(1个), 将原字符串填充够指定长度
# l
# 表示原字符串靠左
# 语法
# ljust(width, fillchar)
# 参数
# 参数1-width
# 指定结果字符串的长度
# 参数2-fillchar
# 如果原字符串长度 < 指定长度时
# 填充过去的字符
# 返回值
# 填充完毕的结果字符串
# 注意
# 不会修改原字符串
# 填充字符的长度为1
# 只有原字符串长度 < 指定结果长度时才会填充
name = "hello"
print(name.ljust(8,"x")) # helloxxx
# rjust
# 作用
# 根据指定字符(1个), 将原字符串填充够指定长度
# r
# 表示原字符串靠右
# 语法
# rjust(width, fillchar)
# 参数
# 参数1-width
# 指定结果字符串的长度
# 参数2-fillchar
# 如果原字符串长度 < 指定长度时
# 填充过去的字符
# 返回值
# 填充完毕的结果字符串
# 注意
# 不会修改原字符串
# 填充字符的长度为1
# 只有原字符串长度 < 指定结果长度时才会填充
name = "hello"
print(name.rjust(8,‘x‘)) #xxxhello
# center
# 作用
# 根据指定字符(1个), 将原字符串填充够指定长度
# center
# 表示原字符串居中
# 语法
# center(width, fillchar)
# 参数
# 参数1-width
# 指定结果字符串的长度
# 参数2-fillchar
# 如果原字符串长度 < 指定长度时
# 填充过去的字符
# 返回值
# 填充完毕的结果字符串
# 注意
# 不会修改原字符串
# 填充字符的长度为1
# 只有原字符串长度 < 指定结果长度时才会填充
name = "hello"
print(name.center(8,‘x‘)) # xhelloxx
# lstrip
# 作用
# 移除所有原字符串指定字符(默认为空白字符)
# l
# 表示从左侧开始移除
# 语法
# lstrip(chars)
# 参数
# 参数-chars
# 需要移除的字符集
# 表现形式为字符串
# "abc"
# 表示,"a"|"b"|"c"
# 返回值
# 移除完毕的结果字符串
# 注意
# 不会修改原字符串
name = " hello, world "
print(name.lstrip()) #hello, world
# rstrip
# 作用
# 移除所有原字符串指定字符(默认为空白字符)
# r
# 表示从右侧开始移除
# 语法
# rstrip(chars)
# 参数
# 参数-chars
# 需要移除的字符集
# 表现形式为字符串
# "abc"
# 表示,"a"|"b"|"c"
# 返回值
# 移除完毕的结果字符串
# 注意
# 不会修改原字符串
name = " hello, world "
print(name.rstrip()) # hello, world
# split
# 作用
# 将一个大的字符串分割成几个子字符串
# 语法
# split(sep, maxsplit)
# 参数
# 参数1-sep
# 分隔符
# 参数2-maxsplit
# 最大的分割次数
# 可省略, 有多少分割多少
# 返回值
# 分割后的子字符串, 组成的列表
# list 列表类型
# 注意
# 并不会修改原字符串本身
name = "ab-cd-ef-0773-211888"
print(name.split("-")) #[‘ab‘, ‘cd‘, ‘ef‘, ‘0773‘, ‘211888‘]
print(name.split("-",3))#[‘ab‘, ‘cd‘, ‘ef‘, ‘0773-211888‘]
# partition
# 作用
# 根据指定的分隔符, 返回(分隔符左侧内容, 分隔符, 分隔符右侧内容)
# 语法
# partition(sep)
# 参数
# 参数-sep
# 分隔符
# 返回值
# 如果查找到分隔符
# (分隔符左侧内容, 分隔符, 分隔符右侧内容)
# tuple 类型
# 如果没有查找到分隔符
# (原字符串, "", "")
# tuple 类型
# 注意
# 不会修改原字符串
# 从左侧开始查找分隔符
name = "ab-cd-ef-0773-211888"
print(name.partition("-"))#(‘ab‘, ‘-‘, ‘cd-ef-0773-211888‘)
# rpartition
# 作用
# 根据指定的分隔符, 返回(分隔符左侧内容, 分隔符, 分隔符右侧内容)
# r
# 表示从右侧开始查找分隔符
# 语法
# partition(sep)
# 参数
# 参数-sep
# 分隔符
# 返回值
# 如果查找到分隔符
# (分隔符左侧内容, 分隔符, 分隔符右侧内容)
# tuple 类型
# 如果没有查找到分隔符
# (原字符串, "", "")
# tuple 类型
# 注意
# 不会修改原字符串
# 从右侧开始查找分隔符
name = "ab-cd-ef-0773-211888"
print(name.rpartition("-"))#(‘ab-cd-ef-0773‘, ‘-‘, ‘211888‘)
# splitlines
# 作用
# 按照换行符(\r, \n), 将字符串拆成多个元素, 保存到列表中
# 语法
# splitlines(keepends)
# 参数
# 参数-keepends
# 是否保留换行符
# bool 类型
# 返回值
# 被换行符分割的多个字符串, 作为元素组成的列表
# list 类型
# 注意
# 不会修改原字符串
name = "hello\nworld\rnihao"
print(name.splitlines()) #[‘hello‘, ‘world‘, ‘nihao‘]
# join
# 作用
# 根据指定字符串, 将给定的可迭代对象, 进行拼接, 得到拼接后的字符串
# 语法
# join(iterable)
# 参数
# iterable
# 可迭代的对象
# 字符串
# 元组
# 列表
# ...
# 返回值
# 拼接好的新字符串
name = "abcdef"
print(‘-‘.join(name)) #a-b-c-d-e-f
# isalpha
# 作用
# 字符串中是否所有的字符都是字母
# 不包含该数字,特殊符号,标点符号等等
# 至少有一个字符
# 语法
# isalpha()
# 参数
# 无
# 返回值
# 是否全是字母
# bool 类型
name = "hello"
print(name.isalpha()) #True
name = "hello,world"
print(name.isalpha()) #False
name = "hh88"
print(name.isalpha()) #False
# isdigit
# 作用
# 字符串中是否所有的字符都是数字
# 不包含该字母,特殊符号,标点符号等等
# 至少有一个字符
# 语法
# isdigit()
# 参数
# 无
# 返回值
# 是否全是数字
# bool 类型
name = "123"
print(name.isdigit())#True
name = "1234a"
print(name.isdigit())#False
# isalnum
# 作用
# 字符串中是否所有的字符都是数字或者字母
# 不包含该特殊符号,标点符号等等
# 至少有一个字符
# 语法
# isalnum()
# 参数
# 无
# 返回值
# 是否全是数字或者字母
# bool 类型
name = "abc123"
print(name.isalnum())#True
name = "abc"
print(name.isalnum())#True
name = "abc-"
print(name.isalnum())#False
name = "123"
print(name.isalnum())#True
name = "123."
print(name.isalnum())#False
# isspace
# 作用
# 字符串中是否所有的字符都是空白符
# 包括空格,缩进,换行等不可见转义符
# 至少有一个字符
# 语法
# isspace()
# 参数
# 无
# 返回值
# 是否全是空白符
# bool 类型
name = " "
print(name.isspace())#True
name = "abd c"
print(name.isspace())#Flase
# startswith
# 作用
# 判定一个字符串是否以某个前缀开头
# 语法
# startswith(prefix, start=0, end=len(str))
# 参数
# 参数1-prefix
# 需要判定的前缀字符串
# 参数2-start
# 判定起始位置
# 参数3-end
# 判定结束位置
# 返回值
# 是否以指定前缀开头
# bool 类型
name = "hello"
print(name.startswith("h"))#True
print(name.startswith("e"))#Flase
# endswith
# 作用
# 判定一个字符串是否以某个后缀结尾
# 语法
# endswith(suffix, start=0, end=len(str))
# 参数
# 参数1-suffix
# 需要判定的后缀字符串
# 参数2-start
# 判定起始位置
# 参数3-end
# 判定结束位置
# 返回值
# 是否以指定后缀结尾
# bool 类型
name = "hello"
print(name.endswith("o"))#True
print(name.endswith("e"))#False
# 补充
# in
# 判定一个字符串, 是否被另外一个字符串包含
# not in
# 判定一个字符串, 是否不被另外一个字符串包含
name = "hello"
print("h" in name) #True
print("c" in name) #False
print("c" not in name) #True
# 字符串概念：由单个字符串组成的一个集合
# 普通字符串（非原始字符串）str = "abc"print(str) # abc
# 原始字符串（前面加r)str = r"abc"print(str) # abc
# 上面2个字符串区别，普通字符串可以加入转义字符，可以使用%来填坑str = "ab\tc";print(str) # ab c
# 原始字符串里面的输出按原型打印
str = r"ab\tc";print(str) # ab\tc
# 字符串的一般操作#---------------------------- 字符串拼接的4种方式 -----------------------------------#str1 = "hello "str2 = "world!"# 方式一：+str = str1 + str2 # hello world!# 多个字符串连接str = "hello ""world!" # hello world!# 填坑发str = "hello %s"%str2 # hello world!# 字符串乘法str = "hello world! "*3 # hello world! hello world! hello world!print(str)
#---------------------------- 字符串切片（获取一个字符串的某个片段）-------------------## name[起始:结束:步长]name = "hello world"print(name[0:6:1]) # helloprint(name[-1:-6:-1])# dlrow 用作反转字符串
# ----------------------------------------字符串函数操作--------------------------------## 作用# 计算字符串的字符个数# 语法# len(name)# 参数# 字符串# 返回值# 整型# 字符个数name = "hello world"print(len(name)) # 11
#字符串类的操作函数
# find# 作用# 查找子串索引位置# 语法# find(sub, start=0, end=len(str))# 参数# 参数1-sub# 需要检索的字符串# 参数2-start# 检索的起始位置# 可省略, 默认0# 参数3-end# 检索的结束位置# 可省略, 默认len(str)# 返回值# 找到了# 指定索引# 整型# 找不到# -1# 注意# 从左到右进行查找# 找到后立即停止name = "hello world"print(name.find("o"))
# rfindo# 功能使用, 同find# 区别# 从右往左进行查找name = "hello world"print(name.rfind("o"))
# index# 作用# 获取子串索引位置# 语法# index(sub, start=0, end=len(str))# 参数# 参数1-sub# 需要检索的字符串# 参数2-start# 检索的起始位置# 可省略, 默认0# 参数3-end# 检索的结束位置# 可省略, 默认len(str)# 返回值# 找到了# 指定索引# 整型# 找不到# 异常# 注意# 从左到右进行查找# 找到后立即停止name = "hello,world"print(name.index("e")) # 1 如果没有找到，则程序会报错
# rindex# 功能使用, 同index# 区别# 从右往左进行查找
# count# 作用# 计算某个子字符串的出现个数# 语法# count(sub, start=0, end=len(str))# 参数# 参数1-sub# 需要检索的字符串# 参数2-start# 检索的起始位置# 可省略, 默认0# 参数3-end# 检索的结束位置# 可省略, 默认len(str)# 返回值# 子字符串出现的个数# 整型
name = "hello,world"print(name.count("o")) # 2
# replace# 作用# 使用给定的新字符串 替换原字符串中的 旧字符串# 语法# replace(old, new[, count])# 参数# 参数1-old# 需要被替换的旧字符串# 参数2-new# 替换后的新字符串# 参数3-count# 替换的个数# 可省略, 表示替换全部# 返回值# 替换后的结果字符串# 注意# 并不会修改原字符串本身name = ‘hello,world‘print(name.replace("world","你好")) # hello,你好
# capitalize# 作用# 将字符串首字母变为大写# 语法# capitalize()# 参数# 无# 返回值# 首字符大写后的新字符串# 注意# 并不会修改原字符串本身name = "hello,world"print(name.capitalize()) # Hello,world
# title# 作用# 将字符串每个单词的首字母变为大写# 语法# title()# 参数# 无# 返回值# 每个单词首字符大写后的新字符串# 注意# 并不会修改原字符串本身name = "hello,world"print(name.title()) # Hello,World# lower# 作用# 将字符串每个字符都变为小写# 语法# lower()# 参数# 无# 返回值# 全部变为小写后的新字符串# 注意# 并不会修改原字符串本身name = "HellO,WORLD"print(name.lower()) #hello,world
# upper# 作用# 将字符串每个字符都变为大写# 语法# upper()# 参数# 无# 返回值# 全部变为大写后的新字符串# 注意# 并不会修改原字符串本身
name = "hello,world"print(name.upper()) # HELLO,WORLD
# ljust# 作用# 根据指定字符(1个), 将原字符串填充够指定长度# l# 表示原字符串靠左# 语法# ljust(width, fillchar)# 参数# 参数1-width# 指定结果字符串的长度# 参数2-fillchar# 如果原字符串长度 < 指定长度时# 填充过去的字符# 返回值# 填充完毕的结果字符串# 注意# 不会修改原字符串# 填充字符的长度为1# 只有原字符串长度 < 指定结果长度时才会填充name = "hello"print(name.ljust(8,"x")) # helloxxx
# rjust# 作用# 根据指定字符(1个), 将原字符串填充够指定长度# r# 表示原字符串靠右# 语法# rjust(width, fillchar)# 参数# 参数1-width# 指定结果字符串的长度# 参数2-fillchar# 如果原字符串长度 < 指定长度时# 填充过去的字符# 返回值# 填充完毕的结果字符串# 注意# 不会修改原字符串# 填充字符的长度为1# 只有原字符串长度 < 指定结果长度时才会填充name = "hello"print(name.rjust(8,‘x‘)) #xxxhello
# center# 作用# 根据指定字符(1个), 将原字符串填充够指定长度# center# 表示原字符串居中# 语法# center(width, fillchar)# 参数# 参数1-width# 指定结果字符串的长度# 参数2-fillchar# 如果原字符串长度 < 指定长度时# 填充过去的字符# 返回值# 填充完毕的结果字符串# 注意# 不会修改原字符串# 填充字符的长度为1# 只有原字符串长度 < 指定结果长度时才会填充name = "hello"print(name.center(8,‘x‘)) # xhelloxx# lstrip# 作用# 移除所有原字符串指定字符(默认为空白字符)# l# 表示从左侧开始移除# 语法# lstrip(chars)# 参数# 参数-chars# 需要移除的字符集# 表现形式为字符串# "abc"# 表示,"a"|"b"|"c"# 返回值# 移除完毕的结果字符串# 注意# 不会修改原字符串name = " hello, world "print(name.lstrip()) #hello, world# rstrip# 作用# 移除所有原字符串指定字符(默认为空白字符)# r# 表示从右侧开始移除# 语法# rstrip(chars)# 参数# 参数-chars# 需要移除的字符集# 表现形式为字符串# "abc"# 表示,"a"|"b"|"c"# 返回值# 移除完毕的结果字符串# 注意# 不会修改原字符串
name = " hello, world "print(name.rstrip()) # hello, world
# split# 作用# 将一个大的字符串分割成几个子字符串# 语法# split(sep, maxsplit)# 参数# 参数1-sep# 分隔符# 参数2-maxsplit# 最大的分割次数# 可省略, 有多少分割多少# 返回值# 分割后的子字符串, 组成的列表# list 列表类型# 注意# 并不会修改原字符串本身name = "ab-cd-ef-0773-211888"print(name.split("-")) #[‘ab‘, ‘cd‘, ‘ef‘, ‘0773‘, ‘211888‘]print(name.split("-",3))#[‘ab‘, ‘cd‘, ‘ef‘, ‘0773-211888‘]
# partition# 作用# 根据指定的分隔符, 返回(分隔符左侧内容, 分隔符, 分隔符右侧内容)# 语法# partition(sep)# 参数# 参数-sep# 分隔符# 返回值# 如果查找到分隔符# (分隔符左侧内容, 分隔符, 分隔符右侧内容)# tuple 类型# 如果没有查找到分隔符# (原字符串, "", "")# tuple 类型# 注意# 不会修改原字符串# 从左侧开始查找分隔符name = "ab-cd-ef-0773-211888"print(name.partition("-"))#(‘ab‘, ‘-‘, ‘cd-ef-0773-211888‘)
# rpartition# 作用# 根据指定的分隔符, 返回(分隔符左侧内容, 分隔符, 分隔符右侧内容)# r# 表示从右侧开始查找分隔符# 语法# partition(sep)# 参数# 参数-sep# 分隔符# 返回值# 如果查找到分隔符# (分隔符左侧内容, 分隔符, 分隔符右侧内容)# tuple 类型# 如果没有查找到分隔符# (原字符串, "", "")# tuple 类型# 注意# 不会修改原字符串# 从右侧开始查找分隔符name = "ab-cd-ef-0773-211888"print(name.rpartition("-"))#(‘ab-cd-ef-0773‘, ‘-‘, ‘211888‘)
# splitlines# 作用# 按照换行符(\r, \n), 将字符串拆成多个元素, 保存到列表中# 语法# splitlines(keepends)# 参数# 参数-keepends# 是否保留换行符# bool 类型# 返回值# 被换行符分割的多个字符串, 作为元素组成的列表# list 类型# 注意# 不会修改原字符串name = "hello\nworld\rnihao"print(name.splitlines()) #[‘hello‘, ‘world‘, ‘nihao‘]
# join# 作用# 根据指定字符串, 将给定的可迭代对象, 进行拼接, 得到拼接后的字符串# 语法# join(iterable)# 参数# iterable# 可迭代的对象# 字符串# 元组# 列表# ...# 返回值# 拼接好的新字符串
name = "abcdef"print(‘-‘.join(name)) #a-b-c-d-e-f
# isalpha# 作用# 字符串中是否所有的字符都是字母# 不包含该数字,特殊符号,标点符号等等# 至少有一个字符# 语法# isalpha()# 参数# 无# 返回值# 是否全是字母# bool 类型name = "hello"print(name.isalpha()) #Truename = "hello,world"print(name.isalpha()) #Falsename = "hh88"print(name.isalpha()) #False
# isdigit# 作用# 字符串中是否所有的字符都是数字# 不包含该字母,特殊符号,标点符号等等# 至少有一个字符# 语法# isdigit()# 参数# 无# 返回值# 是否全是数字# bool 类型name = "123"print(name.isdigit())#Truename = "1234a"print(name.isdigit())#False
# isalnum# 作用# 字符串中是否所有的字符都是数字或者字母# 不包含该特殊符号,标点符号等等# 至少有一个字符# 语法# isalnum()# 参数# 无# 返回值# 是否全是数字或者字母# bool 类型name = "abc123"print(name.isalnum())#Truename = "abc"print(name.isalnum())#Truename = "abc-"print(name.isalnum())#Falsename = "123"print(name.isalnum())#Truename = "123."print(name.isalnum())#False
# isspace# 作用# 字符串中是否所有的字符都是空白符# 包括空格,缩进,换行等不可见转义符# 至少有一个字符# 语法# isspace()# 参数# 无# 返回值# 是否全是空白符# bool 类型
name = " "print(name.isspace())#Truename = "abd c"print(name.isspace())#Flase# startswith# 作用# 判定一个字符串是否以某个前缀开头# 语法# startswith(prefix, start=0, end=len(str))# 参数# 参数1-prefix# 需要判定的前缀字符串# 参数2-start# 判定起始位置# 参数3-end# 判定结束位置# 返回值# 是否以指定前缀开头# bool 类型
name = "hello"print(name.startswith("h"))#Trueprint(name.startswith("e"))#Flase# endswith# 作用# 判定一个字符串是否以某个后缀结尾# 语法# endswith(suffix, start=0, end=len(str))# 参数# 参数1-suffix# 需要判定的后缀字符串# 参数2-start# 判定起始位置# 参数3-end# 判定结束位置# 返回值# 是否以指定后缀结尾# bool 类型name = "hello"print(name.endswith("o"))#Trueprint(name.endswith("e"))#False
# 补充# in# 判定一个字符串, 是否被另外一个字符串包含# not in# 判定一个字符串, 是否不被另外一个字符串包含
name = "hello"print("h" in name) #Trueprint("c" in name) #Falseprint("c" not in name) #True
原文地址：https://www.cnblogs.com/delphiclub/p/8455983.html
时间： 2024-07-30 02:48:50