పైథాన్‌లోని కొత్త పంక్తికి టెక్స్ట్ యొక్క అనువాదం. వచనాన్ని కొత్త పంక్తికి ఎలా తరలించాలి - సూచనలు

పైథాన్‌లో, ఒక పంక్తి ముగింపును గుర్తించడానికి మరియు కొత్తదాన్ని ప్రారంభించడానికి, మీరు ప్రత్యేక అక్షరాన్ని ఉపయోగించాలి. అదే సమయంలో, వివిధ పైథాన్ ఫైళ్ళతో పని చేస్తున్నప్పుడు దాన్ని సరిగ్గా ఎలా ఉపయోగించాలో తెలుసుకోవడం ముఖ్యం, మరియు అవసరమైన క్షణాల్లో కన్సోల్‌లో ప్రదర్శించండి. ప్రోగ్రామ్ కోడ్‌తో పనిచేసేటప్పుడు కొత్త పంక్తుల కోసం డీలిమిటర్‌ను ఎలా ఉపయోగించాలో వివరంగా అర్థం చేసుకోవడం అవసరం, దాన్ని ఉపయోగించకుండా వచనాన్ని జోడించడం సాధ్యమేనా.

కొత్త లైన్ పాత్ర గురించి సాధారణ సమాచారం

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: పేర్లలో పేరు కోసం[:-1]: f.write(f "{name}n") f.write(names[-1])

టెక్స్ట్ ఫైల్ సమాచారాన్ని ప్రత్యేక పంక్తులుగా వేరు చేయడానికి సెట్ చేసినట్లయితే మాత్రమే పేర్లు ఈ విధంగా ప్రదర్శించబడతాయి. ఇది ప్రతి మునుపటి పంక్తి చివర దాచిన అక్షరం “n”ని స్వయంచాలకంగా సెట్ చేస్తుంది. దాచిన గుర్తును చూడటానికి, మీరు ఫంక్షన్‌ను సక్రియం చేయాలి - ".readlines()". ఆ తరువాత, ప్రోగ్రామ్ కోడ్‌లో అన్ని దాచిన అక్షరాలు తెరపై ప్రదర్శించబడతాయి. ఫంక్షన్ యాక్టివేషన్ ఉదాహరణ:

ఓపెన్("names.txt", "r")తో f: print(f.readlines())

సలహా! పైథాన్‌తో చురుకుగా పని చేస్తున్నప్పుడు, వినియోగదారులు ప్రోగ్రామ్ కోడ్‌ను ఒక పొడవైన పంక్తిలో వ్రాయవలసిన పరిస్థితులను తరచుగా ఎదుర్కొంటారు, అయితే దానిని సమీక్షించడం మరియు విభజన లేకుండా తప్పులను గుర్తించడం చాలా కష్టం. కాబట్టి పొడవైన పంక్తిని ప్రత్యేక శకలాలుగా విభజించిన తర్వాత, కంప్యూటర్ దానిని మొత్తంగా పరిగణిస్తుంది, విలువల మధ్య ప్రతి ఉచిత గ్యాప్‌లో, మీరు తప్పనిసరిగా “” అక్షరాన్ని ఇన్సర్ట్ చేయాలి - బ్యాక్‌స్లాష్. అక్షరాన్ని జోడించిన తర్వాత, మీరు మరొక పంక్తికి వెళ్లవచ్చు, కోడ్ రాయడం కొనసాగించండి. ప్రారంభించే సమయంలో, ప్రోగ్రామ్ వ్యక్తిగత శకలాలను ఒకే లైన్‌లో సమీకరించడం.

స్ట్రింగ్‌ను సబ్‌స్ట్రింగ్‌లుగా విభజించడం

ఒక పొడవైన స్ట్రింగ్‌ను అనేక సబ్‌స్ట్రింగ్‌లుగా విభజించడానికి, మీరు స్ప్లిట్ పద్ధతిని ఉపయోగించవచ్చు. తదుపరి సవరణలు చేయకుంటే, డిఫాల్ట్ డీలిమిటర్ ఖాళీగా ఉంటుంది. ఈ పద్ధతిని అమలు చేసిన తర్వాత, ఎంచుకున్న టెక్స్ట్ సబ్‌స్ట్రింగ్‌ల ద్వారా ప్రత్యేక పదాలుగా విభజించబడింది, స్ట్రింగ్‌ల జాబితాగా మార్చబడుతుంది. ఉదాహరణకు:

స్ట్రింగ్ = "కొత్త టెక్స్ట్" స్ట్రింగ్స్ = string.split() print(strings) ['some', 'new', 'text']

రివర్స్ ట్రాన్స్‌ఫర్మేషన్‌ను అమలు చేయడానికి, సబ్‌స్ట్రింగ్‌ల జాబితా ఒక పొడవైన స్ట్రింగ్‌గా మారే సహాయంతో, మీరు తప్పనిసరిగా జాయిన్ పద్ధతిని ఉపయోగించాలి. స్ట్రింగ్స్తో పనిచేయడానికి మరొక ఉపయోగకరమైన పద్ధతి స్ట్రిప్. దానితో, మీరు లైన్ యొక్క రెండు వైపులా ఉన్న ఖాళీలను తీసివేయవచ్చు.

ముగింపు

పైథాన్‌లో పని చేస్తున్నప్పుడు కొత్త లైన్ నుండి నిర్దిష్ట డేటాను అవుట్‌పుట్ చేయడానికి, పాత పంక్తిని “n” అక్షరంతో ముగించడం అవసరం. దాని సహాయంతో, సైన్ తర్వాత సమాచారం తదుపరి పంక్తికి బదిలీ చేయబడుతుంది మరియు పాతది మూసివేయబడుతుంది. అయితే, డేటాను బదిలీ చేయడానికి ఈ చిహ్నాన్ని ఉపయోగించాల్సిన అవసరం లేదు. దీన్ని చేయడానికి, మీరు ముగింపు = "పరామితిని ఉపయోగించవచ్చు.". విలువ "పాత్ర" అనేది సెపరేటర్ క్యారెక్టర్.