रनटाइम कैंडल की श्रृंखला पर जाता है। लेकिन एक कैंडल के भीतर भी दोहराव चाहिए हो सकता है: जैसे आखिरी पाँच क्लोज़ जोड़ना। इसके लिए लूप है।

for और range 

for offset in range(5):
    total += close[offset]

range(5) में offset को 0, 1, 2, 3 और 4 मिलते हैं। 5 शामिल नहीं है। हर वैल्यू पर अंदर की लाइन एक बार चलती है।

close[offset] पहले वर्तमान, फिर एक, दो, तीन और चार कैंडल पुरानी क्लोज़ है। कुल पाँच वैल्यू जोड़ते हैं।

लूप से पहले total शून्य करना है। यह एक कैंडल का बीच का नतीजा है, कैंडल के बीच बचने वाला काउंटर नहीं।

range(1, 5) से 1, 2, 3, 4 मिलते हैं। शुरुआत शामिल, अंत नहीं। शुरुआत न दें तो शून्य है।

हाथ से लिखा मूविंग एवरेज

manual_average.py बनाएँ:

"""
@pyne edge
"""
from pynecore.lib import close, color, input, plot, script, ta


@script.indicator("Manual Average Check", overlay=False)
def main(
    length: int = input.int(5, title="Length", minval=1, maxval=100),
):
    total = 0.0
    for offset in range(length):
        total += close[offset]
    manual_average = total / length
    builtin_average = ta.sma(close, length)
    difference = manual_average - builtin_average
    plot(difference, "Difference", color=color.blue)

डेमो पर चलाएँ। लाइन अपने औसत और तैयार SMA का अंतर है। वार्म-अप के बाद शून्य या संख्याओं के प्रतिनिधित्व की वजह से उसके बहुत पास होनी चाहिए।

manual_average.py के साथ PyneIDE के अलग पैनल में दोनों औसत का अंतर दिखता है।
अपने लूप और तैयार SMA का अंतर वार्म-अप के बाद शून्य के पास रहता है।

दो चढ़ी हुई लाइन में छोटे अंतर पहचानना कठिन है। अंतर सीधे बताता है कि दोनों गणना मिलती हैं या नहीं।

एक निष्पादन क्या करता है?

पाँच की लंबाई पर क्रम:

  1. total शून्य होता है।
  2. लूप वर्तमान और पिछली चार क्लोज़ जोड़ता है।
  3. जोड़ पाँच से भाग देते हैं।
  4. तैयार SMA निकालकर अपने औसत से उसका अंतर लेते हैं।
  5. अंतर की लाइन में एक बिंदु बनाते हैं।

फिर रनटाइम अगली कैंडल पर जाता है। वहाँ total फिर शून्य से है और लूप नई कैंडल की पाँच वैल्यू जोड़ता है।

total को Persistent करें तो अगली कैंडल पुराने जोड़ से जारी होगी। हर कैंडल पाँच और जोड़ेंगे, इसलिए वर्तमान विंडो का औसत नहीं रहेगा।

गायब हिस्ट्री

पहली चार कैंडल में पाँच वाली विंडो की कम से कम एक क्लोज़ गायब है। जोड़ में na आने से अपना औसत भी गायब है। तैयार SMA भी पाँचवीं पर वैध होती है।

डेमो की सभी क्लोज़ वैध हैं। बीच में भी डेटा गायब वाले स्रोत पर ta.sma का अनुपलब्ध वैल्यू संभालना साधारण कैंडल-ऑफ़सेट जोड़ से अलग हो सकता है। इसलिए उदाहरण यहीं दिए डेटा पर जाँचते हैं।

कितना दोहराव माँग रहे हैं?

सौ-कैंडल विंडो में हर कैंडल पर सौ जोड़ हैं। दो हज़ार कैंडल पर दो लाख लूप चरण होंगे।

तैयार ta.sma इसी आम काम को रनटाइम की इसके लिए बनी गणना से करती है। अपना लूप समझने और तुलना के लिए है। तैयार फ़ंक्शन काम करे तो वही लें।

लूप का अंत ज्ञात और सीमित होना चाहिए। इनपुट का अधिकतम तय करता है कि एक कैंडल पर उपयोगकर्ता कितना काम माँग सकता है।

break और continue

break लूप रोकता है। continue मौजूदा चरण का बाकी छोड़कर अगले पर जाता है।

औसत विंडो में ध्यान रखें। तीन वैल्यू जोड़कर रुकें तो पाँच से ऐसे भाग नहीं दे सकते जैसे पाँच वैल्यू थीं। छोड़ना गणना का अर्थ बदलता है।

स्वयं करके देखें

लंबाई तीन करें। किसी कैंडल पर ऑफ़सेट और तीन कीमतें लिखें। फिर तुलना के लिए अपने और तैयार औसत को भी ओवरले में दिखाने वाला रूप बनाएँ।

अभ्यास का हल

तीन ऑफ़सेट 0, 1, 2 हैं। डेकोरेटर में overlay=True और गणना के बाद:

plot(manual_average, "Manual average", color=color.blue, linewidth=2)
plot(builtin_average, "Built-in average", color=color.orange)

इस व्यू से अंतर की लाइन हटाएँ। शून्य के पास लाइन और कीमत पर औसत एक स्केल पर पढ़ना कठिन है। जाँच के लिए मूल अंतर पैनल अलग रूप में रख सकते हैं।

खिसकी हुई विंडो पहचानें

सोचें कि range(1, length + 1) से क्या बदलेगा। संख्या पाँच ही है, लेकिन वर्तमान छूटेगी और पाँच कैंडल पहले की आएगी। यह पिछली कैंडल की औसत विंडो होगी।