格式化字符串的4种⽅式
⽬录：
Python格式化字符串的4中⽅式
⼀：%号
⼆：str.format
三：f-Strings
四：标准库模板
五：总结四种⽅式的应⽤场景
Python格式化字符串的4种⽅式
⼀：%号
%号格式化字符串的⽅式从Python诞⽣之初就已经存在，时⾄今⽇，python官⽅也并未弃⽤%号，但也并不推荐这种格式化⽅式。
# 1、格式的字符串（即%s）与被格式化的字符串（即传⼊的值）必须按照位置⼀⼀对应
# ps：当需格式化的字符串过多时，位置极容易搞混
print('%s asked %s to do something' % ('egon', 'lili'))  # egon asked lili to do something
print('%s asked %s to do something' % ('lili', 'egon'))  # lili asked egon to do something
# 2、可以通过字典⽅式格式化，打破了位置带来的限制与困扰
print('我的名字是 %(name)s, 我的年龄是 %(age)s.' % {'name': 'egon', 'age': 18})
kwargs={'name': 'egon', 'age': 18}
字符串常量的格式
print('我的名字是 %(name)s, 我的年龄是 %(age)s.' % kwargs)
⼆：str.format
该format⽅法是在Python 2.6中引⼊的，是字符串类型的内置⽅法。因为str.format的⽅式在性能和使⽤的灵活性上都⽐%号更胜⼀筹，所以推荐使⽤
2.1 使⽤位置参数
# 按照位置⼀⼀对应
print('{} asked {} to do something'.format('egon', 'lili'))  # egon asked lili to do something
print('{} asked {} to do something'.format('lili', 'egon'))  # lili asked egon to do something
2.2 使⽤索引
# 使⽤索引取对应位置的值
print('{0}{0}{1}{0}'.format('x','y')) # xxyx
2.3 使⽤关键字参数or字典
# 可以通过关键字or字典⽅式的⽅式格式化，打破了位置带来的限制与困扰
print('我的名字是 {name}, 我的年龄是 {age}.'.format(age=18, name='egon'))
kwargs = {'name': 'egon', 'age': 18}
print('我的名字是 {name}, 我的年龄是 {age}.'.format(**kwargs)) # 使⽤**进⾏解包操作
2.4 填充与格式化
# 先取到值，然后在冒号后设定填充格式：[填充字符][对齐⽅式][宽度]
# *<10：左对齐，总共10个字符，不够的⽤*号填充
print('{0:*<10}'.format('开始执⾏')) # 开始执⾏******
# *>10：右对齐，总共10个字符，不够的⽤*号填充
print('{0:*>10}'.format('开始执⾏')) # ******开始执⾏
# *^10：居中显⽰，总共10个字符，不够的⽤*号填充
print('{0:*^10}'.format('开始执⾏')) # ***开始执⾏***
2.5 精度与进制
print('{salary:.3f}'.format(salary=1232132.12351))  #精确到⼩数点后3位，四舍五⼊，结果为：1232132.124
print('{0:b}'.format(123))  # 转成⼆进制，结果为：1111011
print('{0:o}'.format(9))  # 转成⼋进制，结果为：11
print('{0:x}'.format(15))  # 转成⼗六进制，结果为：f
print('{0:,}'.format(99812939393931))  # 千分位格式化，结果为：99,812,939,393,931
三：f-Strings
str.format() ⽐ %格式化⾼级了⼀些，但是它还是有⾃⼰的缺陷。当需要传⼊的字符串过多时，仍然会显得⾮常冗长。与在Python 3.6中引⼊了f-strings，不仅⽐str.format更简洁，性能上也更胜⼀筹
f-string是以f或F开头的字符串，核⼼在于字符串中符号{}的使⽤
3.1 {}中可以是变量名
name = 'egon'
age = 18
print(f'{name} {age}')  # egon 18
print(F'{age} {name}')  # 18 egon
3.2 {}中可以是表达式
# 可以在{}中放置任意合法的Python表达式，会在运⾏时计算
# ⽐如：数学表达式
print(f'{3*3/2}') # 4.5
# ⽐如：函数的调⽤
def foo(n):
print('foo say hello')
return n
print(f'{foo(10)}') # 会调⽤foo(10)，然后打印其返回值
# ⽐如：调⽤对象的⽅法
name='EGON'
print(f'{name.lower()}') # egon
3.3 在类中的使⽤
>>> class Person(object):
...    def __init__(self, name, age):
...        self.name = name
...        self.age = age
...    def __str__(self):
...        return f'{self.name}:{self.age}'
...    def __repr__(self):
...        return f'===>{self.name}:{self.age}<==='
...
>>>
>>> obj=Person('egon',18)
>>> print(obj) # 触发__str__
egon:18
>>> obj        # 触发__repr__
===>egon:18<===
>>>
>>>
>>>
>>> # 在f-Strings中的使⽤
>>> f'{obj}'  # 触发__str__
'egon:18'
>>> f'{obj!r}' # 触发__repr__
'===>egon:18<==='
3.3 多⾏f-Stings
# 当格式化字符串过长时，如下列表info
name = 'Egon'
age = 18
gender = 'male'
hobbie1='play'
hobbie2='music'
hobbie3='read'
info = [f'名字：{name}年龄：{age}性别：{gender}',f'第⼀个爱好：{hobbie1}第⼆个爱好：{hobbie2}第三个爱好：{hobbie3}']
# 我们可以回车分隔到多⾏，注意每⾏前都有⼀个f
info = [
# 第⼀个元素
f'名字：{name}'
f'年龄：{age}'
f'性别：{gender}',
# 第⼆个元素
f'第⼀个爱好：{hobbie1}'
f'第⼆个爱好：{hobbie2}'
f'第三个爱好：{hobbie3}'
]
print(info)
# ['名字：Egon年龄：18性别：male', '第⼀个爱好：play第⼆个爱好：music第三个爱好：read']
3.4 引号的嵌套
# 当字符串嵌套发送冲突时，与正常的字符串处理⽅式是⼀样的
# 1、外层为单引号，内层嵌套也为单引号，并且想要输⼊的内容也为单引号，那么外层需要改⽤双引号
print("my name is 'egon'")
# 2、外层为单引号，内层嵌套也为单引号，并且想要输⼊的内容也为单引号，需要⽤到转义
print('my name is \'egon\'')
3.5注意
#1、反斜杠可以⽤来进⾏字符转义，但不能⽤在{}的表达式中
f'{1\2}' # 语法错误
#2、注释#号也不能出现在{}的表达式中
f'{x#}' # 语法错误
3.6 括号的处理
基于3.5我们得知，不能在{}内出现反斜杠\，所以，当我们的输出的结果中需要包含{}时，下⾯的做法就是错误的
print(f'\{天王盖地虎\}')
类似于输出%号的做法
>>> print('%s%%' %30)
30%
若想输出{}，那么需要在原有的基础上再套⼀层，如下
print(f'{{天王盖地虎}}') # {天王盖地虎}
print(f'{{{{天王盖地虎}}}}') # {{天王盖地虎}}
性能对⽐=>f_Stings性能最⾼
from timeit import timeit
def test_s():
name = 'Egon'
age = 18
return '%s:%s.' % (name, age)
def test_format():
name = 'Egon'
age = 18
return '{}:{}.'.format(name, age)
def test_f_strings():
name = 'Egon'
age = 18
return f'{name}:{age}.'
res1 = timeit(test_s, number=1000000)
res2 = timeit(test_format, number=1000000)
res3 = timeit(test_f_strings, number=1000000)
print(res1) # 0.3709844550030539
print(res2) # 0.47834375899401493
print(res3) # 0.3111891380031011, 最快
四：标准库模板
从Python 2.4起，Python标准库string引⼊了Template也可以⽤来格式化字符串，所以说，与前三种⽅式的⼀个显著区别就是：Template并属于python语⾔的核⼼语法特征，使⽤⽅式如下
from string import Template
name='EGON'
t = Template('Hello $name!')
res=t.substitute(name=name)
print(res)  # Hello EGON!
另外⼀个不同的地⽅是这个模板字符串不⽀持类似str.format那样的进制转换，需要我们⾃⼰处理
from string import Template
name='EGON'
templ_string = 'Hello $name, there is a $error error'
res=Template(templ_string).substitute(name=name, error=hex(12345))
print(res) # Hello EGON, there is a 0x3039 error
使⽤模板字符串Template的最佳的时机就是当你的程序需要处理由⽤户提供的输⼊内容时。模板字符串是最保险的选择，因为可以降低复杂性。
其他⼀些复杂的字符串格式化技巧的可能会给你的程序带来安全漏洞
五：总结四种⽅式的应⽤场景
1、如果格式化的字符串是由⽤户输⼊的，那么基于安全性考虑，推荐使⽤Template
2、如果使⽤的python3.6+版本的解释器，推荐使⽤f-Stings
3、如果要兼容python2.x版本的python解释器，推荐使⽤str.format
4、如果不是测试的代码，不推荐使⽤%

版权声明：本站内容均来自互联网，仅供演示用，请勿用于商业和其他非法用途。如果侵犯了您的权益请与我们联系QQ:729038198，我们将在24小时内删除。