విషయ సూచిక[దాచు][చూపండి]
ఈ ఉపన్యాసం పైథాన్లోని మరొక ముఖ్యమైన నిర్మాణం గురించి, దీనిని టుపుల్ అని పిలుస్తారు.
టుపుల్స్
టుపుల్స్ జాబితాల మాదిరిగానే ఉంటాయి, కాబట్టి మేము వస్తువుల జాబితాను నిల్వ చేయడానికి వాటిని ఉపయోగించవచ్చు. కానీ జాబితాల వలె కాకుండా, మేము వాటిని సవరించలేము, కొత్త అంశాలను జోడించలేము లేదా ఇప్పటికే ఉన్న అంశాలను తీసివేయలేము. టుపుల్స్ మార్పులేనివి అని మనం చెప్పగలం.
నన్ను చూపించనివ్వు. జాబితాలలో స్క్వేర్ బ్రాకెట్లకు బదులుగా కుండలీకరణం ద్వారా టుపుల్స్ గుర్తించబడతాయి.
numbers = (4, 1, 7, 5, 0, 9)
ఇప్పుడు, మేము tuples కోసం పద్ధతుల జాబితాను తీసివేస్తే, మా వద్ద అనుబంధం లేదా చొప్పించే పద్ధతులు లేవని మీరు చూడవచ్చు కాబట్టి ఈ tupleకి కొత్త అంశాలు జోడించబడవు. మాకు రెండు పద్ధతులు మాత్రమే ఉన్నాయి: కౌంట్ మరియు ఇండెక్స్.
మేము ఒక అంశం యొక్క సంఘటనల సంఖ్యను లెక్కించడానికి “గణన” ఉపయోగిస్తాము. "సూచిక" అనేది ఒక అంశం యొక్క మొదటి సంఘటన యొక్క సూచికను కనుగొనడానికి ఉపయోగించబడుతుంది. కాబట్టి, మేము టుపుల్ గురించి మాత్రమే సమాచారాన్ని పొందగలము మరియు దానిని మార్చలేము. మార్గం ద్వారా, మీరు ఇక్కడ చూసే ఈ ఇతర పద్ధతులు, రెండు అండర్స్కోర్లతో ప్రారంభించండి.
వీటిని మేజిక్ పద్ధతులుగా పేర్కొంటాం. అవి మరింత అధునాతనమైన అంశం, మరియు మేము మా భవిష్యత్ సిరీస్లో వాటిని తాకుతాము.
మార్పులేనివి కాకుండా, టుపుల్స్ జాబితా యొక్క చాలా లక్షణాలను పంచుకుంటాయి.
ఆచరణాత్మకంగా చెప్పాలంటే, మీరు ఎక్కువ సమయం జాబితాలను ఉపయోగిస్తున్నారు, కానీ టుపుల్స్ కూడా ఉపయోగకరంగా ఉంటాయి. మీరు అంశాల జాబితాను సృష్టించి, మీ ప్రోగ్రామ్లో ఎక్కడా అనుకోకుండా ఆ జాబితాను సవరించకుండా చూసుకోవాలనుకుంటే, టుపుల్ని ఉపయోగించడం మంచిది.
మూట విడదీయుట
ఈ విభాగంలో, నేను మీకు శక్తివంతమైన లక్షణాన్ని చూపబోతున్నాను, మేము అన్ప్యాకింగ్ అనే పైథాన్లో కలిగి ఉన్నాము.
టుపుల్ “కోఆర్డినేట్”ని నిర్వచిద్దాం
coordinate = (1, 2, 3)
ఇప్పుడు, ఇవి 'x', 'y' మరియు 'z' కోఆర్డినేట్లు అని ఊహించుకోండి. ఇప్పుడు మనం ఈ విలువలను పొందాలనుకుంటున్నాము మరియు వాటిని మా ప్రోగ్రామ్లో కొన్ని క్లిష్టమైన వ్యక్తీకరణలలో ఉపయోగించాలనుకుంటున్నాము. బహుశా, మేము వాటిని పెద్ద సంక్లిష్ట సూత్రంలో భాగంగా చేర్చాలనుకుంటున్నాము.
కాబట్టి, కలిసి మనం ఇలా కోడ్ రాయాలి:
coordinate[0] * coordinate[1] * coordinate[2]
ఈ కోడ్ లైన్ అన్ని కోఆర్డినేట్లను గుణిస్తుంది కానీ మన కోడ్ని ఇలా వ్రాయడం అసమర్థమైనది. ముందుగా, ఒక మంచి విధానాన్ని ఉపయోగించుకుందాం మరియు ఈ కోఆర్డినేట్లను ప్రత్యేక వేరియబుల్స్లో నిల్వ చేద్దాం.
x = coordinate[0]
y = coordinate[1]
z = coordinate[2]
అది మేలు. సరియైనదా? కాబట్టి ఇప్పటివరకు కొత్తది ఏమీ లేదు. ఇప్పుడు, అన్ప్యాకింగ్ అనే శక్తివంతమైన ఫీచర్ని మీకు చూపిస్తాను మరియు దానితో, మేము చాలా తక్కువ కోడ్తో అదే ఫలితాన్ని సాధించగలము.
x, y, z, = coordinate
ఇప్పుడు, ఈ సింగిల్ లైన్ కోడ్ పైన వ్రాసిన మూడు లైన్ల కోడ్కి సరిగ్గా సమానం. ఇది ఎలా పని చేస్తుందో మీకు వివరిస్తాను.
పైథాన్ వ్యాఖ్యాత ఈ ప్రకటనను చూసినప్పుడు, అది ఈ టుపుల్లోని మొదటి అంశాన్ని పొందుతుంది మరియు దానిని వేరియబుల్కు కేటాయిస్తుంది. అదేవిధంగా, రెండవ మరియు మూడవ అంశాలు వేరియబుల్స్కు కేటాయించబడతాయి. ఇలా చేయడం ద్వారా, మేము ఈ టుపుల్ని 3 వేరియబుల్స్గా అన్ప్యాక్ చేస్తున్నాము. మన అవుట్పుట్ని తనిఖీ చేద్దాం.
జాబితాలతో అన్ప్యాకింగ్ కూడా చేయవచ్చు.
డిక్షనరీలు
మనం పైథాన్లోని నిఘంటువుల గురించి నేర్చుకోబోతున్నాం. కీ-విలువ జంటలుగా వచ్చే సమాచారాన్ని నిల్వ చేయాలనుకున్న సందర్భాల్లో మేము నిఘంటువులను ఉపయోగిస్తాము.
ఇక్కడ ఒక ఉదాహరణ. పేరు, ఇమెయిల్, ఫోన్ నంబర్, చిరునామా మొదలైన అనేక లక్షణాలతో కస్టమర్ గురించి ఆలోచించండి. ఇప్పుడు ఈ లక్షణాలలో ప్రతిదానికి ఒక విలువ ఉంది. ఉదాహరణకి:
name = Jay
email = [email protected]
ఈ ఉదాహరణలో, మా కీలు పేరు, ఇమెయిల్ మరియు ఫోన్. ప్రతి కీ ఒక విలువతో అనుబంధించబడి ఉంటుంది కాబట్టి ఇక్కడే మనం నిఘంటువుని ఉపయోగిస్తాము. నిఘంటువుతో, మేము కీ-విలువ జతల సమూహాన్ని నిల్వ చేయవచ్చు. పైథాన్లో నిఘంటువుని ఎలా నిర్వచించాలో నేను మీకు చూపుతాను.
customer = {
"name": "Jay",
"email": "[email protected]",
"age": 30,
"is_verified": True
}
కీని స్ట్రింగ్లు, నంబర్లు, బూలియన్ లేదా దేనికైనా సెట్ చేయవచ్చు. కీలు ప్రత్యేకమైనవి మరియు ఒక్కసారి మాత్రమే నిర్వచించబడతాయి, అనగా నేను "వయస్సు"ని మరొక సంఖ్యతో మళ్లీ నిర్వచించలేను. అవి కూడా కేస్ సెన్సిటివ్.
ఇప్పుడు, నేను టైప్ చేస్తే customer["name"],
అది కస్టమర్ పేరును పిలుస్తుంది. దీన్ని టెర్మినల్లో ప్రింట్ చేద్దాం:
మేము నిఘంటువులతో ఉన్న పద్ధతులను కూడా ఉపయోగించవచ్చు. పైన ప్రదర్శించిన అదే ఫంక్షన్ను "గెట్" పద్ధతిని ఉపయోగించడం ద్వారా పునరావృతం చేయవచ్చు.
పై రెండు పద్ధతుల మధ్య ఒక ప్రత్యేక వ్యత్యాసం ఉంది. నేను దానిని ప్రదర్శించనివ్వండి.
మేము కేవలం ఉనికిలో లేని కీని ప్రింట్ చేసినప్పుడు, అది ఎర్రర్కు దారితీసిందని మీరు చూడవచ్చు. మరోవైపు, ఉనికిలో లేని కీని కాల్ చేయడానికి పద్ధతిని ఉపయోగించడం వలన విలువ లేకపోవడాన్ని సూచించే “ఏదీ లేదు” ఫలితం వస్తుంది. "గెట్" పద్ధతిని ఉపయోగిస్తున్నప్పుడు, మేము డిఫాల్ట్ విలువను కూడా సరఫరా చేయవచ్చు.
ఉదాహరణకు, ఈ డిక్షనరీలో “పుట్టిన తేదీ” కీ లేకుంటే, మేము దానిని ఇలా సరఫరా చేయవచ్చు:
customer.get("birthdate", "Jan 01, 1994")
మేము జాబితాలోని ఏదైనా కీని కూడా నవీకరించవచ్చు. మన డిక్షనరీలో నేమ్ కీని అప్డేట్ చేయాలనుకుంటున్నాము అనుకుందాం. మేము దీన్ని ఎలా చేస్తాము.
customer["name"] = "Shahbaz"
మా నిఘంటువులో కూడా కొత్త కీని జోడించడానికి ఇదే విధమైన సింటాక్స్ ఉపయోగించవచ్చు. అదే పద్ధతిలో “పుట్టిన తేదీ” కీని జోడిద్దాం.
customer["birthdate"] = "Jan 01, 1994"
కాబట్టి, పైథాన్లో నిఘంటువులను ఉపయోగించడం యొక్క ప్రాథమిక అంశాలు ఇది. అవి చాలా ముఖ్యమైనవి మరియు వాస్తవ ప్రపంచంలో వాటికి చాలా అప్లికేషన్లు ఉన్నాయి.
వ్యాయామం
మీరు అంకెలను ఇలా పదాలుగా మార్చే ప్రోగ్రామ్ను వ్రాయబోతున్నారు:
సొల్యూషన్
మీ కోసం ఇక్కడ పరిష్కారం ఉంది.
phone = input("Phone: ")
digits_mapping = {
"1": "One",
"2": "Two",
"3": "Three",
"4": "Four",
"5": "Five",
"6": "Six",
"7": "Seven",
"8": "Eight",
"9": "Nine",
"0": "Zero"
}
output = " "
for ch in phone:
output += digits_mapping.get(ch, "!") + " "
print(output)
అదేవిధంగా, మీరు "ఎమోజి కన్వర్టర్" వంటి ఇతర సరదా ప్రోగ్రామ్లను రూపొందించవచ్చు పైథానర్లను ఆనందించండి!
ముగించు!
మీరు ఈ ఉపన్యాసాన్ని ఆస్వాదించారని నేను ఆశిస్తున్నాను. తరువాత, మేము పైథాన్ ప్రోగ్రామింగ్, విధులు మరియు పారామితుల యొక్క ముఖ్యమైన అంశంలోకి ప్రవేశించబోతున్నాము.
సమాధానం ఇవ్వూ