परीक्षक के लिए पायथन: छोटे सी पांडा स्क्रिप्ट्स बड़े डेटासेट का परीक्षण करने में कैसे मदद करती हैं

1. हमें एक निश्चित प्रारूप (या कई फ़ाइलों) में डेटा के साथ एक फ़ाइल मिलती है
2. फ़ाइल / फ़ाइलों से डेटा प्राप्त करें
3. हम आवश्यक डेटा का चयन करते हैं
4. हम डेटा पर कुछ ऑपरेशन करते हैं
5. यदि आवश्यक हो तो हम डेटा को एक्सेल फाइल में अपलोड करते हैं (आमतौर पर यह प्रारूप आगे के विश्लेषण और भंडारण के लिए सबसे सुविधाजनक है)

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

#   pandas
import pandas as pd

#    csv-  -
# (        )
#       csv-     ";"
df = pd.read_csv('./csv_file.csv', sep=';', encoding='utf-8')

# 
#    json-  -
# (        )
# df = pd.read_json('./json_file.json', encoding='utf-8')

# 
#    Excel-  -,     
# (        )
# file_excel = 'Excel_file.xlsx'
# df = pd.ExcelFile(file_excel).parse('1')


#  -     -  
#    - final_df


#    Excel-,  
#          
# (      )
writer = pd.ExcelWriter('.xlsx')
final_df.to_excel(writer, '1')
writer.save()

#   pandas
import pandas as pd
#      ,     PostgreSQL
# (   -    )
import psycopg2

#    
conn = psycopg2.connect(dbname='_', host='', port='',
                        user='', password='')

#   SQL-
q = """select ... 
    from ... 
    where ..."""

#    -,  SQL-
df = pd.read_sql_query(q, conn)


#  -     -  
#    - final_df


#    Excel-,  
#          
# (      )
writer = pd.ExcelWriter('.xlsx')
final_df.to_excel(writer, '1')
writer.save()

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

• - csv-, - ( union SQL), id, reg_date.
• UI Excel-, , -.
• (merge) - ( outer join SQL) Excel- .
• , , - , , UI.

#   pandas
import pandas as pd

#     csv-    -
# (        )
df_from_file1 = pd.read_csv('./example1_csv_1.csv', sep=';', encoding='utf-8',
                            usecols=['id', 'name', 'email', 'reg_date'])
df_from_file2 = pd.read_csv('./example1_csv_2.csv', sep=';', encoding='utf-8',
                            usecols=['id', 'name', 'email','reg_date'])
df_from_file3 = pd.read_csv('./example1_csv_3.csv', sep=';', encoding='utf-8',
                            usecols=['id', 'name', 'email', 'reg_date'])

#    -    - 
# (   union  SQL)
df_from_csv = pd.concat([df_from_file1, df_from_file2, df_from_file3]).\
    reset_index(drop=True)
print(df_from_csv)

#       
df_from_csv.drop_duplicates(subset='id', keep='first', inplace=True)
print(df_from_csv)

#     NaN ( )   reg_date
df_from_csv = df_from_csv.dropna()
print(df_from_csv)

#    Excel-   UI  -,
#       
# (        )
file_excel = 'report_UI.xlsx'
df_from_excel = pd.ExcelFile(file_excel).parse('1')
print(df_from_excel)

#  -     - 
# -       UI
# (   outer join  SQL)
df = df_from_csv.merge(df_from_excel, left_on='id', right_on="", how='outer')
print(df)

#     Excel-
writer = pd.ExcelWriter('.xlsx')
df.to_excel(writer, '1')
writer.save()

• ( , 30 000 ).
• ( Excel) / , .

• हम यूआई पर विभाजन तालिका से एक्सेल फ़ाइल में डेटा अपलोड करते हैं (यदि यह संभव नहीं है, तो आप हमेशा यूआई पर इस तालिका में डेटा को आउटपुट करने के लिए कोड में उपयोग किए गए SQL क्वेरी के परिणाम से डेटा निर्यात कर सकते हैं) और डेटा को पहले डेटा फ़्रेम में भर सकते हैं। ।
• हमें दूसरे स्रोत से डेटा के साथ json फाइल मिलती है और इसे दूसरे डेटा फ्रेम में लोड किया जाता है।
• (merge — outer join SQL) - - Excel-, . , , .

• ( , 30 000 ).
• json- / – /, - json- pandas /.

• हम डेटाबेस में SQL क्वेरी निष्पादित, एक csv फ़ाइल के लिए क्वेरी परिणाम से डेटा निर्यात, पहले डेटा फ्रेम में इस डेटा लोड।
• हम डेटा को प्रतिक्रिया से बचाने के लिए json फ़ाइल में API से अनुरोध करते हैं, फ़ाइल से डेटा को दूसरे डेटा फ़्रेम में लोड करते हैं।
• हम डेटा को मिलाते हैं (विलय - SQL में बाहरी जुड़ाव के साथ समानता) एक विशिष्ट पहचानकर्ता द्वारा दो नए डेटा फ़्रेम में डेटा फ़्रेम प्राप्त करते हैं और इससे डेटा को Excel फ़ाइल में अनलोड करते हैं, जिसमें हम पहले से ही स्तंभों के कार्यों का उपयोग करके स्तंभों द्वारा डेटा की तुलना करेंगे एक्सेल
• या सामान्य डेटा फ्रेम में कॉलम पर डेटा की तुलना पंडों के उपयोग से की जा सकती है, जबकि कॉलम में समान / अलग डेटा वाली पंक्तियों को विश्लेषण के लिए एक नए डेटा फ़्रेम / एक्सेल फ़ाइल में लोड किया जा सकता है।

[
    {
        "id": "16421118-4116",
        "name_json": "Tempor Consulting",
        "email_json": "Nullam.lobortis.quam@***",
        "tel_json": "1-821-805-****",
        "reg_date_json": "12-11-16",
        "city_json": "Natales"
    },
    {
        "id": "16040210-2206",
        "name_json": "Odio Etiam Incorporated",
        "email_json": "arcu@***",
        "tel_json": "1-730-291-****",
        "reg_date_json": "26-06-05",
        "city_json": "Viddalba"
    },
...
]

#   pandas
import pandas as pd

#    csv-  -
# (        )
#       csv-     ";"
df_from_csv = pd.read_csv('./example3_csv.csv', sep=';', encoding='utf-8')
print(df_from_csv)

#    json-  -
# (        )
df_from_json = pd.read_json('./example3_json.json', encoding='utf-8')
print(df_from_json)

#  -    -
# (   outer join  SQL)
df_csv_json = df_from_csv.merge(df_from_json, left_on='id', 
                                right_on="id", how='outer')
print(df_csv_json)

#    Excel-,   ,
#      -   ,
#          
# (      )
# writer = pd.ExcelWriter('.xlsx')
# df_csv_json.to_excel(writer, '1')
# writer.save()

#       
# (, name_csv  name_json) 
#       Excel-  
# (        )
unequal_data_df = df_csv_json.loc[df_csv_json['name_csv'] != 
                                  df_csv_json['name_json']]
unequal_data_df = unequal_data_df[['id', 'name_csv', 'name_json']]
print(unequal_data_df)

writer = pd.ExcelWriter('_name.xlsx')
unequal_data_df.to_excel(writer, '1')
writer.save()

• जब बहुत बड़ी संख्या में लाइनों के साथ फ़ाइलों के साथ काम करते हैं, तो आपको उन्हें अलग-अलग फ़ाइलों में तोड़ना होगा (यहां आपको कोशिश करने की आवश्यकता है, मेरे पास शायद ही कभी 30,000 से अधिक लाइनें हैं)।
• यदि json फ़ाइल में ऑब्जेक्ट्स / डेटा सरणियों के घोंसले के शिकार के कई स्तर हैं, तो आंतरिक स्तर से उन्हें एक ऑब्जेक्ट / सरणी के रूप में सेल में लोड किया जाएगा, इसलिए पंडों के साथ json फ़ाइलों के साथ काम करना ऑब्जेक्ट्स की अत्यधिक नेस्टिंग के बिना डेटा के लिए सुविधाजनक है / सरणियाँ।
• API SQL- , SQL- .

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

#   ElementTree
from xml.etree import ElementTree
#   pandas
import pandas as pd

#    xml-   
# (        )
tree = ElementTree.parse("example4_xml.xml")

#   
root = tree.getroot()

#  ,     
data_list = []
i = 1

#    -   id_type1  id_type2
for child in root.iter("companies"):
    for child_1 in child.iter("company"):
            data_list.append({"": i, "id": child_1.get("id_type1")
                                                or child_1.get("id_type2"), 
                              "  xml": ""})
            i += 1

#     data_list  -
df_from_xml = pd.DataFrame.from_dict(data_list, orient='columns')
print(df_from_xml)

#    csv-  -
df_from_csv = pd.read_csv('./example4_csv.csv', sep=';', encoding='utf-8')
print(df_from_csv)

#  -   -
# (   outer join  SQL)
df = df_from_csv.merge(df_from_xml, left_on='id', right_on="id", how='outer')
print(df)

#    Excel-
#          
# (      )
writer = pd.ExcelWriter('.xlsx')
df.to_excel(writer, '1')
writer.save()

• हम डेटाबेस में SQL क्वेरी के लिए डेवलपर्स से उस कोड से पूछते हैं जो UI पर विभाजन तालिका में डेटा आउटपुट के लिए जिम्मेदार है।
• हम डेटाबेस में इस एसक्यूएल-क्वेरी को निष्पादित करते हैं, डेटा को सीएसवी फ़ाइल पर अपलोड करते हैं, इससे डेटा को पहले डेटा फ्रेम में लोड करते हैं।
• हम यूआई पर एक्सेल फाइल करने के लिए विभाजन तालिका का डेटा अपलोड और दूसरे डेटा फ्रेम में से डेटा लोड।
• (merge — outer join SQL) - - Excel-, Excel.
• - pandas, / -/Excel- .

• , Excel- UI, , , .