字符串格式化_字符串格式化问题 - CSDN
  • 02“新式”字符串格式化(str.format) 03字符串插值/f-Strings(Python 3.6+) 04字符串模板(Python标准库) 05应该使用哪种字符串格式化方法? 06总结重点 你是还否记得Python之禅(TheZen of Python)中那...

    ★ 目录 ★

    01“旧式”字符串解析(%操作符)

    02“新式”字符串格式化(str.format)

    03  字符串插值/f-Strings(Python 3.6+)

    04  字符串模板(Python标准库) 

    05  应该使用哪种字符串格式化方法?

    06  总结重点

     

    你是还否记得Python之禅(The Zen of Python )中那条“一种明显的解决方案”?当你了解到在Python中竟然有四种主要的字符串格式化(string formatting)方法时,你可能会感到困惑。

     

    通过本教程,你将学会如何使用这四种主要的字符串格式化方法,并且了解它们的优缺点。以及你会知道如何根据经验法则( simple rule of thumb)去选择最适合你程序的最合适且通用的字符串格式化方法。

     

    前面已经讲了那么多,现在就直接开始吧!为了保证教程有一个简单的例子,假设你已经设置好了以下变量(或者常量):

     

     Python

    >>>  errno = 50159747054

    >>>  name = 'Bob'

     

    基于以上的变量,你想要输入带有一个简单错误提示语的字符串:

     

     Python

     'Hey Bob, there is a 0xbadc0ffee error!'

     

    该错误提示可能会影响开发者周一美好的早上。。。但是我们现在就是要讨论字符串格式化。让我们正式开始吧!

     

     

    01

    “旧式”字符串解析(%操作符)

     

    在Python中,有一个独特的内建操作可以使用%操作符来操作字符串。它可以让你很轻松的做基于位置的字符串格式化。如果你使用过C语言中的 printf-style 函数,你马上就能理解它的工作原理。来看下面这个简单的例子:

     

     Python

    >>> 'Hello, %s' % name

    "Hello, Bob"

     

    这里我使用了 %s 格式说明符来告诉Python哪个位置应该替换成 name 的值,它代表了类型为字符串。

     

    除了这个格式说明符,另外还有其他的格式操作符可供选择,让你可以控制输出的格式。例如,它可以让你更容易的将数字转成十六进制或者添加空白来生成一个整洁的格式化表格和报告。

     

    看下面这个例子,你可以使用 %x 格式说明符把一个类型为 Int 的值转成 字符串 使它代表十六进制数:

     

     Python

    >>> '%x' % errno

    'badc0ffee'

     

    如果你想要在单个字符串里做多个替换的话,这个“旧式”字符串格式化语法就需要稍加改变。因为%操作符只能传入一个参数,你需要把右操作符放入一个元组中,就像这样:

     

     Python

    >>> 'Hey %s, there is a 0x%x error!' % (name, errno)

    'Hey Bob, there is a 0xbadc0ffee error!'

     

    假如你在字符串中给 % 操作符传入一个映射,它也能够让你通过变量名来替换:

     

     Python

    >>> 'Hey %(name)s, there is a 0x%(errno)x error!' % {

    "name": name, "errno": errno }

    'Hey Bob, there is a 0xbadc0ffee error!'

     

    这样可以让你将来更简单方便的维护和修改的格式化字符串。你也不需要去担心你需要确保将值传入正确的位置,通过映射,值会自动的被放到正确的地方。 当然啦,它的缺点就是需要写很多代码。

     

    我相信你一定感到疑惑为什么这个 printf-style 字符串格式化方法会被称为“旧式”字符串格式化。因为严格来说它已经被Python3的“新式”字符串格式化方法代替了。这也是我们接下来要讲的。

     

     

    02

    “新式”字符串格式化(str.format)

     

    在Python3引入了一个新的字符串格式化的方法,并且随后支持了Python2.7。这个“新式”的字符串格式化方法摆脱了%操作符并且使得字符串格式化的语法更规范了。 现在时候通过调用字符串对象的.format() 方法进行格式化。

     

    你可以使用 format() 来做简单的基于位置的字符串格式化,和你使用“旧式”格式化是一样的:

     

     Python

    >>> 'Hello, {}'.format(name)

    'Hello, Bob'

     

    或者你可以通过变量名来进行替换,且不用担心变量的位置。这个强大的特性可以在不改变format()的传入参数的情况下,允许重新调整显示的位置。

     

     Python

    >>> 'Hey {name}, there is a 0x{errno:x} error!'.format(     name=name, errno=errno)

    'Hey Bob, there is a 0xbadc0ffee error!'

     

    这个例子也说明了用来将 int 变量格式化成十六进制字符串的语法也不一样了。现在你需要通过添加 :x 后缀传入格式说明符。字符串格式化语法已经变得越来越强大,无需再将简单的用例复杂化。阅读官方文档string formatting mini-language in the Python documentation

     

    在Python 3中,这个“新式”字符串格式化被认为在 %-style上。同时“旧式”字符串格式化也已经不再被强调,它也没有被弃用。并且也支持最新的版本。根据Python开发的邮件和Python开发bug跟踪讨论中,在将来很长一段时间里也会继续使用 %-formating。

     

    不过,在Python 3的官方文档中不太推荐使用“旧式”字符串格式化方法或者也没有提到很喜欢它:

     

    “The formatting operations described here exhibit a variety of quirks that lead to a number of common errors (such as failing to display tuples and dictionaries correctly). Using the newer formatted string literals or the str.format() interface helps avoid these errors. These alternatives also provide more powerful, flexible and extensible approaches to formatting text.” (Source)

     

    这也是为什么我个人在写新的代码时一直使用 str.format的原因。从Python 3.6 开始,目前又有了一个新的字符串格式化方法。我将在下个部分告诉你。

     

     

    03

    字符串插值/f-Strings(Python 3.6+)

     

    在Python 3.6 中添加了一个新的字符串格式化方法,被称为字面量格式化字符串或者“f-strings”。这个新的方法让你能够在字符串常量中嵌入Python表达式。以下这个简单的例子让你对这个特性有一个初步的体验:

     

     Python

    >>> f'Hello, {name}!'

    'Hello, Bob!'

     

    你可以看到它在字符串前面放置了“f”作为前缀 - 因此被称为“f-strings”。这个新的格式化语法非常的强大。你可以使用任何Python表达式,甚至可以做内联计算。看这个例子:

     

     

     Python

    >>> a = 5

    >>> b = 10

    >>> f'Five plus ten is {a + b} and not {2 * (a + b)}.'

    'Five plus ten is 15 and not 30.'

     

    格式化字符串字面量是Python的解析特性,它可以把 f-strings转成一连串的字符串常量和表达式。它们随后在一起组合成最终的字符串。

     

    设想你有以下这个函数 greet(),它包含了f-string:

     

     

     Python

    >>> def greet(name, question):

    ...     return f"Hello, {name}! How's it {question}?"

    ...

    >>> greet('Bob', 'going')

    "Hello, Bob! How's it going?"

     

    当你分解函数并检查代码执行时发生什么事情时,你会发现函数中的f-string实际上被转成了和以下相似的情况:

     

     

     Python

    >>> def greet(name, question):

    ...    return "Hello, " + name + "! How's it " + question + "?"

     

    真正运行的时候是比这个快很多的因为它使用了BUILD_STRING opcode as an optimization 中提到的优化。但是功能层面从它们是一样的:

     

     Python

    >>> import dis

    >>> dis.dis(greet)  

        2      0 LOAD_CONST               1 ('Hello, ')              

                2 LOAD_FAST                    0 (name)              

                4 FORMAT_VALUE            0              

                6 LOAD_CONST                2 ("! How's it ")              

                8 LOAD_FAST                    1 (question)             

                10 FORMAT_VALUE           0             

                12 LOAD_CONST               3 ('?')             

                14 BUILD_STRING             5             

                16 RETURN_VALUE

     

    字符串字面量同时也支持现有的 str.format() 字符串格式化方法。这样就能解决我们上次遇到的同一个格式化问题:

     

     Python

    >>> f"Hey {name}, there's a {errno:#x} error!"

    "Hey Bob, there's a 0xbadc0ffee error!"

     

    Python的新格式化字符串字面量和JavaScript在ES2015里添加的模板字面量类似。我认为对于Python来说就是如虎添翼,我也早就在日常工作中写Python3代码时使用它们了。你也可以在 in-depth Python f-strings tutorial 学习更多关于格式化字符串字面量的内容。

     

     

    04

    字符串模板(Python标准库)

     

    在Python里还有另一个字符串格式化工具:模板字符串。它是一个更简单,也不太强大的方法,但是在某些情况下恰恰是你想要的。

     

    让我们来看以下这个欢迎词例子:

     

     Python

    >>> from string import Template

    >>> t = Template('Hey, $name!')

    >>> t.substitute(name=name)

    'Hey, Bob!'

     

    你可以看到我们需要先从Python的内建 string 模块中导入 Template 类。模板字符串并不是核心的语言特征,但是它们由Python标准库的string提供的。

     

    另外一个不同的地方是这个模板字符串不支持使用格式说明符。所以想要让先前的错误提示信息能够使用,你还需要手动转换这个int 错误号码为十六进制字符串:

     

     Python

    >>> templ_string = 'Hey $name, there is a $error error!'

    >>> Template(templ_string).substitute(

    ...     name=name, error=hex(errno))

    'Hey Bob, there is a 0xbadc0ffee error!'

     

    顺利运行!

     

    但是该什么时候才在你的代码中使用模板字符串呢?在我看来,使用模板字符串的最佳的时机就是当你的程序需要处理由用户提供的输入内容时。模板字符串是最保险的选择,因为可以降低复杂性。

     

    其他一些复杂的字符串格式化技巧的可能会给你的程序带来安全漏洞,例如,格式化字符串可以访问你程序里任意的变量。

     

    这意味着,如果一个恶意用户可以提供一个格式化字符串,他们就有可能泄露安全密匙以及其他敏感的信息!下面是一个简单的例子证明这些可能可以用来影响你的代码:

     

     Python

    >>> # This is our super secret key:

    >>> SECRET = 'this-is-a-secret'

    >>> class Error:

    ...      def __init__(self):

    ...          pass

    >>> # A malicious user can craft a format string that

    >>> # can read data from the global namespace:

    >>> user_input = '{error.__init__.__globals__[SECRET]}'

    >>> # This allows them to exfiltrate sensitive information,

    >>> # like the secret key:

    >>> err = Error()

    >>> user_input.format(error=err)

    'this-is-a-secret'

     

    看到攻击者如何通过从恶意的格式化字符串访问__globals__ 字典并获取我们安全密匙了吗?是不是很可怕?模板字符串关闭了这个攻击载体。如果你的程序会处理来自用户的输入内容,这使得它是一个更安全的选择

     

     Python

    >>> user_input = '${error.__init__.__globals__[SECRET]}'

    >>> Template(user_input).substitute(error=err)

    ValueError:

    "Invalid placeholder in string: line 1, col 1"

     

    05

    应该使用哪种字符串格式化方法?

     

    我完全能理解Python中有那么多字符串格式化可供选择的带来的困惑。来看下面我给你们准备的选择路程图:

     

    Python字符串格式化经验法则

     

    这个流程图是基于我在写Python时会用到的经验法则:

    Python字符串格式化经验法则:如果你的格式化字符串是由用户提供的,那么就是用模板字符串(#4)避免安全问题。不然如果是Python 3.6+的话,就使用字符串插值/f-Strings,如果不是就使用“新式”字符串格式化(str.format)。

     

     

    06

    总结重点

     

    ● 也许感到惊讶,Python在处理字符串格式化时不只有一种方法。

    ● 每个方法都有其优缺点。你应该根据你的用例来选择合适的方法

    ● 如果你在决定该使用哪个字符串格式化方法时感到困难,试试我们的Python字符串格式化经验法则。

     

     

    本文作者:Dan Bader

    大家好,我是Dan Bader。我帮助Python开发者提升他们的编程水平和工作效率。我是一个独立软件工程师、作家和演说家。我从事软件开发工作已经15余载 - 我愿意帮助你们成为一个更高效的Python程序员。

    文章来源:https://realpython.com/python-string-formatting/

    作者:Dan Bader

    作者github:https://github.com/dbader

    作者推特:https://twitter.com/dbader_org

    作者YouTube:https://dbader.org/youtube

    作者官网:https://dbader.org/

     

    声明:转载请注明出处。

     

    关注译者公众号查看更多干货文章:

     

    展开全文
  • Python 中的 字符串格式化1. 字符串格式化的种类2. % 格式化方式3. % 格式化方式例子4. format 格式化方式5. format 格式化方式例子 1. 字符串格式化的种类 Python 的字符串格式化有两种方式: % 格式符方式,...

    1. 字符串格式化的种类

    Python 的字符串格式化有两种方式: % 格式符方式,format 方式

    2. % 格式化方式

    %[(name)][flags][width].[precision]typecode
    
        (name): 可选,用于选择指定的key
        flags: 可选,可供选择的值有:
            +: 右对齐;正数前加正好,负数前加负号;
            -: 左对齐;正数前无符号,负数前加负号;
             : 右对齐;正数前加空格,负数前加负号;
            0: 右对齐;正数前无符号,负数前加负号;用 0 填充空白处
        width: 可选,占有宽度
        .precision: 可选,小数点后保留的位数
        typecode: 必选
            s,获取传入对象的 __str__ 方法的返回值,并将其格式化到指定位置
            r,获取传入对象的 __repr__ 方法的返回值,并将其格式化到指定位置
            c,整数:将数字转换成其 unicode 对应的值,10进制范围为 0 <= i <= 1114111(py27则只支持 0-255);字符:将字符添加到指定位置
            o,将整数转换成八进制表示,并将其格式化到指定位置
            x,将整数转换成十六进制表示,并将其格式化到指定位置
            d,将整数、浮点数转换成十进制表示,并将其格式化到指定位置
            e,将整数、浮点数转换成科学计数法,并将其格式化到指定位置(小写 e )
            E,将整数、浮点数转换成科学计数法,并将其格式化到指定位置(大写 E )
            f,将整数、浮点数转换成浮点数表示,并将其格式化到指定位置(默认保留小数点后6位)
            F,同上
            g,自动调整将整数、浮点数转换成 浮点型或科学计数法表示(超过6位数用科学计数法),并将其格式化到指定位置(如果是科学计数则是 e;)
            G,自动调整将整数、浮点数转换成 浮点型或科学计数法表示(超过6位数用科学计数法),并将其格式化到指定位置(如果是科学计数则是 E;)
            %,当字符串中存在格式化标志时,需要用 %% 表示一个百分号
    

    3. % 格式化方式例子

    [[fill]align][sign][#][0][width][,][.precision][type]
    
            fill: 【可选】空白处填充的字符
            align:【可选】对齐方式(需配合width使用)
                <: 内容左对齐
                >: 内容右对齐(默认)
                =: 内容右对齐,将符号放置在填充字符的左侧,且只对数字类型有效。 即使:符号 + 填充物 + 数字
                ^: 内容居中
            sign: 【可选】有无符号数字
                +: 正号加正,负号加负;
                -: 正号不变,负号加负;
                空格: 正号空格,负号加负;
            #:【可选】对于二进制、八进制、十六进制,如果加上 #,会显示 0b/0o/0x,否则不显示
            ,: 【可选】为数字添加分隔符,如:1,000,000
            width: 【可选】格式化位所占宽度
            .precision: 【可选】小数位保留精度
            type: 【可选】格式化类型
                传入” 字符串类型 “的参数
                    s: 格式化字符串类型数据
                    空白: 未指定类型,则默认是 None,同 s
                传入“ 整数类型 ”的参数
                    b: 将十进制整数自动转换成二进制表示然后格式化
                    c: 将十进制整数自动转换为其对应的 unicode 字符
                    d: 十进制整数
                    o: 将十进制整数自动转换成8进制表示然后格式化;
                    x: 将十进制整数自动转换成16进制表示然后格式化(小写 x )
                    X: 将十进制整数自动转换成16进制表示然后格式化(大写 X )
                传入“ 浮点型或小数类型 ”的参数
                    e: 转换为科学计数法(小写 e )表示,然后格式化;
                    E: 转换为科学计数法(大写 E )表示,然后格式化;
                    f: 转换为浮点型(默认小数点后保留 6 位)表示,然后格式化;
                    F: 转换为浮点型(默认小数点后保留 6 位)表示,然后格式化;
                    g: 自动在e和f中切换
                    G: 自动在E和F中切换
                    %: 显示百分比(默认显示小数点后 6 位)
    
    

    4. format 格式化方式

    # 字符串格式化
    
    print("I am %s, %d years old." % ("Y", 18))
    print("I am %s, %s years old." % ("Y", 18))
    print("I am %s, %s years old." % ("Y", ["18"]))
    print("I am %s, %s years old." % ("Y", (18,)))
    
    # 保留
    print("percent %0.2f%%." % 23.36666)
    # 截取
    print("percent %.5s." % 23.36666)
    
    # 字典形式
    print("I am %(name)s, %(age)d years old." % {"name": "Y", "age": 18})
    
    # 其他
    print("I am \033[42;1m%(name)10s\033[0m, "
          "\033[42;1m%(age)-10d\033[0m years old."
          % {"name": "Y", "age": 18})
    
    print("user", "root", "password", "root", sep=":")
    
    

    结果:
    在这里插入图片描述

    5. format 格式化方式例子

    # format 格式
    print("I am {}, {} years old, who is {}.".format("Y", "22", "wise"))
    print("I am {0}, {1} years old, who is {2}.".format("Y", "22", "wise"))
    print("I am {1}, {1} years old, who is {1}.".format("Y", "22", "wise"))
    
    print("I am {name}, {age} years old, who is {adj}.".format(name="Y", age="22", adj="wise"))
    print("I am {name}, {age} years old, who is {adj}.".format(**{"name": "Y", "age": "22", "adj": "wise"}))
    
    print("I am {0[0]}, {0[1]} years old, who is {0[2]}.".format(["Y", "22", "wise"], [1, 2, 3]))
    print("I am {:s}, {:d} years old, who is {:f}.".format("good", 122, 12.22))
    print("I am {:s}, {:d} years old, who is {:f}.".format(*["good", 122, 12.22]))
    
    # 进制,百分比
    print("number: {:b}, {:o}, {:d}, {:x}, {:X}, {:0.2%}".format(12, 15, 17, 999, 999, 0.55))
    
    

    结果:
    在这里插入图片描述

    展开全文
  • 当我们在开发中需要格式化时或者当一字符串中有某一部分是需要变化时,我们应该如何快速的进行处理呢?比如处理批量的url中www.xxx.com/s?index=后面需要带参数时。 JDK1.5开始String类中提供了一个非常有用的方法 ...

    1 问题背景

    当我们在开发中需要格式化时或者当一字符串中有某一部分是需要变化时,我们应该如何快速的进行处理呢?比如处理批量的url中www.xxx.com/s?index=后面需要带参数时。
    JDK1.5开始String类中提供了一个非常有用的方法
    String.format(String format, Object ... args)
    举例说明:

       String url ="www.xxx.com/s?index=%d";
       for(int i=1;i<=5;i++) {
    		String format = String.format(url, i);
    		System.out.println(format);
       }
    

    执行结果:

    www.xxx.com/s?index=1
    www.xxx.com/s?index=2
    www.xxx.com/s?index=3
    www.xxx.com/s?index=4
    www.xxx.com/s?index=5
    

    2 常规类型的格式化

    format()方法有两种重载形式。
    format(String format, Object… args) 新字符串使用本地语言环境,制定字符串格式和参数生成格式化的新字符串。
    format(Locale locale, String format, Object… args) 使用指定的语言环境,制定字符串格式和参数生成格式化的字符串。

    类型如下:
    类型
    下面通过代码加深对该方法的理解 示例代码如下:

    String str1=String.format("Hi,%s", "哈士奇");  
    System.out.println(str1);  
    String str2=String.format("Hi,%s:%s.%s", "老鹰","是一种","鸟类");            
    System.out.println(str2);                           
    System.out.printf("字母h的大写是:%c %n", 'H');  
    System.out.printf("12.34>33.22的结果是:%b %n", 12.34>33.22);  
    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("100元的书包打8.5折扣是:%f 元%n", 100*0.85);  
    System.out.printf("100的16进制浮点数是:%a %n", 100*0.85);  
    System.out.printf("100的指数表示:%e %n", 100*0.85);  
    System.out.printf("10的指数和浮点数结果的长度较短的是:%g %n", 100*0.85);  
    System.out.printf("100的折扣是%d%% %n", 85);  
    System.out.printf("字母A的散列码是:%h %n", 'A');  
    

    输出结果如下:

    Hi,哈士奇
    Hi,老鹰:是一种.鸟类
    字母h的大写是:H 
    12.34>33.22的结果是:false 
    100的一半是:50 
    10016进制数是:64 
    1008进制数是:144 
    100元的书包打8.5折扣是:85.00000010016进制浮点数是:0x1.54p6 
    100的指数表示:8.500000e+01 
    10的指数和浮点数结果的长度较短的是:85.0000 
    100的折扣是85% 
    字母A的散列码是:41 
    

    3 搭配转换符的标志

    在这里插入图片描述

    4 日期和事件字符串格式化

    在这里插入图片描述
    示例代码:

     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 13:47:42 CST 2018--日格式:2018-09-19//年格式:09/19/18
    HH:MM:SS PM格式(12时制):01:47:42 下午
    HH:MM:SS格式(24时制):13:47:42
    HH:MM格式(24时制):13:47
    

    5 时间格式转换符

    在这里插入图片描述
    示例代码:

    Date date = new Date();  
    //H的使用  
    System.out.printf("2位数字24时制的小时(不足2位前面补0):%tH%n", date);  
    //I的使用  
    System.out.printf("2位数字12时制的小时(不足2位前面补0):%tI%n", date);  
    //k的使用  
    System.out.printf("2位数字24时制的小时(前面不补0):%tk%n", date);  
    //l的使用  
    System.out.printf("2位数字12时制的小时(前面不补0):%tl%n", date);  
    //M的使用  
    System.out.printf("2位数字的分钟(不足2位前面补0):%tM%n", date);  
    //S的使用  
    System.out.printf("2位数字的秒(不足2位前面补0):%tS%n", date);  
    //L的使用  
    System.out.printf("3位数字的毫秒(不足3位前面补0):%tL%n", date);  
    //N的使用  
    System.out.printf("9位数字的毫秒数(不足9位前面补0):%tN%n", date);  
    //p的使用  
    String str = String.format(Locale.US, "小写字母的上午或下午标记(英):%tp", date);  
    System.out.println(str);   
    System.out.printf("小写字母的上午或下午标记(中):%tp%n", date);  
    //z的使用  
    System.out.printf("相对于GMT的RFC822时区的偏移量:%tz%n", date);  
    //Z的使用  
    System.out.printf("时区缩写字符串:%tZ%n", date);  
    //s的使用  
    System.out.printf("1970-1-1 00:00:00 到现在所经过的秒数:%ts%n", date);  
    //Q的使用  
    System.out.printf("1970-1-1 00:00:00 到现在所经过的毫秒数:%tQ%n", date); 
    

    执行结果:

    2位数字24时制的小时(不足2位前面补0:14
    2位数字12时制的小时(不足2位前面补0:02
    2位数字24时制的小时(前面不补0:14
    2位数字12时制的小时(前面不补0:2
    2位数字的分钟(不足2位前面补0:12
    2位数字的秒(不足2位前面补0:49
    3位数字的毫秒(不足3位前面补0:796
    9位数字的毫秒数(不足9位前面补0:796000000
    小写字母的上午或下午标记():pm
    小写字母的上午或下午标记(中):下午
    相对于GMT的RFC822时区的偏移量:+0800
    时区缩写字符串:CST
    1970-1-1 00:00:00 到现在所经过的秒数:1537337569
    1970-1-1 00:00:00 到现在所经过的毫秒数:1537337569796
    
    展开全文
  • 字符串格式化

    2019-06-18 08:51:49
    使用变量名.format来格式化字符串 type_of_people = 10 x = f"There are {type_of_people} types of people." binary = "binary" do_not = "donnot" y = f"Those who know {binary} and those who {do_not}" ...
    1. 使用f"内容{格式化变量名}"
    2. 使用变量名.format来格式化字符串
    type_of_people = 10
    x = f"There are {type_of_people} types of people."
    binary = "binary"
    do_not = "donnot"
    y = f"Those who know {binary} and those who {do_not}"
    
    print(x)
    print(y)
    
    print(f"i said: {x}")
    print(f"i also said: '{y}'")
    
    hilarious = False
    joke_evaluation = "isnot that joke so funny ?!{}"
    #字符串格式化  变量名.format
    print(joke_evaluation.format(hilarious))
    
    w = "This is the left side of ..."
    e = "a string with a right side."
    
    print(w + e)
    
    展开全文
  • 1.常规类型的格式化  String类的format()方法用于创建格式化的字符串以及连接多个字符串对象。熟悉C语言的同学应该记得C语言的sprintf()... args) 新字符串使用本地语言环境,制定字符串格式和参数生成格式化的新字符

       1.常规类型的格式化

           String类的format()方法用于创建格式化的字符串以及连接多个字符串对象。熟悉C语言的同学应该记得C语言的sprintf()方法,两者有类似之处。format()方法有两种重载形式。

          |-----format(String format, Object... args) 新字符串使用本地语言环境,制定字符串格式和参数生成格式化的新字符串。

          |-----format(Locale locale, String format, Object... args) 使用指定的语言环境,制定字符串格式和参数生成格式化的字符串。

    显示不同转换符实现不同数据类型到字符串的转换,如图所示

    转  换  符

    说    明 

    示    例

    %s

    字符串类型

    "mingrisoft"

    %c

    字符类型

    'm'

    %b

    布尔类型

    true

    %d

    整数类型(十进制)

    99

    %x

    整数类型(十六进制)

    FF

    %o

    整数类型(八进制)

    77

    %f

    浮点类型

    99.99

    %a

    十六进制浮点类型

    FF.35AE

    %e

    指数类型

    9.38e+5

    %g

    通用浮点类型(f和e类型中较短的)

     

    %h

    散列码

     

    %%

    百分比类型

    %n

    换行符

     

    %tx

    日期与时间类型(x代表不同的日期与时间转换符

     
    示例如下
    	public static void main(String[] args) {
    	    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("字母a的大写是:%c %n", 'A');
    	    System.out.printf("3>7的结果是:%b %n", 3>7);
    	    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,王南:王力.王张  
    字母a的大写是:A   
    3>7的结果是: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

    左对齐

    ("%-5d",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

    $

    被格式化的参数索引

    ("%1$d,%2$s", 99,"abc")

    99,abc

    测试用例

    public static void main(String[] args) {  
        String str=null;  
        //$使用  
        str=String.format("格式参数$的使用:%1$d,%2$s", 99,"abc");             
        System.out.println(str);                       
        //+使用  
        System.out.printf("显示正负数的符号:%+d与%d%n", 99,-99);  
        //补O使用  
        System.out.printf("最牛的编号是:%03d%n", 7);  
        //空格使用  
        System.out.printf("Tab键的效果是:% 8d%n", 7);  
        //.使用  
        System.out.printf("整数分组的效果是:%,d%n", 9989997);  
        //空格和小数点后面个数  
        System.out.printf("一本书的价格是:% 50.5f元%n", 49.8);  
    }  

    输出结果

    格式参数$的使用:99,abc  
    显示正负数的符号:+99与-99  
    最牛的编号是:007  
    Tab键的效果是:       7  
    整数分组的效果是:9,989,997  
    一本书的价格是:                                          49.80000元 
       2.日期和时间字符串格式化

    在程序界面中经常需要显示时间和日期,但是其显示的 格式经常不尽人意,需要编写大量的代码经过各种算法才得到理想的日期与时间格式。字符串格式中还有%tx转换符没有详细介绍,它是专门用来格式化日期和时 间的。%tx转换符中的x代表另外的处理日期和时间格式的转换符,它们的组合能够将日期和时间格式化成多种格式。

    常见日期和时间组合的格式,如图所示。


    测试用例

    public static void main(String[] args) {  
        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);  
    }  
    输出结果

    全部日期和时间信息:星期一 九月 10 10:43:36 CST 2012  
    年-月-日格式:2012-09-10  
    月/日/年格式:09/10/12  
    HH:MM:SS PM格式(12时制):10:43:36 上午  
    HH:MM:SS格式(24时制):10:43:36  
    HH:MM格式(24时制):10:43  
    定义日期格式的转换符可以使日期通过指定的转换符生成新字符串。这些日期转换符如图所示。

    转  换  符

    说    明

    示    例

    b或者h

    月份简称

    中:十月

    英:Oct

    B

    月份全称

    中:十月

    英:October

    a

    星期的简称

    中:星期六

    英:Sat

    A

    星期的全称

    中:星期六

    英:Saturday

    C

    年的前两位数字(不足两位前面补0)

    20

    y

    年的后两位数字(不足两位前面补0)

    07

    Y

    4位数字的年份(不足4位前面补0)

    2007

    j

    一年中的天数(即年的第几天)

    300

    m

    两位数字的月份(不足两位前面补0)

    10

    d

    两位数字的日(不足两位前面补0)

    27

    e

    月份的日(前面不补0)

    5

    测试用例

    public static void main(String[] args) {  
        Date date=new Date();                                      
        //b的使用,月份简称  
        String str=String.format(Locale.US,"英文月份简称:%tb",date);       
        System.out.println(str);                                                                              
        System.out.printf("本地月份简称:%tb%n",date);  
        //B的使用,月份全称  
        str=String.format(Locale.US,"英文月份全称:%tB",date);  
        System.out.println(str);  
        System.out.printf("本地月份全称:%tB%n",date);  
        //a的使用,星期简称  
        str=String.format(Locale.US,"英文星期的简称:%ta",date);  
        System.out.println(str);  
        //A的使用,星期全称  
        System.out.printf("本地星期的简称:%tA%n",date);  
        //C的使用,年前两位  
        System.out.printf("年的前两位数字(不足两位前面补0):%tC%n",date);  
        //y的使用,年后两位  
        System.out.printf("年的后两位数字(不足两位前面补0):%ty%n",date);  
        //j的使用,一年的天数  
        System.out.printf("一年中的天数(即年的第几天):%tj%n",date);  
        //m的使用,月份  
        System.out.printf("两位数字的月份(不足两位前面补0):%tm%n",date);  
        //d的使用,日(二位,不够补零)  
        System.out.printf("两位数字的日(不足两位前面补0):%td%n",date);  
        //e的使用,日(一位不补零)  
        System.out.printf("月份的日(前面不补0):%te",date);  
    }  
    英文月份简称:Sep  
    本地月份简称:九月  
    英文月份全称:September  
    本地月份全称:九月  
    英文星期的简称:Mon  
    本地星期的简称:星期一  
    年的前两位数字(不足两位前面补0):20  
    年的后两位数字(不足两位前面补0):12  
    一年中的天数(即年的第几天):254  
    两位数字的月份(不足两位前面补0):09  
    两位数字的日(不足两位前面补0):10  
    月份的日(前面不补0):10  


    3.格式化时间字符串

          和日期格式转换符相比,时间格式的转换符要更多、更精确。它可以将时间格式化成时、分、秒甚至时毫秒等单位。格式化时间字符串的转换符如图所示。

    转  换  符

    说    明

    示    例

    H

    2位数字24时制的小时(不足2位前面补0)

    15

    I

    2位数字12时制的小时(不足2位前面补0)

    03

    k

    2位数字24时制的小时(前面不补0)

    15

    l

    2位数字12时制的小时(前面不补0)

    3

    M

    2位数字的分钟(不足2位前面补0)

    03

    S

    2位数字的秒(不足2位前面补0)

    09

    L

    3位数字的毫秒(不足3位前面补0)

    015

    N

    9位数字的毫秒数(不足9位前面补0)

    562000000

    p

    小写字母的上午或下午标记

    中:下午

    英:pm

    z

    相对于GMT的RFC822时区的偏移量

    +0800

    Z

    时区缩写字符串

    CST

    测试用例

    public static void main(String[] args) {  
        Date date = new Date();  
        //H的使用  
        System.out.printf("2位数字24时制的小时(不足2位前面补0):%tH%n", date);  
        //I的使用  
        System.out.printf("2位数字12时制的小时(不足2位前面补0):%tI%n", date);  
        //k的使用  
        System.out.printf("2位数字24时制的小时(前面不补0):%tk%n", date);  
        //l的使用  
        System.out.printf("2位数字12时制的小时(前面不补0):%tl%n", date);  
        //M的使用  
        System.out.printf("2位数字的分钟(不足2位前面补0):%tM%n", date);  
        //S的使用  
        System.out.printf("2位数字的秒(不足2位前面补0):%tS%n", date);  
        //L的使用  
        System.out.printf("3位数字的毫秒(不足3位前面补0):%tL%n", date);  
        //N的使用  
        System.out.printf("9位数字的毫秒数(不足9位前面补0):%tN%n", date);  
        //p的使用  
        String str = String.format(Locale.US, "小写字母的上午或下午标记(英):%tp", date);  
        System.out.println(str);   
        System.out.printf("小写字母的上午或下午标记(中):%tp%n", date);  
        //z的使用  
        System.out.printf("相对于GMT的RFC822时区的偏移量:%tz%n", date);  
        //Z的使用  
        System.out.printf("时区缩写字符串:%tZ%n", date);  
        //s的使用  
        System.out.printf("1970-1-1 00:00:00 到现在所经过的秒数:%ts%n", date);  
        //Q的使用  
        System.out.printf("1970-1-1 00:00:00 到现在所经过的毫秒数:%tQ%n", date);  
    }  

    输出结果

    2位数字24时制的小时(不足2位前面补0):11  
    2位数字12时制的小时(不足2位前面补0):11  
    2位数字24时制的小时(前面不补0):11  
    2位数字12时制的小时(前面不补0):11  
    2位数字的分钟(不足2位前面补0):03  
    2位数字的秒(不足2位前面补0):52  
    3位数字的毫秒(不足3位前面补0):773  
    9位数字的毫秒数(不足9位前面补0):773000000  
    小写字母的上午或下午标记(英):am  
    小写字母的上午或下午标记(中):上午  
    相对于GMT的RFC822时区的偏移量:+0800  
    时区缩写字符串:CST  
    1970-1-1 00:00:00 到现在所经过的秒数:1347246232  
    1970-1-1 00:00:00 到现在所经过的毫秒数:1347246232773 

    原文地址 http://blog.csdn.net/lonely_fireworks/article/details/7962171



    展开全文
  • 程序清单4.1 talkback.c程序 // talkback.c -- 演示与用户交互 #include &lt;stdio.h&gt; #include &lt;string.h&...#define DENSITY 62.4 // 人体密度(单位:磅/立方英尺) ...int...
  • 格式化字符串溢出

    2018-07-31 15:41:27
    漏洞原理:  printf是c语言中少有的支持可变... 格式化字符串漏洞的产生根源主要源于对用户输入未进行过滤,这些输入数据都作为数据传递给某些执行格式化操作的函数,如printf,sprintf,vprintf,vprintf。恶...
  • 字符串类型格式化采用format()方法,基本使用格式是:  .format()  由一系列的槽组成,用来控制修改字符串中嵌入值出现的位置,其基本思想是将format()方法的中的参数按照序号关系替换到的槽中。槽用大括号({})...
  • 格式化参数,format模板(占位符)语法及示例 conversion:转换字符 argument_index$:指定要使用【Object... args】中的哪一个参数作为此处占位符的原始参数 flags:指定格式化标识,此标识的作用有:填充、对齐、...
  • 在《第3.10节 Python强大的字符串格式化新功能:使用format字符串格式化》介绍了使用format进行字符串格式化的方法,在Python 3.6中,如果格式化字符串中的关键字参数变量与替换字段同名,还可使用一种简写:使用f...
  • 一、 概念 格式化字符串就是将一些变量转换为字符串并按一定格式输出字符串,包括指定字符的位置、...在使用字符串格式化方法时,在格式字符串内使用特定符号及其后面的格式及类型指定的串称为“格式符”或“转换说...
  • C#字符串格式化三种方式 //$字符串格式化,用对象名称定位(类似模板语言,可以对参数进行逻辑运算,复杂度高,编译时无法检查错误导致运行时异常) string name = "Horace"; int age = 34; Console....
  • 刚入门python的同学,特别是,没有系统的学习过python,而是学过别的语言,直接上手python的同学,怕是还不是很了解python强大的字符串格式化方法 1.最方便的 print 'hello %s and %s' % ('df', 'another df') 但是...
  • 日期和时间字符串格式化:"%##" String类的静态format()方法用于创建格式化的字符串。 format()方法有两种重载形式。 format()方法通过给定的特殊转换符作为参数来实现对日期和时间的格式化。 format()...
  • java格式化输出与字符串格式化输入 Java格式化输出  Java中可以使用System.out.print()将数值x输出到控制台上,在早期的java版本中,格式化输出数值曾经引发过争议,不过在javaSE5以后,引入了c语言中的格式化...
  • 字符串格式化-format()

    2017-09-21 21:21:14
    字符串格式化-format() 转载请标明出处(http://blog.csdn.net/lis_12/article/details/52712994). 普通格式化方法 (%s%d)生成格式化的字符串,其中s是一个格式化字符串,d是一个十进制数; 格式化...
  • Swift:字符串格式化

    2018-04-02 16:40:45
    字符串格式化1、单个变量格式化1.1、字符串类型格式化let string = "lazy" print(String(format:"%@ boy", arguments:[string]))//输出结果:lazy boy1.2、Number类型格式化let num = 10 print...
  • 今天碰到一简单的功能,就是把字符串格式化成9位,不足的前面补0。懒人就想一行代码解决这个问题,后来发现能一行代码补足位数的,前面都是补的空格,而要想补0的,都是需要整数型。用到的函数是 String.format,...
  • Python字符串格式化 格式化的操作有两种 一、使用%,常用的格式化 格式 描述 %s 字符串 %d 有符号整数(十进制) %f 浮点数 %O 转换为带符号的八进制形式的整数 %X 转换为带符号的十六进制形式的...
  • 本文介绍了Python字符串格式化,主要有两种方法,分享给大家,具体如下用于字符串的拼接,性能更优。字符串格式化有两种方式:百分号方式、format方式。百分号方式比较老,而format方式是比较先进的,企图替代古老的...
1 2 3 4 5 ... 20
收藏数 814,397
精华内容 325,758
关键字:

字符串格式化