sequence类型都支持的一些通用操作：
| 成员检查：in、not in | 'Py' in str 'python' not in str |
| 连接：+ | str_new = str1 + str2 |
| 复制：* | str * 2 |
| 下标取值：s[i] | str[3] |
| 切片：s[i : j] | str[3:8] |
| 长度检查：len(s) | len(str) print('%s length = %d' % (str,len(str))) |
| 最小值：min(s) | min(str) 空格在上面字符串中是最小的 |
| 最大值：max(s) | max(str) 大写字母要小于小写字母 |
实例如下：
str1 = "strcat"
str2 = str1*1
str3 = str1*2
print(str2)
print(str3)
# strcat
# strcatstrcat
字符串切片：
1. 字符串变量名[x:y]，表示下标从x到y的一段字符串（不包括y）。
当x不写，像[:y]，表示从头开始，相当于[0:y]。当y不写时，表示一直到尾。当x和y两个都不写时，就表示整个字符串。
str_result = str[3:8]
2. 步长切片截取
使用两个冒号来实现按一定“步数”来取值的 [x:y:z]
str_result = str[1:9:3] #即从第1个字符开始，每隔3个位移取一个值,到第9个字符截止（不包括第9个字符）
- 查找 & 替换类方法
（1）查找指定字符串出现次数
str.count(sub, start= 0,end=len(string))
返回字符串里某个字符或是子字符串出现的次数。可选参数为在字符串搜索的开始(默认为第一个字符)与结束(默认为最后一个字符)位置。
str = "Python string Function" str_result = str.count("th",2,15) print(str_result) # 1
（2）检测字符串中是否包含子字符串
str.find(str, beg=0, end=len(string))
str.rfind(sub[, start[, end]])
str.index(sub[, start[, end]])
str.rindex(sub[, start[, end]])
检测字符串中是否包含子字符串 str ，如果指定可选参数 beg（开始） 和 end（结束） 范围，则检查是否包含在指定范围内，如果包含子字符串则返回子字符串开始的位置的索引值，否则返回-1。
find()查找的是子字符串在全字符串中出现的第一个位置，匹配到字符串就结束查找，不管后面还有没有匹配的字符串。
str.rfind(sub[, start[, end]]) ，从最右边开始查找，但返回的index位置却是从原字符串的最左边开始算的。
index()方法与find()方法一样，如果包含子字符串则返回开始的索引值，只不过index()方法如果str不在 string中会报一个异常。
str = "Python string Function" str_result = str.find("python",0,len(str)) str_result1 = str.find("Python",0,len(str)) print(str_result) print(str_result1) # -1 # 1
str = "Python string Function" str_result = str.rfind("string",0,len(str)) str1 = "Python string hhhh string Function" str_result1 = str1.rfind("string",0,len(str1)) print(str_result) print(str_result1) # 7 # 19
str = "Python string Function" str_result = str.index("python",0,len(str)) # Traceback (most recent call last): # File "D:/PycharmProjects/LuoXM-1/test/test1.py", line 2, in <module> # str_result = str.index("python",0,len(str)) # ValueError: substring not found
str = "Python string Function" str_result = str.index("Python",0,len(str)) print(str_result) # 0
str = "Python string Function" str_result = str.rindex("string",0,len(str)) str1 = "Python string hhhh string Function" str_result1 = str1.rindex("string",0,len(str1)) print(str_result) print(str_result1) # 7 # 19
（3）字符映射的转换
str.maketrans(x[, [y, z]])
str.translate(map)
用于创建字符映射的转换表，接受两个参数x, y的最简单的调用方式，第一个参数是字符串中需要转换的字符组成的字符串，第二个参数也是字符串表示要转换的目标。 可选参数Z 的意思是删除原字符串中的相应字符。
两个参数字符串的长度必须相同，且为一一对应的关系。
str = 'aaalllaaannn' table = str.maketrans("al","bc","n") print(table) str_result = str.translate(table) print(str_result) # {97: 98, 108: 99, 110: None} # bbbcccbbb
（4）替换字符串中指定字符
返回一个新字符串，原串中的old被替换为new，可选参数count指定替换次数。 str = 'aaalllaaannn' str_result = str.replace("a","d",4) print(str_result) # dddllldaannn
2.判断类方法，通常返回True和False
（1）是否以指定子字符串 结尾和开头
str.endswith(suffix[, start[, end]])
str.startswith(str, beg=0,end=len(string))
用于判断字符串是否以指定子字符串 结尾和开头，如果是则返回True，否则返回False。如果可选参数指定值，则在指定范围内检查。默认检索字符串的开始(默认为第一个字符)与结束(默认为最后一个字符)位置。
str = 'Python string Function study' str_result = str.endswith("dy",10,100) str_result1 = str.startswith("P",0,10) print(str_result) print(str_result1) # True # True
（2）检测字符串是否由字母和数字组成
str.isalnum()
检测字符串是否由字母和数字组成，如果 string 至少有一个字符并且所有字符都是字母或数字则返回 True,否则返回 False
字符串中包含空格也会返回False, 中文字符是被允许的，也会返回True
str = "abc 123" str_result = str.isalnum() print(str_result) str1 = "abc" str_result1 = str1.isalnum() print(str_result1) str2 = "abc12" str_result2 = str2.isalnum() print(str_result2) # # False # True # True
（3）检测字符串是否只由字母组成
str.isalpha()
检测字符串是否只由字母组成, 如果字符串至少有一个字符并且所有字符都是字母则返回 True,否则返回 False
中文字符是被允许的，也会返回True
str = "abc" str_result = str.isalpha() print(str_result) # True
（4）检测字符串是否只由数字组成
str.isdigit()
str.isdecimal()
str.isnumeric()
检测字符串是否只由数字组成, 如果字符串至少有一个字符并且只包含数字则返回 True 否则返回 False
str.isdecimal()：判断字符串是否只包含十进制数字字符，包括多国语言的十进制数字字符表现形式
str.isdigit()：判断字符串是否只包含数字，这里的数字包括十进制数字和其它特殊数字（如上标数字等），一个数字是拥有如下属性值的字符：Numeric_Type=Digit或Numeric_Type=Decimal。
str.isnumeric()：判断字符串是否只包含数字字符。数字字符范围很大，一般来说，数字字符是拥有如下属性值的字符：Numeric_Type=Digit, Numeric_Type=Decimal或Numeric_Type=Numeric。
str = "123" str_result = str.isdigit() str_result1 = str.isdecimal() str_result2 = str.isnumeric() print(str_result) print(str_result1) print(str_result2) # True # True # True
（5）检测字符串是否只由空格或制表符(\t)组成.
str.isspace()
检测字符串是否只由空格或制表符(\t)组成. 是则返回True, 否则返回False
str = ' '
str_result = str.isspace()
（6）检测字符串中的字母字符是否全部由小/大写字母组成
str.islower()
str.isupper()
str.islower()检测字符串中的字母字符是否全部由小写字母组成. 如果字符串中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是小写，则返回 True，否则返回 False
isupper()方法检测字符串中所有的字母是否都为大写。同样返回True, 或是False
这两种方法仅判断字符串中的字母字符，不理会其它字符。字符串必须至少包含一个字母字符，否则返回False
str = "al%an" str_result = str.islower() str_result1 = str.isupper() print(str_result) print(str_result1) # True # False
（7）检测字符串中所有的单词拼写首字母是否为大写，且其他字母为小写
str.istitle()
检测字符串中所有的单词拼写首字母是否为大写，且其他字母为小写。是则返回 True，否则返回 False.
字符串必须至少包含一个字母字符，否则返回False。即使首字母字符前面有非字母字符，如中文、数字、下划线等，也不影响对首字母字符的判断。
str = "Alan Python" str1 = "Alan's Python" str2 = "'Alan Python" str_result = str.istitle() str_result1 = str1.istitle() str_result2 = str2.istitle() print(str_result) print(str_result1) print(str_result2) # True # False # True
（8）判断字符串是否是合法的标识符
str.isidentifier()
判断字符串是否是合法的标识符，字符串仅包含中文字符合法，实际上相当于判断的是变量名是否合法
str = "_Alan_Python" str_result = str.isidentifier() print(str_result) # True
str = "12vv" str_result = str.isidentifier() print(str_result) # False
在Python中使用变量时，需要符合一定的命名规则：
-
- 变量名只能包含字母、数字、下划线，变量名可以以字母和下划线开头，但不能以数字开头。
- 例如：m12_、_m12都可以，但是12m_就不行了。
- 变量名中不能有空格，可以用下划线代替。
- 例如：mn 32_是不行的。
- 不要用Python中的关键字或者函数名作为变量名。
- 例如：print作为变量名就是不合法的。
- 尽量使用小写字母作为变量名，少用大写。
（9）判断字符串所包含的字符是否全部可打印
判断字符串所包含的字符是否全部可打印。字符串包含不可打印字符，如转义字符，将返回False
str = "alan\n python" str_result = str.isprintable() print(str_result) # False
3.格式化类方法，返回一个格式化的新字符串
（1）大小写字母转换
str.lower()
str.upper()
str.swapcase()
把全部字母字符转换成小写 / 大写，不去管其它非字母字符。字符串全部为非字母字符也是合法的，但返回原字符串.
swapcase()方法把字符串中的大小写字母互换，大写转换成小写，小写转换成大写。不去管非字母类字符。
str = "中国Alan Xu" str_result = str.lower() str_result1 = str.upper() str_result2 = str.swapcase() print(str_result,str_result1,str_result2) # 中国alan xu 中国ALAN XU 中国aLAN xU
（2）将字符串的第一个字符转换为大写， 其余转换为小写
str.capitalize()
将字符串的第一个字符转换为大写， 其余转换为小写
如果字符串首字符为非字母字符，将返回原字符,但其余字符仍转换为小写。字符串仅包含非字母字符合法，但返回原字符串。
str = "中国Alan Xu" str_result = str.capitalize() print(str_result) # 中国alan xu
（3）字符串中每个单词的首字母大写，其余小写
str.title()
字符串中每个单词的首字母大写，其余小写。单词的首字符为非字母字符也不影响转换。字符串仅包含非字母字符合法，但返回原字符串
str = "中alAn xU" str_result = str.title() print(str_result) # 中Alan Xu
（4）返回一个指定的宽度 width 居中 / 左对齐 / 右对齐 的字符串
str.center(width[, fillchar])
str.ljust(width[, fillchar])
str.rjust(width[, fillchar])
返回一个指定的宽度 width 居中 / 左对齐 / 右对齐 的字符串，可选参数fillchar 为填充的字符，默认为空格。 如果 width 小于字符串长度直接返回字符串
str = "Alan Xu" #width为偶数时，fillchar将平均地填充到原字符串的开头和结尾； # 为奇数时，fillchar优先填充前面 str_result = str.center(50,"*") print(str_result) # *********************Alan Xu********************** #21个Alan Xu22个 str_result1 = str.ljust(50,"*") str_result2 = str.rjust(50,"*") print(str_result1) print(str_result2) # Alan Xu******************************************* # *******************************************Alan Xu
（5）返回一个去除了特定字符的新字符串
str.lstrip([chars])
str.rstrip([chars])
str.strip([chars])
返回一个去除了特定字符的新字符串，chars参数是一个字符串，它包含了所有将要被移除的字符集合。默认为空格
从原字符串的 最左边 / 最右边 / 两端 开始，匹配chars里包含的所有字符，直至遇到第一个非chars字符为止，原字符串中匹配到的所有字符都被移除。
str = "alan xu python"
#当遇到字符x不属于'a ln'时结束，移除x前的所有字符 str_result = str.lstrip("a ln") str_result1 = str.rstrip("a ln") str_result2 = str.strip("a ln") print(str_result) print(str_result1) print(str_result2) # xu python # alan xu pytho # xu pytho
（6）把字符串中的所有制表符替换成零个或多个空格
str.expandtabs([tabsize])
把字符串中的所有制表符替换成零个或多个空格，每个制表符替换成多少个空格，由制表符在字符串中的位置和tabsize共同决定。tabsize指定每个制表符替换成的空格数，默认为8个
str = "\t\talanhah\tis hero" str_result = str.expandtabs() print(str_result) # alanhah is hero #16个空格alanhah is hero str1 = "\t\talanhahaf\tis hero" str_result1 = str.expandtabs() print(str_result1) # alanhah is hero #16个空格alanhah is hero
（7）返回一个长度为width的字符串
str.zfill(width)
返回一个长度为width的字符串，最左边填充0。如果width小于等于原字符串长度，则返回原字符串。主要用于数字类字符串的格式化。
str = "124" str_result = str.zfill(8) print(str_result) # 00000124
（8）字符串格式化
str.format(*args, **kwargs)
str.format_map(mapping)
增强了字符串格式化的功能, 基本语法是通过 {} 和 : 来代替以前的 %。format() 函数可以接受不限个参数，位置可以不按顺序。
通过位置传递
str_result = "{0},{1}".format("Alan","Xu") str_result1 = "{},{}".format("Alan","Xu") #不能出现同时一个{}和一个{1}这样 str_result2 = "{1}{0}{1}".format("Alan","Xu") print(str_result) print(str_result1) print(str_result2) # Alan,Xu # Alan,Xu # XuAlanXu
通过关键字参数
str_result = "我的名字叫：{name},我的年龄:{age}".format(name="Alan",age = 26) print(str_result) # 我的名字叫：Alan,我的年龄:26
通过对象属性
class Person(object): def __init__(self,name,age): self.name,self.age = name,age def __str__(self): return "我的名字叫：{self.name},年龄是：{self.age}".format(self=self) str_result = Person("Alan",26) print(str_result) # 我的名字叫：Alan,年龄是：26
格式限定符
填充与对齐
^、<、>分别是居中、左对齐、右对齐，后面带宽度
:号后面带填充的字符，只能是一个字符，不指定的话默认是用空格填充
str_result = "{:*^16}".format("alan") str_result1 = "{:*<16}".format("alan") str_result2 = "{:*>16}".format("alan") print(str_result) print(str_result1) print(str_result2) # ******alan****** # alan************ # ************alan
精度与类型f
str_result = "{:.2f}".format(3.1415926) print(str_result) # 3.14
其他类型
主要就是进制，b、d、o、x分别是二进制、十进制、八进制、十六进制。
str_result = "{:b}".format(26) str_result1 = "{:d}".format(26) str_result2 = "{:o}".format(26) str_result3 = "{:x}".format(26) print(str_result) print(str_result1) print(str_result2) print(str_result3) # 11010 # 26 # 32 # 1a
用，号还能用来做金额的千位分隔符。
str_result = '{:,}'.format(1234567890) #1,234,567,890
用 % 号实现百分比
str_result = '{:.2%}'.format(0.26) #26.00%
指数记法
str_result = '{:.2e}'.format(26) #2.60e+01
str.format_map(mapping)类似 str.format(*args, **kwargs) ，不同的是 mapping 是一个字典对象。
People = {'name':'alan', 'age':26}
str_result = 'My name is {name},i am {age} old'.format_map(People) # 'My name is john,i am 56 old'
新增方法：
str.encode(encoding='UTF-8',errors='strict')
以 encoding 指定的编码格式编码字符串（如"UTF-8"）。errors参数可以指定不同的错误处理方案。该方法返回编码后的字符串。
errors -- 设置不同错误的处理方案。默认为 'strict',意为编码错误引起一个UnicodeError。
其他可能的值有 'ignore', 'replace', 'xmlcharrefreplace', 'backslashreplace' 以及通过 codecs.register_error() 注册的任何值。
str = "我在学习Python" str_result = str.encode("UTF-8","strict") str_result1 = str_result.decode("UTF-8","strict") print(str_result) print(str_result1) # b'\xe6\x88\x91\xe5\x9c\xa8\xe5\xad\xa6\xe4\xb9\xa0Python' # 我在学习Python
4.拆分组合类方法
（1）拆分字符串，返回一个包含三个元素的元组。
str.partition(sep)
str.rpartition(sep)
拆分字符串，返回一个包含三个元素的元组。
如果未能在原字符串中找到Sep，则元组的三个元素为：原字符串，空串，空串；否则，从原字符串中遇到的第一个Sep字符开始拆分，元组的三个元素为：Sep前的字符串，Sep字符，Sep之后的字符串；
rpartition(sep)从原字符串的最右边开始拆分，返回：倒数第一个Sep之前的字符串，Sep字符，Sep之后的字符串。
str = "aabcdefgdeh" str_result = str.partition("de") str_result1 = str.rpartition("de") print(str_result) print(str_result1) # ('aabc', 'de', 'fgdeh') # ('aabcdefg', 'de', 'h')
（2）返回一个以Sep分隔的列表
str.split([sep[, maxsplit]])
str.rsplit([sep[, maxsplit]])
返回一个以Sep分隔的列表，maxsplit指定拆分次数（因此，列表中元素的个数为maxsplit + 1）。Sep默认为空格，maxsplit默认不限制拆分次数。
1）如果未指定Sep或指定Sep为None，str两端的空格将舍弃；如果指定Sep（不管能否在原字符串中找到Sep），str两端的空格将保留
2）如果未能在原字符串中找到Sep，则返回一个仅包含一个元素的列表，这个元素就是原字符串。
3) str.rsplit()只是从最右边开始拆分。只有在指定maxsplit的情况下才会看到不同效果
str = " hello alan" str_result = str.split() str_result1 = str.split("l",2) str_result2 = str.rsplit("l",2) print(str_result) print(str_result1) print(str_result2) # ['hello', 'alan'] # [' he', '', 'o alan'] # [' hel', 'o a', 'an']
（3）以指定字符串str作为分隔符，将iterable对象中所有的元素(字符串表示)合并为一个新的字符串
str.join(iterable)
以指定字符串str作为分隔符，将iterable对象中所有的元素(字符串表示)合并为一个新的字符串. 如果传入一个非iterable对象，如整数、布尔值等，将返回Type Error。
iterable object或iterator type最主要的特征是支持两个函数：__iter__()和__next__()，虽然不是很准确，但可以简单的认为支持使用for语句逐个取值的数据类型都是迭代器对象。
sequence type（六种：strings、byte objects、byte arrays、lists、tuples、range objects）和dictionary都属于iterable对象
str = "ab" str_result = str.join("cdef") print(str_result) # cabdabeabf
（4）拆分一个包含多行的字符串，以每行为一个元素返回一个列表。
str.splitlines([keepends])
拆分一个包含多行的字符串，以每行为一个元素返回一个列表。如果字符串不是多行，则返回原字符串。keepends是一个True字符或非零整数，表示保留行尾标志（即换行符）。该方法多用于处理文件。
str = '''ab cd ef''' str_result = str.splitlines() print(str_result) # ['ab', 'cd', 'ef']
1801
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
