නූල් හැඩතල ගැන්වීම:% එදිරිව. ආකෘතිය

පයිතන් 2.6 මෙම str.format()ක්‍රමය හඳුන්වා දුන්නේ පවතින %ක්‍රියාකරුට වඩා තරමක් වෙනස් සින්ටැක්ස් සමඟිනි . වඩා හොඳ කුමක්ද සහ කුමන තත්වයන් සඳහාද?

1. පහත දැක්වෙන්නේ එක් එක් ක්‍රමය භාවිතා කරන අතර එකම ප්‍රති come ලය ඇත, එබැවින් වෙනස කුමක්ද?

   #!/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. පයිතන් හි නූල් හැඩතල ගැන්වීම සිදු වන්නේ කවදාද? උදාහරණයක් ලෙස, මගේ ල ging ු-සටහන් මට්ටම ඉහළ මට්ටමකට සකසා ඇත්නම්, පහත දැක්වෙන %මෙහෙයුම සිදු කිරීම සඳහා මම තවමත් පහරක් ගන්නවාද? එසේ නම්, මෙය වළක්වා ගැනීමට ක්‍රමයක් තිබේද?

   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උදාහරණය වඩා පිරිසිදු පෙනුමකි.

ඔබ එය භාවිතා නොකරන්නේ ඇයි?

• ඒ ගැන නොදැන (මෙය කියවීමට පෙර මා)
• පයිතන් 2.5 සමඟ අනුකූල විය යුතුය

ඔබගේ දෙවන ප්‍රශ්නයට පිළිතුරු සැපයීම සඳහා, නූල් හැඩතල ගැන්වීම සිදුවන්නේ වෙනත් ඕනෑම මෙහෙයුමකට සමගාමීවය - නූල් හැඩතල ගැන්වීමේ ප්‍රකාශනය ඇගයීමට ලක් කළ විට. හා Python, ක්රියාත්මක කරවීම පෙර කම්මැලි භාෂාව, ඇගයීමට ප්රකාශන නොහැකි වීම, ඒ නිසා ඔබේ log.debugඋදාහරණයක් ලෙස, අදහස් ප්රකාශ "some debug info: %s"%some_infoකිරීමට පළමුව, උදා: බලනු ඇත "some debug info: roflcopters are active"පසුව string සම්මත කරගත යුතු බව, log.debug().

මොඩියුලෝ ක්‍රියාකරුට (%) කළ නොහැකි දෙයක්, 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))

ප්‍රති Results ල:

['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මොඩියුලය භාවිතා කරයි යැයි උපකල්පනය කිරීමෙන් , ඔබට .debug()ආකෘතිකරණය ඔබම කරනවාට වඩා ක්‍රමයට තර්ක ලෙස නූල් ආකෘතිකරණ තර්ක ඉදිරිපත් කළ හැකිය :

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

ලොගර් ඇත්ත වශයෙන්ම යමක් ලොග් නොකළහොත් එය ආකෘතිකරණය කිරීමෙන් වළක්වයි.

පයිතන් 3.6 (2016) වන විට ඔබට විචල්‍යයන් ආදේශ කිරීම සඳහා f-string භාවිතා කළ හැකිය :

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

f"උපසර්ගය සටහන් කරන්න . ඔබ මෙය පයිතන් 3.5 හෝ ඊට පෙර උත්සාහ කළහොත් ඔබට ලැබෙනු ඇත SyntaxError.

Https://docs.python.org/3.6/reference/lexical_analysis.html#f-strings බලන්න

PEP 3101 යෝජනා කරන්නේ %ක්‍රියාකරු වෙනුවට නව, උසස් නූල් හැඩතල ගැන්වීම පයිතන් 3 හි ඇති අතර එය පෙරනිමිය වනු ඇත.

එහෙත් ප්රවේසම් වන්න, මේ දැන් මම එක ප්රශ්නයක් විස්ථාපනය කිරීමට උත්සාහ කරන විට සොයා තියෙනවා %සමග .formatපවතින කේතය දී: '{}'.format(unicode_string)ආවරණ unicode_string කිරීමට උත්සාහ කරනු ඇත හා සමහර විට අසමත් වනු ඇත.

මෙම පයිතන් අන්තර්ක්‍රියාකාරී සැසි ලොගය දෙස බලන්න:

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එය නූලක් පමණි (පයිතන් 3 හි 'බයිට් අරා' ලෙස හැඳින්වේ) සහ uඑය යුනිකෝඩ් නූලකි (පයිතන් 3 හි 'නූල්' ලෙස හැඳින්වේ):

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

ඔබ යුනිකෝඩ් වස්තුවක් %ක්‍රියාකරුට පරාමිතියක් ලෙස ලබා දුන් විට එය යුනිකෝඩ් නූලක් නිපදවනු ඇත.

; '{}'.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ශ්‍රිතය "යුනිකෝඩ් එන්කෝඩ් දෝෂය" මතු කරයි:

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

එය යුනිකෝඩ් තර්ක දඩයක් සමඟ ක්‍රියා කරනුයේ මුල් නූල යුනිකෝඩ් නම් පමණි.

; '{}'.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මගේ පරීක්ෂණයට වඩා හොඳ කාර්ය සාධනයක් ලබා දෙයි .

පරීක්ෂණ කේතය:

පයිතන් 2.7.2:

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

ප්‍රති ult ලය:

> format: 0.470329046249
> %: 0.357107877731

පයිතන් 3.5.2

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

ප්‍රති ult ලය

> format: 0.5864730989560485
> %: 0.013593495357781649

එය Python2 හි පෙනේ, වෙනස කුඩා වන අතර Python3 හි %වඩා වේගවත් වේ format.

නියැදි කේතය සඳහා ක්‍රිස් කොග්ඩන්ට ස්තූතියි.

සංස්කරණය 1:

2019 ජූලි මාසයේදී පයිතන් 3.7.2 හි නැවත පරීක්ෂා කරන ලදී.

ප්‍රති ult ලය:

> format: 0.86600608
> %: 0.630180146

එතරම් වෙනසක් නැත. මම හිතන්නේ පයිතන් ක්‍රමයෙන් දියුණු වෙනවා.

සංස්කරණය 2:

යමෙකු අදහස් දැක්වීමේදී පයිතන් 3 හි එෆ්-ස්ට්‍රිං සඳහන් කළ පසු, මම පහත සඳහන් කේතය සඳහා පයිතන් 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\"}'"))

ප්‍රති ult ලය:

format: 0.8331376779999999
%: 0.6314778750000001
f-string: 0.766649943

එෆ්-ස්ට්‍රිං තවමත් වඩා මන්දගාමී %නමුත් වඩා හොඳ බව පෙනේ format.

මම අද සොයාගත් පරිදි, නූල් ආකෘතිගත කිරීමේ පැරණි ක්‍රමයට %සහය නොදක්වයි Decimal, දශම ස්ථාවර ලක්ෂ්‍යය සහ පාවෙන ලක්ෂ්‍ය අංක ගණිතය සඳහා වන පයිතන්ගේ මොඩියුලය කොටුවෙන් පිටත.

උදාහරණය (පයිතන් 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.000000000000000000000312375239000000009907464850 0.0000000000000000000003123752390000000000000000

නිසැකවම වැඩ වටපිටාවක් තිබිය හැකි නමුත් ඔබ තවමත් එම format()ක්‍රමය භාවිතා කිරීම ගැන සලකා බැලිය හැකිය .

ඔබේ python> = 3.6 නම්, F-string හැඩතල ගැන්වූ වචනාර්ථය ඔබේ නව මිතුරා වේ.

එය වඩාත් සරල, පිරිසිදු හා වඩා හොඳ කාර්ය සාධනයකි.

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)

පැති සටහනක් ලෙස, ල ging ු-සටහන් සමඟ නව විලාසිතාවේ හැඩතල ගැන්වීම සඳහා කාර්ය සාධන පහරක් ගත යුතු නැත. ඔබට ඕනෑම වස්තුවක් උරුම විය හැකි logging.debug, logging.infoවන ක්රියාත්මක කරන ආදිය, __str__මැජික් ක්රමය. ල ging ු-සටහන් මොඩියුලය එය ඔබගේ පණිවිඩ වස්තුව විමෝචනය කළ යුතු යැයි තීරණය කළ විට (එය කුමක් වුවත්), 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))

මේ සියල්ල පයිතන් 3 ප්‍රලේඛනයේ ( https://docs.python.org/3/howto/logging-cookbook.html#formatting-styles ) විස්තර කර ඇත . කෙසේ වෙතත්, එය පයිතන් 2.6 සමඟ ද ක්‍රියා කරයි ( https://docs.python.org/2.6/library/logging.html#using-arbitrary-objects-as-messages ).

මෙම තාක්ෂණය භාවිතා කිරීමේ එක් වාසියක් නම්, එය හැඩතල ගැන්වීමේ ශෛලමය අ nost ෙයවාදියා හැරුණු විට, එය කම්මැලි අගයන්ට ඉඩ දීමයි expensive_func. මෙහි පයිතන් ලේඛනයේ දී ඇති උපදෙස් වලට මෙය වඩාත් අලංකාර විකල්පයක් සපයයි: https://docs.python.org/2.6/library/logging.html#optimization .

%ඔබ රීජෙක්ස් ප්‍රකාශන සංයුති කරන විට උදව් විය හැකි එක් අවස්ථාවක් . උදාහරණයක් වශයෙන්,

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

මතු කරයි IndexError. මෙම තත්වය තුළ, ඔබට භාවිතා කළ හැකිය:

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

මෙය රීජෙක්ස් ලෙස ලිවීම වළක්වයි '{type_names} [a-z]{{2}}'. ඔබට රීජෙක්ස් දෙකක් ඇති විට මෙය ප්‍රයෝජනවත් විය හැකිය, එහිදී එකක් ආකෘතියකින් තොරව තනිවම භාවිතා වේ, නමුත් දෙකෙහිම සංයුක්තකරණය සංයුති කර ඇත.

3.6 අනුවාදයේ සිට අපට පහත සඳහන් පරිදි fstrings භාවිතා කළ හැකි බව මම එකතු කරමි

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

දෙන

මගේ නම ජෝන් ස්මිත්

සෑම දෙයක්ම නූල් බවට පරිවර්තනය වේ

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

ප්‍රති ult ලය:

mylist = ['foo', 'bar']

අනෙක් ආකාර ආකෘති ක්‍රමය මෙන් ඔබට ශ්‍රිතය සමත් විය හැකිය

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

උදාහරණයක් ලෙස දීම

හෙලෝ, මෙන්න දිනය: 16/04/2018

පයිතන් අනුවාදය සඳහා> = 3.6 ( PEP 498 බලන්න )

s1='albha'
s2='beta'

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

#output
'albha      beta'

පයිතන් 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}'
>>>