python-字符串内置方法
str.capitalize()
首字母大写
>>> "test".capitalize()
'Test'
str.casefold()
string_data = "ABcdefG"
print(string_data.casefold()) # abcdefg
print(string_data.lower()) # abcdefg
# python3.3
string_data = 'ß'
print(string_data.lower()) # ß
print(string_data.casefold()) # ss
str.center(width[,fillchar])
按照给定字符和总宽度居中显示。
string_data = 'test'
data = string_data.center(10, "*")
print(data, len(data)) # ***test*** 10
str.count(sub,start,end)
子字符串在原字符串中的个数。
- sub：需要搜索的字符串
- 字符串开始搜索的范围，默认是01
- 字符串结束搜索的范围，没有返回-1
>>> 'atesta'.count('a')
2
>>> 'hello world '.count("l", 4)
1
str.encode(encoding="utf-8", errors="strict")
encoding -- 编码方式
errors -- 错误的处理方案。默认为 'strict',是编码错误引起一个UnicodeError,其他可能得值有 'ignore', 'replace', 'xmlcharrefreplace', 'backslashreplace' 以及通过 codecs.register_error() 注册的任何值。
data = string_data.encode() # b'test'
print(data)
data = string_data.encode(encoding='ascii') # b'test'
print(data)
str.endswith(suffix, start, end)
如果字符串含有指定的后缀返回True，否则返回False。
- suffix :子字符串
- start -- 长字符串中的开始位置，默认0
- end -- 长字符中结束位置，默认最后
data = "test"
data1 = data.endswith('t')
print(data1) # True
data2 = data.endswith('test')
print(data2) # True
data3 = data.endswith('s')
print(data3) # False
data3 = data.endswith('s', 1, 2)
print(data3) # False
str.expandtabs(tabsize=8)
把字符串 string 中的 tab 符号转为空格，tab 符号默认的空格数是 8。
data = '01\t012\t0123\t01234'
data1 = data.expandtabs()
print(data1) # 01 012 0123 01234
data = '01\t012\t0123\t01234'
data1 = data.expandtabs(16)
print(data1) # 01 012 0123 01234
str.find(str, beg=0, end=len(string))
检测字符串中是否包含子字符串 str ，beg（开始）到end（结束） 如果包含子字符串，则返回开始的（最小的）索引值，没有找到则返回-1。默认为0和最后。
data = 'B,b,cdEfcg'
res = data.find('c', 6, 9)
print(res) # 8
res1 = data.find('c')
print(res1) # 4
res2 = data.find('w')
print(res2) # -1
str.format(*args, kwargs)
字符串格式化，通过{}代替传统的%.*arg表示不可变参数--元组，**kwargs表示可变参数--字典
info ="name:{},age:{},sex:{}".format("Tom", 12, 'man')
print(info) # name:Tom,age:12,sex:man
info1 ="name:{0},age:{1},sex:{2}".format("Tom", 12, 'man')
print(info1) # name:Tom,age:12,sex:man
info2 ="name:{name},age:{age},sex:{sex}".format(name="Tom", age=12, sex='man')
print(info2) # name:Tom,age:12,sex:man
info3 ="name:{name},age:{age},sex:{sex},test_name:{name}".format(name="Tom", age=12, sex='man')
print(info3) # name:Tom,age:12,sex:man,test_name:Tom
数字格式化format()
print("{:+.2f}".format(3.1415926)) # +3.14
print("{:.2f}".format(3.1415926)) # 3.14
print("{:.2f}".format(1)) # 1.00
print('{}:{{0}}'.format("大括号转义")) # 大括号转义:{0}
| 数字 | 格式 | 输出 | 描述 |
|---|---|---|---|
| 3.1415926 | 3.14 | 保留小数点后两位 | |
| 3.1415926 | +3.14 | 带符号保留小数点后两位 | |
| -1 | -1.00 | 带符号保留小数点后两位 | |
| 2.71828 | 3 | 不带小数 | |
| 5 | 05 | 数字补零 (填充左边, 宽度为2) | |
| 5 | 5xxx | 数字补x (填充右边, 宽度为4) | |
| 10 | 10xx | 数字补x (填充右边, 宽度为4) | |
| 1000000 | 1,000,000 | 以逗号分隔的数字格式 | |
| 0.25 | 25.00% | 百分比格式 | |
| 1000000000 | 1.00e+09 | 指数记法 | |
| 13 | 13 | 右对齐 (默认, 宽度为10) | |
| 13 | 13 | 左对齐 (宽度为10) | |
| 13 | 13 | 中间对齐 (宽度为10) | |
| 11 | '{:b}'.format(11) '{:d}'.format(11) '{:o}'.format(11) '{:x}'.format(11) '{:#x}'.format(11) '{:#X}'.format(11) |
1011 11 13 b 0xb 0XB |
^, <, > 分别是居中、左对齐、右对齐，后面带宽度， : 号后面带填充的字符，只能是一个字符，不指定则默认是用空格填充。+ 表示在正数前显示 +，负数前显示 -； （空格）表示在正数前加空格b、d、o、x 分别是二进制、十进制、八进制、十六进制。
str.index(str, beg=0, end=len(string))
与str.find类似，区别在于，index如果找不到要寻到的字符，会得到ValueError，而find则返回-1。
- str:指定检索的字符串
- beg: 开始索引，默认为0。
- end:结束索引，默认为字符串的长度
>>> "test".index("t")
0
>>> "test".index("a")
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
ValueError: substring not found
str.isanum()
如果 string 至少有一个字符并且所有字符都是字母或数字则返
回 True,否则返回 False
>>> str = 'this2019'
>>> str.isalnum()
True
>>> str = 'this 2019'
>>> str.isalnum()
False
str.isalpha()
检测字符串是否只由字母组成。
>>> str = 'test'
>>>> str1='this 2019'
>>> str.isalpha()
True
>>> str1.isalpha()
False
str.isdecimal()
如果 string 只包含十进制数字则返回 True 否则返回 False。
>>> str1.isdecimal()
True
>>> str2='this2019'
>>> str2.isdecimal()
False
str.isdigit()
如果 string 只包含数字则返回 True 否则返回 False.
>>> str = 'test'
>>>> str1='this 2019'
>>> str1.isdigit()
True
>>> str2.isdigit()
False
str.isnumeric()
如果 string 中只包含数字字符，则返回 True，否则返回 False
>>> str = 'test'
>>>> str1='this 2019'
>>> str1.isnumeric()
True
>>> str2.isnumeric()
False
str.isidentifier()
判断变量名是否合法。
data = 'class'
res = data.isidentifier()
print(res) # True
data1 = 'False'
res1= data1.isidentifier()
print(res1) #True
data2 = "123"
res3 = data2.isidentifier()
print(res3) # False
print( "3a".isidentifier() ) # False
print( "".isidentifier() ) # False
print("_".isidentifier()) # True
str.islower()
如果 string 中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是小写，则返回 True，否则返回 False
print("Test".islower()) # False
print("test...".islower()) # True
print("this iS ".islower()) # False
str.isprintable()
判断是不是都为可见/可打印字符。
print("test".isprintable()) # True
print("Te\tst".isprintable()) # False
print("Te\nst".isprintable()) # False
str.isspace()
判断是否为空格字符（注意不是空）。
print("".isspace()) # False
print(" test".isspace()) # False
print("test".isspace()) # False
print(" ".isspace()) # True 空格
str.istitle()
判断字符串能不能做标题。
print("Test".istitle()) #True
print("test".istitle()) # False
print("This is a test".istitle()) # False
print("This Is A Test".istitle()) # True
str.title()
把字符串变为标题格式。
data = "this is a test"
print(data.title())
data1 = "test....".title()
print(data1) # Test....
str.isupper()
如果字符串中的所有字符都是大写，并且至少有一个字符，则返回True，否则返回False。
print("TEST".isupper()) # True
print("test".isupper()) # False
print("Test IS ".isupper()) # False
str.join(string)
以str作为分隔符，将string所有的元素合并成一个新的字符串。若string为空，则TypeError。
print("+".join("Test")) # T+e+s+t
print("__".join("This is a test")) # T__h__i__s__ __i__s__ __a__ __t__e__s__t
list=['1','2','3','4','5']
print(''.join(list)) # 12345
str.ljust(width,fillchar)
得到一个原始字符串左对齐,并使用fiichar填充至指定长度的新字符串。若指定的长度小于原字符串的长度则返回原始字符串。与format的填充用法相似。
print("test".ljust(10, "+")) # test++++++
print("this is a test".ljust(10, "+")) # this is a test
print(len("test".ljust(10, "+")),"test".ljust(10, "+")) #10 test++++++
str.rjust(width,fillchar)
得到一个原始字符串左对齐,并使用fiichar填充至指定长度的新字符串。若指定的长度小于原字符串的长度则返回原始字符串。与format的填充用法相似。
print("test".rjust(10, "+")) # ++++++test
print("this is a test".rjust(10, "+")) # this is a test
print(len("test".rjust(10, "+")),"test".rjust(10, "+")) #10 ++++++test
str.lower()
把所有字母转化为小写，与str.upper()相对，与str.casefold()区别。
print("TEST".lower()) # test
print("This Is A Test".lower()) # this is a test
print("test".lower()) #test
str.upper()
把所有字母转化为大写。
print("TEST".upper()) # TEST
print("This Is A Test".upper()) # THIS IS A TEST
print("test".upper()) # TEST
str.lstrip(chars)
删除str左边所有出现在chars子字符串，chars为空时默认空格字符。
print(len(" test"),len(" test".lstrip()), " test".lstrip()) # 7 4 test
print("tttttttest".lstrip("t")) # est
str.rstrip(chars)
与str.lstrip(chars)对应且方法一致，删除str右边所有出现在chars子字符串，chars为空时默认空格字符
print(len("test "),len("test ".rstrip()), " test".lstrip()) # 9 4 test
print("tttttttest".rstrip("t")) # tttttttes
str.strip(chars)
与str.lstrip(chars)和str.rstrip(chars)用法一致，这个是删除两边所有出现在chars子字符串，chars为空时默认空格字符
print(" t est ".strip()) # t est
print("TTTTTTTTTTTTRRRRRTTTTTT".strip("T")) # RRRRR
print("test__".strip("_")) # test
str.maketrans(intab,outtab)
得到一个用于str.translate()的映射，其实就是一个字典。
intab--是原始字符
outtab--翻译后的字符，长度与in相等
intab = "abcde"
outtab = "12345"
name = "asdwgwegb"
x = ''.maketrans(intab, outtab)
data = name.translate(x)
print(data)
str.translate()
x就是maketrans得到的字典，字典中的映射是字符对应的Unicode编码。
intab = "aeiou"
outtab = "12345"
trantab = str.maketrans(intab, outtab) # 制作翻译表
str = "this is string example....wow!!!"
print(str.translate(trantab)) # th3s 3s str3ng 2x1mpl2....w4w!!!
str.partition(char)
有点像 find()和 split()的结合体,从 str 出现的第一个位置起,把 字 符 串 string 分 成 一 个 3 元 素 的 元 组 (string_pre_str,str,string_post_str),如果 string 中不包含str 则 string_pre_str == string.
print("Test".partition("e")) # ('T', 'e', 'st')
# 三元分割
print("This is a test".partition(" ")) # ('This', ' ', 'is a test') #
print("a, b, c".partition(',')) # ('a', ',', ' b, c')
str.split(char，count)
以 str 为分隔符切片 string，如果 num 有指定值，则仅分隔 num+ 个子字符串
txt = "Google#Runoob#Taobao#Facebook"
# 第二个参数为 1，返回两个参数列表
x = txt.split("#", 1) # ['Google', 'Runoob#Taobao#Facebook
print(x)
y = txt.split("#") # ['Google', 'Runoob', 'Taobao', 'Facebook']
print(y)
str.rpartition(char)
用法与str.partition(char)一致，str.rpartition(char)根据字符串char分割str得到一个3元素元组（只识别最后一次出现的字符串）。char不能为空
print(s.split('a'))
a = 'A, B, C'
print(a.rpartition(',')) # ('A, B', ',', ' C')
b = "test TEST "
print(b.rpartition(' ')) # ('test TEST', ' ', '')
str.rsplit(char，count)
与str.split用法一致，但是str.rsplit是从后往前工作，str.split是签到后工作。
print(S.rsplit()) # ['this', 'is', 'string', 'test!']
print(S.rsplit('i', 1)) # ['this is str', 'ng test!']
print(S.rsplit('w')) # ['this is string test!']
str.splitlines(keepends)
keepends -- 在输出结果里是否保留换行符('\r', '\r\n', \n')，默认为 False，不包含换行符，如果为 True，则保留换行符。
str1 = 'ab c\n\nde fg\rkl\r\n'
print(str1.splitlines(True)) # ['ab c\n', '\n', 'de fg\r', 'kl\r\n']
print(str1.splitlines()) # ['ab c', '', 'de fg', 'kl']
str.replace(old,new,count)
Python replace() 方法把字符串中的 old（旧字符串） 替换成 new(新字符串)，如果指定第三个参数count，则替换不超过 count 次。
string_Data = 'This is a test, test!!'
data = string_Data.replace("test", 'example')
print(data) # This is a example, example!!
data1 = string_Data.replace("test", 'example', 1)
print(data1) # This is a example, test!!
str.startswith(start,end)
检查字符串是否是以指定子字符串开头，如果是则返回 True，否则返回 False。如果参数 beg 和 end 指定值，则在指定范围内检查。
str = "this is string example!!!"
print(str.startswith('this')) # True
print(str.startswith('is', 2, 4)) # True
print(str.startswith('this', 2, 4)) # False
str.swapcase()
对字符串的大小写字母进行转换。
string_Data = "test"
print(string_Data.swapcase()) # TEST
string_Data1 = "Test"
print(string_Data1.swapcase()) # tEST
str.zfill(width)
定长度的字符串，原字符串右对齐，前面填充0。
string_Data = "test"
print(string_Data.zfill(10)) # 000000test
print(string_Data.zfill(20)) # 0000000000000000test
