目录

格式化字符串是什么？

1.使用占位符格式化字符串：

占位符：

例子：

占位符%s、%c、%%的使用：

 占位符%d、%o、%x的使用：

占位符 %f、%e的使用：

2.使用format方法格式化输出：

1.不设置指定位置：

 2.设置指定名称：

3.设置指定位置 :

格式化字符串是什么？

Python字符串的格式化处理主要是用来将变量（对象）的值填充到字符串中，在字符串中解析Python表达式，对字符串进行格式化显示（左对齐、右对齐、居中对齐，保留数字有效位数）。

1.使用占位符格式化字符串：

使用占位符格式化输出时：在%后面加数字表示给这个字符多少个位置，不足电脑会自动使用空格补齐。正数表示左对齐，负数表示右对齐。如：%4d表示左对齐一共占4的位置，%-8d表示右对齐一共占8个位置

占位符：

1. %s :字符串的格式化，也是最常用的
2. %d :格式化整数，也比较常用
3. %c :格式化字符及ASCII码
4. %f :格式化浮点数，可以指定小数后面的精度，默认是小数点6位
5. %o :格式化无符号八进制数
6. %x :格式化无符号十六进制数
7. %e : 将整数、浮点数转换成科学计数法
8. %%: 当字符串中存在格式化标志时，需要用 %%表示一个百分号;

例子：

占位符%s、%c、%%的使用：

name='小明'
print('%s的使用:')
print('我的名字叫%s！'%(name))
print('我的名字叫%4s！'%(name))   #右对齐
print('我的名字叫%-4s！'%(name))  #左对应
#由于在python中只有字符串这种类型，使用在这里%c只能表示ASCII码，并不能表示字符
character=56
print('c的使用:')
print('%d在ASCII码中表示字母%c'%(character,character))
schedule=99
print('%%的使用:')
print('当前下载进度为%d%%！'%(character))

由于在python中只有字符串这种类型，所以在python中%c只能表示ASCII码，并不能表示字符 ！

 占位符%d、%o、%x的使用：

number=18
print('%d使用十进制为:%d'%(number,number))      #十进制
print('%d使用八进制为:%o'%(number,number))      #八进制
print('%d使用十六进制为:%x'%(number,number))    #十六进制

 如果在表示八进制或者十六进制时想显示各进制的前缀时，在%后面加一个#就好：

number=200
print('%d使用八进制为:%#o'%(number,number))
print('%d使用十六进制为:%#x'%(number,number))

占位符 %f、%e的使用：

high=174.5
print('我的身高有%f米'%(high))                    #默认情况
print('我的身高有%.1f米'%(high))                  #小数点保留1位
print('%f使用科学记数法为：%e'%(high,high))

2.使用format方法格式化输出：

1.不设置指定位置：

name = "{}在{}玩了一天的{}"
data = name.format("小明","网吧","LOL")
print(data)

 2.设置指定名称：

name = "{name}在{Location}玩了一天的{game}"
data = name.format(Location="网吧",game="LOL",name="小明")
print(data)

3.设置指定位置 :

name = "{2}在{0}玩了一天的{1}"
data = name.format("网吧","LOL","小明",)
print(data)

 注意：指定位置是从0开始算起，而不是1！

1.三种常用格式化字符串方式

1.%作占位符

name = '张三'
age = 10

print('姓名%s,今年%d' % (name, age))

# 运行结果:姓名张三,今年10

%占位符，s和d表示填充的数据类型，顺序应与%后括号中的数据变量顺序一致

2.使用format()

name = '张三'
age = 10

print('姓名{0},今年{1}岁'.format(name, age))

# 运行结果:姓名张三,今年10岁

{}为占位符，0表示format参数中第一个数据变量 依次类推

3.使用 f 格式化

name = '张三'
age = 10

print(f'姓名{name},今年{age}岁')

# 运行结果:姓名张三,今年10岁

字符串前要加 f 字符串中 {数据变量名} 才能生效

2.字符串宽度和精度的写法

1.%填充符表示法

# 宽度为10 运行结果:        80
print('%10d' % 80)

# 保留三位小数运行结果:3.142
print('%.3f' % 3.14159)

# 保留三位小数，宽度为10  运行结果:     3.142
print('%10.3f' % 3.1415926)

10为宽度 .3f 为保留三位小数 d为转化前元素数据类型
注意：如果% 后有多个数据元素，只对第一个数据元素进行格式化

2. format()表示法

# .3表示一共三个数 运行结果:3.14
print('{0:.3}'.format(3.14159))

# .3f表示三位小数  运行结果:3.142
print('{0:.3f}'.format(3.14159))

# 宽度为10 保留三位小数 运行结果:     3.142
print('{0:10.3f}'.format(3.14159))

# 0是占位符的顺序, 可以省略 默认为0

例如：

# 运行结果:   256.354
print('{1:10.3f}'.format(3.14159, 256.354))

# 1表示占位符 即format()中参数的顺序，从0开始 1就是第二个数据元素 -> 256.354
# 10表示格式化后数据元素的宽度
# .3f表示精度保留三位小数

3.字符串对齐方式

1.center() 居中对齐，第一个参数指定宽度，第二个参数指定填充符,第二个参数是选填的，默认是空格,如果设置宽度小于实际宽度则则返回原字符串

s = 'hello,python'

print(s.center(20, '*'))

# 运行结果:****hello,python****

2.ljust() 左对齐，第一个参数指定宽度，第二个参数指定填充符,第二个参数是选填的，默认是空格,如果设置宽度小于实际宽度则则返回原字符串

s = 'hello,python'

print(s.ljust(20))
# 运行结果:hello,python        

print(s.ljust(20, '*'))
# 运行结果:hello,python********

print(s.ljust(10))
# 运行结果:hello,python

3.rjust() 右对齐，第一个参数指定宽度，第二个参数指定填充符,第二个参数是选填的，默认是空格,如果设置宽度小于实际宽度则则返回原字符串

s = 'hello,python'

print(s.rjust(20))
# 运行结果:        hello, python

print(s.rjust(20, '*'))
# 运行结果:********hello,python

print(s.rjust(10))
# 运行结果:hello,python

4.zfill() 右对齐，左边用0填充,该方法只接收一个参数，用于指定字符串的宽度，如果指定的宽度小于等于字符串的长度，返回字符串本身

s = 'hello,python'

print(s.zfill(20))
# 运行结果:00000000hello,python

print(s.zfill(10))
# 运行结果:hello,python

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的方式在性能和使用的灵活性上都比%号更胜一筹，所以推荐使用

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. 使用索引

# 使用索引取对应位置的值
print('{0}{0}{1}{0}'.format('x','y')) # xxyx

3. 使用关键字参数or字典

# 可以通过关键字or字典方式的方式格式化，打破了位置带来的限制与困扰
print('我的名字是 {name}, 我的年龄是 {age}.'.format(age=18, name='egon'))

kwargs = {'name': 'egon', 'age': 18}
print('我的名字是 {name}, 我的年龄是 {age}.'.format(**kwargs)) # 使用**进行解包操作

4. 填充与格式化

# 先取到值,然后在冒号后设定填充格式：[填充字符][对齐方式][宽度]

# *<10：左对齐，总共10个字符，不够的用*号填充
print('{0:*<10}'.format('开始执行')) # 开始执行******

# *>10：右对齐，总共10个字符，不够的用*号填充
print('{0:*>10}'.format('开始执行')) # ******开始执行

# *^10：居中显示，总共10个字符，不够的用*号填充
print('{0:*^10}'.format('开始执行')) # ***开始执行***

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开头的字符串， 核心在于字符串中符号{}的使用

1. {}中可以是变量名

name = 'egon'
age = 18
print(f'{name} {age}')  # egon 18
print(F'{age} {name}')  # 18 egon

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. 在类中的使用

>>> 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. 多行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']

4. 引号的嵌套

# 当字符串嵌套发送冲突时，与正常的字符串处理方式是一样的
# 1、外层为单引号，内层嵌套也为单引号，并且想要输入的内容也为单引号，那么外层需要改用双引号
print("my name is 'egon'")

# 2、外层为单引号，内层嵌套也为单引号，并且想要输入的内容也为单引号，需要用到转义
print('my name is \'egon\'')

5. 注意

#1、反斜杠可以用来进行字符转义，但不能用在{}的表达式中
f'{1\2}' # 语法错误

#2、注释#号也不能出现在{}的表达式中
f'{x#}' # 语法错误

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. 如果不是测试的代码，不推荐使用%