Python 字符串概念和操作

#   字符串概念：由单个字符串组成的一个集合

#   普通字符串（非原始字符串）
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