पायथन के साथ डेटा इंजीनियर साक्षात्कार प्रश्न

साक्षात्कार में जाना एक समय लेने वाली और थकाऊ प्रक्रिया हो सकती है, और तकनीकी साक्षात्कार और भी अधिक तनावपूर्ण हो सकते हैं! इस ट्यूटोरियल का उद्देश्य आपको कुछ सामान्य प्रश्नों के लिए तैयार करना है जो आपके डेटा इंजीनियर साक्षात्कार के दौरान आपके सामने आएंगे। आप सीखेंगे कि डेटाबेस, पायथन और एसक्यूएल के बारे में सवालों के जवाब कैसे दें।

इस ट्यूटोरियल के अंत तक, आप निम्न में सक्षम होंगे:

सामान्य डेटा इंजीनियर साक्षात्कार प्रश्नों को समझें
संबंधपरक और गैर-संबंधपरक डेटाबेस के बीच अंतर करें
पायथन का उपयोग करके डेटाबेस सेट करें
डेटा क्वेरी करने के लिए पायथन का उपयोग करें

निःशुल्क डाउनलोड: पायथन ट्रिक्स से एक नमूना अध्याय प्राप्त करें:वह पुस्तक जो आपको सरल उदाहरणों के साथ पायथन की सर्वोत्तम प्रथाओं को दिखाती है जिसे आप और अधिक सुंदर + पाइथोनिक कोड लिखने के लिए तुरंत लागू कर सकते हैं।

डेटा इंजीनियर बनना

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

डेटा इंजीनियर क्या करता है?

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

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

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

पायथन डेटा इंजीनियरों की कैसे मदद कर सकता है?

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

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

डेटा इंजीनियर साक्षात्कार प्रश्नों का उत्तर देना

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

संबंधपरक डेटाबेस पर प्रश्न

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

नोएसक्यूएल
कैश डेटाबेस
ग्राफ़ डेटाबेस
एसक्यूएल डेटाबेस में नोएसक्यूएल सपोर्ट

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

Q1:रिलेशनल बनाम नॉन-रिलेशनल डेटाबेस

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

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

प्रदर्शन किए जा रहे कार्य के प्रकार के आधार पर आपको गति तुलना परीक्षण करने की आवश्यकता होगी। आप INSERT choose चुन सकते हैं , UPDATE , DELETE , या कोई अन्य फ़ंक्शन। स्कीमा डिज़ाइन, सूचकांक, एकत्रीकरण की संख्या और रिकॉर्ड की संख्या भी इस विश्लेषण को प्रभावित करेगी, इसलिए आपको पूरी तरह से परीक्षण करने की आवश्यकता होगी। इसे कैसे करें, इसके बारे में आप बाद में और जानेंगे।

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

एक SQLite उदाहरण

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

import sqlite3

db = sqlite3.connect(':memory:')  # Using an in-memory database
cur = db.cursor()

अब आप इन-मेमोरी डेटाबेस से कनेक्ट हैं और आपका कर्सर ऑब्जेक्ट जाने के लिए तैयार है।

इसके बाद, आप निम्नलिखित तीन तालिकाएँ बनाएंगे:

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

अब जब आपको पता चल गया है कि आपकी टेबल कैसी दिखेगी, तो आप आगे बढ़ सकते हैं और उन्हें बना सकते हैं:

cur.execute('''CREATE TABLE IF NOT EXISTS Customer (
                id integer PRIMARY KEY,
                firstname varchar(255),
                lastname varchar(255) )''')
cur.execute('''CREATE TABLE IF NOT EXISTS Item (
                id integer PRIMARY KEY,
                title varchar(255),
                price decimal )''')
cur.execute('''CREATE TABLE IF NOT EXISTS BoughtItem (
                ordernumber integer PRIMARY KEY,
                customerid integer,
                itemid integer,
                price decimal,
                CONSTRAINT customerid
                    FOREIGN KEY (customerid) REFERENCES Customer(id),
                CONSTRAINT itemid
                    FOREIGN KEY (itemid) REFERENCES Item(id) )''')

आपने cur.execute() . को एक क्वेरी पास की है अपनी तीन टेबल बनाने के लिए।

अंतिम चरण अपनी तालिकाओं को डेटा से भरना है:

cur.execute('''INSERT INTO Customer(firstname, lastname)
               VALUES ('Bob', 'Adams'),
                      ('Amy', 'Smith'),
                      ('Rob', 'Bennet');''')
cur.execute('''INSERT INTO Item(title, price)
               VALUES ('USB', 10.2),
                      ('Mouse', 12.23),
                      ('Monitor', 199.99);''')
cur.execute('''INSERT INTO BoughtItem(customerid, itemid, price)
               VALUES (1, 1, 10.2),
                      (1, 2, 12.23),
                      (1, 3, 199.99),
                      (2, 3, 180.00),
                      (3, 2, 11.23);''') # Discounted price

अब जबकि प्रत्येक तालिका में कुछ रिकॉर्ड हैं, आप इस डेटा का उपयोग कुछ और डेटा इंजीनियर साक्षात्कार प्रश्नों के उत्तर देने के लिए कर सकते हैं।

Q2:SQL एकत्रीकरण कार्य

एकत्रीकरण कार्य वे हैं जो परिणाम सेट पर गणितीय संक्रिया करते हैं। कुछ उदाहरणों में शामिल हैं AVG , COUNT , MIN , MAX , और SUM . अक्सर, आपको GROUP BY . की आवश्यकता होगी और HAVING इन एकत्रीकरण के पूरक के लिए खंड। एक उपयोगी एकत्रीकरण कार्य है AVG , जिसका उपयोग आप किसी दिए गए परिणाम सेट के माध्य की गणना करने के लिए कर सकते हैं:

>>>

>>> cur.execute('''SELECT itemid, AVG(price) FROM BoughtItem GROUP BY itemid''')
>>> print(cur.fetchall())
[(1, 10.2), (2, 11.73), (3, 189.995)]

यहां, आपने अपने डेटाबेस में खरीदे गए प्रत्येक आइटम के लिए औसत मूल्य प्राप्त किया है। आप देख सकते हैं कि आइटम एक itemid . के साथ है का 1 इसकी औसत कीमत $10.20 है।

उपरोक्त आउटपुट को समझने में आसान बनाने के लिए, आप itemid . के बजाय आइटम का नाम प्रदर्शित कर सकते हैं :

>>>

>>> cur.execute('''SELECT item.title, AVG(boughtitem.price) FROM BoughtItem as boughtitem
...             INNER JOIN Item as item on (item.id = boughtitem.itemid)
...             GROUP BY boughtitem.itemid''')
...
>>> print(cur.fetchall())
[('USB', 10.2), ('Mouse', 11.73), ('Monitor', 189.995)]

अब, आप अधिक आसानी से देख सकते हैं कि $10.20 की औसत कीमत वाला आइटम USB है ।

एक और उपयोगी एकत्रीकरण है SUM . आप इस फ़ंक्शन का उपयोग प्रत्येक ग्राहक द्वारा खर्च की गई कुल राशि को प्रदर्शित करने के लिए कर सकते हैं:

>>>

>>> cur.execute('''SELECT customer.firstname, SUM(boughtitem.price) FROM BoughtItem as boughtitem
...             INNER JOIN Customer as customer on (customer.id = boughtitem.customerid)
...             GROUP BY customer.firstname''')
...
>>> print(cur.fetchall())
[('Amy', 180), ('Bob', 222.42000000000002), ('Rob', 11.23)]

एमी नाम के ग्राहक ने औसतन लगभग 180 डॉलर खर्च किए, जबकि रॉब ने केवल 11.23 डॉलर खर्च किए!

यदि आपका साक्षात्कारकर्ता डेटाबेस पसंद करता है, तो हो सकता है कि आप नेस्टेड प्रश्नों पर ब्रश करना चाहें, प्रकारों में शामिल हों, और एक रिलेशनल डेटाबेस आपकी क्वेरी को निष्पादित करने के लिए कदम उठाए।

Q3:SQL क्वेरी को गति देना

गति विभिन्न कारकों पर निर्भर करती है, लेकिन अधिकतर इस बात से प्रभावित होती है कि इनमें से कितने मौजूद हैं:

जुड़ता है
एकत्रीकरण
ट्रैवर्सल
रिकॉर्ड

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

गति इस बात से भी प्रभावित होती है कि सूचकांक . हैं या नहीं डेटाबेस में मौजूद है। सूचकांक अत्यंत महत्वपूर्ण हैं और आपको तालिका के माध्यम से शीघ्रता से खोज करने और क्वेरी में निर्दिष्ट कुछ कॉलम के लिए एक मिलान खोजने की अनुमति देते हैं।

सूचकांक अधिक डालने के समय के साथ-साथ कुछ भंडारण की कीमत पर रिकॉर्ड को सॉर्ट करते हैं। एकल अनुक्रमणिका बनाने के लिए एकाधिक स्तंभों को जोड़ा जा सकता है। उदाहरण के लिए, कॉलम date और price संयुक्त किया जा सकता है क्योंकि आपकी क्वेरी दोनों स्थितियों पर निर्भर करती है।

Q4:SQL क्वेरी डीबग करना

अधिकांश डेटाबेस में एक EXPLAIN QUERY PLAN . शामिल होता है जो क्वेरी को निष्पादित करने के लिए डेटाबेस द्वारा उठाए जाने वाले चरणों का वर्णन करता है। SQLite के लिए, आप EXPLAIN QUERY PLAN . जोड़कर इस कार्यक्षमता को सक्षम कर सकते हैं SELECT . के सामने कथन:

>>>

>>> cur.execute('''EXPLAIN QUERY PLAN SELECT customer.firstname, item.title, 
...                item.price, boughtitem.price FROM BoughtItem as boughtitem
...                INNER JOIN Customer as customer on (customer.id = boughtitem.customerid)
...                INNER JOIN Item as item on (item.id = boughtitem.itemid)''')
...
>>> print(cur.fetchall())
[(4, 0, 0, 'SCAN TABLE BoughtItem AS boughtitem'), 
(6, 0, 0, 'SEARCH TABLE Customer AS customer USING INTEGER PRIMARY KEY (rowid=?)'), 
(9, 0, 0, 'SEARCH TABLE Item AS item USING INTEGER PRIMARY KEY (rowid=?)')]

यह क्वेरी सभी खरीदे गए आइटम के लिए प्रथम नाम, आइटम शीर्षक, मूल मूल्य और खरीदी गई कीमत को सूचीबद्ध करने का प्रयास करती है।

यहां बताया गया है कि क्वेरी योजना स्वयं कैसी दिखती है:

SCAN TABLE BoughtItem AS boughtitem
SEARCH TABLE Customer AS customer USING INTEGER PRIMARY KEY (rowid=?)
SEARCH TABLE Item AS item USING INTEGER PRIMARY KEY (rowid=?)

ध्यान दें कि आपके पायथन कोड में फ़ेच स्टेटमेंट केवल स्पष्टीकरण देता है, लेकिन परिणाम नहीं। ऐसा इसलिए है क्योंकि EXPLAIN QUERY PLAN उत्पादन में उपयोग करने का इरादा नहीं है।

गैर-संबंधपरक डेटाबेस पर प्रश्न

पिछले खंड में, आपने संबंधपरक और गैर-संबंधपरक डेटाबेस के बीच अंतर रखा और पायथन के साथ SQLite का उपयोग किया। अब आप NoSQL पर ध्यान केंद्रित करने जा रहे हैं। आपका लक्ष्य इसकी ताकत, अंतर और उपयोग के मामलों को उजागर करना है।

एक MongoDB उदाहरण

आप पहले की तरह ही डेटा का उपयोग करेंगे, लेकिन इस बार आपका डेटाबेस MongoDB होगा। यह NoSQL डेटाबेस दस्तावेज़-आधारित है और बहुत अच्छी तरह से मापता है। सबसे पहले चीज़ें, आपको आवश्यक पायथन लाइब्रेरी स्थापित करने की आवश्यकता होगी:

$ pip install pymongo

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

नोट: इस खंड में कोड चलाने के लिए, आपको एक चालू डेटाबेस सर्वर की आवश्यकता होगी। इसे कैसे सेट करें, इसके बारे में अधिक जानने के लिए, MongoDB और Python का परिचय देखें।

यहां बताया गया है कि आप डेटाबेस कैसे बनाते हैं और कुछ डेटा कैसे सम्मिलित करते हैं:

import pymongo

client = pymongo.MongoClient("mongodb://localhost:27017/")

# Note: This database is not created until it is populated by some data
db = client["example_database"]

customers = db["customers"]
items = db["items"]

customers_data = [{ "firstname": "Bob", "lastname": "Adams" },
                  { "firstname": "Amy", "lastname": "Smith" },
                  { "firstname": "Rob", "lastname": "Bennet" },]
items_data = [{ "title": "USB", "price": 10.2 },
              { "title": "Mouse", "price": 12.23 },
              { "title": "Monitor", "price": 199.99 },]

customers.insert_many(customers_data)
items.insert_many(items_data)

जैसा कि आपने देखा होगा, MongoDB डेटा रिकॉर्ड को संग्रह . में संग्रहीत करता है , जो पायथन में शब्दकोशों की सूची के बराबर हैं। व्यवहार में, MongoDB BSON दस्तावेज़ों को संग्रहीत करता है।

Q5:MongoDB के साथ डेटा क्वेरी करना

आइए BoughtItem को दोहराने की कोशिश करें तालिका पहले, जैसा आपने SQL में किया था। ऐसा करने के लिए, आपको ग्राहक को एक नया फ़ील्ड जोड़ना होगा। MongoDB का दस्तावेज़ीकरण निर्दिष्ट करता है कि कीवर्ड ऑपरेटर सेट सभी मौजूदा क्षेत्रों को लिखे बिना रिकॉर्ड को अपडेट करने के लिए इस्तेमाल किया जा सकता है:

# Just add "boughtitems" to the customer where the firstname is Bob
bob = customers.update_many(
        {"firstname": "Bob"},
        {
            "$set": {
                "boughtitems": [
                    {
                        "title": "USB",
                        "price": 10.2,
                        "currency": "EUR",
                        "notes": "Customer wants it delivered via FedEx",
                        "original_item_id": 1
                    }
                ]
            },
        }
    )

ध्यान दें कि आपने customer . में अतिरिक्त फ़ील्ड कैसे जोड़े हैं पहले से स्कीमा को स्पष्ट रूप से परिभाषित किए बिना। निफ्टी!

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

amy = customers.update_many(
        {"firstname": "Amy"},
        {
            "$set": {
                "boughtitems":[
                    {
                        "title": "Monitor",
                        "price": 199.99,
                        "original_item_id": 3,
                        "discounted": False
                    }
                ]
            } ,
        }
    )
print(type(amy))  # pymongo.results.UpdateResult

SQL के समान, दस्तावेज़-आधारित डेटाबेस भी क्वेरीज़ और एग्रीगेशन को निष्पादित करने की अनुमति देते हैं। हालाँकि, कार्यक्षमता वाक्यात्मक रूप से और अंतर्निहित निष्पादन दोनों में भिन्न हो सकती है। वास्तव में, आपने देखा होगा कि MongoDB $ . को सुरक्षित रखता है रिकॉर्ड पर कुछ कमांड या एकत्रीकरण निर्दिष्ट करने के लिए वर्ण, जैसे $group . आप इस व्यवहार के बारे में आधिकारिक दस्तावेज़ों में अधिक जान सकते हैं।

आप वैसे ही क्वेरी कर सकते हैं जैसे आपने SQL में किया था। शुरू करने के लिए, आप एक इंडेक्स बना सकते हैं:

>>>

>>> customers.create_index([("name", pymongo.DESCENDING)])

यह वैकल्पिक है, लेकिन यह उन प्रश्नों को गति देता है जिनके लिए नाम देखने की आवश्यकता होती है।

फिर, आप आरोही क्रम में छांटे गए ग्राहक नामों को पुनः प्राप्त कर सकते हैं:

>>>>

>>> items = customers.find().sort("name", pymongo.ASCENDING)

आप खरीदे गए आइटम के माध्यम से पुनरावृति और प्रिंट भी कर सकते हैं:

>>>

>>> for item in items:
...     print(item.get('boughtitems'))    
...
None
[{'title': 'Monitor', 'price': 199.99, 'original_item_id': 3, 'discounted': False}]
[{'title': 'USB', 'price': 10.2, 'currency': 'EUR', 'notes': 'Customer wants it delivered via FedEx', 'original_item_id': 1}]

आप डेटाबेस में अद्वितीय नामों की सूची भी प्राप्त कर सकते हैं:

>>>

>>> customers.distinct("firstname")
['Bob', 'Amy', 'Rob']

अब जब आप अपने डेटाबेस में ग्राहकों के नाम जानते हैं, तो आप उनके बारे में जानकारी प्राप्त करने के लिए एक क्वेरी बना सकते हैं:

>>>

>>> for i in customers.find({"$or": [{'firstname':'Bob'}, {'firstname':'Amy'}]}, 
...                                  {'firstname':1, 'boughtitems':1, '_id':0}):
...     print(i)
...
{'firstname': 'Bob', 'boughtitems': [{'title': 'USB', 'price': 10.2, 'currency': 'EUR', 'notes': 'Customer wants it delivered via FedEx', 'original_item_id': 1}]}
{'firstname': 'Amy', 'boughtitems': [{'title': 'Monitor', 'price': 199.99, 'original_item_id': 3, 'discounted': False}]}

यहाँ समतुल्य SQL क्वेरी है:

SELECT firstname, boughtitems FROM customers WHERE firstname LIKE ('Bob', 'Amy')

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

Q6:NoSQL बनाम SQL

यदि आपके पास लगातार बदलती स्कीमा है, जैसे वित्तीय नियामक जानकारी, तो नोएसक्यूएल रिकॉर्ड्स और नेस्ट संबंधित जानकारी को संशोधित कर सकता है। कल्पना करें कि यदि आपके पास नेस्टिंग के आठ ऑर्डर हैं, तो आपको SQL में कितने जॉइन करने होंगे! हालांकि, यह स्थिति आपके विचार से कहीं अधिक सामान्य है।

अब, क्या होगा यदि आप रिपोर्ट चलाना चाहते हैं, उस वित्तीय डेटा पर जानकारी निकालना चाहते हैं, और निष्कर्ष निकालना चाहते हैं? इस मामले में, आपको जटिल प्रश्नों को चलाने की आवश्यकता है, और इस संबंध में SQL अधिक तेज़ हो जाता है।

नोट: SQL डेटाबेस, विशेष रूप से PostgreSQL, ने भी एक फीचर जारी किया है जो क्वेरी करने योग्य JSON डेटा को रिकॉर्ड के हिस्से के रूप में सम्मिलित करने की अनुमति देता है। हालांकि यह दोनों दुनिया के सर्वश्रेष्ठ को जोड़ सकता है, गति चिंता का विषय हो सकती है।

पोस्टग्रेएसक्यूएल में JSON-टाइप कॉलम से JSON फ़ील्ड को क्वेरी करने की तुलना में NoSQL डेटाबेस से असंरचित डेटा को क्वेरी करना तेज़ है। निश्चित उत्तर के लिए आप हमेशा गति तुलना परीक्षण कर सकते हैं।

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

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

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

आपसे यह भी पूछा जा सकता है कि आपके डेटा इंजीनियर साक्षात्कार में आप किन अन्य डेटाबेस के बारे में जानते हैं। कई अन्य प्रासंगिक डेटाबेस हैं जो कई कंपनियों द्वारा उपयोग किए जाते हैं:

लोचदार खोज पाठ खोज में अत्यधिक कुशल है। यह एक शक्तिशाली खोज उपकरण बनाने के लिए अपने दस्तावेज़-आधारित डेटाबेस का लाभ उठाता है।
न्यूट डीबी पायथन के अनुकूल NoSQL डेटाबेस बनाने के लिए ZODB और PostgreSQL JSONB फीचर को जोड़ती है।
InfluxDB घटनाओं को संग्रहीत करने के लिए समय-श्रृंखला अनुप्रयोगों में उपयोग किया जाता है।

सूची जारी है, लेकिन यह दिखाता है कि कैसे उपलब्ध डेटाबेस की एक विस्तृत विविधता उनके विशिष्ट उद्योग को पूरा करती है।

कैश डेटाबेस पर प्रश्न

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

एक रेडिस उदाहरण

आपने दीर्घकालिक भंडारण समाधानों के लिए SQL और NoSQL डेटाबेस को कवर किया है, लेकिन तेज़, अधिक तत्काल संग्रहण के बारे में क्या? एक डेटा इंजीनियर कैसे बदल सकता है कि किसी डेटाबेस से डेटा कितनी तेजी से प्राप्त होता है?

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

जबकि यह सर्वर लोड को कम करता है, यह डेटा इंजीनियर, बैकएंड टीम और DevOps टीम के लिए दो सिरदर्द भी पैदा करता है। सबसे पहले, अब आपको कुछ ऐसे डेटाबेस की आवश्यकता होगी जिसमें आपके मुख्य SQL या NoSQL डेटाबेस की तुलना में तेज़ रीड टाइम हो। हालाँकि, दोनों डेटाबेस की सामग्री को अंततः मेल खाना चाहिए। (राज्य संगति की समस्या में आपका स्वागत है डेटाबेस के बीच! आनंद लें।)

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

Q7:कैशे डेटाबेस का उपयोग कैसे करें

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

नोट: यदि आपने कभी पायथन में शब्दकोशों का उपयोग किया है, तो रेडिस उसी संरचना का अनुसरण करता है। यह एक की-वैल्यू स्टोर है, जहां आप SET . कर सकते हैं और GET पाइथन dict की तरह ही डेटा ।

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

आवश्यक पुस्तकालय स्थापित करने के लिए आप पाइप का उपयोग कर सकते हैं:

$ pip install redis

अब, उपयोगकर्ता का नाम उनकी आईडी से प्राप्त करने के अनुरोध पर विचार करें:

import redis
from datetime import timedelta

# In a real web application, configuration is obtained from settings or utils
r = redis.Redis()

# Assume this is a getter handling a request
def get_name(request, *args, **kwargs):
    id = request.get('id')
    if id in r:
        return r.get(id)  # Assume that we have an {id: name} store
    else:
        # Get data from the main DB here, assume we already did it
        name = 'Bob'
        # Set the value in the cache database, with an expiration time
        r.setex(id, timedelta(minutes=60), value=name)
        return name

यह कोड जांचता है कि नाम रेडिस में है या नहीं id . का उपयोग करके चाबी। यदि नहीं, तो नाम समाप्ति समय के साथ सेट किया जाता है, जिसका उपयोग आप कैश के अल्पकालिक होने के कारण करते हैं।

अब, क्या होगा यदि आपका साक्षात्कारकर्ता आपसे पूछे कि इस कोड में क्या गलत है? आपकी प्रतिक्रिया होनी चाहिए कि कोई अपवाद हैंडलिंग नहीं है! डेटाबेस में कई समस्याएं हो सकती हैं, जैसे गिराए गए कनेक्शन, इसलिए उन अपवादों को आजमाना और पकड़ना हमेशा एक अच्छा विचार है।

डिज़ाइन पैटर्न और ईटीएल अवधारणाओं पर प्रश्न

बड़े अनुप्रयोगों में, आप अक्सर एक से अधिक प्रकार के डेटाबेस का उपयोग करेंगे। वास्तव में, केवल एक एप्लिकेशन के भीतर PostgreSQL, MongoDB और Redis सभी का उपयोग करना संभव है! एक चुनौतीपूर्ण समस्या डेटाबेस के बीच राज्य परिवर्तनों से निपट रही है, जो डेवलपर को स्थिरता के मुद्दों के लिए उजागर करती है। निम्नलिखित परिदृश्य पर विचार करें:

एक मान डेटाबेस #1 में अपडेट किया गया है।
वही मान डेटाबेस #2 में समान रखा गया है (अपडेट नहीं किया गया)।
एक प्रश्न डेटाबेस #2 पर चलाया जाता है।

अब, आपने अपने आप को एक असंगत और पुराना परिणाम प्राप्त कर लिया है! दूसरे डेटाबेस से लौटाए गए परिणाम पहले डेटाबेस में अपडेट किए गए मान को प्रतिबिंबित नहीं करेंगे। यह किसी भी दो डेटाबेस के साथ हो सकता है, लेकिन यह विशेष रूप से तब होता है जब मुख्य डेटाबेस एक NoSQL डेटाबेस होता है, और जानकारी को क्वेरी उद्देश्यों के लिए SQL में बदल दिया जाता है।

ऐसी समस्याओं से निपटने के लिए डेटाबेस में पृष्ठभूमि कार्यकर्ता हो सकते हैं। ये कार्यकर्ता निकालें एक डेटाबेस से डेटा, रूपांतरित करें इसे किसी तरह से, और लोड करें इसे लक्ष्य डेटाबेस में। जब आप किसी NoSQL डेटाबेस से SQL डेटाबेस में कनवर्ट कर रहे होते हैं, तो एक्सट्रेक्ट, ट्रांसफ़ॉर्म, लोड (ETL) प्रक्रिया निम्न चरणों का पालन करती है:

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

वित्तीय, गेमिंग और रिपोर्टिंग अनुप्रयोगों में यह कार्यप्रवाह काफी सामान्य है। इन मामलों में, लगातार बदलते स्कीमा के लिए एक NoSQL डेटाबेस की आवश्यकता होती है, लेकिन रिपोर्टिंग, विश्लेषण और एकत्रीकरण के लिए SQL डेटाबेस की आवश्यकता होती है।

Q8:ETL चुनौतियां

ईटीएल में निम्नलिखित सहित कई चुनौतीपूर्ण अवधारणाएं हैं:

बड़ा डेटा
राजकीय समस्याएं
अतुल्यकालिक कार्यकर्ता
टाइप-मिलान

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

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

नोट: बहु-प्रसंस्करण और श्रमिकों का पृथक्करण अन्य समाधान हैं जिन पर आप विचार कर सकते हैं।

यदि आप बहुत सारे सीपीयू-गहन कार्यों से निपट रहे हैं, तो आप नुंबा को देखना चाहेंगे। यह पुस्तकालय उन्हें निष्पादन में तेजी लाने के लिए कार्यों को संकलित करता है। सबसे अच्छी बात यह है कि इसे पायथन में आसानी से लागू किया जा सकता है, हालांकि इन संकलित कार्यों में किन कार्यों का उपयोग किया जा सकता है, इसकी कुछ सीमाएँ हैं।

Q9:बिग डेटा में डिज़ाइन पैटर्न

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

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

Apache ने शुरुआत में MapReduce पेश किया था, जो मानचित्र, फेरबदल, कम करें . का अनुसरण करता है कार्यप्रवाह। विचार अलग-अलग मशीनों पर अलग-अलग डेटा को मैप करना है, जिसे क्लस्टर भी कहा जाता है। फिर, आप डेटा पर काम कर सकते हैं, एक कुंजी द्वारा समूहीकृत, और अंत में, डेटा को अंतिम चरण में एकत्रित कर सकते हैं।

यह वर्कफ़्लो आज भी उपयोग किया जाता है, लेकिन यह हाल ही में स्पार्क के पक्ष में लुप्त हो रहा है। हालाँकि, डिज़ाइन पैटर्न अधिकांश बड़े डेटा वर्कफ़्लोज़ का आधार बनता है और यह एक अत्यधिक पेचीदा अवधारणा है। आप IBM Analytics पर MapReduce पर अधिक पढ़ सकते हैं।

Q10:ETL प्रक्रिया और बिग डेटा वर्कफ़्लो के सामान्य पहलू

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

दोनों कार्यप्रवाह निर्माता-उपभोक्ता . का अनुसरण करते हैं नमूना। एक कार्यकर्ता (निर्माता) किसी प्रकार का डेटा तैयार करता है और उसे एक पाइपलाइन में आउटपुट करता है। यह पाइपलाइन नेटवर्क संदेश और ट्रिगर सहित कई रूप ले सकती है। निर्माता द्वारा डेटा को आउटपुट करने के बाद, उपभोक्ता उपभोग करता है और उसका उपयोग करता है। ये कार्यकर्ता आम तौर पर अतुल्यकालिक तरीके से काम करते हैं और अलग-अलग प्रक्रियाओं में निष्पादित होते हैं।

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

निष्कर्ष

बधाई हो! आपने बहुत सारी जमीन को कवर किया है और कई डेटा इंजीनियर साक्षात्कार के सवालों के जवाब दिए हैं। अब आप एक डेटा इंजीनियर द्वारा पहनी जा सकने वाली कई अलग-अलग टोपियों के साथ-साथ डेटाबेस, डिज़ाइन और वर्कफ़्लो के संबंध में आपकी ज़िम्मेदारियों के बारे में थोड़ा और समझ गए हैं।

इस ज्ञान से लैस, अब आप यह कर सकते हैं:

एसक्यूएल, नोएसक्यूएल और कैशे डेटाबेस के साथ पायथन का प्रयोग करें
ईटीएल और क्वेरी एप्लिकेशन में पायथन का उपयोग करें
डिज़ाइन और कार्यप्रवाह को ध्यान में रखते हुए परियोजनाओं की समय से पहले योजना बनाएं

जबकि साक्षात्कार के प्रश्न विविध हो सकते हैं, आपको कई विषयों से अवगत कराया गया है और कंप्यूटर विज्ञान के कई अलग-अलग क्षेत्रों में बॉक्स के बाहर सोचना सीखा है। अब आप एक शानदार साक्षात्कार के लिए तैयार हैं!