1. ప్రోగ్రామింగ్ పైథాన్ పైథాన్లో లాంబ్డా విధులను ఎలా ఉపయోగించాలి

అలాన్ షోవిక్, జాన్ షోవిక్

పైథాన్ అనామక ఫంక్షన్ల భావనకు మద్దతు ఇస్తుంది, దీనిని లాంబ్డా ఫంక్షన్లు అని కూడా పిలుస్తారు. పేరు యొక్క అనామక భాగం ఫంక్షన్‌కు పేరు ఉండనవసరం లేదు (కానీ మీకు కావాలంటే ఒకటి ఉండవచ్చు). లాంబ్డా భాగం పైథాన్‌లో వాటిని నిర్వచించడానికి లాంబ్డా అనే కీవర్డ్‌ను ఉపయోగించడంపై ఆధారపడి ఉంటుంది. లాంబ్డా గ్రీకు వర్ణమాల యొక్క 11 వ అక్షరం.

పైథాన్‌లో ఈ పేరు ఉపయోగించబడటానికి ప్రధాన కారణం ఏమిటంటే, కాలిక్యులస్‌లో అనామక విధులను వివరించడానికి లాంబ్డా అనే పదాన్ని ఉపయోగిస్తారు. ఇప్పుడు మేము దానిని క్లియర్ చేసాము, కార్యాలయ పార్టీలలో మనోహరమైన సంభాషణను ప్రేరేపించడానికి మీరు ఈ సమాచారాన్ని ఉపయోగించవచ్చు.

పైథాన్‌తో లాంబ్డా వ్యక్తీకరణను (పేరు లేకుండా) నిర్వచించడానికి కనీస వాక్యనిర్మాణం:

లాంబ్డా వాదనలు: వ్యక్తీకరణ

దీన్ని ఉపయోగిస్తున్నప్పుడు:

  • వ్యక్తీకరణలోకి డేటా పంపించడంతో వాదనలను భర్తీ చేయండి. లాంబ్డా తిరిగి రావాలని మీరు కోరుకునేదాన్ని నిర్వచించే వ్యక్తీకరణ (ఫార్ములా) తో వ్యక్తీకరణను భర్తీ చేయండి.

ఆ వాక్యనిర్మాణాన్ని ఉపయోగించటానికి చాలా సాధారణ ఉదాహరణ ఏమిటంటే, మీరు టెక్స్ట్ యొక్క తీగలను క్రమబద్ధీకరించడానికి ప్రయత్నిస్తున్నప్పుడు, ఇక్కడ కొన్ని పేర్లు పెద్ద అక్షరాలతో మొదలవుతాయి మరియు కొన్ని ఈ పేర్లలో ఉన్నట్లుగా చిన్న అక్షరాలతో ప్రారంభమవుతాయి:

ఆడమ్స్, మా, డిమియోలా, జాండుస్కీ

పేర్లను జాబితాలో ఉంచడానికి, క్రమబద్ధీకరించడానికి, ఆపై జాబితాను ప్రింట్ చేయడానికి మీరు ఈ క్రింది కోడ్‌ను వ్రాస్తారని అనుకుందాం:

పేర్లు = ['ఆడమ్స్', 'మా', 'డిమియోలా', 'జాండుస్కీ']
names.sort ()
ప్రింట్ (పేర్లు)

దీని నుండి అవుట్‌పుట్:

['ఆడమ్స్', 'మా', 'జాండుస్కీ', 'డిమియోలా']

కొంతమంది ప్రారంభకులకు జాండుస్కీ తప్పు అనిపించిన తర్వాత డిమియోలా రావడం. కానీ కంప్యూటర్లు ఎల్లప్పుడూ మనం చేసే విధంగా చూడవు. (వాస్తవానికి, వారు కళ్ళు లేదా మెదళ్ళు లేనందున వారు దేనినీ "చూడరు" ... కానీ అది పాయింట్ పక్కన ఉంది.) జాండూస్కీ తర్వాత డిమియోలా రావడానికి కారణం, ఎందుకంటే ఈ విధమైన ASCII పై ఆధారపడి ఉంటుంది, ఇది ప్రతి వ్యవస్థ అక్షరం సంఖ్య ద్వారా సూచించబడుతుంది.

అన్ని చిన్న అక్షరాలలో పెద్ద సంఖ్యల కంటే ఎక్కువ సంఖ్యలు ఉన్నాయి. కాబట్టి, క్రమబద్ధీకరించేటప్పుడు, చిన్న అక్షరాలతో ప్రారంభమయ్యే అన్ని పదాలు పెద్ద అక్షరంతో ప్రారంభమయ్యే పదాల తర్వాత వస్తాయి. మరేమీ కాకపోతే, ఇది కనీసం ఒక చిన్న హ్మ్కు హామీ ఇస్తుంది.

ఈ విషయాలలో సహాయపడటానికి, పైథాన్ సార్ట్ () పద్ధతి కుండలీకరణాల్లో ఒక కీ = వ్యక్తీకరణను చేర్చడానికి మిమ్మల్ని అనుమతిస్తుంది, ఇక్కడ మీరు ఎలా క్రమబద్ధీకరించాలో చెప్పగలరు. వాక్యనిర్మాణం:

.సోర్ట్ (కీ = పరివర్తన)

పరివర్తన భాగం క్రమబద్ధీకరించబడిన డేటాపై కొంత వైవిధ్యం. మీరు అదృష్టవంతులైతే మరియు లెన్ (పొడవు కోసం) వంటి అంతర్నిర్మిత ఫంక్షన్లలో ఒకటి మీ కోసం పని చేస్తుంది, అప్పుడు మీరు దీనిని పరివర్తన స్థానంలో, ఇలా ఉపయోగించవచ్చు:

names.sort (కీ = లెన్)

దురదృష్టవశాత్తు మాకు, స్ట్రింగ్ యొక్క పొడవు అక్షరక్రమానికి సహాయపడదు. కాబట్టి మీరు దీన్ని అమలు చేసినప్పుడు, ఆర్డర్ ఇలా మారుతుంది:

['మా', 'ఆడమ్స్', 'డిమియోలా', 'జాండుస్కీ']

క్రమబద్ధీకరణ చిన్నదైన స్ట్రింగ్ (తక్కువ అక్షరాలతో ఉన్నది) నుండి పొడవైన స్ట్రింగ్‌కు వెళుతుంది. ప్రస్తుతానికి సహాయపడదు.

అన్ని చిన్న అక్షరాలు లేదా అన్ని పెద్ద అక్షరాలపై ఆధారపడటానికి మీరు కీ = దిగువ లేదా కీ = ఎగువ వ్రాయలేరు, ఎందుకంటే దిగువ మరియు ఎగువ అంతర్నిర్మిత విధులు కావు (పైథాన్ 3.7 అంతర్నిర్మిత గూగ్లింగ్ ద్వారా మీరు చాలా త్వరగా ధృవీకరించవచ్చు. విధులు).

అంతర్నిర్మిత ఫంక్షన్‌కు బదులుగా, మీరు డెఫ్‌ను ఉపయోగించి మీరే నిర్వచించే కస్టమ్ ఫంక్షన్‌ను ఉపయోగించవచ్చు. ఉదాహరణకు, మీరు తక్కువ () అనే ఫంక్షన్‌ను సృష్టించవచ్చు, అది స్ట్రింగ్‌ను అంగీకరించి, ఆ స్ట్రింగ్‌ను దాని అక్షరాలన్నింటినీ చిన్న అక్షరాలతో మారుస్తుంది. ఫంక్షన్ ఇక్కడ ఉంది:

డెఫ్ తక్కువ (ఏదైనా స్ట్రింగ్):
"" "స్ట్రింగ్‌ను అన్ని చిన్న అక్షరాలకు మారుస్తుంది" ""
anystring.lower () ను తిరిగి ఇవ్వండి

దిగువ పేరు తయారు చేయబడింది మరియు భవిష్యత్తులో మీరు ఏ స్ట్రింగ్‌కు పాస్ చేసినా అది ఏదైనా ప్లేస్‌హోల్డర్. రిటర్న్ anystring.lower () స్ట్రింగ్ (స్ట్రింగ్) ఆబ్జెక్ట్ యొక్క .lower () పద్ధతిని ఉపయోగించి అన్ని చిన్న అక్షరాలకు మార్చబడుతుంది. (మరింత సమాచారం కోసం పైథాన్ స్ట్రింగ్ పద్ధతుల గురించి చదవండి.)

తక్కువ () అంతర్నిర్మిత ఫంక్షన్ కానందున మీరు () కుండలీకరణాల్లో కీ = తక్కువ ఉపయోగించలేరు. ఇది ఒక పద్ధతి… అదే కాదు. ఈ అన్ని బజ్‌వర్డ్‌లతో బాధించే రకం.

మీరు ఈ ఫంక్షన్‌ను జూపిటర్ సెల్ లేదా .py ఫైల్‌లో వ్రాస్తారని అనుకుందాం. అప్పుడు మీరు ఫంక్షన్‌ను ప్రింట్ (లోయర్‌కేఫ్ ('జాండుస్కీ')) తో పిలుస్తారు. మీరు అవుట్పుట్గా పొందేది ఏమిటంటే, మీరు క్రింద చూస్తున్నట్లుగా, స్ట్రింగ్ అన్ని చిన్న అక్షరాలకు మార్చబడుతుంది.

పైథాన్‌లో కస్టమ్ ఫంక్షన్ తక్కువ ()

సరే, కాబట్టి ఇప్పుడు మీరు ఏదైనా స్ట్రింగ్‌ను అన్ని చిన్న అక్షరాలకు మార్చడానికి అనుకూల ఫంక్షన్‌ను కలిగి ఉన్నారు. మీరు దానిని సార్టింగ్ కీగా ఎలా ఉపయోగిస్తారు? సులభం, కీని ఉపయోగించండి = మునుపటిలాగా రూపాంతరం చెందండి, కానీ మీ అనుకూల ఫంక్షన్ పేరుతో పరివర్తనను భర్తీ చేయండి. ఈ ఫంక్షన్‌కు లోయర్‌కేఫ్ అని పేరు పెట్టారు, కాబట్టి మీరు ఈ క్రింది వాటిలో చూపిన విధంగా .sort (key = lowercaseof) ను ఉపయోగిస్తారు:

డెఫ్ లోవర్‌కేఫ్ (ఏదైనా స్ట్రింగ్):
"" "స్ట్రింగ్‌ను అన్ని చిన్న అక్షరాలకు మారుస్తుంది" ""
anystring.lower () ను తిరిగి ఇవ్వండి
 
పేర్లు = ['ఆడమ్స్', 'మా', 'డిమియోలా', 'జాండుస్కీ']
names.sort (కీ = lowercaseof)

పేర్ల జాబితాను ప్రదర్శించడానికి ఈ కోడ్‌ను అమలు చేయడం వలన వాటిని సరైన క్రమంలో ఉంచుతుంది, ఎందుకంటే ఇది అన్ని చిన్న అక్షరాలపై ఆధారపడి ఉంటుంది. అవుట్పుట్ మునుపటి మాదిరిగానే ఉంటుంది, ఎందుకంటే తెర వెనుక జరిగిన సార్టింగ్ మాత్రమే చిన్న అక్షరాలను ఉపయోగించింది. అసలు డేటా ఇప్పటికీ దాని అసలు పెద్ద మరియు చిన్న అక్షరాలలో ఉంది.

'ఆడమ్స్', 'డిమియోలా', 'మా', 'జాండుస్కీ'

ఇవన్నీ చదివిన తర్వాత మీరు ఇంకా మేల్కొని, స్పృహతో ఉంటే, “సరే, మీరు సార్టింగ్ సమస్యను పరిష్కరించారు. కానీ మేము ఇక్కడ లాంబ్డా ఫంక్షన్ల గురించి మాట్లాడుతున్నామని అనుకున్నాను. లాంబ్డా ఫంక్షన్ ఎక్కడ ఉంది? ”ఇంకా లాంబ్డా ఫంక్షన్ లేదు.

మీరు లాంబ్డా ఫంక్షన్‌ను ఎక్కడ ఉపయోగించవచ్చో ఇది ఒక చక్కటి ఉదాహరణ, ఎందుకంటే మీరు పిలుస్తున్న పైథాన్ ఫంక్షన్, లోయర్‌కేఫ్ (), దాని పనులన్నింటినీ కేవలం ఒక లైన్ కోడ్‌తో చేస్తుంది: anystring.lower () ను తిరిగి ఇవ్వండి.

మీ ఫంక్షన్ సరళమైన వన్-లైన్ వ్యక్తీకరణతో దాని పనిని చేయగలిగినప్పుడు, మీరు డెఫ్ మరియు ఫంక్షన్ పేరును దాటవేయవచ్చు మరియు ఈ వాక్యనిర్మాణాన్ని ఉపయోగించవచ్చు:

లాంబ్డా పారామితులు: వ్యక్తీకరణ

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

lambda anystring: anystring.lower ()

ఇది అనామక ఫంక్షన్ ఎందుకు అని ఇప్పుడు మీరు చూడవచ్చు. ఫంక్షన్ పేరు లోయర్ కేస్ () తో మొదటి పంక్తి మొత్తం తొలగించబడింది. కాబట్టి లాంబ్డా వ్యక్తీకరణను ఉపయోగించడం వల్ల మీకు బాహ్య అనుకూల ఫంక్షన్ కూడా అవసరం లేదు. మీకు పెద్దప్రేగు తరువాత పరామితి అవసరం మరియు దానిని తిరిగి ఇవ్వమని చెప్పే వ్యక్తీకరణ అవసరం.

క్రింద ఉన్న చిత్రం పూర్తి కోడ్‌ను మరియు దాన్ని అమలు చేసే ఫలితాన్ని చూపుతుంది. లోయర్‌కేఫ్ () వంటి కస్టమర్ బాహ్య ఫంక్షన్ అవసరం లేకుండా మీరు సరైన క్రమాన్ని పొందుతారు. మీరు ఏదైనా స్ట్రింగ్‌ను వాడండి: anystring.lower () (లాంబ్డా అనే పదం తరువాత) సార్టింగ్ కీగా.

పైథాన్ లాంబ్డా వ్యక్తీకరణ

చాలా పైథోనిస్టాస్ ఉపయోగించేదానికంటే ఏదైనా స్ట్రింగ్ పొడవైన పారామితి పేరు అని కూడా చేద్దాం. పైథాన్ ఫొల్క్స్ చిన్న పేర్లను ఇష్టపడతారు, ఒకే అక్షరాల పేర్లు కూడా. ఉదాహరణకు, మీరు కింది మాదిరిగానే ఏ స్ట్రింగ్‌ను s (లేదా మరేదైనా అక్షరాలతో) భర్తీ చేయవచ్చు మరియు కోడ్ సరిగ్గా అదే విధంగా పనిచేస్తుంది:

పేర్లు = ['ఆడమ్స్', 'మా', 'డిమియోలా', 'జాండుస్కీ']
names.sort (key = lambda s: s.lower ())
ప్రింట్ (పేర్లు)

ఈ టిరేడ్ ప్రారంభంలో, లాంబ్డా ఫంక్షన్ అనామకంగా ఉండవలసిన అవసరం లేదని ప్రస్తావించబడింది. మీరు వారికి పేర్లు ఇవ్వవచ్చు మరియు మీరు ఇతర ఫంక్షన్ల వలె కాల్ చేయవచ్చు.

ఉదాహరణకు, కరెన్సీ అనే లాంబ్డా ఫంక్షన్ ఇక్కడ ఏదైనా సంఖ్యను తీసుకొని కరెన్సీ ఆకృతిలో స్ట్రింగ్‌ను తిరిగి ఇస్తుంది (అనగా, ప్రముఖ డాలర్ గుర్తుతో, వేల మధ్య కామాలతో మరియు పెన్నీలకు రెండు అంకెలు):

కరెన్సీ = లాంబ్డా n: f "$ {n:,. 2f}"

ఇక్కడ మీరు పంపిన సంఖ్యను 100 గుణించి, చివరిలో రెండు శాతం గుర్తుతో చూపించే ఒక పేరు శాతం ఉంది:

శాతం = లాంబ్డా n: f "{n: .2%}"

కింది చిత్రం జూపిటర్ సెల్ పైభాగంలో నిర్వచించిన రెండు ఫంక్షన్ల ఉదాహరణలు చూపిస్తుంది. అప్పుడు కొన్ని ప్రింట్ స్టేట్‌మెంట్‌లు ఫంక్షన్లను పేరు ద్వారా పిలుస్తాయి మరియు వాటికి కొన్ని నమూనా డేటాను పంపుతాయి. ప్రతి ముద్రణ () స్టేట్‌మెంట్‌లు కావలసిన ఆకృతిలో సంఖ్యను ప్రదర్శిస్తాయి.

పైథాన్ ఆకృతీకరణ సంఖ్యలు

మీరు వాటిని సింగిల్-లైన్ లాంబ్డాస్ అని నిర్వచించటానికి కారణం ఏమిటంటే, మీరు అన్ని పనులను ఒకే వరుసలో చేయగలరు, f "$ {n:,. 2f}" మొదటిదానికి మరియు f "{n: .2%}" రెండవది. కానీ మీరు దీన్ని ఆ విధంగా చేయగలరు కాబట్టి, మీరు తప్పక అని అర్ధం కాదు. మీరు ఈ క్రింది విధంగా రెగ్యులర్ ఫంక్షన్లను కూడా ఉపయోగించవచ్చు:

# కరెన్సీ ఆకృతిలో సంఖ్యను చూపించు.
డెఫ్ కరెన్సీ (ఎన్):
తిరిగి f "$ {n:,. 2f}"
 
డెఫ్ శాతం (ఎన్):
# సంఖ్య ఆకృతిలో చూపించు.
తిరిగి f "{n: .2%}"

ఈ పొడవైన వాక్యనిర్మాణంతో, మీరు మరింత సమాచారం కూడా పంపవచ్చు. ఉదాహరణకు, మీరు ఒక నిర్దిష్ట వెడల్పులో కుడి-సమలేఖనం చేసిన ఆకృతికి డిఫాల్ట్ చేయవచ్చు (15 అక్షరాలు చెప్పండి) కాబట్టి అన్ని సంఖ్యలు ఒకే వెడల్పుకు కుడి-సమలేఖనం చేయబడ్డాయి. చిత్రం రెండు ఫంక్షన్లలో ఈ వైవిధ్యాన్ని చూపుతుంది.

పైథాన్ ఆకృతీకరణ ఫంక్షన్ స్థిర వెడల్పు

పై చిత్రంలో, రెండవ పరామితి ఐచ్ఛికం మరియు విస్మరించబడితే 15 కి డిఫాల్ట్ అవుతుంది. మీరు దీన్ని ఇలా పిలిస్తే:

ముద్రణ (కరెన్సీ (9999))

… మీకు 15 అక్షరాల వెడల్పు చేయడానికి ఎడమవైపు తగినంత ఖాళీలతో $ 9,999.00 పాడింగ్ లభిస్తుంది. మీరు దీన్ని ఇలా పిలిస్తే:

ముద్రణ (కరెన్సీ (9999,20)

… మీకు ఇంకా, 9,999.00 లభిస్తుంది, అయితే 20 అక్షరాల వెడల్పు ఉండేలా ఎడమ వైపున తగినంత ఖాళీలు ఉన్నాయి.

పైన ఉపయోగించిన .ljust () పైథాన్ అంతర్నిర్మిత స్ట్రింగ్ పద్ధతి, ఇది స్ట్రింగ్ యొక్క ఎడమ వైపు తగిన వెడల్పుతో తగినంత ఖాళీలతో ప్యాడ్ చేస్తుంది. కుడి వైపున ప్యాడ్ చేయడానికి rjust () పద్ధతి కూడా ఉంది. మీరు స్థలం కాకుండా వేరే అక్షరాన్ని కూడా పేర్కొనవచ్చు. మీకు మరింత సమాచారం అవసరమైతే గూగుల్ పైథాన్ 3 సరిదిద్దండి.

పైథాన్‌లో మీ స్వంత కస్టమ్ ఫంక్షన్‌లను సృష్టించగల సామర్థ్యం మీకు ఉంది. నిజ జీవితంలో, మీరు చేయాలనుకుంటున్నది ఏమిటంటే, మీకు ఎప్పుడైనా ఒకే కోడ్ యొక్క ప్రాప్యత అవసరమని మీరు కనుగొన్నప్పుడు - అదే బిట్ లాగిన్ - మీ అనువర్తనంలో పదే పదే, ఆ భాగాన్ని కాపీ / పేస్ట్ చేయవద్దు కోడ్ పదే పదే. బదులుగా, మీరు పేరు ద్వారా కాల్ చేయగల ఫంక్షన్‌లో ఆ కోడ్‌ను ఉంచండి.

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

  1. ప్రోగ్రామింగ్ పైథాన్ పైథాన్ జాబితాలను ఎలా నిర్వచించాలి మరియు ఉపయోగించాలి

అలాన్ షోవిక్, జాన్ షోవిక్

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

స్కోర్లు = [88, 92, 78, 90, 98, 84]

జాబితాలో తీగలను కలిగి ఉంటే, ఎప్పటిలాగే, ఈ తీగలను ఈ ఉదాహరణలో వలె ఒకే లేదా డబుల్ కొటేషన్ మార్కులతో జతచేయాలి:

స్క్రీన్‌పై జాబితా యొక్క విషయాలను ప్రదర్శించడానికి, మీరు ఏదైనా సాధారణ వేరియబుల్‌ను ప్రింట్ చేసినట్లే దాన్ని ప్రింట్ చేయవచ్చు. ఉదాహరణకు, ఆ జాబితాను నిర్వచించిన తర్వాత మీ కోడ్‌లో ముద్రణ (విద్యార్థులు) ను అమలు చేయడం తెరపై చూపిస్తుంది.

['మార్క్', 'అంబర్', 'టాడ్', 'అనిత', 'శాండీ']

ఇది మీ మనస్సులో సరిగ్గా ఉండకపోవచ్చు. చింతించకండి, జాబితాలలో డేటాను ప్రాప్యత చేయడానికి మరియు మీకు నచ్చిన విధంగా ప్రదర్శించడానికి పైథాన్ చాలా గొప్ప మార్గాలను అందిస్తుంది.

స్థానం ద్వారా పైథాన్ జాబితా అంశాలను సూచిస్తుంది

మీరు ఏ సంఖ్యలను చూడనప్పటికీ, జాబితాలోని ప్రతి అంశానికి సున్నాతో ప్రారంభమయ్యే స్థానం సంఖ్య ఉంటుంది. మీరు జాబితాలోని ఏదైనా వస్తువును దాని సంఖ్య ద్వారా జాబితాకు పేరును ఉపయోగించి చదరపు బ్రాకెట్లలోని సంఖ్యను సూచించవచ్చు. మరో మాటలో చెప్పాలంటే, ఈ వాక్యనిర్మాణాన్ని ఉపయోగించండి:

listname [x]

జాబితా పేరును మీరు యాక్సెస్ చేస్తున్న జాబితా పేరుతో భర్తీ చేయండి మరియు x ను మీకు కావలసిన వస్తువు యొక్క స్థాన సంఖ్యతో భర్తీ చేయండి. గుర్తుంచుకోండి, మొదటి అంశం ఎల్లప్పుడూ సంఖ్య సున్నా, ఒకటి కాదు. ఉదాహరణకు, దిగువ మొదటి పంక్తిలో, నేను విద్యార్థులు అనే జాబితాను నిర్వచించాను, ఆపై ఆ జాబితా నుండి ఐటెమ్ నంబర్ సున్నాను ప్రింట్ చేస్తాను. ఫలితం, కోడ్‌ను అమలు చేసేటప్పుడు, మార్క్ పేరు ప్రదర్శించబడుతుంది.
విద్యార్థులు = ["మార్క్", "అంబర్", "టాడ్", "అనిత", "శాండీ"]
ముద్రణ (విద్యార్ధులు [0])
మార్క్

యాక్సెస్ జాబితా అంశాలను చదివేటప్పుడు, నిపుణులు సంఖ్యకు ముందు ఉప అనే పదాన్ని ఉపయోగిస్తారు. ఉదాహరణకు, విద్యార్థులు [0] విద్యార్థులు ఉప సున్నాగా మాట్లాడతారు.

ఈ తదుపరి ఉదాహరణ స్కోర్లు అనే జాబితాను చూపుతుంది. ముద్రణ () ఫంక్షన్ జాబితాలోని చివరి స్కోరు యొక్క స్థానం సంఖ్యను ముద్రిస్తుంది, ఇది 4 (ఎందుకంటే మొదటిది ఎల్లప్పుడూ సున్నా).

స్కోర్లు = [88, 92, 78, 90, 84]
ముద్రణ (స్కోర్లు [4])
84

మీరు ఉనికిలో లేని జాబితా అంశాన్ని ప్రాప్యత చేయడానికి ప్రయత్నిస్తే, మీకు “సూచిక పరిధిలో లేదు” లోపం వస్తుంది. ఇండెక్స్ భాగం చదరపు బ్రాకెట్లలోని సంఖ్యకు సూచన. ఉదాహరణకు, క్రింద ఉన్న చిత్రం జూపిటర్ నోట్‌బుక్‌లో ఒక చిన్న ప్రయోగాన్ని చూపిస్తుంది, ఇక్కడ స్కోర్‌ల జాబితా సృష్టించబడింది మరియు తరువాత స్కోరు ముద్రణ [5] ప్రయత్నించబడింది.

స్కోర్లు లేనందున ఇది విఫలమైంది మరియు లోపం సృష్టించింది [5]. స్కోర్‌లు [0], స్కోర్‌లు [1], స్కోర్‌లు [2], స్కోర్‌లు [3] మరియు స్కోర్‌లు [4] మాత్రమే ఉన్నాయి, ఎందుకంటే లెక్కింపు ఎల్లప్పుడూ జాబితాలో మొదటిదానితో సున్నాతో మొదలవుతుంది.

పైథాన్ సూచిక పరిధి

పైథాన్ జాబితా ద్వారా లూప్ అవుతోంది

జాబితాలోని ప్రతి అంశాన్ని యాక్సెస్ చేయడానికి, ఈ వాక్యనిర్మాణంతో లూప్ కోసం ఉపయోగించండి:

జాబితాలో x కోసం:

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

స్కోర్‌లలో స్కోరు కోసం:
ముద్రణ (స్కోరు)

లూప్‌లో అమలు చేయాల్సిన కోడ్‌ను ఎల్లప్పుడూ ఇండెంట్ చేయడం గుర్తుంచుకోండి. ఈ చిత్రం జూపిటర్ నోట్‌బుక్‌లో కోడ్‌ను అమలు చేసే ఫలితాన్ని చూడగల పూర్తి ఉదాహరణను చూపుతుంది.

పైథాన్ జాబితా ద్వారా లూప్ అవుతోంది

పైథాన్ జాబితాలో ఒక అంశం ఉందా అని చూడటం

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

ఉదాహరణకు, దిగువ చిత్రంలోని కోడ్ పేర్ల జాబితాను సృష్టిస్తుంది. అప్పుడు, రెండు వేరియబుల్స్ అనిత మరియు బాబ్ పేర్ల కోసం జాబితాను శోధించే ఫలితాలను నిల్వ చేస్తాయి. ప్రతి వేరియబుల్ యొక్క విషయాలను ముద్రించడం వలన జాబితాలో పేరు (అనిత) ఉన్నదానికి ట్రూ చూపిస్తుంది. బాబ్ జాబితాలో ఉన్నారో లేదో పరీక్ష తప్పు అని రుజువు చేస్తుంది.

ఒక అంశం పైథాన్ జాబితాలో ఉందో లేదో చూడటం

పైథాన్ జాబితా యొక్క పొడవును పొందడం

జాబితాలో ఎన్ని అంశాలు ఉన్నాయో తెలుసుకోవడానికి, లెన్ () ఫంక్షన్‌ను ఉపయోగించండి (పొడవు కోసం చిన్నది). కుండలీకరణాల లోపల జాబితా పేరు ఉంచండి. ఉదాహరణకు, కింది కోడ్‌ను జూపిటర్ నోట్‌బుక్ లేదా పైథాన్ ప్రాంప్ట్ లేదా ఏమైనా టైప్ చేయండి:

విద్యార్థులు = ["మార్క్", "అంబర్", "టాడ్", "అనిత", "శాండీ"]
ప్రింట్ (లెన్ (విద్యార్థులు))

ఆ కోడ్‌ను అమలు చేయడం ఈ అవుట్‌పుట్‌ను ఉత్పత్తి చేస్తుంది:

5

జాబితాలో వాస్తవానికి ఐదు అంశాలు ఉన్నాయి, అయితే చివరిది ఎల్లప్పుడూ సంఖ్య కంటే తక్కువగా ఉంటుంది, ఎందుకంటే పైథాన్ సున్నా వద్ద లెక్కించడం ప్రారంభిస్తుంది. కాబట్టి చివరిది, శాండీ, వాస్తవానికి విద్యార్థులను సూచిస్తుంది [4] మరియు విద్యార్థులను కాదు [5].

పైథాన్ జాబితా చివరికి ఒక అంశాన్ని జోడిస్తోంది

మీ పైథాన్ కోడ్ జాబితా చివరలో క్రొత్త అంశాన్ని జోడించాలనుకున్నప్పుడు, కుండలీకరణాల్లో మీరు జోడించదలిచిన విలువతో .append () పద్ధతిని ఉపయోగించండి. కొటేషన్ మార్కుల లోపల మీరు వేరియబుల్ పేరు లేదా అక్షర విలువను ఉపయోగించవచ్చు.

ఉదాహరణకు, కింది చిత్రంలో స్టూడెంట్స్.అప్పెండ్ ("గూబెర్") ను చదివే పంక్తి జాబితాకు గూబెర్ పేరును జోడిస్తుంది. Students.append (new_student) ను చదివే పంక్తి జాబితాకు new_student అనే వేరియబుల్‌లో నిల్వ చేసిన పేరును జతచేస్తుంది. .Apend () పద్ధతి ఎల్లప్పుడూ జాబితా చివర జతచేస్తుంది. కాబట్టి మీరు జాబితాను ముద్రించినప్పుడు చివరిలో ఆ రెండు కొత్త పేర్లను చూస్తారు.

పైథాన్ అనుబంధ జాబితా

ఒక అంశం జాబితాలో ఉందో లేదో తెలుసుకోవడానికి మీరు ఒక పరీక్షను ఉపయోగించవచ్చు మరియు ఆ అంశం ఇప్పటికే లేనప్పుడు మాత్రమే దాన్ని జోడించవచ్చు. ఉదాహరణకు, దిగువ కోడ్ జాబితాలో అంబర్ పేరును జోడించదు ఎందుకంటే ఆ పేరు ఇప్పటికే జాబితాలో ఉంది:

student_name = "అమండా"

# విద్యార్థి_పేరును జోడించండి కాని ఇప్పటికే జాబితాలో లేకుంటే మాత్రమే.
విద్యార్థులలో విద్యార్థి పేరు ఉంటే:
    ముద్రణ (విద్యార్థి_పేరు + "ఇప్పటికే జాబితాలో ఉంది")
లేకపోతే:
    students.append (student_name)
    ముద్రణ (విద్యార్థి_పేరు + "జాబితాకు జోడించబడింది")

పైథాన్ జాబితాలో ఒక అంశాన్ని చొప్పించడం

జాబితా చివరలో ఒక అంశాన్ని జోడించడానికి అనుబంధం () పద్ధతి మిమ్మల్ని అనుమతించినప్పటికీ, చొప్పించు () పద్ధతి ఏ స్థితిలోనైనా జాబితాకు ఒక అంశాన్ని జోడించడానికి మిమ్మల్ని అనుమతిస్తుంది. చొప్పించు () కోసం వాక్యనిర్మాణం

listname.insert (స్థానం, అంశం)

జాబితా పేరును జాబితా పేరుతో భర్తీ చేయండి, మీరు అంశాన్ని చొప్పించదలిచిన స్థానంతో ఉంచండి (ఉదాహరణకు, దీన్ని మొదటి వస్తువుగా చేయడానికి 0, రెండవ అంశంగా చేయడానికి 1 మరియు మొదలగునవి). మీరు జాబితాలో ఉంచాలనుకునే విలువను లేదా విలువను కలిగి ఉన్న వేరియబుల్ పేరుతో అంశాన్ని భర్తీ చేయండి.

ఉదాహరణకు, కింది కోడ్ లూపేను జాబితాలోని మొదటి అంశంగా చేస్తుంది:

# తీగల జాబితాను సృష్టించండి (పేర్లు).
విద్యార్థులు = ["మార్క్", "అంబర్", "టాడ్", "అనిత", "శాండీ"]

student_name = "లూప్"
# జాబితా ముందు విద్యార్థుల పేరును జోడించండి.
students.insert (0, student_name)

# నాకు క్రొత్త జాబితాను చూపించు.
ప్రింట్ (విద్యార్థులు)

మీరు కోడ్‌ను అమలు చేస్తే, కొత్త పేరు చొప్పించిన తర్వాత ముద్రణ (విద్యార్థులు) జాబితాను చూపుతుంది:

['లూప్', 'మార్క్', 'అంబర్', 'టాడ్', 'అనిత', 'శాండీ']

పైథాన్ జాబితాలోని అంశాన్ని మార్చడం

మీరు వేరియబుల్స్‌తో చేసినట్లే = అసైన్‌మెంట్ ఆపరేటర్ (ఈ సాధారణ పైథాన్ ఆపరేటర్లను చూడండి) ఉపయోగించి జాబితాలోని ఒక అంశాన్ని మార్చవచ్చు. మీరు మార్చదలిచిన అంశం యొక్క చదరపు బ్రాకెట్లలో ఇండెక్స్ సంఖ్యను చేర్చారని నిర్ధారించుకోండి. వాక్యనిర్మాణం:

listname [ఇండెక్స్] = newvalue

జాబితా పేరును జాబితా పేరుతో భర్తీ చేయండి; మీరు మార్చదలిచిన అంశం యొక్క సబ్‌స్క్రిప్ట్ (ఇండెక్స్ సంఖ్య) తో సూచికను భర్తీ చేయండి; మరియు క్రొత్త విలువను మీరు జాబితా అంశంలో ఉంచాలనుకుంటున్న దానితో భర్తీ చేయండి. ఉదాహరణకు, ఈ కోడ్‌ను చూడండి:

# తీగల జాబితాను సృష్టించండి (పేర్లు).
విద్యార్థులు = ["మార్క్", "అంబర్", "టాడ్", "అనిత", "శాండీ"]
విద్యార్థులు [3] = "హోబర్ట్"
ప్రింట్ (విద్యార్థులు)

మీరు ఈ కోడ్‌ను అమలు చేస్తున్నప్పుడు, అవుట్‌పుట్ ఈ క్రింది విధంగా ఉంటుంది, ఎందుకంటే అనిత పేరు హోబర్ట్ గా మార్చబడింది.

['మార్క్', 'అంబర్', 'టాడ్', 'హోబర్ట్', 'శాండీ']

పైథాన్ జాబితాలను కలపడం

మీరు ఒకే జాబితాలో కలపాలనుకుంటున్న రెండు జాబితాలు ఉంటే, వాక్యనిర్మాణంతో పొడిగించు () ఫంక్షన్‌ను ఉపయోగించండి:

original_list.extend (additional_items_list)

మీ కోడ్‌లో, ఒరిజినల్_లిస్ట్‌ను మీరు క్రొత్త జాబితా అంశాలను జోడించే జాబితా పేరుతో భర్తీ చేయండి. అదనపు_టైమ్స్_లిస్ట్‌ను మీరు మొదటి జాబితాకు జోడించదలిచిన అంశాలను కలిగి ఉన్న జాబితా పేరుతో భర్తీ చేయండి. జాబితా 1 మరియు జాబితా 2 అనే జాబితాలను ఉపయోగించి ఒక సాధారణ ఉదాహరణ ఇక్కడ ఉంది. List1.extend (list2) ను అమలు చేసిన తరువాత, మొదటి జాబితాలో రెండు జాబితాల నుండి అంశాలు ఉంటాయి, ఎందుకంటే మీరు చివరిలో ప్రింట్ () స్టేట్మెంట్ యొక్క అవుట్పుట్లో చూడవచ్చు.

# పేర్ల యొక్క రెండు జాబితాలను సృష్టించండి.
list1 = ["జరా", "లూప్", "హాంగ్", "అల్బెర్టో", "జేక్"]
list2 = ["హ్యూయ్", "డ్యూయీ", "లూయీ", "నాడర్", "బుబ్బా"]

# జాబితా 1 కు జాబితా 2 పేర్లను జోడించండి.
list1.extend (list2)

# ప్రింట్ జాబితా 1.
ప్రింట్ (list1)

['జరా', 'లూప్', 'హాంగ్', 'అల్బెర్టో', 'జేక్', 'హ్యూయ్', 'డీవీ', 'లూయీ', 'నాడర్', 'బుబ్బా']

సులువు పార్చేసీ, లేదు?

పైథాన్ జాబితా అంశాలను తొలగిస్తోంది

పైథాన్ తొలగింపు () పద్ధతిని అందిస్తుంది, కాబట్టి మీరు జాబితా నుండి ఏదైనా విలువను తొలగించవచ్చు. అంశం జాబితాలో చాలాసార్లు ఉంటే, మొదటి సంఘటన మాత్రమే తొలగించబడుతుంది. ఉదాహరణకు, కింది కోడ్ సి అక్షరాలతో కొన్ని సార్లు పునరావృతమయ్యే అక్షరాల జాబితాను చూపిస్తుంది. జాబితా నుండి సి అక్షరాన్ని తొలగించడానికి కోడ్ అక్షరాలు.రెమోవ్ ("సి") ను ఉపయోగిస్తుంది:

# జాబితా నుండి "సి" ను తొలగించండి.
letters.remove ( "సి")

# నాకు క్రొత్త జాబితాను చూపించు.
ప్రింట్ (అక్షరాలు)

మీరు నిజంగా ఈ కోడ్‌ను అమలు చేసి, ఆపై జాబితాను ముద్రించినప్పుడు, మొదటి అక్షరం C మాత్రమే తొలగించబడిందని మీరు చూస్తారు:

['A', 'B', 'D', 'C', 'E', 'C']

మీరు అన్ని అంశాలను తీసివేయవలసి వస్తే, అంశం ఇంకా జాబితాలో ఉన్నంత వరకు .remove ను పునరావృతం చేయడానికి మీరు కాసేపు లూప్‌ను ఉపయోగించవచ్చు. ఉదాహరణకు, “సి” ఇప్పటికీ జాబితాలో ఉన్నంత వరకు ఈ కోడ్ .remove ను పునరావృతం చేస్తుంది.

# తీగల జాబితాను సృష్టించండి.
అక్షరాలు = ["A", "B", "C", "D", "C", "E", "C"]

మీరు జాబితాలోని దాని స్థానం ఆధారంగా ఒక అంశాన్ని తీసివేయాలనుకుంటే, విలువతో () తీసివేయకుండా సూచిక సంఖ్యతో పాప్ () ను ఉపయోగించండి. మీరు జాబితా నుండి చివరి అంశాన్ని తీసివేయాలనుకుంటే, ఇండెక్స్ సంఖ్య లేకుండా పాప్ () ను ఉపయోగించండి.

ఉదాహరణకు, కింది కోడ్ జాబితాను సృష్టిస్తుంది, ఒక పంక్తి మొదటి అంశాన్ని (0) తొలగిస్తుంది మరియు మరొకటి చివరి అంశాన్ని తొలగిస్తుంది (కుండలీకరణాల్లో ఏమీ లేని పాప్ ()). జాబితాను ముద్రించడం వలన ఆ రెండు అంశాలు తీసివేయబడ్డాయి:

# తీగల జాబితాను సృష్టించండి.
అక్షరాలు = ["A", "B", "C", "D", "E", "F", "G"]
 
# మొదటి అంశాన్ని తొలగించండి.
letters.pop (0)
# చివరి అంశాన్ని తొలగించండి.
letters.pop ()
 
# నాకు క్రొత్త జాబితాను చూపించు.
ప్రింట్ (అక్షరాలు)

కోడ్‌ను అమలు చేయడం వలన మొదటి మరియు చివరి అంశాలు పాపింగ్ చేయడం పని చేస్తుందని చూపిస్తుంది:

['బి', 'సి', 'డి', 'ఇ', 'ఎఫ్']

మీరు జాబితా నుండి ఒక అంశాన్ని పాప్ చేసినప్పుడు, మీరు ఆ విలువ యొక్క కాపీని కొన్ని వేరియబుల్‌లో నిల్వ చేయవచ్చు. ఉదాహరణకు ఈ చిత్రం పైన ఉన్న కోడ్‌ను చూపిస్తుంది. అయినప్పటికీ, ఇది ఫస్ట్_రెమోవ్డ్ మరియు లాస్ట్_రెమోవ్డ్ అనే వేరియబుల్స్‌లో తొలగించబడిన వాటి కాపీలను నిల్వ చేస్తుంది. చివరికి ఇది పైథాన్ జాబితాను ముద్రిస్తుంది మరియు ఏ అక్షరాలు తొలగించబడిందో కూడా చూపిస్తుంది.

పైథాన్ జాబితా నుండి అంశాలను తొలగించండి

పైథాన్ డెల్ (తొలగించడానికి చిన్నది) ఆదేశాన్ని కూడా అందిస్తుంది, ఇది ఏదైనా వస్తువును దాని సూచిక సంఖ్య (స్థానం) ఆధారంగా జాబితా నుండి తొలగిస్తుంది. కానీ మళ్ళీ, మీరు మొదటి అంశం సున్నా అని గుర్తుంచుకోవాలి. కాబట్టి, జాబితా నుండి ఐటెమ్ నంబర్ 2 ను తొలగించడానికి మీరు ఈ క్రింది కోడ్‌ను నడుపుతున్నారని చెప్పండి:

# తీగల జాబితాను సృష్టించండి.
అక్షరాలు = ["A", "B", "C", "D", "E", "F", "G"]
 
# అంశం ఉప 2 ను తొలగించండి.
డెల్ అక్షరాలు [2]
 
ప్రింట్ (అక్షరాలు)

ఆ కోడ్‌ను అమలు చేయడం ఈ క్రింది విధంగా జాబితాను మళ్లీ చూపిస్తుంది. సి అక్షరం తొలగించబడింది, ఇది తొలగించడానికి సరైన అంశం ఎందుకంటే అక్షరాలు 0, 1, 2, 3, మరియు మొదలగునవి.

['A', 'B', 'D', 'E', 'F', 'G']

మొత్తం జాబితాను తొలగించడానికి మీరు డెల్ ను కూడా ఉపయోగించవచ్చు. చదరపు బ్రాకెట్లను మరియు సూచిక సంఖ్యను ఉపయోగించవద్దు. ఉదాహరణకు, మీరు క్రింద చూసే కోడ్ జాబితాను సృష్టించి, దాన్ని తొలగిస్తుంది. తొలగింపు తర్వాత జాబితాను ముద్రించడానికి ప్రయత్నించడం లోపం కలిగిస్తుంది, ఎందుకంటే ముద్రణ () స్టేట్మెంట్ అమలు చేయబడినప్పుడు జాబితా ఉండదు.

పైథాన్ జాబితాను తొలగించండి

పైథాన్ జాబితాను క్లియర్ చేస్తోంది

మీరు జాబితా యొక్క కంటెంట్లను తొలగించాలనుకుంటే, జాబితాలోనే కాదు,. క్లియర్ () ను ఉపయోగించండి. జాబితా ఇప్పటికీ ఉంది; అయితే, ఇందులో అంశాలు లేవు. మరో మాటలో చెప్పాలంటే, ఇది ఖాళీ జాబితా. కింది కోడ్ మీరు దీన్ని ఎలా పరీక్షించవచ్చో చూపిస్తుంది. కోడ్ డిస్ప్లేలను [] చివర్లో అమలు చేయడం, జాబితా ఖాళీగా ఉందని మీకు తెలియజేస్తుంది:

# తీగల జాబితాను సృష్టించండి.
అక్షరాలు = ["A", "B", "C", "D", "E", "F", "G"]
 
# అన్ని ఎంట్రీల జాబితాను క్లియర్ చేయండి.
letters.clear ()
 
# నాకు క్రొత్త జాబితాను చూపించు.
ప్రింట్ (అక్షరాలు)

[]

పైథాన్ జాబితాలో ఒక అంశం ఎన్నిసార్లు కనిపిస్తుందో లెక్కించడం

జాబితాలో ఒక అంశం ఎన్నిసార్లు కనిపిస్తుందో లెక్కించడానికి మీరు పైథాన్ కౌంట్ () పద్ధతిని ఉపయోగించవచ్చు. ఇతర జాబితా పద్ధతుల మాదిరిగా, వాక్యనిర్మాణం సులభం:

listname.count (x)

జాబితా పేరును మీ జాబితా పేరుతో మరియు x మీరు వెతుకుతున్న విలువతో భర్తీ చేయండి (లేదా ఆ విలువను కలిగి ఉన్న వేరియబుల్ పేరు).

దిగువ చిత్రంలోని కోడ్ .count () యొక్క కుండలీకరణాల లోపల అక్షర B ని ఉపయోగించి జాబితాలో B అక్షరం ఎన్నిసార్లు కనిపిస్తుందో లెక్కిస్తుంది. ఇదే కోడ్ సి గ్రేడ్‌ల సంఖ్యను కూడా లెక్కిస్తుంది, కానీ ఆ విలువ వాక్యనిర్మాణంలో వ్యత్యాసాన్ని చూపించడానికి వేరియబుల్‌లో నిల్వ చేయబడింది. దిగువన ఉన్న ప్రోగ్రామ్ యొక్క అవుట్పుట్లో మీరు చూడగలిగినట్లుగా రెండు గణనలు పనిచేశాయి. ఏ వేరియబుల్స్ ఉపయోగించకుండా, F లను లెక్కించడానికి ఒకటి జోడించబడింది. సందేశాన్ని ప్రదర్శించే కోడ్‌లోనే F లు లెక్కించబడ్డాయి. ఎఫ్ గ్రేడ్‌లు లేవు, కాబట్టి ఇది అవుట్పుట్‌లో మీరు చూడగలిగినట్లుగా ఇది సున్నాకి తిరిగి వస్తుంది.

పైథాన్ జాబితా అంశాలను లెక్కించండి

సందేశాన్ని రూపొందించడానికి సంఖ్యలు మరియు తీగలను కలపడానికి ప్రయత్నిస్తున్నప్పుడు, మీరు str () ఫంక్షన్‌ను ఉపయోగించి సంఖ్యలను తీగలుగా మార్చాలని గుర్తుంచుకోండి. లేకపోతే, మీరు str ను ("int" కాదు) str కు మాత్రమే కలుపుతారు. ఆ సందేశంలో, పూర్ణాంకం కోసం పూర్ణాంకం చిన్నది, మరియు స్ట్రింగ్ కోసం str చిన్నది.

పైథాన్ జాబితా అంశం సూచికను కనుగొనడం

పైథాన్ ఒక .index () పద్ధతిని అందిస్తుంది, ఇది జాబితాలోని ఒక అంశం యొక్క సూచిక సంఖ్య ఆధారంగా స్థానాన్ని సూచించే సంఖ్యను అందిస్తుంది. వాక్యనిర్మాణం:

listname.index (x)

ఎప్పటిలాగే, మీరు శోధించదలిచిన జాబితా పేరుతో జాబితా పేరును మార్చండి. మీరు వెతుకుతున్న దాన్ని x ని మార్చండి (అక్షరాలా లేదా వేరియబుల్ పేరుగా, ఎప్పటిలాగే). వాస్తవానికి, అంశం జాబితాలో ఉందని ఎటువంటి హామీ లేదు, మరియు అది ఉన్నప్పటికీ, అంశం ఒక్కసారి మాత్రమే జాబితాలో ఉందని హామీ లేదు. అంశం జాబితాలో లేకపోతే, అప్పుడు లోపం సంభవిస్తుంది. అంశం జాబితాలో అనేకసార్లు ఉంటే, అప్పుడు మొదటి సరిపోలే అంశం యొక్క సూచిక తిరిగి ఇవ్వబడుతుంది.

జాబితాలో F లేనందున ప్రోగ్రామ్ f_index = grades.index (look_for) పంక్తిలో క్రాష్ అయ్యే ఉదాహరణను ఈ క్రింది చిత్రం చూపిస్తుంది.

పైథాన్ జాబితా అంశం సూచిక

ఆ సమస్యను అధిగమించడానికి ఒక సులభమైన మార్గం ఏమిటంటే, మీరు దాని సూచిక సంఖ్యను పొందడానికి ప్రయత్నించే ముందు ఒక అంశం జాబితాలో ఉందో లేదో చూడటానికి if స్టేట్మెంట్ ఉపయోగించడం. అంశం జాబితాలో లేకపోతే, అలా చెప్పే సందేశాన్ని ప్రదర్శించండి. లేకపోతే, సూచిక సంఖ్యను పొందండి మరియు సందేశంలో చూపించండి. ఆ కోడ్ క్రింది విధంగా ఉంది:

# తీగల జాబితాను సృష్టించండి.
గ్రేడ్‌లు = ["సి", "బి", "ఎ", "డి", "సి", "బి", "సి"]
# దేనికోసం నిర్ణయించుకోవాలో నిర్ణయించుకోండి
look_for = "F"
# అంశం జాబితాలో ఉందో లేదో చూడండి.
గ్రేడ్‌లలో చూస్తే_:
    # ఇది జాబితాలో ఉంటే, పొందండి మరియు సూచికను చూపండి.
    ముద్రణ (str (look_for) + "సూచిక వద్ద ఉంది" + str (grades.index (look_for)))
లేకపోతే:
    # జాబితాలో లేకపోతే, సూచిక సంఖ్య కోసం కూడా ప్రయత్నించవద్దు.
    ముద్రణ (str (look_for) + "జాబితాలో లేదు.")

పైథాన్ జాబితాలను అక్షరక్రమం మరియు క్రమబద్ధీకరించడం

పైథాన్ జాబితాలను క్రమబద్ధీకరించడానికి ఒక విధమైన () పద్ధతిని అందిస్తుంది. దాని సరళమైన రూపంలో, ఇది జాబితాలోని అంశాలను అక్షరక్రమం చేస్తుంది (అవి తీగ అయితే). జాబితాలో సంఖ్యలు ఉంటే, అవి చిన్నవి నుండి పెద్దవిగా క్రమబద్ధీకరించబడతాయి. అలాంటి సరళమైన క్రమబద్ధీకరణ కోసం, ఖాళీ కుండలీకరణాలతో క్రమబద్ధీకరణ () ను ఉపయోగించండి:

listname.sort ()

జాబితా పేరును మీ జాబితా పేరుతో భర్తీ చేయండి. కింది చిత్రం తీగల జాబితాను మరియు సంఖ్యల జాబితాను ఉపయోగించి ఒక ఉదాహరణను చూపుతుంది. ఉదాహరణలో, ప్రతి క్రమబద్ధీకరించిన జాబితాను క్రొత్త జాబితా పేరుకు కేటాయించడం ద్వారా వాటిలో ప్రతిదానికి క్రొత్త జాబితా సృష్టించబడింది. అప్పుడు కోడ్ ప్రతి క్రమబద్ధీకరించిన జాబితాలోని విషయాలను ప్రింట్ చేస్తుంది.

పైథాన్ జాబితాను క్రమబద్ధీకరించండి

మీ జాబితాలో పెద్ద అక్షరాలు మరియు చిన్న అక్షరాల మిశ్రమంతో తీగలను కలిగి ఉంటే, మరియు విధమైన ఫలితాలు సరిగ్గా కనిపించకపోతే, .sort () ను .sort (key = lambda s: s.lower ()) తో భర్తీ చేయడానికి ప్రయత్నించండి. కోడ్‌ను మళ్లీ అమలు చేస్తోంది.

తేదీలు కొద్దిగా ఉపాయాలు ఎందుకంటే మీరు వాటిని "12/31/2020" వంటి తీగలుగా టైప్ చేయలేరు. సరిగ్గా క్రమబద్ధీకరించడానికి అవి తేదీ డేటా రకంగా ఉండాలి. ప్రతి తేదీని నిర్వచించడానికి డేట్‌టైమ్ మాడ్యూల్ మరియు తేదీ () పద్ధతిని ఉపయోగించడం దీని అర్థం. మీరు ఏ ఇతర జాబితాలోనైనా తేదీలను జాబితాకు జోడించవచ్చు. ఉదాహరణకు, కింది పంక్తిలో, కోడ్ నాలుగు తేదీల జాబితాను సృష్టిస్తుంది మరియు కోడ్ ఖచ్చితంగా మంచిది.

తేదీలు = [dt.date (2020,12,31), dt.date (2019,1,31), dt.date (2018,2,28), dt.date (2020,1,1)]

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

datelist = []
పైథాన్‌లో ప్రదర్శన తేదీలు

అప్పుడు ఒక సమయంలో ఒక తేదీని dt.date (సంవత్సరం, నెల, రోజు) వాక్యనిర్మాణం ఉపయోగించి జాబితాకు చేర్చారు.

జాబితా సృష్టించబడిన తరువాత, కోడ్ వాటిని కాలక్రమానుసారం క్రమబద్ధీకరించడానికి datelist.sort () ను ఉపయోగిస్తుంది (ప్రారంభ నుండి తాజాది). మీరు ఆ కోడ్‌లో ప్రింట్ (డేట్‌లిస్ట్) ను ఉపయోగించాల్సిన అవసరం లేదు, ఎందుకంటే ఈ పద్ధతి డేటా రకం సమాచారంతో తేదీలను ప్రదర్శిస్తుంది,

[datetime.date (2018, 2, 28), datetime.date (2019, 1, 31), datetime.date (2020, 1, 1), datetime.date (2020, 12, 31)]

చదవడానికి సులభమైన జాబితా కాదు. కాబట్టి, మొత్తం జాబితాను ఒక ప్రింట్ () స్టేట్‌మెంట్‌తో ప్రింట్ చేయకుండా, మీరు జాబితాలోని ప్రతి తేదీని లూప్ చేయవచ్చు మరియు ప్రతిదాన్ని f- స్ట్రింగ్% m /% d /% Y తో ఫార్మాట్ చేయవచ్చు. ఇది ప్రతి తేదీని దాని స్వంత పంక్తిలో mm / dd / yyyy

మీరు అంశాలను రివర్స్ క్రమంలో క్రమబద్ధీకరించాలనుకుంటే, క్రమబద్ధీకరణ () కుండలీకరణాల లోపల రివర్స్ = ట్రూ ఉంచండి (మరియు మొదటి అక్షరాన్ని పెద్ద అక్షరం చేయడం మర్చిపోవద్దు). దిగువ ఉన్న చిత్రం రివర్స్ = ట్రూ ఉపయోగించి అవరోహణ (రివర్స్) క్రమంలో మూడు జాబితాలను క్రమబద్ధీకరించడానికి ఉదాహరణలు చూపిస్తుంది.

పైథాన్ జాబితాలో రివర్స్‌లో సమాచారాన్ని క్రమబద్ధీకరించండి

పైథాన్ జాబితాను తిరగరాస్తోంది

మీరు .reverse పద్ధతిని ఉపయోగించి జాబితాలోని అంశాల క్రమాన్ని కూడా రివర్స్ చేయవచ్చు. ఇది రివర్స్‌లో క్రమబద్ధీకరించడానికి సమానం కాదు, ఎందుకంటే మీరు రివర్స్‌లో క్రమబద్ధీకరించినప్పుడు, మీరు ఇప్పటికీ క్రమబద్ధీకరిస్తారు: తీగలకు Z-A, సంఖ్యల కోసం అతి పెద్దది, చిన్నది, తాజాది నుండి తేదీల వరకు. మీరు జాబితాను రివర్స్ చేసినప్పుడు, మీరు జాబితాలోని అంశాలను ఏ క్రమంలోనైనా క్రమబద్ధీకరించడానికి ప్రయత్నించకుండా, వాటి క్రమం లేకుండా రివర్స్ చేయండి.

కింది కోడ్ మీరు జాబితాలోని పేర్ల క్రమాన్ని రివర్స్ చేసి, ఆపై జాబితాను ముద్రించే ఉదాహరణను చూపుతుంది. అవుట్పుట్ జాబితా అంశాలను వాటి అసలు క్రమం నుండి తిరగరాసింది:

# తీగల జాబితాను సృష్టించండి.
పేర్లు = ["జరా", "లూప్", "హాంగ్", "అల్బెర్టో", "జేక్"]
# జాబితాను రివర్స్ చేయండి
names.reverse ()
# జాబితాను ముద్రించండి
ప్రింట్ (పేర్లు)
 
['జేక్', 'అల్బెర్టో', 'హాంగ్', 'లూప్', 'జరా']

పైథాన్ జాబితాను కాపీ చేస్తోంది

మీరు ఎప్పుడైనా జాబితా యొక్క కాపీతో పని చేయవలసి వస్తే, అసలు జాబితాను మార్చకుండా .copy () పద్ధతిని ఉపయోగించండి. ఉదాహరణకు, కింది కోడ్ మునుపటి కోడ్‌తో సమానంగా ఉంటుంది, అసలు జాబితా యొక్క క్రమాన్ని తిప్పికొట్టే బదులు, మీరు జాబితా యొక్క కాపీని తయారు చేసి, దాన్ని రివర్స్ చేయండి. ప్రతి జాబితా యొక్క విషయాలను ముద్రించడం మొదటి జాబితా ఇప్పటికీ అసలు క్రమంలో ఎలా ఉందో చూపిస్తుంది, అయితే రెండవది తారుమారు చేయబడింది:

# తీగల జాబితాను సృష్టించండి.
పేర్లు = ["జరా", "లూప్", "హాంగ్", "అల్బెర్టో", "జేక్"]
 
# జాబితా యొక్క కాపీని చేయండి
backward_names = names.copy ()
# కాపీని రివర్స్ చేయండి
backward_names.reverse ()
 
# జాబితాను ముద్రించండి
ప్రింట్ (పేర్లు)
ప్రింట్ (backward_names)
 
['జరా', 'లూప్', 'హాంగ్', 'అల్బెర్టో', 'జేక్']
['జేక్', 'అల్బెర్టో', 'హాంగ్', 'లూప్', 'జరా']

భవిష్యత్ సూచనల కోసం, ఈ క్రింది పట్టిక మీరు నేర్చుకున్న పద్ధతులను సంగ్రహిస్తుంది.