python版本：python3.5.1 ; IDE：pycharm2017.2
 
目录
 
一、print()函数概述
 
二、变量的输出
 
三、数据的格式化输出
 
3.1 %字符
 
3.2 最小字段宽度和精度
 
3.3 转换标志
 
3.4 格式字符归纳
 
四、换行与防止换行
 

一、print()函数概述
 
print() 方法用于打印输出，是python中最常见的一个函数。
 
该函数的语法如下：
 
print(*objects, sep=' ', end='\n', file=sys.stdout)
 
参数的具体含义如下：
 
objects --表示输出的对象。输出多个对象时，需要用 , （逗号）分隔。
 
sep -- 用来间隔多个对象。
 
end -- 用来设定以什么结尾。默认值是换行符 \n，我们可以换成其他字符。
 
file -- 要写入的文件对象。
 
print(1)  #数值类型可以直接输出

'''
运行结果如下
1
'''

print("Hello World")  #字符串类型可以直接输出

'''
运行结果如下：
Hello World
'''

a=1
b="Hello World"
print(a, b)  #可以一次输出多个对象，对象之间用逗号分隔
'''
运行结果如下：
1 Hello World
'''

#如果直接输出字符串，而不是用对象表示的话，可以不使用逗号
print("Duan""Yixuan")
print("Duan","Yixuan")

'''
运行结果如下：
DuanYixuan
Duan Yixuan

可知，不添加逗号分隔符，字符串之间没有间隔
'''

print("www", "snh48", "com", sep=".")  # 设置间隔符
'''
运行结果如下：
www.snh48.com
'''
 
二、变量的输出
 
无论什么类型的数据，包括但不局限于：数值型，布尔型，列表变量，字典变量...都可以直接输出。
 

#例如：

num = 19
print(num)    #19  输出数值型变量

str = 'Duan Yixuan'
print(str)  #Duan Yixuan  输出字符串变量

list = [1,2,'a']
print(list)   #[1, 2, 'a']  输出列表变量

tuple = (1,2,'a')
print(tuple)    #(1, 2, 'a') 输出元组变量

dict = {'a':1, 'b':2}
print(dict)   # {'a': 1, 'b': 2} 输出字典变量
 
三、数据的格式化输出
 
在C语言中，我们可以使用printf("%-.4f",a)之类的形式，实现数据的的格式化输出。
 
在python中，我们同样可以实现数据的格式化输出。我们可以先看一个简单的例子：
 
s='Duan Yixuan'
x=len(s)
print('The length of %s is %d' %(s,x))

'''
'The length of %s is %d' 这部分叫做：格式控制符
(s,x) 这部分叫做：转换说明符
% 字符，表示标记转换说明符的开始

输出如下：
The length of Duan Yixuan is 11
'''
 
和C语言的区别在于，Python中格式控制符和转换说明符用%分隔，C语言中用逗号。
 
接下来我们仔细探讨一下格式化输出
 
3.1 %字符
 
(1).%字符：标记转换说明符的开始。
 
%字符的用法可参考上例，不再赘述。
 
3.2 最小字段宽度和精度
 
最小字段宽度：转换后的字符串至少应该具有该值指定的宽度。如果是*（星号），则宽度会从值元组中读出。
 
点(.)后跟精度值：如果需要输出实数，精度值表示出现在小数点后的位数。如果需要输出字符串，那么该数字就表示最大字段宽度。如果是*，那么精度将从元组中读出。
 
可参考C语言的实现方式。
 
注：字段宽度中，小数点也占一位。
 
PI = 3.141592653
print('%10.3f'%PI)  #字段宽10，精度3
#     3.142

#精度为3，所以只显示142，指定宽度为10，所以在左边需要补充5个空格，以达到10位的宽度
 
PI=3.1415926
print("PI=%.*f"%(3,PI))
#用*从后面的元组中读取字段宽度或精度,可以读取出来精度是3位
#PI=3.142 

#没有指定宽度，所以不需要缩进

print("PI=%*.3f"%(10,PI))   #精度为3，总长为10.
# PI=     3.142

#* 所处的位置不同，读取的内容也不同
 
3.3 转换标志
 
转换标志：-表示左对齐；+表示在数值前要加上正负号；" "(空白字符)表示正数之前保留空格()；0表示转换值若位数不够则用0填充。
 
具体的我们可以看一下例子：
 
PI=3.1415926
print('%-10.3f' %PI)  #左对齐，还是10个字符，但空格显示在右边。
#3.142
 
PI=3.1415926
print('%+f' % PI)  #显示正负号  #+3.141593
# 类型f的默认精度为6位小数。
 
PI=3.1415926
print('%010.3f'%PI) #字段宽度为10，精度为3，不足处用0填充空白
#000003.142   0表示转换值若位数不够则用0填充
 
3.4 格式字符归纳
 
格式字符    说明                                 格式字符     说明
 
%s  字符串采用str()的显示                 %x 十六进制整数
 
%r  字符串(repr())的显示                    %e 指数（基底写e）
 
%c  单个字符                                      %E   指数（基底写E）
 
%b 二进制整数                                   %f,%F      浮点数
 
%d 十进制整数                                   %g   指数(e)或浮点数(根据显示长度)
 
%i  十进制整数                                    %G  指数(E)或浮点数(根据显示长度)
 
%o 八进制整数                                     %%  字符%
 
四、换行与防止换行
 
在python中，输出函数总是默认换行，比如说：
 
for x in range(0,5):
    print(x)

'''
0
1
2
3
4
'''
 
而显然，这种输出太占“空间”，我们可以进行如下改造：
 
参考文本第一部分对end参数的描述：end -- 用来设定以什么结尾。默认值是换行符 \n，我们可以换成其他字符。
 
for x in range(0, 5):
    print(x, end=' ')
#0 1 2 3 4 
 
for x in range(0, 5):
    print(x, end=',')
#0,1,2,3,4,
 
但如果，我们同时运行上面两段代码，结果会如下所示，可知：我们需要在两次输出间，实现换行。
 
for x in range(0, 5):
    print(x, end=' ')
for x in range(0, 5):
    print(x, end=',')

#0 1 2 3 4 0,1,2,3,4,
 
我们比较以下几种方式
 
方式一：
 
for x in range(0, 5):
    print(x, end=' ')

print('\n')  

for x in range(0, 5):
    print(x, end=',')

'''
0 1 2 3 4 

0,1,2,3,4,
'''
 
之所以出现上面这种情况，是因为print()本身就是默认换行的，再加上换行符，相当于换行两次。
 
方式二：
 
for x in range(0, 5):
    print(x, end=' ')

print()  #本身自带换行，完美输出

for x in range(0, 5):
    print(x, end=',')

'''
0 1 2 3 4 
0,1,2,3,4,
'''
 
本篇完。
 
如果错误，欢迎指出。
 
 

 
 
前言：tensorflow之前的版本由于是采用静态图，所以在调试的时候比较麻烦，前面一篇文章介绍了tensorflow自带的调试器，类似于python的pdb调试，本文专门讲两个函数，用来打印tensorflow中的变量，前一篇文章参考：tensorflow Debugger教程（一）——使用自带的tfdbg进行调试
 
一、tensorflow查看tensor的传统做法
 
比如下面的例子：
 
import tensorflow as tf

x=tf.constant([2,3,4,5])
y=tf.constant([20,30,40,50])
z=tf.add(x,y)
 
with tf.Session() as sess:
    x_,y_,z_=sess.run([x,y,z])
    print(f"x:{x_} ,y:{y_} ,z:{z_}")

'''
x:[2 3 4 5] ,y:[20 30 40 50] ,z:[22 33 44 55]
'''
 
二、使用tf.Print()函数来查看
 
如果要实现上面同样的功能，需要这么做
 
import tensorflow as tf

x=tf.constant([2,3,4,5])
y=tf.constant([20,30,40,50])
z=tf.add(x,y)
xyz=tf.Print(x,["x:",x,"y:",y,'z:', z],message='x+y=z:  ',summarize=100)
 
with tf.Session() as sess:
    sess.run(xyz)
'''
x+y=z:  [x:][2 3 4 5][y:][20 30 40 50][z:][22 33 44 55]
'''
 
2.1 tf.Print()函数定义的查看
 
tf.Print(input, data, message=None, first_n=None, summarize=None, name=None)

'''
参数param：
    input: 是一个tensor，需要打印的张量；
    data：data要求是一个list，list的每一个元素是一个张量，里面包含要打印的内容；
    message：是需要输出的错误信息；
    first_n：指只记录前n次；
    summarize：是对每个tensor只打印的条目数量，如果是None，对于每个输入tensor只打印3个元素
    name：这个操作op的名字
返回值return:

    返回一个 Tensor，和 input的形状一样
'''
 
需要注意的是，tf.Print()只是构建一个op，需要run之后才会打印。而且，上面的例子中似乎觉得第一个参数x是没有什么用的，那是因为我们没有用到它的返回值，下面看一下tf.Print()的返回值是什么：
 
import tensorflow as tf

x=tf.constant([2,3,4,5])
y=tf.constant([20,30,40,50])
z=tf.add(x,y)
xyz=tf.Print(x+100,["x:",x,"y:",y,'z:', z],message='x+y=z:  ',summarize=100) # 第一个参数为 x+100
 
with tf.Session() as sess:
    print(sess.run(xyz))
'''
x+y=z:  [x:][2 3 4 5][y:][20 30 40 50][z:][22 33 44 55]
[102 103 104 105]  # 这其实就是tf.Print()的返回值，它实际上就是对x进行某种操作后返回，当然也可以不进行任何操作，直接返回x
'''
 
注意事项：
 
tf.Print()函数已经逐渐被遗弃，不再推荐使用，现在在较新的tensorflow版本中使用该方法会得到如下提示：
 
Print (from tensorflow.python.ops.logging_ops) is deprecated and will be removed after 2018-08-20.
Instructions for updating:
Use tf.print instead of tf.Print. ......后面的省略
 
推荐我们使用tf.print()函数，这是下面的内容。
 
三、tf.print()函数的使用
 
前面不管是直接使用python的print函数，还是使用tf.Print都需要构建一个会话对象session，然后再会话里面运行，而tf.print()则不在需要了，但是需要用到eager_execution模式。
 
3.1 tf.print()函数的定义
 
def print_v2(*inputs, output_stream="stderr", name=None):
   """
   Args:
    *inputs: 可以是一个tensor或者是一个string.也可以同时输出多个tensor
    output_stream: "stdout", "stderr", "log(info)", "log(warning)", "log(error)"`. Defaults to "stderr".
    name: A name for the operation (optional).
   """
 
3.2 查看一个tensor
 
import sys
import tensorflow as tf

# tf.compat.v1.enable_eager_execution()  # 此处使用的是tensorflow 1.13.1 版本
tf.enable_eager_execution()  # 此处使用的是tensorflow 1.12.0 版本

x=tf.constant([2,3,4,5])
tf.print(x, output_stream=sys.stderr)
'''
[2 3 4 5]
'''
 
3.2 同时查看多个tensor
 
import sys
import tensorflow as tf

# tf.compat.v1.enable_eager_execution()  # 此处使用的是tensorflow 1.13.1 版本
tf.enable_eager_execution()  # 此处使用的是tensorflow 1.12.0 版本

x=tf.constant([2,3,4,5])
y=tf.constant([20,30,40,50])
z=tf.add(x,y)

tf.print("x:",x, "y:",y,"z:",z,output_stream=sys.stderr)
'''
x: [2 3 4 5] y: [20 30 40 50] z: [22 33 44 55]
'''
 
3.3 在函数中使用tf.print()
 
import sys
import tensorflow as tf

# tf.compat.v1.enable_eager_execution()  # 此处使用的是tensorflow 1.13.1 版本
tf.enable_eager_execution()  # 此处使用的是tensorflow 1.12.0 版本

x=tf.constant([2,3,4,5])
y=tf.constant([20,30,40,50])

@tf.contrib.eager.defun # 构建一个函数
def add_xy(x,y):
    z=tf.add(x,y)
    tf.print("x:",x, "y:",y,"z:",z,output_stream=sys.stderr)
 
add_xy(x,y)  # 直接调用函数，不再需要构建会话
'''
x: [2 3 4 5] y: [20 30 40 50] z: [22 33 44 55]
'''
 
3.4 在会话session里面通过run来打印tensor
 
import sys
import tensorflow as tf

# tf.compat.v1.enable_eager_execution()  # 此处使用的是tensorflow 1.13.1 版本
#tf.enable_eager_execution()  # 此处使用的是tensorflow 1.12.0 版本
# 由于此处演示在session中 使用，故而不再需要eager模式

x=tf.constant([2,3,4,5])
y=tf.constant([20,30,40,50])
z=tf.add(x,y)
print_op = tf.print("x:",x, "y:",y,"z:",z,output_stream=sys.stderr)

sess = tf.Session()  # 构建一个会话
with sess.as_default():   
    sess.run(print_op)

'''
x: [2 3 4 5] y: [20 30 40 50] z: [22 33 44 55]
'''
 
注意：上面的做法显得有点鸡肋多余，因为这和我通过普通的print函数来查看tensor的值似乎没什么区别，的确如此，但是也提供了一种思路，那就是：
 
在网络的构建过程我们必须要构建session会话，能不能将会话session和tf.print()结合起来呢？参见下面
 
3.5 在构建graph的时候使用tf.print()
 
import sys
import tensorflow as tf

# tf.compat.v1.enable_eager_execution()  # 此处使用的是tensorflow 1.13.1 版本
# tf.enable_eager_execution()  # 此处使用的是tensorflow 1.12.0 版本
# 此处构建graph和session，不再使用eager模式

x=tf.constant([2,3,4,5])
y=tf.constant([20,30,40,50])
z=tf.add(x,y)
print_op = tf.print("x:",x, "y:",y,"z:",z,output_stream=sys.stderr)

sess = tf.Session()  # 构建一个会话
with sess.as_default():
    with tf.control_dependencies([print_op]):
        tripled_tensor = z * 3

    sess.run(tripled_tensor)
 
在上面我想要查看的是x,y,z这三个tensor，但是我不直接去打印它们，构建了一个操作tripled_tensor，它依赖于z,而z又依赖于x,y，所以在运行tripled_tensor的时候，会将x,y,z也运行，这个时候就可以间接得到tf.print()里面的tensor值，不需要显式的去run。

1、表格的列缺失（element-ui table组件）
 
        原因：table-layout: fixed导致的，出现部分列没有被打印
 
 
 
让表table布局更加符合预期，普通使用table时，其table-layout 默认值是 auto，导致表格第二行和第一行不一样宽，也就是两行的宽度不对齐。而使用：
 
 
table { table-layout: fixed; }
 
 
则会让表的布局以第一行为准，设置表格的宽度，然后其他行的表格宽度就按照第一行为准。一般表格第一行是表头标题，第二行以后是数据行，也就是让数据行的每列宽度向第一行列宽度看齐。
 
 
这种样式的表格布局在性能上也快得多，这是因为整个表格的内容不需要花费进行分析，以便知道列的宽度。
 
 
 解决方法：
 
<style lang="less" scoped>
    /deep/ table{
        table-layout: auto !important;
    }
    /deep/ .el-table__header-wrapper .el-table__header{
        width: 100% !important;
    }
    /deep/ .el-table__body-wrapper .el-table__body{
        width: 100% !important;
    }
</style>
 
 
 
注意点：
 
 
/deep/ table{
        table-layout: auto !important;
    }
 
 
可能会造成样式错乱，比如你页面有table，打印弹出层的table，这样修改样式有可能会导致页面表格行错位，解决办法：在页面的<el-table>标签上加id,比如pagetable，修改less样式如下
 
 
<style lang="less" scoped>
    /deep/ table{
        table-layout: auto !important;
    }
    /deep/ .el-table__header-wrapper .el-table__header{
        width: 100% !important;
    }
    /deep/ .el-table__body-wrapper .el-table__body{
        width: 100% !important;
    }
    /deep/ #pagetable table{
        table-layout: fixed !important;
    }
</style>
 
 
 
 
2、打印内容缺失（print.js/print-js独有，固定高度导致）
 
        原因：一般为了好看，会固定高度，然后超出内容出现滚动条，但是打印的时候，只会打印固定高度的内容，导致打印内容缺失
 
 解决方法：
 
<style scoped>
    @media print {
        #box{
            height: 100%;
        }
    }
</style>
 
 或者这样：
 
找到print.js的getStyle方法，加入一行代码
 
str += "<style>html,body,div{height: auto !important;}</style>";
 
getStyle: function () {
		var str = "",
			styles = document.querySelectorAll('style,link');
		for (var i = 0; i < styles.length; i++) {
			str += styles[i].outerHTML;
		}
		str += "<style>" + (this.options.noPrint ? this.options.noPrint : '.no-print') + "{display:none;}</style>";
		str += "<style>html,body,div{height: auto !important;}</style>";

		return str;
	},
 
 
 
注意点：
 
 
1、box是你固定高度标签的id，当然你也可以换成class或者其他，使样式生效即可
 
 
2、@media print只影响打印的样式，不会影响页面样式
  
 
 
3、表格内容缺失（表格滚动导致，只打印显示区域内容）
 
         原因：不管是print.js还是vue-print-nb插件，都有这个问题，因为表格滚动导致
 
 解决方法：
 
        用一个隐藏div包裹你要打印的表格或者还有其他内容，总体包裹
 
<div id="boxbox" style="display:none;">
        <el-table :data="formList" style="width: 100%" border  width="100%">
            <el-table-column align="center"  width="200" prop="prop"  label="列名"></el-table-column>
            <el-table-column label="是否启用" width="100">
                <template slot-scope="scope">
                    <el-switch v-model="scope.row.show" :active-value="1" :inactive-value="2" active-color="#409eff" inactive-color="#B9B9B9"
                    @change="changeSwitch(scope.row)"/>
                </template>
            </el-table-column>
            <el-table-column label="是否必填" width="100">
                <template slot-scope="scope">
                    <el-switch v-model="scope.row.required" :active-value="1" :inactive-value="2" active-color="#409eff" inactive-color="#B9B9B9"
                    @change="changeSwitch(scope.row)"/>
                </template>
            </el-table-column>
            <el-table-column align="center"  prop="sort" width="150"  label="排序"></el-table-column>
            <el-table-column label="操作"  align="center"  width="200">
                <template slot-scope="scope">
                    <span v-if="scope.row.sort!=0" class="editrow" @click="up(scope.row)" style="margin-right:10px">上升</span>
                    <span v-if="scope.row.sort!=formList.length-1" class="editrow" style="margin-right:10px" @click="down(scope.row)">下降</span>
                    <span v-if="scope.row.sort!=0" class="editrow" @click="upToZero(scope.row)" style="margin-right:10px">置顶</span>
                    
                </template>
            </el-table-column>
        </el-table>

    </div>
 
 
 
注意点:
 
 
1、经过测试，A4纸大小宽度大致在650px，所以你隐藏的table列，要自己设置宽度，整体宽度在750左右，大于750，列会超出，不打印，小于750，右边会留有空白
 
 
2、<el-table>不能固定高度，所以不要设置高度
 
 
 4、不能分页
 
        原因：不管你是下载print.js保存到本地，还是npm下载print-js，只能打印一页，可能太菜了
 
 
 
 
 解决方法：
 
        使用插件：vue-print-nb，使用方法：vue-print-nb
 
         此插件会根据打印内容的高度，自己分页，如果想自定义分页的话，方法如下：
 
1、在末尾的最后一个标签，加入样式 style="page-break-after: always;"
 
<div style="page-break-after: always;">我是本页的末尾哦</div>
 
2、定义打印样式，原理同上，但是方便需要，只需要统一定义class即可
 
@media print {
        @page{
            size:  auto;
            margin: 3mm;
        }
        .footer {page-break-after: always;}
}
 
 
 

1. 说明
 
1.1 符号说明
 
%字符：标记转换说明符的开始
最小字段宽度：转换后的字符串至少应该具有该值指定的宽度。如果是*，则宽度会从值元组中读出
点(.)后跟精度值：如果转换的是实数，精度值就表示出现在小数点后的位数。如果转换的是字符串，那么该数字就表示最大字段宽度。如果是*，那么精度将从元组中读出
 
1.2 格式化输出进制
 
格式
描述
%%
百分号标记
%c
字符及其ASCII码
%s
字符串
%d
有符号整数(十进制)
%u
无符号整数(十进制)
%o
无符号整数(八进制)
%x
无符号整数(十六进制)
%X
无符号整数(十六进制大写字符)
%e
浮点数字(科学计数法)
%E
浮点数字(科学计数法，用E代替e)
%f
浮点数字(用小数点符号)
%g
浮点数字(根据值的大小采用%e或%f)
%G
浮点数字(类似于%g)
%p
指针(用十六进制打印值的内存地址)
%n
存储输出字符的数量放进参数列表的下一个变量中
2. 字符串类print使用
 
string = 'hello'
# %s打印时结果是hello    
print("string=%s" %string)   # output: string=hello    

# %2s意思是字符串长度为2，当原字符串的长度超过2时，
# 按原长度打印，所以%2s的打印结果还是hello    
print ("string=%2s" %string )     # output: string=hello  

# %7s意思是字符串长度为7，当原字符串的长度小于7时，
# 在原字符串左侧补空格
print ("string=%7s" %string)     # output: string=  hello  

# %-7s意思是字符串长度为7，当原字符串的长度小于7时，
# 在原字符串右侧补空 
print ("string=%-7s" %string)     # output: string=hello  !    

# %.2s意思是截取字符串的前2个字符，所以%.2s的打印结果是he    
print ("string=%.2s" % string)    # output: string=he    
# 另一种写法，*代表的数字是小括号里的数字
print ("string=%.*s" % (3,string))  # output: string=hel

# %.7s意思是截取字符串的前7个字符，
# 当原字符串长度小于7时，即是字符串本身，       
print ("string=%.7s" % string)    # output: string=hello

# %a.bs这种格式是上面两种格式的综合，
# 首先根据小数点后面的数b截取字符串，    
# 当截取的字符串长度小于a时，还需要在其左侧补空格    
print ("string=%7.2s" % string)   # output: string=     he    
print ("string=%2.7s" % string)   # output: string=hello    
print ("string=%10.7s" % string)  # output: string=     hello    
    
# 还可以用%*.*s来表示精度，
# 两个*的值分别在后面小括号的前两位数值指定    
print ("string=%*.*s" % (7,2,string))   # output: string=     he
 
3. 整型int类print使用
 
num=14    
    
# %d打印时结果是14    
print ("num=%d" %num )            # output: num=14    
    
# %1d意思是打印结果为1位整数，当整数的位数超过1位时，
# 按整数原值打印，所以%1d的打印结果还是14    
print ("num=%1d" %num )           # output: num=14    
    
# %3d意思是打印结果为3位整数，当整数的位数不够3位时，
# 在整数左侧补空格，所以%3d的打印结果是 14    
print ("num=%3d" %num )           # output: num= 14    
    
# %-3d意思是打印结果为3位整数，
# 当整数的位数不够3位时，在整数右侧补空格   
print ("num=%-3d" %num )          # output: num=14_    
    
# %05d意思是打印结果为5位整数，
# 当整数的位数不够5位时，在整数左侧补0   
print ("num=%05d" %num )          # output: num=00014    
    
# %.3d小数点后面的3意思是打印结果为3位整数，    
# 当整数的位数不够3位时，在整数左侧补0   
print ("num=%.3d" %num )          # output: num=014    
    
# %.0003d小数点后面的0003和3一样，都表示3，意思是打印结果为3位整数，    
# 当整数的位数不够3位时，在整数左侧补0    
print ("num=%.0003d" %num )       # output: num=014    
    
# %5.3d是两种补齐方式的综合，当整数的位数不够3时，
# 先在左侧补0，还是不够5位时，再在左侧补空格，    
# 规则就是补0优先，最终的长度选数值较大的那个   
print ("num=%5.3d" %num )         # output: num=  014    
    
# %05.3d是两种补齐方式的综合，当整数的位数不够3时，
# 先在左侧补0，还是不够5位时，    
# 由于是05，再在左侧补0，最终的长度选数值较大的那个    
print ("num=%05.3d" %num )        # output: num=00014    
    
# 还可以用%*.*d来表示精度，两个*的值分别在后面小括号的前两位数值指定       
print ("num=%*.*d" % (5,4,num))  # output: num= 0014    
 
4. 浮点数float
 
import math
# 正常输出，%f表示浮点数格式控制
print 'PI = %f' % math.pi
# PI = 3.141593
 
# 宽度 = 10, 精度 = 3, 左对齐
print 'PI = %10.3fxxx' % math.pi
# PI =  3.142xxx
 
# 宽度 = 10, 精度 = 3, 右对齐
print 'PI = %-10.3fxxx' % math.pi
# PI = 3.142  xxx
 
# 使用0前面填充字符串
print 'PI = %06d' % int(math.pi)
# PI = 000003
 
5.Python format()格式控制
 
5.1 万能的%r
 
# 它可以将后面给的参数原样打印出来，带有类型信息
formatter = '%r %r %r %r'
print(formatter % (1, 2, 3, 4))
# output    1 2 3 4
print(formatter % ('one', 'two', 'three', 'four'))
# output    'one' 'two' 'three' 'four'
print(formatter % (True, False, False, True))
# output    True False False True
print(formatter % (formatter, formatter, formatter, formatter))
# output    '%r %r %r %r' '%r %r %r %r' '%r %r %r %r' '%r %r %r %r'
print(formatter % ("I thing.","had right.","But it.","said good.") )
# output    'I thing.' 'had right.' 'But it.' 'said good.'
 
5.2 通过位置标号
 
# {0}表示第一个元素， {1}表示第二个元素， {2}表示第三个元素，以此类推。。。
a = 'Ace'
b = 'hello'
print("{1}, my name is {0}".format(a, b))
# output    hello, my name is Ace
 
5.3 通过关键词参数
 
name = "Ace"
age = 26
print("{myname}'s age is {myage}".format(myname=name, myage=age))
# output    Ace's age is 26
 
5.4 通过属性和下标
 
person = ["Ace", 26]
personB = ["bce", 29]
print("{0[0]}'s age is {1[1]}".format(person, personB))
# output    Ace's age is 29

print("{people[0]}'s age is {people[1]}".format(people=person))
# output    Ace's age is 26
 
# 字典字符串
person = {'Ace': 23}
print("{myname}'s age is {people[Ace]}".format(myname=name,people=person))
# output    Ace's age is 23
 
5.5 格式化限定符和填充与对齐
 
# “ ^ ”、“ < ”、“ > ”分别代表居中，左对齐，右对齐，后面带宽度
a = 123.456789
haha = 'haha!!!'
print("{0:0.3f}, *{1:<14}*".format(a, haha))
print("{0:0.3f}, *{1:>14}*".format(a, haha))
print("{0:0.3f}, *{1:^14}*".format(a, haha))
print("{0:0.3f}, *{1:}*".format(a, haha))
 
输出：
 
# 123.457, *haha!!!    *
# 123.457, *    haha!!!*
# 123.457, *  haha!!!  *
# 123.457, *haha!!!*