精华内容
下载资源
问答
  • Python格式化输出

    万次阅读 多人点赞 2019-07-20 14:47:00
    Python格式化输出 格式化输出最常用的是format方法和占位符输出的方法 format方法 下面是使用format方法格式化输出字符串 print('{}{}{}'.format('小明','小红','小蓝')) 小明小红小蓝 下面是使用format方法格式化...

    Python格式化输出

    格式化输出最常用的是format方法和占位符输出的方法

    format方法

    下面是使用format方法格式化输出字符串

    print('{}{}{}'.format('小明','小红','小蓝'))
    
    小明小红小蓝
    

    下面是使用format方法格式化输出数字

    #对于整数
    print('{}'.format(2))
    
    2
    
    #对于小数   输出时只输出前n位小数位,不够时补0  冒号的作用就是让后面的部分生效
    print('{:.2f}'.format(2))
    print('{:.2f}'.format(2.344))
    print('{:.2f}'.format(2.355))
    
    2.00
    2.34
    2.35
    

    有时候需要对多个括号赋值

    print('{a:.2f},{b:.2f},{c:.2f}'.format(b = 2,c = 1,a = 0))
    
    0.00,2.00,1.00
    

    这里赋值要注意若前面大括号没有变量名,则后面也不需要,只要括号与数字一一对应即可,若前面大括号有变量名,则后面也需要标出变量名。

    print('{:.2f},{:.2f},{:.2f}'.format(2,1,0))
    
    2.00,1.00,0.00
    

    在使用format方法进行格式化输出大量数字时可能会有位数要求,还可以使用以下方法

    print('{:-<10}'.format(12.3))
    print('{:*<10}'.format(12.3))
    
    12.3------
    12.3******
    

    10表示输出的字符的长度,小数点也算一个长度, { : − &lt; 10 } \{:-&lt;10\} {:<10}的意思就是输出的数字长度为10,若不足10则用-代替,也可以用0或者空格代替不够的位数

    print('{:0<10}'.format(12.3))
    
    12.3000000
    
    print('{:<10}'.format(12.3))
    
    12.3 
    

    输出的字符默认左对齐,若要求右对齐使用下面的方法

    print('{:0>10}'.format(12.3))
    print('{:>10}'.format(12.3))
    
    00000012.3
          12.3
    

    若使用居中对齐,使用下面的方法

    print('{:-^10}'.format(12.3))
    
    ---12.3---
    

    若format后面的是一个str、list或者tuple时使用下面的方法进行格式化输出

    print('{0[0]}{0[1]}{0[2]}'.format(('小明','小红','小蓝')))
    print('{0[0]}{0[1]}{0[2]}'.format(['小明','小红','小蓝']))
    print('{0[0]}{1[1]}{2[1]}'.format('小明','小红','小蓝'))
    
    小明小红小蓝
    小明小红小蓝
    小红蓝
    

    { 0 [ 0 ] } \{0[0]\} {0[0]}中第一个0表示format方法括号内的是一个整体,是format匹配的第0个索引,第二个0表示是str、list或者tuple中的第0个元素

    下面是使用占位符方式进行格式化输出

    首先明确使用占位符输出时,%s表示字符串输出,%d表示整数输出,%f表示浮点数输出

    整数占位符输出

    print('%d,%d,%d'%(1,2,3))
    
    1,2,3
    

    字符串占位符输出

    print('%s,%s,%s'%('apple','banana','strawberry'))
    
    apple,banana,strawberry
    

    浮点数占位符输出

    print('%f,%f,%f'%(1,2,3))
    
    1.000000,2.000000,3.000000
    

    使用占位符输出浮点数时默认输出6位小数,有特别需要可以指定输出的小数位数

    print('%.2f'%3.445)
    
    3.44
    

    特别注意python3.7.3中,使用%.nf输出浮点数会进行五舍六入

    print('%.2f'%3.446)
    
    3.45
    
    展开全文
  • C语言格式化输出

    千次阅读 多人点赞 2019-08-04 07:52:16
    格式化输出 格式化输出的函数有printf、sprintf和snprintf等,功能略有不同,使用方法大同小异,本章节我们以printf为例。 对于 printf 函数,相信大家并不陌生。之所以称它为格式化输出函数,该函数的声名如下...

     

    格式化输出

           格式化输出的函数有printf、sprintf和snprintf等,功能略有不同,使用方法大同小异,本章节我们以printf为例。

           对于 printf 函数,相信大家并不陌生。之所以称它为格式化输出函数,该函数的声名如下:

                  int printf(const char *format, ...);

           大家看到printf函数的声明就会有点懵,它参数的写法与我们之前学到的函数知识不一样,printf函数是一个“可变参数函数”(即函数参数的个数是可变的),可变参数函数的知识以后再介绍,现在只要知道怎么使用就行了。

           printf函数的参数的个数和类型都是可变的,每一个参数的输出格式都有对应的格式说明符与之对应,从格式串的左端第 1 个格式说明符对应第 1 个输出参数,第 2 个格式说明符对应第 2 个输出参数,第 3 个格式说明符对应第 3 个输出参数,以此类推。

           其中,格式说明符的形式如下(方括号 [] 中的项为可选项):

           %[flags][width][.prec] type

    1、类型符(type)

           它用以表示输出数据的类型,以下是常用类型的汇总,不常用的就不列了。

           %hd、%d、%ld 以十进制、有符号的形式输出 short、int、long 类型的整数。

           %hu、%u、%lu 以十进制、无符号的形式输出 short、int、long 类型的整数

           %c 输出字符。

           %lf 以普通方式输出double(float弃用,long doube无用)。

           %e 以科学计数法输出double。

           %s 输出字符串。

          以上输出数据的知识在之前介绍数据类型的时候已演示过,这里就不举例了。

    2、宽度(width)

           它用于控制输出内容的宽度。

                printf("=%12s=\n","abc");    // 输出=         abc=

                printf("=%12d=\n",123);     // 输出=         123=

                printf("=%12lf=\n",123.5);    // 输出=  123.500000=

    3、对齐标志(flags)

           flags它用于控制输出内容的对齐方式。

           不填或+:输出的内容右对齐,这是缺省的方式,上一小节就是右对齐的示例。

           -:输出的内容左对齐。

                 printf("=%-12s=\n","abc");    // 输出=abc         =

                printf("=%-12d=\n",123);     // 输出=123         =

                printf("=%-12f=\n",123.5);    // 输出=123.500000  =

           如果输出的内容是整数或浮点数,并且对齐的方式是右对齐,可以加0填充,例如:

             printf("=%012s=\n","abc");  // 输出=         abc=

             printf("=%012d=\n",123);   // 输出=000000000123=

             printf("=%012f=\n",123.5);  // 输出=00123.500000=

           从上面第一行代码的结果看出,输出的内容不是整数或浮点数,是字符串,不能在前面填0。

           左对齐的时候,能在整数或浮点数的后面补0吗?浮点数最多可以补到6位,整数不行,你的存款能在后面补0吗?

    4、精度(prec)

           如果输出的内容是浮点数,它用于控制输出内容的精度,也就是说小数点后面保留多少位,后面的数四舍五入。

           printf("=%12.2lf=\n",123.5);   // 输出=      123.50=

           printf("=%.2lf=\n",123.5);     // 输出=123.50=

           printf("=%12.2e=\n",123500000000.0);  // 输出=    1.24e+11=

           printf("=%.2e=\n",123500000000.0);    // 输出=1.24e+11=

    格式化输出到字符串

           int printf(const char *format, ...);

           int sprintf(char *str, const char *format, ...);

           int snprintf(char *str, size_t size, const char *format, ...);

           功能:printf是把结果输出到屏幕,sprintf把格式化输出的内容保存到字符串str中,snprintf的n类似于strncpy中的n,意思是只获取输出结果的前n-1个字符,不是n个字符。

           在之前的章节中,介绍过把字符串转换为整数和浮点数据的库函数,C语言没有提供把整数和浮点数据转换为字符串的库函数,而是采用sprintf和snprintf函数格式化输出到字符串。

           示例(book98.c)

           

           运行结果

           

           程序运行第二行只输出了14个字符,注意,snprintf函数在unix和windows平台下的表现略有不同,在windows平台下,第二行会输出15个字符。

    C语言多行书写

           在我们之前学习的过程中,编写的程序的功能很简单,一句代码很短,但是在实际开发中,参数往往很长很多,一句代码可能会很长,需要用多行才能书写。

           如果我们在一行代码的行尾放置一个反斜杠,c语言编译器会忽略行尾的换行符,而把下一行的内容也算作是本行的内容。这里反斜杠起到了续行的作用。

           

           如果我们不使用反斜杠,当我们试图初始化一个跨多行的字符串时,c语言编译器可能会发出警告或错误。如下面的语句所示:

           

           C语言中还有一种拆分字符串的方法,那就是将其写个多个字符串,C语言编译器会自动将这些字符串连接起来。因此,下面的表达式:"aaaaa"  "bbbbb" "ccccc" 实际上相当于 "aaaaabbbbbccccc"。

           

           多行书写的方法如下:

           

           把字符串很长,参数很多的代码用多行书写,可以使程序代码结构更清晰,以下代码是我实际开发中用到的一句代码,这还不算长的。

           

     

    版权声明

    C语言技术网原创文章,转载请说明文章的来源、作者和原文的链接。

    来源:C语言技术网(www.freecplus.net

    作者:码农有道

    如果这篇文章对您有帮助,请点赞支持,或在您的博客中转发我的文章,谢谢!!!

    如果文章有错别字,或者内容有误,或其他的建议或意见,请您留言指正,非常感谢!!!

     

    展开全文
  • Java格式化输出的四种方法

    万次阅读 多人点赞 2021-01-19 19:56:58
    Java SE5推出了C语言printf()风格的格式化输出功能。 String str="Java"; double pi=3.14; int i=100; //"%"表示进行格式化输出,其后是格式的定义 System.out.printf("%f\n",pi);//"f"表示格式化输出浮点数 System....

    一、System.out.printf()

    Java SE5推出了C语言printf()风格的格式化输出功能。

    String str="Java";
    double pi=3.14;
    int i=100;
    //"%"表示进行格式化输出,其后是格式的定义
    System.out.printf("%f\n",pi);//"f"表示格式化输出浮点数
    System.out.printf("%d\n",i);//"d"表示格式化输出十进制整数
    System.out.printf("%o\n",i);//"o"表示格式化输出八进制整数
    System.out.printf("%x\n",i);//"x"表示格式化输出十六进制整数
    System.out.printf("%s\n",str);//"s"表示格式化输出字符串
    System.out.printf("一个字符串:%s,一个浮点数:%f,一个整数:%d",str,pi,i);//可以一次输出多个变量,注意顺序即可
    

    在这里插入图片描述
    二、System.out.format()

    Java SE5引入的format()方法模仿C的printf()方法,可用于PrintStream或者PrintWriter对象,包括System.out对象。用法基本上和System.out.printf()类似。

    String str="Java";
    double pi=3.14;
    int i=100;
    //"%"表示进行格式化输出,其后是格式的定义
    System.out.format("%f\n",pi);//"f"表示格式化输出浮点数
    System.out.format("%d\n",i);//"d"表示格式化输出十进制整数
    System.out.format("%o\n",i);//"o"表示格式化输出八进制整数
    System.out.format("%x\n",i);//"x"表示格式化输出十六进制整数
    System.out.format("%s\n",str);//"s"表示格式化输出字符串
    System.out.format("一个字符串:%s,一个浮点数:%f,一个整数:%d",str,pi,i);//可以一次输出多个变量,注意顺序即可
    

    在这里插入图片描述
    三、Fomatter类

    Java中所有的格式化功能都由java.util.Formatter类处理。当你创建一个Formatter对象时 ,需要向其构造器传递一些信息,告诉它最终的结果将向哪里输出。

    import java.util.Formatter;//使用Formatter类时需要导入java.util.Formatter
    
    Formatter f=new Formatter(System.out);//创建一个Formatter对象,指定输出为System.out
    String str="Java";
    double pi=3.14;
    int i=100;
    //"%"表示进行格式化输出,其后是格式的定义
    f.format("%f\n",pi);//"f"表示格式化输出浮点数
    f.format("%d\n",i);//"d"表示格式化输出十进制整数
    f.format("%o\n",i);//"o"表示格式化输出八进制整数
    f.format("%x\n",i);//"x"表示格式化输出十六进制整数
    f.format("%s\n",str);//"s"表示格式化输出字符串
    f.format("一个字符串:%s,一个浮点数:%f,一个整数:%d",str,pi,i);//可以一次输出多个变量,注意顺序即可
    

    在这里插入图片描述

    四、String.format()

    String.format()是一个static方法,接收与Formatter.format()一样的参数,其返回值:String对象,适用于一次输出。

    String str="Java";
    double pi=3.14;
    int i=100;
    //"%"表示进行格式化输出,其后是格式的定义
    System.out.println(String.format("%f",pi));//"f"表示格式化输出浮点数
    System.out.println(String.format("%d",i));//"d"表示格式化输出十进制整数
    System.out.println(String.format("%o",i));//"o"表示格式化输出八进制整数
    System.out.println(String.format("%x",i));//"x"表示格式化输出十六进制整数
    System.out.println(String.format("%s",str));//"s"表示格式化输出字符串
    

    在这里插入图片描述

    展开全文
  • 全网最细 Python 格式化输出用法讲解

    千次阅读 多人点赞 2021-01-17 14:32:42
    文章目录一、使用 print() 函数二、使用 str.format() 方法三、详解 format() 函数运用一:格式转换运用...在 Python 中,print() 函数支持格式化输出,与 C 语言的 printf 类似。 1. 格式化输出字符串和整数 【示例1】

    一、使用 print() 函数

    在 Python 中,print() 函数支持格式化输出,与 C 语言的 printf 类似。

    1. 格式化输出字符串和整数

    【示例1】输出字符串 AmoXiang,并计算、输出它的字符长度

    str1 = "%s.length = %d" % ("AmoXiang", len("AmoXiang"))
    print(str1)  # 输出AmoXiang.length = 8
    
    1. % 在字符串中表示格式化操作符,它后面必须附加一个格式化符号,具体说明如下表所示。
      在这里插入图片描述
    2. %()元组可以包含一个或多个值,如变量或表达式,用来向字符串中%操作符传递值,元组包含元素数量、顺序都必须与字符串中%操作符一一对应,否则将抛出异常。
    3. %()元组必须位于字符串的后面,否则无效。如果字符串中只包含一个%操作符,那么也可以直接传递值。例如:
      str1 = "AmoXiang.length = %d" % len("AmoXiang")
      print(str1)  # 输出AmoXiang.length = 8
      

    2. 格式化输出不同进制数

    【示例2】使用 print() 函数把数字输出为十六进制、十进制、八进制格式的字符串。

    num = 123
    # 输出:Hex = 7b Dec = 123 Oct=173
    print("Hex = %x Dec = %d Oct=%o" % (num, num, num))
    

    补充:整数类型包括十进制整数、八进制整数、十六进制整数和二进制整数。

    1. 十进制的整数不能以 0 开头。
    2. 八进制整数由 0~7 组成,逢八进一,以 0o 或 0O 开头,例如:0o23
    3. 十六进制整数由 0~9 以及 a~f 组成,逢十六进一,以 0x 或 0X 开头。例如:0x23
    4. 二进制整数由 0 和 1组成,逢二进一,以 0b 或 0B 开头。例如:0b101
    5. 关于进制这个知识点不懂的读者可以点击 进制转换 学习

    3. 格式化输出浮点数

    【示例3】把数字输出为不同格式的浮点数字符串。

    PI = 3.141592653
    print("pi1 = %10.3f" % PI)  # 总宽度为10,小数位精度为3
    print("pi2 = %.*f" % (3, PI))  # *表示从后面的元组中读取3,定义精度
    print("pi3 = %010.3f" % PI)  # 用0填充空白
    print("pi4 = %-10.3f" % PI)  # 左对齐,总宽度10个字符,小数位精度为3
    print("pi5 = %+f" % PI)  # 在浮点数前面显示正号
    

    程序运行结果如下:
    在这里插入图片描述
    在格式化输出数字或字符串时,可以附加辅助指令来完善格式化操作。具体说明如下表所示:
    在这里插入图片描述

    二、使用 str.format() 方法

    % 操作符是传统格式化输出的基本方法,从 Python 2.6 版本开始,为字符串数据新增了一种格式化方法 str.format(),它通过 {} 操作符和 : 辅助指令来代替 % 操作符。
    【示例1】通过位置索引值

    print('{0} {1}'.format('Python', 3.7))  # Python 3.7
    print('{} {}'.format('Python', 3.7))  # Python 3.7
    print('{1} {0} {1}'.format('Python', 3.7))  # 3.7 Python 3.7
    

    在字符串中可以使用 {} 作为格式化操作符。与 % 操作符不同的是,{} 操作符可以通过包含的位置值自定义引用值的位置,也可以重复引用。
    【示例2】通过关键字索引值

    # 输出:Amo年龄是18岁。
    print('{name}年龄是{age}岁。'.format(age=18, name="Amo"))
    

    【示例3】通过下标进行索引

    L = ["Jason", 30]
    # 输出:Jason年龄是30岁。
    print('{0[0]}年龄是{0[1]}岁。'.format(L))
    

    通过使用 format() 函数这种便捷的 映射 方式,列表和元组可以 打散 成普通参数传递给 format() 方法,字典可以打散成关键字参数给方法。format() 方法包含丰富的格式限定符,附带在 {} 操作符中 : 符号的后面。

    1. 填充与对齐

    : 符号后面可以附带填充的字符,默认为空格, ^、<、> 分别表示居中、左对齐、右对齐,后面附带宽度限定值。

    【示例4】下面示例设计输出 8 位字符,并分别设置不同的填充字符和值对齐方式。

    print('{:>8}'.format('1'))  # 总宽度为8,右对齐,默认空格填充
    print('{:0>8}'.format('1'))  # 总宽度为8,右对齐,使用0填充
    print('{:a<8}'.format('1'))  # 总宽度为8,左对齐,使用a填充
    

    程序运行结果如下:
    在这里插入图片描述
    2. 精度与类型f

    【示例5】f 与 float 类型数据配合使用

    print('{:.2f}'.format(3.141592653))  # 输出结果:3.14
    

    其中 .2f 表示小数点后面的精度为 2,f 表示浮点数输出。

    3. 进制数字输出

    【示例6】使用b、d、o、x 分别输出二进制、十进制、八进制、十六进制数字。

    num = 100
    print('{:b}'.format(num))  # 1100100
    print('{:d}'.format(num))  # 100
    print('{:o}'.format(num))  # 144
    print('{:x}'.format(num))  # 64
    

    4. 千位分隔输出

    【示例7】使用逗号(,)输出金额的千分位分隔符。

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

    三、详解 format() 函数

    format()函数可以对数据进行格式化处理操作。语法格式如下:
    在这里插入图片描述
    format_spec为格式化解释。当参数 format_spec 为空时,等同于函数 str(value) 的方式。value 为要转换的数据。format_ spec 可以设置非常复杂的格式转换参数,生成比较完备的数据格式处理模板。format_spec 的编写方式如下形式:

    format_spec ::= [[fill]align][sign][#][0][width][,][.precision][type]
    

    format_spec 格式控制符可以分为文字对齐、填充值、标志设置、格式化、类型转换、千位符(数字分组)等主要应用。细化分类说明如下图所示:
    在这里插入图片描述
    参数说明:
    (1) fill(填充值):此处可以填写任何字符,通常与align、width一起使用,实现指定位数字符填充,通常格式如图1.2所示,填充效果及位置如图1.3所示。
    在这里插入图片描述
    通常用 0、*、#、@ 等进行填充。如果不写填充值,则使用默认填充值,默认填充值为空格。代码如下:

    # 81@@@@@@@@
    print(format(81, '@<10'))  # 用@符号填充,宽度为10个空格
    # @@@@@@@@81
    print(format(81, '@>10'))  # 用@符号填充,宽度为10个空格
    

    (2) align(对齐方式):指在 width(数字宽度) 内输出时的对齐方式,分别使用 <、>、^、= 4个符号表示左对齐、右对齐、居中对齐和数字填充(只用于数字,在符号后进行补齐)。
    (3) width(数字宽度):指设定输出字符宽度,如果数据的实际位数比 width 指定宽度值大,则使用数据实际的长度。如果该值的实际位数小于指定宽度,则位数将设定的 fill 值填充或设定的 0 值填充,如果没有设置填充值,则用空格填充。

    s = "PYTHON"
    print(format(s, '10'))  # 没有标志符,如果是字符串则默认左对齐,不足宽度部分默认用空格填充
    print(format(13.14, '10'))  # 没有标志符,如果是数字则默认右对齐,不足宽度部分默认用空格填充
    print(format(s, '0>10'))  # 右对齐,不足指定宽度部分用0填充
    print(format(s, '>04'))  # 右对齐,因字符实际宽度大于指定宽度4,不用填充
    print(format(s, '*>10'))  # 右对齐,不足部分用"*"填充
    print(format(s, '>010'))  # 右对齐,不足部分用0填充
    print(format(s, '>10'))  # 右对齐,默认用空格填充
    print(format(s, '<10'))  # 左对齐,默认用空格填充
    print(format(s, '<010'))  # 左对齐,不足部分用0填充
    print(format(s, '@^10'))  # 中间对齐,不足部分用'@'填充,宽度为10个空格
    print(format(13.14, '0<10'))  # 左对齐,不足部分用0填充
    print(format(13.14, '@^10'))  # 中间对齐,不足部分用@填充
    print(format(13.14, '0>10'))  # 右对齐,不足部分用0填充
    print(format(-13.14, '0=10'))  # 右对齐,符号后面不足部分用0填充
    

    程序运行结果如下:

    (4) precision(精度):精度由小数点 . 开头。对于浮点数,精度表示小数部分输出的有效位数。对于字符串,精度表示输出的最大长度。precision(精度) 通常和 type(类型) 配合起来使用。
    (5) type(类型):表示输出字符串、整数和浮点数类型的格式规则,默认为字符型 s。对于整数类型,输出格式包括 7 种:

    1. b:输出整数的二进制方式。
    2. c:输出整数对应的 Unicode 字符。
    3. d:输出整数的十进制方式。
    4. n:输出整数的十进制方式。
    5. o:输出整数的八进制方式。
    6. x:输出整数的小写十六进制方式。当值为整数时和 d 类似,值为浮点数时和 g 类似。不同之处在于 n 会使用当前区域设置来插入适当数字分隔字符。
    7. X:输出整数的大写十六进制方式。

    对于浮点数类型,输出格式包括 7 种:

    1. e:输出浮点数对应的小写字母 e 的指数形式。
    2. E:输出浮点数对应的大写字母 E 的指数形式。
    3. f:输出浮点数的浮点表示形式,默认保留 6 位小数。
    4. F:输出浮点数的浮点表示形式,默认保留 6 位小数,无穷大转换成大写字母 INF。
    5. g:自动调整将整数、浮点数转换成浮点型或科学记数法表示(超过 6 位数用科学记数法),并将其格式化到指定位置(如果是科学计数则是 e)。
    6. G:自动调整将整数、浮点数转换成浮点型或科学记数法表示(超过 6 位数用科学记数法),并将其格式化到指定位置(如果是科学计数则是 E)。
    7. %:输出浮点数的百分形式。

    运用一:格式转换

    使用 format() 函数可以转换格式。如果 format() 函数的参数format_spec 未提供,则默认为将其他格式数据格式化为字符型,和调用 str(value) 效果相同。如:

    import datetime
    
    # 使用format()函数将浮点数转换成字符,结果为:'3.14'
    print(format(3.14))
    # 使用str()函数将浮点数转换成字符,结果为:'3.14'
    print(str(3.14))
    # 将日期格式化为字符,结果为:'2021-01-17   05:25:02'
    print(format(datetime.datetime.utcnow().strftime("%Y-%m-%d   %H:%M:%S")))
    

    设置参数 format_spec 的值,可以进行相应数据类型的格式化,字符串可以提供的参数为 s。十进制整型提供的参数为 d 和 n,二进制的参数为 b,八进制的参数为 o,十六进制小写的参数为 x,十六进制大写的参数为 X,ASIIC 码的参数为 c,浮点数的参数为 f。以上格式化后的数据类型都为字符型,举例如下:

    print(format(12.2, 'f'))  # 转换成浮点数,默认为小数保留6位,输出:12.200000
    print(format(12, 'd'))  # 转换成十进制,输出:12
    print(format(13))  # 不带参数默认为十进制,输出:13
    print(format(13, 'n'))  # 转换成十进制数,输出:13
    print(format(13, 'b'))  # 转换成二进制,输出:1101
    print(format(65, 'c'))  # 转换Unicode成字符,输出:A
    print(format(97, 'c'))  # 转换Unicode成字符,输出:a
    print(format(8750, 'c'))  # 转换Unicode成字符,输出:∮
    print(format(12, 'o'))  # 转换成八进制,输出:14
    print(format(12, 'x'))  # 转换成十六进制小写字母表示,输出:c
    print(format(12, 'X'))  # 转换成十六进制大写字母表示,输出:C
    

    运用二:生成数据编号

    利用 format() 函数实现数据编号。对数据进行编号,也是对字符串格式化操作的一种方式,使用 format() 函数可以对字符串进行格式化编号。只需设置填充字符(编号通常设置 0),设置对齐方式时可以使用 <、> 和 ^ 符号表示左对齐、右对齐和居中对齐,对齐填充的符号在 宽度 范围内输出时填充即可。对数字 1 进行 3 位编号,右对齐,需要设置 format() 函数的填充字符为 0,对齐方式为右对齐,宽度为 3。具体代码为:

    print(format(1, '0>3'))  # 输出:001
    print(format(1, '>03'))  # 输出:001
    print(format(15, '0>5'))  # 输出:00015
    

    要生成的编号通常比较复杂,如根据当天的日期建立编号,或者批量生成编号,或者将给定的批量数据中的数字转换成位数固定的编号,下面给出实现编号的代码:

    import datetime
    
    # 时间+编号
    wx = datetime.datetime.now().date()
    now = datetime.datetime.now()
    print(str(wx), format(1, '0>3'))  # 年-月-日 +3位编号,输出:2021-01-17 001
    print(format(now, '%Y-%m-%d'), format(1, '0>3'))  # 年-月-日 +3位编号,输出:2021-01-17 001
    print(format(now, '%Y%m%d'), 'NO' + format(1, '0>3'))  # 年-月-日+NO+3位编号,输出:20210117 NO001
    print(format(now, '%d'), 'NO' + format(1, '0>3'))  # 日期 +NO+3位编号,输出:17 NO001
    print(format(now, '%H%M'), 'NO' + format(1, '0>3'))  # 时-+分 +NO+3位编号,输出:1411 NO001
    

    批量生成编号:

    # 批量生成编号
    for i in range(1, 6):
        print(format(i, '0>2'))
    

    程序运行结果如下:
    在这里插入图片描述

    # 格式化列表编号
    # 对已有非编号数字进行格式化编号
    nba = {1: '伦纳德', 2: '哈登', 3: '乔治'}
    for key, value in nba.items():
        print(format(key, '0>3'), value)
    

    程序运行结果如下:
    在这里插入图片描述
    要实现嵌套编号,如A001-A005、B001-B005、C001-005 的嵌套编号,代码如下:

    for i in range(65, 69):
        for j in range(1, 6):
            data = chr(i) + format(j, '0>3') + ' '
            print(data, end='')
        print()
    

    程序运行结果如下:
    在这里插入图片描述

    运用三:格式化十进制整数

    对于不同的类型数据,format() 函数的参数 format_spec 提供的值都不一样,对于十进制整数,整型数值可以提供的参数有d、n。具体如下:

    print(format(81, '8d'))  # 8位整数显示,不足部分整数前用空格填充
    print(format(81, '+d'))  # 格式化为带符号整数显示数据
    print(format(-81, '8d'))  # 格式化为8位带符号整数显示,补位空格放到符号前
    print(format(81, '=8d'))  # 格式化为8位正整数,用空格补位
    print(format(-81, '=8d'))  # 格式化为8位负整数,不足部分在负号后填充
    print(format(81, '+8d'))  # 格式化为8位正整数,不足部分在符号前填充
    print(format(-81, '8d'))  # 格式化为8位负整数,不足部分在符号前填充
    
    print(format(81, '>10'))  # 右对齐,宽度为10个字符
    print(format(81, '<10'))  # 左对齐,宽度为10个字符
    print(format(81, '010'))  # 用0填充空格,宽度为10个字符
    print(format(81, '@<10'))  # 用“@”填充空格,宽度为10个字符
    print(format(81, '@>10'))  # 用“@”填充空格,宽度为10个字符
    print(format(+81, '=10'))  # 右对齐,宽度为10个字符
    print(format(81, '0^10'))  # 用0填充空格,宽度为10个字符
    
    s = 125
    print(format(s, '0>10'))  # 右对齐,不足指定宽度部分用0填充
    print(format(s, '>04'))  # 右对齐,不足指定宽度部分用0填充
    print(format(s, '*>10'))  # 右对齐,不足指定宽度部分用“*”填充
    print(format(s, '>010'))  # 右对齐,指定0标志位填充
    print(format(s, '>10'))  # 右对齐,没指定填充值,用默认值空格填充
    print(format(s, '+^30'))  # 居中对齐,用“+”填充不足部分
    print(format(s, '*<8'))  # 右对齐,不足指定宽度部分用“*”填充
    print(format(s, '08'))  # 右对齐,指定0标志位填充
    

    运用四:格式化浮点数

    对于浮点数类型,可以提供的参数有e、E、f、F、g、G、n、%、None 等。
    用 f 表示浮点类型,可以在其前边加上精度控制,用于控制输出宽度。如果输出位数大于宽度,就按实际位数输出。还可以为浮点数指定符号,+表示在正数前显示正号+。- 表示在负数前显示负号 - (- 与什么都不加({:f})时一致)。空格表示在正数前加空格,在负数前加 -,.3f 表示浮点数的精度为 3(小数位保留3位)。

    print(format(628, '.1f'))  # 格式化为保留1位小数的浮点数,输出:628.0
    print(format(628, '.2f'))  # 格式化为保留2位小数的浮点数,输出:628.00
    print(format(3.14159, '.1f'))  # 格式化为保留1位小数的浮点数,输出:3.1
    print(format(3.14159, '.2f'))  # 格式化为保留2位小数的浮点数,输出:3.14
    print(format(3.14159, '.5f'))  # 格式化为保留5位小数的浮点数,输出:3.14159
    print(format(-3.14159, '.3f'))  # 格式化为保留3位小数的浮点数,输出:-3.142
    print(format(3.1415926535898, 'f'))  # 默认精度保留6位小数,输出:3.141593
    # 默认精度保留6位小数,不足部分用空格填充,输出:3.141590
    print(format(3.14159, 'f'))
    
    print(format(3.14159, '+.3f'))  # 格式化为保留3位小数带符号的浮点数
    print(format(3.14159, '>8.2f'))  # 右对齐,保留2位小数
    print(format(3.14159, '<10.2f'))  # 左对齐,宽度为10,保留2位小数,不足部分用空格填充
    print(format(3.14159, '<.3f'))  # 左对齐,保留3位小数
    print(format(3.14159, '@>10.3f'))  # 右对齐,用“@”填充不足位置
    print(format(-3.14159, '=10.2f'))  # 格式化为保留2位小数的10位数,默认用空格填充
    print(format(-3.14159, '0=10.2f'))  # 格式化为保留2位小数的10位数,空格用0填充
    print(format(3.14159, '0^10.2f'))  # 保留2位小数的10位数,居中显示,空格用0填充
    

    运用五:格式化百分数

    在格式化解释中单独或者在精度之后添加 % 号,可以实现用百分数显示浮点数,如:

    print(format(0.161896, '%'))  # 将小数格式化成百分数,输出:16.189600%
    print(format(0.161896, '.2%'))  # 格式化为保留2位小数的百分数,输出:16.19%
    print(format(0.0238912, '.6%'))  # 格式化为保留6位小数的百分数,输出:2.389120%
    print(format(2 / 16, '.2%'))  # 格式化为保留2位小数的百分数,输出:12.50%
    print(format(3.1415926, '.1%'))  # 格式化为保留1位小数的百分数,输出:314.2%
    print(format(0.161896, '.0%'))  # 格式化为保留整数的百分数,输出:16%
    print(format(0.0238912, '8.6%'))  # 格式化为保留6位小数的八位百分数,输出:2.389120%
    print(format(0.0238912, '>8.3%'))  # 格式化为保留3位小数的八位百分数,输出:2.389%
    

    运用六:格式化科学记数法

    如果要将浮点数采用科学记数法表示,可以在格式化模板中使用 e 和 E 或者 g 和 G。e 为通用的幂符号,用科学记数法打印数字,用 e 表示幂。使用 g 时,将数值以 fixed-point 格式输出。当数值特别大的时候,用幂形式输出。

    #####e和E
    print(format(3141592653589, 'e'))  # 科学记数法,默认保留6位小数,输出:3.141593e+12
    print(format(3.14, 'e'))  # 科学记数法,默认保留6位小数,输出:3.140000e+00
    print(format(3.14, '0.4e'))  # 科学记数法,默认保留4位小数,输出:3.1400e+00
    print(format(3141592653589, '0.2e'))  # 科学记数法,保留2位小数,输出:3.14e+12
    print(format(3141592653589, '0.2E'))  # 科学记数法,保留2位小数,采用大写E表示,输出:3.14E+12
    #####g和G
    print(format(3.14e+1000000, 'F'))  # 无穷大转换成大写字母,输出:INF
    print(format(3141592653589, 'g'))  # 科学记数法,保留2位小数,输出:3.14159e+12
    print(format(314, 'g'))  # 科学记数法,保留2位小数,输出:314
    print(format(3141592653589, '0.2g'))  # 科学记数法,保留2位有效数字,采用小写e表示,输出:3.1e+12
    print(format(3141592653589, 'G'))  # 科学记数法,保留5位小数,采用大写E表示,输出:3.14159E+12
    print(format(3.14e+1000000, 'g'))  # 小数点计数法,无穷大转换成小写字母,输出:inf
    

    运用七:格式化金额

    format() 函数还能用来作金额的千位分隔符。如果要实现金额前面带上相关货币的符号形式的功能,需要在该函数前面手动加上相应货币符号。如:

    print('$' + format(1201398.2315, '.2f'))  # 添加美元符号,小数保留2位
    print(chr(36) + format(1201398.2315, '.2f'))  # ASCII码添加美元符号,小数保留2位
    print('¥' + format(78088888, ','))  # 添加人民币符号,用千位分隔符区分金额
    print('£' + format(7908.2315, '.2f'))  # 添加英镑符号,用千位分隔符进行区分
    print('€' + format(7908.2315, ',.2f'))  # 添加欧元符号,保留两位小数,千位分隔
    print(chr(0x20ac) + format(1201398.2315, ',f'))  # 使用十六进制编码添加欧元符号
    

    程序运行结果如下:
    在这里插入图片描述

    运用八:格式化字符

    格式化字符主要包括截取字符串,字符串对齐方式显示,填充字符串等,代码如下:

    print(format('PYTHON', 'M^20.3'))  # 截取3个字符,宽度为20居中,不足用M填充
    print(format("PYTHON", '10'))  # 默认居左显示,不足部分用空格填充
    print(format('blog.csdn.net', '.3'))  # 截取3个字符,默认居左显示
    print(format("PYTHON", '>10'))  # 居右显示,不足部分用空格填充
    s = 'blog.csdn.net'
    print(format(s, '0>20'))  # 右对齐,不足指定宽度部分用0填充
    print(format(s, '>4'))  # 右对齐,因字符实际宽度大于指定宽度4,不用填充
    print(format(s, '*>20'))  # 右对齐,不足指定宽度部分用*填充
    print(format(s, '>020'))  # 右对齐,指定0标志位填充
    print(format(s, '>20'))  # 右对齐,没指定填充值,用默认值空格填充
    print(format(s, '+^30'))  # 居中对齐,用+填充不足部分
    

    程序运行结果如下:
    在这里插入图片描述

    运用九:进制转换

    进制转换主要是进行十进制、十六进制、八进制、二进制的转换,如果是十六进制、八进制、二进制数,转换前最好保留进制前缀,如 Ox/0o/0b,这样可以保证转换的准确性。主要进制转换符号说明如下:

    1. b:二进制。将数字以 2 为基数进行输出。
    2. d:十进制整数。将数字以 10 为基数进行输出。
    3. o:八进制。将数字以 8 为基数进行输出。
    4. x:十六进制。将数字 以16 为基数进行输出,9 以上的数字用小写字母。

    十进制、十六进制、八进制、二进制的转换代码如下:

    print(format(77))  # 格式参数为空,默认为十进制
    print(format(77, 'd'))  # 原来是十进制数,转换后为原值
    print(format(-77, 'd'))  # 原来是十进制数,转换后为原值
    print(format(77, '8d'))  # 转换为8位十进制数,空余部分用空格填充
    print(format(-77, '8d'))  # 转换为8位十进制数,负数在负号前填充空余部分空格
    print(format(77, '+8d'))  # 转换为8位带符号十进制数,在符号前填充空余部分空格
    print(format(-77, '08d'))  # 转换为8位十进制数,负数在负号前填充空余部分空格
    print(format(77, '+08d'))  # 转换为8位带符号十进制数,在符号前填充空余部分空格
    print(format(-77, '#8d'))  # 转换为8位十进制数,加进制标志
    print(format(-77, '=8d'))  # 转换为8位十进制数,空余部分填充空格
    print(format(+77, '=8d'))  # 转换为8位十进制数,空余部分填充空格
    print(format(+77, '*=8d'))  # 转换为8位十进制数,空余部分填充*
    print(format(+77, '*=+8d'))  # 转换为8位带符号十进制数,符号与数据之间填充*
    print(format(-77, '#=8d'))  # 转换为8位十进制数,在符号与空余部分填充#
    print(format(+77, '*<8d'))  # 转换为8位十进制数,左对齐,空余部分填充*
    print(format(-77, '#>8d'))  # 转换为8位十进制数,右对齐,空余部分填充#
    print(format(0X5A, 'd'))  # 十六进制数5A转换成十进制数,0X代表十六进制数
    print(format(0B011101, '+8d'))  # 二进制数011101转换成十进制数,0B代表二进制数
    print(format(0O34, 'd'))  # 八进制数34转换成十进制数,0O代表八进制数
    print(format(0O123456, '08d'))  # 十六制数123456转换成十进制数,不足用0填充
    print(format(+0X1234, '*>8d'))  # 十六进制数1234转换成十进制数,右对齐,不足用*
    

    对于带有进制前缀的数,如 0x、0o、0b,可以直接在后面加上 x、o、b 进行删除。

    print(format(0X5A, 'x'))  # 去除十六进制数的前缀,输出:5a
    print(format(0B011101, 'b'))  # 去除二进制数的前缀,输出:11101
    print(format(0O34, 'o'))  # 去除八进制数的前缀,输出:34
    

    运用十:格式化日期和时间

    format() 函数也可以对日期和时间进行格式化,格式化时可以通过日期和时间格式符号进行设置,Python 中常用的时间日期格式化符号如表 1.1 所示。
    在这里插入图片描述
    常用操作代码如下:

    import datetime
    
    now = datetime.datetime.now()
    print(format(now, '%Y-%m-%d %H:%M:%S %A'))  # 当前时间格式化为年-月-日+完整英文星期
    print(format(now, '%Y-%m-%d %H:%M:%S %a'))  # 当前时间格式化为年-月-日+简写英文星期
    # 中文年-月-日显示
    print(format(now, '%Y'), '年', format(now, '%m'), '月', format(now, '%d'), '日')
    # 中文时间显示
    print(format(now, '%H'), '年', format(now, '%M'), '分', format(now, '%S'), '秒')
    print(format(now, '%Y-%m-%d %H:%M:%S %a'))  # 当前时间格式化为年-月-日+简写英文星期
    print(format(now, '%Y-%m-%d'))  # 当前时间格式化为标准年-月-日
    print(format(now, '%y-%m-%d'))  # 当前时间格式化为短日期年-月-日
    print(format(now, '%Y<%m>%d'))  # 当前时间格式化为长日期年-月-日,间隔符为“<”和“>”
    print(format(now, '%c'))  # 本地对应的年-月-日星期表示
    
    print(format(now, '%B'))  # 本地完整的月份表示,输出:May
    print('现在是今年第', format(now, '%j'), '天')  # 今天是一年中第几天,输出:现在是今年第 017 天
    print('本周是今年第', format(now, '%U'), '周')  # 本周是一年中第几周,输出:本周是今年第 02 周
    print(format(now, '%y%m%d'))  # 无间隔符短日期格式年月日,输出:210117
    print(format(now, '%Y-%m'))  # 长日期格式年-月,输出:2021-01
    print(format(now, '%m-%d'))  # 月-日显示,输出:01-17
    print(format(now, '%m'))  # 月份单独显示,输出:01
    print(format(now, '%d'))  # 日期单独显示,输出:17
    
    print(format(now, '%H%M%S'))  # 无间隔符,输出:133536
    print(format(now, '%H:%M:%S'))  # 标准时-分-秒,输出:13:35:36
    print(format(now, '%I:%M:%S %I'))  # 12小时制时-分-秒,输出:01:35:36 01
    print(format(now, '%H:%M'))  # 时+分,输出:13:35
    print(format(now, '%M%S'))  # 分+秒,输出:3536
    print(format(now, '%H'))  # 只显示小时,输出:13
    print(format(now, '%H:%M:%S %p'))  # 日期显示按AM,PM显示,输出:13:35:36 PM
    print(format(now, '%a'))  # 英文星期简写,输出:Sun
    print(format(now, '%A'))  # 英文星期完整显示,输出:Sunday
    week = ['星期日', '星期一', '星期二', '星期三', '星期四', '星期五', '星期六']
    print(week[int(format(now, '%w'))])  # 中文星期,输出:星期日
    
    dt = datetime.datetime(2020, 5, 9)
    dm = datetime.datetime(2020, 5, 9, 12, 50, 20)
    # 将输入的日期按年-月-日和时间格式化,因时间没有输入,按0时处理
    print(format(dt, '%Y-%m-%d %H:%M:%S'))
    print(format(dt, '%Y-%m-%d'))  # 将输入的日期按年-月-日格式化
    print(format(dm, '%Y-%m-%d %H:%M:%S'))  # 将输入的日期按年-月-日和时间格式化
    print(format(dm, '%Y-%m-%d'))  # 将输入的日期按年-月-日格式化
    
    wx = datetime.datetime.now()
    print(str(wx), format(1, '0>3'))  # 年-月-日 +3位编号
    print(format(now, '%Y-%m-%d'), format(1, '0>3'))  # 年-月-日 +3位编号
    print(format(now, '%Y%m%d'), 'NO' + format(1, '0>3'))  # 年-月-日 +NO+3位编号
    print(format(now, '%d'), 'NO' + format(1, '0>3'))  # 日期 +NO+3位编号
    print(format(now, '%H%M'), 'NO' + format(1, '0>3'))  # 时钟+分 +NO+3位编号
    

    四、使用 f-string 方法

    f-string 是 Python3.6 新增的一种字符串格式方法,由于前面已经介绍了多种格式化方式,大同小异,此处用简单的案例对其用法进行演示。

    【示例1】使用 f-string 方法在字符串中嵌入变量和表达式

    name = "Python"  # 字符串
    ver = 3.6  # 浮点数
    # 输出:Python-3.6、Python-3.7、Python-3.8000000000000003
    print(f"{name}-{ver}、{name}-{ver + 0.1}、{name}-{ver + 0.2}")
    

    【示例2】在示例 1 中,表达式计算浮点数时发生溢出,可以使用特殊格式化修饰符限定只显示 1 位小数。

    name = "Python"  # 字符串
    ver = 3.6  # 浮点数
    # 输出:Python-3.6、Python-3.7、Python-3.8
    print(f"{name}-{ver}、{name}-{ver + 0.1}、{name}-{ver + 0.2:.1f}")
    

    【示例3】把十六进制数字 10 分别转换为用十进制、十六进制、八进制和二进制表示。

    n = 0x10  # 十六进制数字10
    # 输出:dec:16, hex:10, oct:16, bin:10000
    print(f"dec:{n:d}, hex:{n:x}, oct:{n:0}, bin:{n:b}")
    

    【示例4】如果要在多行中表示字符串,可以使用下面示例方式,在每一行子串前面都加上 f 修饰符。

    name = "Python"  # 字符串
    ver = 3.6  # 浮点数
    s = f"{name}-" \
        f"{ver}"
    print(s)  # 输出:Python-3.6
    

    至此今天的案例就到此结束了,笔者在这里声明,笔者写文章只是为了学习交流,以及让更多学习 Python 基础的读者少走一些弯路,节省时间,并不用做其他用途,如有侵权,联系博主删除即可。感谢您阅读本篇博文,希望本文能成为您编程路上的领航者。祝您阅读愉快!


    在这里插入图片描述

        好书不厌读百回,熟读课思子自知。而我想要成为全场最靓的仔,就必须坚持通过学习来获取更多知识,用知识改变命运,用博客见证成长,用行动证明我在努力。
        如果我的博客对你有帮助、如果你喜欢我的博客内容,请 点赞评论收藏 一键三连哦!听说点赞的人运气不会太差,每一天都会元气满满呦!如果实在要白嫖的话,那祝你开心每一天,欢迎常来我博客看看。
     编码不易,大家的支持就是我坚持下去的动力。点赞后不要忘了 关注 我哦!

    展开全文
  • Python print函数用法,print 格式化输出 使用print输出各型的 字符串 整数 浮点数
  • Java格式化输出printf()详解

    千次阅读 多人点赞 2020-09-14 14:11:05
    本文通过实例详细介绍Java格式化输出 System.out.printf() 方法的使用、参数的含义、格式转换符使用时的注意事项。
  • python格式化输出(二):f-string格式化输出

    千次阅读 多人点赞 2020-02-01 10:53:18
    format格式化再到f-string格式化格式化的方式越来越直观,f-string的效率也较前两个高一些,使用起来也比前两个简单一些。   同时值得注意的是,f-string就是在format格式化的基础之上做了一些变动,核心使用...
  • Python 格式化输出时间

    千次阅读 2020-08-01 15:32:07
    总是忘记,记录一下: print(time.strftime("%Y-%m-%d %H:%M:%S", time.gmtime())) 打印结果: 2020-08-01 07:28:12 格式化字符串可以改成自己喜欢的样子~
  • Java中格式化输出

    千次阅读 2019-03-16 15:24:04
    概要格式化控制台输出要点提示:常用的格式标识符格式标识符的解释指定宽度和精度的例子格式化输出语法注意的问题应用 格式化控制台输出 要点提示: 在控制台上显示格式化输出:System.out.printf方法 常用的格式标识符...
  • Python格式化输出的几种方式

    千次阅读 2020-07-20 11:10:06
    Python中三种格式化输出的方式: 比如要求用户输入用户名和年龄,然后打印如下格式: a = "------------- info -------------" b = "name:" c = "age:" d = "job:" e = "-------------- end -------------" name = ...
  • java 格式化输出时间日期

    千次阅读 2019-09-28 15:17:03
    java中对于格式化输出日期时间提供了很好的工具类DateFormat和SimpleDateFormat。本文以SimpleDateFormat类为主,简单介绍格式化输出日期时间的操作,因为SimpleDateFormat类可以让用户自定义各种时间格式。 ...
  • 在进行接口调试或进行接口说明时,常常需要把接口返回的JSON数据以一种友好、易读的方式进行展现。 本文介绍一种在网页里格式化输出(打印)JSON字符串的简单方式。
  • Java的格式化输出

    千次阅读 2019-03-26 18:09:53
    System.out的print和println方法,可以向控制台输出不同类型的数据,可以满足程序调试信息的输出要求。...System.out的printf方法可以对数据进行格式化输出,printf方法在Java API 文档中声明如下: voi...
  • JavaScript 字符串格式化输出

    千次阅读 2020-12-14 09:52:46
    JavaScript 字符串格式化输出 1、什么是格式 ​ 上课的时候,老师让你写作文,老师说:段落开头要缩进两个字,每一行开头不能有句号……等。这是写作文的时候,我们需要遵循的格式。 ​ 在格式化输出语句中,比如...
  • Python格式化输出(format)

    千次阅读 2018-08-16 23:42:42
    格式化输出(format) 1.基本用法 &amp;quot;hello {}&amp;quot;.format(&amp;quot;python&amp;quot;) # 引用一个参数 传字符串 # 输出:hello python &amp;quot;hello {}&amp;quot;...
  • c++的格式化输出

    千次阅读 2018-09-09 15:42:17
    在c++中通过格式化输出的库主要是iomanip 主要是对cin,cout之类的一些操纵运算子,比如setfill,setw,setbase,setprecision等等。它是I/O流控制头文件,就像C里面的格式化输出一样.以下是一些常见的控制函数的: ...
  • Java格式化输出%字符

    千次阅读 2019-05-30 12:57:13
    %为特殊字符,直接输出会报错, System.out.println(String.format("where name like %%s","Zhang san")); 要加上%进行转义 System.out.println(String.format("where name like %%%s","Zhang san")); ...
  • QString格式化输出两种方式

    千次阅读 2021-01-12 11:03:59
    个人比较喜欢这种格式化 QString str; str.sprintf("ID:%d",15); 其他 QString str = QString("ID:%1").arg(15);
  • Rust中的格式化输出

    千次阅读 2020-06-07 08:40:57
    Rust中的格式化输出格式化输出println的使用fmt::Debug的使用fmt::Display的使用一个list类型的对象的自定义格式化输出format的使用 格式化输出 rust中由一些宏(macro)负责输出,这些宏定义在std::fmt中,下面是一些...
  • 格式化输出示例 Printf详解 格式字符串 旗标 宽度和精度 arg 索引 动词 通用动词 布尔型 整型 浮点型和复数型 字符串或字节切片 指针类型 复合类型 Printf、Sprintf、Fprintf区别 Print: 输出到...
  • C语言 printf格式化输出,参数详解

    万次阅读 多人点赞 2019-02-20 20:23:54
    有关输出对齐 #include&lt;stdio.h&gt; int main(int argc, char* argv[]) { char insertTime[20] = {"1234567890"}; double insertTime1 = 12321; printf("|%-15s|\n",insertTime...
  • 3. 日期是否格式化显示为可读字符串 fastjson:SerializerFeature属性使用  https://blog.csdn.net/fly910905/article/details/78474813 实例 public static void main(String[] args) { // ...
  • Python 字典对象格式化输出

    千次阅读 2020-06-13 15:57:54
    如果这个对象的内容比较少还行,如果太长的话,这种输出会看着特别难受,还不清楚,那么如何让它格式化输出呢?这里可以应用json.dumps()方法 格式化输出 data = json.dumps(dic, indent=4,ensure_ascii=False, sort...
  • 详述 Java 语言中的格式化输出

    千次阅读 2017-03-28 10:00:37
    毫无疑问,该语句的作用就是将Hello World打印到控制台,格式也非常的简单,直接按原格式输出。但是,如果将输出的内容换成“数值”或者“日期”呢?其打印的格式是否会有什么不同的变化呢?在本文中,就让咱们一起...
  • C# 时间日期的格式化输出

    千次阅读 2018-08-28 22:34:49
    Char类型的常用方法: 对照表:   自定义格式
  • Java格式化输出

    千次阅读 2018-11-05 10:21:31
    Java SE5推出了C语言printf()风格的格式化输出功能。 1 System.out.printf() public static void main(String[] args) { int x = 1; float y=1.5f; //%d表示x是一个整数,%f表示y是一个浮点数 System.out.printf...
  • matlab 格式化输出

    千次阅读 2019-02-17 09:31:15
    matlab 格式化输出

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,023,813
精华内容 409,525
关键字:

格式化输出