Python 3.7.1 模組 string
string-常用string操作
- 1. 字串常量
- string.ascii_letters
- string.ascii_lowercase
- string.ascii_uppercase
- string.digits
- string.hexdigits
- string.octdigits
- string.punctuation
- string.printable
- string.whitespace
- 2. 自定義字串格式
- 3. 格式字串語法
- 4. strings模板
- 5. 幫助函式
原始碼： Lib/string.py
也可以看看 str型別及方法
1. 字串常量
原始碼定義如下：
whitespace = ' \t\n\r\v\f'
ascii_lowercase = 'abcdefghijklmnopqrstuvwxyz'
ascii_uppercase = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
ascii_letters = ascii_lowercase + 在這個模組中定義的常量如下：
string.ascii_letters
ascii_lowercase + ascii_uppercase的結果 。該值不依賴於本地設定。
string.ascii_lowercase
小寫字母 a-z.該值不依賴於本地設定以及不會被修改。
string.ascii_uppercase
大寫字母 A-Z.該值不依賴於本地設定以及不會被修改。
string.digits
字串 0-9.
string.hexdigits
十六進位制數字對應的字串 '0123456789abcdefABCDEF'.
string.octdigits
八進位制數字對應字串'01234567'.
string.punctuation
在 C語言 中被定義為ASCII 字元的字元集合而成的字串
string.printable
被定義為printable的ASCII 字元集合而成的字串，這是一個包含了 digits + ascii_letters + punctuation + whitespace 的組合
string.whitespace
包含所有ASCII中可當作空白的字元集合而成的字串。這包括字元間的空格、 tab、 換行符(\n)、 return(\r)、 換頁符(\f)和垂直製表符（\v -> vertical tab）。
2. 自定義字串格式
內建string類提供了通過format()方法 執行復雜變數替換和值格式化的功能，參見PEP 3101。string模組中的Formatter類允許您使用與內建format()方法相同的實現來建立和自定義您自己的字串格式化行為。
2.1 class string.Formatter
Formatter 類有下列公共方法：
format（format_string，* args，** kwargs ）
主要的API方法。它採用格式字串和一組任意位置和關鍵字引數。它只是一個呼叫vformat()的包裝器。
在python 3.7中更改：格式字串引數現在 positional-only(只能由位置提供的引數)。
vformat（format_string，args，kwargs ）
此函式執行格式化的實際工作。對於要傳遞預定義引數字典的情況，它是作為單獨的函式公開的，而不是使用*args和**kwargs 語法將字典解包並重新打包為單個引數。 vformat()將格式字串分解為字元資料和替換欄位的工作。它呼叫下面描述的各種方法。
此外，Formatter定義了許多旨在被子類替換的方法：
parse（format_string ）
迴圈遍歷format_string並返回一個可迭代的元組（literal_text，field_name，format_spec，conversion）。這用於vformat()將字串分解為文字文字或替換欄位。
元組中的值在概念上表示文字文字的範圍，後跟單個替換欄位。如果沒有文字文字（如果連續出現兩個替換欄位會發生這種情況），則 literal_text將是一個零長度字串。如果沒有替換欄位，則field_name，format_spec和conversion的值 將為None。
get_field（field_name，args，kwargs ）
給定parse()中返回的field_name（參見上文），將其轉換為要格式化的物件。返回一個元組（obj，used_key）。預設版本採用在PEP 3101中定義的表單的字串，例如0 [name]或label.title。 args和 kwargs是在 vformat()中傳過來的。返回值 used_key與 get_value()中的key引數的含義相同 。
get_value（key，args，kwargs ）
檢索給定的欄位值。key引數將是一個整數或字串。如果是整數，則表示args中位置引數的索引; 如果它是一個字串，那麼它代表kwargs中的命名引數。
該args引數就是vformat()中的位置引數列表 ，kwargs引數就是其中的關鍵字引數字典。
對於複合字段名稱，僅為欄位名稱的第一個元件呼叫這些函式; 後續元件通過常規屬性和索引操作來處理。
因此，例如，欄位表示式“0.name”將導致 get_value()使用鍵引數0 呼叫。通過呼叫getattr()內建函式返回name 後將查詢該屬性。get_value()
如果索引或關鍵字引用了不存在的項，則會引發IndexError或KeyError。
def get_value(self, key, args, kwargs):
if isinstance(key, int):
return args[key]
else:
return kwargs[key]
check_unused_args（used_args，args，kwargs ）
如果需要，可以自己實現檢查未使用的引數。此函式的引數是格式字串中實際引用的所有引數鍵的集合（位置引數的整數和命名引數的字串），以及對傳遞給vformat 的args和kwargs的引用。可以從這些引數計算未使用的args集。 check_unused_args()如果檢查失敗，則假定引發異常。
format_field（value，format_spec ）
format_field()只簡單地呼叫全域性format()內建函式。提供該方法以便子類可以覆蓋它。
convert_field（價值，轉換）
根據給定的轉換型別（如parse()方法返回的元組）轉換值（get_field()返回值）。預設版本理解's'（str），'r'（repr）和'a'（ascii）轉換型別。
譯者例項，這裡提供一個簡單的使用string.Formatter類的例子：
def string_format():
from string import Formatter
sf = Formatter()
ostr = '{1},Mr {0!s}! Your gf {gfname} is arriving as {time}'
tuple_param = ('leng','hello','feng')
dict_param = {"gfname": "qian", "time":"3:40"}
print(sf.format(ostr,*tuple_param,**dict_param))
# 輸出結果
hello,Mr leng! Your gf qian is arriving as 3:40
這裡注意一下列表引數和字典引數的傳入方式，*和**。
3. 格式字串語法
str.format()方法和Formatter 類共享格式字串的相同語法（儘管在Formatter子類中，可以定義自己的格式字串語法）。語法與格式化字串文字的語法相關，但存在差異。
格式字串包含由大括號{}括起的“替換欄位” 。除了大括號中的任何內容都被視為文字，它將不加改變地複製到輸出中。如果你需要在文字文字中包含一個大括號字元，可以通過加倍{{}}來轉義它。
替換欄位 的語法如下：
replacement_field ::= "{" [field_name] ["!" conversion] [":" format_spec] "}"
field_name ::= arg_name ("." attribute_name | "[" element_index "]")*
arg_name ::= [identifier | digit+]
attribute_name ::= identifier
element_index ::= digit+ | index_string
index_string ::= <any source character except "]"> +
conversion ::= "r" | "s" | "a"
format_spec ::= <described in the next section>
在不太正式的術語中，替換欄位 可以以field_name開頭，該欄位指定要將其值格式化並插入輸出而不是替換欄位的物件。field_name可選地跟隨一個 conversion欄位，它前面帶有感嘆號!，和一個format_spec，前面有一個:。這些指定非預設格式的替換值。
另請參閱 格式規範迷你語言 部分。
譯者例項，先看這個例子，再看下面的大段解釋文字，才能更好理解文件的意思：
a = 'hello\n'
print("{1!s}mr {0!r:*^30},you arriving at }{{time!s}}}".format("leng\n",a,time="3:40"))
# 輸出結果
hello
mr ***********'leng\n'***********,you arriving at {3:40}
解釋一下：
（1）!之前就是field_name，可以是索引數字，也可以是字典中的鍵（也就是parse（format_string ）函式返回的field_name)
（2）!之後跟一個字元，這裡跟了s和r，分別是str和raw的縮寫，結果很明顯，r原樣輸出了字串裡的\n，s轉義了\n
（3）:之後就是format_spec部分，這裡是讓0位置的引數居中顯示，兩邊用*填充，更多format_spec的用法在後面說
（4）輸出{time}，用了兩層{}包裹一個待格式化的{}
field_name
field_name本身開始於arg_name，arg_name是一個數字或一個關鍵字。如果它是一個數字，它引用一個位置引數，如果它是一個關鍵字，它引用一個命名關鍵字引數。如果格式字串中的數字arg_names按順序為0,1,2，…，它們都可以省略，數字0,1,2，…將按順序自動插入。由於arg_name不是引號分隔的，因此無法在格式字串中指定任意字典鍵（例如，字串’10’或’:-]’）。arg_name之後可以進行任何數量的索引或屬性表示式。表示式.name選擇使用getattr()查詢屬性，而表示式[index]使用__getitem__()進行索引查詢。
在版本3.1中的更改：可以對str.format()省略位置引數說明符，因此'{} {}'.format(a, b)等效於'{0} {1}'.format(a, b)。
在版本3.4中的更改：使用Formatter可以省略位置引數說明符。
例子：
"First, thou shalt count to {0}" # References first positional argument
"Bring me a {}" # Implicitly references the first positional argument
"From {} to {}" # Same as "From {0} to {1}"
"My quest is {name}" # References keyword argument 'name'
"Weight in tons {0.weight}" # 'weight' attribute of first positional arg
"Units destroyed: {players[0]}" # First element of keyword argument 'players'.
conversion
conversion在格式化之前會進行型別強制轉換。通常，格式化值的工作是通過值本身的__format__()方法完成的。但是，在某些情況下，最好強制將型別格式化為字串，從而覆蓋其自己的格式定義。通過在呼叫__format__()之前將值轉換為字串，可以繞過普通的格式化邏輯。
目前支援三種conversion 標誌：!s呼叫str() 值，!r呼叫repr()和!a呼叫 ascii()。
"Harold's a clever {0!s}" # Calls str() on the argument first
"Bring out the holy {name!r}" # Calls repr() on the argument first
"More {!a}" # Calls ascii() on the argument first
format_spec
format_spec欄位表示 值應該如何被呈現，包括很多細節如寬度，對齊，填充，小數精度等的規範。每種值型別都可以定義自己的“迷你語言格式化風格”或format_spec的風格。
大多數內建型別都支援常見的迷你語言格式化風格，這將在下一節中介紹。
format_spec欄位內部還可以巢狀替換欄位。這些巢狀的替換欄位可能包含field_name，conversion和format_spec，但不允許更深的巢狀。在解釋format_spec字串之前，format_spec中的替換欄位將被替換。這允許動態指定值的格式。
有關示例，請參閱格式示例部分。
3.1 格式規範Mini-Language
3.1.1 定義
format_spec用於格式字串中包含的替換欄位中，以定義各個值的顯示方式（請參閱 格式字串語法和格式化字串文字）。它們也可以直接傳遞給內建 format()函式。每種格式表型別可以定義如何解釋格式規範。
儘管某些格式選項僅受數字型別支援，但大多數內建型別都會為格式規範實現以下選項。
一般慣例是，空格式字串（""）產生的結果與呼叫str()值時的結果相同。非空格式字串通常會修改結果。
標準格式說明符的一般形式是：
format_spec ::= [[fill]align][sign][#][0][width][grouping_option][.precision][type]
fill ::= <any character>
align ::= "<" | ">" | "=" | "^"
sign ::= "+" | "-" | " "
width ::= digit+
grouping_option ::= "_" | ","
precision ::= digit+
type ::= "b" | "c" | "d" | "e" | "E" | "f" | "F" | "g" | "G" | "n" | "o" | "s" | "x" | "X" | "%"
3.1.2 各選項的含義
align
如果指定了有效的對齊值(align)，則可以在其前面加上填充字元（fill, 可以是任何字元的，除了{和}），如果省略則預設為空格。但是，可以插入帶有巢狀替換欄位的花括號。
各種align選項的含義如下：
| 對齊方式 | 含義 |
|---|---|
< |
左對齊欄位，預設用空格填充 |
> |
右對齊欄位，預設用空格填充 |
^ |
居中對齊欄位，預設用空格填充 |
= |
強制將填充物放在符號和數字中間，用於’+0000120’這種格式的數字，只能應用於數字型別，當0緊接在欄位寬度之前，成為預設的填充值 |
例子：
def str_format():
print("{0:-<30}".format('left'))
print("{0:>30}".format('right'))
print("{0:*^30}".format('center'))
print("{0:=+08}".format(120))
print("{0:0=+8}".format(120))
# 輸出結果
left--------------------------
right
************center************
+0000120
+0000120
後兩個輸出語句一致，其用法都是一樣的，都用0來填充。
sign
sign 選項只支援數字型別，可以是如下選項之一
| 選項 | 含義 |
|---|---|
+ |
數字的符號符號會被顯示，數字可以是正數或負數 |
- |
負數的符號會被顯示，正數的符號用填充物佔位（預設行為） |
|
正數會顯示前導填充物，符號為為空，負數會顯示符號和前導填充物 |
def str_format2():
print("{:0=+8}".format(123))
print("{:0=+8}".format(-123))
print("{:0=-8}".format(123))
print("{:0=-8}".format(-123))
print("{:0= 8}".format(123))
print("{:0= 8}".format(-123))
print("{:0=8}".format(123))
print("{:0=8}".format(-123))
# 輸出結果
+0000123
-0000123
00000123
-0000123
0000123
-0000123
00000123
-0000123
# 選項
#選項使“替代形式”進行轉換。對於不同型別，替代形式的定義不同。此選項僅對integer，float，complex和Decimal型別有效。
對於正數，當二進位制，八進位制或十六進位制輸出時，此選項新增字首’0b’，'0o’或 '0x’到輸出值。
對於浮點數，複數和Decimal，替代形式會導致轉換結果始終包含小數點字元，即使後面沒有數字也是如此。通常，只有在跟隨數字後，這些轉換的結果中才會出現小數點字元。
此外，對於 轉換’g’和’G’轉換，不會從結果中刪除尾隨零。
例子：
def str_jing():
a = 123.456
b = 3e-7
c = "%g" %(6.000)
print("{},{:#x},{:#o},{:#b}".format(a,int(a),int(a),int(a)))
print("{},{:x},{:o},{:b}".format(a, int(a), int(a), int(a)))
print("{:#},{:#},{:#},{:#G}".format(a,b,6.000,,6.000))
#輸出結果
123.456,0x7b,0o173,0b1111011
123.456,7b,173,1111011
123.456,3.e-07,6.0,6.000
, 選項
,選項表示千位分隔符。對於區域設定感知分隔符，請改用n。
版本：在3.1版中更改，添加了,選項（另請參閱PEP 378）。
print("{0:,},{0:_}".format(123456789))
#輸出結果
123,456,789,123_456_789
_ 選項
_選項表示對數字分隔符使用下劃線表示浮點表示型別和整數表示型別’d’。對於整數呈現型別’b’， ‘o’，‘x’，和’X’，下劃線將每4位插入。對於其他簡報型別，指定此選項是錯誤的。
版本：在版本3.6中更改，添加了’_'選項（另請參閱PEP 515）。
print("{0:_},{0:_x}".format(123456789))
#輸出結果
123_456_789,75b_cd15
width
width是定義最小欄位寬度的十進位制整數。如果未指定，則欄位寬度將由內容確定。
如果沒有給出顯式對齊，則使用0來填充。這等同於align選項的=。
precision
precision(精度) 是指示浮點型資料f和F 的小數點之後應該有多少數字，或f和F 轉化為g或G之前。對於非數字型別，該欄位表示最大欄位大小 - 換句話說，將使用欄位內容中的前N個字元數。precision不允許應用於整數值。
def str_pre():
a = 11123.45600
b = 'hello, mr leng!'
#c ='!'
print("{0:8.2f},{0:8.8f},{0:8.8G}".format(a))
print("{0:s}\n{0:.5s}\n{1:.5%}".format(b,a))
# 輸出結果
11123.46,11123.45600000,11123.456
hello, mr leng!
hello
1112345.60000%
type
最後，type確定應如何呈現資料。
（1）可用的字串表示型別是：
| 型別 | 含義 |
|---|---|
| ‘s’ | 字串格式。這是字串的預設型別，可以省略。 |
| None | 同’s’ |
（2）可用的整數表示型別是：
| 型別 | 含義 |
|---|---|
| ‘b’ | 二進位制格式。輸出基數為2的數字。 |
| ‘c’ | 字元。在列印之前將整數轉換為相應的unicode字元。 |
| ‘d’ | 十進位制整數。輸出基數為10的數字。 |
| ‘o’ | 八進位制格式。輸出基數為8的數字。 |
| ‘x’ | 十六進位制格式 輸出基數為16的數字，使用小寫字母表示9以上的數字。 |
| ‘X’ | 十六進位制格式 輸出基數16中的數字，使用大寫字母表示9以上的數字。 |
| ‘n’ | 數字。除了它使用當前語言環境設定插入適當的數字分隔符之外，它與’d’是相同的。 |
| None | 同’d’。 |
除了上述表示型別之外，還可以使用下面列出的浮點表示型別（除了'n'和不指定）來格式化整數 。這樣做時，float()用於在格式化之前將整數轉換為浮點數。
浮點和小數值的可用表示型別是：
| 型別 | 含義 |
|---|---|
| ‘e’ | 指數表示法。使用字母“e”以科學記數法列印數字以表示指數。預設精度為6。 |
| ‘E’ | 指數表示法。同e，只是可以用大寫表示 |
| ‘f’ | 定點表示法。將數字顯示為定點數。預設精度為6。 |
| ‘F’ | 定點表示法。同’f’，但轉換 nan到 NAN，inf到INF |
| ‘g’ | 一般格式。 1. 對於給定的精度(p >= 1)，將數字舍入為p位有效數字，然後根據其大小以定點格式或科學計數法格式化結果。 2. 精確的規則如下：假設結果格式中存在型別 ‘e’ 和精度 p-1，結果將具有指數exp。然後如果 -4 <= exp < p，數字將被格式化為型別’f’和精度p-1-exp 。否則，使用型別’e’和 精度 p-1 格式化數字。在這兩種情況下，從有效數字中刪除不重要的尾隨零，如果後面沒有剩餘數字，則也會刪除小數點。3. 正負無窮大，正負零和NaN，分別被格式化為 inf和-inf， 0，-0和nan，而不管精度。4. 精度0被視為等於精度1。預設精度為6。 |
| ‘G’ | 一般格式。與’g’相同，除了一種情況， 如果數字太大，轉換為’E’。無窮大和NaN的表示也是大寫的。 |
| ‘n’ | 數字。'與’g’相同，除了一種情況，除了它使用當前語言環境設定插入適當的數字分隔符之外，它是相同的。 |
| ‘%’ | 百分比。將數字乘以100並以（‘f’）格式顯示，後跟百分號。 |
| None | 類似於’g’，除了定點表示法，使用時，小數點後至少有一位數字。預設精度與表示特定值所需的一樣。總體效果是匹配由其他格式修飾符更改的str()輸出。 |
3.2. 格式化示例
（1）按位置訪問引數：
>>> '{0}, {1}, {2}'.format('a', 'b', 'c')
'a, b, c'
>>> '{}, {}, {}'.format('a', 'b', 'c') # 3.1+ only
'a, b, c'
>>> '{2}, {1}, {0}'.format('a', 'b', 'c')
'c, b, a'
>>> '{2}, {1}, {0}'.format(*'abc') # unpacking argument sequence
'c, b, a'
>>> '{0}{1}{0}'.format('abra', 'cad') # arguments' indices can be repeated
'abracadabra'
（2）按名稱訪問引數：
>>> 'Coordinates: {latitude}, {longitude}'.format(latitude='37.24N', longitude='-115.81W')
'Coordinates: 37.24N, -115.81W'
>>> coord = {'latitude': '37.24N', 'longitude': '-115.81W'}
>>> 'Coordinates: {latitude}, {longitude}'.format(**coord)
'Coordinates: 37.24N, -115.81W'
（3）訪問這些引數的屬性：
>>> c = 3-5j
>>> ('The complex number {0} is formed from the real part {0.real} '
... 'and the imaginary part {0.imag}.').format(c)
'The complex number (3-5j) is formed from the real part 3.0 and the imaginary part -5.0.'
>>> class Point:
... def __init__(self, x, y):
... self.x, self.y = x, y
... def __str__(self):
... return 'Point({self.x}, {self.y})'.format(self=self)
...
>>> str(Point(4, 2))
'Point(4, 2)'
（4）訪問引數的項：
>>> coord = (3, 5)
>>> 'X: {0[0]}; Y: {0[1]}'.format(coord)
'X: 3; Y: 5'
（5）替換%s和%r：
>>> "repr() shows quotes: {!r}; str() doesn't: {!s}".format('test1', 'test2')
"repr() shows quotes: 'test1'; str() doesn't: test2"
（6）替換%+f，%-f和% f，並指定一個符號：
>>> '{:+f}; {:+f}'.format(3.14, -3.14) # show it always
'+3.140000; -3.140000'
>>> '{: f}; {: f}'.format(3.14, -3.14) # show a space for positive numbers
' 3.140000; -3.140000'
>>> '{:-f}; {:-f}'.format(3.14, -3.14) # show only the minus -- same as '{:f}; {:f}'
'3.140000; -3.140000'
（7）替換%x和%o並將值轉換為不同的基數
>>> # format also supports binary numbers
>>> "int: {0:d}; hex: {0:x}; oct: {0:o}; bin: {0:b}".format(42)
'int: 42; hex: 2a; oct: 52; bin: 101010'
>>> # with 0x, 0o, or 0b as prefix:
>>> "int: {0:d}; hex: {0:#x}; oct: {0:#o}; bin: {0:#b}".format(42)
'int: 42; hex: 0x2a; oct: 0o52; bin: 0b101010'
（8）表示百分比：
>>> points = 19
>>> total = 22
>>> 'Correct answers: {:.2%}'.format(points/total)
'Correct answers: 86.36%'
（9）使用特定於型別的格式：
>>> import datetime
>>> d = datetime.datetime(