Pandas DataFrames: డేటా దిగుమతి, మిస్సింగ్ విలువల నిర్వహణ, dtype మార్పులు & కాలమ్ శుభ్రపరచడం

పరిచయం

ఈ ఉపన్యాసంలో పాండాస్ డేటాఫ్రేమ్‌లపై ముందున్న పాఠాల సంక్షిప్త పునర్విమర్శ చేసి, కొత్తగా CSV ఫైల్‌ను ఎలా దిగుమతి చేసుకోవాలి, మిస్సింగ్ (null) విలువలను ఎలా గుర్తించాలి, వాటిని ఎలా నిర్వహించాలి, అలాగే కాలమ్‌ల డేటా రకాలను (dtype) ఎలా మార్చాలి, మెమరీ వినియోగాన్ని తగ్గించడానికి category రకాన్ని ఎలా ఉపయోగించాలి, మరియు స్ట్రింగ్ విలువలను సంఖ్యలుగా మార్చి కాలమ్‌లను శుభ్రపరచడం గురించి చర్చించాం.

1. గత పాఠాల రీక్యాప్

• డేటా రకాలు: సంఖ్యాపరమైన (numeric) మరియు అక్షర (string) రకాలు.
• ప్రతి కాలమ్ dtype తనిఖీ: df.dtypes ద్వారా.
• డేటా ఎంపిక: నిర్దిష్ట dtype ఆధారంగా వరుసలను ఫిల్టర్ చేయడం.
• డేటాఫ్రేమ్ సారాంశం: df.info(), df.describe() ద్వారా.
• నాన్‑నల్ విలువల లెక్కింపు: ప్రతి కాలమ్‌లో ఉన్న null కాని విలువల సంఖ్య.

2. CSV ఫైల్‌ను దిగుమతి చేయడం

import pandas as pd

df = pd.read_csv('toyota.csv', index_col=0,
                 na_values=['??', '????', '?????'],
                 keep_default_na=True)

• index_col=0 → మొదటి కాలమ్‌ను ఇండెక్స్‌గా తీసుకోవడం.
• na_values ద్వారా ??, ???? వంటి ప్రత్యేక అక్షరాలను NaN గా పరిగణించడం.

3. మిస్సింగ్ విలువల (Missing Values) గుర్తింపు

• NaN, ఖాళీ స్ట్రింగ్, ప్రశ్నార్థక చిహ్నాలు వంటి రూపాలు NaN గా మారుతాయి.
• df.isnull().sum() ద్వారా ప్రతి కాలమ్‌లోని మిస్సింగ్ విలువల సంఖ్యను తెలుసుకోవచ్చు.
• ఉదాహరణ ఫలితం:
• price – 0
• age – 100
• kilometer – 15
• fuel_type – 100
• horsepower – 6
• metallic_color – 150

4. డేటా రకాన్ని (dtype) మార్చడం

• astype ఫంక్షన్**: df['metallic_color'] = df['metallic_color'].astype('object')
• category vs object:
• category → మెమరీ సేవ్ చేస్తుంది, పెద్ద స్ట్రింగ్ కాలమ్‌లకు అనుకూలం.
• object → సాధారణ స్ట్రింగ్, ఎక్కువ మెమరీ వినియోగం.
• మెమరీ వినియోగం తనిఖీ: df['fuel_type'].memory_usage(deep=True)
• object → 11488 బైట్లు
• category → 1460 బైట్లు (సుమారు 8‑గుణం తగ్గింపు)

5. కాలమ్ శుభ్రపరచడం – doors ఉదాహరణ

• doors కాలమ్‌లో "5", "4", "3" వంటి స్ట్రింగ్‌లు ఉన్నాయి, ఇవి సంఖ్యలుగా మార్చాలి.
• replace ద్వారా స్ట్రింగ్‌ను సంఖ్యతో భర్తీ చేయడం:

df['doors'] = df['doors'].replace({'5':5, '4':4, '3':3})

• astype ద్వారా integer dtype కు మార్చడం:

df['doors'] = df['doors'].astype('int64')

• ఈ ప్రక్రియ కొత్త విలువల సమూహాన్ని (ఉదా: 2,3,4,5) సృష్టించకుండా, ఇప్పటికే ఉన్న విలువలను మాత్రమే మార్చుతుంది.

6. ఇతర కాలమ్‌లలో స్ట్రింగ్ → సంఖ్య మార్పు

• df['doors'].replace({'3':3, '4':4, '5':5}, inplace=True)
• అవసరమైతే pd.to_numeric(df['doors'], errors='coerce') ద్వారా బలవంతంగా సంఖ్యలుగా మార్చవచ్చు.

7. మొత్తం ప్రక్రియ సారాంశం

1. CSV ను read_csv తో దిగుమతి, na_values ద్వారా మిస్సింగ్ గుర్తింపులు నిర్వచించండి.
2. df.isnull().sum() ద్వారా మిస్సింగ్ విలువల సంఖ్యను తెలుసుకోండి.
3. అవసరమైతే astype లేదా pd.to_numeric ద్వారా dtype మార్చండి.
4. స్ట్రింగ్‑సంఖ్యల మిశ్రమం ఉన్న కాలమ్‌లను replace + astype ద్వారా శుభ్రపరచండి.
5. మెమరీ సేవ్ చేయడానికి category dtype ను ఉపయోగించండి.

8. తదుపరి దశలు

• మిస్సింగ్ విలువలను ఎలా పూరించాలి (mean, median, interpolation, లేదా drop) అనే లాజిక్‌ను రూపొందించాలి.
• శుభ్రపరచిన డేటాను విశ్లేషణ, మోడలింగ్ లేదా విజువలైజేషన్ కోసం సిద్ధం చేయాలి.

ఈ పాఠం ద్వారా మీరు - CSV ఫైల్‌ను ఖచ్చితంగా దిగుమతి చేయగలరు, - మిస్సింగ్ విలువలను గుర్తించి, వాటిని సరైన విధంగా నిర్వహించగలరు, - డేటా రకాలను మార్చి మెమరీ వినియోగాన్ని తగ్గించగలరు, - స్ట్రింగ్‑సంఖ్యల మిశ్రమ కాలమ్‌లను శుభ్రపరచి విశ్లేషణకు సిద్ధం చేయగలరు.

డేటాను సక్రమంగా దిగుమతి చేసి, మిస్సింగ్ విలువలను గుర్తించి, అవసరమైన dtype మార్పులు (object → category, string → int) చేసి, కాలమ్‌లను శుభ్రపరచడం ద్వారా మీరు పెద్ద పరిమాణంలో కూడా సమర్థవంతమైన pandas విశ్లేషణను నిర్వహించగలరు.