01. హలో వరల్డ్
02. రెండు తీగలను చేరండి
03. స్ట్రింగ్‌లో ఫ్లోటింగ్ పాయింట్‌ని ఫార్మాట్ చేయండి
04. శక్తికి సంఖ్యను పెంచండి
05. బూలియన్ రకాలతో పని చేస్తోంది
06. లేకపోతే ప్రకటన
07. AND మరియు OR ఆపరేటర్లను ఉపయోగించడం
08. కేసు స్టేట్‌మెంట్‌ను మార్చండి
09. లూప్ అయితే
10. లూప్ కోసం
పదకొండు. ఒక పైథాన్ స్క్రిప్ట్‌ను మరొకదాని నుండి అమలు చేయండి
12. కమాండ్-లైన్ ఆర్గ్యుమెంట్ యొక్క ఉపయోగం
13 రెగెక్స్ ఉపయోగం
14 గెట్‌పాస్ ఉపయోగం
పదిహేను. తేదీ ఫార్మాట్ ఉపయోగం
16. జాబితా నుండి అంశాన్ని జోడించండి మరియు తీసివేయండి
17. జాబితా అవగాహన
18 స్లైస్ డేటా
19. నిఘంటువులో డేటాను జోడించండి మరియు శోధించండి
ఇరవై. సెట్‌లో డేటాను జోడించండి మరియు శోధించండి
ఇరవై ఒకటి. జాబితాలో అంశాలను లెక్కించండి
22 ఒక ఫంక్షన్‌ను నిర్వచించండి మరియు కాల్ చేయండి
2. 3. త్రో మరియు క్యాచ్ మినహాయింపు ఉపయోగం
24. ఫైల్‌ను చదవండి మరియు వ్రాయండి
25 డైరెక్టరీలో ఫైల్‌లను జాబితా చేయండి
26. ఊరగాయ ఉపయోగించి చదవండి మరియు వ్రాయండి
27. తరగతి మరియు పద్ధతిని నిర్వచించండి
28 పరిధి ఫంక్షన్ ఉపయోగం
29. మ్యాప్ ఫంక్షన్ ఉపయోగం
30. ఫిల్టర్ ఫంక్షన్ ఉపయోగం
మొదటి పైథాన్ స్క్రిప్ట్‌ను సృష్టించండి మరియు అమలు చేయండి:
మీరు పైథాన్ ఫైల్‌ను సృష్టించకుండానే టెర్మినల్ నుండి ఒక సాధారణ పైథాన్ స్క్రిప్ట్ వ్రాయవచ్చు మరియు అమలు చేయవచ్చు. స్క్రిప్ట్ పెద్దది అయితే, దానికి రాయడం అవసరం మరియు ఏదైనా ఎడిటర్‌ని ఉపయోగించి ఏదైనా పైథాన్ ఫైల్‌లో స్క్రిప్ట్‌ను సేవ్ చేస్తుంది. మీరు స్క్రిప్ట్ రాయడానికి పైచార్మ్ లేదా స్పైడర్ వంటి పైథాన్ కోసం అభివృద్ధి చేసిన ఏదైనా టెక్స్ట్ ఎడిటర్ లేదా ఉత్కృష్ట, విజువల్ స్టూడియో కోడ్ లేదా ఏదైనా IDE సాఫ్ట్‌వేర్‌ను ఉపయోగించవచ్చు. పైథాన్ ఫైల్ యొక్క పొడిగింపు .పై . పైథాన్ వెర్షన్ 3.8 ఇంకా స్పైడర్ 3 పైథాన్ స్క్రిప్ట్ రాయడానికి ఈ వ్యాసంలో పైథాన్ యొక్క IDE ఉపయోగించబడింది. మీరు ఇన్‌స్టాల్ చేయాలి గూఢచారి దాన్ని ఉపయోగించడానికి మీ సిస్టమ్‌లో IDE.
మీరు టెర్మినల్ నుండి ఏదైనా స్క్రిప్ట్‌ను అమలు చేయాలనుకుంటే, 'రన్ చేయండి కొండచిలువ ' లేదా ' పైథాన్ 3 ' పరస్పర మోడ్‌లో పైథాన్‌ను తెరవడానికి ఆదేశం. కింది పైథాన్ స్క్రిప్ట్ టెక్స్ట్‌ను ప్రింట్ చేస్తుంది హలో వరల్డ్ అవుట్‌పుట్‌గా.
>>> ముద్రణ(హలో వరల్డ్)
ఇప్పుడు, స్క్రిప్ట్ పేరు ఉన్న ఫైల్‌లో సేవ్ చేయండి c1.py . అమలు చేయడానికి మీరు టెర్మినల్ నుండి కింది ఆదేశాన్ని అమలు చేయాలి c1.py .
$ పైథాన్ 3 c1.పై
మీరు ఫైల్‌ను అమలు చేయాలనుకుంటే స్పైడర్ 3 IDE, అప్పుడు మీరు దానిపై క్లిక్ చేయాలి అమలు బటన్
ఎడిటర్ యొక్క. కోడ్‌ను అమలు చేసిన తర్వాత కింది అవుట్‌పుట్ ఎడిటర్‌లో కనిపిస్తుంది.
టాప్రెండు తీగలను కలపడం:
పైథాన్‌లో స్ట్రింగ్ విలువలను చేరడానికి అనేక మార్గాలు ఉన్నాయి. పైథాన్‌లో రెండు స్ట్రింగ్ విలువలను కలపడానికి అత్యంత సులభమైన మార్గం ‘+’ ఆపరేటర్‌ను ఉపయోగించడం. రెండు స్ట్రింగ్‌లలో చేరడానికి మార్గం తెలుసుకోవడానికి క్రింది స్క్రిప్ట్‌తో ఏదైనా పైథాన్‌ను సృష్టించండి. ఇక్కడ, రెండు స్ట్రింగ్ విలువలు రెండు వేరియబుల్స్‌లో కేటాయించబడతాయి మరియు తరువాత ముద్రించిన జాయింట్ వాల్యూస్‌ని నిల్వ చేయడానికి మరొక వేరియబుల్ ఉపయోగించబడుతుంది.
c2.py
స్ట్రింగ్ 1= 'లైనక్స్'స్ట్రింగ్ 2= 'సూచన'
join_string=స్ట్రింగ్ 1 + స్ట్రింగ్ 2
ముద్రణ(join_string)
ఎడిటర్ నుండి స్క్రిప్ట్‌ను అమలు చేసిన తర్వాత కింది అవుట్‌పుట్ కనిపిస్తుంది. ఇక్కడ రెండు మాటలు, లైనక్స్ మరియు సూచన చేరాయి, మరియు LinuxHint అవుట్‌పుట్‌గా ముద్రించబడింది.
మీరు పైథాన్‌లోని ఇతర జాయినింగ్ ఆప్షన్ గురించి మరింత తెలుసుకోవాలనుకుంటే, మీరు ట్యుటోరియల్, పైథాన్ స్ట్రింగ్ కాన్కాటనేషన్‌ను తనిఖీ చేయవచ్చు.
స్ట్రింగ్‌లో ఫ్లోటింగ్ పాయింట్‌ని ఫార్మాట్ చేయండి:
పాక్షిక సంఖ్యలను రూపొందించడానికి ప్రోగ్రామింగ్‌లో ఫ్లోటింగ్ పాయింట్ సంఖ్య అవసరం, మరియు కొన్నిసార్లు ప్రోగ్రామింగ్ ప్రయోజనాల కోసం ఫ్లోటింగ్ పాయింట్ నంబర్‌ను ఫార్మాట్ చేయడం అవసరం. ఫ్లోటింగ్-పాయింట్ సంఖ్యను ఫార్మాట్ చేయడానికి పైథాన్‌లో అనేక మార్గాలు ఉన్నాయి. స్ట్రింగ్ ఫార్మాటింగ్ మరియు స్ట్రింగ్ ఇంటర్‌పోలేషన్ ఫ్లోటింగ్-పాయింట్ నంబర్‌ని ఫార్మాట్ చేయడానికి క్రింది స్క్రిప్ట్‌లో ఉపయోగించబడతాయి. ఫార్మాట్ () స్ట్రింగ్ ఫార్మాటింగ్‌లో ఫార్మాట్ వెడల్పు ఉన్న పద్ధతి ఉపయోగించబడుతుంది మరియు స్ట్రింగ్ ఇంటర్‌పోలేషన్‌లో 'వెడల్పు ఉన్న ఫార్మాట్‌తో% సింబల్ ఉపయోగించబడుతుంది. ఫార్మాటింగ్ వెడల్పు ప్రకారం, దశాంశ బిందువుకు ముందు 5 అంకెలు, దశాంశ బిందువు తర్వాత 2 అంకెలు సెట్ చేయబడతాయి.
c3.py
# స్ట్రింగ్ ఫార్మాటింగ్ ఉపయోగంఫ్లోట్ 1= 563.78453
ముద్రణ('{: 5.2f}'.ఫార్మాట్(ఫ్లోట్ 1))
# స్ట్రింగ్ ఇంటర్‌పోలేషన్ ఉపయోగం
తేలు 2= 563.78453
ముద్రణ('%5.2f'% ఫ్లోట్ 2)
ఎడిటర్ నుండి స్క్రిప్ట్‌ను అమలు చేసిన తర్వాత కింది అవుట్‌పుట్ కనిపిస్తుంది.
మీరు పైథాన్‌లో స్ట్రింగ్ ఫార్మాటింగ్ గురించి మరింత తెలుసుకోవాలనుకుంటే, మీరు పైథాన్ స్ట్రింగ్ ఫార్మాటింగ్ ట్యుటోరియల్‌ని తనిఖీ చేయవచ్చు.
శక్తికి సంఖ్యను పెంచండి:
పైథాన్‌లో లెక్కించడానికి అనేక మార్గాలు ఉన్నాయి xఎన్ పైథాన్‌లో. కింది స్క్రిప్ట్‌లో, లెక్కించడానికి మూడు మార్గాలు చూపబడ్డాయి xn పైథాన్‌లో. డబుల్ ' * ’ ఆపరేటర్, NS() పద్ధతి, మరియు గణితం.పో () xn లెక్కించడానికి ఈ పద్ధతి ఉపయోగించబడుతుంది. యొక్క విలువలు x మరియు ఎన్ సంఖ్యా విలువలతో ప్రారంభించబడింది. డబుల్ ' * ’ మరియు NS() పూర్ణాంక విలువల శక్తిని లెక్కించడానికి పద్ధతులు ఉపయోగించబడతాయి. గణితం.పో () పాక్షిక సంఖ్యల శక్తిని లెక్కించవచ్చు; అలాగే, అది స్క్రిప్ట్ చివరి భాగంలో చూపబడింది.
c4.py
దిగుమతి గణితం# విలువలను x మరియు n కి కేటాయించండి
x= 4
ఎన్= 3
# పద్ధతి 1
శక్తి=x ** n
ముద్రణ(' %d శక్తికి %d %d'%(x,ఎన్,శక్తి))
# పద్ధతి 2
శక్తి= NS(x,ఎన్)
ముద్రణ(' %d శక్తికి %d %d'%(x,ఎన్,శక్తి))
# పద్ధతి 3
శక్తి= గణితం.NS(2,6.5)
ముద్రణ(' %d నుండి శక్తి %d %5.2f'%(x,ఎన్,శక్తి))
స్క్రిప్ట్ అమలు చేసిన తర్వాత కింది అవుట్‌పుట్ కనిపిస్తుంది. మొదటి రెండు అవుట్‌పుట్‌లు ఫలితాన్ని చూపుతాయి 43, మరియు మూడవ అవుట్‌పుట్ ఫలితాన్ని చూపుతుంది 26.5 .
టాప్బూలియన్ రకాలతో పని చేయడం:
బూలియన్ రకాల వివిధ ఉపయోగాలు క్రింది స్క్రిప్ట్‌లో చూపబడ్డాయి. మొదటి అవుట్‌పుట్ బూలియన్ విలువను కలిగి ఉన్న వాల్యూ 1 విలువను ప్రింట్ చేస్తుంది, నిజం అన్ని పాజిటివ్‌లు ప్రతికూల సంఖ్యలు తిరిగి వస్తాయి నిజం బూలియన్ విలువ మరియు సున్నా రాబడి మాత్రమే తప్పుడు బూలియన్ విలువగా. కాబట్టి, రెండవ మరియు మూడవ అవుట్‌పుట్‌లు ముద్రించబడతాయి నిజం సానుకూల మరియు ప్రతికూల సంఖ్యల కోసం. నాల్గవ అవుట్‌పుట్ 0 కోసం తప్పుడు ముద్రించబడుతుంది మరియు ఐదవ అవుట్‌పుట్ ముద్రించబడుతుంది తప్పుడు ఎందుకంటే పోలిక ఆపరేటర్ తిరిగి వస్తాడు తప్పుడు .
c5.py
# బూలియన్ విలువవాల్యూ 1= నిజమే
ముద్రణ(వాల్యూ 1)
# బూలియన్ సంఖ్య
సంఖ్య= 10
ముద్రణ(బూల్(సంఖ్య))
సంఖ్య=-5
ముద్రణ(బూల్(సంఖ్య))
సంఖ్య= 0
ముద్రణ(బూల్(సంఖ్య))
పోలిక ఆపరేటర్ నుండి # బూలియన్
వాల్యూ 1= 6
వాల్యూ 2= 3
ముద్రణ(వాల్యూ 1<వాల్యూ 2)
స్క్రిప్ట్ అమలు చేసిన తర్వాత కింది అవుట్‌పుట్ కనిపిస్తుంది.
టాప్If if స్టేట్మెంట్ ఉపయోగించండి:
కింది స్క్రిప్ట్ పైథాన్‌లో షరతులతో కూడిన స్టేట్మెంట్ ఉపయోగించడాన్ని చూపుతుంది. యొక్క ప్రకటన if-else పైథాన్‌లో స్టేట్మెంట్ ఇతర భాషల కంటే కొద్దిగా భిన్నంగా ఉంటుంది. ఇతర భాషలలాగా పైథాన్‌లో if-else బ్లాక్‌ను నిర్వచించడానికి వంకర బ్రాకెట్‌లు అవసరం లేదు, కానీ ఇండెంటేషన్ బ్లాక్‌ను సరిగ్గా ఉపయోగించాలి, లేకపోతే స్క్రిప్ట్ లోపం చూపుతుంది. ఇక్కడ, చాలా సింపుల్ if-else స్టేట్మెంట్ స్క్రిప్ట్‌లో ఉపయోగించబడుతుంది, ఇది నంబర్ వేరియబుల్ విలువ 70 లేదా అంతకంటే ఎక్కువ లేదా సమానంగా ఉందో లేదో తనిఖీ చేస్తుంది. ఎ పెద్దప్రేగు (:) 'తర్వాత ఉపయోగించబడుతుంది ఉంటే ' మరియు ' లేకపోతే' బ్లాక్ ప్రారంభాన్ని నిర్వచించడానికి బ్లాక్.
c6.py
# సంఖ్యా విలువను కేటాయించండిసంఖ్య= 70
# 70 కంటే ఎక్కువ ఉందో లేదో తనిఖీ చేయండి
ఉంటే (సంఖ్య> = 70):
ముద్రణ('నువ్వు పాసయ్యావు')
లేకపోతే:
ముద్రణ('నువ్వు పాస్ కాలేదు')
స్క్రిప్ట్ అమలు చేసిన తర్వాత కింది అవుట్‌పుట్ కనిపిస్తుంది.
టాప్AND మరియు OR ఆపరేటర్ల ఉపయోగం:
కింది స్క్రిప్ట్ యొక్క ఉపయోగాలను చూపుతుంది మరియు మరియు లేదా నియత ప్రకటనలో ఆపరేటర్లు. మరియు ఆపరేటర్ తిరిగి వస్తాడు నిజం రెండు పరిస్థితులు తిరిగి వచ్చినప్పుడు నిజం, మరియు లేదా ఆపరేటర్ తిరిగి వస్తాడు నిజం రెండు షరతుల యొక్క ఏదైనా పరిస్థితి తిరిగి వచ్చినప్పుడు నిజం . రెండు ఫ్లోటింగ్-పాయింట్ సంఖ్యలు MCQ మరియు థియరీ మార్కులుగా తీసుకోబడతాయి. AND మరియు OR ఆపరేటర్లు రెండూ ‘లో ఉపయోగించబడతాయి ఉంటే ' ప్రకటన. షరతు ప్రకారం, MCQ మార్కులు 40 కి సమానంగా ఉంటే మరియు థియరీ మార్కులు 30 కంటే ఎక్కువ లేదా సమానంగా ఉంటే ' ఉంటే ' ప్రకటన తిరిగి వస్తుంది నిజం లేదా మొత్తం MCQ మరియు సిద్ధాంతం 70 కంటే ఎక్కువ లేదా సమానంగా ఉంటే ' ఉంటే ' ప్రకటన కూడా తిరిగి వస్తుంది నిజం .
c7.py
# MCQ మార్కులు తీసుకోండిmcq_marks= తేలుతాయి(ఇన్పుట్('MCQ మార్కులను నమోదు చేయండి:'))
# థియరీ మార్కులు తీసుకోండి
సిద్ధాంతం_మార్కులు= తేలుతాయి(ఇన్పుట్('థియరీ మార్కులను నమోదు చేయండి:'))
# మరియు OR ఆపరేటర్‌ని ఉపయోగించి ఉత్తీర్ణత స్థితిని తనిఖీ చేయండి
ఉంటే (mcq_marks> = 40 మరియుసిద్ధాంతం_మార్కులు> = 30) లేదా (mcq_marks + theory_marks) > =70:
ముద్రణ(' nనువ్వు పాసయ్యావు ')
లేకపోతే:
ముద్రణ(' nమీరు విఫలమయ్యారు ')
కింది అవుట్‌పుట్ ప్రకారం, ఉంటే స్టేట్మెంట్ రిటర్న్స్ తప్పుడు ఇన్పుట్ విలువలు 30 మరియు 35, మరియు రిటర్న్‌ల కోసం నిజం ఇన్పుట్ విలువలు 40 మరియు 45 కోసం.
టాప్కేసు స్టేట్మెంట్ మార్చండి:
పైథాన్ మద్దతు ఇవ్వదు ఒక స్విచ్-కేస్ ఇతర ప్రామాణిక ప్రోగ్రామింగ్ లాంగ్వేజ్‌ల వంటి స్టేట్మెంట్, కానీ కస్టమ్ ఫంక్షన్‌ను ఉపయోగించడం ద్వారా ఈ రకమైన స్టేట్‌మెంట్‌ను పైథాన్‌లో అమలు చేయవచ్చు. ఉద్యోగి_వివరాలు () స్విచ్-కేస్ స్టేట్మెంట్ లాగా పనిచేయడానికి ఫంక్షన్ కింది స్క్రిప్ట్‌లో సృష్టించబడింది. ఫంక్షన్‌లో ఒక పరామితి మరియు పేరు ఉన్న నిఘంటువు ఉన్నాయి స్విచ్చర్. ఫంక్షన్ పరామితి విలువ నిఘంటువు యొక్క ప్రతి సూచికతో తనిఖీ చేయబడుతుంది. ఏదైనా సరిపోలిక కనుగొనబడితే, సూచిక యొక్క సంబంధిత విలువ ఫంక్షన్ నుండి తిరిగి ఇవ్వబడుతుంది; లేకపోతే, యొక్క రెండవ పరామితి విలువ switchcher.get () పద్ధతి తిరిగి ఇవ్వబడుతుంది.
c8.py
# స్విచ్ కేస్ ఎంపికలను అమలు చేయడానికి స్విచ్చర్డెఫ్ఉద్యోగి_వివరాలు(ID):
స్విచ్చర్= {
'1004':ఉద్యోగి పేరు: MD. మెహ్రాబ్ ',
'1009':ఉద్యోగి పేరు: మితా రెహమాన్,
'1010':'ఉద్యోగి పేరు: సకీబ్ అల్ హసన్',
}
మ్యాచ్ కనుగొనబడితే మొదటి వాదన తిరిగి ఇవ్వబడుతుంది మరియు
మ్యాచ్ దొరకకపోతే ఏమీ తిరిగి ఇవ్వబడదు ''
తిరిగిస్విచ్చర్.పొందండి(ID, 'ఏమిలేదు')
# ఉద్యోగి ID తీసుకోండి
ID= ఇన్పుట్('ఉద్యోగి ID ని నమోదు చేయండి:')
# అవుట్‌పుట్ ప్రింట్ చేయండి
ముద్రణ(ఉద్యోగి_వివరాలు(ID))
కింది అవుట్‌పుట్ ప్రకారం, స్క్రిప్ట్ రెండుసార్లు అమలు చేయబడుతుంది మరియు ID విలువల ఆధారంగా ఇద్దరు ఉద్యోగుల పేర్లు ముద్రించబడతాయి.
టాప్అయితే లూప్ ఉపయోగం:
పైథాన్‌లో కొంతకాలం లూప్ ఉపయోగించడం కింది ఉదాహరణలో చూపబడింది. పెద్దప్రేగు (:) లూప్ యొక్క ప్రారంభ బ్లాక్‌ను నిర్వచించడానికి ఉపయోగించబడుతుంది, మరియు లూప్ యొక్క అన్ని స్టేట్‌మెంట్‌లు సరైన ఇండెంటేషన్ ఉపయోగించి నిర్వచించబడాలి; లేకపోతే, ఇండెంటేషన్ లోపం కనిపిస్తుంది. కింది స్క్రిప్ట్‌లో, కౌంటర్ విలువ ప్రారంభించబడింది 1 అది లూప్‌లో ఉపయోగించబడుతుంది. లూప్ 5 సార్లు పునరావృతమవుతుంది మరియు ప్రతి పునరుక్తిలో కౌంటర్ విలువలను ముద్రించును. ది కౌంటర్ లూప్ యొక్క ముగింపు స్థితిని చేరుకోవడానికి ప్రతి పునరావృతంలో విలువ 1 ద్వారా పెరుగుతుంది.
c9.py
# కౌంటర్ ప్రారంభించండికౌంటర్= 1
# లూప్‌ని 5 సార్లు పునరావృతం చేయండి
అయితేకౌంటర్< 6:
# కౌంటర్ విలువను ముద్రించండి
ముద్రణ ('ప్రస్తుత కౌంటర్ విలువ: %d'% కౌంటర్)
# కౌంటర్‌ను పెంచండి
కౌంటర్=కౌంటర్ +1
స్క్రిప్ట్ అమలు చేసిన తర్వాత కింది అవుట్‌పుట్ కనిపిస్తుంది.
టాప్లూప్ యొక్క ఉపయోగం:
పైథాన్‌లో అనేక ప్రయోజనాల కోసం లూప్ ఉపయోగించబడుతుంది. ఈ లూప్ యొక్క ప్రారంభ బ్లాక్ పెద్దప్రేగు ద్వారా నిర్వచించాల్సిన అవసరం ఉంది (:), మరియు స్టేట్‌మెంట్‌లు సరైన ఇండెంటేషన్ ఉపయోగించి నిర్వచించబడతాయి. కింది స్క్రిప్ట్‌లో, వారం రోజుల పేర్ల జాబితా నిర్వచించబడింది మరియు జాబితాలోని ప్రతి అంశాన్ని పునరుద్ఘాటించడానికి మరియు ముద్రించడానికి ఒక లూప్ ఉపయోగించబడుతుంది. ఇక్కడ, జాబితాలోని మొత్తం అంశాలను లెక్కించడానికి మరియు పరిధి () ఫంక్షన్ యొక్క పరిమితిని నిర్వచించడానికి లెన్ () పద్ధతి ఉపయోగించబడుతుంది.
c10.py
# జాబితాను ప్రారంభించండివారం రోజులు= ['ఆదివారం', 'సోమవారం', 'మంగళవారం','బుధవారం', 'గురువారం','శుక్రవారం', 'శనివారం']
ముద్రణ('ఏడు వారాలు: n')
# లూప్ కోసం జాబితాను సూచించండి
కోసంరోజులో పరిధి(లెన్(వారం రోజులు)):
ముద్రణ(వారం రోజులు[రోజు])
స్క్రిప్ట్ అమలు చేసిన తర్వాత కింది అవుట్‌పుట్ కనిపిస్తుంది.
ఒక పైథాన్ స్క్రిప్ట్‌ను మరొకదాని నుండి అమలు చేయండి:
కొన్నిసార్లు మరొక పైథాన్ ఫైల్ నుండి పైథాన్ ఫైల్ స్క్రిప్ట్‌ను ఉపయోగించడం అవసరం. ఉపయోగించడం ద్వారా ఏదైనా మాడ్యూల్‌ని దిగుమతి చేయడం వంటివి సులభంగా చేయవచ్చు దిగుమతి కీవర్డ్. ఇక్కడ, సెలవులు. py స్ట్రింగ్ విలువల ద్వారా ప్రారంభించిన రెండు వేరియబుల్స్ ఫైల్‌లో ఉన్నాయి. ఈ ఫైల్ దిగుమతి చేయబడింది c11.py అలియాస్ పేరుతో ఫైల్ ' v ’ . నెల పేర్ల జాబితా ఇక్కడ నిర్వచించబడింది. ది జెండా విలువను ముద్రించడానికి వేరియబుల్ ఇక్కడ ఉపయోగించబడుతుంది సెలవు 1 నెలలకు ఒక సారి వేరియబుల్ ' జూన్' మరియు ' జూలై '. యొక్క విలువ సెలవు 2 వేరియబుల్ నెలకు ముద్రించబడుతుంది 'డిసెంబర్' . ఇతర తొమ్మిది నెలల పేర్లు ముద్రించబడతాయి if-elseif-else ప్రకటన అమలు చేయబడుతుంది.
సెలవులు. py
# విలువలను ప్రారంభించండిసెలవు 1= 'వేసవి సెలవులు'
సెలవు 2= 'శీతాకాలపు సెలవులు'
c11.py
# మరొక పైథాన్ స్క్రిప్ట్‌ను దిగుమతి చేయండిదిగుమతిసెలవులుగాv
# నెల జాబితాను ప్రారంభించండి
నెలల= ['జనవరి', 'ఫిబ్రవరి', 'మార్చి', 'ఏప్రిల్', 'మే', 'జూన్',
'జూలై', 'ఆగస్టు', 'సెప్టెంబర్', 'అక్టోబర్', 'నవంబర్', 'డిసెంబర్']
# వేసవి సెలవులను ఒకేసారి ముద్రించడానికి ప్రారంభ జెండా వేరియబుల్
జెండా= 0
# లూప్ కోసం జాబితాను సూచించండి
కోసంనెలలోనెలల:
ఉంటేనెల== 'జూన్' లేదానెల== 'జూలై':
ఉంటేజెండా== 0:
ముద్రణ('ఇప్పుడు',v.సెలవు 1)
జెండా= 1
ఎలిఫ్నెల== 'డిసెంబర్':
ముద్రణ('ఇప్పుడు',v.సెలవు 2)
లేకపోతే:
ముద్రణ('ప్రస్తుత నెల',నెల)
స్క్రిప్ట్ అమలు చేసిన తర్వాత కింది అవుట్‌పుట్ కనిపిస్తుంది.
టాప్కమాండ్-లైన్ ఆర్గ్యుమెంట్ ఉపయోగం:
కింది స్క్రిప్ట్ పైథాన్‌లో కమాండ్-లైన్ ఆర్గ్యుమెంట్‌ల వినియోగాన్ని చూపుతుంది. కమాండ్-లైన్ ఆర్గ్యుమెంట్‌లను అన్వయించడానికి పైథాన్‌లో అనేక మాడ్యూల్స్ ఉన్నాయి 'Sys' కమాండ్-లైన్ ఆర్గ్యుమెంట్‌లను అన్వయించడానికి మాడ్యూల్ ఇక్కడ దిగుమతి చేయబడింది. లెన్ () స్క్రిప్ట్ ఫైల్ పేరుతో సహా మొత్తం వాదనలను లెక్కించడానికి ఈ పద్ధతి ఉపయోగించబడుతుంది. తరువాత, ఆర్గ్యుమెంట్ విలువలు ముద్రించబడతాయి.
c12.py
# Sys మాడ్యూల్‌ని దిగుమతి చేయండిదిగుమతి sys
# వాదనల మొత్తం సంఖ్య
ముద్రణ('మొత్తం వాదనలు:', లెన్(sys.argv))
ముద్రణ('వాదన విలువలు:')
# లూప్ కోసం ఉపయోగించి కమాండ్-లైన్ ఆర్గ్యుమెంట్‌లను ప్రతిబింబించండి
కోసంiలో sys.argv:
ముద్రణ(i)
స్క్రిప్ట్ ఎటువంటి కమాండ్-లైన్ ఆర్గ్యుమెంట్‌లు లేకుండా అమలు చేయబడితే, స్క్రిప్ట్ ఫైల్ పేరును చూపే కింది అవుట్‌పుట్ కనిపిస్తుంది.
కమాండ్-లైన్ ఆర్గ్యుమెంట్ విలువలను తెరవడం ద్వారా స్పైడర్ ఎడిటర్‌లో సెట్ చేయవచ్చు ప్రతి ఫైల్‌కు కాన్ఫిగరేషన్‌ను అమలు చేయండి పై క్లిక్ చేయడం ద్వారా డైలాగ్ బాక్స్ అమలు మెను. డైలాగ్ బాక్స్‌లో సాధారణ సెట్టింగ్‌ల భాగం యొక్క కమాండ్ లైన్ ఎంపికలను క్లిక్ చేయడం ద్వారా విలువలను ఖాళీతో సెట్ చేయండి.
పైన చూపిన విలువలను సెట్ చేసిన తర్వాత స్క్రిప్ట్ అమలు చేయబడితే, కింది అవుట్‌పుట్ కనిపిస్తుంది.
కమాండ్-లైన్ ఆర్గ్యుమెంట్ విలువలను పైథాన్ స్క్రిప్ట్‌లో టెర్మినల్ నుండి సులభంగా పాస్ చేయవచ్చు. స్క్రిప్ట్ టెర్మినల్ నుండి అమలు చేయబడితే కింది అవుట్‌పుట్ కనిపిస్తుంది.
మీరు పైథాన్‌లో కమాండ్-లైన్ ఆర్గ్యుమెంట్‌ల గురించి మరింత తెలుసుకోవాలనుకుంటే, మీరు ట్యుటోరియల్‌ని తనిఖీ చేయవచ్చు, పైథాన్‌లో కమాండ్ లైన్‌లో వాదనలను ఎలా అన్వయించాలి .
రెగెక్స్ ఉపయోగం:
పైథాన్‌లో రెగ్యులర్ ఎక్స్‌ప్రెషన్ లేదా రీజెక్స్ అనేది నిర్దిష్ట నమూనా ఆధారంగా స్ట్రింగ్‌లోని ఏదైనా నిర్దిష్ట భాగాన్ని సరిపోల్చడానికి లేదా శోధించడానికి మరియు భర్తీ చేయడానికి ఉపయోగించబడుతుంది. 'రీ' రెగ్యులర్ ఎక్స్‌ప్రెషన్‌ను ఉపయోగించడానికి పైథాన్‌లో మాడ్యూల్ ఉపయోగించబడుతుంది. కింది స్క్రిప్ట్ పైథాన్‌లో రెగెక్స్ వాడకాన్ని చూపుతుంది. స్క్రిప్ట్‌లో ఉపయోగించిన నమూనా స్ట్రింగ్‌లోని మొదటి అక్షరం పెద్ద అక్షరం అయిన స్ట్రింగ్‌తో సరిపోతుంది. స్ట్రింగ్ విలువ తీసుకోబడుతుంది మరియు ఉపయోగించి నమూనాను సరిపోల్చండి మ్యాచ్ () పద్ధతి పద్ధతి నిజమైతే, విజయ సందేశం ముద్రించబడుతుంది, లేకపోతే సూచన సందేశం ముద్రించబడుతుంది.
c13.py
# రీ మాడ్యూల్‌ను దిగుమతి చేయండిదిగుమతి తిరిగి
# ఏదైనా స్ట్రింగ్ డేటాను తీసుకోండి
స్ట్రింగ్ = ఇన్పుట్('స్ట్రింగ్ విలువను నమోదు చేయండి:')
# శోధన నమూనాను నిర్వచించండి
నమూనా= '^[A-Z]'
# నమూనాను ఇన్పుట్ విలువతో సరిపోల్చండి
కనుగొన్నారు= తిరిగి.మ్యాచ్(నమూనా, స్ట్రింగ్)
# రిటర్న్ వాల్యూ ఆధారంగా మెసేజ్ ప్రింట్ చేయండి
ఉంటేకనుగొన్నారు:
ముద్రణ('ఇన్పుట్ విలువ పెద్ద అక్షరంతో ప్రారంభించబడింది')
లేకపోతే:
ముద్రణ('మీరు పెద్ద అక్షరంతో స్ట్రింగ్ స్టార్ట్ టైప్ చేయాలి')
కింది అవుట్‌పుట్‌లో స్క్రిప్ట్ రెండుసార్లు అమలు చేయబడుతుంది. మ్యాచ్ () ఫంక్షన్ మొదటి ఎగ్జిక్యూషన్‌కి తప్పుడు రిటర్న్ ఇస్తుంది మరియు రెండో ఎగ్జిక్యూషన్‌కు రిటర్న్ వస్తుంది.
టాప్గెట్పాస్ ఉపయోగం:
గెట్‌పాస్ యూజర్ నుండి పాస్వర్డ్ ఇన్పుట్ తీసుకోవడానికి ఉపయోగించే పైథాన్ యొక్క ఉపయోగకరమైన మాడ్యూల్. కింది స్క్రిప్ట్ గెట్‌పాస్ మాడ్యూల్ యొక్క ఉపయోగాన్ని చూపుతుంది. ఇన్‌పుట్‌ను పాస్‌వర్డ్‌గా తీసుకోవడానికి getpass () పద్ధతి ఇక్కడ ఉపయోగించబడుతుంది ఉంటే ' నిర్వచించిన పాస్‌వర్డ్‌తో ఇన్పుట్ విలువను సరిపోల్చడానికి స్టేట్మెంట్ ఇక్కడ ఉపయోగించబడుతుంది. మీరు ప్రామాణీకరించబడ్డారు పాస్వర్డ్ సరిపోలితే సందేశం ముద్రించబడుతుంది, లేకపోతే అది ముద్రించబడుతుంది మీరు ప్రామాణీకరించబడలేదు సందేశం.
c14.py
# దిగుమతి getpass మాడ్యూల్దిగుమతి గెట్‌పాస్
# వినియోగదారు నుండి పాస్వర్డ్ తీసుకోండి
పాస్వర్డ్= గెట్‌పాస్.గెట్‌పాస్('పాస్వర్డ్:')
# పాస్‌వర్డ్‌ని తనిఖీ చేయండి
ఉంటేపాస్వర్డ్== 'ఫహ్మిదా':
ముద్రణ('మీరు ప్రామాణీకరించబడ్డారు')
లేకపోతే:
ముద్రణ('మీరు ప్రామాణీకరించబడలేదు')
స్పైడర్ ఎడిటర్ నుండి స్క్రిప్ట్ రన్ అవుతుంటే, ఎడిటర్ కన్సోల్ పాస్వర్డ్ మోడ్‌కు మద్దతు ఇవ్వనందున ఇన్పుట్ విలువ చూపబడుతుంది. కాబట్టి, కింది అవుట్‌పుట్ కింది అవుట్‌పుట్‌లోని ఇన్పుట్ పాస్‌వర్డ్‌ను చూపుతుంది.
స్క్రిప్ట్ టెర్మినల్ నుండి అమలు చేయబడితే, ఇన్పుట్ విలువ ఇతర Linux పాస్వర్డ్ లాగా చూపబడదు. స్క్రిప్ట్ టెర్మినల్ నుండి రెండుసార్లు చెల్లని మరియు చెల్లుబాటు అయ్యే పాస్‌వర్డ్‌తో అమలు చేయబడింది, అది క్రింది అవుట్‌పుట్‌లో చూపబడుతుంది.
తేదీ ఫార్మాట్ ఉపయోగం:
తేదీ విలువను వివిధ మార్గాల్లో పైథాన్‌లో ఫార్మాట్ చేయవచ్చు. కింది స్క్రిప్ట్ ఉపయోగిస్తుంది డేటిమ్ ప్రస్తుత మరియు అనుకూల తేదీ విలువను సెట్ చేయడానికి ఇ మాడ్యూల్. నేడు () ప్రస్తుత సిస్టమ్ తేదీ మరియు సమయాన్ని చదవడానికి ఇక్కడ పద్ధతి ఉపయోగించబడుతుంది. తరువాత, తేదీ వస్తువు యొక్క వివిధ ఆస్తి పేర్లను ఉపయోగించి తేదీ యొక్క ఫార్మాట్ విలువ ముద్రించబడుతుంది. అనుకూల తేదీ విలువను ఎలా కేటాయించవచ్చు మరియు ముద్రించవచ్చు అనేది స్క్రిప్ట్ యొక్క తదుపరి భాగంలో చూపబడింది.
c15.py
నుండి తేదీ సమయం దిగుమతితేదీ# ప్రస్తుత తేదీని చదవండి
కరెంట్_తేదీ=తేదీనేడు()
# ఫార్మాట్ చేసిన తేదీని ముద్రించండి
ముద్రణ('ఈ రోజు:%d-%d-%d'%(కరెంట్_తేదీ.రోజు,కరెంట్_తేదీ.నెల,కరెంట్_తేదీ.సంవత్సరం))
# అనుకూల తేదీని సెట్ చేయండి
అనుకూల_తేదీ=తేదీ(2020, 12, 16)
ముద్రణ('తేదీ:',అనుకూల_తేదీ)
స్క్రిప్ట్‌ను అమలు చేసిన తర్వాత కింది అవుట్‌పుట్ కనిపిస్తుంది.
జాబితా నుండి అంశాన్ని జోడించండి మరియు తీసివేయండి:
వివిధ రకాల సమస్యలను పరిష్కరించడానికి పైథాన్‌లో జాబితా వస్తువు ఉపయోగించబడుతుంది. జాబితా వస్తువుతో పనిచేయడానికి పైథాన్ అనేక అంతర్నిర్మిత విధులను కలిగి ఉంది. జాబితా నుండి కొత్త అంశం ఎలా చేర్చబడుతుంది మరియు తీసివేయబడుతుంది అనేది క్రింది ఉదాహరణలో చూపబడింది. స్క్రిప్ట్‌లో నాలుగు అంశాల జాబితా ప్రకటించబడింది. చొప్పించు () జాబితా యొక్క రెండవ స్థానంలో క్రొత్త అంశాన్ని చేర్చడానికి పద్ధతి ఉపయోగించబడుతుంది. తొలగించు () జాబితా నుండి నిర్దిష్ట అంశాన్ని శోధించడానికి మరియు తీసివేయడానికి పద్ధతి ఉపయోగించబడుతుంది. చొప్పించడం మరియు తొలగింపు తర్వాత జాబితా ముద్రించబడుతుంది.
c16.py
# పండ్ల జాబితాను ప్రకటించండిపండ్లు= ['మామిడి','ఆరెంజ్','జామ','అరటి']
# 2 వ స్థానంలో ఒక అంశాన్ని చొప్పించండి
పండ్లు.చొప్పించు(1, 'ద్రాక్ష')
# చొప్పించిన తర్వాత జాబితాను ప్రదర్శిస్తోంది
ముద్రణ('చొప్పించిన తర్వాత పండ్ల జాబితా:')
ముద్రణ(పండ్లు)
# ఒక అంశాన్ని తీసివేయండి
పండ్లు.తొలగించు('జామ')
# తొలగించిన తర్వాత జాబితాను ముద్రించండి
ముద్రణ('తొలగించిన తర్వాత పండ్ల జాబితా:')
ముద్రణ(పండ్లు)
స్క్రిప్ట్‌ను అమలు చేసిన తర్వాత కింది అవుట్‌పుట్ కనిపిస్తుంది.
మీరు పైథాన్ స్క్రిప్ట్ చొప్పించడం మరియు తొలగింపు గురించి మరిన్ని వివరాలను తెలుసుకోవాలనుకుంటే, మీరు ట్యుటోరియల్‌ని తనిఖీ చేయవచ్చు, పైథాన్‌లో జాబితా నుండి అంశాలను ఎలా జోడించాలి మరియు తీసివేయాలి .
జాబితా అవగాహన:
ఏదైనా స్ట్రింగ్ లేదా టుపుల్ లేదా మరొక జాబితా ఆధారంగా కొత్త జాబితాను రూపొందించడానికి పైథాన్‌లో లిస్ట్ కాంప్రహెన్షన్ ఉపయోగించబడుతుంది. లూప్ మరియు లాంబ్డా ఫంక్షన్ కోసం అదే పనిని చేయవచ్చు. కింది స్క్రిప్ట్ లిస్ట్ కాంప్రహెన్షన్ యొక్క రెండు విభిన్న ఉపయోగాలను చూపుతుంది. స్ట్రింగ్ విలువ లిస్ట్ కాంప్రహెన్షన్ ఉపయోగించి అక్షరాల జాబితాగా మార్చబడుతుంది. తరువాత, ఒక టపుల్ అదే విధంగా జాబితాగా మార్చబడుతుంది.
c17.py
# జాబితా గ్రహణశక్తిని ఉపయోగించి అక్షరాల జాబితాను సృష్టించండిchar_list= [చార్కోసంచార్లో 'linuxhint' ]
ముద్రణ(char_list)
# వెబ్‌సైట్‌ల టపుల్‌ను నిర్వచించండి
వెబ్‌సైట్‌లు= ('గూగుల్ కామ్','yahoo.com', 'ask.com', 'bing.com')
# జాబితా గ్రహణశక్తిని ఉపయోగించి టుపుల్ నుండి జాబితాను సృష్టించండి
సైట్_లిస్ట్= [ సైట్ కోసం సైట్ లోవెబ్‌సైట్‌లు]
ముద్రణ(సైట్_లిస్ట్)
స్లైస్ డేటా:
ముక్క () స్ట్రింగ్ యొక్క నిర్దిష్ట భాగాన్ని కత్తిరించడానికి పైథాన్‌లో పద్ధతి ఉపయోగించబడుతుంది. ఈ పద్ధతి మూడు పారామితులను కలిగి ఉంది. ఈ పారామితులు ప్రారంభం , ఆపు, మరియు అడుగు . ది ఆపు తప్పనిసరి పరామితి, మరియు ఇతర రెండు పారామితులు ఐచ్ఛికం. కింది స్క్రిప్ట్ దీని ఉపయోగాలను చూపుతుంది ముక్క () ఒకటి, రెండు మరియు మూడు పారామితులతో కూడిన పద్ధతి. లో ఒక పరామితి ఉపయోగించినప్పుడు ముక్క () పద్ధతి, అప్పుడు అది తప్పనిసరి పరామితిని ఉపయోగిస్తుంది, ఆపు . లో రెండు పారామితులు ఉపయోగించినప్పుడు ముక్క () పద్ధతి, అప్పుడు ప్రారంభం మరియు ఆపు పారామితులు ఉపయోగించబడతాయి. మూడు పారామితులు ఉపయోగించినప్పుడు, అప్పుడు ప్రారంభం , ఆపు , మరియు అడుగు పారామితులు ఉపయోగించబడతాయి.
c18.py
# స్ట్రింగ్ విలువను కేటాయించండిటెక్స్ట్= 'పైథాన్ ప్రోగ్రామింగ్ నేర్చుకోండి'
# ఒక పరామితిని ఉపయోగించి స్లైస్ చేయండి
స్లైస్ ఓబ్జె= ముక్కలు(5)
ముద్రణ(టెక్స్ట్[స్లైస్ ఓబ్జె])
# రెండు పరామితులను ఉపయోగించి స్లైస్ చేయండి
స్లైస్ ఓబ్జె= ముక్కలు(6,12)
ముద్రణ(టెక్స్ట్[స్లైస్ ఓబ్జె])
# మూడు పారామీటర్‌ని ఉపయోగించి స్లైస్ చేయండి
స్లైస్ ఓబ్జె= ముక్కలు(6,25,5)
ముద్రణ(టెక్స్ట్[స్లైస్ ఓబ్జె])
స్క్రిప్ట్ అమలు చేసిన తర్వాత కింది అవుట్‌పుట్ కనిపిస్తుంది. మొదటి లో ముక్క () పద్ధతి, 5 వాదన విలువగా ఉపయోగించబడుతుంది. ఇది ఐదు అక్షరాలను ముక్కలు చేసింది టెక్స్ట్ అవుట్‌పుట్‌గా ముద్రించబడిన వేరియబుల్స్. రెండవ లో ముక్క () పద్ధతి, 6 మరియు 12 వాదనలుగా ఉపయోగించబడతాయి. ముక్కలు చేయడం స్థానం 6 నుండి ప్రారంభించబడింది మరియు 12 అక్షరాల తర్వాత నిలిపివేయబడింది. మూడవ లో ముక్క () పద్ధతి, 6, 25 మరియు 5 వాదనలుగా ఉపయోగించబడతాయి. స్లైసింగ్ 6 వ స్థానం నుండి ప్రారంభించబడింది మరియు ప్రతి దశలో 5 అక్షరాలను వదిలివేయడం ద్వారా 25 అక్షరాల తర్వాత స్లైసింగ్ నిలిపివేయబడింది.
టాప్నిఘంటువులో డేటాను జోడించండి మరియు శోధించండి:
ఇతర ప్రోగ్రామింగ్ భాషల అనుబంధ శ్రేణి వంటి బహుళ డేటాను నిల్వ చేయడానికి పైథాన్‌లో నిఘంటువు వస్తువు ఉపయోగించబడుతుంది. కింది స్క్రిప్ట్ కొత్త అంశాన్ని ఎలా చొప్పించవచ్చో చూపిస్తుంది మరియు ఏదైనా వస్తువును డిక్షనరీలో శోధించవచ్చు. సూచికలో కస్టమర్ ID ఉన్న విలువ మరియు కస్టమర్ పేరు ఉన్న స్క్రిప్ట్‌లో కస్టమర్ సమాచార నిఘంటువు ప్రకటించబడింది. తరువాత, డిక్షనరీ చివరలో ఒక కొత్త కస్టమర్ సమాచారం చేర్చబడుతుంది. డిక్షనరీలో సెర్చ్ చేయడానికి కస్టమర్ ID ఇన్‌పుట్‌గా తీసుకోబడుతుంది. 'కోసం' లూప్ మరియు 'ఉంటే' డిక్షనరీ యొక్క ఇండెక్స్‌లను మార్చడానికి మరియు డిక్షనరీలోని ఇన్పుట్ విలువను శోధించడానికి షరతు ఉపయోగించబడుతుంది.
c19.py
# నిఘంటువును నిర్వచించండివినియోగదారులు= {'06753':'మెహజాబిన్ ఆఫ్రోజ్','02457':'కళ. అలీ ',
'02834':'మోసరోఫ్ అహ్మద్','05623':'మీలా హసన్', '07895':'యాకూబ్ అలీ'}
# కొత్త డేటాను జోడించండి
వినియోగదారులు['05634'] = 'మెహబోబా ఫెర్డౌస్'
ముద్రణ('కస్టమర్ పేర్లు:')
# నిఘంటువు విలువలను ముద్రించండి
కోసంకస్టమర్లోవినియోగదారులు:
ముద్రణ(వినియోగదారులు[కస్టమర్])
# శోధించడానికి కస్టమర్ ID ని ఇన్‌పుట్‌గా తీసుకోండి
పేరు= ఇన్పుట్('కస్టమర్ ID ని నమోదు చేయండి:')
# నిఘంటువులో ID ని శోధించండి
కోసంకస్టమర్లోవినియోగదారులు:
ఉంటేకస్టమర్==పేరు:
ముద్రణ(వినియోగదారులు[కస్టమర్])
విరామం
స్క్రిప్ట్‌ను అమలు చేసి, 'తీసుకున్న తర్వాత కింది అవుట్‌పుట్ కనిపిస్తుంది. 02457 ' ID విలువగా.
మీరు నిఘంటువు యొక్క ఇతర ఉపయోగకరమైన పద్ధతుల గురించి మరింత తెలుసుకోవాలనుకుంటే, మీరు ట్యుటోరియల్, 10 అత్యంత ఉపయోగకరమైన పైథాన్ డిక్షనరీ పద్ధతులను తనిఖీ చేయవచ్చు.
సెట్‌లో డేటాను జోడించండి మరియు శోధించండి:
కింది స్క్రిప్ట్ పైథాన్ సెట్‌లో డేటాను జోడించడానికి మరియు శోధించడానికి మార్గాలను చూపుతుంది. స్క్రిప్ట్‌లో పూర్ణాంక డేటా సమితి ప్రకటించబడింది. జోడించు () సెట్‌లో కొత్త డేటాను చొప్పించడానికి పద్ధతి ఉపయోగించబడుతుంది. తరువాత, ఉపయోగించడం ద్వారా సెట్‌లోని విలువను శోధించడానికి ఒక పూర్ణాంక విలువ ఇన్‌పుట్‌గా తీసుకోబడుతుంది కోసం లూప్ మరియు ఉంటే పరిస్థితి.
c20.py
# సంఖ్య సెట్‌ను నిర్వచించండిసంఖ్యలు= {2. 3, 90, 56, 78, 12, 3. 4, 67}
# కొత్త డేటాను జోడించండి
సంఖ్యలు.జోడించు(యాభై)
# సెట్ విలువలను ముద్రించండి
ముద్రణ(సంఖ్యలు)
సందేశం= 'నంబర్ దొరకలేదు'
# శోధన కోసం సంఖ్య విలువను తీసుకోండి
శోధన_ సంఖ్య= int(ఇన్పుట్('ఒక సంఖ్యను నమోదు చేయండి:'))
# సెట్‌లోని నంబర్‌ను శోధించండి
కోసంగంటలులోసంఖ్యలు:
ఉంటేగంటలు==శోధన_ సంఖ్య:
సందేశం= 'నంబర్ కనుగొనబడింది'
విరామం
ముద్రణ(సందేశం)
పూర్ణాంకం విలువ 89 మరియు 67. తో స్క్రిప్ట్ రెండుసార్లు అమలు చేయబడుతుంది. 89 సెట్‌లో ఉనికిలో లేదు, మరియు సంఖ్య కనుగొనబడలేదు ముద్రించబడింది. 67 సెట్‌లో ఉంది, మరియు సంఖ్య కనుగొనబడింది ముద్రించబడింది.
మీరు దీని గురించి తెలుసుకోవాలనుకుంటే యూనియన్ సెట్‌లో ఆపరేషన్, అప్పుడు మీరు ట్యుటోరియల్‌ని తనిఖీ చేయవచ్చు, పైథాన్ సెట్‌లో యూనియన్‌ను ఎలా ఉపయోగించాలి.
జాబితాలో అంశాలను లెక్కించండి:
కౌంట్ () ఇతర స్ట్రింగ్‌లో ఒక నిర్దిష్ట స్ట్రింగ్ ఎన్నిసార్లు కనిపిస్తుందో లెక్కించడానికి పైథాన్‌లో పద్ధతి ఉపయోగించబడుతుంది. ఇది మూడు వాదనలు తీసుకోవచ్చు. మొదటి వాదన తప్పనిసరి, మరియు అది మరొక స్ట్రింగ్ మొత్తం భాగంలో నిర్దిష్ట స్ట్రింగ్‌ని శోధిస్తుంది. ఈ పద్ధతి యొక్క ఇతర రెండు వాదనలు శోధన స్థానాలను నిర్వచించడం ద్వారా శోధనను పరిమితం చేయడానికి ఉపయోగించబడతాయి. కింది స్క్రిప్ట్‌లో, ది కౌంట్ () పదాన్ని శోధించే మరియు లెక్కించే ఒక వాదనతో పద్ధతి ఉపయోగించబడుతుంది పైథాన్ ' లో స్ట్రింగ్ వేరియబుల్.
c21.py
# స్ట్రింగ్‌ను నిర్వచించండిస్ట్రింగ్ = 'పైథాన్ బాష్ జావా పైథాన్ PHP పెర్ల్'
# శోధన స్ట్రింగ్‌ను నిర్వచించండి
వెతకండి= 'పైథాన్'
# కౌంట్ విలువను నిల్వ చేయండి
లెక్క= స్ట్రింగ్.లెక్క(వెతకండి)
# ఫార్మాట్ చేసిన అవుట్‌పుట్‌ను ప్రింట్ చేయండి
ముద్రణ(' %s %d సార్లు కనిపిస్తుంది'%(వెతకండి,లెక్క))
స్క్రిప్ట్‌ను అమలు చేసిన తర్వాత కింది అవుట్‌పుట్ కనిపిస్తుంది.
మీరు కౌంట్ () పద్ధతి గురించి మరిన్ని వివరాలను తెలుసుకోవాలనుకుంటే, మీరు ట్యుటోరియల్‌ని తనిఖీ చేయవచ్చు, పైథాన్‌లో కౌంట్ () పద్ధతిని ఎలా ఉపయోగించాలి .
ఒక ఫంక్షన్‌ను నిర్వచించండి మరియు కాల్ చేయండి:
పైథాన్‌లో యూజర్ నిర్వచించిన ఫంక్షన్‌ను ఎలా డిక్లేర్ చేయవచ్చు మరియు కాల్ చేయవచ్చు అనేది క్రింది స్క్రిప్ట్‌లో చూపబడింది. ఇక్కడ, రెండు విధులు ప్రకటించబడ్డాయి. అదనంగా () ఫంక్షన్ రెండు సంఖ్యల మొత్తాన్ని లెక్కించడానికి మరియు విలువను ముద్రించడానికి రెండు వాదనలను కలిగి ఉంటుంది. ప్రాంతం() ఫంక్షన్ ఒక వృత్తం యొక్క వైశాల్యాన్ని లెక్కించడానికి మరియు వాడి ద్వారా ఫలితాన్ని కాలర్‌కు తిరిగి ఇవ్వడానికి ఒక వాదనను కలిగి ఉంటుంది వాపసు ప్రకటన.
c22.py
# అదనపు ఫంక్షన్‌ను నిర్వచించండిడెఫ్అదనంగా(సంఖ్య 1,సంఖ్య 2):
ఫలితం=సంఖ్య 1 + సంఖ్య 2
ముద్రణ('చేర్పు ఫలితం:',ఫలితం)
# రిటర్న్ స్టేట్‌మెంట్‌తో ఏరియా ఫంక్షన్‌ను నిర్వచించండి
డెఫ్ప్రాంతం(వ్యాసార్థం):
ఫలితం= 3.14* వ్యాసార్థం * వ్యాసార్థం
తిరిగిఫలితం
# కాల్ అదనంగా ఫంక్షన్
అదనంగా(400, 300)
# కాల్ ఏరియా ఫంక్షన్
ముద్రణ('సర్కిల్ ప్రాంతం',ప్రాంతం(4))
స్క్రిప్ట్‌ను అమలు చేసిన తర్వాత కింది అవుట్‌పుట్ కనిపిస్తుంది.
మీరు పైథాన్ ఫంక్షన్ నుండి తిరిగి వచ్చే విలువల గురించి వివరాలు తెలుసుకోవాలనుకుంటే, మీరు ట్యుటోరియల్‌ని తనిఖీ చేయవచ్చు, ఒక పైథాన్ ఫంక్షన్ నుండి బహుళ విలువలను తిరిగి ఇవ్వండి .
త్రో మరియు క్యాచ్ మినహాయింపు ఉపయోగం:
ప్రయత్నించండి మరియు క్యాచ్ మినహాయింపును విసిరేందుకు మరియు పట్టుకోవడానికి బ్లాక్ ఉపయోగించబడుతుంది. కింది స్క్రిప్ట్ a యొక్క ఉపయోగాన్ని చూపుతుంది ప్రయత్నించండి-క్యాచ్ పైథాన్‌లో బ్లాక్. లో ప్రయత్నించండి బ్లాక్, సంఖ్య విలువ ఇన్‌పుట్‌గా తీసుకోబడుతుంది మరియు సంఖ్య సరి లేదా బేసి అని తనిఖీ చేయబడుతుంది. ఏదైనా సంఖ్యా రహిత విలువ ఇన్‌పుట్‌గా అందించబడితే, a విలువ లోపం ఉత్పత్తి చేయబడుతుంది, మరియు దీనికి మినహాయింపు ఇవ్వబడుతుంది క్యాచ్ దోష సందేశాన్ని ముద్రించడానికి బ్లాక్ చేయండి.
c23.py
# బ్లాక్ ప్రయత్నించండిప్రయత్నించండి:
# ఒక నంబర్ తీసుకోండి
సంఖ్య= int(ఇన్పుట్('ఒక సంఖ్యను నమోదు చేయండి:'))
ఉంటేసంఖ్య %2 == 0:
ముద్రణ('సంఖ్య సరి')
లేకపోతే:
ముద్రణ('సంఖ్య బేసి')
# మినహాయింపు బ్లాక్
తప్ప (విలువ లోపం):
# దోష సందేశాన్ని ముద్రించండి
ముద్రణ('సంఖ్యా విలువను నమోదు చేయండి')
స్క్రిప్ట్‌ను అమలు చేసిన తర్వాత కింది అవుట్‌పుట్ కనిపిస్తుంది.
మీరు పైథాన్‌లో మినహాయింపు నిర్వహణ గురించి మరిన్ని వివరాలను తెలుసుకోవాలనుకుంటే, మీరు పైథాన్‌లో మినహాయింపు నిర్వహణ అనే ట్యుటోరియల్‌ని తనిఖీ చేయవచ్చు.
ఫైల్‌ను చదవండి మరియు వ్రాయండి:
కింది స్క్రిప్ట్ పైథాన్‌లోని ఫైల్ నుండి చదవడానికి మరియు వ్రాయడానికి మార్గాన్ని చూపుతుంది. ఫైల్ పేరు వేరియబుల్, ఫైల్ పేరులో నిర్వచించబడింది. ఫైల్ ఉపయోగించి రాయడం కోసం తెరవబడింది తెరువు () స్క్రిప్ట్ ప్రారంభంలో పద్ధతి. ఫైల్ ఉపయోగించి మూడు పంక్తులు వ్రాయబడ్డాయి వ్రాయడానికి() పద్ధతి తరువాత, అదే ఫైల్‌ను ఉపయోగించి చదవడానికి తెరవబడుతుంది తెరువు () పద్ధతి, మరియు ఫైల్ యొక్క ప్రతి పంక్తిని ఉపయోగించి చదవండి మరియు ముద్రించబడుతుంది కోసం లూప్.
c24.py
#ఫైల్ పేరు కేటాయించండిఫైల్ పేరు= 'languages.txt'
# రాయడం కోసం ఫైల్‌ని తెరవండి
ఫైల్ హ్యాండ్లర్= తెరవండి(ఫైల్ పేరు, 'లో')
# కొంత వచనాన్ని జోడించండి
ఫైల్ హ్యాండ్లర్.వ్రాయడానికి('బాష్ n')
ఫైల్ హ్యాండ్లర్.వ్రాయడానికి('పైథాన్ n')
ఫైల్ హ్యాండ్లర్.వ్రాయడానికి('PHP n')
# ఫైల్‌ను మూసివేయండి
ఫైల్ హ్యాండ్లర్.దగ్గరగా()
# చదవడానికి ఫైల్‌ని తెరవండి
ఫైల్ హ్యాండ్లర్= తెరవండి(ఫైల్ పేరు, 'r')
# ఫైల్‌ని లైన్‌ల వారీగా చదవండి
కోసంలైన్లోఫైల్ హ్యాండ్లర్:
ముద్రణ(లైన్)
# ఫైల్‌ను మూసివేయండి
ఫైల్ హ్యాండ్లర్.దగ్గరగా()
స్క్రిప్ట్‌ను అమలు చేసిన తర్వాత కింది అవుట్‌పుట్ కనిపిస్తుంది.
మీరు పైథాన్‌లో ఫైల్స్ చదవడం మరియు రాయడం గురించి మరిన్ని వివరాలను తెలుసుకోవాలనుకుంటే, మీరు ట్యుటోరియల్‌ని తనిఖీ చేయవచ్చు, పైథాన్‌లో ఫైల్‌లను చదవడం మరియు వ్రాయడం ఎలా .
డైరెక్టరీలో ఫైల్‌లను జాబితా చేయండి:
ఏదైనా డైరెక్టరీలోని కంటెంట్‌ను ఉపయోగించడం ద్వారా చదవవచ్చు మీరు పైథాన్ మాడ్యూల్. పైథాన్‌ని ఉపయోగించి ఒక నిర్దిష్ట డైరెక్టరీ జాబితాను ఎలా పొందాలో క్రింది స్క్రిప్ట్ చూపుతుంది మీరు మాడ్యూల్. జాబితా డైరెక్టరీ యొక్క ఫైల్‌లు మరియు ఫోల్డర్‌ల జాబితాను తెలుసుకోవడానికి స్క్రిప్ట్‌లో పద్ధతి ఉపయోగించబడుతుంది. కోసం డైరెక్టరీ కంటెంట్‌ను ముద్రించడానికి లూప్ ఉపయోగించబడుతుంది.
c25.py
# డైరెక్టరీని చదవడానికి OS మాడ్యూల్‌ని దిగుమతి చేయండిదిగుమతి మీరు
# డైరెక్టరీ మార్గాన్ని సెట్ చేయండి
మార్గం= '/హోమ్/ఫహ్మిదా/ప్రాజెక్ట్స్/బిన్'
# ఫైల్ కంటెంట్‌ని చదవండి
ఫైళ్లు= మీరు.జాబితా(మార్గం)
# డైరెక్టరీలోని కంటెంట్‌ను ముద్రించండి
కోసం ఫైల్ లోఫైళ్లు:
ముద్రణ(ఫైల్)
డైరెక్టరీ యొక్క నిర్వచించిన మార్గం ఉన్నట్లయితే స్క్రిప్ట్‌ను అమలు చేసిన తర్వాత డైరెక్టరీ యొక్క కంటెంట్ కనిపిస్తుంది.
టాప్ఊరగాయ ఉపయోగించి చదవండి మరియు వ్రాయండి:
కింది స్క్రిప్ట్ ఉపయోగించి డేటాను వ్రాయడానికి మరియు చదవడానికి మార్గాలను చూపుతుంది ఊరగాయ పైథాన్ మాడ్యూల్. స్క్రిప్ట్‌లో, ఒక వస్తువు ఐదు సంఖ్యా విలువలతో ప్రకటించబడింది మరియు ప్రారంభించబడింది. ఈ వస్తువు యొక్క డేటా ఉపయోగించి ఒక ఫైల్‌లో వ్రాయబడుతుంది డంప్ () పద్ధతి తరువాత, ది లోడ్ () అదే ఫైల్ నుండి డేటాను చదవడానికి మరియు ఒక వస్తువులో నిల్వ చేయడానికి పద్ధతి ఉపయోగించబడుతుంది.
c26.py
# ఊరగాయ మాడ్యూల్‌ను దిగుమతి చేయండిదిగుమతి ఊరగాయ
# డేటాను నిల్వ చేయడానికి వస్తువును ప్రకటించండి
డేటా ఆబ్జెక్ట్= []
# 5 సార్లు లూప్‌ని పునరావృతం చేయండి
కోసంఒకదానిపైలో పరిధి(10,పదిహేను):
డేటా ఆబ్జెక్ట్.అనుబంధం(ఒకదానిపై)
# డేటాను వ్రాయడానికి ఫైల్‌ను తెరవండి
ఫైల్_హ్యాండ్లర్= తెరవండి('భాషలు', 'wb')
# ఆబ్జెక్ట్ యొక్క డేటాను ఫైల్‌లోకి డంప్ చేయండి
ఊరగాయ.డంప్(డేటా ఆబ్జెక్ట్,ఫైల్_హ్యాండ్లర్)
# ఫైల్ హ్యాండ్లర్‌ను మూసివేయండి
ఫైల్_హ్యాండ్లర్.దగ్గరగా()
# ఫైల్‌ని చదవడానికి ఫైల్‌ని తెరవండి
ఫైల్_హ్యాండ్లర్= తెరవండి('భాషలు', 'rb')
డీసిరియలైజేషన్ తర్వాత ఫైల్ నుండి డేటాను లోడ్ చేయండి
డేటా ఆబ్జెక్ట్= ఊరగాయ.లోడ్(ఫైల్_హ్యాండ్లర్)
# డేటాను ముద్రించడానికి లూప్‌ని పునరుద్ఘాటించండి
కోసంగంటలులోడేటా ఆబ్జెక్ట్:
ముద్రణ('డేటా విలువ:',గంటలు)
# ఫైల్ హ్యాండ్లర్‌ను మూసివేయండి
ఫైల్_హ్యాండ్లర్.దగ్గరగా()
స్క్రిప్ట్‌ను అమలు చేసిన తర్వాత కింది అవుట్‌పుట్ కనిపిస్తుంది.
మీరు ఊరగాయ ఉపయోగించి చదవడం మరియు రాయడం గురించి మరిన్ని వివరాలను తెలుసుకోవాలనుకుంటే, మీరు ట్యుటోరియల్‌ని తనిఖీ చేయవచ్చు, పైథాన్‌లో వస్తువులను ఊరగాయ చేయడం ఎలా .
తరగతి మరియు పద్ధతిని నిర్వచించండి:
పైథాన్‌లో క్లాస్ మరియు మెథడ్‌ను ఎలా డిక్లేర్ చేయవచ్చు మరియు యాక్సెస్ చేయవచ్చో క్రింది స్క్రిప్ట్ చూపుతుంది. ఇక్కడ, క్లాస్ వేరియబుల్ మరియు మెథడ్‌తో క్లాస్ ప్రకటించబడింది. తరువాత, క్లాస్ వేరియబుల్ మరియు క్లాస్ పద్ధతిని యాక్సెస్ చేయడానికి క్లాస్ యొక్క ఒక వస్తువు ప్రకటించబడింది.
c27.py
# తరగతిని నిర్వచించండితరగతిఉద్యోగి:
పేరు= 'మోస్తక్ మహమూద్'
# పద్ధతిని నిర్వచించండి
డెఫ్వివరాలు(స్వీయ):
ముద్రణ('పోస్ట్: మార్కెటింగ్ ఆఫీసర్')
ముద్రణ('విభాగం: అమ్మకాలు')
ముద్రణ('జీతం: $ 1000')
# ఉద్యోగి వస్తువును సృష్టించండి
ఎంప=ఉద్యోగి()
# తరగతి వేరియబుల్‌ను ముద్రించండి
ముద్రణ('పేరు:',ఎంపపేరు)
# తరగతి పద్ధతికి కాల్ చేయండి
ఎంపవివరాలు()
స్క్రిప్ట్‌ను అమలు చేసిన తర్వాత కింది అవుట్‌పుట్ కనిపిస్తుంది.
టాప్పరిధి ఫంక్షన్ ఉపయోగం:
కింది స్క్రిప్ట్ పైథాన్‌లో రేంజ్ ఫంక్షన్ యొక్క వివిధ ఉపయోగాలను చూపుతుంది. ఈ ఫంక్షన్ మూడు వాదనలు తీసుకోవచ్చు. ఇవి ప్రారంభం , ఆపు , మరియు అడుగు . ది ఆపు వాదన తప్పనిసరి. ఒక ఆర్గ్యుమెంట్ ఉపయోగించినప్పుడు, స్టార్ట్ యొక్క డిఫాల్ట్ విలువ 0. రేంజ్ () ఫంక్షన్ ఒక ఆర్గ్యుమెంట్, రెండు ఆర్గ్యుమెంట్‌లు మరియు మూడు ఆర్గ్యుమెంట్‌లు మూడులో ఉపయోగించబడతాయి కోసం ఇక్కడ ఉచ్చులు.
c28.py
# పరిధి () ఒక పరామితితోకోసంగంటలులో పరిధి(6):
ముద్రణ(గంటలు,ముగింపు='')
ముద్రణ(' n')
# పరిధి () రెండు పారామీటర్‌తో
కోసంగంటలులో పరిధి(5,10):
ముద్రణ(గంటలు,ముగింపు='')
ముద్రణ(' n')
# పరిధి () మూడు పారామీటర్‌తో
కోసంగంటలులో పరిధి(0,8,2):
ముద్రణ(గంటలు,ముగింపు='')
స్క్రిప్ట్‌ను అమలు చేసిన తర్వాత కింది అవుట్‌పుట్ కనిపిస్తుంది.
మ్యాప్ ఫంక్షన్ ఉపయోగం:
మ్యాప్ () ఏదైనా యూజర్ నిర్వచించిన ఫంక్షన్ మరియు ఏదైనా పునరుత్పాదక వస్తువు ఉపయోగించి జాబితాను తిరిగి ఇవ్వడానికి ఫంక్షన్ పైథాన్‌లో ఉపయోగించబడుతుంది. కింది స్క్రిప్ట్‌లో, cal_power () లెక్కించడానికి ఫంక్షన్ నిర్వచించబడింది xఎన్, మరియు ఫంక్షన్ మొదటి వాదనలో ఉపయోగించబడుతుంది మ్యాప్ () ఫంక్షన్ పేరు పెట్టబడిన జాబితా సంఖ్యలు యొక్క రెండవ వాదనలో ఉపయోగించబడుతుంది మ్యాప్ () ఫంక్షన్ యొక్క విలువ x వినియోగదారు నుండి తీసుకోబడుతుంది, మరియు మ్యాప్ () ఫంక్షన్ యొక్క పవర్ విలువల జాబితాను అందిస్తుంది x, ఐటెమ్ విలువల ఆధారంగా సంఖ్యలు జాబితా
c29.py
# శక్తిని లెక్కించడానికి ఫంక్షన్‌ను నిర్వచించండిడెఫ్cal_power(ఎన్):
తిరిగిx ** n
# X విలువను తీసుకోండి
x= int(ఇన్పుట్('X:' విలువను నమోదు చేయండి))
# సంఖ్యల టపుల్‌ను నిర్వచించండి
సంఖ్యలు= [2, 3, 4]
# మ్యాప్ () ఉపయోగించి x ని పవర్ n కి లెక్కించండి
ఫలితం= మ్యాప్(cal_power,సంఖ్యలు)
ముద్రణ(జాబితా(ఫలితం))
స్క్రిప్ట్‌ను అమలు చేసిన తర్వాత కింది అవుట్‌పుట్ కనిపిస్తుంది.
ఫిల్టర్ ఫంక్షన్ ఉపయోగం:
ఫిల్టర్ () పైథాన్ యొక్క ఫంక్షన్ ఒక ఇట్రేబుల్ ఆబ్జెక్ట్ నుండి డేటాను ఫిల్టర్ చేయడానికి మరియు ఫంక్షన్ నిజమైన రిటర్న్‌ల కోసం అంశాలతో జాబితాను రూపొందించడానికి అనుకూల ఫంక్షన్‌ను ఉపయోగిస్తుంది. కింది స్క్రిప్ట్‌లో, ఎంచుకున్న వ్యక్తి () అంశాల ఆధారంగా ఫిల్టర్ చేయబడిన డేటా జాబితాను రూపొందించడానికి ఫంక్షన్ స్క్రిప్ట్‌లో ఉపయోగించబడుతుంది ఎంపిక జాబితా .
c30.py
# పాల్గొనేవారి జాబితాను నిర్వచించండి= ['మోనాలిసా', 'అక్బర్ హుస్సేన్', 'జాకీర్ హసన్', 'జహదుర్ రహమాన్', 'జెనిఫర్ లోపెజ్']
# ఎంపిక చేసిన అభ్యర్థులను ఫిల్టర్ చేయడానికి ఫంక్షన్‌ను నిర్వచించండి
డెఫ్ఎంచుకున్న వ్యక్తి(పాల్గొనేవారు):
ఎంపిక చేయబడింది= ['అక్బర్ హుస్సేన్', 'జిల్లూర్ రెహమాన్', 'మోనాలిసా']
ఉంటే(పాల్గొనేవారులోఎంపిక చేయబడింది):
తిరిగి నిజమే
ఎంపిక జాబితా= వడపోత(ఎంచుకున్న వ్యక్తి,పాల్గొనేవారు)
ముద్రణ('ఎంపికైన అభ్యర్థులు:')
కోసంఅభ్యర్థిలోఎంపిక జాబితా:
ముద్రణ(అభ్యర్థి)
స్క్రిప్ట్‌ను అమలు చేసిన తర్వాత కింది అవుట్‌పుట్ కనిపిస్తుంది.
ముగింపు:
పైథాన్ ప్రోగ్రామింగ్ బేసిక్స్ ఈ వ్యాసంలోని 30 విభిన్న అంశాలను ఉపయోగించి చర్చించబడ్డాయి. ఈ వ్యాసం యొక్క ఉదాహరణలు పాఠకులకు మొదటి నుండి సులభంగా పైథాన్ నేర్చుకోవడానికి సహాయపడతాయని నేను ఆశిస్తున్నాను.