පයිතන් නූල්වල වචනාර්ථයෙන් කැරලි-වරහන් අක්ෂර මුද්‍රණය කර එය මත ආකෘති භාවිතා කරන්නේ කෙසේද?

x = " \{ Hello \} {0} "
print(x.format(42))

මට ලබා දෙයි: Key Error: Hello\\

මට ප්‍රතිදානය මුද්‍රණය කිරීමට අවශ්‍යයි: {Hello} 42

ඔබ දෙගුණ කළ යුතු {{අතර }}:

>>> x = " {{ Hello }} {0} "
>>> print(x.format(42))
' { Hello } 42 '

හැඩතල සින්ටැක්ස් සඳහා පයිතන් ප්‍රලේඛනයේ අදාළ කොටස මෙන්න :

ආකෘති නූල් වල කැරලි වරහන් වලින් වට වූ “ආදේශන ක්ෂේත්‍ර” අඩංගු වේ {}. වරහන් වල අඩංගු නොවන ඕනෑම දෙයක් වචනාර්ථයෙන් පෙළ ලෙස සලකනු ලබන අතර එය ප්‍රතිදානයට නොවෙනස්ව පිටපත් වේ. ඔබට වචනයේ පරිසමාප්ත අර්ථයෙන්ම ඇතුළත් කිරීමට අවශ්‍ය නම්, එය දෙගුණ කිරීමෙන් ගැලවිය හැකිය: {{සහ }}.

වරහන් දෙගුණ කිරීමෙන් ඔබ එයින් ගැලවී යයි.

උදා:

x = "{{ Hello }} {0}"
print(x.format(42))

පයිතන් 3.6+ (2017)

පයිතන්ගේ මෑත සංස්කරණ වලදී යමෙක් f-string භාවිතා කරයි ( PEP498 ද බලන්න ).

F-string සමඟ යමෙකු දෙවරක් {{හෝ භාවිතා කළ යුතුය}}

n = 42  
print(f" {{Hello}} {n} ")

අපේක්ෂිත නිෂ්පාදනය කරයි

 {Hello} 42

වචනාර්ථයෙන් පෙළ භාවිතා කිරීම වෙනුවට වරහන් තුළ ප්‍රකාශනයක් නිරාකරණය කිරීමට ඔබට අවශ්‍ය නම් ඔබට වරහන් තුනක් අවශ්‍ය වේ:

hello = "HELLO"
print(f"{{{hello.lower()}}}")

නිෂ්පාදනය කරයි

{hello}

OP මෙම අදහස ලිවීය:

මම මේ වගේ සමහර අරමුණු සඳහා කුඩා JSON එකක් ආකෘතිකරණය කිරීමට උත්සාහ කළා: '{"all": false, "selected": "{}"}'.format(data)එවැනි දෙයක් ලබා ගැනීමට{"all": false, "selected": "1,2"}

JSON සමඟ ගනුදෙනු කිරීමේදී "පැන යාමේ වරහන්" ගැටළුව ඇතිවීම සාමාන්‍ය දෙයකි.

මෙය කිරීමට මම යෝජනා කරමි:

import json
data = "1,2"
mydict = {"all": "false", "selected": data}
json.dumps(mydict)

එය විකල්පයට වඩා පිරිසිදු ය, එනම්:

'{{"all": false, "selected": "{}"}}'.format(data)

jsonඋදාහරණයට වඩා JSON නූල වඩාත් සංකීර්ණ වූ විට පුස්තකාලය භාවිතා කිරීම වඩාත් සුදුසුය.

මෙය කිරීමට උත්සාහ කරන්න:

x = " {{ Hello }} {0} "
print x.format(42)

මේක උත්සාහ කරන්න:

x = "{{ Hello }} {0}"

වඩා හොඳ නොවුනත්, යොමු කිරීම සඳහා පමණක් ඔබට මෙය කළ හැකිය:

>>> x = '{}Hello{} {}'
>>> print x.format('{','}',42)
{Hello} 42

යමෙකුට මුද්‍රණය කිරීමට අවශ්‍ය වූ විට එය ප්‍රයෝජනවත් වේ {argument}. එය වඩා කියවිය හැකි ය'{{{}}}'.format('argument')

පයිතන් 2.7 න් පසු ඔබ තර්ක ස්ථාන (උදා {}වෙනුවට {0}) අතහැර දමා ඇති බව සලකන්න

ඔබ මෙය බොහෝ දේ කිරීමට යන්නේ නම්, ඒ වෙනුවට අත්තනෝමතික වරහන් ආදේශක භාවිතා කිරීමට ඔබට ඉඩ සලසන උපයෝගිතා ශ්‍රිතයක් නිර්වචනය කිරීම හොඳ විය හැකිය.

def custom_format(string, brackets, *args, **kwargs):
    if len(brackets) != 2:
        raise ValueError('Expected two brackets. Got {}.'.format(len(brackets)))
    padded = string.replace('{', '{{').replace('}', '}}')
    substituted = padded.replace(brackets[0], '{').replace(brackets[1], '}')
    formatted = substituted.format(*args, **kwargs)
    return formatted

>>> custom_format('{{[cmd]} process 1}', brackets='[]', cmd='firefox.exe')
'{{firefox.exe} process 1}'

මෙය වරහන් 2 දිගකින් හෝ නූල් දෙකකින් (බහු-අක්ෂර පරිසීමක සඳහා) නැවත ක්‍රියා කළ හැකි බව සලකන්න.

ඔබට නූල් වල කරකැවෙන වරහන් දෙකක් තබා ගැනීමට අවශ්‍ය නම්, විචල්යයේ සෑම පැත්තකින්ම කැරලි වරහන් 5 ක් අවශ්ය වේ.

>>> myvar = 'test'
>>> "{{{{{0}}}}}".format(myvar)
'{{test}}'

පෙර සැකසූ JSON වෙත නූල් එන්නත් කිරීමට මට අවශ්‍ය වූ නිසා මම මෑතකදී මේ වෙත දිව ගියෙමි. මගේ විසඳුම වූයේ මේ වගේ උපකාරක ක්‍රමයක් නිර්මාණය කිරීමයි:

def preformat(msg):
    """ allow {{key}} to be used for formatting in text
    that already uses curly braces.  First switch this into
    something else, replace curlies with double curlies, and then
    switch back to regular braces
    """
    msg = msg.replace('{{', '<<<').replace('}}', '>>>')
    msg = msg.replace('{', '{{').replace('}', '}}')
    msg = msg.replace('<<<', '{').replace('>>>', '}')
    return msg

එවිට ඔබට මෙවැනි දෙයක් කළ හැකිය:

formatted = preformat("""
    {
        "foo": "{{bar}}"
    }""").format(bar="gas")

කාර්ය සාධනය ගැටලුවක් නොවේ නම් සිදු කරන ලද කාර්යය ලබා ගනී.

හේතුව නම්, ඔබේ නඩුවේ {}වාක්‍ය ඛණ්ඩය හඳුනා නොගැනීම නිසා එය දෝෂයක් ඇතිවිය..format().format(){Hello}

ද්විත්ව වක්‍ර වරහන් {{} using භාවිතා කිරීමෙන් ඔබට එය අභිබවා යා හැකිය.

x = " {{ Hello }} {0} "

හෝ

%sපෙළ හැඩතල ගැන්වීමට උත්සාහ කරන්න ,

x = " { Hello } %s"
print x%(42)  

පෙළ මුද්‍රණය කිරීමට උත්සාහ කරන විට මම මෙම ගැටළුවට බාධා කළෙමි. මම මෙම පිළිතුර දීර් extend කර නම් කරන ලද ආදේශන ක්ෂේත්‍ර භාවිතා කරමි:

ලැටෙක්ස් හි වැනි දර්ශක සහිත බහු විචල්‍ය විචල්‍යයන්ගේ නිෂ්පාදනයක් මුද්‍රණය කිරීමට ඔබට අවශ්‍ය යැයි කියමු. $A_{ 0042 }*A_{ 3141 }*A_{ 2718 }*A_{ 0042 }$ පහත දැක්වෙන කේතය නම් කරන ලද ක්ෂේත්‍ර සමඟ කටයුතු කරයි, එවිට බොහෝ දර්ශක සඳහා එය කියවිය හැකි ය:

idx_mapping = {'i1':42, 'i2':3141, 'i3':2178 }
print('$A_{{ {i1:04d} }} * A_{{ {i2:04d} }} * A_{{ {i3:04d} }} * A_{{ {i1:04d} }}$'.format(**idx_mapping))

ඔබට එක් රැලි වරහනක් පමණක් මුද්‍රණය කිරීමට අවශ්‍ය නම් (නිදසුනක් ලෙස {) ඔබට භාවිතා කළ හැකි අතර {{, ඔබට අවශ්‍ය නම් පසුව තවත් වරහන් එකතු කළ හැකිය. උදාහරණයක් වශයෙන්:

>>> f'{{ there is a curly brace on the left. Oh, and 1 + 1 is {1 + 1}'
'{ there is a curly brace on the left. Oh, and 1 + 1 is 2'

ඔබ කේත නූල් අන්තර්ග්‍රහණය කිරීමට උත්සාහ කරන විට , පයිතන් සඳහා අංග සම්පූර්ණ අච්චු එන්ජිමක් වන ජින්ජා 2 භාවිතා කිරීමට මම යෝජනා කරමි , එනම්:

from jinja2 import Template

foo = Template('''
#include <stdio.h>

void main() {
    printf("hello universe number {{number}}");
}
''')

for i in range(2):
    print(foo.render(number=i))

අනෙක් පිළිතුරු සමූහය යෝජනා කරන පරිදි රැලි වරහන් අනුපිටපත් කිරීමට ඔබට බල කෙරෙන්නේ නැත

F-string හි රැලි සහිත වරහන් වලින් ගැලවීමට ගැලවීමේ අනුක්‍රම භාවිතා කරන්න. උදා: මුද්‍රණය කරන්න (f '{a = {1}}')

අමු නූල් ක්‍රමය භාවිතා කිරීමෙන් ඔබට මෙය කළ හැකිය.

# to print '{I am inside braces}'
print(r'{I am inside braces}')