പൈത്തണിലെ ഒരു പുതിയ വരിയിലേക്ക് വാചകത്തിന്റെ വിവർത്തനം. ഒരു പുതിയ വരിയിലേക്ക് ടെക്സ്റ്റ് എങ്ങനെ നീക്കാം - നിർദ്ദേശങ്ങൾ

പൈത്തണിൽ, ഒരു വരിയുടെ അവസാനം അടയാളപ്പെടുത്താനും പുതിയത് ആരംഭിക്കാനും, നിങ്ങൾ ഒരു പ്രത്യേക പ്രതീകം ഉപയോഗിക്കേണ്ടതുണ്ട്. അതേ സമയം, വിവിധ പൈത്തൺ ഫയലുകൾക്കൊപ്പം പ്രവർത്തിക്കുമ്പോൾ അത് എങ്ങനെ ശരിയായി ഉപയോഗിക്കണമെന്ന് അറിയേണ്ടത് പ്രധാനമാണ്, ആവശ്യമായ നിമിഷങ്ങളിൽ കൺസോളിൽ പ്രദർശിപ്പിക്കുക. പ്രോഗ്രാം കോഡുമായി പ്രവർത്തിക്കുമ്പോൾ പുതിയ ലൈനുകൾക്കായി ഡിലിമിറ്റർ എങ്ങനെ ഉപയോഗിക്കണമെന്ന് വിശദമായി മനസ്സിലാക്കേണ്ടത് ആവശ്യമാണ്, അത് ഉപയോഗിക്കാതെ ടെക്സ്റ്റ് ചേർക്കാൻ കഴിയുമോ.

പുതിയ ലൈൻ പ്രതീകത്തെക്കുറിച്ചുള്ള പൊതുവായ വിവരങ്ങൾ

ഒരു പുതിയ വരിയിൽ വിവരങ്ങൾ പൊതിയുന്നതിനും പൈത്തണിലെ പഴയ ലൈൻ അടയ്ക്കുന്നതിനുമുള്ള ചിഹ്നമാണ് n. ഈ ചിഹ്നത്തിൽ രണ്ട് ഘടകങ്ങൾ അടങ്ങിയിരിക്കുന്നു:

• റിവേഴ്സ് ചരിഞ്ഞ;
• n ഒരു ചെറിയ അക്ഷരമാണ്.

ഈ പ്രതീകം ഉപയോഗിക്കുന്നതിന്, നിങ്ങൾക്ക് "print(f" HellonWorld!")" എന്ന പദപ്രയോഗം ഉപയോഗിക്കാം, അതിനാൽ നിങ്ങൾക്ക് f-ലൈനുകളിൽ വിവരങ്ങൾ കൈമാറാൻ കഴിയും.

പ്രിന്റ് ഫംഗ്ഷൻ എന്താണ്

അധിക ക്രമീകരണങ്ങൾ ഇല്ലാതെ, അടുത്ത വരിയിലേക്ക് ഡാറ്റ ട്രാൻസ്ഫർ പ്രതീകം മറഞ്ഞിരിക്കുന്ന മോഡിൽ ചേർക്കുന്നു. ഇക്കാരണത്താൽ, ഒരു നിശ്ചിത പ്രവർത്തനം സജീവമാക്കാതെ വരികൾക്കിടയിൽ ഇത് കാണാൻ കഴിയില്ല. പ്രോഗ്രാം കോഡിൽ ഒരു സെപ്പറേറ്റർ ഐക്കൺ പ്രദർശിപ്പിക്കുന്നതിനുള്ള ഒരു ഉദാഹരണം:

പ്രിന്റ് ചെയ്യുക ("ഹലോ, വേൾഡ്"!") - "ഹലോ, വേൾഡ്!"n

അതേ സമയം, ഈ കഥാപാത്രത്തിന്റെ അത്തരമൊരു കണ്ടെത്തൽ പൈത്തണിന്റെ അടിസ്ഥാന സവിശേഷതകളിൽ എഴുതിയിരിക്കുന്നു. "പ്രിന്റ്" ഫംഗ്ഷന് "അവസാനം" പരാമീറ്ററിന് ഒരു ഡിഫോൾട്ട് മൂല്യമുണ്ട് - n. അടുത്ത വരികളിലേക്ക് ഡാറ്റ കൈമാറ്റം ചെയ്യുന്നതിനായി വരികളുടെ അവസാനം ഈ പ്രതീകം സജ്ജീകരിച്ചിരിക്കുന്നത് ഈ പ്രവർത്തനത്തിന് നന്ദി. "പ്രിന്റ്" ഫംഗ്ഷന്റെ വിശദീകരണം:

പ്രിന്റ് (*objects, sep=' ', end='n', file=sys.stdout, flush=False)

"പ്രിന്റ്" ഫംഗ്ഷനിൽ നിന്നുള്ള "എൻഡ്" പാരാമീറ്ററിന്റെ മൂല്യം "n" എന്ന പ്രതീകത്തിന് തുല്യമാണ്. പ്രോഗ്രാം കോഡിന്റെ ഓട്ടോമാറ്റിക് അൽഗോരിതം അനുസരിച്ച്, അത് അവസാനം വരികൾ പൂർത്തിയാക്കുന്നു, അതിന് മുമ്പ് "പ്രിന്റ്" ഫംഗ്ഷൻ എഴുതിയിരിക്കുന്നു. ഒരൊറ്റ "പ്രിന്റ്" ഫംഗ്ഷൻ ഉപയോഗിക്കുമ്പോൾ, അതിന്റെ പ്രവർത്തനത്തിന്റെ സാരാംശം നിങ്ങൾ ശ്രദ്ധിക്കാനിടയില്ല, കാരണം സ്ക്രീനിൽ ഒരു വരി മാത്രമേ പ്രദർശിപ്പിക്കൂ. എന്നിരുന്നാലും, നിങ്ങൾ ഇതുപോലുള്ള കുറച്ച് പ്രസ്താവനകൾ ചേർക്കുകയാണെങ്കിൽ, ഫംഗ്ഷന്റെ ഫലം കൂടുതൽ വ്യക്തമാകും:

പ്രിന്റ്("ഹലോ, വേൾഡ് 1!") പ്രിന്റ്("ഹലോ, വേൾഡ് 2!") പ്രിന്റ്("ഹലോ, വേൾഡ് 3!") പ്രിന്റ്("ഹലോ, വേൾഡ് 4!")

മുകളിലുള്ള കോഡിന്റെ ഫലത്തിന്റെ ഒരു ഉദാഹരണം:

ഹലോ, വേൾഡ് 1! ഹലോ, വേൾഡ് 2! ഹലോ, വേൾഡ് 3! ഹലോ, വേൾഡ് 4!

ഒരു പുതിയ ലൈൻ പ്രതീകം പ്രിന്റ് ഉപയോഗിച്ച് മാറ്റിസ്ഥാപിക്കുന്നു

"പ്രിന്റ്" ഫംഗ്ഷൻ ഉപയോഗിച്ച്, വരികൾക്കിടയിൽ ഒരു സെപ്പറേറ്റർ പ്രതീകം ഉപയോഗിക്കാതിരിക്കാൻ സാധിക്കും. ഇത് ചെയ്യുന്നതിന്, നിങ്ങൾ ഫംഗ്ഷനിൽ തന്നെ "അവസാനം" പരാമീറ്റർ മാറ്റേണ്ടതുണ്ട്. ഈ സാഹചര്യത്തിൽ, "അവസാനം" മൂല്യത്തിന് പകരം, നിങ്ങൾ ഒരു സ്പേസ് ചേർക്കേണ്ടതുണ്ട്. ഇതുമൂലം, "അവസാനം" പ്രതീകത്തെ മാറ്റിസ്ഥാപിക്കുന്ന ഇടമാണിത്. സ്ഥിരസ്ഥിതി ക്രമീകരണങ്ങൾ സജ്ജമാക്കിയ ഫലം:

>>> പ്രിന്റ് ("ഹലോ") >>> പ്രിന്റ് ("വേൾഡ്") ഹലോ വേൾഡ്

"n" എന്ന അക്ഷരം ഒരു സ്പേസ് ഉപയോഗിച്ച് മാറ്റിസ്ഥാപിച്ചതിന് ശേഷം ഫലം പ്രദർശിപ്പിക്കുന്നു:

>>> പ്രിന്റ്("ഹലോ", എൻഡ്=" ") >>> പ്രിന്റ്("വേൾഡ്") ഹലോ വേൾഡ്

ഒരു വരിയിൽ മൂല്യങ്ങളുടെ ഒരു ശ്രേണി പ്രദർശിപ്പിക്കുന്നതിന് പ്രതീകങ്ങൾ മാറ്റിസ്ഥാപിക്കുന്നതിനുള്ള ഈ രീതി ഉപയോഗിക്കുന്നതിനുള്ള ഒരു ഉദാഹരണം:

ഞാൻ ശ്രേണിയിൽ (15): i < 14: print(i, end=", ") else: print(i)

ഫയലുകളിൽ സെപ്പറേറ്റർ പ്രതീകം ഉപയോഗിക്കുന്നു

പ്രോഗ്രാം കോഡിന്റെ വാചകം അടുത്ത വരിയിലേക്ക് മാറ്റുന്ന ചിഹ്നം പൂർത്തിയായ ഫയലുകളിൽ കാണാം. എന്നിരുന്നാലും, പ്രോഗ്രാം കോഡിലൂടെ പ്രമാണം തന്നെ കാണാതെ, അത് കാണാൻ കഴിയില്ല, കാരണം അത്തരം പ്രതീകങ്ങൾ സ്ഥിരസ്ഥിതിയായി മറച്ചിരിക്കുന്നു. പുതിയ ലൈൻ പ്രതീകം ഉപയോഗിക്കുന്നതിന്, പേരുകൾ നിറഞ്ഞ ഒരു ഫയൽ നിങ്ങൾ സൃഷ്ടിക്കേണ്ടതുണ്ട്. അത് തുറന്ന ശേഷം, എല്ലാ പേരുകളും ഒരു പുതിയ ലൈനിൽ ആരംഭിക്കുന്നത് നിങ്ങൾക്ക് കാണാം. ഉദാഹരണം:

പേരുകൾ = ['Petr', 'Dima', 'Artem', 'Ivan'] തുറന്ന് ("names.txt", "w") f ആയി: പേരുകളിലെ പേരിന്[:-1]: f.write(f "{name}n") f.write(names[-1])

വിവരങ്ങൾ പ്രത്യേകം വരികളായി വേർതിരിക്കാൻ ടെക്സ്റ്റ് ഫയൽ സജ്ജീകരിച്ചാൽ മാത്രമേ പേരുകൾ ഈ രീതിയിൽ പ്രദർശിപ്പിക്കുകയുള്ളൂ. ഇത് ഓരോ മുൻ വരിയുടെയും അവസാനം മറഞ്ഞിരിക്കുന്ന "n" പ്രതീകം സ്വയമേവ സജ്ജമാക്കും. മറഞ്ഞിരിക്കുന്ന അടയാളം കാണുന്നതിന്, നിങ്ങൾ ഫംഗ്ഷൻ സജീവമാക്കേണ്ടതുണ്ട് - ".readlines()". അതിനുശേഷം, എല്ലാ മറഞ്ഞിരിക്കുന്ന പ്രതീകങ്ങളും പ്രോഗ്രാം കോഡിൽ സ്ക്രീനിൽ പ്രദർശിപ്പിക്കും. ഫംഗ്ഷൻ ആക്റ്റിവേഷൻ ഉദാഹരണം:

f: print(f.readlines()) ആയി തുറന്ന് ("names.txt", "r")

ഉപദേശം! പൈത്തണുമായി സജീവമായി പ്രവർത്തിക്കുമ്പോൾ, പ്രോഗ്രാം കോഡ് ഒരു നീണ്ട വരിയിൽ എഴുതേണ്ട സാഹചര്യങ്ങൾ ഉപയോക്താക്കൾക്ക് പലപ്പോഴും നേരിടേണ്ടിവരുന്നു, എന്നാൽ വേർപെടുത്താതെ തന്നെ അത് അവലോകനം ചെയ്യുന്നതും അപാകതകൾ തിരിച്ചറിയുന്നതും വളരെ ബുദ്ധിമുട്ടാണ്. അതിനാൽ, ഒരു നീണ്ട വരിയെ പ്രത്യേക ശകലങ്ങളായി വിഭജിച്ച ശേഷം, കമ്പ്യൂട്ടർ അതിനെ പൂർണ്ണമായി കണക്കാക്കുന്നു, മൂല്യങ്ങൾക്കിടയിലുള്ള ഓരോ സ്വതന്ത്ര വിടവിലും, നിങ്ങൾ "" - ഒരു ബാക്ക്സ്ലാഷ് പ്രതീകം ചേർക്കണം. ഒരു പ്രതീകം ചേർത്ത ശേഷം, നിങ്ങൾക്ക് മറ്റൊരു വരിയിലേക്ക് പോകാം, കോഡ് എഴുതുന്നത് തുടരുക. ലോഞ്ച് സമയത്ത്, പ്രോഗ്രാം തന്നെ വ്യക്തിഗത ശകലങ്ങളെ ഒരൊറ്റ വരിയിൽ കൂട്ടിച്ചേർക്കും.

ഒരു സ്ട്രിംഗ് സബ്‌സ്ട്രിംഗുകളായി വിഭജിക്കുന്നു

ഒരു നീണ്ട സ്ട്രിംഗിനെ നിരവധി സബ്‌സ്ട്രിംഗുകളായി വിഭജിക്കാൻ, നിങ്ങൾക്ക് സ്പ്ലിറ്റ് രീതി ഉപയോഗിക്കാം. കൂടുതൽ തിരുത്തലുകൾ വരുത്തിയില്ലെങ്കിൽ, ഡിഫോൾട്ട് ഡിലിമിറ്റർ ഒരു സ്‌പെയ്‌സാണ്. ഈ രീതി നടപ്പിലാക്കിയ ശേഷം, തിരഞ്ഞെടുത്ത വാചകം സബ്‌സ്ട്രിംഗുകൾ ഉപയോഗിച്ച് പ്രത്യേക പദങ്ങളായി വിഭജിച്ച് സ്ട്രിംഗുകളുടെ പട്ടികയിലേക്ക് പരിവർത്തനം ചെയ്യുന്നു. ഒരു ഉദാഹരണം എന്ന നിലക്ക്:

സ്ട്രിംഗ് = "ചില പുതിയ ടെക്സ്റ്റ്" സ്ട്രിംഗുകൾ = string.split() പ്രിന്റ്(സ്ട്രിംഗുകൾ) ['ചിലത്', 'പുതിയത്', 'ടെക്സ്റ്റ്']

റിവേഴ്സ് ട്രാൻസ്ഫോർമേഷൻ നടപ്പിലാക്കുന്നതിനായി, സബ്സ്ട്രിംഗുകളുടെ ലിസ്റ്റ് ഒരു നീണ്ട സ്ട്രിംഗായി മാറുന്ന സഹായത്തോടെ, നിങ്ങൾ ജോയിൻ രീതി ഉപയോഗിക്കണം. സ്ട്രിംഗുകളുമായി പ്രവർത്തിക്കുന്നതിനുള്ള മറ്റൊരു ഉപയോഗപ്രദമായ രീതി സ്ട്രിപ്പ് ആണ്. ഇത് ഉപയോഗിച്ച്, വരിയുടെ ഇരുവശത്തും സ്ഥിതിചെയ്യുന്ന ഇടങ്ങൾ നിങ്ങൾക്ക് നീക്കംചെയ്യാം.

തീരുമാനം

പൈത്തണിൽ പ്രവർത്തിക്കുമ്പോൾ ഒരു പുതിയ ലൈനിൽ നിന്ന് ചില ഡാറ്റ ഔട്ട്പുട്ട് ചെയ്യുന്നതിന്, "n" എന്ന അക്ഷരത്തിൽ പഴയ വരി അവസാനിപ്പിക്കേണ്ടത് ആവശ്യമാണ്. അതിന്റെ സഹായത്തോടെ, അടയാളത്തിനു ശേഷമുള്ള വിവരങ്ങൾ അടുത്ത വരിയിലേക്ക് മാറ്റുകയും പഴയത് അടയ്ക്കുകയും ചെയ്യുന്നു. എന്നിരുന്നാലും, ഡാറ്റ കൈമാറാൻ ഈ ചിഹ്നം ഉപയോഗിക്കേണ്ടതില്ല. ഇത് ചെയ്യുന്നതിന്, നിങ്ങൾക്ക് അവസാനം = " എന്ന പാരാമീറ്റർ ഉപയോഗിക്കാം.". "പ്രതീകം" എന്നത് സെപ്പറേറ്റർ പ്രതീകമാണ്.