String类的静态format()方法用于创建格式化的字符串。format()方法有两种重载形式。
（1）format(String format,Object…args)
该方法使用指定的格式字符串和参数返回一个格式化字符串，格式化后的新字符串使用本地默认的语言环境。
语法如下：
str.format(Stringformat,Object…args)
þ  format：格式字符串。
þ  args：格式字符串中由格式说明符引用的参数。如果还有格式说明符以外的参数，则忽略这些额外的参数。此参数的数目是可变的，可以为0。
（2）format(Local l,String format,Object…args)
þ  l：格式化过程中要应用的语言环境。如果l为null，则不进行本地化。
þ  format：格式字符串。
þ  args：格式字符串中由格式说明符引用的参数。如果还有格式说明符以外的参数，则忽略这些额外的参数。此参数的数目是可变的，可以为0。
1.　日期和时间字符串格式化
在应用程序设计中，经常需要显示时间和日期。如果想输出满意的日期和时间格式，一般需要编写大量的代码经过各种算法才能实现。format()方法通过给定的特殊转换符作为参数来实现对日期和时间的格式化。
þ  日期格式化
先来看下面的例子，返回一个月中的天数，实例代码如下：
Datedate = new Date();                            //创建Date对象date
Strings = String.format("%te", date);          //通过format()方法对date进行格式化


上述代码中变量s的值是当前日期中的天数，如今天是15号，则s的值为15；%te是转换符。常用的日期格式化转换符如表5.1所示。
说明：java.util.Date是Java中的时间日期类，这个类表示特定的瞬间，精确到毫秒。默认获取当前的时间。
表5.1  常用的日期格式化转换符


转换符


说明


示例


%te


一个月中的某一天（1~31）


2


%tb


指定语言环境的月份简称


Feb（英文）、二月（中文）


%tB


指定语言环境的月份全称


February（英文）、二月（中文）


%tA


指定语言环境的星期几全称


Monday（英文）、星期一（中文）


%ta


指定语言环境的星期几简称


Mon（英文）、星期一（中文）


%tc


包括全部日期和时间信息


星期二三月 25 13:37:22 CST 2008


%tY


4位年份


2008


%tj


一年中的第几天（001~366）


085


%tm


月份


03


%td


一个月中的第几天（01~31）


02


%ty


2位年份


08


 
【例】在项目中创建类Eval，实现将当前日期信息以4位年份、月份全称、2位日期形式输出。
 

01         import java.util.Date;                                    //导入java.util.Date类
02         publicclass Eval {                                             //新建类
03         publicstaticvoid main(String[] args) {        //主方法
04                 Date date = new Date();                             //创建Date对象date
05                 String year =String.format("%tY", date);    //将date进行格式化
06                 String month =String.format("%tB", date);
07                 String day =String.format("%td", date);
08                 System.out.println("今年是：" + year + "年"); //输出信息
09                 System.out.println("现在是：" + month);
10                 System.out.println("今天是：" + day + "号");
11             }
12         }

 运行结果如图5.36所示。



 图5.36获取指定的日期信息
þ  时间格式化
使用format()方法不仅可以完成日期的格式化，也可以实现时间的格式化。时间格式化转换符要比日期转换符更多、更精确，它可以将时间格式化为时、分、秒、毫秒。格式化时间的转换符如表5.2所示。
表5.2  时间格式化转换符


转换符


说明


示例


%tH


2位数字的24时制的小时（00~23）


14


%tI


2位数字的12时制的小时（01~12）


05


%tk


1~2位数字的24时制的小时（0~23）


5


%tl


1~2位数字的12时制的小时（1~12）


10


%tM


2位数字的分钟（00~59）


05


%tS


2位数字的秒数（00~60）


12


%tL


3位数字的毫秒数（000~999）


920


%tN


9位数字的微秒数（000000000~999999999）


062000000


%tp


指定语言环境下上午或下午标记


下午（中文）、pm（英文）


%tz


相对于GMT RFC 82 格式的数字时区偏移量


+0800


%tZ


时区缩写形式的字符串


CST


%ts


1970-01-01 00:00:00至现在经过的秒数


1206426646


%tQ


1970-01-01 00:00:00至现在经过的毫秒数


1206426737453


 
【例】在项目中创建类GetDate，实现将当前时间信息以2位小时数、2位分钟数、2位秒数形式输出。 

01        import java.util.Date;                                   //导入java.util.Date类
02         publicclass GetDate {                                  //新建类
03         publicstaticvoid main(String[] args) {         //主方法
04                 Date date = new Date();                            //创建Date对象date
05                 String hour =String.format("%tH", date);    //将date进行格式化
06                 String minute =String.format("%tM", date);
07                 String second =String.format("%tS", date);
08         //输出的信息
09                 System.out.println("现在是：" + hour + "时" + minute + "分"
10                         + second + "秒");
11             }
12         }

运行结果如图5.37所示。




 图5.37获取当前时间
þ  格式化常见的日期时间组合
格式化日期与时间的转换符定义了各种日期时间组合的格式，其中最常用的日期和时间的组合格式如表5.3所示。
表5.3  常见的日期和时间组合的格式


转换符


说明


示例


%tF


“年-月-日”格式（4位年份）


2008-03-25


%tD


“月/日/年”格式（2位年份）


03/25/08


%tc


全部日期和时间信息


星期二三月 25 15:20:00 CST 2008


%tr


“时：分：秒 PM（AM）”格式（12时制）


03:22:06 下午


%tT


“时：分：秒”格式（24时制）


15:23:50


%tR


“时：分”格式（24时制）


15:25


【例】在项目中创建类DateAndTime，在主方法中实现将当前日期时间的全部信息以指定格式的日期输出。
 
01        import java.util.Date;                                     //导入java.util.Date类
02         publicclass DateAndTime {                                     //创建类
03         publicstaticvoid main(String[] args) {        //主方法
04                 Date date = new Date();                              //创建Date对象date
05                 String time = String.format("%tc", date);       //将date格式化
06                 String form = String.format("%tF", date);
07         //将格式化后的日期时间输出
08                 System.out.println("全部的时间信息是：" + time);
09                 System.out.println("年-月-日格式：" + form);
10             }
11         }

 运行结果如图5.38所示。




图5.38将当前日期时间的全部信息以指定格式的日期输出
2.  常规类型格式化
常规类型的格式转化可应用于任何参数类型，可以通过表5.4所示的转换符来实现。
表5.4转换符


转换符


说明


示例


%b、%B


结果被格式化为布尔类型


true


%h、%H


结果被格式化为散列码


A05A5198


%s、%S


结果被格式化为字符串类型


“abcd”


%c、%C


结果被格式化为字符类型


‘a’


%d


结果被格式化为十进制整数


40


%o


结果被格式化为八进制整数


11


%x、%X


结果被格式化为十六进制整数


4b1


%e


结果被格式化为用计算机科学记数法表示的十进制数


1.700000e+01


%a


结果被格式化为带有效位数和指数的十六进制浮点值


0X1.C000000000001P4


%n


结果为特定于平台的行分隔符


 


%%


结果为字面值‘%’


%


【例】实现不同类型的格式转化。

01        publicclass StringFormat {
02         publicstaticvoid main(String[] args) {
03                 String str1 =String.format("%c", 'X'); // 输出字符
04                 System.out.println("字母x大写：" + str1);
05                 String str2 =String.format("%d", 1251 + 3950); // 输出数字
06                 System.out.println("1251+3950的结果是：" + str2);
07                 String str3 =String.format("%.2f", Math.PI); // 输出小数点后两位
08                 System.out.println("π取两位小数点：" + str3);
09                 String str4 =String.format("%b", 2 < 3); // 输出布尔值
10                 System.out.println("2<3的结果是：" + str4);
11         // 输出哈希散列码，等同Integer.toHexString(3510);
12                 String str5 =String.format("%h", 3510);
13                 System.out.println("3510的hashCode值：" + str5);
14                 String str6 =String.format("%o", 33); // 输出8进制
15                 System.out.println("33的8进制结果是：" + str6);
16                 String str7 =String.format("%x", 33); // 输出16进制
17                 System.out.println("33的16进制结果是：" + str7);
18                 String str8 =String.format("%e", 120000.1); // 输出科学计数法
19                 System.out.println("120000.1用科学计数法表示：" + str8);
20         // 输出带有效位数和指数的16进制浮点值
21                 String str9 =String.format("%a", 40.0);
22                 System.out.println("40.0的十六进制浮点值：" + str9);
23         // 输出百分号和数字
24                 System.out.println(String.format("天才是由%d%%的灵感，%d%%的汗水。", 1, 99));
25             }
26         }



运行结果如图5.39所示。



图5.39不同类型数字的格式化
使用转换符，还可以配合转换符标识来控制输出的格式，如表5.5所示。
表5.5转换符标识


标识


说明


‘-‘


在最小宽度内左对其，不可以与’0’填充标识同时使用


‘#’


用于8进制和16进制格式，在8进制前加一个0，在16进前加一个0x


‘+’


显示数字的正负号


‘’


在正数前加空格，在负数前加负号


‘0’


在不够最小位数的结果前用0填充


‘,’


只适用于10进制，每三位数字用‘，’分隔


‘(’


用括号把负数括起来


【例】使用标识控制字符串的输出格式。

01        publicclass StringFormat2 {
02         publicstaticvoid main(String[] args) {
03                  // 让字符串输出的最大长度为5，不足长度在前端补空格
04                 String str1 =String.format("%5d", 123);
05                 System.out.println("输出长度为5的字符串|" + str1 + "|");
06                 String str2 =String.format("%-5d", 123); // 让字符串左对齐
07                 System.out.println("左对齐|" + str2 + "|");
08                 String str3 =String.format("%#o", 33); // 在8进制前加一个0
09                 System.out.println("33的8进制结果是：" + str3);
10                 String str4 =String.format("%#x", 33); // 在16进前加一个0x
11                 System.out.println("33的16进制结果是：" + str4);
12                 String str5 =String.format("%+d", 1); // 显示数字正负号
13                 System.out.println("我是正数：" + str5);
14                 String str6 =String.format("%+d", -1); // 显示数字正负号
15                 System.out.println("我是负数：" + str6);
16                 String str7 =String.format("% d", 1); // 在正数前补一个空格
17                 System.out.println("我是正数，前面有空格" + str7);
18                 String str8 =String.format("% d", -1); // 在负数前补一个负号
19                 System.out.println("我是负数，前面有负号" + str8);
20                  // 让字符串输出的最大长度为5，不足长度在前端补0
21                 String str9 =String.format("%05d", 12);
22                 System.out.println("前面不够的数用0填充：" + str9);
23                 String str10 =String.format("%,d", 123456789); // 用逗号分隔数字
24                 System.out.println("用逗号分隔：" + str10);
25                 String str11 =String.format("%(d", 13); // 正数无影响
26                 System.out.println("我是正数，我没有括号：" + str11);
27                 String str12 =String.format("%(d", -13); // 让负数用括号括起来
28                 System.out.println("我是负数，我有括号的：" + str12);
29             }
30         }


运行结果如图5.40所示。




图5.40使用标识控制字符串的输出格式
  
本文摘自明日科技出版的《Java从入门到精通（项目案例版）》，转载请注明出处！！！  
感谢读者朋友对明日科技的支持，如果您对图书中的讲解及光盘源码有任何问题，可以直接登录http://www.mingrisoft.com上的社区进行发贴，把您的问题详细的说明一下，我们的技术人员会在那里给您回复！

                                            第3.11节 format字符串格式化的格式控制

一、    引言

上节介绍了四种format进行字符串格式化的方法，但都只介绍了真实值与格式符的位置映射关系，而没有介绍诸如宽度、对齐方式、精度控制等控制每个真实值显示格式的内容。本节就介绍怎么进行字符串格式化的格式控制，这种格式控制的要素在format格式化中称为“格式说明符”。

在前面章节介绍了“格式符”（也称为“替换字段”、“转换说明符”），格式说明符是格式符的一个子串，专门用于控制输出格式。

二、    格式符内容

在format字符串格式化中，“格式符”中大括号（大括号就是占位符）及其内的内容组成如下：

格式符：{[字段名][!转换标志][: 格式说明符]}

1.    字段名：索引或标识符，可以是数字（即索引）、变量、变量.属性、变量[索引]、变量[键值]，指出要设置哪个真实值并使用结果来替换该字段。请见案例部分；

2.    转换标志：跟在叹号后面的单个字符。当前支持的字符包括r（表示repr）、s（表示str）和a（表示ascii）。如果你指定了转换标志，将不使用对象本身的格式设置机制，而是使用指定的函数将对象转换为字符串，再做进一步的格式设置。上述三个标志（s、r和a）指定分别使用str、repr和ascii进行转换。关于这三种类型，老猿没有深入研究，我们来以：s='20190301 班 小明 同学,小名：小明，总分:597.5'这个字符串来进行测试：

1)    ascii(s)输出：带双引号的编码串

"'20190301 \\u73ed \\u5c0f\\u660e \\u540c\\u5b66,\\u5c0f\\u540d\\uff1a\\u5c0f\\u660e\\uff0c\\u603b\\u5206:597.5'"

2)    repr(s)输出：在原输入前加了双引号

"'20190301 班 小明 同学,小名：小明，总分:597.5'"

3)    str(s)：与s值一样。

函数str通常创建外观普通的字符串版本（没有对输入字符串做任何处理）。函数repr尝试创建给定值的Python表示（这里是一个字符串字面量，老猿暂时没有理解这句话，可能是字符串内容在Python中的内存存储？）。函数ascii创建只包含ASCII字符的表示（老猿理解就是把不是ascii码的字符转换成双字节编码展示）。

3.    格式说明符：跟在冒号后面的微型格式指定语言表达式。格式说明符让我们能够详细地指定最终的格式，包括格式类型（如字符串、浮点数或十六进制数），字段宽度和数的精度，如何显示符号和千位分隔符，以及各种对齐和填充方式。

语法：[[填充符]对齐方式][符号][#][0][宽度][分组选项][.精度][类型]

1)    所有格式说明符字段都是可选项；

2)    填充符：可以是任何字符，将在显示内容宽度比设定宽度短时用填充符补齐；

3)    对齐方式：“<”符号表示左对齐、“>”表示右对齐，“^”表示居中对齐，“=”用于带符号的数字对齐时，在符号和数字之间补充填充符，当没有指定填充符时，使用默认填充符（空格），但如果数字的宽度前有0时，0将替换默认填充符。

关于使用等号对数字对齐的举例：

'{:=+9}'.format(12345)  #结果为：'+   12345'

'{:=+09}'.format(12345) #结果为：'+00012345'

'{:*=+09}'.format(12345) #结果为：'+***12345'

4)    符号：仅用于数字，“+”表示在数字前加正号和负号，“-”表示只有负数加负号，这是默认的方式，空格表示在正数前加一个空格，负数前加一个减号

5)    #：表示在转换成字符串时使用“替代形式”。此选项仅对integer、float、complex和decimal类型有效。对于整数，使用二进制、八进制或十六进制输出时，此选项会将前缀“0b”、“0o”或“0x”分别添加到输出值。对于浮点数、复数和小数，替换形式会导致转换结果（即使后面没有数字）始终包含小数点字符。此外，对于“g”和“g”转换，尾随零不会从结果中移除。

6)    0：当没有指定填充符时，如果数字的宽度前有“0”时，“0”将替换默认填充符；

7)    宽度：数据输出占用的宽度，当实际输出大于该宽度时按实际宽度输出，此时对齐方式和填充符不起作用；

8)    分组选项：用于数字，“，”选项表示使用逗号作为千位分隔符。“_”选项表示对浮点类型和整型表示类型“d”的千位分隔符使用下划线。对于整数表示类型“B”、“O”、“X”和“x”，下划线将每4位插入一次。对于其他类型，指定此选项是错误的；

9)    精度：精度对于格式为“f”和“F”的浮点值，表示小数点后应显示多少位数，对于格式为“g”或“G”的浮点值，小数点前后应显示多少位数。对于非数字类型，字段指示最大字段大小——换句话说，字符串的精度小于字符串长度时，直接截取前面长度。整数值不允许精度。注意精度前要带点。

10)    类型：说明真实值的类型

类型           含义

b          将整数表示为二进制数

c          将整数解读为Unicode码点

d          将整数视为十进制数进行处理，这是整数默认使用的说明符

e          使用科学表示法来表示小数（用e来表示指数）

E          与e相同，但使用E来表示指数

f          将小数表示为定点数

F          与f相同，但对于特殊值（nan和inf），使用大写表示

g          自动在定点表示法和科学表示法之间选择。默认用于小数，在默认情况下至少有1位小数

G          与g相同，但使用大写来表示指数和特殊值

n          与d相同，但插入随区域而异的数字分隔符

o          将整数表示为八进制数

s          保持字符串的格式不变，这是默认用于字符串的说明符

x          将整数表示为十六进制数并使用小写字母

X          与x相同，但使用大写字母

%          将数表示为百分比值（乘以100，按说明符f设置格式，再在后面加上%）

None           当没有指定类型时，字符串按s方式，数字按d方式，浮点数按g方式

三、    格式符举例

student={'name':'小明','class':'20190301','score':597.5}

1.    s1='{st[class]}班{st[name]:_>4}总分：{st[score]:0>+6.1f}'.format(st=student)

执行结果：s1= '20190301班__小明总分：+597.5'

2.    s2='{st[class]}班{st[name]!r:_>4}总分：{st[score]:0>+6.1f}'.format(st=student)

指定名字转换标记为r，执行结果：s2="20190301班'小明'总分：+597.5"

3.    s3=f"{ student ['classno']}班{ student ['name']:_>4}总分：{ student ['score']:0>+6.1f}"

执行结果：'20190301班__小明总分：+597.5'，注意这里的字典键值加了单引号。

4.    '{:*>+#10_}'.format(123456)   #结果为'**+123_456'

5.    '{:*>+#10_b}'.format(123456) #结果为'+0b1_1110_0010_0100_0000'

6.    '{:*>+#10_o}'.format(123456) #结果为'+0o36_1100

7.    '{:*>+#10_x}'.format(123456) #结果为'*+0x1_e240'

以上例子就不补充解释了，大家对照前面的说明自己分析一下。

本节详细介绍了格式化字符串中的格式符的组成及每部分的含义，并举例进行说明，内容比较多，不容易记住，请大家先理解，具体格式实际使用时进行资料速查就可以了。最后补充介绍一下模块string中几个与字符串相关的常量和一个函数：

string.digits：包含数字0～9的字符串。

string.ascii_letters：包含所有ASCII字母（大写和小写）的字符串。

string.ascii_lowercase：包含所有小写ASCII字母的字符串。

string.printable：包含所有可打印的ASCII字符的字符串。

string.punctuation：包含所有ASCII标点字符的字符串。

string.ascii_uppercase：包含所有大写ASCII字母的字符串。虽然说的是ASCII字符，但值实际上是未解码的Unicode字符串。

string.capwords(s[, sep]) 使用split根据sep拆分s，将每项的首字母大写，再以SPLIT为分隔符将它们合并起来，如：

string.capwords(s,'/')

'/Usr/Var/Tempdirectory'

到本节为止，字符串的内容共介绍了六节内容，基本上字符串相关的内容就全介绍完了，希望大家好好理解。


截止到本节，Python的数据类型基础知识就介绍完了。这阵子老猿是每天至少写一篇博客，都是基于前期学习的知识基础上整理出来的内容，后后面准备介绍的生成器、迭代器、列表解析等内容部分还在深入研究和总结，后面更新将放慢节奏，但至少保证每周一节内容的更新，同时个人认为后面这些内容属于数据类型进阶的内容，将新开一章进行介绍。

    老猿Python(https://blog.csdn.net/LaoYuanPython)系列文章用于逐步介绍老猿学习Python后总结的学习经验，这些经验有助于没有接触过Python的程序员可以很容易地进入Python的世界。 

    欢迎大家批评指正，谢谢大家关注！

一、    引言

前面两节介绍的字符串格式化方法，都有其本身对应的缺陷，老猿不建议大家使用，之所以详细介绍主要是考虑历史代码的兼容性，方便大家理解前人留下的代码。老猿推荐大家新编码时使用format方法，因为该方法比前面2种方法更强大，也更容易理解。format方法是在Python2.6以后的版本才支持。

format格式字符串中使用大括号将格式符（也称为“转换说明符”、“替换字段”）括起来，对应的真实值通过format方法传递进来。format格式字符串有多种使用方法，我们接下来将逐一介绍。

二、    最简单的format方法进行字符串格式化

最简单的办法就是格式字符串中的每个格式符就是一个空的大括号，然后按照大括号出现的顺序逐一从format传入的参数中取值。

继续以上节的学生信息为例：

student={'name':'小明','class':'20190301','score':597.5}

print('{} 班 {} 同学，总分:{}'.format(student['class'],student['name'],student['score']))

或：

s='{} 班 {} 同学，总分:{}'

print(s.format(student['class'],student['name'],student['score']))

三、    使用索引方式的format方法进行字符串格式化

这里所说的索引就是format参数每个参数出现的顺序号，从0开始计数。在格式字符串中，格式符就是用大括号括起来的索引，因此无需按格式符出现顺序传入参数到format，也可以一个format参数在格式字符串中作为多个格式符对应真实值。

举例：

student={'name':'小明','class':'20190301','score':597.5}

print('{1} 班 {0} 同学，小名：{0}，总分:{2}'.format(student['name'],student['class'], student['score']))

#输出：20190301 班 小明 同学，小名：小明，总分:597.5

上面介绍的最简单方法实际上是索引方式的一种特例，就是每个格式符内的索引自动在其前一个格式符基础加1，第一个格式符的索引为0。我们称上一种方式为自动编号索引format方法，而现在介绍的这种方法称为人工编号索引format方法。

注意：自动编号索引format方法和人工编号索引format方法二者不能混用！为什么呢？大家请想一想。

四、    使用关键字参数方式的format方法进行字符串格式化

使用关键字参数方式的format方法进行字符串格式化与使用模板字符串进行格式化方法的基础思想很像。

关键字参数方式就是在格式符内使用索引方式的format方法用索引的地方传入一个变量名，该变量名与使用模板字符串的$符号后面的关键字参数类似，后面在format参数中，使用：关键字参数=值的模式传入实际数据。

举例：

student={'name':'小明','class':'20190301','score':597.5}

print('{classno} 班 {name} 同学,小名：{name}，总分:{score}'.format(classno=student['class'],name=student['name'],score=student['score']))

    输出内容为：20190301 班 小明 同学,小名：小明，总分:597.5

注意：与模板字符串法类似，这里的关键字参数使用的是”classno”,而不是”class”。

五、    使用关键字参数变量的属性或元素的format方法进行字符串格式化

除了一个个指定真实值对应的关键字参数外，还有一种方法可以简化format的参数，就是在格式化字符串中用点“.”或中括号“[]”来引用一个变量的属性或元素，而format只需要传入该变量就可以。

举例：

student={'name':'小明','class':'20190301','score':597.5}

s1='{st[class]}班{st[name]}总分：{st[score]}'.format(st=student)

执行后s1的内容为: '20190301班小明总分：597.5'

六、    使用format_map方法进行字符串格式化

对使用字典作为关键字参数而格式化字符串中使用字典键值获取真实值的情况，除了使用前面介绍的2种方法，还可以使用format_map方法。相对format方法，有如下变化：

1、    调用方法从format改成了format_map；

2、    格式化字符串从“变量[键]”值方式变成了“键”方式；

3、    format_map的参数不需传入“关键字=真实值”，而是直接传入真实的字典值。

举例说明如下：

如上面使用format的方法如下：

student={'name':'小明','class':'20190301','score':597.5}

s1='{st[class]}班{st[name]}总分：{st[score]}'.format(st=student)

改用format_map方法后代码如下：

student={'name':'小明','class':'20190301','score':597.5}

s1='{class}班{name}总分：{score}'.format_map(student)

执行结果都是：'20190301班小明总分：597.5'

七、    f字符串格式化方法

在Python 3.6中，如果关键字参数变量与替换字段同名，还可使用一种简写。在这种情况下，可使用f字符串——在字符串前面加上f，后面无需加format调用。

举例：   

classno,name,score=student['class'],student['name'],student['score']

s=f"{classno} 班 {name} 同学,小名：{name}，总分:{score}"  #注意使用的是classno

print(s)  #输出：20190301 班 小明 同学,小名：小明，总分:597.5

这种方法也支持变量.属性、变量[索引]的方法传递数据。举例：

l=[1,2,3]

s=f'{l[0]}' #s=’1’

这种方法也支持真实值来源一个字典:

如: s=f”{student[‘name’]}” 

注意这里“name”用了单引号，否则会报错。

以上介绍了四种使用format字符串格式化的方法，这些方法大部分不能混合使用,目前来看索引方式（包括自动编号与手动编号）与关键字参数方式可以混用，混用时使用索引的参数放在format参数的前面，关键字参数对应的真实值赋值表达式放在后面。总体来说老猿建议大家在一个字符串甚至一个模块中，尽量使用相同的字符串格式化方法。

老猿Python系列文章用于逐步介绍老猿学习Python后总结的学习经验，这些经验有助于没有接触过Python的程序员可以很容易地进入Python的世界。该系列文章同步发表于：

http://blog.sina.com.cn/learnpython   注：新浪暂停了pc的博客更新，等恢复后补齐

http://laoyuanpython.lofter.com/
https://me.csdn.net/LaoYuanPython

由于csdn对技术文章的支持度最好，推荐大家访问csdn。欢迎大家批评指正，谢谢大家关注！

 

  
【前言】本文主要介绍python中的字符串格式化，通过基本概念，使用方法及例子学习python字符串格式化的两种主要形式：字符串格式化表达以及字符串格式化方法调用。




 0. python字符串格式化

　　字符串格式化允许在一个单个的步骤中对一个字符串执行多个特定类型的替换，特别是给用户提示的时候，格式化非常方便。如今的python中的字符串格式化可以以两种形式实现： 
字符串格式化表达式


  
基于C语言的“printf”模型，并且在大多数的代码中使用。在表达式中，我们使用%二进制操作符对字符串进行格式化，%操作符为编写多字符串提供了一种简洁的方法。


字符串格式化方法调用   


  
这是python 2.6和python 3.0新增的一种格式化字符串的方法str.format()，通过{}和字符串对象的format方法代替字符串格式化表达式%


 1. 字符串格式化表达式

　　格式化字符串表达式的定义如下： 

1. 在%操作符的左侧放置一个需要进行格式化的字符串，这个字符串带有一个或多个嵌入的转换目标，都以%开头（e.g., %d）. 

2. 在%d操作符右侧放置一个（或多个，嵌入到元组中）对象，这些对象将会插入到左侧想让python进行格式化字符串的一个（或多个）转换目标的位置上去。


>>> '%s -- %s -- %s' % (42, 3.1415926, [1, 2, 3])
"42 -- 3.1415926 -- [1, 2, 3]"

　　注意到上述例子在字符串插入三个值，类型分别为：整数， 浮点数对象， 列表对象。但是所有目标左侧都是 ‘%s’, 这就表示把它们转换为字符串。由于对象的每个类别都可以转换为字符串（打印时使用），每一个与’%s’一同参与操作的对象类型都可以转换代码。因此，除非需要做特殊的格式化，一般用’%s’就可以格式化表达式。 

　　转换目标的通用结构：



%[(name)][flags][width][.precision] typecode



%[对齐] [索引:] [占位符(填充符号)] [最小占位宽度] [.精度 ] [限定符] 标识格式符 (c,s,d,o,f,x,X...)

python字符串格式化符号:

　　　　　　符   号
  
描述
%c
  
格式化字符及其ASCII码
%s
  
格式化字符串(或任何对象)
%d
  
格式化整数（十进制）
%u
  
格式化无符号整型
%o
  
格式化无符号八进制数
%x
  
格式化无符号十六进制数
%X
  
格式化无符号十六进制数（大写）
%f
  
格式化浮点数字，可指定小数点后的精度
%e
  
用科学计数法格式化浮点数
%E
  
作用同%e，用科学计数法格式化浮点数（大写E）
%g
  
根据值的大小决定使用%f活%e
%G
  
作用同%g，根据值的大小决定使用%f活%e
%p
  
用十六进制数格式化变量的地址
格式化操作符辅助指令:

符号
  
功能
*
  
定义宽度或者小数点精度
-
  
用做左对齐
+
  
在正数前面显示加号( + )
sp
  
在正数前面显示空格
#
  
在八进制数前面显示零(‘0’)，在十六进制前面显示’0x’或者’0X’(取决于用的是’x’还是’X’)
0
  
显示的数字前面填充’0’而不是默认的空格
%
  
‘%%’输出一个单一的’%’
(var)
  
映射变量(字典参数)
m.n.
  
m 是显示的最小总宽度,n 是小数点后的位数(如果可用的话)
例子：你可以在格式化字符串中用一个*来指定通过计算得出width和precision，从而迫使它们的值从%运算符右边的输出中的下一项获取，在这里，元组中的4指定为precision：



>>> 
>>> "%f, %.2f, %.*f" % (1/3.0, 1/3.0, 4, 1/3.0)
'0.333333, 0.33, 0.3333'
>>> 

基于字典的字符串格式化 

　　字符串中的格式化同时也允许左边的转换目标来引用右边字典中的键来提取对应的值：



>>> 
>>> "%(n)d %(x)s" % {"n":1, "x":"spam"}
'1 spam'
>>> 

　　上例中，格式化字符串里(ｎ)和(ｘ)引用了右边字典中的键，并提取它们对应的值。生成类似HTML或XML的程序往往利用了这一技术：你可以建立一个数值字典，并利用一个基于键的引用的格式化表达式一次性替代它们：



>>> reply = """
... Greetings...
... Hello %(name)s !
... Your age squared is %(age)s
... """
>>> values = {'name':'Solomon', 'age':18}
>>> print(reply % values)

Greetings...
Hello Solomon !
Your age squared is 18
>>> 

　　python中三引号可以将复杂的字符串进行复制, python三引号允许一个字符串跨多行，字符串中可以包含换行符、制表符以及其他特殊字符。



２. 字符串格式化调用方法

　　python 2.6和python 3.0（及其以后的版本）中的新的字符串对象的format方法使用主体字符串作为模板，并且接受任意多个表示将要根据模板替换的值的参数。在主体字符串中，花括号{}通过位置（e.g., {1}）或关键字(e.g., {food})指出替换目标及将要插入的参数。



“映射”示例

通过位置



>>> '{0},{1}'.format('Solomon',24)  
'Solomon,24'
>>> '{},{}'.format('Trump',70)  
'Trump,70'
>>> '{1},{0},{1}'.format('Hillary',69)
'69,Hillary,69'
>>> 

　　字符串的format函数可以接受不限个参数，位置可以不按顺序，可以不用或者用多次，不过2.6不能为空{}，2.7才可以。 
通过关键字参数



'{name},{age}'.format(age=18,name='kzc')  

通过对象属性



...     def __init__(self,name,age):  
...         self.name,self.age = name,age  
...         def __str__(self):  
...             return 'This guy is {self.name},is {self.age} old'.format(self=self) 
... 
>>> 
>>> str(Person('Solomon', 24))

通过下标



>>> str = ['Solomon', 24]
>>> '{0[0]},{0[1]}'.format(str)
'Solomon,24'
>>>

　　基本的Python知识告诉我们，list和tuple可以通过“打散”成普通参数给函数，而dict可以打散成关键字参数给函数（通过和*）。所以可以轻松的传个list/tuple/dict给format函数。非常灵活。

格式限定符

　　它有着丰富的的“格式限定符”（语法是{}中带:号），比如——

填充与对齐 
填充常跟对齐一起使用 

^、<、>分别是居中、左对齐、右对齐，后面带宽度 

:号后面带填充的字符，只能是一个字符，不指定的话默认是用空格填充 

比如



>>> '{:<9}'.format('1992')
'1992     '
>>> '{:>9}'.format('1992')
'     1992'
>>> '{:0>9}'.format('1992')
'000001992'
>>> '{:0<9}'.format('1992')
'199200000'
>>> '{:a<9}'.format('1992')
'1992aaaaa'
>>> 

精度与类型f 

　　精度常跟类型f一起使用



>>> '{:.2f}'.format(3.1415926)
'3.14'
>>> 

　　其中.2表示长度为2的精度，f表示float类型。

其他类型 

　　主要就是进制了，b、d、o、x分别是二进制、十进制、八进制、十六进制。



>>> '{:b}'.format(9)
'1001'
>>> '{:d}'.format(9)
'9'
>>> '{:o}'.format(9)
'11'
>>> '{:x}'.format(9)
'9'
>>> 

　　用‘，’号还能用来做金额的千位分隔符。



>>> '{:,}'.format(1234567890)
'1,234,567,890'
>>> 



Reference

[1]  爱做梦的鱼. Python中的字符串处理  
http://www.cnblogs.com/dreamer-fish/p/3818443.html 

[2] mattkang.  飘逸的python - 增强的格式化字符串format函数  
http://blog.csdn.net/handsomekang/article/details/9183303