रोजमर्रा की जिंदगी में आलसी कंप्यूटिंग

और हालांकि जो लोग खरीदारी की सूची लिखने के लिए या सिर से किराए के डेटा संकलन को संकलित करने के लिए अजगर लिपियों का उपयोग करते हैं, लेकिन अगर ऐसा होता है कि आप नियमित कार्यों को हल करने के लिए स्क्रिप्ट का उपयोग करते हैं और कभी-कभी स्क्रिप्ट अस्वीकार्य रूप से लंबे समय तक काम करते हैं, तो विचार आलसी गणनाओं का उपयोग करना है। हर चीज जो चलती है, आप उसे पसंद करेंगे।

अपने पत्र के पिछले अध्यायों में, मैंने वाष्पीकरण पुस्तकालय के संचालन का मुफ्त विवरण दिया।
लिंक: आलसी कम्प्यूटिंग पेड़ों की डिस्क कैशिंग

यह पढ़ने से पहले आपको उस सामग्री का अध्ययन करने की आवश्यकता के साथ बोर नहीं करने के लिए, पिछले भाग का एक संक्षिप्त सारांश:

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

कुछ बदलावों के बारे में

अंतिम लेख लिखने के बाद से, evalcache ने कुछ अतिरिक्त यांत्रिकी प्राप्त किए हैं।

गैर-कैश्ड निष्पादन यांत्रिकी

यह पता चला है कि एक आलसी वस्तु का हैश इतनी उपयोगी चीज है कि आप इसे ऐसी स्थिति में उपयोग करना चाहते हैं जहां ऑब्जेक्ट को कैशिंग करना असंभव और अनावश्यक है।

इस उद्देश्य के लिए एक विशेष वाक्यविन्यास पेश किया गया है:

lazyhash = evalcache.LazyHash() #: #evalcache.Lazy(self, cache=None, fastdo=True) @lazyhash def foo(): ... 

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

अव्यवस्थित प्रकटीकरण यांत्रिकी

अव्यवस्थित प्रकटीकरण एक ज्ञापनकर्ता का अपेक्षित व्यवहार है। हालांकि evalcache मूल रूप से संस्मरण के लिए नहीं बनाया गया था, लेकिन संगणना पेड़ों के साथ काम करने के लिए, evalcache एल्गोरिदम पर आधारित अंतर्निहित प्रकटीकरण प्राप्त किया जा सकता है। इसके लिए दो नए विकल्प onplace और onuse पेश किए गए हैं। onplace निर्माण के तुरंत बाद आलसी वस्तु के प्रकटीकरण की ओर अग्रसर होता है, और आलसी वस्तु के लिए अनुमत कुछ कार्यों में इसका उपयोग करने की कोशिश करने पर चालू होता है।

 import evalcache lazy = evalcache.Lazy(cache={}, onuse=True) #lazy = evalcache.Lazy(cache={}, onplace=True) ###   . #lazy = evalcache.Memoize() ###   . #lazy = evalcache.Memoize(onplace=True) ###   . @lazy def fib(n): if n < 2: return n return fib(n - 1) + fib(n - 2) for i in range(0,100): print(fib(i)) 

लेकिन हम इस अनावश्यक जोड़ के बारे में बात नहीं कर रहे हैं, पुस्तकालय को अन्य lenificators के समान थोड़ा अधिक बनाने के लिए डिज़ाइन किया गया है। और आलसी फाइलों के बारे में:

आलसी फाइलें

Evalcache में फ़ाइलों को उत्पन्न करने वाले कार्यों को जोड़ने के लिए एक ऐड-इन होता है। प्रारंभ में, इस कार्यक्षमता का उपयोग स्क्रीनशॉट की पीढ़ी को सक्रिय करने के लिए किया जाना था। जैसा कि बाद में पता चला, आलसी फाइलों के यांत्रिकी का उपयोग करके, आप अन्य दिलचस्प चीजें कर सकते हैं।

 import evalcache import evalcache.lazyfile lazyfile = evalcache.lazyfile.LazyFile(cache = evalcache.DirCache(".evalfile")) @lazyfile(field="path") def foo(data, path): f = open(path, "w") f.write(data) f.close() foo("HelloWorld","data.dat") 

यह कैसे काम करता है ...
सामान्य तौर पर, काम का तर्क सभी आलसी वस्तुओं के साथ समान है।
foo("HelloWorld","data.dat") एक आलसी वस्तु का निर्माण करना शुरू करता है जिसकी हैश कुंजी इसे पारित किए गए तर्कों से जुड़ी होती है। उसके बाद, अंतर्निहित प्रकटीकरण के यांत्रिकी लागू होते हैं, जिससे गणना की तत्काल शुरुआत होती है।

लेकिन फिर कार्रवाई का तरीका बदल जाता है।
@lazyfile(field="path") lazyfile डेकोरेटर क्षेत्र में निर्दिष्ट नाम के साथ एक पैरामीटर को पार्स करता है। डेकोरेटर को उम्मीद है कि फ़ंक्शन के निष्पादन पर, इस पथ के साथ एक फ़ाइल बनाई जाएगी। evalcache इस फ़ाइल को लेता है और ".evalfile" हैश निर्देशिका में इसके लिए एक कड़ी बनाता है। हार्ड लिंक फ़ाइल नाम आलसी वस्तु के हैश कुंजी से मेल खाता है। बाद में, जब उस नाम के साथ एक फ़ाइल कैश में होती है, तो evalcache, फ़ंक्शन को कॉल करने के बजाय ऑब्जेक्ट का विस्तार करते समय, बस आवश्यक स्थान पर हार्ड लिंक को कैश में मौजूदा फ़ाइल में बनाता है।

यह उपयोगी है कि एक आलसी फ़ाइल एक साधारण आलसी वस्तु है, और इसे बनाने के लिए अन्य आलसी वस्तुओं का उपयोग किया जा सकता है।

 import evalcache import evalcache.lazyfile lazy = evalcache.lazy.Lazy(cache = evalcache.DirCache(".evalcache")) lazyfile = evalcache.lazyfile.LazyFile(cache = evalcache.DirCache(".evalfile")) @lazyfile(field="path") def foo(data, path): f = open(path, "w") f.write(data) f.close() @lazy def datagenerator(): return "HelloWorld" foo(datagenerator(),"data.dat") 

मूवीपी टूल के माध्यम से वीडियो एडिटिंग के लिए लाइनेशन लागू करना।

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

विशेष रूप से, मूवीपी लाइब्रेरी और इसके लिए प्रलेखन का अध्ययन करने के दो घंटे हमें एक सरल और कार्यात्मक वीडियो संपादक देते हैं। स्थापना - कृपया। ध्वनि लगाने के लिए - कृपया। विशेष प्रभाव - कृपया।

हालांकि, हमेशा की तरह, स्क्रिप्ट के साथ काम करने में एक खामी है। जब भी स्क्रिप्ट चलती है, सभी कलाकृतियों को फिर से बनाया जाता है। एक घंटे का वीडियो स्थापित करते समय, इस तरह की स्क्रिप्ट का संचालन बहुत लंबे समय तक रह सकता है।

Evalcache लाइब्रेरी का उपयोग करने से इस स्थिति में समायोजन करने में मदद मिली।

 #!/usr/bin/env python3 #coding:utf-8 import sys import types from moviepy.editor import * import evalcache.lazyfile lazyhash = evalcache.LazyHash() lazyfile = evalcache.lazyfile.LazyFile() LazyVideoClip = lazyhash(VideoClip) VideoFileClip = lazyhash(VideoFileClip) AudioFileClip = lazyhash(AudioFileClip) CompositeVideoClip = lazyhash(CompositeVideoClip) concatenate_videoclips = lazyhash(concatenate_videoclips) @lazyfile("path") def lazy_write_videofile(path, clip): clip.write_videofile(path) source = VideoFileClip("source.mp4") music0 = AudioFileClip("music0.mp3") music1 = AudioFileClip("music1.mp3") music = music0 dur = 3 s0 = 1 s1 = 8 s2 = 16 part0 = source.subclip(s0, s0 + dur) part1 = source.subclip(s1, s1 + dur * 2).fl_time(lambda t: t * 2).set_duration(2) part2 = source.subclip(s2, s2 + dur * 4).fl_time(lambda t: t * 5).set_duration(2) clip = concatenate_videoclips([part0, part1, part2]) clip = clip.set_audio(music.set_duration(clip.duration)) lazy_write_videofile("part0.mp4", part0) lazy_write_videofile("part1.mp4", part1) lazy_write_videofile("part2.mp4", part2) lazy_write_videofile("part0_mus.mp4", part0.set_audio(music.set_duration(part0.duration))) lazy_write_videofile("part1_mus.mp4", part1.set_audio(music.set_duration(part1.duration))) lazy_write_videofile("part2_mus.mp4", part2.set_audio(music.set_duration(part2.duration))) if len(sys.argv) > 1 and sys.argv[1] == "compile": clip.lazy_write_videofile("clip.mp4", clip) 

वहाँ क्या है

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

पुस्तकालयों में लपेटें पुस्तकालय कॉल:

 LazyVideoClip = lazyhash(VideoClip) VideoFileClip = lazyhash(VideoFileClip) AudioFileClip = lazyhash(AudioFileClip) CompositeVideoClip = lazyhash(CompositeVideoClip) concatenate_videoclips = lazyhash(concatenate_videoclips) 

इस निर्माण का उपयोग करते हुए, हम फाइलें उत्पन्न करेंगे:

 @lazyfile("path") def lazy_write_videofile(path, clip): clip.write_videofile(path) 

वीडियो अनुक्रम पर आवश्यक संचालन पूरा करने के बाद, हम अपनी क्लिप के हिस्सों को अलग-अलग फाइलों में लिखते हैं। संगीत के साथ और उसके बिना:

 lazy_write_videofile("part0.mp4", part0) lazy_write_videofile("part1.mp4", part1) lazy_write_videofile("part2.mp4", part2) lazy_write_videofile("part0_mus.mp4", part0.set_audio(music.set_duration(part0.duration))) lazy_write_videofile("part1_mus.mp4", part1.set_audio(music.set_duration(part1.duration))) lazy_write_videofile("part2_mus.mp4", part2.set_audio(music.set_duration(part2.duration))) 

इन फ़ाइलों को तभी बदला जाएगा जब संबंधित निष्पादन शाखाएं बदल जाएंगी।

जब परिणाम पूरा हो जाता है, तो 'संकलन' विकल्प का उपयोग करके भागों को एक बड़ी फ़ाइल में इकट्ठा करें:

 if len(sys.argv) > 1 and sys.argv[1] == "compile": clip.lazy_write_videofile("clip.mp4", clip) 

निष्कर्ष के बजाय:

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

संदर्भ:

गिथब परियोजना
पिपी परियोजना