Python 的內置字符串方法（收藏專用）

1
2
3
4
5
6
7
8
9
10
11
'adi dog'.capitalize()
# 'Adi dog'
 
'abcd 徐'.capitalize()
# 'Abcd 徐'
 
'徐 abcd'.capitalize()
# '徐 abcd'
 
'ß'.capitalize()
# 'SS'

str.lower()

將字符串轉換成小寫，其僅對 ASCII 編碼的字母有效。

1
2
3
4
5
6
7
8
'DOBI'.lower()
# 'dobi'
 
'ß'.lower()   # 'ß' 爲德語小寫字母，其有另一種小寫 'ss'， lower 方法無法轉換
# 'ß'
 
'徐 ABCD'.lower()
# '徐 abcd'

str.casefold()

將字符串轉換成小寫，Unicode 編碼中凡是有對應的小寫形式的，都會轉換。

1
2
3
4
5
'DOBI'.casefold()
# 'dobi'
 
'ß'.casefold()   #德語中小寫字母 ß 等同於小寫字母 ss， 其大寫爲 SS 
# 'ss'

str.swapcase()

對字符串字母的大小寫進行反轉。

1
2
'徐Dobi a123 ß'.swapcase()
#: '徐dOBI A123 SS'    這裏的 ß 被轉成 SS 是一種大寫

但需要注意的是 s.swapcase().swapcase() == s 不一定爲真：

1
2
3
4
5
6
7
8
9
10
11
u'xb5'
# 'µ'
 
u'xb5'.swapcase()
# 'Μ'
 
u'xb5'.swapcase().swapcase()
# 'μ'
 
hex(ord(u'xb5'.swapcase().swapcase()))
Out[154]: '0x3bc'

這裏 'Μ'(是 mu 不是 M) 的小寫正好與 'μ' 的寫法一致。

str.title()

將字符串中每個“單詞”首字母大寫。其判斷“單詞”的依據則是基於空格和標點，所以應對英文撇好所有格或一些英文大寫的簡寫時，會出錯。

1
2
3
4
5
6
7
8
9
'Hello world'.title()
# 'Hello World'
 
'中文abc def 12gh'.title()
# '中文Abc Def 12Gh'
 
# 但這個方法並不完美：
"they're bill's friends from the UK".title()
# "They'Re Bill'S Friends From The Uk"

str.upper()

將字符串所有字母變爲大寫，會自動忽略不可轉成大寫的字符。

1
2
'中文abc def 12gh'.upper()
# '中文ABC DEF 12GH'

需要注意的是 s.upper().isupper() 不一定爲 True。

字符串格式輸出

str.center(width[, fillchar])

將字符串按照給定的寬度居中顯示，可以給定特定的字符填充多餘的長度，如果指定的長度小於字符串長度，則返回原字符串。

1
2
3
4
5
'12345'.center(10, '*')
# '**12345***'
 
'12345'.center(10)
# '  12345   '

str.ljust(width[, fillchar]); str.rjust(width[, fillchar])

返回指定長度的字符串，字符串內容居左（右）如果長度小於字符串長度，則返回原始字符串，默認填充爲 ASCII 空格，可指定填充的字符串。

1
2
3
4
5
6
7
8
9
10
11
'dobi'.ljust(10)
# 'dobi      '
 
'dobi'.ljust(10, '~')
# 'dobi~~~~~~'
 
'dobi'.ljust(3, '~')
# 'dobi'
 
'dobi'.ljust(3)
# 'dobi'

str.zfill(width)

用 ‘0’ 填充字符串，並返回指定寬度的字符串。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
"42".zfill(5)
# '00042'
"-42".zfill(5)
# '-0042'
 
'dd'.zfill(5)
# '000dd'
 
'--'.zfill(5)
# '-000-'
 
' '.zfill(5)
# '0000 '
 
''.zfill(5)
# '00000'
 
'dddddddd'.zfill(5)
# 'dddddddd'

str.expandtabs(tabsize=8)

用指定的空格替代橫向製表符，使得相鄰字符串之間的間距保持在指定的空格數以內。

1
2
3
4
5
6
7
8
9
tab = '1t23t456t7890t1112131415t161718192021'
 
tab.expandtabs()
# '1       23      456     7890    1112131415      161718192021'
# '123456781234567812345678123456781234567812345678'  注意空格的計數與上面輸出位置的關係
 
tab.expandtabs(4)
# '1   23  456 7890    1112131415  161718192021'
# '12341234123412341234123412341234'

str.format(^args, ^^kwargs)

格式化字符串的語法比較繁多，官方文檔已經有比較詳細的 examples，這裏就不寫例子了，想了解的童鞋可以直接戳這裏 Format examples.

str.format_map(mapping)

類似 str.format(*args, **kwargs) ，不同的是 mapping 是一個字典對象。

1
2
3
4
People = {'name':'john', 'age':56}
 
'My name is {name},i am {age} old'.format_map(People)
# 'My name is john,i am 56 old'

字符串搜索定位與替換

str.count(sub[, start[, end]])

1
2
3
4
5
6
7
8
9
10
text = 'outer protective covering'
 
text.count('e')
# 4
 
text.count('e', 5, 11)
# 1
 
text.count('e', 5, 10)
# 0

str.find(sub[, start[, end]]); str.rfind(sub[, start[, end]])

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
text = 'outer protective covering'
 
text.find('er')
# 3
 
text.find('to')
# -1
 
text.find('er', 3)
Out[121]: 3
 
text.find('er', 4)
Out[122]: 20
 
text.find('er', 4, 21)
Out[123]: -1
 
text.find('er', 4, 22)
Out[124]: 20
 
text.rfind('er')
Out[125]: 20
 
text.rfind('er', 20)
Out[126]: 20
 
text.rfind('er', 20, 21)
Out[129]: -1

str.index(sub[, start[, end]]); str.rindex(sub[, start[, end]])

與 find() rfind() 類似，不同的是如果找不到，就會引發 ValueError。

str.replace(old, new[, count])

1
2
3
4
5
6
7
8
9
10
11
12
13
14
'dog wow wow jiao'.replace('wow', 'wang')
# 'dog wang wang jiao'
 
'dog wow wow jiao'.replace('wow', 'wang', 1)
# 'dog wang wow jiao'
 
'dog wow wow jiao'.replace('wow', 'wang', 0)
# 'dog wow wow jiao'
 
'dog wow wow jiao'.replace('wow', 'wang', 2)
# 'dog wang wang jiao'
 
'dog wow wow jiao'.replace('wow', 'wang', 3)
# 'dog wang wang jiao'

str.lstrip([chars]); str.rstrip([chars]); str.strip([chars])

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
'  dobi'.lstrip()
# 'dobi'
'db.kun.ac.cn'.lstrip('dbk')
# '.kun.ac.cn'
 
' dobi   '.rstrip()
# ' dobi'
'db.kun.ac.cn'.rstrip('acn')
# 'db.kun.ac.'
 
'   dobi   '.strip()
# 'dobi'
'db.kun.ac.cn'.strip('db.c')
# 'kun.ac.cn'
'db.kun.ac.cn'.strip('cbd.un')
# 'kun.a'

static str.maketrans(x[, y[, z]]); str.translate(table)

maktrans 是一個靜態方法，用於生成一個對照表，以供 translate 使用。
如果 maktrans 僅一個參數，則該參數必須是一個字典，字典的 key 要麼是一個 Unicode 編碼（一個整數），要麼是一個長度爲 1 的字符串，字典的 value 則可以是任意字符串、None或者 Unicode 編碼。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
a = 'dobi'
ord('o')
# 111
 
ord('a')
# 97
 
hex(ord('狗'))
# '0x72d7'
 
b = {'d':'dobi', 111:' is ', 'b':97, 'i':'u72d7u72d7'}
table = str.maketrans(b)
 
a.translate(table)
# 'dobi is a狗狗'

如果 maktrans 有兩個參數，則兩個參數形成映射，且兩個字符串必須是長度相等；如果有第三個參數，則第三個參數也必須是字符串，該字符串將自動映射到 None：

1
2
3
4
5
6
7
8
9
10
11
a = 'dobi is a dog'
 
table = str.maketrans('dobi', 'alph')
 
a.translate(table)
# 'alph hs a alg'
 
table = str.maketrans('dobi', 'alph', 'o')
 
a.translate(table)
# 'aph hs a ag'

字符串的聯合與分割

str.join(iterable)

用指定的字符串，連接元素爲字符串的可迭代對象。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
'-'.join(['2012', '3', '12'])
# '2012-3-12'
 
'-'.join([2012, 3, 12])
# TypeError: sequence item 0: expected str instance, int found
 
'-'.join(['2012', '3', b'12'])  #bytes 爲非字符串
# TypeError: sequence item 2: expected str instance, bytes found
 
'-'.join(['2012'])
# '2012'
 
'-'.join([])
# ''
 
'-'.join([None])
# TypeError: sequence item 0: expected str instance, NoneType found
 
'-'.join([''])
# ''
 
','.join({'dobi':'dog', 'polly':'bird'})
# 'dobi,polly'
 
','.join({'dobi':'dog', 'polly':'bird'}.values())
# 'dog,bird'

str.partition(sep); str.rpartition(sep)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
'dog wow wow jiao'.partition('wow')
# ('dog ', 'wow', ' wow jiao')
 
'dog wow wow jiao'.partition('dog')
# ('', 'dog', ' wow wow jiao')
 
'dog wow wow jiao'.partition('jiao')
# ('dog wow wow ', 'jiao', '')
 
'dog wow wow jiao'.partition('ww')
# ('dog wow wow jiao', '', '')
 
 
 
'dog wow wow jiao'.rpartition('wow')
Out[131]: ('dog wow ', 'wow', ' jiao')
 
'dog wow wow jiao'.rpartition('dog')
Out[132]: ('', 'dog', ' wow wow jiao')
 
'dog wow wow jiao'.rpartition('jiao')
Out[133]: ('dog wow wow ', 'jiao', '')
 
'dog wow wow jiao'.rpartition('ww')
Out[135]: ('', '', 'dog wow wow jiao')

str.split(sep=None, maxsplit=-1); str.rsplit(sep=None, maxsplit=-1)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
'1,2,3'.split(','), '1, 2, 3'.rsplit()
# (['1', '2', '3'], ['1,', '2,', '3'])
 
'1,2,3'.split(',', maxsplit=1),  '1,2,3'.rsplit(',', maxsplit=1)
# (['1', '2,3'], ['1,2', '3'])
 
'1 2 3'.split(), '1 2 3'.rsplit()
# (['1', '2', '3'], ['1', '2', '3'])
 
'1 2 3'.split(maxsplit=1), '1 2 3'.rsplit(maxsplit=1)
# (['1', '2 3'], ['1 2', '3'])
 
'   1   2   3   '.split()
# ['1', '2', '3']
 
'1,2,,3,'.split(','), '1,2,,3,'.rsplit(',')
# (['1', '2', '', '3', ''], ['1', '2', '', '3', ''])
 
''.split()
# []
''.split('a')
# ['']
'bcd'.split('a')
# ['bcd']
'bcd'.split(None)
# ['bcd']

str.splitlines([keepends])

字符串以行界符爲分隔符拆分爲列表；當 keepends 爲True，拆分後保留行界符，能被識別的行界符見官方文檔。

1
2
3
4
5
6
7
8
9
'ab cnnde fgrklrn'.splitlines()
# ['ab c', '', 'de fg', 'kl']
'ab cnnde fgrklrn'.splitlines(keepends=True)
# ['ab cn', 'n', 'de fgr', 'klrn']
 
"".splitlines()， ''.split('n')      #注意兩者的區別
# ([], [''])
"One linen".splitlines()
# (['One line'], ['Two lines', ''])

字符串條件判斷

str.endswith(suffix[, start[, end]]); str.startswith(prefix[, start[, end]])

1
2
3
4
5
6
7
8
9
10
11
12
text = 'outer protective covering'
 
text.endswith('ing')
# True
 
text.endswith(('gin', 'ing'))
# True
text.endswith('ter', 2, 5)
# True
 
text.endswith('ter', 2, 4)
# False

str.isalnum()

字符串和數字的任意組合，即爲真，簡而言之：

只要 c.isalpha(), c.isdecimal(), c.isdigit(), c.isnumeric() 中任意一個爲真，則 c.isalnum() 爲真。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
'dobi'.isalnum()
# True
 
'dobi123'.isalnum()
# True
 
'123'.isalnum()
# True
 
'徐'.isalnum()
# True
 
'dobi_123'.isalnum()
# False
 
'dobi 123'.isalnum()
# False
 
'%'.isalnum()
# False

str.isalpha()

Unicode 字符數據庫中作爲 “Letter”（這些字符一般具有 “Lm”, “Lt”, “Lu”, “Ll”, or “Lo” 等標識，不同於 Alphabetic）的，均爲真。

1
2
3
4
5
6
7
8
9
10
11
'dobi'.isalpha()
# True
 
'do bi'.isalpha()
# False
 
'dobi123'.isalpha()
# False
 
'徐'.isalpha()
# True

str.isdecimal(); str.isdigit(); str.isnumeric()

三個方法的區別在於對 Unicode 通用標識的真值判斷範圍不同：

isdecimal: Nd,
isdigit: No, Nd,
isnumeric: No, Nd, Nl

digit 與 decimal 的區別在於有些數值字符串，是 digit 卻非 decimal ，具體戳這裏

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
num = 'u2155'
print(num)
# ⅕
num.isdecimal(), num.isdigit(), num.isnumeric()
# (False, False, True)
 
num = 'u00B2'
print(num)
# ²
num.isdecimal(), num.isdigit(), num.isnumeric()
# (False, True, True)
 
num = "1"  #unicode
num.isdecimal(), num.isdigit(), num.isnumeric()
# (Ture, True, True)
 
num = "'Ⅶ'" 
num.isdecimal(), num.isdigit(), num.isnumeric()
# (False, False, True)
 
num = "十"
num.isdecimal(), num.isdigit(), num.isnumeric()
# (False, False, True)
 
num = b"1" # byte
num.isdigit()   # True
num.isdecimal() # AttributeError 'bytes' object has no attribute 'isdecimal'
num.isnumeric() # AttributeError 'bytes' object has no attribute 'isnumeric'

str.isidentifier()

判斷字符串是否可爲合法的標識符。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
'def'.isidentifier()
# True
 
'with'.isidentifier()
# True
 
'false'.isidentifier()
# True
 
'dobi_123'.isidentifier()
# True
 
'dobi 123'.isidentifier()
# False
 
'123'.isidentifier()
# False

str.islower()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
'徐'.islower()
# False
 
'ß'.islower()   #德語大寫字母
# False
 
'a徐'.islower()
# True
 
'ss'.islower()
# True
 
'23'.islower()
# False
 
'Ab'.islower()
# False

str.isprintable()

判斷字符串的所有字符都是可打印字符或字符串爲空。Unicode 字符集中 “Other” “Separator” 類別的字符爲不可打印的字符（但不包括 ASCII 的空格（0x20））。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
'dobi123'.isprintable()
# True
 
'dobi123n'.isprintable()
Out[24]: False
 
'dobi 123'.isprintable()
# True
 
'dobi.123'.isprintable()
# True
 
''.isprintable()
# True

str.isspace()

判斷字符串中是否至少有一個字符，並且所有字符都是空白字符。

1
2
3
4
5
6
7
8
In [29]: 'rnt'.isspace()
Out[29]: True
 
In [30]: ''.isspace()
Out[30]: False
 
In [31]: ' '.isspace()
Out[31]: True

str.istitle()

判斷字符串中的字符是否是首字母大寫，其會忽視非字母字符。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
'How Python Works'.istitle()
# True
 
'How Python WORKS'.istitle()
# False
 
'how python works'.istitle()
# False
 
'How Python  Works'.istitle()
# True
 
' '.istitle()
# False
 
''.istitle()
# False
 
'A'.istitle()
# True
 
'a'.istitle()
# False
 
'甩甩Abc Def 123'.istitle()
# True

str.isupper()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
'徐'.isupper()
# False
 
'DOBI'.isupper()
Out[41]: True
 
'Dobi'.isupper()
# False
 
'DOBI123'.isupper()
# True
 
'DOBI 123'.isupper()
# True
 
'DOBIt 123'.isupper()
# True
 
'DOBI_123'.isupper()
# True
 
'_123'.isupper()
# False

字符串編碼

str.encode(encoding=”utf-8″, errors=”strict”)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
fname = '徐'
 
fname.encode('ascii')
# UnicodeEncodeError: 'ascii' codec can't encode character 'u5f90'...
 
fname.encode('ascii', 'replace')
# b'?'
 
fname.encode('ascii', 'ignore')
# b''
 
fname.encode('ascii', 'xmlcharrefreplace')
# b'徐'
 
fname.encode('ascii', 'backslashreplace')
# b'\u5f90'

我去圖書館了

發佈了20 篇原創文章 · 獲贊 22 · 訪問量 4萬+

私信關注