కోడ్ జనరేషన్: పైథాన్ (పాండాలు) మరియు SQLతో AI-సహాయక విశ్లేషణ

లాభాలు:

• ఆర్టిఫిషియల్ ఇంటెలిజెన్స్‌కు స్పష్టమైన స్కీమా మరియు ఉద్దేశ్యాన్ని అందించడం ద్వారా బలమైన SQL మరియు పాండాస్ కోడ్‌ని తీసుకొని, లైన్ వారీగా చదివి ధృవీకరించగల సామర్థ్యం
• అడ్డు వరుసల సంఖ్య, ఫిట్టింగ్ ఫంక్షన్ మరియు విలీనం/JOIN తర్వాత నిర్గమాంశ వంటి నిశ్శబ్ద లోపాలను క్యాచ్ చేయగల సామర్థ్యం
• డీబగ్‌లో సమస్యను నిశ్శబ్దం చేయకుండా పరిష్కరించగల సామర్థ్యం మరియు ఉత్పత్తి వాతావరణంలో పరీక్షించకుండా కోడ్‌ను అమలు చేయకుండా నిరోధించడం

డేటా సైన్స్‌లో రెండు ప్రాథమిక భాషలు ఉన్నాయి: SQL (స్ట్రక్చర్డ్ క్వెరీ లాంగ్వేజ్ — డేటాబేస్‌ల నుండి డేటాను ప్రశ్నించే భాష) మరియు పైథాన్ (ప్రత్యేకంగా, పాండాస్ లైబ్రరీ — టేబుల్‌లను ప్రోగ్రామిక్‌గా మార్చడానికి ప్రామాణిక సాధనం). ఈ యూనిట్‌లో, మేము AIని కోడ్ పార్టనర్‌గా ఉపయోగించడం నేర్చుకుంటాము: దాని నుండి సాలిడ్ SQL మరియు పాండాస్ కోడ్‌ని సరైన ప్రశ్నలతో పొందడం, ఆ కోడ్‌ని చదవడం మరియు ధృవీకరించడం, డీబగ్ చేయడం మరియు ఎప్పుడూ గుడ్డిగా రన్ చేయడం నేర్చుకుంటాము. AI నిమిషాలకు బదులుగా సెకన్లలో పునరావృతమయ్యే కోడ్‌ను వ్రాస్తుంది; కానీ అది ఉత్పత్తి చేసే కోడ్ సరైన లాజిక్‌తో సరైన నిలువు వరుసను ప్రాసెస్ చేస్తుందని నిర్ధారించుకోవడం మీ పని. వర్కింగ్ కోడ్ అంటే సరైన కోడ్ కాదు.

AIతో కోడ్‌ని ఉత్పత్తి చేయడం ఎందుకు శక్తివంతమైనది కానీ ప్రమాదకరం

AI కోడ్ ఉత్పత్తిలో మూడు పెద్ద ప్రయోజనాలను అందిస్తుంది: వేగం (సెకన్లలో 30-లైన్ గ్రూప్-బై-పివోట్ ఆపరేషన్‌ను వ్రాస్తుంది), రిమైండర్ (మీరు మర్చిపోయిన పాండాస్ ఫంక్షన్‌ను మీకు గుర్తు చేస్తుంది) మరియు టీచింగ్ (కోడ్ లైన్‌ను లైన్ ద్వారా వివరిస్తుంది). కానీ ఇది మూడు ప్రమాదాలను కలిగి ఉంటుంది: నిశ్శబ్ద లాజిక్ ఎర్రర్ (తప్పు కాలమ్‌ని తప్పులు లేకుండా అమలు చేసే కోడ్), అమర్చిన ఫంక్షన్ (ఉనికిలో లేని పద్ధతిని సూచిస్తుంది) మరియు ఈల్డ్ ట్రాప్ (చిన్న డేటాపై పనిచేసే కోడ్ 10 మిలియన్ వరుసల వద్ద క్రాష్ అవుతుంది). కాబట్టి గోల్డెన్ రూల్: AI కోడ్‌ను మీరే వ్రాసినట్లుగా చదవండి. మీకు అర్థం కాని లైన్‌ను నడపవద్దు.

SQL: మూలం వద్ద డేటాను ప్రాసెస్ చేయండి

SQL డేటాబేస్ నుండి డేటాను తిరిగి పొందేందుకు మరియు అక్కడ ప్రాసెస్ చేయడానికి మిమ్మల్ని అనుమతిస్తుంది; మీరు వాటిని పైథాన్‌లోకి లాగకుండా మిలియన్ల కొద్దీ లైన్‌లను సంగ్రహించవచ్చు. ప్రాథమిక బిల్డింగ్ బ్లాక్‌లు: ఎంచుకోండి (ఏ నిలువు వరుసలు), ఎక్కడ (ఏ వరుసలు), గ్రూప్ వారీగా (సమూహం మరియు సారాంశం), చేరండి (పట్టికలలో చేరండి), HAVING (పోస్ట్-గ్రూప్ ఫిల్టర్). సంక్లిష్టమైన JOINలు మరియు విండో ఫంక్షన్‌లను వ్రాయడంలో AI చాలా సహాయకారిగా ఉంటుంది, అయితే రెండు విషయాలను తప్పకుండా తనిఖీ చేయండి: JOIN అనేది సరైన కీ (తప్పు కీ నకిలీ వరుసలు) మరియు ఫిల్టర్ లాజిక్ సరైనదా (ముఖ్యంగా NULL ప్రవర్తన మరియు తేదీ పరిధులు).

హెచ్చరిక: ఉత్పత్తి డేటాబేస్కు వ్యతిరేకంగా AI- రూపొందించిన SQL ప్రశ్నను నేరుగా అమలు చేయవద్దు. ముందుగా చిన్న కాపీ లేదా పరిమితితో పరీక్షించండి. WHERE షరతును ధృవీకరించకుండా UPDATE/DELETE ప్రశ్నను ఎప్పుడూ అమలు చేయవద్దు; తప్పు ఎక్కడ ఉంటే మొత్తం పట్టికను తొలగించవచ్చు.

పైథాన్/పాండాలు: అనువైన విశ్లేషణ

పాండాలు పైథాన్‌లో పట్టికలను (డేటాఫ్రేమ్) మార్చేందుకు ప్రామాణిక మార్గం. AI యొక్క అత్యంత సమర్థవంతమైన ఉపయోగం దానికి స్పష్టమైన పథకం మరియు ప్రయోజనాన్ని అందించడం. సాధారణంగా ఉపయోగించే ఆపరేషన్‌లు: ఫిల్టర్, గ్రూప్‌బై, మెర్జ్, పివోట్_టేబుల్, వర్తిస్తాయి. AI వీటిని త్వరగా వ్రాస్తుంది; మీరు తనిఖీ చేయదలిచినది లాజిక్: సరైన కాలమ్‌లో గ్రూపింగ్ అనేది, ఊహించని విధంగా అడ్డు వరుసల సంఖ్యను విలీనం చేసిందా (విలీనం తర్వాత వరుసల సంఖ్యను ఎల్లప్పుడూ తనిఖీ చేయండి), అసలైనదాన్ని మార్చే గొలుసు కార్యకలాపాలు.

లావాదేవీ

SQL

పాండాలు

తనిఖీ కేంద్రం

వడపోత

ఎక్కడ

df[df.x > 5]

NULL/NaN ప్రవర్తన

సమూహం చేయడం

సమూహం ద్వారా

df.groupby()

ఇది సరైన కాలమ్నా?

విలీనం

చేరండి

df.merge()

వరుస గణన మార్పు

సారాంశం

AVG(), SUM()

.సగటు(), .మొత్తం()

ఏ కాలమ్ సేకరించబడింది

క్రమబద్ధీకరించు

ద్వారా ఆర్డర్

.sort_values()

దిశ (ఆరోహణ/అవరోహణ)

నకిలీ

విభిన్నమైనది

.drop_duplicates()

ఏ నిలువు వరుసలలో?

డీబగ్గింగ్: AIతో

కోడ్ విఫలమైనప్పుడు, AI ఒక అద్భుతమైన డీబగ్గింగ్ భాగస్వామి. దానికి పూర్తి ఎర్రర్ మెసేజ్ మరియు సంబంధిత కోడ్ స్నిప్పెట్ ఇవ్వండి. కానీ రెండు ఉచ్చులు జాగ్రత్త. మొదట, AI లోపాన్ని "నిశ్శబ్ధం" చేసే పరిష్కారాన్ని సూచించవచ్చు (ఉదా., హెచ్చరికలను దాచడం) - ఇది లోపాన్ని పరిష్కరించదు, అది దాచిపెడుతుంది. రెండవది, సమస్యను "పరిష్కరిస్తున్నప్పుడు" AI కొన్నిసార్లు నిశ్శబ్దంగా మరొక ప్రవర్తనను మారుస్తుంది. నియమం: పరిష్కారాన్ని అర్థం చేసుకోండి, మ్యూట్ చేయకుండా పరిష్కరించండి మరియు పరిష్కరించిన తర్వాత కూడా అవుట్‌పుట్ సరైనదని ధృవీకరించండి.

అర్థమయ్యేలా మరియు నిర్వహించదగిన కోడ్ కావాలి

AI నుండి కోడ్‌ను కొనుగోలు చేస్తున్నప్పుడు, "పనిచేస్తుంది" అనే కోడ్ మాత్రమే కాకుండా చదవగలిగే మరియు నిర్వహించదగిన కోడ్ కోసం అడగండి. మీరు లేదా సహోద్యోగి నెలల తర్వాత ఆ కోడ్‌ని తెరిచినప్పుడు, అది ఏమి చేస్తుందో అర్థం చేసుకోగలదు. దీన్ని చేయడానికి, AI మూడు అంశాలను చేర్చడాన్ని అలవాటు చేసుకోండి: అర్థవంతమైన వేరియబుల్ పేర్లు (orders_temiz, df2 కాదు), క్లిష్టమైన దశల్లో చిన్న వ్యాఖ్య లైన్‌లు (ఎందుకు చేస్తున్నారో వివరిస్తూ) మరియు మ్యాజిక్ నంబర్‌కు బదులుగా పేరు పెట్టబడిన స్థిరాంకం (0.85 కోడ్‌కు బదులుగా ACCEPT_ESIGI = 0.85). పొడవైన సింగిల్-లైన్ గొలుసులను కూడా నివారించండి (ఒక లైన్‌లో ఐదు చర్యలను కనెక్ట్ చేయడం); ఇవి డీబగ్గింగ్ కష్టతరం చేస్తాయి. డిఫాల్ట్‌గా, AI తరచుగా సంక్షిప్త మరియు “స్మార్ట్” కోడ్‌ని ఉత్పత్తి చేస్తుంది; మీరు "రీడబుల్, ఇంటర్‌ప్రెటబుల్, మెయింటెనబుల్" అని స్పష్టంగా చెబితే, మీరు మరింత మెయింటెనబుల్ అవుట్‌పుట్ పొందుతారు. ఇది పునరుత్పత్తికి కూడా ఆధారం (యూనిట్ 10): అర్థం చేసుకోని కోడ్ సురక్షితంగా మళ్లీ అమలు చేయలేని కోడ్.

మూడు చిన్న కేసులు

కేసు 1 — ప్రతిరూపణలో చేరండి. ఒక విశ్లేషకుడు ఆర్డర్‌లను ఉత్పత్తి పట్టికతో కలిపి మొత్తం టర్నోవర్ 3 రెట్లు ఎక్కువగా ఉన్నట్లు కనుగొన్నారు. కారణం: ప్రతి ఉత్పత్తికి ఉత్పత్తి పట్టికలో బహుళ వరుసలు (వివిధ రంగులు) ఉన్నాయి; JOIN ప్రతి ఆర్డర్ డూప్లికేట్ చేయబడింది. AI యొక్క కోడ్ "పనిచేస్తోంది", కానీ లైన్ల సంఖ్య 240 వేల నుండి 690 వేలకు పెరిగింది. పాఠం: విలీనం/JOIN తర్వాత లైన్ల సంఖ్యను ఎల్లప్పుడూ తనిఖీ చేయండి.

కేస్ 2 - ఫిట్టింగ్ ఫంక్షన్. అతను ఇంటర్న్‌కి AI df.groupby('x').summarize()ని సూచించాడు; పాండాలలో అలాంటి పద్ధతి లేదు (.agg() ఉంది). కోడ్ పని చేయలేదు, ఇంటర్న్ 20 నిమిషాల పాటు పోయింది. పాఠం: పత్రం నుండి మీరు గుర్తించని ఫంక్షన్‌ని ధృవీకరించండి; AI పద్ధతులను రూపొందించగలదు.

కేస్ 3 - దిగుబడి పతనం. ప్రతి అడ్డు వరుసకు వర్తించే డేటాబేస్‌ను ఒక కోడ్ ప్రశ్నిస్తోంది; ఇది 5,000 లైన్లలో నడిచింది, 4 మిలియన్ లైన్లలో 9 గంటలు పట్టింది మరియు ఆగిపోయింది. AI వెక్టరైజ్డ్ (బ్యాచ్) పరిష్కారాన్ని సూచించినప్పుడు, సమయం 40 సెకన్లకు తగ్గించబడింది. పాఠం: చిన్న డేటాపై పనిచేసే కోడ్ పెద్ద డేటాపై క్రాష్ కావచ్చు; సమర్థతను పరిగణించండి.

నాలుగు కాపీ చేయగల టెంప్లేట్‌లు

1) స్కీమాతో SQLని అభ్యర్థిస్తోంది:

మీ పాత్ర: SQL అసిస్టెంట్ (PostgreSQL). పట్టికలు:- ఆర్డర్‌లు(id, customer_id, తేదీ టైమ్‌స్టాంప్, మొత్తం సంఖ్య)- కస్టమర్‌లు (id, సిటీ టెక్స్ట్) టాస్క్: 2024లో ఒక నగరానికి మొత్తం టర్నోవర్ మరియు ఆర్డర్‌ల సంఖ్యను పొందండి, అవరోహణ క్రమంలో టర్నోవర్ ద్వారా క్రమబద్ధీకరించబడింది. మీరు NULL నగరాలను ఎలా నిర్వహిస్తారో వివరించండి. నేను మొదట LIMITతో ప్రశ్నను పరీక్షిస్తాను; తరంని నవీకరించండి/తొలగించండి.

2) చెక్‌పాయింట్‌తో పాండాల ప్రక్రియ:

నా దగ్గర DataFrames df (ఆర్డర్‌లు) మరియు df_customers (కస్టమర్లు) ఉన్నాయి. నగరానికి సగటు మొత్తాన్ని లెక్కించండి. ముఖ్యమైనది: విలీనానికి ముందు మరియు తర్వాత అడ్డు వరుసల సంఖ్యను ప్రింట్ చేయండి, తద్వారా నేను నకిలీని చూడగలను. మీరు ఏ నిలువు వరుసలో విలీనం చేసారో మరియు మీరు లోపలి/ఎడమవైపు ఎందుకు ఎంచుకున్నారో వివరించండి.

3) కోడ్ వివరణ మరియు ధృవీకరణ:

కింది పాండాస్ కోడ్ లైన్‌ను లైన్ ద్వారా వివరించండి: ప్రతి పంక్తి ఏమి చేస్తుంది, అది ఎలాంటి అంచనాలను చేస్తుంది, ఏ సందర్భాలలో అది తప్పు ఫలితాలను ఇవ్వగలదు? నేను ఫడ్జ్ ఫంక్షన్‌ని ఉపయోగించినట్లయితే నాకు తెలియజేయండి. కోడ్: [అతికించు]

4) డీబగ్గింగ్:

ఈ కోడ్ ఈ లోపాన్ని ఇస్తుంది. పూర్తి దోష సందేశం: [అతికించు]. కోడ్: [పేస్ట్]. లోపం యొక్క మూల కారణాన్ని వివరించండి మరియు దాన్ని పరిష్కరించండి. హెచ్చరికను నిశ్శబ్దం చేయడం ద్వారా కాకుండా సమస్యను వాస్తవంగా పరిష్కరించడం ద్వారా దాన్ని పరిష్కరించండి. ఫిక్స్ అవుట్‌పుట్‌ని మార్చిందో లేదో కూడా సూచించండి.

బలహీనమైన ప్రాంప్ట్ / బలమైన ప్రాంప్ట్

బలహీనమైన ప్రాంప్ట్:

ప్రతి నగరానికి నాకు విక్రయాలను అందించే ప్రశ్నను వ్రాయండి.

పట్టిక పేర్లు, నిలువు వరుసలు, డేటాబేస్ రకం, NULL ప్రవర్తన అస్పష్టంగా ఉన్నాయి. AI సాధారణం, ఇది బహుశా మీ టేబుల్‌కి సరిపోని ప్రశ్నను ఉత్పత్తి చేస్తుంది.

శక్తివంతమైన ప్రాంప్ట్:

మీ పాత్ర: SQL అసిస్టెంట్ (MySQL 8). పట్టిక: విక్రయాలు(id, సిటీ వర్చార్, మొత్తం దశాంశం, తేదీ తేదీ). టాస్క్: 2024 సంవత్సరానికి మొత్తం మరియు సగటు మొత్తం, ఒక్కో నగరానికి ఆర్డర్‌ల సంఖ్యను పొందండి; మొత్తం మొత్తం ద్వారా తగ్గుతున్న క్రమబద్ధీకరణ; 100 కంటే ఎక్కువ ఆర్డర్‌లు ఉన్న నగరాలను మాత్రమే చూపు (హవింగ్). NULL నగరాన్ని మినహాయించండి. ప్రశ్నను వివరించండి; నేను LIMITతో పరీక్షిస్తాను.

ఇక్కడ డేటాబేస్, స్కీమా, ఫిల్టర్, సార్టింగ్ మరియు NULL నియమం స్పష్టంగా ఉన్నాయి.

సాధారణ తప్పులు

• కోడ్‌ని చదవకుండానే అమలు చేస్తోంది. వర్కింగ్ కోడ్ సరైన కోడ్ కాదు; తప్పు కాలమ్‌ను మార్చే కోడ్ కూడా లోపాలు లేకుండా నడుస్తుంది.
• విలీనం/JOIN తర్వాత అడ్డు వరుసల సంఖ్యను తనిఖీ చేయడం లేదు. తప్పు కీ నిశ్శబ్దంగా అడ్డు వరుసలను నకిలీ చేస్తుంది మరియు మొత్తాలను పెంచుతుంది.
• ఫిట్టింగ్ ఫంక్షన్‌ని ధృవీకరించడం లేదు. AI ఉనికిలో లేని పద్ధతులను సూచించవచ్చు; మీరు దానిని గుర్తించలేదని పత్రం నుండి నిర్ధారించండి.
• సమర్థత గురించి ఆలోచించడం లేదు. మిలియన్ల కొద్దీ అడ్డు వరుసలలో చిన్న డేటా క్రాష్‌లపై పని చేయడం/లూప్ చేయడం; వెక్టరైజ్.
• ఉత్పత్తి డేటాబేస్లో నేరుగా అమలు చేయండి. ముఖ్యంగా ఎక్కడ లేదా పరీక్ష లేకుండా UPDATE/DELETE అమలు చేయడం వినాశకరమైనది.

చిట్కా: మీరు AI నుండి స్వీకరించే ప్రతి కోడ్‌కి "ధృవీకరణ పంక్తి"ని జోడించడం అలవాటు చేసుకోండి: ముందు మరియు పోస్ట్-ప్రాసెసింగ్ లైన్ల సంఖ్య, కొన్ని నమూనా పంక్తులు మరియు చేతితో క్లిష్టమైన మొత్తం. ఈ మూడు తనిఖీలు చాలా సైలెంట్ లాజిక్ ఎర్రర్‌లను క్యాచ్ చేస్తాయి.

సారాంశంలో

AI అనేది SQL మరియు పాండాస్ కోడ్‌ను త్వరగా ఉత్పత్తి చేసే శక్తివంతమైన భాగస్వామి, కానీ ఇది బ్లైండ్ అథారిటీ కాదు. అతనికి పథకం మరియు ఉద్దేశ్యాన్ని స్పష్టంగా ఇవ్వండి; అది ఉత్పత్తి చేసే కోడ్‌ను మీరే వ్రాసినట్లుగా చదవండి; విలీనం/JOIN తర్వాత అడ్డు వరుసల సంఖ్య, ఫిట్టింగ్ ఫంక్షన్‌లు మరియు నిర్గమాంశను తనిఖీ చేయండి; ఉత్పత్తి డేటాబేస్లో పరీక్షించకుండా దీన్ని అమలు చేయవద్దు. డీబగ్ చేస్తున్నప్పుడు, సమస్యను పరిష్కరించడానికి లక్ష్యంగా పెట్టుకోండి, నిశ్శబ్దం చేయకూడదు. పని చేసే కోడ్ సరైన కోడ్ కాదు; మీరు మాత్రమే ఖచ్చితత్వానికి హామీ ఇవ్వగలరు.

అప్లికేషన్ టాస్క్

విశ్లేషణ ప్రశ్నను ఎంచుకోండి (ఉదా. "ఒక ఛానెల్‌కు నెలవారీ టర్నోవర్") మరియు SQL మరియు పాండాలు రెండింటితో AI నుండి కోడ్‌ను అభ్యర్థించండి. పంక్తి ద్వారా రెండు కోడ్‌లను చదవండి, విలీనం/JOIN తర్వాత పంక్తుల సంఖ్యను తనిఖీ చేయండి మరియు కనీసం ఒక క్లిష్టమైన మొత్తాన్ని మాన్యువల్‌గా ధృవీకరించండి. రెండు కోడ్‌లు ఒకే ఫలితాన్ని ఇస్తాయో లేదో సరిపోల్చండి; భిన్నంగా ఉంటే, ఎందుకు అని తెలుసుకోండి.

చెక్లిస్ట్

• [ ] నేను పట్టిక/స్కీమా మరియు ప్రయోజనాన్ని స్పష్టంగా AIకి ఇచ్చానా?
• [ ] నేను లైన్ ద్వారా అది ఉత్పత్తి చేసిన కోడ్‌ని చదివి అర్థం చేసుకున్నానా?
• [ ] నేను విలీనం/JOIN తర్వాత లైన్ల సంఖ్యను తనిఖీ చేశానా?
• [ ] నేను డాక్యుమెంటేషన్ నుండి గుర్తించని ఫంక్షన్‌లను ధృవీకరించానా?
• [ ] నేను ముందుగా ఉత్పత్తి వాతావరణంలో కాకుండా సురక్షితమైన/చిన్న డేటాపై కోడ్‌ని పరీక్షించానా?