format 订阅
format是DOS系统的一种命令,用于格式化磁盘,是一种高级格式化,对磁盘进行的格式编写程序。format参数是一个格式字符串,用于格式化Args里面的值的。 展开全文
format是DOS系统的一种命令,用于格式化磁盘,是一种高级格式化,对磁盘进行的格式编写程序。format参数是一个格式字符串,用于格式化Args里面的值的。
信息
属    于
对磁盘进行的格式编写程序
类    别
DOS系统的一种命令
性    质
一种高级格式化
外文名
format
format常规用法
其主要格式为:FORMAT volume [/FS:file-system] [/V:label] [/Q] [/A:size] [/C] [/X]FORMAT volume [/V:label] [/Q] [/F:size]FORMAT volume [/V:label] [/Q] [/T:tracks /N:sectors]FORMAT volume [/V:label] [/Q]FORMAT volume [/Q]其主要参数有:volume 指定驱动器(后面跟一个冒号)、装入点或卷名。/FS:filesystem 指定文件系统类型(FAT、FAT32 或 NTFS)。/V:label 指定卷标。/Q 执行快速格式化。/C 仅适于 NTFS: 默认情况下,将压缩在该新建卷上创建的文件。/X 如果必要,先强制卸下卷。那时,该卷所有已打开的句柄不再有效。/A:size 替代默认配置单位大小。极力建议您在一般状况下使用默认设置。NTFS 支持 512、1024、2048、4096、8192、16K、32K、64K。FAT 支持 512、1024、2048、4096、8192、16K、32K、64k,(128k、256k 用于大于 512 字节的扇区)。FAT32 支持 512、1024、2048、4096、8192、16k、32k、64k,(128k 、256k 用于大于 512 字节的扇区)。注意 FAT 及FAT32文件系统对卷上的群集数量有以下限制:如果判定使用指定的群集大小无法满足以上需求,格式化将立即停止。NTFS 压缩不支持大于 4096 的分配单元。/F:size 指定要格式化的软盘大小(1.44)/T:tracks 为磁盘指定每面磁道数。/N:sectors 指定每条磁道的扇区数。
收起全文
精华内容
下载资源
问答
  • javascript Date format(js日期格式化)

    万次阅读 多人点赞 2010-06-02 19:04:00
    这个很不错,好像是 csdn 的 Meizz 写的: // 对Date的扩展,将 Date 转化为...1 个占位符(是 1-3 位的数字) // 例子: // (new Date()).Format("yyyy-MM-dd hh:mm:ss.S") ==> 2006-07-02 08:09:04.423 // (new Date())

    方法一:这个很不错,好像是 csdn 的 Meizz 写的:

    // 对Date的扩展,将 Date 转化为指定格式的String // 月(M)、日(d)、小时(h)、分(m)、秒(s)、季度(q) 可以用 1-2 个占位符, // 年(y)可以用 1-4 个占位符,毫秒(S)只能用 1 个占位符(是 1-3 位的数字) // 例子: // (new Date()).Format("yyyy-MM-dd hh:mm:ss.S") ==> 2006-07-02 08:09:04.423 // (new Date()).Format("yyyy-M-d h:m:s.S") ==> 2006-7-2 8:9:4.18 Date.prototype.Format = function(fmt) { //author: meizz var o = { "M+" : this.getMonth()+1, //月份 "d+" : this.getDate(), //日 "h+" : this.getHours(), //小时 "m+" : this.getMinutes(), //分 "s+" : this.getSeconds(), //秒 "q+" : Math.floor((this.getMonth()+3)/3), //季度 "S" : this.getMilliseconds() //毫秒 }; if(/(y+)/.test(fmt)) fmt=fmt.replace(RegExp.$1, (this.getFullYear()+"").substr(4 - RegExp.$1.length)); for(var k in o) if(new RegExp("("+ k +")").test(fmt)) fmt = fmt.replace(RegExp.$1, (RegExp.$1.length==1) ? (o[k]) : (("00"+ o[k]).substr((""+ o[k]).length))); return fmt; }

     

     

    调用方法:

    var time1 = new Date().format("yyyy-MM-dd HH:mm:ss"); var time2 = new Date().format("yyyy-MM-dd");

     

    方法二:

    <mce:script language="javascript" type="text/javascript"><!-- /** * 对Date的扩展,将 Date 转化为指定格式的String * 月(M)、日(d)、12小时(h)、24小时(H)、分(m)、秒(s)、周(E)、季度(q) 可以用 1-2 个占位符 * 年(y)可以用 1-4 个占位符,毫秒(S)只能用 1 个占位符(是 1-3 位的数字) * eg: * (new Date()).pattern("yyyy-MM-dd hh:mm:ss.S") ==> 2006-07-02 08:09:04.423 * (new Date()).pattern("yyyy-MM-dd E HH:mm:ss") ==> 2009-03-10 二 20:09:04 * (new Date()).pattern("yyyy-MM-dd EE hh:mm:ss") ==> 2009-03-10 周二 08:09:04 * (new Date()).pattern("yyyy-MM-dd EEE hh:mm:ss") ==> 2009-03-10 星期二 08:09:04 * (new Date()).pattern("yyyy-M-d h:m:s.S") ==> 2006-7-2 8:9:4.18 */ Date.prototype.pattern=function(fmt) { var o = { "M+" : this.getMonth()+1, //月份 "d+" : this.getDate(), //日 "h+" : this.getHours()%12 == 0 ? 12 : this.getHours()%12, //小时 "H+" : this.getHours(), //小时 "m+" : this.getMinutes(), //分 "s+" : this.getSeconds(), //秒 "q+" : Math.floor((this.getMonth()+3)/3), //季度 "S" : this.getMilliseconds() //毫秒 }; var week = { "0" : "/u65e5", "1" : "/u4e00", "2" : "/u4e8c", "3" : "/u4e09", "4" : "/u56db", "5" : "/u4e94", "6" : "/u516d" }; if(/(y+)/.test(fmt)){ fmt=fmt.replace(RegExp.$1, (this.getFullYear()+"").substr(4 - RegExp.$1.length)); } if(/(E+)/.test(fmt)){ fmt=fmt.replace(RegExp.$1, ((RegExp.$1.length>1) ? (RegExp.$1.length>2 ? "/u661f/u671f" : "/u5468") : "")+week[this.getDay()+""]); } for(var k in o){ if(new RegExp("("+ k +")").test(fmt)){ fmt = fmt.replace(RegExp.$1, (RegExp.$1.length==1) ? (o[k]) : (("00"+ o[k]).substr((""+ o[k]).length))); } } return fmt; } var date = new Date(); window.alert(date.pattern("yyyy-MM-dd hh:mm:ss")); // --></mce:script>

     

    方法三:

    Date.prototype.format = function(mask) { var d = this; var zeroize = function (value, length) { if (!length) length = 2; value = String(value); for (var i = 0, zeros = ''; i < (length - value.length); i++) { zeros += '0'; } return zeros + value; }; return mask.replace(/"[^"]*"|'[^']*'|/b(?:d{1,4}|m{1,4}|yy(?:yy)?|([hHMstT])/1?|[lLZ])/b/g, function($0) { switch($0) { case 'd': return d.getDate(); case 'dd': return zeroize(d.getDate()); case 'ddd': return ['Sun','Mon','Tue','Wed','Thr','Fri','Sat'][d.getDay()]; case 'dddd': return ['Sunday','Monday','Tuesday','Wednesday','Thursday','Friday','Saturday'][d.getDay()]; case 'M': return d.getMonth() + 1; case 'MM': return zeroize(d.getMonth() + 1); case 'MMM': return ['Jan','Feb','Mar','Apr','May','Jun','Jul','Aug','Sep','Oct','Nov','Dec'][d.getMonth()]; case 'MMMM': return ['January','February','March','April','May','June','July','August','September','October','November','December'][d.getMonth()]; case 'yy': return String(d.getFullYear()).substr(2); case 'yyyy': return d.getFullYear(); case 'h': return d.getHours() % 12 || 12; case 'hh': return zeroize(d.getHours() % 12 || 12); case 'H': return d.getHours(); case 'HH': return zeroize(d.getHours()); case 'm': return d.getMinutes(); case 'mm': return zeroize(d.getMinutes()); case 's': return d.getSeconds(); case 'ss': return zeroize(d.getSeconds()); case 'l': return zeroize(d.getMilliseconds(), 3); case 'L': var m = d.getMilliseconds(); if (m > 99) m = Math.round(m / 10); return zeroize(m); case 'tt': return d.getHours() < 12 ? 'am' : 'pm'; case 'TT': return d.getHours() < 12 ? 'AM' : 'PM'; case 'Z': return d.toUTCString().match(/[A-Z]+$/); // Return quoted strings with the surrounding quotes removed default: return $0.substr(1, $0.length - 2); } }); };

    展开全文
  • 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


    展开全文
  • python中format函数

    万次阅读 多人点赞 2019-05-14 12:07:45
    python中format函数用于字符串的格式化 通过关键字 1. print('{name}在{option}'.format(name="谢某人",option="写代码")) 结果:谢某人在写代码 通过位置 1. print('name={} path={}'.format('zhangsan', ...

    python中format函数用于字符串的格式化


    通过关键字

    1.

    print('{name}在{option}'.format(name="谢某人",option="写代码"))

    结果:谢某人在写代码 


    通过位置
    1. 

    print('name={} path={}'.format('zhangsan', '/')

    结果:name=zhangsan path=/

    2. 

    print('{1}在{0}'.format('写代码','谢某人'))

    3. 

    print('{0}在{1}'.format('谢某人','写代码'))

    结果:谢某人在写代码


    填充和对齐^<>分别表示居中、左对齐、右对齐,后面带宽度

    print('{:^30}'.format("zhangsan")) # 居中
    print('{:>30}'.format("zhangsan")) # 右对齐
    print('{:<30}'.format("zhangsan")) # 左对齐
    30:字段长度(最左到最右之间的长度)

    结果显示

     

    精度控制  :.nf

    1. 

    print('{:.2f}'.format(3.14159))
    结果:3.14
    保留两位小数,两位后四舍五入

    2. 

    print('{:.5f}'.format(3.14))
    结果:3.14000
    保留5位小数,不足补0.
    进制转化,b o d x 分别表示二、八、十、十六进制
    
    print('{:b}'.format(20))
    print('{:o}'.format(20))
    print('{:d}'.format(20))
    print('{:x}'.format(20))

    结果:

    10100
    24
    20
    14 


     千位分隔符::,

    print('{:,}'.format(100000000))
    print('{:,}'.format(123456.123456))

    结果:

    100,000,000
    123,456.123456

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

    万次阅读 多人点赞 2018-09-03 11:38:55
    format(Locale locale, String format, Object… args) 使用指定的语言环境,制定字符串格式和参数生成格式化的字符串。 上个栗子有用到了字符类型和整数类型的格式化 下面我把常用的类型例举出来 转换符 ...

    问题

    在开发的时候一段字符串的中间某一部分是需要可变的 比如一个Textview需要显示”XXX用户来自 上海 年龄 21 性别 男” 
    其中的 XXX 是用户名 每个用户也是不一样的 
    地区 上海 为可变的string数据 
    年龄 21 为可变的int数据 
    性别 男 为可变的string数据 
    遇到这种情况你们是怎么样解决的呢?把这段字符串保存在常量类里吗?不!我们应该遵循Google的开发模式

    XML

    <string name="user_info'> %1$s</span> 用户来自 <span class="hljs-variable">%2</span><span class="hljs-variable">$s  年龄 %3$d</span>  性别 <span class="hljs-variable">%4</span><span class="hljs-variable">$s</string>  
    • 1

    JAVA

    String userName="XXX";
    String userProvince="上海"; 
    int userAge=21;
    String userSex="男";
    String string=getResources().getString(R.string.user_info);
    String userInfo=String.format(string,userName,userProvince,userAge,userSex);

    是不是觉得很方便 
    本来是打算当笔记记录下来备忘的,但是有朋友有朋友问到的一些相关的东西,我就完善一下吧

    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", "小超");  
        System.out.println(str);  
        str=String.format("Hi,%s %s %s", "小超","是个","大帅哥");            
        System.out.println(str);                           
        System.out.printf("字母c的大写是:%c %n", 'C');  
        System.out.printf("布尔结果是:%b %n", "小超".equal("帅哥"));  
        System.out.printf("100的一半是:%d %n", 100/2);  
        System.out.printf("100的16进制数是:%x %n", 100);  
        System.out.printf("100的8进制数是:%o %n", 100);  
        System.out.printf("50元的书打8.5折扣是:%f 元%n", 50*0.85);  
        System.out.printf("上面价格的16进制数是:%a %n", 50*0.85);  
        System.out.printf("上面价格的指数表示:%e %n", 50*0.85);  
        System.out.printf("上面价格的指数和浮点数结果的长度较短的是:%g %n", 50*0.85);  
        System.out.printf("上面的折扣是%d%% %n", 85);  
        System.out.printf("字母A的散列码是:%h %n", 'A');  

    输出结果

    Hi,小超 
    Hi,小超 是个 大帅哥  
    字母c的大写是:C   
    布尔的结果是:false   
    100的一半是:50   
    100的16进制数是:64   
    100的8进制数是:144   
    50元的书打8.5折扣是:42.500000 元  
    上面价格的16进制数是:0x1.54p5   
    上面价格的指数表示:4.250000e+01   
    上面价格的指数和浮点数结果的长度较短的是:42.5000   
    上面的折扣是85%   
    字母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);  

    输出结果

    全部日期和时间信息:星期三 九月 21 22:43:36 CST 2016  
    年-月-日格式:2016-09-21
    月/日/年格式:16/10/21  
    HH:MM:SS PM格式(12时制):10:43:36 下午  
    HH:MM:SS格式(24时制):22:43:36  
    HH:MM格式(24时制):22:43  

    其实还有很多其他有趣的玩法 我这边只列举一些常用的 有兴趣的朋友可以自己再去多了解了解

     

    展开全文
  • mysql年月日时分秒格式化 DATE_FORMAT

    万次阅读 2017-12-27 19:38:25
    求人不如求己 SELECT DATE_FORMAT(NOW(),'%Y-%m-%d %H:%i:%s')
  • SAS: Format语句与Format过程

    千次阅读 2020-08-02 22:25:57
    SAS中的format可以控制数据的输出和输入格式,它分为format语句和format过程 FORMAT STATMENT 用于临时设置格式,语法为FORMAT variable(s) format-name,其中format-name可以是SAS的format,也可以用户自定义的...
  • python format用法详解

    万次阅读 多人点赞 2018-08-02 10:32:05
    format 基本语法是通过 {} 和 : 来代替以前的 % 。 format 函数可以接受不限个参数,位置可以不按顺序。 format基本用法 "Hello{0}{1}".format("Chen","xin")#引用第一个参数 #...
  • 【SAS】format和informat

    千次阅读 2019-04-17 10:47:26
    SAS中format和informat是用来控制输入和输出的数据类型的。 其中format表示设置输入数据格式; informat设置输出数据格式
  • @JsonFormat与@DateTimeFormat注解的使用

    万次阅读 2020-03-05 17:51:51
    注解@JsonFormat主要是后台到前台的时间格式的转换 注解@DataFormAT主要是前后到后台的时间格式的转换 1.注解@JsonFormat 1.使用maven引入@JsonFormat所需要的jar包,我贴一下我这里的pom文件的依赖 <!--Json...
  • format函数

    千次阅读 2018-07-17 19:05:11
    自python2.6开始,新增了一种格式化字符串的函数str.format(),此函数可以快速处理各种字符串。 语法 它通过{}和:来代替%。 请看下面的示例,基本上总结了format函数在python的中所有用法 1 #通过位置 2 ...
  • python format

    千次阅读 2017-09-20 00:28:05
    python之字符串格式化(format) 用法:  它通过{}和:来代替传统%方式   1、使用位置参数 要点:从以下例子可以看出位置参数不受顺序约束,且可以为{},只要format里有相对应的参数值即可,参数索引从0开,传入...
  • Python中format_map与format字符串格式化的区别

    千次阅读 多人点赞 2019-06-27 23:33:03
    在Python3中使用formatformat_map方法都可以进行字符串格式化,但format是一种所有情况都能使用的格式化方法,format_map仅使用于字符串格式中可变数据参数来源于字典等映射关系数据时才可以使用。 format_map的...
  • Python字符串格式化--format()方法

    万次阅读 多人点赞 2017-09-10 16:34:39
    字符串类型格式化采用format()方法,基本使用格式是:  .format()  由一系列的槽组成,用来控制修改字符串中嵌入值出现的位置,其基本思想是将format()方法的中的参数按照序号关系替换到的槽中。槽用大括号({})...
  • String.format和MessageFormat.format的使用

    千次阅读 2019-02-20 15:06:30
    常规类型的格式化 String类的format()方法用于创建格式化的字符串以及连接...format(String format, Object... args) 新字符串使用本地语言环境,制定字符串格式和参数生成格式化的新字符串。 format(Locale lo...
  • JAVA字符串格式化-String.format()的使用

    万次阅读 多人点赞 2012-09-10 11:01:10
    String类的format()方法用于创建格式化的字符串以及连接多个字符串对象。熟悉C语言的同学应该记得C语言的sprintf()方法,两者有类似之处。format()方法有两种重载形式。 format(String format, Object... args)...
  • python-format

    千次阅读 2018-08-17 10:05:09
    format函数格式化字符串的用法 python2.6之后format通过{}和:来代替%。 print('{0},{1}'.format('zhangk', 32)) print('{},{},{}'.format('zhangk', 'boy', 32)) print('{name},{sex},{age}'.format(age=32, ...
  • android PixelFormat与ImageFormat的对比

    千次阅读 2016-06-24 17:17:09
    PixelFormat public class PixelFormat  extends Object  java.lang.Object  ↳ android.graphics.PixelFormat Summary Constants int A_8
  • 1.错误信息 Exception in thread "main" java.lang.IllegalArgumentException: Cannot format given Object as a Date at java.text.DateFormat.format... at java.text.Format.format(Unknown ...
  • vc中format用法以及c++中Format用法

    千次阅读 2017-07-03 19:32:19
    总结一下Format的用法: Format('x=%d',[12]);//'x=12'//最普通 Format('x==',[12]);//'x=12'//指定宽度 Format('x=%f',[12.0]);//'x=12.00'//浮点数 Format('x=%.3f',[12.0]);//'x=12.000'//指定小数 Format...
  • Python的format()函数

    万次阅读 多人点赞 2018-11-21 19:50:22
    上篇博文,我们用format(number,',')快速实现了对数字千分位的分隔。 熟悉python的人都知道,foramt函数更常见的用法其实是str.format(),其基本语法是通过{}和:来代替以前的%。 示例: &gt;&gt;&gt;&...
  • DecimalFormat format 方法

    千次阅读 2018-02-21 14:03:34
    DecimalFormat format 方法 大家在format()一个小数是,总是对格式中的’0’和’#’有些不解吧! eg: 1:new DecimalFormat(“00.000”).format(pi) //结果:03.142 2:new DecimalFormat(“##.###”).format...
  • git format-patch

    千次阅读 2020-01-07 18:58:22
    转自:... 1使用git format-patch生成所需要的patch: 当前分支所有超前master的提交: git format-patch -M master 某次提交以后的所有patch: git format-patch 4e16 --4e16指的...
  • @JsonFormat(shape = JsonFormat.Shape.STRING)

    千次阅读 2020-10-29 07:53:19
    定睛一看精度疑似丢失了,到这里就明白缘由了,给Vo实体类加上@JsonFormat(shape = JsonFormat.Shape.STRING)然后再启动就没问题了,取到了全值。 @JsonFormat 用来表示json序列化的一种格式或者类型,s
  • error: format not a string literal and no format arguments [-Werror=format-security] 解决方法: 在你的ndk目录下修改build/core/default-build-commands.mk TARGET_FORMAT_STRING_CFLAGS := -Wformat -...
  • format html floatformat django python

    千次阅读 2014-04-01 10:22:32
    开发python项目时,使用django框架,前台的数值有时需要format, 每3位加逗号之类的。只需要以下两行就搞定{% load humanize %} {{ value|floatformat:1|intcomma }}
  • String.format

    千次阅读 2019-09-10 17:56:26
    String.format("%02d", "") 将后面的数字格式化为至少2位十进制整数 譬如 int year = 5; 结果为05
  • @JsonFormat

    千次阅读 2019-02-25 12:32:47
    前台使用固定时间格式时可以在属性名上添加@JsonFormat注解() @JsonFormat(pattern = "yyyy-MM-dd", timezone = "GMT+8") private LocalDateTime createTime; 解释 pattern:日期格式 time...
  • VB Format函数

    千次阅读 2017-01-02 20:31:21
    VB Format函数

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 357,474
精华内容 142,989
关键字:

format