By

文章目录
  1. 1. Python f-string 详解
    1. 1.1. 基本用法
    2. 1.2. 格式化控制
      1. 1.2.1. 输出左对齐，居中，右对齐
      2. 1.2.2. 补零
      3. 1.2.3. 千分位分隔符
      4. 1.2.4. 二进制，八进制，十六进制表示
      5. 1.2.5. 小数点保留数字和有效数字
      6. 1.2.6. 科学计数法
      7. 1.2.7. 百分数
      8. 1.2.8. 时间日期
      9. 1.2.9. 花括号转义
      10. 1.2.10. 嵌套变量动态格式控制
      11. 1.2.11. 等号表达式输出

Python f-string 详解

f-string 是从Python 3.6开始引入的一个特性，目的是简化 format() 函数字符串格式化输出。

根据 f-string官方文档 的描述，完整的语法描述如下：

1
2
3
4
5
6
7
8
f_string          ::=  (literal_char | "{{" | "}}" | replacement_field)*
replacement_field ::=  "{" f_expression ["="] ["!" conversion] [":" format_spec] "}"
f_expression      ::=  (conditional_expression | "*" or_expr)
                         ("," conditional_expression | "," "*" or_expr)* [","]
                       | yield_expression
conversion        ::=  "s" | "r" | "a"
format_spec       ::=  (literal_char | replacement_field)*
literal_char      ::=  <any code point except "{", "}" or NULL>

PEP 498 – Literal String Interpolation

基本用法

1
2
3
4
>>> name = 'Kevin'
>>> age = 18
>>> print(f'{name} is {age} years old.')
Kevin is 18 years old.

之所以叫做f-string，是因为使用时有一个前缀f, 也可以使用F,比如 f'...'或者F'...'，引用变量时，变量放在 {}之间。f-string本身还是一个字符串，所以可以使用单引号'，双引号""，以及三引号""" 或者 '''

1
2
3
4
5
6
>>> print(F'{name} is {age} years old.')
Kevin is 18 years old.
>>> print(f"{name} is {age} years old.")
Kevin is 18 years old.
>>> print(f"""{name} is {age} years old.""")
Kevin is 18 years old.

格式化控制

f-string输出变量值时，可以在 {}之间使用 :来进一步控制输出格式。

输出左对齐，居中，右对齐

1
2
3
4
5
6
7
>>> s = 'python'
>>> print(f'left: {s:*<20}') # 向左(<)对齐，宽度为20，*补足
left: python**************
>>> print(f'right: {s:*>20}')# 向右(>)对齐，宽度为20，*补足
right: **************python
>>> print(f'center: {s:*^20}')# 居中(^)，宽度为20，*补足
center: *******python*******

补零

1
2
3
>>> salary = 123456789
>>> print(f'zero padding: {salary:018}') # 18位宽前补0
zero padding: 000000000123456789

千分位分隔符

1
2
3
4
5
6
7
8
9
>>> salary = 123456789.15556345
>>> print(f'comma: {salary:,}') #, 作千分位分隔符
comma: 123,456,789.15556344
>>> print(f'comma: {salary:_}') # _ 作千分位分隔符
comma: 123_456_789.15556344
>>> print(f'comma: {salary:,.2f}') #, 作千分位分隔符,保留2位小数
comma: 123,456,789.16
>>> print(f'comma: {salary:018,.2f}') #, 作千分位分隔符，保留2位小数，宽度为18，前补0，
comma: 000,123,456,789.16

二进制，八进制，十六进制表示

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
>>> i = 255
>>> print(f'bin       : {i:b}') # 二进制表示
bin       : 11111111
>>> print(f'oct       : {i:o}') # 八进制表示
oct       : 377
>>> print(f'hex(lower): {i:x}') # 十六进制小写表示
hex(lower): ff
>>> print(f'hex(upper): {i:X}') # 十六进制大写表示
hex(upper): FF
>>> print(f'bin       : {i:08b}') # 二进制表示，8位宽前补0
bin       : 11111111
>>> print(f'oct       : {i:08o}') # 八进制表示，8位宽前补0
oct       : 00000377
>>> print(f'hex(lower): {i:08x}') # 十六进制小写表示，8位宽前补0
hex(lower): 000000ff
>>> print(f'hex(upper): {i:08X}') # 十六进制大写表示，8位宽前补0
hex(upper): 000000FF
>>> print(f'bin       : {i:#010b}') # 带前缀二进制小写表示，10位宽前补0
bin       : 0b11111111
>>> print(f'oct       : {i:#010o}') # 带前缀八进制小写表示，10位宽前补0
oct       : 0o00000377
>>> print(f'hex(lower): {i:#010x}') # 带前缀十六进制小写表示，10位宽前补0
hex(lower): 0x000000ff
>>> print(f'hex(upper): {i:#010X}') # 带前缀十六进制大写表示，10位宽前补0
hex(upper): 0X000000FF

小数点保留数字和有效数字

忘了什么是有效数字？

在数学中，有效数字是指在一个数中，从该数的第一个非零数字起，直到末尾数字止的数字称为有效数字，如0.618的有效数字有三个，分别是6,1,8。

1
2
3
4
5
>>> pi = 3.14159265
>>> print(f'小数点: {pi:.3f}') # 小数点后保留3位，四舍五入
小数点: 3.142
>>> print(f'有效数字: {pi:.3g}') # 三位有效数字
有效数字: 3.14

科学计数法

1
2
3
4
5
>>> f = 123.45624
>>> print(f'科学计数法: {f:.3e}')
科学计数法: 1.235e+02
>>> print(f'科学计数法: {f:.3E}')
科学计数法: 1.235E+02

百分数

1
2
3
>>> f = 0.12345
>>> print(f'百分数: {f:.2%}')
百分数: 12.35%

时间日期

1
2
3
4
5
6
7
8
9
>>> from datetime import datetime
>>> dt = datetime.now()
datetime.datetime(2024, 7, 23, 12, 46, 5, 787642)
>>> print(f'datetime: {dt}')
datetime: 2024-07-23 12:46:05.787642
>>> print(f'datetime: {dt:%A, %Y年%m月%d日 %H:%M:%S}')
datetime: Tuesday, 2024年07月23日 12:46:05
>>> print(f'datetime: {dt.isoformat()}')
datetime: 2024-07-23T12:46:05.787642

花括号转义

因为花括号已经在f-string中被使用，如果想输出花括号({})，就使用双重花括号({{}})去转义。

1
2
3
>>> n = 123
>>> print(f'{{}}-{n}-{{{n}}}')
{}-123-{123}

嵌套变量动态格式控制

1
2
3
4
5
6
7
8
9
>>> pi = 3.14159265
>>> for i in range(5):
...     print(f'pi={pi:.{i}f}') # 小数点后保留数字动态变化
... 
pi=3
pi=3.1
pi=3.14
pi=3.142
pi=3.1416

等号表达式输出

从Python 3.8开始支持等号表达式的输出。

1
2
3
>>> i = 123
>>> print(f'{i=}')
i=123

等号表达式中的空格也会保留：

1
2
3
4
5
>>> i = 123
>>> print(f'{i = }')
i = 123
>>> print(f'{ i  =   }')
 i  =   123

等号表达式两侧都支持计算：

1
2
3
4
5
>>> i = 123
>>> print(f'{i = :#b}')
i = 0b1111011
>>> print(f'{i * 2 = }')
i * 2 = 246

对于列表和字典的动态计算也支持

1
2
3
4
5
6
>>> l = [0, 10, 20]
>>> print(f'{l = }, {l[1] = }')
l = [0, 10, 20], l[1] = 10
>>> d = {'key1': 10, 'key2': 20}
>>> print(f'{d = }, {d["key1"] = }')
d = {'key1': 10, 'key2': 20}, d["key1"] = 10

lambda 表达式也可以放入{}中，但为避免 lambda 表达式的分号 : 带来的歧义，应将 lambda 表达式置于圆括号( )中

1
2
>>> print(f'{(lambda x: x**2)(10)}')
100
文章目录
  1. 1. Python f-string 详解
    1. 1.1. 基本用法
    2. 1.2. 格式化控制
      1. 1.2.1. 输出左对齐，居中，右对齐
      2. 1.2.2. 补零
      3. 1.2.3. 千分位分隔符
      4. 1.2.4. 二进制，八进制，十六进制表示
      5. 1.2.5. 小数点保留数字和有效数字
      6. 1.2.6. 科学计数法
      7. 1.2.7. 百分数
      8. 1.2.8. 时间日期
      9. 1.2.9. 花括号转义
      10. 1.2.10. 嵌套变量动态格式控制
      11. 1.2.11. 等号表达式输出