精华内容
下载资源
问答
  • FORMAT
    千次阅读
    2019-08-14 22:42:00

    format常见用法包括格式化填充字符,文本的填充与对齐,格式转换等.

    format填充字符串

    通过位置进行填充

    print("""
    注意你的{},他会变成你的{};
    注意你的{},他会变成你的{};
    注意你的{},他会变成你的{};
    注意你的{},他会变成你的{};
    注意你的{},他会变成你的{}
    """.format("思想","言语","言语","行动","行动","习惯","习惯","性格","性格","命运"))
    

    用来填充的字符和需要填充的位置一一对应,如果填充的内容比较多,而且有重复,可以把填充的内容赋值给变量,重复利用

    赋值变量

    a = "思想"
    b = "言语"
    c = "行动"
    d = "习惯"
    e = "性格"
    f = "命运"
    

    变量与需要填充的位置一一对应进行填充,不需要重复写用来填充的字符了,和上边填充方法相同的一点是位置与变量的数量是相同的

    print("""
    注意你的{},他会变成你的{};
    注意你的{},他会变成你的{};
    注意你的{},他会变成你的{};
    注意你的{},他会变成你的{};
    注意你的{},他会变成你的{}
    """.format(a,b,b,c,c,d,d,e,e,f))
    

    输出结果:

    注意你的思想,他会变成你的言语;
    注意你的言语,他会变成你的行动;
    注意你的行动,他会变成你的习惯;
    注意你的习惯,他会变成你的性格;
    注意你的性格,他会变成你的命运
    

    还有另一种方法来确定变量与位置的关系

    print("""
    注意你的{0},他会变成你的{1};
    注意你的{1},他会变成你的{2};
    注意你的{2},他会变成你的{3};
    注意你的{3},他会变成你的{4};
    注意你的{4},他会变成你的{5}
    """.format(a,b,c,d,e,f))  
    

    用来进行的填充去重,把位置信息填入花括号中,此时花括号中的位置信息指向的是format后边圆括号中的变量信息,与前两种填充方法不同的一点是位置数量与用来填充的变量数量不一致了,因为有重复利用的变量.

    虽然有不同,但是以上三种方法都是通过位置信息来进行填充的,只是有的是在空缺的地方进行位置限制,有的是在format后边进行位置限制,只要对位置信息比较清楚,都可以进行正确的填充.

    通过关键字参数进行填充

    print("""
    注意你的{A},他会变成你的{B};
    注意你的{B},他会变成你的{C};
    注意你的{C},他会变成你的{D};
    注意你的{D},他会变成你的{E};
    注意你的{E},他会变成你的{F}
    """.format(A=a,B=b,C=c,D=d,E=e,F=f))  
    

    返回结果:

    注意你的思想,他会变成你的言语;
    注意你的言语,他会变成你的行动;
    注意你的行动,他会变成你的习惯;
    注意你的习惯,他会变成你的性格;
    注意你的性格,他会变成你的命运
    

    通过关键字参数进行控制,和位置就没有多大关系了,在所有空缺都用关键字参数进行控制填充的时候,format后边先写哪一个位置的对应关系都没有关系,这样也可以:

    print("""
    注意你的{A},他会变成你的{B};
    注意你的{B},他会变成你的{C};
    注意你的{C},他会变成你的{D};
    注意你的{D},他会变成你的{E};
    注意你的{E},他会变成你的{F}
    """.format(F=f,A=a,D=d,B=b,C=c))  
    

    打乱关键字参数顺序也是可以返回正确结果的.

    还可以通过列表进行填充

    list1 = ["思想","言语","行动","习惯","性格","命运"]
    print("""
    注意你的{0[0]},他会变成你的{0[1]};
    注意你的{0[1]},他会变成你的{0[2]};
    注意你的{0[2]},他会变成你的{0[3]};
    注意你的{0[3]},他会变成你的{0[4]};
    注意你的{0[4]},他会变成你的{0[5]}.
    """.format(list1))
    

    返回结果:

    注意你的思想,他会变成你的言语;
    注意你的言语,他会变成你的行动;
    注意你的行动,他会变成你的习惯;
    注意你的习惯,他会变成你的性格;
    注意你的性格,他会变成你的命运.
    

    需要注意的是{0[0]},{0[1]}…{0[5]}这些花括号里前边的0不能直接写成list1,如果写成list1会报错,因为写了list1就等于是直接匹配到需要填充的字符了,根本用不到后边的format方法.所以,可以写0,也可以写其他随便的变量名字(比如说这个被随便取的变量名字是a),然后在format后边的括号了赋值刚刚随便写的变量名字给list1(.format(a=list1))就可以了.

    通过字典进行填充

    #通过字典填充
    dic1 = {"a":"思想","b":"言语","c":"行动","d":"习惯","e":"性格","f":"命运"}
    print("""
    注意你的{names[a]},他会变成你的{names[b]};
    注意你的{names[b]},他会变成你的{names[c]};
    注意你的{names[c]},他会变成你的{names[d]};
    注意你的{names[d]},他会变成你的{names[e]};
    注意你的{names[e]},他会变成你的{names[f]}.
    """.format(names=dic1))
    

    返回结果:

    注意你的思想,他会变成你的言语;
    注意你的言语,他会变成你的行动;
    注意你的行动,他会变成你的习惯;
    注意你的习惯,他会变成你的性格;
    注意你的性格,他会变成你的命运.
    

    需要注意的是用访问字典的键(key)的时候,是不需要加引号的.

    实际上,在字符串填充涉及到的知识点,不管是所谓的位置填充还是关键字填充,或者是列表填充或者字典填充,最重要的就是要清楚要填补的位置与要填充的字符的关系,对应的关系是不是对,当然除了涉及到位置和关键字参数,还涉及到列表的切片以及字典的访问,都是比较基础的内容

    文本的填充与对齐

    填充和对齐经常一起使用,这里的填充不是指前边的字符串填充,而是在对齐过程中,字符个数不够时用什么来填充.

    ^ < >这三个符号分别表示居中、左对齐、右对齐,符号后边跟着数字指字符的整体长度

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

    print('{:^14}'.format('江南燕'))  #居中,整个字符串的长度为14,不指定填充字符,用空格填充
    print('{:>14}'.format('江南燕'))  #右对齐,用空格填充
    print('{:<14}'.format('江南燕'))  #左对齐,用空格填充
    print('{:*<14}'.format('江南燕')) #左对齐,用*填充
    print('{:&>14}'.format('江南燕')) #右对齐,用&填充
    

    返回结果:

         江南燕      
               江南燕
    江南燕           
    江南燕***********
    &&&&&&&&&&&江南燕
    

    格式转换

    关于格式转换,网上有很多大神总结了特别全面的知识点,这里不全部罗列了,只拿最常用的做个例子展示一下怎么用吧.

    '{:.2f}'.format(3.1415926) #保留两位小数

    返回结果:'3.14'
    如果想保留几位小数,就把f前边的2换成几就可以了

    '{:.0f}'.format(3.1415926) #不保留小数位数

    返回结果:```3``

    '{:+.2f}'.format(3.1415926) #保留带符号的两位小数

    返回结果:'+3.14'

    '{:+.2f}'.format(-3.1415926) #不管保留的符号是正号还是负号,都是在冒号和点之间加"+"

    返回结果:'-3.14'

    '{:.2%}'.format(0.25) #百分位数保留小数位数,想保留几位,百分号前边就写数字几

    返回结果:'25.00%'

    '{:>10d}'.format(100) #右对齐,10表示带宽,在这里也是字符个数

    返回结果:' 100'

    '{:0>10d}'.format(100) #用0填充补齐的位置 (右对齐)

    返回结果:'0000000100'

    对齐和填充的规则和前边文本与填充的规则和效果差不多,可以自行尝试.

    金额的千位分隔符

    '{:,}'.format(1234567890) #冒号后边加逗号,形成千位分隔符

    返回结果:'1,234,567,890'

    更多相关内容
  • ICOFormat(photoshop制作ico图标插件)

    热门讨论 2014-07-02 08:33:00
    让你的Photoshop编辑制作ICO格式图标文件(ICOFormat支持图标文件插件) 相信很多制图的朋友都喜欢用PS,但是你能用Photoshop保存为ICO格式图标文件吗?默认肯定不行,不知道是什么原因,大名鼎鼎的图像编辑软件...
  • Python的format用法详解

    万次阅读 多人点赞 2021-03-21 10:05:05
    format的详细讲解 一.基础用法 format术语说明 fotmat作为Python的的格式字符串函数,主要通过字符串中的花括号{},来识别替换字段,从而完成字符串的格式化。 print("我叫{},今年{}岁。".format("小蜜",18)) #我...

    format的详细讲解

    一.基础用法

    1. format术语说明
      fotmat作为Python的的格式字符串函数,主要通过字符串中的花括号{},来识别替换字段,从而完成字符串的格式化。
    print("我叫{},今年{}岁。".format("小蜜",18))
    #我叫小蜜,今年18岁。
    #花括号的个数决定了,参数的个数。但是花括号的个数可以少于参数。
    print("我喜欢{}和{}"format("乒乓球","羽毛球","敲代码"))
    #我喜欢乒乓球和羽毛球。
    """
    花括号多于参数的个数,则会报错。
    """
    

    2.通过数字参数传入位置参数
    传入参数注意以下事项

    • 数字必须是大于0的整数
    • 带数字的替换字段可以重复
    • 数字形式的简单字段名相当于把字段当成一个序列形式。通过索引的形式进行一一取值
    #通过数字索引传入参数
    print("名字{0},家住{1}").format("橙留香","水果村")
    #带数字的替换1字段可以重复
    
    ```python
    print("我爱{0}。\n他爱{1}。\n{0}爱{1}".format("灰太狼","红太狼")
    """
    我爱灰太狼
    他爱红太狼
    灰太狼爱红太狼
    """
    
    """
    数字形式的简单字段名相当于把字段当成一个序列形式。通过索引的形式进行一一取值
    """
    print("小明喜欢{1},{2}和{0}".foramt("海绵宝宝","机器猫","海贼王","火影忍者","龙珠"))
    #小明喜欢机器猫,海贼王,和海绵宝宝
    

    3.用关键字传递

    print("我今年{age}岁,我在读{college}".format(age=18","college="大学"))
    #我今年18岁,我今年20岁
    #关键字可以随便放置
    print("我今年{age}岁,我在读{college}".format("college="大学",age=18"))
    

    4.关键字和数字的混合使用
    注意以下事项

    • 数字和关键字段可以混合使用传递参数
    • 关键字参数必须位于位置参数之后。
    • 混合使用时,可以省略数字
    • 省略字段名{}不能和数字形式的字段名同时使用
    #混合使用传递参数
    print("我是要当{0},他是要当{1},这个世界只有一个{truth}"
    .format("海贼王","火影",truth="真理"))
    #我要当海贼王,他要当火影,这个世界只有一个真理
    
    #数字也可以省略
    print("我是要当{},他是要当{},这个世界只有一个{truth}"
    .format("海贼王","火影",truth="真理"))
    #如果关建字位于位置参数之前则会发生
    '''
    SyntaxError: unexpected indent
    ![在这里插入图片描述](https://img-blog.csdnimg.cn/20210321105132614.png#pic_center)
    '''
    

    5.使用元组和字典传参

    • format可以使用元组和字典传参,俩者可以混合使用
    • 多种混合使用的时候。位置参数要在关键字参数前面,元组要在字典前面
    a=["鸣人","火影""雏田"]
    print("我是{},我是要当{}的男人".format(*a))
    """
    我是鸣人,我是要当火影的男人
    """
    print("我是{1},我是要当{2}的男人".format(*a))
    
    #使用字典传参
    v={"name":"孙悟空","skill":"龟派气功"}
    print("我是{name},我的绝招是{skill}".format(**v))
    """
    我是孙悟空,我的绝招是龟派气功
    """
    #同时使用元组和字典传参
    name=["卡卡罗特","界王拳"]
    names={"nickname":"孙君","skill":"元气弹"}
    print("我是{0},我的绝招是{skill}".format(*name,**names))
    print("我是{nickname},我的绝招是{1}".format(*name,**names))
    
    #同时使用位置参数,元组,关键字参数,字典传参。
    #注意位置参数要在关键数参数前面
    a=["卡卡罗特"]
    dic={"name":"超级赛亚人"}
    print("我是{0},我也是{0},因为我是正义的战士,所以我变成了{name}".
    format("卡卡罗特"*a,**dic))
    """
    我是卡卡罗特,是孙悟空,但不可改变的是我是正义的战士。
    """
    

    二.升华讲解

    2.1复合字段名的使用
    • format使用数字和变量名俩种形式,这就是复合字段
    • 复合字段名支持两种操作符
      - [] 方括号
      - . 点号
    2.2 点号的使用
    class Person:
    	def __int__(self,name,addr):
    		self.name=name
    		self.addr=addr
    p=Person("孙悟空","包子山")
    #点号用法。传递位置参数。
    print("我是{0.name},家在{0.addr}".format(p))
    #当只有一个字段的时候,就可以省略数字
    print("我是{.name}}".format(p))
    #试一下传递文件对象的属性
    f=open("out.txt","w")
    print("文件名为:"{.name}.format(f))
    
    #传递关键字
    print("我是{p.name},家在{p.addr}".format(p=p))
    print("我是{girl.name},家在{girl.addr}".format(girl=p))
    """
    我是孙悟空,家在包子山。
    我是孙悟空,家在包子山。
    """
    

    2.4方括号的用法

    mylist=["陈道明","www.chendaoming.cc"]
    print("网站名:{0[0],地址{0[1]}}".format(my_list))
    

    2.5对齐字符串

    • ^ 剧中 后面带宽度
    • < 左对齐 后面带宽度
    • 右对齐 后面带宽度

    • : 后面带填充的字符,只能是一个字符,不指定则是默认用空格填充
    print("{:>5}".format(1))#宽度为5,右对齐
    print(":>5".format(10))
    print(":>5".format(100))
    print(":>5".format(1000))
    """
    输出结果为	
    	1	 
    	10
    	100
    	1000		 "
    """
    

    在这里插入图片描述

    #正号表示正数
    print("{:+2f}".format(3.14))
    #+3.140000
    print("{:-2f}".format(-1))
    #-1.000000
    #不带小数的
    print("{:.0f}".format(3.23123131))
    #3
    #以逗号为分隔符的
    print("{:,}".format(100000))
    #100,000
    #表示一个百份比
    print("{:.2%}".format(0.25))
    #25%
    
    展开全文
  • Python 中 str.format() 方法详解

    万次阅读 多人点赞 2018-11-15 10:03:12
    Python 中 str.format() 方法详解 文章目录Python 中 str.format() 方法详解0. 参考资料1. 术语说明2. 简单字段名2.1 简单字段名的说明2.2 省略字段名2.3 数字形式的简单字段名2.4 变量名形式的简单字段名2.5 ...

    Python 中 str.format() 方法详解

    转载请注明出处:https://blog.csdn.net/jpch89/article/details/84099277



    0. 参考资料


    1. 术语说明

    • str.format() 方法通过字符串中的花括号 {} 来识别替换字段 replacement field,从而完成字符串的格式化。
    • 替换字段 由字段名 field name 和转换字段 conversion field 以及格式说明符 format specifier 组成,即一般形式为 {字段名!转换字段:格式说明符}
    • 字段名分为简单字段名 simple field name 和复合字段名 compound field name
    • 转换字段格式说明符都是可选的。

    2. 简单字段名

    2.1 简单字段名的说明

    简单字段名有三种写法:

    • 省略不写 {}
    • 数字 {十进制非负整数}
    • 变量名 {合法的Python标识符}

    2.2 省略字段名

    花括号内省略字段名,传递位置参数

    • 替换字段形式: {}
    • 注意:花括号个数可以少于位置参数的个数,反之不然。
    # 省略字段名传递位置参数
    print('我叫{},今年{}岁。'.format('小明', 18))
    """
    我叫小明,今年18岁。
    """
    
    # 花括号个数可以少于位置参数的个数
    print('我爱吃{}和{}。'.format('香蕉', '苹果', '大鸭梨'))
    """
    我爱吃香蕉和苹果。
    """
    
    # 花括号个数多于位置参数的个数则会报错
    # print('我还吃{}和{}。'.format('西红柿'))
    """
    IndexError: tuple index out of range
    """
    

    2.3 数字形式的简单字段名

    可以通过数字形式的简单字段名传递位置参数

    • 数字必须是大于等于 0 的整数。
    • 带数字的替换字段可以重复使用
    • 数字形式的简单字段名相当于把 format 中的所有位置参数整体当作一个元组,通过字段名中的数字进行取值。
    • {0} 等价于 tuple[0],所以花括号内的数字不能越界
    # 通过数字形式的简单字段名传递位置参数
    print('身高{0},家住{1}。'.format(1.8, '铜锣湾'))
    """
    身高1.8,家住铜锣湾
    """
    
    # 数字形式的简单字段名可以重复使用。
    print('我爱{0}。\n她今年{1}。\n{0}也爱我。'.format('阿香', 17))
    """
    我爱阿香。
    她今年17。
    阿香也爱我。
    """
    
    # 体会把所有位置参数整体当成元组来取值
    print('阿香爱吃{1}、{3}和{0}。'.format(
        '榴莲', '臭豆腐', '皮蛋', '鲱鱼罐头', '螺狮粉'))
    """
    阿香爱吃臭豆腐、鲱鱼罐头和榴莲。
    """
    
    # 尝试一下越界错误
    # print('{1}'.format('错误用法'))
    """
    IndexError: tuple index out of range
    """
    

    2.4 变量名形式的简单字段名

    使用变量名形式的简单字段名传递关键字参数

    • 关键字参数的位置可以随意调换。
    # 使用变量名形式的简单字段名传递关键字参数
    print('我大哥是{name},今年{age}岁。'.format(name='阿飞', age=20))
    """
    我大哥是阿飞,今年20岁。
    """
    
    # 关键字参数的顺序可以随意调换
    print('我大哥是{name},今年{age}岁。'.format(age=20, name='阿飞'))
    """
    我大哥是阿飞,今年20岁。
    """
    

    2.5 简单字段名的混合使用

    • 混合使用数字形式和变量名形式的字段名,可以同时传递位置参数和关键字参数。
    • 关键字参数必须位于位置参数之后。
    • 混合使用时可以省略数字。
    • 省略字段名 {} 不能和数字形式的字段名 {非负整数} 同时使用。
    # 混合使用数字形式和变量名形式的字段名
    # 可以同时传递位置参数和关键字参数
    print('这是一个关于{0}、{1}和{girl}的故事。'.format(
        '小明', '阿飞', girl='阿香'))
    """
    这是一个关于小明、阿飞和阿香的故事。
    """
    
    # 但是关键字参数必须位于位置参数之后
    # print('这是一个关于{0}、{1}和{girl}的故事。'.format(
        # '小明', girl='阿香' , '阿飞'))
    """
    SyntaxError: positional argument follows keyword argument
    """
    
    # 数字也可以省略
    print('这是一个关于{}、{}和{girl}的故事。'.format(
        '小明', '阿飞', girl='阿香'))
    
    # 但是省略字段名不能和数字形式的字段名同时出现
    # print('这是一个关于{}、{1}和{girl}的故事。'.format(
    #     '小明', '阿飞', girl='阿香'))
    """
    ValueError: cannot switch from automatic field numbering to manual field specification
    """
    
    

    2.6 使用元组和字典传参

    str.format() 方法还可以使用 *元组**字典 的形式传参,两者可以混合使用。
    位置参数、关键字参数、*元组**字典 也可以同时使用,但是要注意,位置参数要在关键字参数前面,*元组 要在 **字典 前面。

    # 使用元组传参
    infos = '钢铁侠', 66, '小辣椒'
    print('我是{},身价{}亿。'.format(*infos))
    """
    我是钢铁侠,身家66亿。
    """
    print('我是{2},身价{1}亿。'.format(*infos))
    """
    我是小辣椒,身家66亿。
    """
    
    # 使用字典传参
    venom = {'name': '毒液', 'weakness': '火'}
    print('我是{name},我怕{weakness}。'.format(**venom))
    """
    我是毒液,我怕火。
    """
    
    # 同时使用元组和字典传参
    hulk = '绿巨人', '拳头'
    captain = {'name': '美国队长', 'weapon': '盾'}
    print('我是{}, 我怕{weapon}。'.format(*hulk, **captain))
    print('我是{name}, 我怕{1}。'.format(*hulk, **captain))
    
    """
    我是绿巨人, 我怕盾。
    我是美国队长, 我怕拳头。
    """
    
    # 同时使用位置参数、元组、关键字参数、字典传参
    # 注意:
    # 位置参数要在关键字参数前面
    # *元组要在**字典前面
    tup = '鹰眼',
    dic = {'weapon': '箭'}
    text = '我是{1},我怕{weakness}。我是{0},我用{weapon}。'
    text = text.format(
        *tup, '黑寡妇', weakness='男人', **dic)
    print(text)
    """
    我是黑寡妇,我怕男人。我是鹰眼,我用箭。
    """
    

    3. 复合字段名

    3.1 复合字段名的说明

    • 同时使用了数字和变量名两种形式的字段名就是复合字段名
    • 复合字段名支持两种操作符:
      • [] 方括号
      • . 点号

    3.2 . 点号的使用

    传递位置参数

    • 替换字段形式:{数字.属性名}
    • 只有一个替换字段的时候可以省略数字
    # 复合字段名中使用点号传递对象属性
    class Person:
        def __init__(self, name, addr):
            self.name = name
            self.addr = addr
    
    
    p = Person('辣妹子', '重庆')
    
    # 点号用法:传递位置参数
    print('我是{0.name},家在{0.addr}。'.format(p))
    """
    我是辣妹子,家在重庆。
    """
    
    # 当只有一个替换字段的时候可以省略数字
    print('{.name}辣!'.format(p))
    """
    辣妹子辣!
    """
    
    # 试试传递文件对象的属性
    f = open('out.txt', 'w')
    print('文件名为:{.name}'.format(f))
    f.close()
    """
    文件名为:out.txt
    """
    

    传递关键字参数

    • 替换字段形式:{关键字参数名.属性名}
    # 点号用法:传递关键字参数
    print('我是{girl.name},家在{girl.addr}。'.format(girl=p))
    # 和上一句等价
    print('我是{p.name},家在{p.addr}。'.format(p=p))
    """
    我是辣妹子,家在重庆。
    我是辣妹子,家在重庆。
    """
    

    3.3 [] 方括号的使用

    传递位置参数

    • 用列表传递位置参数
    • 用元组传递位置参数
    • 用字典传递位置参数
    # 方括号用法:用列表传递位置参数
    infos = ['阿星', 9527]
    food = ['霸王花', '爆米花']
    print('我叫{0[0]},警号{0[1]},爱吃{1[0]}。'.format(
        infos, food))
    """
    我叫阿星,警号9527,爱吃霸王花。
    """
    
    # 方括号用法:用元组传递位置参数
    food = ('僵尸', '脑子')
    print('我叫{0[0]},年龄{1},爱吃{0[1]}。'.format(
        food, 66))
    """
    我叫僵尸,年龄66,爱吃脑子。
    """
    
    # 方括号用法:用字典传递位置参数
    dic = dict(name='阿星', pid=9527)
    print('我是{[name]}!'.format(
        dic))
    # 多个替换字段,不能省略数字
    print('我是{0[name]},警号{0[pid]}。'.format(
        dic))
    """
    我是阿星!
    我是阿星,警号9527。
    """
    

    传递关键字参数

    • 用列表传递关键字参数
    • 用元组传递关键字参数
    • 用字典传递关键字参数
    # 方括号用法:传递关键字参数
    names = ['皮卡丘']
    dic = {'name': '妙蛙花'}
    skills = ('十万伏特', '飞叶快刀')
    text = '我是{names[0]},我会{skills[0]}。我是{dic[name]},我会{skills[1]}。'
    text = text.format(names=names, skills=skills, dic=dic)
    print(text)
    """
    我是皮卡丘,我会十万伏特。我是妙蛙花,我会飞叶快刀。
    """
    

    4. 转换字段

    转换字段 conversion field 的取值有三种,前面要加 !

    • s:传递参数之前先对参数调用 str()
    • r:传递参数之前先对参数调用 repr()
    • a:传递参数之前先对参数调用 ascii()

    ascii() 函数类似 repr() 函数,返回一个可以表示对象的字符串。
    但是对于非 ASCII 字符,使用 \x\u 或者 \U 转义。

    # 转换字段
    print('I am {!s}!'.format('Bruce Lee 李小龙'))
    print('I am {!r}!'.format('Bruce Lee 李小龙'))
    print('I am {!a}!'.format('Bruce Lee 李小龙'))
    """
    I am Bruce Lee 李小龙!
    I am 'Bruce Lee 李小龙'!
    I am 'Bruce Lee \u674e\u5c0f\u9f99'!
    """
    

    5. 格式说明符

    • 替换字段中,格式说明符前面有一个冒号 :
      {字段名!转换字段:格式说明符}
    • 其中格式说明符本身可以是一个字段名,比如:
    print('{0:{1}}'.format(3.14159, '.4f'))
    """
    3.1416
    """
    

    5.1 标准格式说明符的格式

    • 如果不通过重写 __format__ 方法来进行自定义的话,标准格式说明符的形式如下。其中方括号是可选的。
      [[fill]align][sign][#][0][width][grouping_option][.precision][type]
    • 中文形式可以写作:
      [[填充]对齐方式][正负号][#][0][宽度][分组选项][.精度][类型码]

    5.2 填充与对齐方式

    填充

    • 只能是一个字符
    • 不指定默认用空格填充
    • 如果指定填充字符,则必须要同时指定对齐方式

    对齐方式的取值:

    • <:左对齐
    • >:右对齐
    • ^:居中
    • =:在正负号(如果有的话)和数字之间填充,该对齐选项仅对数字类型有效。
      它可以输出类似 +0000120 这样的字符串。

    注意:

    • 如果不给定最小宽度 width,对齐方式毫无意义。

    5.3 正负号

    • 正负号选项仅对数字类型生效
    • 取值有三种:
      • + 正数前面添加正号,负数前面添加负号
      • - 仅在负数前面添加负号(默认行为)
      • 空格:正数前面需要添加一个空格,以便与负数对齐
    # 正负号
    print('{:哈=+8.2f}'.format(3.14159))
    print('{:哈=+8.2f}'.format(-3.14159))
    print('{:哈=+8.2f}'.format(0))
    print('{:哈=+8.2f}'.format(-0))
    """
    +哈哈哈3.14
    -哈哈哈3.14
    +哈哈哈0.00
    +哈哈哈0.00
    """
    

    5.4 # 号

    # 号:

    • 给u二进制数加上 0b 前缀
    • 给八进制数加上 0o 前缀
    • 给十六进制数加上 0x 前缀

    5.5 最小宽度

    最小宽度 width

    • 如果不指定,最小字段宽度由内容决定,与内容相等
    • 如果最小宽度前面有一个前导 0,意味着用 0 填充
      这等价于指定了 0= 的填充和对齐方式

    5.6 分组选项

    分组选项 grouping_option 的取值有两种:

    • 逗号 ,:使用逗号对数字以千为单位进行分隔。n 类型的数字可以使用本地化的分隔符。

    n 类型在本机无法使用分组选项 ,
    原因可能是中文没有数字分隔符

    # n 类型使用本地化的分组选项 ,
    # 此项报错,我怀疑是因为中文没有数字的分隔符
    # print('数字:{0:,n}'.format(6666))
    """
    ValueError: Cannot specify ',' with 'n'.
    """
    
    # 使用 d 类型确实是可以的
    print('数字:{0:,d}'.format(6666))
    """
    数字:6,666
    """
    
    • 下划线 _:使用下划线对浮点数和 d 类型的整数以千为单位进行分隔。对于 boxX 类型,每四位插入一个下划线,其他类型都会报错。
    # 分组选项 _ 作用于 b 类型
    print('数字:{0:_b}'.format(0b100111011))
    """
    数字:1_0011_1011
    """
    
    # 分组选项 _ 作用于 o 类型
    print('数字:{0:_o}'.format(0o426754316))
    """
    数字:4_2675_4316
    """
    
    # 分组选项 _ 作用于 x 类型
    print('数字:{0:_x}'.format(0x2a846e98d))
    """
    数字:2_a846_e98d
    """
    
    # 分组选项 _ 作用于 X 类型
    print('数字:{0:_X}'.format(0X2a846e98d))
    """
    数字:2_A846_E98D
    """
    
    # 分组选项 _ 作用于其他类型(比如 n 类型)
    # print('字符串:{0:_n}'.format(1234567))
    """
    ValueError: Cannot specify ',' with 'n'.
    """
    

    5.7 精度

    精度:

    • 精度指定了小数点后面要展示多少位小数
    • 对于非数字类型,精度指定了最大字段宽度
    • 整数类型不能指定精度
    # 对于非数字类型,精度指定最大字段宽度
    print('{0:.3}'.format('哇哈哈哈哈哈'))
    """
    哇哈哈
    """
    # 整数类型不能指定精度
    print('{:.3d}'.format(666))
    """
    ValueError: Precision not allowed in integer format specifier
    """
    

    5.8 类型码

    类型码可以分为三大类:

    • 字符串类型
    • 整数类型
    • 浮点数类型

    5.8.1 字符串类型

    • s 字符串类型。这是字符串的默认类型,可以省略。
    • None 不指定类型。同 s 类型。
    # s 类型
    print('{0:s}'.format('略略略'))
    # s 类型可以省略
    print('{0:}'.format('略略略'))
    """
    略略略
    略略略
    """
    

    5.8.2 整数类型

    • b 二进制。
    # b 类型:二进制
    print('{0:b}'.format(3))
    """
    11
    """
    
    • c 字符。把整数转换为相应的 Unicode 字符,然后再打印。
    # c 类型:把整数转换成 unicode 字符
    print('{:c}'.format(97))
    """
    a
    """
    
    • d 十进制整数。
    # d 类型:十进制整数
    print('{:d}'.format(666))
    """
    666
    """
    
    • o 八进制数。
    # o 类型:八进制数
    print('{:o}'.format(10))
    """
    12
    
    • x 十六进制数,af 小写。
    # x 类型:十六进制数,a到f小写
    print('{:x}'.format(15))
    """
    f
    """
    
    • X 十六进制数,AF 大写。
    # X 类型:十六进制数,A到F大写
    print('{:X}'.format(15))
    """
    F
    """
    
    • n 数字 number 类型,与 d 相同,只不过它会使用本地化的数字分隔符。

    经试验,在本机为 n 类型指定任何分组选项(,_)都会报错。
    ValueError: Cannot specify ',' with 'n'.

    # n 类型:与d相同,会插入本地化的分隔符
    print('{:n}'.format(66666))
    # 经试验,本机无法为 n 指定任何分组选项(,_)
    # print('{:,n}'.format(66666))
    """
    ValueError: Cannot specify ',' with 'n'.
    """
    # print('{:_n}'.format(66666))
    """
    ValueError: Cannot specify ',' with 'n'.
    """
    
    • None 不指定类型,与 d 相同。

    5.8.3 浮点数类型

    • e 科学记数法,用 e 来表示指数。默认精度为 6
    # e 类型:科学记数法
    # 默认精度为 6 位
    print('{:e}'.format(1234567.1234567))
    """
    1.234567e+06
    """
    
    • Ee 相同,但是使用大写的 E 表示指数。
    # E 类型:与 e 相同,用大写 E 表示指数
    # 默认精度为 6 位
    print('{:E}'.format(1234567.1234567))
    # 修改精度为 10 位
    print('{:.10E}'.format(1234567.1234567))
    """
    1.234567E+06
    1.2345671235E+06
    """
    
    • f 定点记法,默认精度为 6
    # f 类型
    # 默认精度为 6 位
    print('{:f}'.format(1234567.1234567))
    """
    1234567.123457
    """
    
    • F 定点记法,同 f,但是会把 nan 转换成 NAN,把 inf 转换成 INF
    # F 类型
    nan = float('nan')
    inf = float('inf')
    print('{:F}\n{:F}'.format(nan, inf))
    """
    NAN
    INF
    """
    
    • g 通用 general 格式。自动转换到 e 或者 f 格式,具体的转换规则在此省略。正无穷、负无穷、正零、负零和非数字分别显示为 inf-inf0-0nan。指定精度为 0 时等价于精度为 1。默认精度为 6 位。
    # g 类型
    print('{:g}'.format(1234567.1234567))
    print('{:g}'.format(1234.1234))
    """
    1.23457e+06
    1234.12
    """
    
    • G 通用 general 格式。自动转换到 E 或者 F 格式,转换规则同上,相应表示方式换成大写。
    # g 类型
    print('{:g}'.format(1234567.1234567))
    print('{:g}'.format(1234.1234))
    """
    1.23457e+06
    1234.12
    """
    
    • n 数字 number 类型。跟 g 一样,只不过用本地化的分隔符来分隔数字。
    # n 类型
    print('{:n}'.format(1234567.1234567))
    print('{:n}'.format(1234.1234))
    """
    1.23457E+06
    1234.12
    """
    
    # 经试验,本机指定分组选项会报错
    # print('{:,n}'.format(1234.1234))
    """
    ValueError: Cannot specify ',' with 'n'.
    """
    # print('{:_n}'.format(1234.1234))
    """
    ValueError: Cannot specify ',' with 'n'.
    """
    
    • % 百分号类型。会将数字乘以 100,然后以 f 定点 fixed-point 格式显示,最后加上一个百分号 %
    # % 类型
    print('{:%}'.format(1))
    """
    100.000000%
    """
    
    • None 不指定类型。输出效果类似调用 str() 函数。

    6. 补充说明

    • 输出花括号需要用花括号本身来转义
    # 打印花括号需要使用花括号转义
    print('{{{}}}'.format('张无忌'))
    """
    {张无忌}
    """
    
    • 对象可以自定义格式说明符来替换标准格式说明符,比如 datetime 类。
    from datetime import datetime
    print("Today is: {0:%a %b %d %H:%M:%S %Y}".format(datetime.now()))
    """
    今天是:Thu Nov 15 13:05:09 2018
    """
    

    完成于 2018.11.15


    展开全文
  • String.format()的详细用法

    千次阅读 2022-03-19 14:06:54
    format(String format, Object… args) 新字符串使用本地语言环境,制定字符串格式和参数生成格式化的新字符串。 format(Locale locale, String format, Object… args) 使用指定的语言环境,制定字符串格式和参数...

    问题

    在开发的时候一段字符串的中间某一部分是可变的;比如:xxx来自中国

    在这里插入图片描述

    String.format()字符串常规类型格式化的两种重载方式

    • format(String format, Object… args) 新字符串使用本地语言环境,制定字符串格式和参数生成格式化的新字符串。
    • format(Locale locale, String format, Object… args) 使用指定的语言环境,制定字符串格式和参数生成格式化的字符串。

    上个栗子有用到了字符类型和整数类型的格式化 下面我把常用的类型例举出来

    转换符详细说明示例
    %s字符串类型“喜欢请收藏”
    %c字符类型‘m’
    %b布尔类型true
    %d整数类型(十进制)88
    %x整数类型(十六进制)FF
    %o整数类型(八进制)77
    %f浮点类型8.888
    %a十六进制浮点类型FF.35AE
    %e指数类型9.38e+5
    %g通用浮点类型(f和e类型中较短的)不举例(基本用不到)
    %h散列码不举例(基本用不到)
    %%百分比类型%(%特殊字符%%才能显示%)
    %n换行符不举例(基本用不到)
    %tx日期与时间类型(x代表不同的日期与时间转换符)不举例(基本用不到)

    为了方便理解还是举个例子

        String str=null;  
        str=String.format("Hi,%s", "siri");   
        System.out.println(str);   //Hi,siri
        
        str=String.format("Hi,%s %s", "siri","我在");            
        System.out.println(str);                 //Hi,siri 我在 
                  
        System.out.printf("字母c的大写是:%c %n", 'C');  //字母c的大写是:C  
        System.out.printf("布尔结果是:%b %n", "小超".equal("帅哥"));  //布尔的结果是:false   
        System.out.printf("100的一半是:%d %n", 100/2);  //100的一半是:50   
        System.out.printf("100的16进制数是:%x %n", 100);  //100的16进制数是:64   
        System.out.printf("100的8进制数是:%o %n", 100);  //100的8进制数是:144   
        System.out.printf("50元的书打8.5折扣是:%f 元%n", 50*0.85);  //50元的书打8.5折扣是:42.500000 元  
        System.out.printf("上面价格的16进制数是:%a %n", 50*0.85);  //上面价格的16进制数是:0x1.54p5   
        System.out.printf("上面价格的指数表示:%e %n", 50*0.85);  //上面价格的指数表示:4.250000e+01   
        System.out.printf("上面价格的指数和浮点数结果的长度较短的是:%g %n", 50*0.85);  //上面价格的指数和浮点数结果的长度较短的是:42.5000 
        System.out.printf("上面的折扣是%d%% %n", 85);  //上面的折扣是85% 
        System.out.printf("字母A的散列码是:%h %n", 'A');    //字母A的散列码是:41   
    

    搭配转换符还有实现高级功能 第一个例子中有用到 $

    标志说明示例结果
    +为正数或者负数添加符号(“%+d”,15)+15
    0数字前面补0(加密常用)(“%04d”, 99)0099
    空格在整数之前添加指定数量的空格(“% 4d”, 99)99
    ,以“,”对数字分组(常用显示金额)(“%,f”, 9999.99)9,999.990000
    (使用括号包含负数(“%(f”, -99.99)(99.990000)
    #如果是浮点数则包含小数点,如果是16进制或8进制则添加0x或0(“%#x”, 99)(“%#o”, 99)0x63 0143
    <格式化前一个转换符所描述的参数(“%f和%<3.2f”, 99.45)99.450000和99.45
    d,%2$s”, 99,”abc”)99,abc

    第一个例子中有说到 %tx x代表日期转换符 我也顺便列举下日期转换符

    标志说明示例
    c包括全部日期和时间信息星期六 十月 27 14:21:20 CST 2007
    F“年-月-日”格式2007-10-27
    D“月/日/年”格式10/27/07
    r“HH:MM:SS PM”格式(12时制)02:25:51 下午
    T“HH:MM:SS”格式(24时制)14:28:16
    R“HH:MM”格式(24时制)14:28

    来个例子方便理解

    	Date date=new Date();                                  
        //c的使用  
        System.out.printf("全部日期和时间信息:%tc%n",date);          
        //f的使用  
        System.out.printf("年-月-日格式:%tF%n",date);  
        //d的使用  
        System.out.printf("月/日/年格式:%tD%n",date);  
        //r的使用  
        System.out.printf("HH:MM:SS PM格式(12时制):%tr%n",date);  
        //t的使用  
        System.out.printf("HH:MM:SS格式(24时制):%tT%n",date);  
        //R的使用  
        System.out.printf("HH:MM格式(24时制):%tR",date);  
    

    输出结果

    全部日期和时间信息:星期六 三月 19 14:20:53 CST 2022--日格式:2022-03-19//年格式:03/19/22
    HH:MM:SS PM格式(12时制):02:20:53 下午
    HH:MM:SS格式(24时制):14:20:53
    HH:MM格式(24时制):14:20
    
    展开全文
  • clang-format配置与使用

    千次阅读 2021-09-30 15:06:59
    clang-format配置与使用 参考教程. 1. 安装 下载clang-format,设置环境变量。我使用的是vscode扩展中的clang-format。 位于: extensions/ms-vscode.cpptools-1.7.0-insiders/bin/。 将程序放置到系统边境变量的...
  • C# 之 String.Format详解

    千次阅读 2022-05-02 12:59:38
    有兴趣的同学可以去看官方文档String.Format Method (System) | Microsoft Docs 本文仅对官方文档中的内容进行提炼和总结 功能描述:把一些对象(Object)的值转化为字符串,并按照formats里的格式塞到另外一个...
  • 支持PS CS6 64位的ico输出插件 ICOFormat64.8bi 和 ICOFormat.8bi 我们做系统ICO图标时 , 为了美观 , 会使背景透明 , 但是 PS 本身 并没有 ICO 输出格式, 我们可能会用到IconWorkshop来 支持一下输出, 但是有...
  • python中format的用法-Python中format的用法

    万次阅读 多人点赞 2020-10-30 00:40:54
    自python2.6开始,新增了一种格式化字符串的函数str.format(),可谓威力十足。那么,他跟之前的%型格式化字符串相比,有什么优越的存在呢?让我们来揭开它羞答答的面纱。语法它通过{}和:来代替%。"映射”示例...
  • python中format的用法详解

    万次阅读 多人点赞 2021-07-05 08:51:07
    format是字符串内嵌的一个方法,用于格式化字符串。以大括号{}来标明被替换的字符串。 1、基本用法 1. 按照{}的顺序依次匹配括号中的值 s = "{} is a {}".format('Tom', 'Boy') print(s) # Tom is a Boy s1 = "{} ...
  • Python中format函数用法

    万次阅读 2020-08-17 16:42:21
    Python中format函数用法 format优点 format是python2.6新增的格式化字符串的方法,相对于老版的%格式方法,它有很多优点。 1.不需要理会数据类型的问题,在%方法中%s只能替代字符串类型 2.单个参数可以多次输出...
  • 【C++ 】 format 函数详解

    万次阅读 2019-07-09 14:50:49
    C++ format 函数 C++编程 Format是一个很常用,却又似乎很烦的方法,以下是它的完整概貌,以供大家查询之用: 一、字符串 首先看它的声明: function Format(const Format: string;const Args: array of const): ...
  • format 基本语法是通过 {} 和 : 来代替以前的 % 。format 函数可以接受不限个参数,位置可以不按顺序。format基本用法"Hello{0}{1}".format("Chen","xin")#引用第一个参数#输出"...
  • clang-format安装配置与vscode支持

    千次阅读 2021-12-24 12:16:13
    文章目录calng-format安装centos下clang-format安装ubuntu下clang-format的安装vscode支持clang-formatclang-format使用参考文献 calng-format安装 centos下clang-format安装 centos 的yum仓库中并没有clang-format...
  • java中format

    千次阅读 2020-10-24 17:33:26
    formatJAVA中format的使用(常用1,5)1. java 中 SimpleDateFormat2. java 中 DateFormat(不怎么使用SimpleDateFormat 是)3.JAVA 中 NumberFormat(转化为整数(四舍五入)-百分数-)4.MessageFormat 占不介绍5....
  • python中format函数

    万次阅读 多人点赞 2019-05-14 12:07:45
    python中format函数用于字符串的格式化 通过关键字 1. print('{name}在{option}'.format(name="谢某人",option="写代码")) 结果:谢某人在写代码 通过位置 1. print('name={} path={}'.format('zhangsan', ...
  • vscode的clang-format插件就提供了clang和C/C++代码的Style的检查和格式化功能,而且还能指定VisualStudio、LLVM、Google等多种code style格式,点击vscode主窗口左侧的的Extensions,输入clang-format搜索到这个...
  • Python format的用法

    千次阅读 2021-11-09 13:26:08
    一、format的作用 Python2.6 开始,新增了一种格式化字符串的函数 str.format(),它增强了字符串格式化的功能。 基本语法是通过 {} 和 : 来代替以前的 % 。 format 函数可以接受不限个参数,位置可以不按顺序 二、...
  • format函数基本用法

    千次阅读 2022-03-16 18:00:50
    1.format函数基本格式:<模块字符>.format(<逗号分隔的参数>) 例如: print("{},我想跟你说:{}“.format(a,b)) 2.字符串format()方法。例如: print("{} {}".format("hello","world"))#不指定...
  • date.format.js

    热门讨论 2012-08-31 11:08:51
    javascript格式化代码 js格式化代码
  • Python之format用法详解

    万次阅读 多人点赞 2020-03-21 11:49:37
    Python之format用法详解 一、填充 1.无参(1) print('{} {}'.format('hello','world')) hello world 2.无参(2) print('{0} {1}'.format('hello','world')) hello world 3.无参(3) print('{1} {0} {1}'....
  • python的format函数的用法及实例

    千次阅读 多人点赞 2022-06-05 09:48:14
    目录1.format函数的语法及用法(1)语法:'{}'.format()(2)用法:用于格式化字符串。可以接受无限个参数,可以指定顺序。返回结果为字符串。2.实例(1)不设置位置,按默认顺序(从左到右)输出。(2)指定位置(3...
  • clang-format的使用

    千次阅读 2021-10-01 10:53:52
    clang-format使用1. clang-format简介2. clang-format的使用2.1 clang-format中.clang-format file2.2 示例:配置google的代码风格2.3 vscode clang-format配置3. clang-format 中 .clang-format file配置(yaml格式...
  • format是python2.6新增的一个格式化字符串的方法,相对于老版的%格式方法,它有很多优点。1.不需要理会数据类型的问题,在%方法中%s只能替代字符串类型2.单个参数可以多次输出,参数顺序可以不相同3.填充方式十分...
  • C++中Format用法

    万次阅读 2019-02-17 13:53:09
    C++中Format用法
  • Java String format() 方法

    万次阅读 2021-03-06 18:54:24
    例如:String 类的format方法可以格式化日期和时间import java.util.Date;import java.util.Locale;public class Main {public static void main( String[] args ) {Date date=new Date();//定义Date类对象Locale ...
  • mysql date_format函数

    万次阅读 2022-08-14 23:16:12
    代码】mysql date_format函数。
  • boost format使用详解

    千次阅读 2019-09-10 14:28:10
    可能需要对int, string, char等进行格式化,常用的方法包括 snprintf, std::string, std::stringstream, boost::format等。 snprintf支持c语言,可能是这几种方式中效率最高的,它们之间的效率对比可以参考 Compar.....
  • @JsonFormat 使用方法

    万次阅读 2022-06-13 00:33:43
    @JsonFormat

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 2,469,039
精华内容 987,615
关键字:

FORMAT