r - बड़े आर कार्यक्रमों को व्यवस्थित कैसे करें?




package conventions (7)

जब मैं किसी भी जटिलता की आर परियोजना शुरू करता हूं, तो मेरी स्क्रिप्ट जल्दी से लंबी और उलझन में आती हैं।

कुछ अभ्यास क्या हैं जिन्हें मैं अपना सकता हूं ताकि मेरा कोड हमेशा काम करने में खुशी होगी? मैं चीजों के बारे में सोच रहा हूँ

  • स्रोत फ़ाइलों में कार्यों का प्लेसमेंट
  • किसी अन्य स्रोत फ़ाइल में कुछ तोड़ने के लिए कब
  • मास्टर फ़ाइल में क्या होना चाहिए
  • संगठनात्मक इकाइयों के रूप में कार्यों का उपयोग करना (चाहे यह सार्थक है कि आर वैश्विक राज्य तक पहुंच बनाना मुश्किल बनाता है)
  • इंडेंटेशन / लाइन ब्रेक प्रैक्टिस।
    • इलाज (जैसे {?
    • चीजें रखो)} 1 या 2 लाइनों पर?

असल में, बड़े आर स्क्रिप्ट को व्यवस्थित करने के लिए अंगूठे के आपके नियम क्या हैं?


आर इंटरैक्टिव उपयोग और छोटी स्क्रिप्ट के लिए ठीक है, लेकिन मैं इसे बड़े कार्यक्रम के लिए उपयोग नहीं करता। मैं अधिकांश प्रोग्रामिंग के लिए मुख्यधारा की भाषा का उपयोग करता हूं और इसे आर इंटरफ़ेस में लपेटता हूं।


पैकेज के पक्ष में मुझे एक और व्यक्ति के रूप में गिनें। मैं मैन पेज और विगेट्स लिखने पर बहुत खराब होने के लिए स्वीकार करूंगा जब तक कि मुझे / या जब मुझे जारी किया जाए (यानी जारी किया जा रहा हो), लेकिन यह स्रोत डो को बंडल करने के लिए एक आसान आसान तरीका बनाता है। इसके अलावा, यदि आप अपना कोड बनाए रखने के बारे में गंभीर हैं, तो अंक जो डिर्क लाता है वह सभी प्ली में आते हैं।


मानक जवाब पैकेज का उपयोग करना है - लेखन आर एक्सटेंशन मैनुअल के साथ-साथ वेब पर विभिन्न ट्यूटोरियल देखें।

यह आपको देता है

  • विषय के आधार पर अपना कोड व्यवस्थित करने के लिए एक अर्ध स्वचालित तरीका
  • आपको इंटरफ़ेस के बारे में सोचने के लिए दृढ़ता से एक सहायता फ़ाइल लिखने के लिए प्रोत्साहित करता है
  • R CMD check चेक के माध्यम से बहुत से सैनिटी चेक
  • रिग्रेशन परीक्षण जोड़ने का मौका
  • साथ ही नामस्थान के लिए साधन भी।

कोड पर बस चल रहा source() वास्तव में छोटे स्निपेट के लिए काम करता है। बाकी सब कुछ पैकेज में होना चाहिए - भले ही आप इसे प्रकाशित करने की योजना नहीं बनाते क्योंकि आप आंतरिक भंडारों के लिए आंतरिक पैकेज लिख सकते हैं।

'कैसे संपादित करें' भाग के लिए, आर आंतरिक मैनुअल के पास अनुभाग 6 में उत्कृष्ट आर कोडिंग मानकों हैं । अन्यथा, मैं Emacs 'ESS मोड में डिफ़ॉल्ट का उपयोग करता हूं।

2008-अगस्त -13 अपडेट करें: डेविड स्मिथ ने अभी Google आर स्टाइल गाइड के बारे में ब्लॉग किया है।


मेरा मतलब है कि संकुल कैसे लिखना है, लेकिन समय का निवेश नहीं किया है। मेरी प्रत्येक मिनी-प्रोजेक्ट्स के लिए मैं अपने सभी निम्न-स्तरीय कार्यों को 'फ़ंक्शंस' नामक फ़ोल्डर में रखता हूं, और उन्हें एक अलग नामस्थान में स्रोत करता हूं जिसे मैं स्पष्ट रूप से बना देता हूं।

कोड की निम्न पंक्तियां खोज पथ पर "myfuncs" नामक वातावरण बनाती हैं, यदि यह पहले से मौजूद नहीं है (संलग्नक का उपयोग करके), और मेरे 'कार्यों /' निर्देशिका में .r फ़ाइलों में निहित कार्यों के साथ इसे पॉप्युलेट करें sys.source)। मैं आमतौर पर "मुख्य इंटरफ़ेस" के लिए मेरी मुख्य स्क्रिप्ट के शीर्ष पर इन पंक्तियों को डालता हूं, जिससे उच्च स्तरीय फ़ंक्शंस (निम्न-स्तरीय फ़ंक्शंस का आह्वान) कहा जाता है।

if( length(grep("^myfuncs$",search()))==0 )
  attach("myfuncs",pos=2)
for( f in list.files("functions","\\.r$",full=TRUE) )
  sys.source(f,pos.to.env(grep("^myfuncs$",search())))

जब आप परिवर्तन करते हैं तो आप इसे हमेशा उसी पंक्ति के साथ फिर से स्रोत कर सकते हैं, या कुछ ऐसा उपयोग कर सकते हैं

evalq(f <- function(x) x * 2, pos.to.env(grep("^myfuncs$",search())))

आपके द्वारा बनाए गए पर्यावरण में परिवर्धन / संशोधन का मूल्यांकन करने के लिए।

यह मुझे पता है, लेकिन इसके बारे में बहुत औपचारिक होने से बचाता है (लेकिन अगर आपको मौका मिलता है तो मैं पैकेज सिस्टम को प्रोत्साहित करता हूं - उम्मीद है कि मैं भविष्य में इस तरह से माइग्रेट करूंगा)।

कोडिंग सम्मेलनों के लिए, यह सौंदर्यशास्त्र के बारे में मैंने देखा है केवल एकमात्र चीज है (मुझे उन्हें पसंद है और संक्षेप में पालन करें लेकिन मैं आर में बहुत अधिक घुंघराले ब्रेसिज़ का उपयोग नहीं करता):

http://www1.maths.lth.se/help/R/RCC/

[, ड्रॉप = FALSE] के उपयोग के संबंध में अन्य "सम्मेलन" हैं और <- असाइनमेंट ऑपरेटर के रूप में उपयोग प्रस्तुति पर विभिन्न प्रस्तुतियों (आमतौर पर मुख्य नोट) में सुझाया गया है! सम्मेलन, लेकिन मुझे नहीं लगता कि इनमें से कोई भी सख्त है (हालांकि [, ड्रॉप = FALSE] उन कार्यक्रमों के लिए उपयोगी है जिनमें आप अपेक्षित इनपुट के बारे में सुनिश्चित नहीं हैं)।


मैं Dirk सलाह से सहमत हूँ! आईएमएचओ, आपके प्रोग्राम को सरल स्क्रिप्ट से दस्तावेज पैकेज में व्यवस्थित करना, प्रोग्रामिंग में आर के लिए है, जैसे वर्ड टू टीएक्स / लाटेक्स को लिखित रूप में स्विच करना। मैं बहुत उपयोगी क्रिएटिंग आर पैकेज पर एक नज़र डालने की सलाह देता हूं : फ्रेडरिक लीश द्वारा एक ट्यूटोरियल


मैं अपनी फाइलों में अलग कार्यक्षमता डालना पसंद करता हूं।

लेकिन मुझे आर की पैकेज प्रणाली पसंद नहीं है। इसका उपयोग करना मुश्किल है।

मैं एक हल्के विकल्प को पसंद करता हूं, एक फ़ाइल के कार्यों को पर्यावरण के अंदर रखने के लिए (क्या हर दूसरी भाषा "नामस्थान" कहती है) और इसे संलग्न करें। उदाहरण के लिए, मैंने इस तरह के कार्यों का 'उपयोग' समूह बनाया है:

util = new.env()

util$bgrep = function [...]

util$timeit = function [...]

while("util" %in% search())
  detach("util")
attach(util)

यह सब एक फाइल util.Rutil.R । जब आप इसे स्रोत करते हैं, तो आपको पर्यावरण 'उपयोग' मिलता है ताकि आप util$bgrep() और इस तरह का उपयोग कर util$bgrep() ; लेकिन इसके अलावा, attach() कॉल इसे बस bgrep() और ऐसे काम को सीधे बनाता है। यदि आपने उन सभी कार्यों को अपने पर्यावरण में नहीं रखा है, तो वे दुभाषिया के शीर्ष-स्तरीय नेमस्पेस को प्रदूषित करेंगे (वह जो ls() दिखाता है)।

मैं पायथन प्रणाली को अनुकरण करने की कोशिश कर रहा था, जहां हर फाइल एक मॉड्यूल है। यह बेहतर होगा, लेकिन यह ठीक लगता है।


यह थोड़ा स्पष्ट हो सकता है खासकर यदि आप प्रोग्रामर हैं, लेकिन यहां मैं कोड की तार्किक और भौतिक इकाइयों के बारे में सोचता हूं।

मुझे नहीं पता कि यह आपका मामला है, लेकिन जब मैं आर में काम कर रहा हूं, तो मैं शायद ही कभी एक बड़े जटिल कार्यक्रम के साथ शुरूआत करता हूं। मैं आम तौर पर एक स्क्रिप्ट में शुरू होता हूं और अलग-अलग कोड को तार्किक रूप से अलग करने योग्य इकाइयों में शुरू करता हूं, अक्सर कार्यों का उपयोग करता हूं। डेटा मैनिपुलेशन और विज़ुअलाइजेशन कोड अपने कार्यों में इत्यादि रखे जाते हैं। और ऐसे कार्यों को फ़ाइल के एक सेक्शन में एक साथ समूहीकृत किया जाता है (शीर्ष पर डेटा मैनिपुलेशन, फिर विज़ुअलाइजेशन इत्यादि)। आखिरकार आप इस बारे में सोचना चाहते हैं कि अपनी स्क्रिप्ट को बनाए रखने और दोष दर को कम करने के लिए इसे कैसे आसान बनाना है।

आप कितने अच्छे / मोटे अनाज को अपने कार्यों में बदल देंगे और अंगूठे के विभिन्न नियम हैं: उदाहरण के लिए कोड की 15 पंक्तियां, या "एक कार्य करने के लिए एक कार्य जिम्मेदार होना चाहिए जिसे इसके नाम से पहचाना जाता है", आदि। आपका लाभ अलग-अलग होगा । चूंकि आर कॉल-बाय-रेफरेंस का समर्थन नहीं करता है, इसलिए आमतौर पर मैं अपने कार्यों को बहुत अच्छी तरह से दानेदार बनाने में भिन्न होता हूं जब इसमें डेटा फ्रेम या इसी तरह के ढांचे को पास करना शामिल होता है। लेकिन जब मैंने पहली बार आर के साथ शुरुआत की तो कुछ मूर्ख प्रदर्शन गलतियों के लिए यह अतिसंवेदनशील हो सकता है।

लॉजिकल इकाइयों को अपनी भौतिक इकाइयों में निकालने के लिए (जैसे स्रोत फाइलें और पैकेज जैसे बड़े समूह)? मेरे पास दो मामले हैं सबसे पहले, अगर फ़ाइल बहुत बड़ी हो जाती है और तार्किक रूप से असंबंधित इकाइयों के बीच स्क्रॉलिंग एक परेशानी है। दूसरा, अगर मेरे पास ऐसे कार्य हैं जिन्हें अन्य कार्यक्रमों द्वारा पुन: उपयोग किया जा सकता है। मैं आमतौर पर कुछ समूहबद्ध इकाई को रखकर शुरू करता हूं, डेटा मैनिपुलेशन फ़ंक्शंस को एक अलग फ़ाइल में कहता हूं। मैं फिर इस फ़ाइल को किसी अन्य स्क्रिप्ट से स्रोत कर सकता हूं।

यदि आप अपने कार्यों को तैनात करने जा रहे हैं, तो आपको पैकेज के बारे में सोचना शुरू करना होगा। मैं उत्पादन में आर कोड तैनात नहीं करता हूं या विभिन्न कारणों से दूसरों द्वारा पुन: उपयोग के लिए (संक्षेप में: संगठन संस्कृति अन्य लैंगुग पसंद करता है, प्रदर्शन के बारे में चिंताओं, जीपीएल, आदि)। साथ ही, मैं निरंतर परिष्कृत फाइलों के अपने संग्रह में परिष्कृत और जोड़ना चाहता हूं, और जब मैं कोई परिवर्तन करता हूं तो मैं संकुल से निपटने की अपेक्षा नहीं करता। तो आपको इस मोर्चे पर अधिक जानकारी के लिए, डिर्क की तरह अन्य पैकेज से संबंधित उत्तरों की जांच करनी चाहिए।

अंत में, मुझे लगता है कि आपका प्रश्न आर के लिए जरूरी नहीं है। मैं वास्तव में स्टीव मैककनेल द्वारा कोड पूर्ण पढ़ने की सिफारिश करता हूं जिसमें बड़े पैमाने पर ऐसे मुद्दों और कोडिंग प्रथाओं के बारे में बहुत सारी जानकारी होती है।





project-organization