การจัดรูปแบบสตริง:% กับ. format

Python 2.6 แนะนำstr.format()วิธีการที่มีไวยากรณ์แตกต่างกันเล็กน้อยจาก%ผู้ให้บริการที่มีอยู่ ไหนดีกว่าและสำหรับสถานการณ์อะไร

1. ต่อไปนี้ใช้แต่ละวิธีและมีผลลัพธ์เหมือนกันดังนั้นความแตกต่างคืออะไร

   #!/usr/bin/python
   sub1 = "python string!"
   sub2 = "an arg"
   
   a = "i am a %s" % sub1
   b = "i am a {0}".format(sub1)
   
   c = "with %(kwarg)s!" % {'kwarg':sub2}
   d = "with {kwarg}!".format(kwarg=sub2)
   
   print a    # "i am a python string!"
   print b    # "i am a python string!"
   print c    # "with an arg!"
   print d    # "with an arg!"
   

2. นอกจากนี้การจัดรูปแบบสตริงเกิดขึ้นใน Python เมื่อใด ตัวอย่างเช่นหากระดับการบันทึกของฉันถูกตั้งค่าเป็นสูงฉันจะยังคงได้รับผลกระทบจากการดำเนินการต่อไปนี้%หรือไม่ และถ้าเป็นเช่นนั้นมีวิธีที่จะหลีกเลี่ยงปัญหานี้หรือไม่?

   log.debug("some debug info: %s" % some_info)

เพื่อตอบคำถามแรกของคุณ ... .formatดูเหมือนจะซับซ้อนกว่านี้ในหลาย ๆ ทาง สิ่งที่น่ารำคาญก็%คือมันสามารถใช้ตัวแปรหรือทูเปิลได้ คุณคิดว่าสิ่งต่อไปนี้จะได้ผลเสมอ:

"hi there %s" % name

แต่ถ้าnameเกิดขึ้นจะเป็นก็จะโยน(1, 2, 3) TypeErrorหากต้องการรับประกันว่าจะพิมพ์ออกมาเสมอคุณต้องทำ

"hi there %s" % (name,)   # supply the single argument as a single-item tuple

ซึ่งน่าเกลียดเพียง .formatไม่มีปัญหาเหล่านั้น นอกจากนี้ในตัวอย่างที่สองที่คุณให้.formatตัวอย่างนั้นดูสะอาดตากว่ามาก

ทำไมคุณไม่ใช้มัน?

• ไม่ทราบเกี่ยวกับมัน (ฉันก่อนที่จะอ่านนี้)
• ต้องเข้ากันได้กับ Python 2.5

เพื่อตอบคำถามที่สองของคุณการจัดรูปแบบสตริงเกิดขึ้นในเวลาเดียวกันกับการดำเนินการอื่น ๆ - เมื่อนิพจน์การจัดรูปแบบสตริงถูกประเมิน และ Python ไม่เป็นภาษาขี้เกียจประเมินการแสดงออกก่อนที่จะเรียกฟังก์ชั่นดังนั้นในของคุณlog.debugตัวอย่างเช่นการแสดงออก"some debug info: %s"%some_infoแรกจะประเมินเช่นแล้วว่าสตริงจะถูกส่งผ่านไปยัง"some debug info: roflcopters are active"log.debug()

สิ่งที่ตัวดำเนินการ modulo (%) ไม่สามารถทำได้ Afaik:

tu = (12,45,22222,103,6)
print '{0} {2} {1} {2} {3} {2} {4} {2}'.format(*tu)

ผลลัพธ์

12 22222 45 22222 103 22222 6 22222

มีประโยชน์มาก.

อีกจุดหนึ่ง: format()เป็นฟังก์ชันสามารถใช้เป็นอาร์กิวเมนต์ในฟังก์ชันอื่นได้:

li = [12,45,78,784,2,69,1254,4785,984]
print map('the number is {}'.format,li)   

print

from datetime import datetime,timedelta

once_upon_a_time = datetime(2010, 7, 1, 12, 0, 0)
delta = timedelta(days=13, hours=8,  minutes=20)

gen =(once_upon_a_time +x*delta for x in xrange(20))

print '\n'.join(map('{:%Y-%m-%d %H:%M:%S}'.format, gen))

ผลลัพธ์ใน:

['the number is 12', 'the number is 45', 'the number is 78', 'the number is 784', 'the number is 2', 'the number is 69', 'the number is 1254', 'the number is 4785', 'the number is 984']

2010-07-01 12:00:00
2010-07-14 20:20:00
2010-07-28 04:40:00
2010-08-10 13:00:00
2010-08-23 21:20:00
2010-09-06 05:40:00
2010-09-19 14:00:00
2010-10-02 22:20:00
2010-10-16 06:40:00
2010-10-29 15:00:00
2010-11-11 23:20:00
2010-11-25 07:40:00
2010-12-08 16:00:00
2010-12-22 00:20:00
2011-01-04 08:40:00
2011-01-17 17:00:00
2011-01-31 01:20:00
2011-02-13 09:40:00
2011-02-26 18:00:00
2011-03-12 02:20:00

สมมติว่าคุณกำลังใช้loggingโมดูลPython คุณสามารถส่งอาร์กิวเมนต์การจัดรูปแบบสตริงเป็นอาร์กิวเมนต์ไปยัง.debug()วิธีการแทนที่จะทำรูปแบบด้วยตัวคุณเอง:

log.debug("some debug info: %s", some_info)

ซึ่งหลีกเลี่ยงการจัดรูปแบบเว้นแต่คนตัดไม้บันทึกสิ่งจริง

ตั้งแต่ Python 3.6 (2016) คุณสามารถใช้f-stringsเพื่อทดแทนตัวแปร:

>>> origin = "London"
>>> destination = "Paris"
>>> f"from {origin} to {destination}"
'from London to Paris'

หมายเหตุf"คำนำหน้า หากคุณลองทำสิ่งนี้ใน Python 3.5 หรือSyntaxErrorเก่ากว่าคุณจะได้รับ

ดูhttps://docs.python.org/3.6/reference/lexical_analysis.html#f-strings

PEP 3101เสนอการแทนที่%โอเปอเรเตอร์ด้วยการจัดรูปแบบสตริงขั้นสูงใหม่ใน Python 3 ซึ่งจะเป็นค่าเริ่มต้น

แต่โปรดระวังตอนนี้ฉันได้ค้นพบปัญหาหนึ่งข้อเมื่อพยายามแทนที่ทั้งหมด%ด้วย.formatรหัสที่มีอยู่: '{}'.format(unicode_string)จะพยายามเข้ารหัส unicode_string และอาจล้มเหลว

เพียงดูบันทึกเซสชันแบบโต้ตอบ Python นี้:

Python 2.7.2 (default, Aug 27 2012, 19:52:55) 
[GCC 4.1.2 20080704 (Red Hat 4.1.2-48)] on linux2
; s='й'
; u=u'й'
; s
'\xd0\xb9'
; u
u'\u0439'

sเป็นเพียงสตริง (เรียกว่า 'byte array' ใน Python3) และuเป็นสตริง Unicode (เรียกว่า 'string' ใน Python3):

; '%s' % s
'\xd0\xb9'
; '%s' % u
u'\u0439'

เมื่อคุณให้วัตถุ Unicode เป็นพารามิเตอร์ให้กับ%โอเปอเรเตอร์มันจะสร้างสตริง Unicode แม้ว่าสตริงเดิมไม่ใช่ Unicode:

; '{}'.format(s)
'\xd0\xb9'
; '{}'.format(u)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
UnicodeEncodeError: 'latin-1' codec can't encode character u'\u0439' in position 0: ordinal not in range(256)

แต่.formatฟังก์ชั่นจะเพิ่ม "UnicodeEncodeError":

; u'{}'.format(s)
u'\xd0\xb9'
; u'{}'.format(u)
u'\u0439'

และมันจะทำงานกับอาร์กิวเมนต์ Unicode ได้ก็ต่อเมื่อสตริงเดิมคือ Unicode

; '{}'.format(u'i')
'i'

หรือถ้าสตริงอาร์กิวเมนต์สามารถแปลงเป็นสตริง (เรียกว่า 'ไบต์อาร์เรย์')

อีกข้อได้เปรียบของ.format(ซึ่งฉันไม่เห็นในคำตอบ): มันสามารถใช้คุณสมบัติของวัตถุ

In [12]: class A(object):
   ....:     def __init__(self, x, y):
   ....:         self.x = x
   ....:         self.y = y
   ....:         

In [13]: a = A(2,3)

In [14]: 'x is {0.x}, y is {0.y}'.format(a)
Out[14]: 'x is 2, y is 3'

หรือเป็นอาร์กิวเมนต์ของคำหลัก:

In [15]: 'x is {a.x}, y is {a.y}'.format(a=a)
Out[15]: 'x is 2, y is 3'

นี่เป็นไปไม่ได้%ที่ฉันจะบอกได้

%ให้ประสิทธิภาพที่ดีกว่าformatจากการทดสอบของฉัน

รหัสทดสอบ:

Python 2.7.2:

import timeit
print 'format:', timeit.timeit("'{}{}{}'.format(1, 1.23, 'hello')")
print '%:', timeit.timeit("'%s%s%s' % (1, 1.23, 'hello')")

ผลลัพธ์:

> format: 0.470329046249
> %: 0.357107877731

Python 3.5.2

import timeit
print('format:', timeit.timeit("'{}{}{}'.format(1, 1.23, 'hello')"))
print('%:', timeit.timeit("'%s%s%s' % (1, 1.23, 'hello')"))

ผลลัพธ์

> format: 0.5864730989560485
> %: 0.013593495357781649

มันดูใน Python2 ความแตกต่างเล็กในขณะที่ Python3 %นั้นเร็วกว่าformatมาก

ขอบคุณ @Chris Cogdon สำหรับตัวอย่างโค้ด

แก้ไข 1:

ทดสอบอีกครั้งใน Python 3.7.2 ในเดือนกรกฎาคม 2019

ผลลัพธ์:

> format: 0.86600608
> %: 0.630180146

มีความแตกต่างไม่มาก ฉันเดาว่า Python กำลังค่อยๆดีขึ้น

แก้ไข 2:

หลังจากมีคนพูดถึง f-string ของ python 3 ในความคิดเห็นฉันได้ทำการทดสอบโค้ดต่อไปนี้ภายใต้ python 3.7.2:

import timeit
print('format:', timeit.timeit("'{}{}{}'.format(1, 1.23, 'hello')"))
print('%:', timeit.timeit("'%s%s%s' % (1, 1.23, 'hello')"))
print('f-string:', timeit.timeit("f'{1}{1.23}{\"hello\"}'"))

ผลลัพธ์:

format: 0.8331376779999999
%: 0.6314778750000001
f-string: 0.766649943

ดูเหมือนว่า F-สตริงยังคงช้ากว่าแต่ดีกว่า%format

ตามที่ฉันค้นพบในวันนี้การจัดรูปแบบสตริงแบบเก่า%ไม่สนับสนุนDecimalโมดูลของ Python สำหรับจุดทศนิยมคงที่และเลขคณิตจุดลอยตัวนอกกรอบ

ตัวอย่าง (โดยใช้ Python 3.3.5):

#!/usr/bin/env python3

from decimal import *

getcontext().prec = 50
d = Decimal('3.12375239e-24') # no magic number, I rather produced it by banging my head on my keyboard

print('%.50f' % d)
print('{0:.50f}'.format(d))

เอาท์พุท:

0.000000000000000000000000000312375239000000009907464850 0.000000000000000000000000000312375239000000000000000000

อาจมีวิธีแก้ปัญหาอย่างแน่นอน แต่คุณยังอาจลองใช้format()วิธีนี้ในทันที

ถ้า python ของคุณ> = 3.6 ฟอร์แมทที่จัดรูปแบบตัวอักษร F คือเพื่อนใหม่ของคุณ

มันง่ายกว่าสะอาดและมีประสิทธิภาพดีกว่า

In [1]: params=['Hello', 'adam', 42]

In [2]: %timeit "%s %s, the answer to everything is %d."%(params[0],params[1],params[2])
448 ns ± 1.48 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)

In [3]: %timeit "{} {}, the answer to everything is {}.".format(*params)
449 ns ± 1.42 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)

In [4]: %timeit f"{params[0]} {params[1]}, the answer to everything is {params[2]}."
12.7 ns ± 0.0129 ns per loop (mean ± std. dev. of 7 runs, 100000000 loops each)

ในฐานะที่เป็นบันทึกย่อด้านข้างคุณไม่จำเป็นต้องใช้ประสิทธิภาพในการจัดรูปแบบรูปแบบใหม่พร้อมการบันทึก คุณสามารถส่งผ่านวัตถุใด ๆ ที่จะlogging.debug, logging.infoฯลฯ ที่ใช้__str__วิธีมายากล เมื่อโมดูลการบันทึกได้ตัดสินใจแล้วว่ามันจะต้องปล่อยวัตถุข้อความของคุณ (ไม่ว่ามันจะเป็นอะไร) มันก็จะเรียกstr(message_object)ก่อนที่จะทำเช่นนั้น ดังนั้นคุณสามารถทำสิ่งนี้:

import logging


class NewStyleLogMessage(object):
    def __init__(self, message, *args, **kwargs):
        self.message = message
        self.args = args
        self.kwargs = kwargs

    def __str__(self):
        args = (i() if callable(i) else i for i in self.args)
        kwargs = dict((k, v() if callable(v) else v) for k, v in self.kwargs.items())

        return self.message.format(*args, **kwargs)

N = NewStyleLogMessage

# Neither one of these messages are formatted (or calculated) until they're
# needed

# Emits "Lazily formatted log entry: 123 foo" in log
logging.debug(N('Lazily formatted log entry: {0} {keyword}', 123, keyword='foo'))


def expensive_func():
    # Do something that takes a long time...
    return 'foo'

# Emits "Expensive log entry: foo" in log
logging.debug(N('Expensive log entry: {keyword}', keyword=expensive_func))

นี่คือทั้งหมดที่อธิบายไว้ในเอกสาร Python 3 ( https://docs.python.org/3/howto/logging-cookbook.html#formatting-styles ) อย่างไรก็ตามมันจะทำงานกับ Python 2.6 ได้เช่นกัน ( https://docs.python.org/2.6/library/logging.html#using-arbitrary-objects-as-messages )

ข้อดีอย่างหนึ่งของการใช้เทคนิคนี้นอกเหนือจากความจริงที่ว่ามันเป็นรูปแบบที่ไม่เชื่อเรื่องพระเจ้าคือมันช่วยให้ค่าที่ขี้เกียจเช่นฟังก์ชั่นexpensive_funcด้านบน นี้เป็นทางเลือกที่สง่างามมากขึ้นในการให้คำแนะนำที่ถูกกำหนดในเอกสารหลามที่นี่: https://docs.python.org/2.6/library/logging.html#optimization

สถานการณ์หนึ่งที่%อาจช่วยได้คือเมื่อคุณจัดรูปแบบนิพจน์ regex ตัวอย่างเช่น,

'{type_names} [a-z]{2}'.format(type_names='triangle|square')

IndexErrorยก ในสถานการณ์นี้คุณสามารถใช้:

'%(type_names)s [a-z]{2}' % {'type_names': 'triangle|square'}

เขียน regex '{type_names} [a-z]{{2}}'เป็นหลีกเลี่ยงนี้ สิ่งนี้มีประโยชน์เมื่อคุณมีสอง regexes โดยที่ใช้เพียงอย่างเดียวโดยไม่มีรูปแบบ แต่การต่อข้อมูลของทั้งสองถูกจัดรูปแบบ

ฉันจะเพิ่มที่ตั้งแต่รุ่น 3.6 เราสามารถใช้ fstrings ดังต่อไปนี้

foo = "john"
bar = "smith"
print(f"My name is {foo} {bar}")

ซึ่งให้

ฉันชื่อจอห์นสมิ ธ

ทุกอย่างถูกแปลงเป็นสตริง

mylist = ["foo", "bar"]
print(f"mylist = {mylist}")

ผลลัพธ์:

mylist = ['foo', 'bar']

คุณสามารถผ่านฟังก์ชั่นเช่นเดียวกับในรูปแบบอื่น ๆ วิธี

print(f'Hello, here is the date : {time.strftime("%d/%m/%Y")}')

ยกตัวอย่างเช่น

สวัสดีนี่คือวันที่: 16/04/2018

สำหรับเวอร์ชัน python> = 3.6 (ดูPEP 498 )

s1='albha'
s2='beta'

f'{s1}{s2:>10}'

#output
'albha      beta'

Python 3.6.7 เปรียบเทียบ:

#!/usr/bin/env python
import timeit

def time_it(fn):
    """
    Measure time of execution of a function
    """
    def wrapper(*args, **kwargs):
        t0 = timeit.default_timer()
        fn(*args, **kwargs)
        t1 = timeit.default_timer()
        print("{0:.10f} seconds".format(t1 - t0))
    return wrapper


@time_it
def new_new_format(s):
    print("new_new_format:", f"{s[0]} {s[1]} {s[2]} {s[3]} {s[4]}")


@time_it
def new_format(s):
    print("new_format:", "{0} {1} {2} {3} {4}".format(*s))


@time_it
def old_format(s):
    print("old_format:", "%s %s %s %s %s" % s)


def main():
    samples = (("uno", "dos", "tres", "cuatro", "cinco"), (1,2,3,4,5), (1.1, 2.1, 3.1, 4.1, 5.1), ("uno", 2, 3.14, "cuatro", 5.5),) 
    for s in samples:
        new_new_format(s)
        new_format(s)
        old_format(s)
        print("-----")


if __name__ == '__main__':
    main()

เอาท์พุท:

new_new_format: uno dos tres cuatro cinco
0.0000170280 seconds
new_format: uno dos tres cuatro cinco
0.0000046750 seconds
old_format: uno dos tres cuatro cinco
0.0000034820 seconds
-----
new_new_format: 1 2 3 4 5
0.0000043980 seconds
new_format: 1 2 3 4 5
0.0000062590 seconds
old_format: 1 2 3 4 5
0.0000041730 seconds
-----
new_new_format: 1.1 2.1 3.1 4.1 5.1
0.0000092650 seconds
new_format: 1.1 2.1 3.1 4.1 5.1
0.0000055340 seconds
old_format: 1.1 2.1 3.1 4.1 5.1
0.0000052130 seconds
-----
new_new_format: uno 2 3.14 cuatro 5.5
0.0000053380 seconds
new_format: uno 2 3.14 cuatro 5.5
0.0000047570 seconds
old_format: uno 2 3.14 cuatro 5.5
0.0000045320 seconds
-----

แต่สิ่งหนึ่งก็คือถ้าคุณมีเครื่องหมายปีกกาแบบซ้อนอยู่ด้วยจะไม่สามารถใช้รูปแบบได้ แต่%จะใช้งานได้

ตัวอย่าง:

>>> '{{0}, {1}}'.format(1,2)
Traceback (most recent call last):
  File "<pyshell#3>", line 1, in <module>
    '{{0}, {1}}'.format(1,2)
ValueError: Single '}' encountered in format string
>>> '{%s, %s}'%(1,2)
'{1, 2}'
>>>