आर में कोडिंग अभ्यास: विभिन्न शैलियों के फायदे और नुकसान क्या हैं?

Question

बनाम आवश्यकता के उपयोग के संबंध में हालिया प्रश्न :: आर में प्रोग्रामिंग करते समय कौन सी प्रोग्रामिंग शैलियों का उपयोग किया जाता है, और उनके फायदे/नुकसान क्या हैं, इस बारे में सवाल उठाया गया है। स्रोत कोड के माध्यम से ब्राउज़ करना या नेट पर ब्राउज़ करना, आप कई अलग-अलग शैलियों को प्रदर्शित करते हैं।

मेरी कोड में मुख्य रुझान:

• मैं सूचकांक (और नेस्ट सूचकांक), जो कभी कभी बल्कि अस्पष्ट कोड में परिणाम है लेकिन आम तौर पर एक बहुत अन्य समाधान की तुलना में तेजी है के साथ एक बहुत खेलते हैं। जैसे: x[x < 5] <- 0x <- ifelse(x < 5, x, 0) के बजाय

• मैं घोंसला कार्यों के लिए करते हैं अस्थायी वस्तुओं है कि मैं साफ करने के लिए की जरूरत के साथ स्मृति ओवरलोडिंग से बचने के लिए। खासकर बड़े डेटासेट में हेरफेर करने वाले कार्यों के साथ यह एक वास्तविक बोझ हो सकता है। उदाहरण: y <- cbind(x,as.numeric(factor(x)))y <- as.numeric(factor(x)) ; z <- cbind(x,y)

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

• मैं, हर हालत में छोरों से बचने के रूप में मैं vectorization पर विचार एक बहुत क्लीनर होने के लिए (और तेजी से)

फिर भी, मैं, देखा है कि इस पर राय अलग है और कुछ लोगों वापस करने के लिए करते हैं प्रोग्रामिंग के मेरे "पर्ल" तरीके से (या यहां तक ​​कि "लिस्प", मेरे कोड में चारों ओर उड़ने वाले सभी ब्रैकेट के साथ वे क्या कहेंगे। मैं अब तक नहीं जाऊंगा)।

आप आर में अच्छे कोडिंग अभ्यास पर क्या विचार करते हैं?

आपकी प्रोग्रामिंग शैली क्या है, और आप इसके फायदे और नुकसान कैसे देखते हैं?

Answer 1

मैं जो करता हूं वह इस बात पर निर्भर करेगा कि मैं कोड क्यों लिख रहा हूं। अगर मैं अपने शोध (दिन की नौकरी) के लिए डेटा विश्लेषण स्क्रिप्ट लिख रहा हूं, तो मुझे कुछ ऐसा काम चाहिए जो काम करता है लेकिन वह पठनीय और समझने योग्य महीनों या साल बाद भी है। मुझे गणना समय के बारे में बहुत ज्यादा परवाह नहीं है। lapply एट अल के साथ वेक्टरिंग। obfuscation के लिए नेतृत्व कर सकते हैं, जो मैं टालना चाहता हूँ।

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

आपके अन्य गोलियों के लिए; मैं इनलाइन/घोंसला कॉल तक नहीं करूँगा जब तक वे बहुत तुच्छ नहीं थे। यदि मैं स्पष्ट रूप से चरणों का स्पेल करता हूं, तो मुझे कोड को पढ़ने में आसान लगता है और इसलिए बग रखने की संभावना कम होती है।

मैं हर समय कस्टम फ़ंक्शन लिखता हूं, खासकर यदि मैं लूप या इसी तरह के फ़ंक्शन के बराबर कोड को कॉल करने जा रहा हूं। इस तरह मैंने मुख्य डेटा विश्लेषण स्क्रिप्ट से कोड को अपने स्वयं के .R फ़ाइल में समाहित किया है जो विश्लेषण के इरादे से विश्लेषण को अलग करने में मदद करता है।और यदि समारोह उपयोगी है तो मेरे पास अन्य परियोजनाओं आदि में उपयोग के लिए है।

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

एक बात जो मैं करने से बचने की कोशिश करता हूं, बहुत चालाक है जब मैं कोड, जो भी मैं कोडिंग कर रहा हूं। आखिरकार मैं कभी भी चालाक नहीं हूं क्योंकि मुझे लगता है कि मैं कई बार हूं और यदि मैं चीजों को सरल रखता हूं, तो मैं अपने चेहरे पर गिरना नहीं चाहता जितनी बार मैं कर सकता था अगर मैं चालाक होने की कोशिश कर रहा था।

Answer 2

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

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

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

मैं प्रत्येक कार्य के लिए एक फ़ंक्शन ढूंढने का प्रयास करता हूं जिसे मैं प्राप्त करने का प्रयास कर रहा हूं। मेरा मानना ​​है कि मेरे सामने किसी ने इसके बारे में सोचा है और एक ऐसा कार्य किया है जो मैं कुछ भी कर सकता हूं उससे बेहतर काम करता है। यह कभी-कभी काम करता है, कभी-कभी इतना नहीं।

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

मुझे पता चला कि कोड फोल्डिंग और सिंटैक्स रंग (मैं ग्रहण + स्टेटेट का उपयोग करता हूं) के साथ एक अच्छा वाक्यविन्यास संपादक मुझे बहुत सारे सिरदर्द बचाता है।

विटोशका के पोस्ट के आधार पर, मैं जोड़ रहा हूं कि मैं फ़ंक्शन नामों के लिए पूंजीकृत शब्द (सेंसू जावा) का उपयोग करता हूं और चर के लिए fullstop.delimited। मैं देखता हूं कि मेरे पास फ़ंक्शन तर्कों के लिए एक और शैली हो सकती है।

Answer 3

डेटा जॉगलिंग के लिए मैं जितना संभव हो उतना एसक्यूएल का उपयोग करने की कोशिश करता हूं, कम से कम मूलभूत चीजों जैसे GROUP BY औसत के लिए। मुझे आर बहुत पसंद है लेकिन कभी-कभी यह महसूस करना मजेदार नहीं है कि आपकी शोध रणनीति अभी तक एक और पैकेज में छिपी हुई एक और कार्य को खोजने के लिए पर्याप्त नहीं है। मेरे मामलों के लिए एसक्यूएल बोलियां ज्यादा भिन्न नहीं होती हैं और कोड वास्तव में पारदर्शी है। अधिकांश समय सीमा (आर वाक्यविन्यास का उपयोग शुरू करने के लिए) खोजने के बजाय सहज ज्ञान युक्त है। जैसे

require(RMySQL) 
# selection of variables alongside conditions in SQL is really transparent 
# even if conditional variables are not part of the selection 
statement = "SELECT id,v1,v2,v3,v4,v5 FROM mytable 
      WHERE this=5 
      AND that != 6" 
mydf <- dbGetQuery(con,statement) 
# some simple things get really tricky (at least in MySQL), but simple in R 
# standard deviation of table rows 
dframe$rowsd <- sd(t(dframe)) 

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

Answer 4

नामकरण सम्मेलन कोड की पठनीयता के लिए अत्यंत महत्वपूर्ण हैं।आर के एस 4 आंतरिक शैली यहाँ से प्रेरित होकर मैं क्या उपयोग है:

• वैश्विक कार्य करता है और वस्तुओं (DoSomething, getXyyy, UPPERLIMIT की तरह) के लिए केमलकेस
• कार्यों एक क्रिया के साथ शुरू
• निर्यात नहीं और सहायक कार्यों हमेशा शुरू साथ में "।"
• स्थानीय चर और फ़ंक्शन सभी छोटे अक्षरों में और "_" वाक्यविन्यास (do_something, get_xyyy) में हैं, यह स्थानीय बनाम वैश्विक को अलग करना आसान बनाता है और इसलिए क्लीनर कोड की ओर जाता है।