પાયથોનમાં બહુવિધ રેખાઓ પર ટેક્સ્ટની લાંબી સ્ટ્રીંગ્સ લખવી

જો તમે Python માં flake8 જેવા PEP8 સુસંગત કોડ ચેકરનો ઉપયોગ કરો છો, તો જ્યારે લાઇન 80 અક્ષરો કરતાં વધી જાય ત્યારે તમને નીચેની ભૂલ મળશે.
E501 line too long

હું તમને બતાવીશ કે 80 થી વધુ અક્ષરોની લાંબી સ્ટ્રિંગને કેવી રીતે વિભાજીત કરવી, જેમ કે URL, કોડની બહુવિધ રેખાઓમાં.

• બેકસ્લેશ સાથે લાઇન બ્રેક્સને અવગણો (\)
• રેખા વિરામ મુક્તપણે કૌંસમાં બંધ કરી શકાય છે

ઉપરાંત, જો તમે આઉટપુટ કરવા માંગતા હો અને લાંબા તારોને લપેટીને અથવા સંક્ષિપ્ત કરીને દર્શાવવા માંગતા હોવ તો ટેક્સ્ટવ્રેપ મોડ્યુલ ઉપયોગી છે.

જો લાઇનમાં અક્ષરોની સંખ્યા લાંબી સ્ટ્રિંગ કરતાં પદ્ધતિની સાંકળમાં લાંબી હોય, તો કોડમાં પણ લાઇન તૂટી શકે છે.

બેકસ્લેશ સાથે લાઇન બ્રેક્સને અવગણો (\)

પાયથોનમાં, બેકસ્લેશ (\) એ ચાલુ રાખવાનું પાત્ર છે, અને જ્યારે લીટીના અંતે મૂકવામાં આવે છે, ત્યારે તે અનુગામી લાઇન બ્રેક્સને અવગણે છે અને ધારે છે કે લીટી ચાલુ છે.

n = 1 + 2 \
    + 3

print(n)
# 6

ઉપરાંત, જ્યારે બહુવિધ શબ્દમાળાના શાબ્દિક અનુગામી લખવામાં આવે છે, ત્યારે તેઓ નીચે બતાવ્યા પ્રમાણે એક જ શબ્દમાળા રચવા માટે સંકલિત થાય છે.

s = 'aaa' 'bbb'

print(s)
# aaabbb

બેને સંયોજિત કરીને, નીચે બતાવ્યા પ્રમાણે, કોડની બહુવિધ રેખાઓમાં લાંબી સ્ટ્રિંગ લખી શકાય છે.

s = 'https://wikipedia.org/wiki/'\
    '%E3%83%97%E3%83%AD%E3%82%B0%E3%83'\
    '%A9%E3%83%9F%E3%83%B3%E3%82%B0%E8%A8%80%E8%AA%9E'

print(s)
# https://wikipedia.org/wiki/%E3%83%97%E3%83%AD%E3%82%B0%E3%83%A9%E3%83%9F%E3%83%B3%E3%82%B0%E8%A8%80%E8%AA%9E

નોંધ કરો કે માત્ર શબ્દમાળાના શાબ્દિક (‘ અથવા “”માં બંધ) જોડી શકાય છે, અને શબ્દમાળાઓ ધરાવતા ચલો ભૂલમાં પરિણમશે.

s_var = 'xxx'

# s = 'aaa' s_var 'bbb'
# SyntaxError: invalid syntax

ચલોને એકબીજા સાથે અથવા ચલોને શબ્દમાળામાં જોડવા માટે, + ઓપરેટરનો ઉપયોગ કરો.

s = 'aaa' + s_var + 'bbb'

print(s)
# aaaxxxbbb

બેકસ્લેશ (\) દ્વારા અલગ કરવામાં આવે ત્યારે પણ, + ઓપરેટરને ચલોને જોડવા માટે જરૂરી છે.

s = 'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa'\
    + s_var\
    + 'bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb'

print(s)
# aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaxxxbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb

રેખા વિરામ મુક્તપણે કૌંસમાં બંધ કરી શકાય છે

પાયથોનમાં, તમે નીચેના કૌંસમાં મુક્તપણે રેખાઓ તોડી શકો છો. તમે આ નિયમનો ઉપયોગ કૌંસમાં લખાણની લાંબી સ્ટ્રીંગને બંધ કરવા માટે કરી શકો છો.

• ()
• {}
• []

નોંધ કરો કે નીચેના કૌંસનો અર્થ છે.

• {} = set
• [] = list

આ કારણોસર, બહુવિધ રેખાઓ પર લાંબી સ્ટ્રિંગ લખતી વખતે રાઉન્ડ કૌંસ () નો ઉપયોગ કરો.

ફરીથી, એ હકીકતનો ઉપયોગ કરીને કે એક જ શબ્દમાળા બનાવવા માટે બહુવિધ તારોને એકસાથે જોડી શકાય છે, અમે નીચે લખી શકીએ છીએ

s = ('https://wikipedia.org/wiki/'
     '%E3%83%97%E3%83%AD%E3%82%B0%E3%83'
     '%A9%E3%83%9F%E3%83%B3%E3%82%B0%E8%A8%80%E8%AA%9E')

print(s)
# https://wikipedia.org/wiki/%E3%83%97%E3%83%AD%E3%82%B0%E3%83%A9%E3%83%9F%E3%83%B3%E3%82%B0%E8%A8%80%E8%AA%9E

જેમ કે બેકસ્લેશ સાથેના ઉદાહરણમાં, જ્યારે વેરીએબલનો સમાવેશ કરવામાં આવે ત્યારે + ઓપરેટર જરૂરી છે.

s = ('aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa'
     + s_var
     + 'bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb')

print(s)
# aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaxxxbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb