పైథాన్‌లో, పునరావృతాల సంఖ్యకు గరిష్ట పరిమితి ఉంది (గరిష్ట సంఖ్యలో పునరావృత్తులు). పెద్ద సంఖ్యలో కాల్‌లతో పునరావృత ఫంక్షన్‌ను అమలు చేయడానికి, పరిమితిని మార్చడం అవసరం. ప్రామాణిక లైబ్రరీ యొక్క sys మాడ్యూల్‌లోని ఫంక్షన్‌లను ఉపయోగించండి.
స్టాక్ పరిమాణం ద్వారా పునరావృతాల సంఖ్య కూడా పరిమితం చేయబడింది. కొన్ని పరిసరాలలో, ప్రామాణిక లైబ్రరీ యొక్క వనరుల మాడ్యూల్ గరిష్ట స్టాక్ పరిమాణాన్ని మార్చడానికి ఉపయోగించబడుతుంది (ఇది ఉబుంటులో పనిచేసింది, కానీ విండోస్ లేదా మాక్‌లో కాదు).
కింది సమాచారం ఇక్కడ అందించబడింది.
- ప్రస్తుత పునరావృతాల గరిష్ట పరిమితిని పొందండి:
sys.getrecursionlimit() - పునరావృతాల సంఖ్య యొక్క ఎగువ పరిమితిని మార్చండి:
sys.setrecursionlimit() - స్టాక్ యొక్క గరిష్ట పరిమాణాన్ని మార్చండి:
resource.setrlimit()
నమూనా కోడ్ ఉబుంటులో రన్ అవుతోంది.
ప్రస్తుత పునరావృత పరిమితిని పొందండి: sys.getrecursionlimit ()
ప్రస్తుత పునరావృత పరిమితిని sys.getrecursionlimit () తో పొందవచ్చు.
import sys
import resource
print(sys.getrecursionlimit())
# 1000
ఉదాహరణలో, పునరావృతాల గరిష్ట సంఖ్య 1000, ఇది మీ వాతావరణాన్ని బట్టి మారవచ్చు. మేము ఇక్కడ దిగుమతి చేస్తున్న వనరు తరువాత ఉపయోగించబడుతుందని గమనించండి, కానీ Windows లో కాదు.
ఉదాహరణగా, మేము కింది సాధారణ పునరావృత ఫంక్షన్‌ను ఉపయోగిస్తాము. ఒక పాజిటివ్ పూర్ణాంకం n ఒక ఆర్గ్యుమెంట్‌గా పేర్కొనబడితే, కాల్‌ల సంఖ్య n సార్లు ఉంటుంది.
def recu_test(n):
if n == 1:
print('Finish')
return
recu_test(n - 1)
మీరు ఎగువ పరిమితి కంటే ఎక్కువగా పునరావృతం చేయడానికి ప్రయత్నిస్తే ఒక లోపం (RecursionError) లేవనెత్తబడుతుంది.
recu_test(950)
# Finish
# recu_test(1500)
# RecursionError: maximum recursion depth exceeded in comparison
Sys.getrecursionlimit () ద్వారా పొందిన విలువ ఖచ్చితంగా గరిష్ట సంఖ్యలో పునరావృత్తులు కాదని గమనించండి, కానీ పైథాన్ ఇంటర్‌ప్రెటర్ యొక్క గరిష్ట స్టాక్ డెప్త్, కాబట్టి పునరావృతాల సంఖ్య ఈ విలువ కంటే కొంచెం తక్కువగా ఉన్నప్పటికీ, ఒక లోపం (పునరావృత లోపం) అవుతుంది పెంచబడుతుంది.
、 帰 限界 は 再 帰 の の 限界 は 、 、 、 పైథాన్ イ ン タ ー プ リ タ の ス タ ッ ク の 最大 深度
python – Max recursion is not exactly what sys.getrecursionlimit() claims. How come? – Stack Overflow
# recu_test(995)
# RecursionError: maximum recursion depth exceeded while calling a Python object
పునరావృత పరిమితిని మార్చండి: sys.setrecursionlimit ()
పునరావృతాల సంఖ్య యొక్క ఎగువ పరిమితిని sys.setrecursionlimit () ద్వారా మార్చవచ్చు. ఎగువ పరిమితి వాదనగా పేర్కొనబడింది.
లోతైన పునరావృతాన్ని నిర్వహించడానికి అనుమతిస్తుంది.
sys.setrecursionlimit(2000)
print(sys.getrecursionlimit())
# 2000
recu_test(1500)
# Finish
పేర్కొన్న ఎగువ పరిమితి చాలా చిన్నది లేదా చాలా పెద్దది అయితే, లోపం ఏర్పడుతుంది. ఈ పరిమితి (పరిమితి యొక్క ఎగువ మరియు దిగువ పరిమితులు) పర్యావరణాన్ని బట్టి మారుతుంది.
పరిమితి యొక్క గరిష్ట విలువ ప్లాట్‌ఫారమ్‌పై ఆధారపడి ఉంటుంది. మీకు లోతైన పునరావృతం అవసరమైతే, మీరు ప్లాట్‌ఫారమ్ మద్దతు ఇచ్చే పరిధిలో పెద్ద విలువను పేర్కొనవచ్చు, కానీ ఈ విలువ చాలా పెద్దదిగా ఉంటే క్రాష్‌కు కారణమవుతుందని తెలుసుకోండి.
If the new limit is too low at the current recursion depth, a RecursionError exception is raised.
sys.setrecursionlimit() — System-specific parameters and functions — Python 3.10.0 Documentation
sys.setrecursionlimit(4)
print(sys.getrecursionlimit())
# 4
# sys.setrecursionlimit(3)
# RecursionError: cannot set the recursion limit to 3 at the recursion depth 1: the limit is too low
sys.setrecursionlimit(10 ** 9)
print(sys.getrecursionlimit())
# 1000000000
# sys.setrecursionlimit(10 ** 10)
# OverflowError: signed integer is greater than maximum
గరిష్ఠ సంఖ్యలో పునరావృత్తులు స్టాక్ పరిమాణం ద్వారా పరిమితం చేయబడ్డాయి, తరువాత వివరించిన విధంగా.
స్టాక్ యొక్క గరిష్ట పరిమాణాన్ని మార్చండి: resource.setrlimit ()
Sys.setrecursionlimit () లో పెద్ద విలువ సెట్ చేసినప్పటికీ, పునరావృతాల సంఖ్య పెద్దగా ఉంటే అది అమలు చేయబడకపోవచ్చు. సెగ్మెంటేషన్ లోపం క్రింది విధంగా జరుగుతుంది.
sys.setrecursionlimit(10 ** 9)
print(sys.getrecursionlimit())
# 1000000000
recu_test(10 ** 4)
# Finish
# recu_test(10 ** 5)
# Segmentation fault
పైథాన్‌లో, గరిష్ట స్టాక్ పరిమాణాన్ని మార్చడానికి ప్రామాణిక లైబ్రరీలోని వనరుల మాడ్యూల్‌ని ఉపయోగించవచ్చు. అయితే, వనరుల మాడ్యూల్ యునిక్స్-నిర్దిష్ట మాడ్యూల్ మరియు Windows లో ఉపయోగించబడదు.
- Unix Specific Services — Python 3.10.0 Documentation
- resource — Resource usage information — Python 3.10.0 Documentation
Resource.getrlimit () తో, మీరు వాదనలో పేర్కొన్న వనరు పరిమితిని (మృదు పరిమితి, కఠిన పరిమితి) టూపుల్‌గా పొందవచ్చు. ఇక్కడ, మేము resource.RLIMIT_STACK ని రిసోర్స్‌గా పేర్కొంటాము, ఇది ప్రస్తుత ప్రక్రియ యొక్క కాల్ స్టాక్ యొక్క గరిష్ట పరిమాణాన్ని సూచిస్తుంది.
- resource.getrlimit() — Resource usage information — Python 3.10.0 Documentation
- resource.RLIMIT_STACK — Resource usage information — Python 3.10.0 Documentation
print(resource.getrlimit(resource.RLIMIT_STACK))
# (8388608, -1)
ఉదాహరణలో, మృదువైన పరిమితి 8388608 (8388608 B = 8192 KB = 8 MB) మరియు కఠిన పరిమితి -1 (అపరిమిత).
మీరు resource.setrlimit () తో వనరు పరిమితిని మార్చవచ్చు. ఇక్కడ, మృదు పరిమితి -1 కి కూడా సెట్ చేయబడింది (పరిమితి లేదు). మీరు అపరిమిత పరిమితిని సూచించడానికి స్థిరమైన వనరును కూడా ఉపయోగించవచ్చు. RIM_INFINIT.
స్టాక్ సైజు మార్పుకు ముందు సెగ్మెంటేషన్ లోపం కారణంగా నిర్వహించలేని డీప్ రికర్షన్, ఇప్పుడు చేయవచ్చు.
resource.setrlimit(resource.RLIMIT_STACK, (-1, -1))
print(resource.getrlimit(resource.RLIMIT_STACK))
# (-1, -1)
recu_test(10 ** 5)
# Finish
ఇక్కడ, ఒక సాధారణ ప్రయోగం కోసం మృదువైన పరిమితి -1 (పరిమితి లేదు) కు సెట్ చేయబడింది, కానీ వాస్తవానికి, దానిని తగిన విలువకు పరిమితం చేయడం సురక్షితం.
అదనంగా, నేను నా Mac లో అపరిమిత సాఫ్ట్ పరిమితిని సెట్ చేయడానికి ప్రయత్నించినప్పుడు, కింది లోపం సంభవించింది.ValueError: not allowed to raise maximum limit
సుడోతో స్క్రిప్ట్‌ను అమలు చేయడం సహాయం చేయలేదు. ఇది సిస్టమ్ ద్వారా పరిమితం కావచ్చు.
సూపర్ యూజర్ యొక్క ప్రభావవంతమైన UID తో ఉన్న ప్రక్రియ ఎటువంటి పరిమితి లేకుండా సహేతుకమైన పరిమితిని అభ్యర్థించవచ్చు.
అయితే, సిస్టమ్ విధించిన పరిమితిని మించిన అభ్యర్థన ఇప్పటికీ ValueError కి దారి తీస్తుంది.
resource.setrlimit() — Resource usage information — Python 3.10.0 Documentation
విండోస్‌లో రిసోర్స్ మాడ్యూల్ లేదు, మరియు సిస్టమ్ పరిమితుల కారణంగా మాక్ గరిష్ట స్టాక్ పరిమాణాన్ని మార్చలేకపోయింది. మేము కొన్ని మార్గాల ద్వారా స్టాక్ పరిమాణాన్ని పెంచగలిగితే, మేము సెగ్మెంటేషన్ లోపాన్ని పరిష్కరించగలగాలి, కానీ మేము దీనిని నిర్ధారించలేకపోయాము.
