ప్రోగ్రామింగ్‌లో, జాబితాలు శ్రేణుల వలె డేటా నిర్మాణం వలె ఉపయోగపడతాయి. జాబితాలు ఏమిటి, వాటిని ఎలా సృష్టించాలి? పైథాన్‌లోని జాబితాలతో ఎలా పని చేయాలి? మీరు మా వ్యాసం నుండి దీని గురించి నేర్చుకుంటారు.

పైథాన్‌లో జాబితాలు ఏమిటి?

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

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

దాని అర్థం ఏమిటి? నిర్వచనాన్ని వివరంగా పరిశీలిద్దాం.

జాబితా యొక్క పరిమాణాన్ని మార్చవచ్చు, తగ్గించవచ్చు, దానికి కొత్త పంక్తులు జోడించబడతాయి. మీరు జాబితా యొక్క మొత్తం నిర్మాణాన్ని కూడా మార్చవచ్చు. జాబితాలోని పద్ధతిని ఉపయోగించిన ప్రతిసారీ, అసలు జాబితా మార్చబడుతుందని గుర్తుంచుకోండి, కాపీ కాదు.

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

జాబితాను రూపొందించడానికి మార్గాలు

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

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

చివరికి ఏమి జరుగుతుందో ఇక్కడ ఉంది:

>>> జాబితా('జాబితా') ['c', 'n', 'i', 'c', 'o', 'to']

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

>>> s = [] # ఖాళీ జాబితా >>> l = ['s', 'p', ['isok'], 2] >>> s [] >>> l ['s', 'p' , ['isok'], 2]

జాబితాలను రూపొందించే తదుపరి, మూడవ మార్గం అని పిలవబడేది జాబితా జెనరేటర్.

లిస్టింగ్ జెనరేటర్ అనేది జాబితాలను రూపొందించడానికి ఒక వాక్యనిర్మాణ నిర్మాణం. ఇది ఫర్ లూప్ మాదిరిగానే ఉంటుంది.

>>> c = ['జాబితా'లో c కోసం 3] >>> c ['lll', 'iii', 'sss', 'ttt']

ఇది మరింత భారీ నిర్మాణాలను రూపొందించడానికి కూడా ఉపయోగించవచ్చు:

>>> c = [c * 3 for 'list' if c != 'i'] >>> c ['lll', 'sss', 'ttt'] >>> c = [c + d for 'జాబితా'లో c != 'i' అయితే 'స్పామ్'లో d ఉంటే != 'a'] >>> c ['ls', 'lp', 'lm', 'ss', 'sp' , 'sm', 'ts', 'tp', 'tm']

అయినప్పటికీ, బహుళ జాబితాలను కంపైల్ చేసేటప్పుడు ఈ తరం పద్ధతి ఎల్లప్పుడూ సమర్థవంతంగా ఉండదు. కాబట్టి, జాబితాలను రూపొందించడానికి for loopని ఉపయోగించడం మంచిది.

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

సూచిక అనేది జాబితాలోని మూలకం యొక్క సంఖ్య.

మీరు జాబితాను పునరావృతమయ్యే, ఒకేలాంటి అంశాలతో పూరించాలనుకుంటే, * చిహ్నం ఉపయోగించబడుతుంది. ఉదాహరణకు, మీరు జాబితాకు మూడు సారూప్య సంఖ్యలను జోడించాలి: [100] * 3.

జాబితా విధులు

విధులు - ఇది బహుశా ఇతర ప్రోగ్రామింగ్ భాషల కంటే పైథాన్ యొక్క ప్రధాన ప్రయోజనం. ప్రాథమిక అంతర్నిర్మిత విధులు జాబితాలకు వర్తించవచ్చు.

వాటిలో అత్యంత ప్రాచుర్యం పొందిన వాటిని పరిగణించండి:

• జాబితా(పరిధి()) – ఒక సీక్వెన్షియల్ జాబితాను సృష్టించడం పని అయితే, పరిధి ఫంక్షన్ ఉపయోగించబడుతుంది. ఈ ఫంక్షన్ క్రింది రూపాలను కలిగి ఉంది:

1. పరిధి(ముగింపు). సున్నా నుండి పరిమిత సంఖ్య వరకు జాబితాను సృష్టించడానికి అవసరమైనప్పుడు ఇది ఉపయోగించబడుతుంది.
2. పరిధి (ప్రారంభం, ముగింపు). ప్రారంభం మరియు ముగింపు సంఖ్యలు రెండూ పేర్కొనబడ్డాయి.
3. పరిధి (ప్రారంభం, ముగింపు, దశ). దశ పరామితి ఎంపిక లక్షణాన్ని నిర్దేశిస్తుంది. ఉదాహరణకు, మీరు 1 నుండి 21 వరకు ఉన్న సీక్వెన్స్ నుండి ప్రతి ఐదవ సంఖ్యను ఎంచుకోవలసి ఉంటే, ఫలితంగా జాబితా ఇలా కనిపిస్తుంది: [10,15, 20].

పరిధి ఫంక్షన్ కోడ్ మొత్తాన్ని గణనీయంగా తగ్గిస్తుంది.

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

మీరు ఇతర అంతర్నిర్మిత ఫంక్షన్లను కూడా ఉపయోగించవచ్చు:

• జాబితా (టుపుల్) - టుపుల్ ఆబ్జెక్ట్‌ను జాబితాగా మారుస్తుంది.
• మొత్తం (జాబితా) - అన్ని విలువలు సంఖ్యలు అయితే, పూర్ణాంకాలు మరియు దశాంశాలు రెండింటికీ వర్తింపజేస్తే జాబితాలోని అన్ని మూలకాలను సంగ్రహిస్తుంది. అయినప్పటికీ, ఆమె ఎల్లప్పుడూ సరిగ్గా అర్థం చేసుకోదు. జాబితాలో సంఖ్యేతర మూలకం ఉన్నట్లయితే, ఫంక్షన్ లోపాన్ని విసురుతుంది: “టైప్‌ఎర్రర్: +: 'int' మరియు 'str' కోసం మద్దతు లేని ఒపెరాండ్ రకం(లు)”.

జాబితా పద్ధతులు

స్టోర్‌లో కొనుగోలు చేయడానికి మా వస్తువుల జాబితాకు తిరిగి వెళ్లి దానిని షాప్‌లిస్ట్ అని పిలుద్దాం:

దుకాణ జాబితా = []

తరువాత, జాబితా పద్ధతులను పరిగణించండి:

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

సరైన ఉత్పత్తులతో మా కొత్త జాబితాను పూరించండి:

shoplist.append(రొట్టె)

shoplist.append(పాలు)

• జాబితా.పొడిగించు(A) - "జాబితాకు జాబితా" జోడిస్తుంది. మీరు ఒకే సమయంలో అనేక అంశాలను జోడించవచ్చు కాబట్టి ఈ ఫీచర్ సమయాన్ని ఆదా చేస్తుంది. మేము ఇప్పటికే పండ్ల జాబితాను కలిగి ఉన్నామని చెప్పండి, మేము వాటిని ప్రధాన జాబితాకు జోడించాలి.

shoplist.extend(పండ్లు)

• చొప్పించు (సూచిక, అంశం) - పేర్కొన్న సూచికకు ముందు పేర్కొన్న విలువను పేర్కొన్న సూచికతో మూలకంపై ఇన్సర్ట్ చేస్తుంది.
• లెక్కింపు(అంశం) - మూలకం యొక్క పునరావృతాల సంఖ్యను చూపుతుంది.
• జాబితా.తొలగించు(అంశం) వ్యతిరేక ఫంక్షన్ జాబితా.జోడించు (x). ఇది ఏదైనా మూలకాన్ని తొలగించడానికి ఉపయోగించవచ్చు. ఎంచుకున్న అంశం జాబితాలో లేకుంటే, లోపం నివేదించబడుతుంది.
• పాప్ ([సూచిక]) - ఎంచుకున్న మూలకాన్ని తీసివేసి, అదే విధంగా తిరిగి ఇస్తుంది. మూలకం పేర్కొనబడకపోతే, చివరి మూలకం జాబితా నుండి తీసివేయబడుతుంది.
• క్రమబద్ధీకరించు ([కీ]) – లిస్టింగ్‌లోని మూలకాలను ఆరోహణ క్రమంలో ఉంచుతుంది, కానీ మీరు ఒక ఫంక్షన్‌ను కూడా పేర్కొనవచ్చు.
• సూచిక(అంశం) - మొదట ఎంచుకున్న మూలకం యొక్క సూచికను చూపుతుంది.
• మీరు జాబితాను విస్తరించవచ్చు, అంటే, పద్ధతిని ఉపయోగించి దాని అన్ని అంశాలను ప్రతిబింబిస్తుంది రివర్స్ (జాబితా). చివరి మూలకం మొదటిది అవుతుంది, చివరి మూలకం రెండవది అవుతుంది, మొదలైనవి.
• జాబితా యొక్క నకలు ఆదేశంతో సృష్టించబడుతుంది కాపీ (జాబితా).
• డీప్‌కాపీ(జాబితా) - లోతైన కాపీ.
• పద్ధతిని ఉపయోగించి అన్ని లిస్టింగ్ ఎలిమెంట్‌లను తీసివేయండి స్పష్టమైన జాబితా).

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

>>> l = [1, 2, 3, 5, 7] >>> l.sort() >>> l [1, 2, 3, 5, 7] >>> l = l.sort() > >> ప్రింట్(ఎల్) ఏదీ లేదు

జాబితాలతో పని చేయడానికి క్రింది ఉదాహరణ:

>>> a = [66.25, 333, 333, 1, 1234.5] >>> ప్రింట్(a.count(333), a.count(66.25), a.count('x')) 2 1 0 >>> a.insert(2, -1) >>> a.append(333) >>> a [66.25, 333, -1, 333, 1, 1234.5, 333] >>> a.index(333) 1 >> > a.remove(333) >>> a [66.25, -1, 333, 1, 1234.5, 333] >>> a.reverse() >>> a [333, 1234.5, 1, 333, -1, 66.25 ] >>> a.sort() >>> a [-1, 1, 66.25, 333, 333, 1234.5]