பைத்தானில் ஒரு புதிய வரிக்கு உரையின் மொழிபெயர்ப்பு. உரையை புதிய வரிக்கு நகர்த்துவது எப்படி - வழிமுறைகள்

பைத்தானில், ஒரு வரியின் முடிவைக் குறிக்கவும், புதிய ஒன்றைத் தொடங்கவும், நீங்கள் ஒரு சிறப்பு எழுத்தைப் பயன்படுத்த வேண்டும். அதே நேரத்தில், பல்வேறு பைதான் கோப்புகளுடன் பணிபுரியும் போது அதை எவ்வாறு சரியாகப் பயன்படுத்துவது என்பது முக்கியம், மேலும் தேவையான தருணங்களில் அதை கன்சோலில் காண்பிக்கவும். நிரல் குறியீட்டுடன் பணிபுரியும் போது புதிய வரிகளுக்கு டிலிமிட்டரை எவ்வாறு பயன்படுத்துவது, அதைப் பயன்படுத்தாமல் உரையைச் சேர்க்க முடியுமா என்பதை விரிவாகப் புரிந்துகொள்வது அவசியம்.

புதிய வரி எழுத்து பற்றிய பொதுவான தகவல்கள்

n என்பது ஒரு புதிய வரியில் தகவலைப் பொதிவதற்கும் பைத்தானில் பழைய வரியை மூடுவதற்கும் குறியீடு. இந்த சின்னம் இரண்டு கூறுகளைக் கொண்டுள்ளது:

• தலைகீழ் சாய்ந்த;
• n என்பது ஒரு சிறிய எழுத்து.

இந்த எழுத்தைப் பயன்படுத்த, நீங்கள் “print(f” HellonWorld!”) ” என்ற வெளிப்பாட்டைப் பயன்படுத்தலாம், இதன் காரணமாக நீங்கள் f-வரிகளில் தகவலைப் பரிமாற்றலாம்.

அச்சு செயல்பாடு என்ன

கூடுதல் அமைப்புகள் இல்லாமல், அடுத்த வரிக்கு தரவு பரிமாற்ற எழுத்து மறைக்கப்பட்ட பயன்முறையில் சேர்க்கப்படும். இதன் காரணமாக, ஒரு குறிப்பிட்ட செயல்பாட்டை செயல்படுத்தாமல் வரிகளுக்கு இடையில் பார்க்க முடியாது. நிரல் குறியீட்டில் பிரிப்பான் ஐகானைக் காண்பிப்பதற்கான எடுத்துக்காட்டு:

அச்சிடுக ("வணக்கம், உலகம்"!") - "வணக்கம், உலகம்!"n

அதே நேரத்தில், இந்த பாத்திரத்தின் அத்தகைய கண்டுபிடிப்பு பைத்தானின் அடிப்படை பண்புகளில் எழுதப்பட்டுள்ளது. "அச்சு" செயல்பாடு "முடிவு" அளவுருவிற்கு இயல்புநிலை மதிப்பைக் கொண்டுள்ளது - n. இந்த செயல்பாட்டிற்கு நன்றி, இந்த எழுத்து அடுத்த வரிகளுக்கு தரவை மாற்ற வரிகளின் முடிவில் அமைக்கப்பட்டுள்ளது. "அச்சு" செயல்பாட்டின் விளக்கம்:

அச்சு (* பொருள்கள், 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'] with open("names.txt", "w") f: for names in names[:-1]: f.write(f "{name}n") f.write(பெயர்கள்[-1])

டெக்ஸ்ட் பைல் தகவலை தனித்தனி வரிகளாக பிரிக்கும் வகையில் அமைத்தால் மட்டுமே பெயர்கள் இவ்வாறு காட்டப்படும். இது ஒவ்வொரு முந்தைய வரியின் முடிவிலும் மறைக்கப்பட்ட "n" எழுத்தை தானாகவே அமைக்கும். மறைக்கப்பட்ட அடையாளத்தைக் காண, நீங்கள் செயல்பாட்டைச் செயல்படுத்த வேண்டும் - ".readlines()". அதன் பிறகு, அனைத்து மறைக்கப்பட்ட எழுத்துக்கள் நிரல் குறியீட்டில் திரையில் காட்டப்படும். செயல்பாடு செயல்படுத்தும் எடுத்துக்காட்டு:

திறந்த("names.txt", "r") f: print(f.readlines())

அறிவுரை! பைத்தானுடன் செயலில் பணிபுரியும், பயனர்கள் நிரல் குறியீட்டை ஒரு நீண்ட வரியில் எழுத வேண்டிய சூழ்நிலைகளை அடிக்கடி எதிர்கொள்கின்றனர், ஆனால் அதை மதிப்பாய்வு செய்வது மற்றும் பிரித்தல் இல்லாமல் தவறுகளை அடையாளம் காண்பது மிகவும் கடினம். எனவே ஒரு நீண்ட கோட்டை தனித்தனி துண்டுகளாகப் பிரித்த பிறகு, கணினி அதை முழுதாகக் கருதுகிறது, மதிப்புகளுக்கு இடையிலான ஒவ்வொரு இலவச இடைவெளியிலும், நீங்கள் "" என்ற எழுத்தை செருக வேண்டும் - ஒரு பின்சாய்வு. ஒரு எழுத்தைச் சேர்த்த பிறகு, நீங்கள் மற்றொரு வரிக்குச் செல்லலாம், குறியீட்டை எழுதுவதைத் தொடரலாம். துவக்கத்தின் போது, ​​நிரல் தனித்தனி துண்டுகளை ஒரு வரியில் இணைக்கும்.

ஒரு சரத்தை துணை சரங்களாகப் பிரித்தல்

ஒரு நீண்ட சரத்தை பல துணை சரங்களாகப் பிரிக்க, நீங்கள் பிளவு முறையைப் பயன்படுத்தலாம். மேலும் திருத்தங்கள் எதுவும் செய்யப்படவில்லை எனில், இயல்புநிலை டிலிமிட்டர் ஒரு இடைவெளியாகும். இந்த முறையைச் செயல்படுத்திய பிறகு, தேர்ந்தெடுக்கப்பட்ட உரை துணை வரிகளால் தனி வார்த்தைகளாகப் பிரிக்கப்பட்டு, சரங்களின் பட்டியலாக மாற்றப்படுகிறது. எடுத்துக்காட்டாக:

சரம் = "சில புதிய உரை" சரங்கள் = string.split() print(strings) ['some', 'new', 'text']

தலைகீழ் மாற்றத்தை மேற்கொள்ள, துணை சரங்களின் பட்டியல் ஒரு நீண்ட சரமாக மாறும், நீங்கள் சேரும் முறையைப் பயன்படுத்த வேண்டும். சரங்களுடன் வேலை செய்வதற்கான மற்றொரு பயனுள்ள முறை ஸ்ட்ரிப் ஆகும். இதன் மூலம், கோட்டின் இருபுறமும் அமைந்துள்ள இடங்களை நீங்கள் அகற்றலாம்.

தீர்மானம்

பைத்தானில் பணிபுரியும் போது புதிய வரியிலிருந்து சில தரவை வெளியிடுவதற்கு, பழைய வரியை "n" என்ற எழுத்துடன் முடிக்க வேண்டியது அவசியம். அதன் உதவியுடன், அடையாளத்திற்குப் பிறகு தகவல் அடுத்த வரிக்கு மாற்றப்பட்டு, பழையது மூடப்படும். இருப்பினும், தரவை மாற்ற இந்த குறியீட்டைப் பயன்படுத்த வேண்டிய அவசியமில்லை. இதைச் செய்ய, நீங்கள் முடிவு = "என்ற அளவுருவைப் பயன்படுத்தலாம்.". மதிப்பு "எழுத்து" என்பது பிரிப்பான் எழுத்து.