SEO के लिए सर्वर लॉग फाइल को पार्स और पिवट करने के लिए पायथन का उपयोग कैसे करें

लॉग फ़ाइलों में पाया गया खोज इंजन क्रॉल डेटा किसी भी एसईओ पेशेवर के लिए जानकारी का एक शानदार स्रोत है।

द्वारा लॉग फाइलों का विश्लेषण, आप ठीक से समझ सकते हैं कि कैसे खोज इंजन आपकी वेबसाइट को क्रॉल और व्याख्या कर रहे हैं – तृतीय-पक्ष टूल पर निर्भर होने पर आपको स्पष्टता नहीं मिल सकती है।

यह आपको इसकी अनुमति देगा:

  • खोज इंजन कैसे व्यवहार कर रहे हैं, इसका निर्विवाद प्रमाण प्रदान करके अपने सिद्धांतों को मान्य करें।
  • किसी समस्या के पैमाने और इसे ठीक करने के संभावित प्रभाव को समझने में आपकी सहायता करके अपने निष्कर्षों को प्राथमिकता दें।
  • अन्य डेटा स्रोतों का उपयोग करते समय दिखाई नहीं देने वाली अतिरिक्त समस्याओं का पता लगाएं।

लेकिन अनेक लाभों के बावजूद, लॉग फ़ाइल डेटा का उतनी बार उपयोग नहीं किया जाता जितना कि होना चाहिए। कारण समझ में आते हैं:

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

विज्ञापन

नीचे पढ़ना जारी रखें

ये सभी मुद्दे प्रवेश के लिए पूरी तरह से वैध बाधाएं हैं, लेकिन उनका दुर्गम होना जरूरी नहीं है।

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

आरंभ करने के लिए आपको एक स्क्रिप्ट भी मिलेगी।

प्रारंभिक विचार

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

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

हम पर ध्यान देंगे संयुक्त लॉग प्रारूप इस पोस्ट के लिए, क्योंकि यह Nginx के लिए डिफ़ॉल्ट है और Apache सर्वर पर एक सामान्य पसंद है।

विज्ञापन

नीचे पढ़ना जारी रखें

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

अभी भी कोई समझदार नहीं है? कच्ची फाइलों में से एक को खोलने का प्रयास करें।

अक्सर, विशिष्ट क्षेत्रों की जानकारी के साथ टिप्पणियां प्रदान की जाती हैं, जिन्हें बाद में क्रॉस-रेफरेंस किया जा सकता है।

#Fields: time c-ip cs-method cs-uri-stem sc-status cs-version 
17:42:15 172.16.255.255 GET /default.htm 200 HTTP/1.0

एक और विचार यह है कि हम किन खोज इंजनों को शामिल करना चाहते हैं, क्योंकि इसे हमारे प्रारंभिक फ़िल्टरिंग और सत्यापन में शामिल करने की आवश्यकता होगी।

चीजों को सरल बनाने के लिए, हम Google पर ध्यान केंद्रित करेंगे, इसके प्रभुत्व को देखते हुए 88% अमेरिकी बाजार हिस्सेदारी।

आएँ शुरू करें।

1. फाइलों को पहचानें और प्रारूप निर्धारित करें

सार्थक एसईओ विश्लेषण करने के लिए, हम औसत साइट के लिए न्यूनतम ~100k अनुरोध और 2-4 सप्ताह के मूल्य का डेटा चाहते हैं।

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

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

यह हमें हमारे द्वारा निर्दिष्ट पैटर्न से मेल खाने वाली किसी भी फ़ाइल को वापस करने की अनुमति देता है। उदाहरण के तौर पर, निम्न कोड किसी भी TXT फ़ाइल से मेल खाएगा।

import glob

files = glob.glob('*.txt')

लॉग फ़ाइलें विभिन्न फ़ाइल स्वरूपों में प्रदान की जा सकती हैं, हालांकि, केवल TXT ही नहीं।

वास्तव में, कभी-कभी फ़ाइल एक्सटेंशन वह नहीं हो सकता है जिसे आप पहचानते हैं। यहाँ अकामाई की लॉग डिलीवरी सेवा से एक कच्ची लॉग फ़ाइल है, जो इसे पूरी तरह से दर्शाती है:

bot_log_100011.esw3c_waf_S.202160250000-2000-41

इसके अतिरिक्त, यह संभव है कि प्राप्त फ़ाइलें एकाधिक सबफ़ोल्डर में विभाजित हों, और हम इन्हें एक ही स्थान में कॉपी करने में समय बर्बाद नहीं करना चाहते हैं।

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

विज्ञापन

नीचे पढ़ना जारी रखें

files = glob.glob('**/*.*', recursive=True)

इसके बाद, हम यह पहचानना चाहते हैं कि हमारी सूची में किस प्रकार की फाइलें हैं। ऐसा करने के लिए, माइम प्रकार विशिष्ट फ़ाइल का पता लगाया जा सकता है। यह हमें बताएगा कि हम किस प्रकार की फ़ाइल के साथ काम कर रहे हैं, एक्सटेंशन की परवाह किए बिना।

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

pip install python-magic
pip install libmagic
import magic

def file_type(file_path):
    mime = magic.from_file(file_path, mime=True)
    return mime

सूची समझ फिर हमारी फाइलों के माध्यम से लूप करने और फ़ंक्शन को लागू करने के लिए उपयोग किया जा सकता है, जिससे नाम और प्रकार दोनों को स्टोर करने के लिए एक शब्दकोश बनाया जा सकता है।

file_types = [file_type(file) for file in files]

file_dict = dict(zip(files, file_types))

अंत में, एक फ़ंक्शन और a घुमाव के दौरान उन फ़ाइलों की सूची निकालने के लिए जो एक MIME प्रकार का पाठ/सादा लौटाती हैं और कुछ भी बाहर नहीं करती हैं।

uncompressed = []

def file_identifier(file):
    for key, value in file_dict.items():
        if file in value:
            uncompressed.append(key)

while file_identifier('text/plain'):
    file_identifier('text/plain') in file_dict

फ़ाइल पहचान।

2. खोज इंजन अनुरोध निकालें

हमारे फ़ोल्डर (फ़ोल्डर) में फ़ाइलों को फ़िल्टर करने के बाद, अगला चरण केवल उन अनुरोधों को निकालकर फ़ाइलों को फ़िल्टर करना है जिनकी हम परवाह करते हैं।

विज्ञापन

नीचे पढ़ना जारी रखें

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

इस उदाहरण में, चूंकि हम केवल Googlebot अनुरोध चाहते हैं, इसलिए ‘Googlebot’ की खोज सभी से मेल खाएगी प्रासंगिक उपयोगकर्ता एजेंट.

हम अपनी फ़ाइल को पढ़ने और लिखने के लिए पायथन के ओपन फ़ंक्शन का उपयोग कर सकते हैं और खोज करने के लिए पायथन के रेगेक्स मॉड्यूल, आरई का उपयोग कर सकते हैं।

import re

pattern = 'Googlebot'
new_file = open('./googlebot.txt', 'w', encoding='utf8')

for txt_files in uncompressed:
    with open(txt_files, 'r', encoding='utf8') as text_file:
        for line in text_file:
            if re.search(pattern, line):
                new_file.write(line)

रेगेक्स OR ऑपरेटर का उपयोग करके इसे आसानी से मापनीय बनाता है।

pattern = 'Googlebot|bingbot'

3. पार्स अनुरोध

में पिछला पद, हेमलेट बतिस्ता ने अनुरोधों को पार्स करने के लिए रेगेक्स का उपयोग करने के बारे में मार्गदर्शन प्रदान किया।

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

  1. अनावश्यक कॉलम ड्रॉप करें।
  2. टाइमस्टैम्प को प्रारूपित करें।
  3. पूरे यूआरएल के साथ एक कॉलम बनाएं।
  4. शेष कॉलम का नाम बदलें और पुन: व्यवस्थित करें।

डोमेन नाम को हार्डकोड करने के बजाय, इनपुट फ़ंक्शन का उपयोग उपयोगकर्ता को संकेत देने और इसे एक चर के रूप में सहेजने के लिए किया जा सकता है।

विज्ञापन

नीचे पढ़ना जारी रखें

whole_url = input('Please enter full domain with protocol: ') # get domain from user input

df = pd.read_csv('./googlebot.txt', sep='s+', error_bad_lines=False, header=None, low_memory=False) # import logs

df.drop([1, 2, 4], axis=1, inplace=True) # drop unwanted columns/characters

df[3] = df[3].str.replace('[', '') # split time stamp into two
df[['Date', 'Time']] = df[3].str.split(':', 1, expand=True)

df[['Request Type', 'URI', 'Protocol']] = df[5].str.split(' ', 2, expand=True) # split uri request into columns
df.drop([3, 5], axis=1, inplace=True)

df.rename(columns = {0:'IP', 6:'Status Code', 7:'Bytes', 8:'Referrer URL', 9:'User Agent'}, inplace=True) #rename columns

df['Full URL'] = whole_url + df['URI'] # concatenate domain name

df['Date'] = pd.to_datetime(df['Date']) # declare data types
df[['Status Code', 'Bytes']] = df[['Status Code', 'Bytes']].apply(pd.to_numeric)

df = df[['Date', 'Time', 'Request Type', 'Full URL', 'URI', 'Status Code', 'Protocol', 'Referrer URL', 'Bytes', 'User Agent', 'IP']] # reorder columns

पार्स किए गए डेटाफ़्रेम।

4. मान्य अनुरोध

खोज इंजन उपयोगकर्ता एजेंटों को धोखा देना अविश्वसनीय रूप से आसान है, जिससे अनुरोध सत्यापन प्रक्रिया का एक महत्वपूर्ण हिस्सा बन जाता है, ऐसा न हो कि हम अपने स्वयं के तृतीय-पक्ष क्रॉल का विश्लेषण करके गलत निष्कर्ष निकाल सकें।

ऐसा करने के लिए, हम एक पुस्तकालय स्थापित करने जा रहे हैं जिसे कहा जाता है डीएनएसपीथन और एक रिवर्स DNS करें।

पंडों का उपयोग डुप्लिकेट आईपी को छोड़ने और परिणामों को फिर से लागू करने और किसी भी अमान्य अनुरोध को फ़िल्टर करने से पहले इस छोटे डेटाफ़्रेम पर लुकअप चलाने के लिए किया जा सकता है।

विज्ञापन

नीचे पढ़ना जारी रखें

from dns import resolver, reversename
def reverseDns(ip):
    try:
        return str(resolver.query(reversename.from_address(ip), 'PTR')[0])
    except:
        return 'N/A'

logs_filtered = df.drop_duplicates(['IP']).copy() # create DF with dupliate ips filtered for check

logs_filtered['DNS'] = logs_filtered['IP'].apply(reverseDns)  # create DNS column with the reverse IP DNS result

logs_filtered = df.merge(logs_filtered[['IP', 'DNS']], how='left', on=['IP'])  # merge DNS column to full logs matching IP

logs_filtered = logs_filtered[logs_filtered['DNS'].str.contains('googlebot.com')]  # filter to verified Googlebot

logs_filtered.drop(['IP', 'DNS'], axis=1, inplace=True)  # drop dns/ip columns

इस दृष्टिकोण को अपनाने से मिनटों में लाखों अनुरोधों को मान्य करते हुए लुकअप में तेजी आएगी।

नीचे दिए गए उदाहरण में, अनुरोधों की ~4 मिलियन पंक्तियों को 26 सेकंड में संसाधित किया गया था।
लॉग सत्यापन कमांड लाइन।

5. डेटा को पिवट करें

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

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

विज्ञापन

नीचे पढ़ना जारी रखें

status_code = logs_filtered.groupby('Status Code').agg('size')

एक्सेल में आपके द्वारा उपयोग की जाने वाली गिनती के प्रकार को दोहराने के लिए, यह ध्यान देने योग्य है कि हमें ‘आकार’ का एक समग्र कार्य निर्दिष्ट करने की आवश्यकता है, न कि ‘गिनती’।

गिनती का उपयोग करने से फ़ंक्शन चालू हो जाएगा सब DataFrame के भीतर कॉलम, और अशक्त मान अलग-अलग तरीके से हैंडल किए जाते हैं।

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

status_code = logs_filtered.groupby('Status Code').agg('size').sort_values(ascending=False).reset_index()

status_code.rename(columns={0:'# Requests'}, inplace=True)

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

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

विज्ञापन

नीचे पढ़ना जारी रखें

pd.pivot_table(logs_filtered, index['Full URL'])

अधिक विशिष्टता के लिए, आवश्यक मूल्यों को घोषित किया जा सकता है और एकत्रीकरण – योग, माध्य, आदि – aggfunc पैरामीटर का उपयोग करके लागू किया जाता है।

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

status_code_url = pd.pivot_table(logs_filtered, index=['Full URL'], columns=['Status Code'], aggfunc="size", fill_value=0)

स्थिति कोड url पिवट।
यहां थोड़ा अधिक जटिल उदाहरण दिया गया है, जो केवल अनुरोधों की संख्या की गणना के बजाय प्रति उपयोगकर्ता एजेंट प्रति दिन क्रॉल किए जाने वाले अद्वितीय URL की संख्या प्रदान करता है।

user_agent_url = pd.pivot_table(logs_filtered, index=['User Agent'], values=['Full URL'], columns=['Date'], aggfunc=pd.Series.nunique, fill_value=0)

यदि आप अभी भी वाक्य रचना के साथ संघर्ष कर रहे हैं, तो देखें मितो. यह आपको JupyterLab का उपयोग करते समय Jupyter के भीतर एक दृश्य इंटरफ़ेस के साथ बातचीत करने की अनुमति देता है, लेकिन फिर भी प्रासंगिक कोड को आउटपुट करता है।

विज्ञापन

नीचे पढ़ना जारी रखें

शामिल रेंज

बाइट्स जैसे डेटा बिंदुओं के लिए जिनके कई अलग-अलग संख्यात्मक मान होने की संभावना है, डेटा को बकेट करना समझ में आता है।

ऐसा करने के लिए, हम अपने अंतराल को एक सूची में परिभाषित कर सकते हैं और फिर इसका उपयोग कर सकते हैं कट गया घोषित अधिकतम मूल्य से ऊपर कुछ भी पकड़ने के लिए np.inf निर्दिष्ट करते हुए, मानों को डिब्बे में क्रमबद्ध करने के लिए कार्य करें।

byte_range = [0, 50000, 100000, 200000, 500000, 1000000, np.inf]

bytes_grouped_ranges = (logs_filtered.groupby(pd.cut(logs_filtered['Bytes'], bins=byte_range, precision=0))
    .agg('size')
    .reset_index()
)

bytes_grouped_ranges.rename(columns={0: '# Requests'}, inplace=True)

सटीक श्रेणियों को परिभाषित करने के लिए आउटपुट के भीतर अंतराल संकेतन का उपयोग किया जाता है, उदाहरण के लिए

(५०००० १०००००)

गोल कोष्ठक इंगित करते हैं कि कोई संख्या कब है नहीं शामिल है और एक वर्ग ब्रैकेट जब इसे शामिल किया जाता है। तो, उपरोक्त उदाहरण में, बाल्टी में ५०,००१ और १००,००० के बीच के मान वाले डेटा बिंदु होते हैं।

6. निर्यात

हमारी प्रक्रिया का अंतिम चरण हमारे लॉग डेटा और पिवोट्स को निर्यात करना है।

विश्लेषण में आसानी के लिए, इसे CSV के बजाय किसी Excel फ़ाइल (XLSX) में निर्यात करना समझ में आता है। XLSX फाइलें कई शीट का समर्थन करती हैं, जिसका अर्थ है कि सभी डेटाफ्रेम को एक ही फाइल में जोड़ा जा सकता है।

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

विज्ञापन

नीचे पढ़ना जारी रखें

writer = pd.ExcelWriter('logs_export.xlsx', engine="xlsxwriter", datetime_format="dd/mm/yyyy", options={'strings_to_urls': False})

logs_filtered.to_excel(writer, sheet_name="Master", index=False)
pivot1.to_excel(writer, sheet_name="My pivot")

writer.save()

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

sheet_names = {
    'Request Status Codes Per Day': status_code_date,
    'URL Status Codes': status_code_url,
    'User Agent Requests Per Day': user_agent_date,
    'User Agent Requests Unique URLs': user_agent_url,
    }

for sheet, name in sheet_names.items():
    name.to_excel(writer, sheet_name=sheet)

एक अंतिम जटिलता यह है कि एक्सेल की पंक्ति सीमा 1,048,576 है। हम हर अनुरोध को निर्यात कर रहे हैं, इसलिए बड़े नमूनों के साथ काम करते समय यह समस्या पैदा कर सकता है।

चूंकि सीएसवी फाइलों की कोई सीमा नहीं है, इसलिए अगर एक सीएसवी निर्यात में फ़ॉलबैक के रूप में जोड़ने के लिए एक कथन का उपयोग किया जा सकता है।

यदि लॉग फ़ाइल DataFrame की लंबाई 1,048,576 से अधिक है, तो इसके बजाय इसे CSV के रूप में निर्यात किया जाएगा, जिससे स्क्रिप्ट को विफल होने से रोका जा सकेगा, जबकि पिवोट्स को एकवचन निर्यात में संयोजित किया जा सकेगा।

if len(logs_filtered) <= 1048576:
    logs_filtered.to_excel(writer, sheet_name="Master", index=False)
else:
    logs_filtered.to_csv('./logs_export.csv', index=False)

अंतिम विचार

लॉग फ़ाइल डेटा से प्राप्त की जा सकने वाली अतिरिक्त अंतर्दृष्टि कुछ समय के लिए निवेश करने योग्य हैं।

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

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

विज्ञापन

नीचे पढ़ना जारी रखें

पूरी स्क्रिप्ट मैंने बनाया है यहां जीथब पर पाया जा सकता है।

इसमें अतिरिक्त अतिरिक्त शामिल हैं जैसे जीएससी एपीआई एकीकरण, अधिक पिवोट्स, और दो और लॉग प्रारूपों के लिए समर्थन: अमेज़ॅन ईएलबी और डब्ल्यू 3 सी (आईआईएस द्वारा उपयोग किया जाता है)।
लॉग पार्सर एनिमेशन
दूसरे प्रारूप में जोड़ने के लिए, लाइन 17 पर log_fomats सूची में नाम शामिल करें और लाइन 193 पर एक अतिरिक्त elif विवरण जोड़ें (या मौजूदा में से किसी एक को संपादित करें)।

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

विज्ञापन

नीचे पढ़ना जारी रखें

और अधिक संसाधनों:


छवि क्रेडिट

लेखक द्वारा लिए गए सभी स्क्रीनशॉट, जुलाई 2021

Related Posts

Leave a Reply

Your email address will not be published. Required fields are marked *