格式化顯示

以下整理自 python字符串格式化

*輸出結果的空格在md預覽中沒效果(用代碼塊三個撇號就可以保留格式了)

一、使用格式化符來格式化字符串：

Python支持的所有格式化符：

格式化符 意義

'd' 返回要格式化對象的十進制表示，如果可以

'i' 返回要格式化對象的十進制表示，如果可以

'o' 返回要格式化對象的八進制表示，如果可以

'u' 同格式化符'd'

'x' 返回要格式化對象的十六進制表示，如果可以【如果要求的前導，使用'0x'】

'X' 返回要格式化對象的十六進制表示，如果可以【如果要求的前導，使用'0X'】

'e' 返回要格式化對象的浮點的科學計數的表示，如果可以【使用'e'】

'E' 返回要格式化對象的浮點的科學計數的表示，如果可以【使用'E'】

'f' 返回要格式化對象的浮點數表示，如果可以

'F' 返回要格式化對象的浮點數表示，如果可以

'g' 使用小寫字母科學計數格式，如果指數小于-4或不少于精度,否則返回十進制格式。

'G' 使用大寫字母科學計數格式，如果指數小于-4或不少于精度,否則返回十進制格式。

'c' 對0-255之間的整數返回其對應的ASCII碼字符(其它整數報錯)，或者返回單個字符本身

'r' 返回要格式化對象的__repr__()方法的返回值

's' 返回要格式化對象的__str__()方法的返回值

'%' 即每兩個%顯示一個

1.%s格式化符：

將要格式化的值表中對應位置的元素，格式化為字符串，如果值元素不是字符串，將自動調用該元素的__str__()，以得到其字符串表示。

[1]%ns決定對齊與填充：

n為整數；當n>0時，左填充，當n<0時，右填充。

>>> for i,x in enumerate(('one','two','three','four','five','six')):

print('%5s = %d'%(x,i))

one = 0

two = 1

three = 2

four = 3

five = 4

six = 5

[2]%.ns決定對字符串的截取：

n為正整數

>>> for i,x in enumerate(('one','two','three','four','five','six')):

print('%.3s = %d'%(x,i))

one = 0

two = 1

thr = 2

fou = 3

fiv = 4

six = 5

2.%d格式化符：

將任何Python對象轉化為整數，如果轉化失敗，則報錯。

[1]%nd：決定對齊與填充。

n為整數；當n>0時，左填充，當n<0時，右填充。

>>> print('%3d'%1.52`)

1

[2]%0nd：以數字0而不是默認的空格來作填充。

>>> print('%03d'%1.52)

001

[3]%+d：數字被轉化后將保留正負號

>>> print('%+d'%1.52)

+1

>>> print('%+d'%-1.52)

-1

>>> print('%+3d'%1.52)

+1

>>> print('%+03d'%1.52)

+01

3.%r格式化符：

將任何Python對象轉化成repr字符串，自動調用Python對象的__repr__()

[1]%nr：決定對齊與填充。

n為整數；當n>0時，左填充，當n<0時，右填充。

>>> print('Names = #%50r#'%(['C','CPP','CSharp','Java','Python']))

Names = # ['C', 'CPP', 'CSharp', 'Java', 'Python']#

>>> print('Names = #%-50r#'%(['C','CPP','CSharp','Java','Python']))

Names = #['C', 'CPP', 'CSharp', 'Java', 'Python'] #

[2]%.nr：決定截取字符數。

n為正整數

>>> print('Names = #%.10r#'%(['C','CPP','CSharp','Java','Python']))

Names = #['C', 'CPP#

4.%o與%x格式化符：

將十進制數值格式化為八進制與十六進制字符串；當有'#'時，格式化后的字符串帶前導

>>> '%x'%20

'14'

>>> '%#x'%20

'0x14'

>>> '%#X'%20 #使用X作前綴，如果使用#要求了前綴

'0X14'

>>> '%o'%10

'12'

>>> '%#o'%10

'012'

注意：如果要格式化的數值是浮點數，將先取整，再格式化

>>> '%o'%13.2

'15'

>>> '%x'%20.3232

'14'

>>> '%x'%20.5232

'14'

5.%f格式化符：

以浮點數格式化數值。

[1]%nf：格式化數字后填充到固定寬度；

當n>0時，左填充，當n<0時，右填充。【若不指定小數位數時，最小寬度8位，如'0.000000'】

'%20f'%32

' 32.000000'

'%-20f'%32

'32.000000 '

[2]%.nf：格式化數字后的小數位數；

n>=0且為整數

'%.3f'%0.3245

'0.325'

'%.0f'%0.3233

'0'

'%.8f'%0.3245

'0.32450000'

PS:

*ps:運行時動態指定浮點數的精度

但是當代碼在運行中如何動態地通過參數來指定浮點數的精度呢？

python的神奇之處在于它又提供了一種非常方便的語法。只需要在 typecode(這里是f)之前加一個 *，浮點數的精度就用它前面的數字來指定。

>>> for i in range(5):

... '%.*f' % (i, 1.234234234234234)

...

'1'

'1.2'

'1.23'

'1.234'

'1.2342'

通過輸出結果可以看出，精度都是在運行時動態指定，這樣就省去了格式化字符串的拼湊。

使用 String Formatting Method Calls 可以更簡潔地完成功能。

>>> for i in range(5):

... '{0:.{1}f}'.format(1 / 3.0, i)

...

'0'

'0.3'

'0.33'

'0.333'

'0.3333'

6.%e格式化符：

以浮點科學計數的方式轉化數值，即10的指數冪形式

[1]%ne：將格式化后的數字字符串進行填充到指定寬度；

當n>0時，左填充，當n<0時，右填充。【如不指定小數位數，最小寬度是12位，如'0.000000e+00'】

'%15e'%8283489323232

' 8.283489e+12'

'%-15e'%8283489323232

'8.283489e+12 '

[2]%.ne：指定小數位數；

n>=0且為整數。

'%.10e'%82834

'8.2834000000e+04'

'%.2e'%8283489323232

'8.28e+12'

7.%c格式化符：

將0-255之間的數字轉化成對應的ASCII碼字符，也可以轉化單個字符，不過基本不做什么，直接返回

'%c'%32

' '

print '%c'%'A'

A

print '%c'%8

*一個空白

【上面的第五行的語句在這里顯示不了結果，請在IDLE或者shell中執行，就可看到結果】

二、使用str.format(*args, **kwargs)方法來格式化字符串

1.序數占位符：

'{0} is our new {1}, welcome {0}.'.format('Tom','teacher')

'Tom is our new teacher, welcome Tom.'

2.命名占位符：

'{name} is a lovly girl, she likes {fruit} and {food}.'.format(name='Lily',fruit='apple',food='rice')

'Lily is a lovly girl, she likes apple and rice.'

3.以上兩種可以混用，

且序數占位符的序數可以不給出，即使用空占位符形式，它會自動從零起開始給空占位符編序號，但切記空占位符不能與編了序數的占位符混用。

'{} is a boy, {} is {age}.'.format('Tom','he',age=12)

'Tom is a boy, he is 12.'

numbers=('one','two','three','four','five','six','seven')

'I love the numbers: {3},{5}.'.format(0,*numbers) #0只是占個位，方便選擇第3、5個元素

'I love the numbers: three,five.'

4.支持內部格式語法，即{:xxx}這種語法

format_spec ::= [[fill]align][sign][#][0][width][,][.precision][type]

fill ::=

align ::= "" | "=" | ""

sign ::= "+" | "-" | " "

width ::= integer

precision ::= integer

type ::= "b" | "c" | "d" | "e" | "E" | "f" | "F" | "g" | "G" | "n" | "o" | "s" | "x" | "X" | "%"

[1]align填充之對齊標記：

align char Meaning

'

'>' 在左邊填充

'=' 填充時強制在正負號與數字之間進行填充，只支持對數字的填充

'' 在兩邊填充

>>> for align, text in zip('', ['left', 'center', 'right']):

print 'fill = align = %r, text = %r, output:'%(align,text)

print '{0:{fill}{align}16}'.format(text, fill=align, align=align)

print

fill = align = '

left<<<<<<<<<<<<

fill = align = '^', text = 'center', output:

^^^^^center^^^^^

fill = align = '>', text = 'right', output:

>>>>>>>>>>>right

>>> def sy():

a,b=12345,8794

print '{: =6}'.format(a)

print '{: =+6}'.format(b)

print '-'*6

print '{: =6}'.format(a+b)

>>> sy()

12345

+ 8794

------

21139

>>>

[2]sign數字之前導標記：

sign char Meaning

'+' 強制對數字使用正負號

'-' 僅對負數使用前導負號(這是默認的行為)

' ' 對正數使用一個' '作前導，負數仍以'-'為前導

【參見上例】

[3]#被用來與type為'b'/'o'/'x'/'X'合作，對整數進行格式化，

格式化后數字前分別以'0b'/'0o'/'0x'/'0X'為前導

>>> #str.format支持數值向二進制格式化，是使用%進行字符串格式化所無法做到的

>>> "int: {0:d}; hex: {0:x}; oct: {0:o}; bin: {0:b}".format(42)

'int: 42; hex: 2a; oct: 52; bin: 101010'

>>> #如上str.format支持對同一Python對象進行多次不同格式化

>>> #使用'#'時，將會自動給各種格式化結果加上前導，如果有前導

>>> "int: {0:d}; hex: {0:#x}; oct: {0:#o}; bin: {0:#b}".format(42)

'int: 42; hex: 0x2a; oct: 0o52; bin: 0b101010'

>>>

[4]','被用來對數字整數部分進行千分位分隔

>>> '{:,}'.format(1234567890)

'1,234,567,890'

>>>

[5].precision對于數字對象，用來指定數字的小數位數，如果有小數；對于非數字對象，用來指定最終返回的格式化字符的最大長度，即格式化完成后，以這個precision參數對結果進行截取

>>> '{:.2f}'.format(3.235)

'3.23'

>>> '{:.2}'.format('hello')

'he'

>>> '%.2f'%3.235

'3.23'

>>> '%.2f'%3.2353

'3.24'

>>> '{:.2f}'.format(3.2351)

'3.24'

>>>

[6]type用來指定格式化時的轉換方式

當要格式化的Python對象是str對象時

Type Meaning

's' 字符串格式，這是默認格式

None 與's'相同，即原數據是str類型，且不指定type時，將采用默認的's'格式

>>> print '{{0:}}=={{0:s}}\n{0:}=={0:s}'.format('hello')

{0:}=={0:s}

hello==hello

>>>

當要格式化的Python對象是integer對象時

Type Meaning

'b' 將數值轉換成二進制字符串

'c' 將數值轉換成對應的unicode字符，比%c強多了，它支持0-255之外的字符

'd' 十進制數值

'o' 八進制數值

'x' 十六進制數值，如果要求前綴，則使用0x

'X' 十六進制數值，如果要求前綴，則使用0X

'n' 同'd'

None 在原數值為整數時，如果又沒有指定type，則此時使用'd'作為type

【參見例子2.4.3】

當要格式化的Python對象是浮點數對象時

Type Meaning

'e' 科學計數，使用字母'e'，默認精度6

'E' 科學計數，使用字母'E'，默認精度6

'f' 浮點數，默認精度6

'F' 浮點數，默認精度6

'g' 很難用，棄之不說

'G' 同'g'

'n' 同'g'

'%' 對原數值乘以100后，加上'%’作后綴

None 同'g'

【因為'g'的用法難以掌握，且規則復雜，而'e'/'f'/'%'已經足夠使用了，所以這里就棄之不說了，有興趣的可以自行研究】

>>> '{:f}'.format(32.3863)

'32.386300'

>>> '{:e}'.format(3738)

'3.738000e+03'

>>> '{:.2%}'.format(100/365.0)

'27.40%'

>>>

5.使用要格式化對象的屬性來進行格式化

>>> from collections import namedtuple

>>> Point=namedtuple('Point','X Y')

>>> p=Point(3,7)

>>> p

Point(X=3, Y=7)

>>> 'Point({p.X}, {p.Y})'.format(p=p)

'Point(3, 7)'

>>>

6.使用要格式化對象的項來進行格式化

>>> person=('Bill',23,'male')

>>> "Name: {0[0]}, Age: {0[1]}, Sex: {0[2]}".format(person)

'Name: Bill, Age: 23, Sex: male'

>>>

7.使用{!r}和{!s}取得%r和%s的效果

>>> '{!r},{!s}'.format('hello','world')

"'hello',world"

>>> #下面的無法成功，表明其它格式化符并不支持這種搞法

>>> '{!d}'.format(32)

Traceback (most recent call last):

File "", line 1, in

'{!d}'.format(32)

ValueError: Unknown conversion specifier d

>>>

8.如果要格式化的Python對象擁有自己的格式化字符，那么也可以用這個對象的格式化符進行format

>>> import datetime

>>> d = datetime.datetime(2010, 7, 4, 12, 15, 58)

>>> '{:%Y-%m-%d %H:%M:%S}'.format(d)

'2010-07-04 12:15:58'

三、str.format的基礎——Format String Syntax，

替換規則其定義如下：

replacement_field ::= "{" [field_name] ["!" conversion] [":" format_spec] "}"

field_name ::= arg_name ("." attribute_name | "[" element_index "]")*

arg_name ::= [identifier | integer]

attribute_name ::= identifier

element_index ::= integer | index_string

index_string ::= +

conversion ::= "r" | "s"

format_spec ::= Format Specification

replacement_field Example

"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'.

1.通過第1、2行，可知上面的2.5與2.6的語法基礎，而arg_name既可以是標識符也可以是序數，所以

[1]2.5的例子可以改為：

>>> from collections import namedtuple

>>> Point=namedtuple('Point','X Y')

>>> p=Point(3,7)

>>> p

Point(X=3, Y=7)

>>> 'Point({0.X}, {0.Y})'.format(p)

'Point(3, 7)'

>>>

[2]2.6的例子可以改為：

>>> person=('Bill',23,'male')

>>> "Name: {person[0]}, Age: {person[1]}, Sex: {person[2]}".format(person=person)

'Name: Bill, Age: 23, Sex: male'

>>>

2.通過第5行，可以知道element_index既可以是整數索引也可以是字符串索引，所以也可以使用字典的字符串鍵來索引字典的值

>>> person={'name':'Bill','age':23,'sex':'male'}

>>> "Name: {0[name]}, Age: {0[age]}, Sex: {0[sex]}".format(person)

'Name: Bill, Age: 23, Sex: male'

>>>

【要注意的是，占位符中的字符串索引必須不帶字符串定界符】

3.通過第1、7行，可知占位符中只允許出現!r和!s兩種，其它都不支持；而它的前后也可以有其它內容，來進行更細節的格式化控制

>>> 'The variable value is {0!r},{0!r:.3}'.format('hello')

"The variable value is 'hello','he"

>>>

PS:

字符串格式化他人學習筆記

1

總結

以上是生活随笔為你收集整理的python整数格式显示_[python之路]格式化显示的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。