Python基础阶段：字符串数据类型操作大全

Posted 2020-12-27 easyone

 1 # _*_encoding:utf8_*_
 2 #
 3 #
 4 # # 非原始字符串
 5 # #     使用单引号包含的
 6 # #         ‘abc‘
 7 # # str1 = ‘aaa‘
 8 # # print(str1, type(str1))
 9 #
10 #
11 # #     使用双引号包含的
12 # #         "abc"
13 # # str1 = "aaa"
14 # # print(str1, type(str1))
15 #
16 # #     使用3个单引号
17 # #         ‘‘‘ abc ‘‘‘
18 # # str1 = ‘‘‘aaa‘‘‘
19 # # print(str1, type(str1))
20 #
21 # #     使用3个双引号
22 # #         """ abc """
23 # # str1 = """aaa"""
24 # # print(str1, type(str1))
25 #
26 #
27 # # str1 = """a	aa"""
28 # # print(str1, type(str1))
29 #
30 #
31 #
32 # # 我是 "yy"
33 # # name = "我是 ‘yy‘"
34 # # print(name)
35 #
36 # # name = "y"
37 # # "y"
38 # # "123"
39 # # print(name)
40 #
41 # # 我是 
 yy
42 # # name = r‘‘‘我是 
 	 \ yy‘‘‘
43 # # print(name)
44 #
45 #
46 #
47 #
48 # # 我是 ‘yy‘
49 # # name = "我是 "yy""
50 # # name = "我是 ‘yy‘"
51 # # print(name)
52 #
53 #
54 # name = ("woshi"
55 # "yy")
56 # print(name)
57 #
58 #
59 #
60 # str1 = """woshi
61 # yy
62 # 123"""
63 # print(str1)
64 #
65 #
66 # import math
67 # math.sin(30)

引号操作

 1 # name = "abcdefg"
 2 #
 3 # print(name[3])
 4 # print(name)
 5 #
 6 #
 7 # print(name[-4])
 8 # # [0, 3)
 9 # print(name[::])
10 # print(len(name))
11 # print(name[0:len(name):-1])
12 #
13 #
14 # print(name[4:1:-1])
15 # print(name[-1:-4:-1])

切片操作

  1 # len
  2 #     作用
  3 #         计算字符串的字符个数
  4 #     语法
  5 #         len(name)
  6 #     参数
  7 #         字符串
  8 #     返回值
  9 #         整型
 10 #         字符个数
 11 # name = "woshisz"
 12 # name = "我
是sz"
 13 # num = len(name)
 14 # print(num)
 15 
 16 
 17 
 18 
 19 
 20 # find
 21 #     作用
 22 #         查找子串索引(下标)位置
 23 #     语法
 24 #         find(sub, start=0, end=len(str))
 25 #     参数
 26 #         参数1-sub
 27 #             需要检索的字符串
 28 #         参数2-start
 29 #             检索的起始位置
 30 #             可省略, 默认0
 31 #         参数3-end
 32 #             检索的结束位置
 33 #             可省略, 默认len(str)
 34 #     返回值
 35 #         找到了
 36 #             指定索引
 37 #             整型
 38 #         找不到
 39 #             -1
 40 #     注意
 41 #         从左到右进行查找
 42 #         找到后立即停止
 43 #       [start, end)
 44 # name = "wo shi sz"
 45 # num = name.find("s", 4, 7)
 46 # print(num)
 47 
 48 
 49 
 50 # rfind
 51 #     功能使用, 同find
 52 #     区别
 53 #         从右往左进行查找
 54 # name = "wo shi sz"
 55 # num = name.rfind("s")
 56 # print(num)
 57 
 58 
 59 
 60 
 61 # index
 62 #     作用
 63 #         获取子串索引位置
 64 #     语法
 65 #         index(sub, start=0, end=len(str))
 66 #     参数
 67 #         参数1-sub
 68 #             需要检索的字符串
 69 #         参数2-start
 70 #             检索的起始位置
 71 #             可省略, 默认0
 72 #         参数3-end
 73 #             检索的结束位置
 74 #             可省略, 默认len(str)
 75 #     返回值
 76 #         找到了
 77 #             指定索引
 78 #             整型
 79 #         找不到
 80 #             异常
 81 #     注意
 82 #         从左到右进行查找
 83 #         找到后立即停止
 84 # name = "wo shi sz"
 85 # num = name.index("ss")
 86 # print(num)
 87 
 88 
 89 
 90 
 91 # rindex
 92 #     功能使用, 同index
 93 #     区别
 94 #         从右往左进行查找
 95 # name = "wo shi sz"
 96 # num = name.rindex("ss")
 97 # print(num)
 98 
 99 
100 
101 # count
102 #     作用
103 #         计算某个子字符串的出现个数
104 #     语法
105 #         count(sub, start=0, end=len(str))
106 #     参数
107 #         参数1-sub
108 #             需要检索的字符串
109 #         参数2-start
110 #             检索的起始位置
111 #             可省略, 默认0
112 #         参数3-end
113 #             检索的结束位置
114 #             可省略, 默认len(str)
115 #     返回值
116 #         子字符串出现的个数
117 #         整型
118 # name = "wo shi szwo"
119 # print(name.count("s"))

函数操作-查找计算类

 1 # replace
 2 #     作用
 3 #         使用给定的新字符串 替换原字符串中的 旧字符串
 4 #     语法
 5 #         replace(old, new[, count])
 6 #     参数
 7 #         参数1-old
 8 #             需要被替换的旧字符串
 9 #         参数2-new
10 #             替换后的新字符串
11 #         参数3-count
12 #             替换的个数
13 #             可省略, 表示替换全部
14 #     返回值
15 #         替换后的结果字符串
16 #     注意
17 #         并不会修改原字符串本身
18 # name = "wo shi sz"
19 # # print(name.replace("s", "z"))
20 # print(name.replace("s", "z", 1))
21 # print(name)
22 
23 
24 
25 # capitalize
26 #     作用
27 #         将字符串首字母变为大写
28 #     语法
29 #         capitalize()
30 #     参数
31 #         无
32 #     返回值
33 #         首字符大写后的新字符串
34 #     注意
35 #         并不会修改原字符串本身
36 
37 # name = "wo shi sz"
38 # print(name.capitalize())
39 # print(name)
40 
41 
42 # title
43 #     作用
44 #         将字符串每个单词的首字母变为大写
45 #     语法
46 #         title()
47 #     参数
48 #         无
49 #     返回值
50 #         每个单词首字符大写后的新字符串
51 #     注意
52 #         并不会修改原字符串本身
53 # name = "wo shi-sz*sz2-qq%yy"
54 # print(name.title())
55 # print(name)
56 
57 
58 
59 # lower
60 #     作用
61 #         将字符串每个字符都变为小写
62 #     语法
63 #         title()
64 #     参数
65 #         无
66 #     返回值
67 #         全部变为小写后的新字符串
68 #     注意
69 #         并不会修改原字符串本身
70 # name = "Wo Shi SZ"
71 # print(name.lower())
72 # print(name)
73 
74 
75 
76 # upper
77 #     作用
78 #         将字符串每个字符都变为大写
79 #     语法
80 #         upper()
81 #     参数
82 #         无
83 #     返回值
84 #         全部变为大写后的新字符串
85 #     注意
86 #         并不会修改原字符串本身
87 
88 # name = "Wo Shi SZ"
89 # print(name.upper())
90 # print(name)

函数转换操作

  1 # ljust
  2 #     作用
  3 #         根据指定字符(1个), 将原字符串填充够指定长度
  4 #         l
  5 #             表示原字符串靠左
  6 #     语法
  7 #         ljust(width, fillchar)
  8 #     参数
  9 #         参数1-width
 10 #             指定结果字符串的长度
 11 #         参数2-fillchar
 12 #             如果原字符串长度 < 指定长度时
 13 #             填充过去的字符
 14 #     返回值
 15 #         填充完毕的结果字符串
 16 #     注意
 17 #         不会修改原字符串
 18 #         填充字符的长度为1
 19 #         只有原字符串长度 < 指定结果长度时才会填充
 20 
 21 
 22 # name = "abcdefg"
 23 # print(name.ljust(16, "x"))
 24 # print(name)
 25 
 26 
 27 
 28 
 29 # rjust
 30 #     作用
 31 #         根据指定字符(1个), 将原字符串填充够指定长度
 32 #         r
 33 #             表示原字符串靠右
 34 #     语法
 35 #         rjust(width, fillchar)
 36 #     参数
 37 #         参数1-width
 38 #             指定结果字符串的长度
 39 #         参数2-fillchar
 40 #             如果原字符串长度 < 指定长度时
 41 #             填充过去的字符
 42 #     返回值
 43 #         填充完毕的结果字符串
 44 #     注意
 45 #         不会修改原字符串
 46 #         填充字符的长度为1
 47 #         只有原字符串长度 < 指定结果长度时才会填充
 48 # name = "abcdefg"
 49 # print(name.rjust(16, "x"))
 50 # print(name)
 51 
 52 
 53 # center
 54 #     作用
 55 #         根据指定字符(1个), 将原字符串填充够指定长度
 56 #         center
 57 #             表示原字符串居中
 58 #     语法
 59 #         center(width, fillchar)
 60 #     参数
 61 #         参数1-width
 62 #             指定结果字符串的长度
 63 #         参数2-fillchar
 64 #             如果原字符串长度 < 指定长度时
 65 #             填充过去的字符
 66 #     返回值
 67 #         填充完毕的结果字符串
 68 #     注意
 69 #         不会修改原字符串
 70 #         填充字符的长度为1
 71 #         只有原字符串长度 < 指定结果长度时才会填充
 72 # name = "abcdefg"
 73 # print(name.center(18, "x"))
 74 # print(name)
 75 
 76 
 77 
 78 # lstrip
 79 #     作用
 80 #         移除所有原字符串指定字符(默认为空白字符)
 81 #         l
 82 #             表示仅仅只移除左侧
 83 #     语法
 84 #         lstrip(chars)
 85 #     参数
 86 #         参数-chars
 87 #             需要移除的字符集
 88 #             表现形式为字符串
 89 #                 "abc"
 90 #                 表示,"a"|"b"|"c"
 91 #     返回值
 92 #         移除完毕的结果字符串
 93 #     注意
 94 #         不会修改原字符串
 95 
 96 # name = "wwwoo shi sz "
 97 # # print("|" + name.lstrip() + "|")
 98 # print("|" + name.lstrip("wo") + "|")
 99 # print("|" + name + "|")
100 
101 
102 # rstrip
103 #     作用
104 #         移除所有原字符串指定字符(默认为空白字符)
105 #         r
106 #             表示从右侧开始移除
107 #     语法
108 #         rstrip(chars)
109 #     参数
110 #         参数-chars
111 #             需要移除的字符集
112 #             表现形式为字符串
113 #                 "abc"
114 #                 表示,"a"|"b"|"c"
115 #     返回值
116 #         移除完毕的结果字符串
117 #     注意
118 #         不会修改原字符串
119 # name = "wwwoo shi sz oowwwoa"
120 # # print("|" + name.lstrip() + "|")
121 # print("|" + name.rstrip("wo") + "|")
122 # print("|" + name + "|")

函数填充压缩操作

  1 # split
  2 #     作用
  3 #         将一个大的字符串分割成几个子字符串
  4 #     语法
  5 #         split(sep, maxsplit)
  6 #     参数
  7 #         参数1-sep
  8 #             分隔符
  9 #         参数2-maxsplit
 10 #             最大的分割次数
 11 #             可省略, 有多少分割多少
 12 #     返回值
 13 #         分割后的子字符串, 组成的列表
 14 #         list 列表类型
 15 #     注意
 16 #         并不会修改原字符串本身
 17 
 18 # info = "sz-18-180-0558-12345678"
 19 # result = info.split("-", 3)
 20 # print(result)
 21 # print(info)
 22 
 23 
 24 # partition
 25 #     作用
 26 #         根据指定的分隔符, 返回(分隔符左侧内容, 分隔符, 分隔符右侧内容)
 27 #     语法
 28 #         partition(sep)
 29 #     参数
 30 #         参数-sep
 31 #             分隔符
 32 #     返回值
 33 #         如果查找到分隔符
 34 #             (分隔符左侧内容, 分隔符, 分隔符右侧内容)
 35 #             tuple 类型
 36 #         如果没有查找到分隔符
 37 #             (原字符串, "", "")
 38 #             tuple 类型
 39 #     注意
 40 #         不会修改原字符串
 41 #         从左侧开始查找分隔符
 42 # info = "sz-18-180-0558-12345678"
 43 # result = info.partition("-")
 44 # print(result)
 45 # print(info)
 46 
 47 
 48 
 49 # rpartition
 50 #     作用
 51 #         根据指定的分隔符, 返回(分隔符左侧内容, 分隔符, 分隔符右侧内容)
 52 #         r
 53 #             表示从右侧开始查找分隔符
 54 #     语法
 55 #         partition(sep)
 56 #     参数
 57 #         参数-sep
 58 #             分隔符
 59 #     返回值
 60 #         如果查找到分隔符
 61 #             (分隔符左侧内容, 分隔符, 分隔符右侧内容)
 62 #             tuple 类型
 63 #         如果没有查找到分隔符
 64 #             (原字符串, "", "")
 65 #             tuple 类型
 66 #     注意
 67 #         不会修改原字符串
 68 #         从右侧开始查找分隔符
 69 
 70 # info = "sz-18-180-0558-12345678"
 71 # result = info.rpartition("-")
 72 # print(result)
 73 # print(info)
 74 
 75 
 76 # splitlines
 77 #     作用
 78 #         按照换行符(
, 
), 将字符串拆成多个元素, 保存到列表中
 79 #     语法
 80 #         splitlines(keepends)
 81 #     参数
 82 #         参数-keepends
 83 #             是否保留换行符
 84 #             bool 类型
 85 #     返回值
 86 #         被换行符分割的多个字符串, 作为元素组成的列表
 87 #         list 类型
 88 #     注意
 89 #         不会修改原字符串
 90 # name = "wo 
 shi 
 sz"
 91 # result = name.splitlines(True)
 92 # print(result)
 93 # print(name)
 94 
 95 
 96 # join
 97 #     作用
 98 #         根据指定字符串, 将给定的可迭代对象, 进行拼接, 得到拼接后的字符串
 99 #     语法
100 #         join(iterable)
101 #     参数
102 #         iterable
103 #             可迭代的对象
104 #                 字符串
105 #                 元组
106 #                 列表
107 #                 ...
108 #     返回值
109 #         拼接好的新字符串
110 
111 # items = ["sz", "18", "shanghai"]
112 # result = "xxx".join(items)
113 # print(result)

分解拼割操作

  1 # isalpha
  2 #     作用
  3 #         字符串中是否所有的字符都是字母
  4 #             不包含该数字,特殊符号,标点符号等等
  5 #             至少有一个字符
  6 #     语法
  7 #         isalpha()
  8 #     参数
  9 #         无
 10 #     返回值
 11 #         是否全是字母
 12 #         bool 类型
 13 
 14 # name = "Sz	"
 15 # name = ""
 16 # print(name.isalpha())
 17 
 18 
 19 # isdigit
 20 #     作用
 21 #         字符串中是否所有的字符都是数字
 22 #             不包含该字母,特殊符号,标点符号等等
 23 #             至少有一个字符
 24 #     语法
 25 #         isdigit()
 26 #     参数
 27 #         无
 28 #     返回值
 29 #         是否全是数字
 30 #         bool 类型
 31 # name = "123	"
 32 # name = ""
 33 # print(name.isdigit())
 34 
 35 
 36 # isalnum
 37 #     作用
 38 #         字符串中是否所有的字符都是数字或者字母
 39 #             不包含该特殊符号,标点符号等等
 40 #             至少有一个字符
 41 #     语法
 42 #         isalnum()
 43 #     参数
 44 #         无
 45 #     返回值
 46 #         是否全是数字或者字母
 47 #         bool 类型
 48 # name = "123abc,"
 49 # print(name.isalnum())
 50 
 51 
 52 # isspace
 53 #     作用
 54 #         字符串中是否所有的字符都是空白符
 55 #             包括空格,缩进,换行等不可见转义符
 56 #             至少有一个字符
 57 #     语法
 58 #         isspace()
 59 #     参数
 60 #         无
 61 #     返回值
 62 #         是否全是空白符
 63 #         bool 类型
 64 # name = "
"
 65 # print(name.isspace())
 66 
 67 
 68 # startswith
 69 #     作用
 70 #         判定一个字符串是否以某个前缀开头
 71 #     语法
 72 #         startswith(prefix, start=0, end=len(str))
 73 #     参数
 74 #         参数1-prefix
 75 #             需要判定的前缀字符串
 76 #         参数2-start
 77 #             判定起始位置
 78 #         参数3-end
 79 #             判定结束位置
 80 #     返回值
 81 #         是否以指定前缀开头
 82 #         bool 类型
 83 # name = "2018-09-02: 某某报告.xls"
 84 # print(name.startswith("18", 2, 4))
 85 
 86 
 87 
 88 # endswith
 89 #     作用
 90 #         判定一个字符串是否以某个后缀结尾
 91 #     语法
 92 #         endswith(suffix, start=0, end=len(str))
 93 #     参数
 94 #         参数1-suffix
 95 #             需要判定的后缀字符串
 96 #         参数2-start
 97 #             判定起始位置
 98 #         参数3-end
 99 #             判定结束位置
100 #     返回值
101 #         是否以指定后缀结尾
102 #         bool 类型
103 # name = "2018-09-02: 某某报告.xls"
104 # name = "2018-09-02: 某某报告.doc"
105 # print(name.endswith(".doc"))
106 
107 
108 # 补充
109 #     in
110 #         判定一个字符串, 是否被另外一个字符串包含
111 #     not in
112 #         判定一个字符串, 是否不被另外一个字符串包含
113 
114 print("sz" in "wo shi z")
115 print("sz" not in "wo shi z")
116 
117 
118 
119 
120 
121 name = "abc"
122 name[0] = "d"
123 print(name[0])

函数判定操作