પાયથોનમાં, પુનરાવૃત્તિની સંખ્યા (પુનરાવર્તનની મહત્તમ સંખ્યા) ની ઉપરની મર્યાદા છે. મોટી સંખ્યામાં કોલ્સ સાથે પુનરાવર્તિત કાર્ય ચલાવવા માટે, મર્યાદા બદલવી જરૂરી છે. પ્રમાણભૂત પુસ્તકાલયના sys મોડ્યુલમાં કાર્યોનો ઉપયોગ કરો.
પુનરાવૃત્તિની સંખ્યા પણ સ્ટેક કદ દ્વારા મર્યાદિત છે. કેટલાક વાતાવરણમાં, પ્રમાણભૂત પુસ્તકાલયના સંસાધન મોડ્યુલનો ઉપયોગ મહત્તમ સ્ટેક કદને બદલવા માટે કરી શકાય છે (તે ઉબુન્ટુ પર કામ કરે છે, પરંતુ વિન્ડોઝ અથવા મેક પર નહીં).
નીચેની માહિતી અહીં આપવામાં આવી છે.
- વર્તમાન પુનરાવર્તનની સંખ્યાની ઉપલી મર્યાદા મેળવો:
sys.getrecursionlimit() - પુનરાવર્તનની સંખ્યાની ઉપરની મર્યાદા બદલો:
sys.setrecursionlimit() - સ્ટેકનું મહત્તમ કદ બદલો:
resource.setrlimit()
ઉબુન્ટુ પર નમૂના કોડ ચાલી રહ્યો છે.
વર્તમાન રિકર્ઝન મર્યાદા મેળવો: sys.getrecursionlimit ()
વર્તમાન રિકર્ઝન મર્યાદા sys.getrecursionlimit () સાથે મેળવી શકાય છે.
import sys
import resource
print(sys.getrecursionlimit())
# 1000
ઉદાહરણમાં, પુનરાવર્તનની મહત્તમ સંખ્યા 1000 છે, જે તમારા પર્યાવરણને આધારે બદલાઈ શકે છે. નોંધ કરો કે જે સંસાધન આપણે અહીં આયાત કરી રહ્યા છીએ તે પાછળથી ઉપયોગમાં લેવાશે, પરંતુ વિન્ડોઝ પર નહીં.
ઉદાહરણ તરીકે, અમે નીચેના સરળ પુનરાવર્તિત કાર્યનો ઉપયોગ કરીશું. જો હકારાત્મક પૂર્ણાંક n ને દલીલ તરીકે સ્પષ્ટ કરવામાં આવે છે, તો કોલની સંખ્યા n વખત હશે.
def recu_test(n):
if n == 1:
print('Finish')
return
recu_test(n - 1)
જો તમે ઉપરની મર્યાદા કરતા વધારે રિકર્શન કરવાનો પ્રયાસ કરશો તો એક ભૂલ (રિકર્સન એરર) ભી થશે.
recu_test(950)
# Finish
# recu_test(1500)
# RecursionError: maximum recursion depth exceeded in comparison
નોંધ કરો કે sys.getrecursionlimit () દ્વારા મેળવેલ મૂલ્ય સખત રીતે પુનરાવર્તનની મહત્તમ સંખ્યા નથી, પરંતુ પાયથોન દુભાષિયાની મહત્તમ સ્ટેક depthંડાઈ છે, તેથી જો પુનરાવર્તનની સંખ્યા આ મૂલ્ય કરતા થોડી ઓછી હોય તો પણ, ભૂલ (RecursionError) થશે beભા થવું.
帰 限界 は 、 、 帰 の 限界 で 、 、 અજગર イ ン タ ー プ リ の
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 () દ્વારા બદલી શકાય છે. ઉપલી મર્યાદા દલીલ તરીકે સ્પષ્ટ થયેલ છે.
Deepંડા પુનરાવર્તન કરવા માટે પરવાનગી આપે છે.
sys.setrecursionlimit(2000)
print(sys.getrecursionlimit())
# 2000
recu_test(1500)
# Finish
જો ઉલ્લેખિત ઉપલી મર્યાદા ખૂબ નાની અથવા ખૂબ મોટી છે, તો એક ભૂલ થશે. આ અવરોધ (મર્યાદાની ઉપલી અને નીચલી મર્યાદા પોતે) પર્યાવરણના આધારે બદલાય છે.
મર્યાદાનું મહત્તમ મૂલ્ય પ્લેટફોર્મ પર આધાર રાખે છે. જો તમને deepંડા રિકર્શનની જરૂર હોય, તો તમે પ્લેટફોર્મ દ્વારા સપોર્ટેડ રેન્જમાં મોટું મૂલ્ય નિર્દિષ્ટ કરી શકો છો, પરંતુ ધ્યાન રાખો કે જો આ મૂલ્ય ખૂબ મોટું હોય તો ક્રેશનું કારણ બનશે.
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
પાયથોનમાં, પ્રમાણભૂત લાઇબ્રેરીમાં રિસોર્સ મોડ્યુલનો ઉપયોગ મહત્તમ સ્ટેક સાઇઝ બદલવા માટે કરી શકાય છે. જો કે, સંસાધન મોડ્યુલ યુનિક્સ-વિશિષ્ટ મોડ્યુલ છે અને વિન્ડોઝ પર તેનો ઉપયોગ કરી શકાતો નથી.
- Unix Specific Services — Python 3.10.0 Documentation
- resource — Resource usage information — Python 3.10.0 Documentation
Resource.getrlimit () સાથે, તમે (સોફ્ટ લિમિટ, હાર્ડ લિમિટ) ના ટુપલ તરીકે દલીલમાં ઉલ્લેખિત સ્ત્રોતની મર્યાદા મેળવી શકો છો. અહીં, અમે સ્ત્રોત તરીકે સ્પષ્ટ કરીએ છીએ.
- 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 (કોઈ મર્યાદા નથી) પર સેટ કરવામાં આવી છે, પરંતુ વાસ્તવમાં, તેને યોગ્ય મૂલ્ય સુધી મર્યાદિત કરવું વધુ સુરક્ષિત રહેશે.
આ ઉપરાંત, જ્યારે મેં મારા મેક પર પણ અમર્યાદિત નરમ મર્યાદા સેટ કરવાનો પ્રયાસ કર્યો, ત્યારે નીચેની ભૂલ આવી.ValueError: not allowed to raise maximum limit
સુડો સાથે સ્ક્રિપ્ટ ચલાવવામાં મદદ મળી નથી. તે સિસ્ટમ દ્વારા પ્રતિબંધિત થઈ શકે છે.
સુપરયુઝરની અસરકારક UID સાથેની પ્રક્રિયા કોઈપણ મર્યાદા સહિત કોઈપણ વ્યાજબી મર્યાદાની વિનંતી કરી શકે છે.
જો કે, એક વિનંતી કે જે સિસ્ટમ દ્વારા લાદવામાં આવેલી મર્યાદાને ઓળંગે છે તે હજુ પણ મૂલ્ય ભૂલ તરફ દોરી જશે.
resource.setrlimit() — Resource usage information — Python 3.10.0 Documentation
Windows પાસે સંસાધન મોડ્યુલ નથી, અને મેક સિસ્ટમની મર્યાદાઓને કારણે મહત્તમ સ્ટેક કદ બદલી શક્યું નથી. જો આપણે કોઈક રીતે સ્ટેકનું કદ વધારી શકીએ, તો આપણે સેગ્મેન્ટેશન ફોલ્ટને ઉકેલવામાં સમર્થ હોવા જોઈએ, પરંતુ અમે આની પુષ્ટિ કરી શક્યા નથી.