# పైథాన్ పనితీరు: స్థానిక నంపీ లూప్‌లు, కాల్‌బ్యాక్‌లు మరియు మార్పిడి ఖర్చులు

Published: 2026-10-17

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

Canonical: https://thedailydiff.dev/te/video/2026-10-17-python-native-loops/

## ఈ వీడియో ఏమి కవర్ చేస్తుంది

- CPython మూలాన్ని బైట్‌కోడ్‌కు కంపైల్ చేస్తుంది. పదేపదే ఇంటర్‌ప్రెటర్/వస్తువు పని మరియు టైప్ చేసిన స్థానిక సంఖ్యా లూప్ వేర్వేరు అమలు ఏర్పాట్లు.
- సంఖ్యా నంపీ అంకగణితం టైప్ చేసిన బ్యాచ్‌లను కంపైల్ చేయబడిన కార్యకలాపాలకు అందజేస్తుంది; అంకగణిత లూప్ ఇప్పటికీ ఉంది, మరియు వీక్షణలు నాన్‌కాంటిగ్యుస్ లేఅవుట్‌లను కలిగి ఉండవచ్చు.
- మార్పిడి మరియు అవసరమైన అవుట్‌పుట్ ప్రాతినిధ్యాన్ని కొలవండి. ఈ రన్‌లో, పైథాన్ జాబితాలను శ్రేణులుగా మార్చడం మరియు తిరిగి మార్చడం పెద్ద సిద్ధంగా-శ్రేణి ఆధిక్యాన్ని తొలగించింది.
- చిన్న పనిభారాలు సాధారణ పైథాన్‌కు అనుకూలంగా ఉండవచ్చు ఎందుకంటే స్థిర శ్రేణి-కాల్ ఖర్చులు ముఖ్యమైనవి. ఎనిమిది-విలువ కాంప్రహెన్షన్ ఈ కొలవబడిన పోలికను గెలిచింది.
- np.vectorize అనేది వరుస మూలకాల కోసం పైథాన్‌ను కాల్ చేసే సౌలభ్యం వ్రాపర్; ఒక బ్యాచ్ ఇంటర్‌ఫేస్ మాత్రమే స్థానిక సంఖ్యా అమలును ఏర్పాటు చేయదు.
- కంపైల్ చేయబడిన పైథాన్-సింటాక్స్ లూప్‌లు కూడా వేగంగా ఉండగలవు. కాలర్‌కు ముఖ్యమైనప్పుడు కోల్డ్ కంపైలేషన్/సెటప్ ఖర్చులను చేర్చండి.
- స్థానిక అమలు, CPU SIMD, మల్టీథ్రెడింగ్ మరియు GPU బ్యాకెండ్‌లు వేర్వేరు ఆలోచనలు. అందుబాటులో ఉన్న CPU ఫీచర్లు ఒక నిర్దిష్ట రన్‌లో ఉపయోగించిన సూచనలను గుర్తించవు.

## అధ్యాయాలు

- 0:00 ఒకే CPU ఎందుకు త్వరగా పూర్తి చేయగలదు?
- 0:52 పైథాన్ లూప్ ఏ పనిని పునరావృతం చేస్తుంది?
- 1:38 నంపీ లూప్‌ను ఎక్కడికి కదుపుతుంది?
- 2:13 వేగంగా అంటే GPU లేదా చాలా CPU కోర్లు అని అర్థమా?
- 2:49 ఆకట్టుకునే వేగం ఎప్పుడు అదృశ్యమవుతుంది?
- 3:28 బెంచ్‌మార్క్‌లో ఏ సరిహద్దులు చేర్చాలి?
- 4:00 కంపైల్ చేయబడిన పైథాన్ లూప్ కూడా వేగంగా ఉండగలదా?
- 4:56 np.vectorize వాస్తవానికి ఏమి అమలు చేస్తుంది?
- 5:41 మీ కోడ్‌లో మీరు ఏమి మార్చాలి?

## అనువదించబడిన ట్రాన్స్క్రిప్ట్

అసలైన ఆంగ్ల కథనం నుండి అనువదించబడింది. అందుబాటులో ఉన్న ఆడియో మరియు క్యాప్షన్లు YouTube ద్వారా నియంత్రించబడతాయి.

### ఒకే CPU ఎందుకు త్వరగా పూర్తి చేయగలదు?

0:00 వేగవంతం కావడానికి పైథాన్‌కు కొత్త భాష అవసరమని మీరు భావిస్తున్నారు. లూప్ కదిలిన తర్వాత అదే CPU మా బ్యాచ్‌ను వేగంగా నడిపింది. పని ఎక్కడికి వెళ్ళింది? వేగం ఎప్పుడు అదృశ్యమవుతుంది? పైథాన్‌ను తిరిగి తీసుకువచ్చే షార్ట్‌కట్ ఏది? ఇది ది డైలీ డిఫ్, అంతర్గతంగా. ఆ షార్ట్‌కట్‌పై ఒక కన్ను వేసి ఉంచండి. CPython ప్రామాణిక పైథాన్ అమలు.

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

0:40 ఈ మెషీన్‌లో, కాంప్రహెన్షన్ దాదాపు ముప్పై మూడు మిల్లీసెకన్లు పట్టింది. నంపీ ఒకదాని కంటే తక్కువ తీసుకుంది. రెండూ CPU లో నడిచాయి. ఇది ఈ పనిభారానికి ఉపయోగకరమైన సాక్ష్యం, మరియు ఒక ప్రోగ్రామింగ్ భాషకు భయంకరమైన సంతాపం. సాధారణ లూప్‌తో ప్రారంభించండి.

### పైథాన్ లూప్ ఏ పనిని పునరావృతం చేస్తుంది?

0:53 పైథాన్ తదుపరి విలువను పొందుతుంది, అంకగణితాన్ని నిర్వహిస్తుంది మరియు సమాధానాన్ని జోడిస్తుంది. ఆపై అది మళ్ళీ చేస్తుంది. గుణకారం చౌకగా ఉంటుంది. తదుపరి గుణకారాన్ని ఏర్పాటు చేయడం, మరియు దాని చుట్టూ ఉన్న పైథాన్ వస్తువులను నిర్వహించడం, ప్రతిసారీ పనిని పెంచుతుంది. ఇది పరీక్షించబడిన ఫంక్షన్ యొక్క వాస్తవ విచ్ఛేదనం. పునరావృతం, గుణకారం మరియు కూడిక బైట్‌కోడ్ సూచనలుగా కనిపిస్తాయి. పైథాన్ వెర్షన్లు మరియు ఇంటర్‌ప్రెటర్లు వేర్వేరు ఎంపికలు చేస్తాయి.

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

1:36 పేపర్‌వర్క్ దాని స్వంత కెరీర్‌ను అభివృద్ధి చేసుకుంది.

### నంపీ లూప్‌ను ఎక్కడికి కదుపుతుంది?

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

2:00 పైథాన్ ఇప్పటికీ పనిని అందజేసే వ్యక్తి. ఇటామర్ టర్నర్ ట్రౌరింగ్ పైథాన్ స్పీడ్ లో ఈ వ్యత్యాసాన్ని వివరిస్తాడు. బ్యాచ్ ఇంటర్‌ఫేస్‌లు, స్థానిక అమలులు మరియు ప్రాసెసర్ వెక్టార్ సూచనలు వేర్వేరు విషయాలు. ఫంక్షన్ పేరు చాలా తక్కువ సాక్ష్యాలను అందిస్తుంది.

### వేగంగా అంటే GPU లేదా చాలా CPU కోర్లు అని అర్థమా?

2:13 ఈ ఫలితం CPU లో నంపీని ఉపయోగించింది. CuPy వంటి GPU బ్యాకెండ్ శ్రేణులు మరియు కార్యకలాపాలకు వేరే ఇంటిని ఎంచుకుంటుంది. GPU ని కొనుగోలు చేయడం వలన ఈ సాధారణ పైథాన్ లూప్ అది ఇప్పటికే నడుస్తున్న చోట నడుస్తుంది. CPU వెక్టార్ సూచనలు అనేక విలువలను కలిసి ప్రాసెస్ చేయగలవు. నంపీ మద్దతు ఉన్న కెర్నల్‌లను ఎంచుకోవడానికి యంత్రాంగాన్ని కలిగి ఉంది. మా రన్‌టైమ్ అందుబాటులో ఉన్న లక్షణాలను నివేదిస్తుంది, కానీ ఈ వ్యక్తీకరణ యొక్క సూచనలను గుర్తించదు. మొత్తం కొలవబడిన లాభాన్ని వెక్టార్ సూచనలకు ఇవ్వడం సాక్ష్యాన్ని అతిశయోక్తి చేస్తుంది.

2:40 GPU షాపింగ్ కార్ట్ మూసి ఉంచవచ్చు. కొనుగోలును రద్దు చేసే పనితీరు పరిష్కారం గురించి చాలా సంతృప్తికరమైన విషయం ఉంది. దురదృష్టవశాత్తు, బెంచ్‌మార్క్ కొనసాగుతుంది.

### ఆకట్టుకునే వేగం ఎప్పుడు అదృశ్యమవుతుంది?

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

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

### బెంచ్‌మార్క్‌లో ఏ సరిహద్దులు చేర్చాలి?

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

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

### కంపైల్ చేయబడిన పైథాన్ లూప్ కూడా వేగంగా ఉండగలదా?

4:00 మీరు లూప్ సింటాక్స్‌ను కూడా ఉంచవచ్చు మరియు దాని అమలును మార్చవచ్చు. నంబా మద్దతు ఉన్న సంఖ్యా పైథాన్ ఫంక్షన్‌లను స్థానిక కోడ్‌గా కంపైల్ చేయగలదు. ఇక్కడ మా పరీక్ష నుండి దాని కంపైలర్ డెకరేటర్‌తో లూప్ ఉంది. అది ఇప్పటికీ 'ఫర్' అని చెబుతుంది. ఖరీదైన ఇంటర్‌ప్రెటర్ మార్గం మారింది. కంపైలేషన్ తర్వాత, ఈ లూప్ సిద్ధంగా ఉన్న శ్రేణులతో సగం మిల్లీసెకన్ కంటే తక్కువ తీసుకుంది. ఈ రన్‌లో కంపైలేషన్ స్వయంగా దాదాపు ఒక సెకను పట్టింది. ఆ సెటప్ ఖర్చు పునరావృత సమయాల నుండి మినహాయించబడింది,

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

4:43 ఇప్పుడు ఆ షార్ట్‌కట్ కోసం. మీరు ఒక పైథాన్ ఫంక్షన్‌ను కలిగి ఉన్నారు మరియు అది ఒక శ్రేణిని అంగీకరించాలని కోరుకుంటున్నారు. వెక్టరైజ్ అనే వ్రాపర్ తప్పిపోయిన పనితీరు బటన్ లాగా అనిపిస్తుంది. దాని డాక్యుమెంటేషన్‌లో ఒక ముఖ్యమైన వాక్యం వేచి ఉంది. నంపీ దాని వెక్టరైజ్ వ్రాపర్ ప్రధానంగా సౌలభ్యం కోసం అందించబడిందని చెబుతుంది.

### np.vectorize వాస్తవానికి ఏమి అమలు చేస్తుంది?

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

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

### మీ కోడ్‌లో మీరు ఏమి మార్చాలి?

5:41 సాధారణ లూప్‌లు ఇప్పటికే బాగా పనిచేసినప్పుడు వాటిని ఉంచుకోండి. పని ఎక్కడ జరుగుతుందో మరియు తదుపరి కాలర్‌కు ఏమి అవసరమో తనిఖీ చేయండి. సబ్‌స్క్రైబ్ చేయండి, గంటను కొట్టండి, మరియు మీరు దానిని వేరే విధంగా స్టాంప్ చేశారా అని వ్యాఖ్యలలో నాకు చెప్పండి. మరియు ఈ రోజుకు ఇది డిఫ్. నేను ఆక్స్రిసి నుండి నికో. బాధ్యతాయుతంగా విలీనం చేయండి. బాధ్యతాయుతంగా విలీనం చేయండి.

## మూలాలు

- [Universal functions (ufunc) basics — NumPy 2.2](https://numpy.org/doc/2.2/user/basics.ufuncs.html) — NumPy
- [The N-dimensional array — NumPy 2.2](https://numpy.org/doc/2.2/reference/arrays.ndarray.html) — NumPy
- [numpy.vectorize — convenience and performance notes](https://numpy.org/doc/2.2/reference/generated/numpy.vectorize.html) — NumPy
- [CPU/SIMD optimizations — NumPy 2.2](https://numpy.org/doc/2.2/reference/simd/index.html) — NumPy
- [dis — Disassembler for Python bytecode](https://docs.python.org/3.10/library/dis.html) — Python Software Foundation
- [CPython 3.10.12 list representation](https://github.com/python/cpython/blob/v3.10.12/Include/cpython/listobject.h) — CPython contributors
- [The limits of Python vectorization as a performance technique](https://pythonspeed.com/articles/vectorization-python-alternatives/) — Itamar Turner-Trauring / Python⇒Speed
- [Performance Tips](https://numba.readthedocs.io/en/stable/user/performance-tips.html) — Numba
- [Basics of CuPy](https://docs.cupy.dev/en/stable/user_guide/basic.html) — CuPy