Định dạng chuỗi:% so với .format

Python 2.6 đã giới thiệu str.format()phương thức với cú pháp hơi khác so với %toán tử hiện có . Cái nào tốt hơn và cho tình huống nào?

1. Sau đây sử dụng từng phương pháp và có cùng kết quả, vậy sự khác biệt là gì?

   #!/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. Hơn nữa khi định dạng chuỗi xảy ra trong Python? Ví dụ: nếu mức ghi nhật ký của tôi được đặt thành CAO thì tôi vẫn sẽ nhấn để thực hiện %thao tác sau chứ? Và nếu vậy, có cách nào để tránh điều này?

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

Để trả lời câu hỏi đầu tiên của bạn ... .formatcó vẻ phức tạp hơn theo nhiều cách. Một điều khó chịu %cũng là làm thế nào nó có thể mất một biến hoặc một tuple. Bạn sẽ nghĩ rằng những điều sau đây sẽ luôn hoạt động:

"hi there %s" % name

Tuy nhiên, nếu namexảy ra (1, 2, 3), nó sẽ ném a TypeError. Để đảm bảo rằng nó luôn được in, bạn cần phải làm

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

mà chỉ là xấu xí. .formatkhông có những vấn đề đó Cũng trong ví dụ thứ hai bạn đưa ra, .formatví dụ này trông gọn gàng hơn nhiều.

Tại sao bạn không sử dụng nó?

• không biết về nó (tôi trước khi đọc nó)
• phải tương thích với Python 2.5

Để trả lời câu hỏi thứ hai của bạn, định dạng chuỗi xảy ra cùng lúc với mọi thao tác khác - khi biểu thức định dạng chuỗi được ước tính. Và Python, không phải là một ngôn ngữ lười biếng, đánh giá các biểu thức trước khi gọi các hàm, vì vậy trong log.debugví dụ của bạn , biểu thức "some debug info: %s"%some_infotrước tiên sẽ đánh giá, ví dụ "some debug info: roflcopters are active", sau đó chuỗi đó sẽ được chuyển đến log.debug().

Một cái gì đó mà toán tử modulo (%) không thể làm được, afaik:

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

kết quả

12 22222 45 22222 103 22222 6 22222

Rất hữu ích.

Một điểm khác : format(), là một hàm, có thể được sử dụng làm đối số trong các hàm khác:

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))

Kết quả trong:

['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

Giả sử bạn đang sử dụng loggingmô-đun của Python , bạn có thể chuyển các đối số định dạng chuỗi dưới dạng đối số cho .debug()phương thức thay vì tự định dạng:

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

mà tránh thực hiện định dạng trừ khi logger thực sự ghi nhật ký một cái gì đó.

Kể từ Python 3.6 (2016), bạn có thể sử dụng chuỗi f để thay thế các biến:

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

Lưu ý f"tiền tố. Nếu bạn thử điều này trong Python 3.5 hoặc sớm hơn, bạn sẽ nhận được SyntaxError.

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

PEP 3101 đề xuất thay thế %toán tử bằng định dạng chuỗi mới, nâng cao trong Python 3, trong đó nó sẽ là mặc định.

Nhưng hãy cẩn thận, vừa rồi tôi đã phát hiện ra một vấn đề khi cố gắng thay thế tất cả %bằng .formatmã hiện có: '{}'.format(unicode_string)sẽ cố mã hóa unicode_ chuỗi và có thể sẽ thất bại.

Chỉ cần nhìn vào nhật ký phiên tương tác Python này:

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'

schỉ là một chuỗi (được gọi là 'mảng byte' trong Python3) và ulà một chuỗi Unicode (được gọi là 'chuỗi' trong Python3):

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

Khi bạn cung cấp một đối tượng Unicode làm tham số cho %toán tử, nó sẽ tạo ra một chuỗi Unicode ngay cả khi chuỗi ban đầu không phải là 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)

nhưng .formatchức năng sẽ nâng cao "UnicodeEncodeError":

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

và nó sẽ hoạt động tốt với một đối số Unicode chỉ khi chuỗi gốc là Unicode.

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

hoặc nếu chuỗi đối số có thể được chuyển đổi thành một chuỗi (được gọi là 'mảng byte')

Một ưu điểm khác của .format(mà tôi không thấy trong các câu trả lời): nó có thể lấy các thuộc tính đối tượng.

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'

Hoặc, như một đối số từ khóa:

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

Điều này là không thể với %như tôi có thể nói.

%cho hiệu suất tốt hơn so với formatthử nghiệm của tôi.

Mã kiểm tra:

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')")

Kết quả:

> 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')"))

Kết quả

> format: 0.5864730989560485
> %: 0.013593495357781649

Nó nhìn vào Python2, sự khác biệt là nhỏ trong khi trong Python3, %nhanh hơn nhiều format.

Cảm ơn @Chris Cogdon cho mã mẫu.

Chỉnh sửa 1:

Đã thử nghiệm lại trong Python 3.7.2 vào tháng 7 năm 2019.

Kết quả:

> format: 0.86600608
> %: 0.630180146

Không có nhiều khác biệt. Tôi đoán Python đang dần cải thiện.

Chỉnh sửa 2:

Sau khi ai đó đề cập đến chuỗi f của python 3 trong bình luận, tôi đã thực hiện kiểm tra mã sau theo 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\"}'"))

Kết quả:

format: 0.8331376779999999
%: 0.6314778750000001
f-string: 0.766649943

Có vẻ như f-string vẫn chậm hơn %nhưng tốt hơn format.

Như tôi đã khám phá ngày nay, cách định dạng cũ của các chuỗi thông qua %không hỗ trợ Decimal, mô-đun của Python cho số học điểm cố định thập phân và số học dấu phẩy động, ra khỏi hộp.

Ví dụ (sử dụng 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))

Đầu ra:

0,0000000000000000000000000312375239000000009907464850 0,0000000000000000000000000312375239000000000000000000

Chắc chắn có thể có cách giải quyết nhưng bạn vẫn có thể cân nhắc sử dụng format()phương pháp ngay lập tức.

Nếu python của bạn> = 3.6, chuỗi F được định dạng bằng chữ là người bạn mới của bạn.

Nó đơn giản hơn, sạch sẽ hơn và hiệu suất tốt hơn.

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)

Là một lưu ý phụ, bạn không cần phải thực hiện một cú đánh hiệu suất để sử dụng định dạng kiểu mới với ghi nhật ký. Bạn có thể vượt qua bất kỳ đối tượng logging.debug, logging.infovv mà thực hiện các __str__phương pháp kỳ diệu. Khi mô-đun đăng nhập đã quyết định rằng nó phải phát ra đối tượng tin nhắn của bạn (bất kể đó là gì), nó sẽ gọi str(message_object)trước khi thực hiện. Vì vậy, bạn có thể làm một cái gì đó như thế này:

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))

Đây là tất cả được mô tả trong tài liệu Python 3 ( https://docs.python.org/3/howto/logging-cookbook.html#formatted-styles ). Tuy nhiên, nó cũng sẽ hoạt động với Python 2.6 ( https://docs.python.org/2.6/l Library / global.html #USE-arbitrary-objects-as- messages ).

Một trong những lợi thế của việc sử dụng kỹ thuật này, ngoài thực tế là thuyết bất khả tri kiểu định dạng, là nó cho phép các giá trị lười biếng, ví dụ như hàm expensive_functrên. Điều này cung cấp một giải pháp thay thế thanh lịch hơn cho lời khuyên được đưa ra trong các tài liệu Python tại đây: https://docs.python.org/2.6/l Library / loggging.html # optimization .

Một tình huống %có thể giúp là khi bạn định dạng biểu thức regex. Ví dụ,

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

tăng IndexError. Trong tình huống này, bạn có thể sử dụng:

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

Điều này tránh viết regex như '{type_names} [a-z]{{2}}'. Điều này có thể hữu ích khi bạn có hai biểu thức chính, trong đó một biểu thức được sử dụng một mình mà không có định dạng, nhưng phần nối của cả hai được định dạng.

Tôi sẽ thêm rằng kể từ phiên bản 3.6, chúng ta có thể sử dụng fstrings như sau

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

Đưa ra

Tôi tên là John

Mọi thứ được chuyển đổi thành chuỗi

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

Kết quả:

mylist = ['foo', 'bar']

bạn có thể truyền hàm, giống như trong các định dạng khác

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

Cho ví dụ

Xin chào, đây là ngày: 16/04/2018

Đối với phiên bản python> = 3.6 (xem PEP 498 )

s1='albha'
s2='beta'

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

#output
'albha      beta'

Python 3.6.7 so sánh:

#!/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()

Đầu ra:

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
-----

Nhưng có một điều là nếu bạn có niềng răng lồng nhau, sẽ không hoạt động cho định dạng nhưng %sẽ hoạt động.

Thí dụ:

>>> '{{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}'
>>>