|
|
<!--
|
|
|
CO_OP_TRANSLATOR_METADATA:
|
|
|
{
|
|
|
"original_hash": "7bfec050f4717dcc2dfd028aca9d21f3",
|
|
|
"translation_date": "2025-12-19T15:29:16+00:00",
|
|
|
"source_file": "2-Working-With-Data/07-python/README.md",
|
|
|
"language_code": "te"
|
|
|
}
|
|
|
-->
|
|
|
# డేటాతో పని చేయడం: పైథాన్ మరియు పాండాస్ లైబ్రరీ
|
|
|
|
|
|
|  ](../../sketchnotes/07-WorkWithPython.png) |
|
|
|
| :-------------------------------------------------------------------------------------------------------: |
|
|
|
| Python తో పని చేయడం - _Sketchnote by [@nitya](https://twitter.com/nitya)_ |
|
|
|
|
|
|
[](https://youtu.be/dZjWOGbsN4Y)
|
|
|
|
|
|
డేటాబేసులు డేటాను నిల్వ చేయడానికి మరియు క్వెరీ భాషలను ఉపయోగించి వాటిని క్వెరీ చేయడానికి చాలా సమర్థవంతమైన మార్గాలను అందించినప్పటికీ, డేటాను ప్రాసెస్ చేయడానికి అత్యంత అనుకూలమైన మార్గం మీ స్వంత ప్రోగ్రామ్ రాయడం. చాలా సందర్భాల్లో, డేటాబేస్ క్వెరీ చేయడం మరింత సమర్థవంతమైన మార్గం అవుతుంది. అయితే, కొన్ని సందర్భాల్లో, మరింత సంక్లిష్టమైన డేటా ప్రాసెసింగ్ అవసరం అయితే, అది SQL ఉపయోగించి సులభంగా చేయలేము.
|
|
|
డేటా ప్రాసెసింగ్ ఏ ప్రోగ్రామింగ్ భాషలోనైనా ప్రోగ్రామ్ చేయవచ్చు, కానీ డేటాతో పని చేయడంలో కొంతమంది భాషలు ఉన్నత స్థాయిలో ఉంటాయి. డేటా సైంటిస్టులు సాధారణంగా క్రింది భాషలలో ఒకదాన్ని ఇష్టపడతారు:
|
|
|
|
|
|
* **[Python](https://www.python.org/)**, ఒక సాధారణ ప్రయోజన ప్రోగ్రామింగ్ భాష, ఇది సులభత కారణంగా ప్రారంభకులకు ఉత్తమ ఎంపికలలో ఒకటిగా పరిగణించబడుతుంది. పైథాన్లో అనేక అదనపు లైబ్రరీలు ఉన్నాయి, ఇవి మీకు అనేక ప్రాక్టికల్ సమస్యలను పరిష్కరించడంలో సహాయపడతాయి, ఉదాహరణకు ZIP ఆర్కైవ్ నుండి డేటాను తీసుకోవడం లేదా చిత్రాన్ని గ్రేస్కేల్గా మార్చడం. డేటా సైన్స్కు అదనంగా, పైథాన్ వెబ్ డెవలప్మెంట్ కోసం కూడా తరచుగా ఉపయోగిస్తారు.
|
|
|
* **[R](https://www.r-project.org/)** ఒక సాంప్రదాయ టూల్బాక్స్, ఇది గణాంక డేటా ప్రాసెసింగ్ దృష్టితో అభివృద్ధి చేయబడింది. ఇది పెద్ద లైబ్రరీ రిపాజిటరీ (CRAN) కలిగి ఉంది, ఇది డేటా ప్రాసెసింగ్కు మంచి ఎంపిక. అయితే, R సాధారణ ప్రయోజన ప్రోగ్రామింగ్ భాష కాదు, మరియు డేటా సైన్స్ డొమైన్ వెలుపల అరుదుగా ఉపయోగిస్తారు.
|
|
|
* **[Julia](https://julialang.org/)** మరొక భాష, ఇది ప్రత్యేకంగా డేటా సైన్స్ కోసం అభివృద్ధి చేయబడింది. ఇది పైథాన్ కంటే మెరుగైన పనితీరు ఇవ్వడానికి ఉద్దేశించబడింది, ఇది శాస్త్రీయ ప్రయోగాలకు గొప్ప సాధనం.
|
|
|
|
|
|
ఈ పాఠంలో, మేము సులభమైన డేటా ప్రాసెసింగ్ కోసం పైథాన్ ఉపయోగంపై దృష్టి సారిస్తాము. భాషపై ప్రాథమిక పరిచయం ఉన్నట్లు భావిస్తాము. మీరు పైథాన్ లో మరింత లోతైన పర్యటన కోరుకుంటే, క్రింది వనరులలో ఒకదాన్ని చూడవచ్చు:
|
|
|
|
|
|
* [Learn Python in a Fun Way with Turtle Graphics and Fractals](https://github.com/shwars/pycourse) - GitHub ఆధారిత పైథాన్ ప్రోగ్రామింగ్ త్వరిత పరిచయ కోర్సు
|
|
|
* [Take your First Steps with Python](https://docs.microsoft.com/en-us/learn/paths/python-first-steps/?WT.mc_id=academic-77958-bethanycheum) [Microsoft Learn](http://learn.microsoft.com/?WT.mc_id=academic-77958-bethanycheum) లో లెర్నింగ్ పాత్
|
|
|
|
|
|
డేటా అనేక రూపాల్లో ఉండవచ్చు. ఈ పాఠంలో, మేము మూడు రూపాల డేటాను పరిగణిస్తాము - **టేబులర్ డేటా**, **పాఠ్యం** మరియు **చిత్రాలు**.
|
|
|
|
|
|
మేము డేటా ప్రాసెసింగ్ కొన్ని ఉదాహరణలపై దృష్టి సారిస్తాము, అన్ని సంబంధిత లైబ్రరీల పూర్తి అవలోకనం ఇవ్వకుండా. ఇది మీరు సాధ్యమైన ప్రధాన ఆలోచనను పొందడానికి మరియు మీకు అవసరమైనప్పుడు సమస్యలకు పరిష్కారాలు ఎక్కడ కనుగొనాలో అర్థం చేసుకోవడానికి సహాయపడుతుంది.
|
|
|
|
|
|
> **అత్యంత ఉపయోగకరమైన సలహా**. మీరు డేటాపై నిర్దిష్ట ఆపరేషన్ చేయాల్సిన అవసరం ఉన్నప్పుడు, మీరు ఎలా చేయాలో తెలియకపోతే, దాన్ని ఇంటర్నెట్లో శోధించండి. [Stackoverflow](https://stackoverflow.com/) సాధారణ పనుల కోసం పైథాన్లో చాలా ఉపయోగకరమైన కోడ్ నమూనాలను కలిగి ఉంటుంది.
|
|
|
|
|
|
|
|
|
|
|
|
## [పూర్వ-లెక్చర్ క్విజ్](https://ff-quizzes.netlify.app/en/ds/quiz/12)
|
|
|
|
|
|
## టేబులర్ డేటా మరియు డేటాఫ్రేమ్స్
|
|
|
|
|
|
మేము రిలేషనల్ డేటాబేసుల గురించి మాట్లాడినప్పుడు మీరు ఇప్పటికే టేబులర్ డేటాను కలుసుకున్నారు. మీరు చాలా డేటా కలిగి ఉన్నప్పుడు, మరియు అది అనేక వేర్వేరు లింక్ చేసిన పట్టికల్లో ఉంటే, దానితో పని చేయడానికి SQL ఉపయోగించడం ఖచ్చితంగా అర్థం. అయితే, చాలా సందర్భాల్లో మాకు డేటా పట్టిక ఉంటే, మరియు ఆ డేటా గురించి కొన్ని **అర్థం** లేదా **అవగాహన** పొందాలి, ఉదాహరణకు పంపిణీ, విలువల మధ్య సంబంధం మొదలైనవి. డేటా సైన్స్లో, మాకు అసలు డేటాను కొన్ని మార్పులు చేయాల్సిన అవసరం ఉంటుంది, ఆ తర్వాత దాన్ని విజువలైజ్ చేయాలి. ఈ రెండు దశలను సులభంగా పైథాన్ ఉపయోగించి చేయవచ్చు.
|
|
|
|
|
|
పైథాన్లో టేబులర్ డేటాతో పని చేయడానికి రెండు అత్యంత ఉపయోగకరమైన లైబ్రరీలు ఉన్నాయి:
|
|
|
* **[Pandas](https://pandas.pydata.org/)** మీరు **డేటాఫ్రేమ్స్** అని పిలవబడే వాటిని నిర్వహించడానికి అనుమతిస్తుంది, ఇవి రిలేషనల్ పట్టికలకు సమానమైనవి. మీరు పేరుతో ఉన్న కాలమ్స్ కలిగి ఉండవచ్చు, మరియు వరుసలు, కాలమ్స్ మరియు డేటాఫ్రేమ్స్ పై వివిధ ఆపరేషన్లు చేయవచ్చు.
|
|
|
* **[Numpy](https://numpy.org/)** అనేది **టెన్సార్ల**తో పని చేయడానికి లైబ్రరీ, అంటే బహుముఖ్యమైన **అర్రేస్**. అర్రేలో ఒకే రకమైన విలువలు ఉంటాయి, ఇది డేటాఫ్రేమ్ కంటే సులభం, కానీ ఇది మరింత గణిత ఆపరేషన్లు అందిస్తుంది మరియు తక్కువ ఓవర్హెడ్ సృష్టిస్తుంది.
|
|
|
|
|
|
మరియు మీరు తెలుసుకోవలసిన కొన్ని ఇతర లైబ్రరీలు కూడా ఉన్నాయి:
|
|
|
* **[Matplotlib](https://matplotlib.org/)** డేటా విజువలైజేషన్ మరియు గ్రాఫ్లను ప్లాట్ చేయడానికి ఉపయోగించే లైబ్రరీ
|
|
|
* **[SciPy](https://www.scipy.org/)** కొన్ని అదనపు శాస్త్రీయ ఫంక్షన్లతో కూడిన లైబ్రరీ. probability మరియు statistics గురించి మాట్లాడినప్పుడు మేము ఇప్పటికే ఈ లైబ్రరీని చూశాము
|
|
|
|
|
|
ఇది మీరు సాధారణంగా మీ పైథాన్ ప్రోగ్రామ్ ప్రారంభంలో ఆ లైబ్రరీలను దిగుమతి చేసుకోవడానికి ఉపయోగించే కోడ్ భాగం:
|
|
|
```python
|
|
|
import numpy as np
|
|
|
import pandas as pd
|
|
|
import matplotlib.pyplot as plt
|
|
|
from scipy import ... # మీరు అవసరమైన ఖచ్చితమైన ఉప-ప్యాకేజీలను పేర్కొనాలి
|
|
|
```
|
|
|
|
|
|
పాండాస్ కొన్ని ప్రాథమిక భావనల చుట్టూ కేంద్రీకృతమైంది.
|
|
|
|
|
|
### సిరీస్
|
|
|
|
|
|
**సిరీస్** అనేది విలువల శ్రేణి, ఇది జాబితా లేదా నంపై అర్రేకు సమానంగా ఉంటుంది. ప్రధాన తేడా ఏమిటంటే సిరీస్కు కూడా ఒక **ఇండెక్స్** ఉంటుంది, మరియు మేము సిరీస్పై ఆపరేషన్ చేస్తే (ఉదా., వాటిని జోడించడం), ఇండెక్స్ను పరిగణలోకి తీసుకుంటుంది. ఇండెక్స్ సాధారణంగా పూర్తి సంఖ్య వరుస సంఖ్య (జాబితా లేదా అర్రే నుండి సిరీస్ సృష్టించినప్పుడు డిఫాల్ట్గా ఉపయోగించే ఇండెక్స్) కావచ్చు, లేదా అది సంక్లిష్ట నిర్మాణం కలిగి ఉండవచ్చు, ఉదా., తేదీ వ్యవధి.
|
|
|
|
|
|
> **గమనిక**: సహాయక నోట్బుక్ [`notebook.ipynb`](notebook.ipynb) లో కొంత పరిచయ పాండాస్ కోడ్ ఉంది. మేము ఇక్కడ కొన్ని ఉదాహరణలను మాత్రమే వివరించాము, మీరు పూర్తి నోట్బుక్ను తప్పకుండా చూడవచ్చు.
|
|
|
|
|
|
ఒక ఉదాహరణను పరిగణించండి: మేము మా ఐస్-క్రీమ్ స్థలంలో అమ్మకాలను విశ్లేషించాలనుకుంటున్నాము. కొంత కాలం పాటు రోజుకు అమ్మిన ఐటెమ్ల సంఖ్య సిరీస్ను సృష్టిద్దాం:
|
|
|
|
|
|
```python
|
|
|
start_date = "Jan 1, 2020"
|
|
|
end_date = "Mar 31, 2020"
|
|
|
idx = pd.date_range(start_date,end_date)
|
|
|
print(f"Length of index is {len(idx)}")
|
|
|
items_sold = pd.Series(np.random.randint(25,50,size=len(idx)),index=idx)
|
|
|
items_sold.plot()
|
|
|
```
|
|
|
|
|
|
|
|
|
ఇప్పుడు ప్రతీ వారం మేము స్నేహితుల కోసం పార్టీ నిర్వహిస్తున్నాము, మరియు పార్టీ కోసం అదనంగా 10 ఐస్-క్రీమ్ ప్యాకెట్లు తీసుకుంటాము అనుకోండి. మేము వారానికి ఇండెక్స్ చేయబడిన మరో సిరీస్ సృష్టించవచ్చు, దీన్ని చూపించడానికి:
|
|
|
```python
|
|
|
additional_items = pd.Series(10,index=pd.date_range(start_date,end_date,freq="W"))
|
|
|
```
|
|
|
రెండు సిరీస్లను కలిపితే, మొత్తం సంఖ్య వస్తుంది:
|
|
|
```python
|
|
|
total_items = items_sold.add(additional_items,fill_value=0)
|
|
|
total_items.plot()
|
|
|
```
|
|
|
|
|
|
|
|
|
> **గమనిక** మేము సాదారణ సింటాక్స్ `total_items+additional_items` ఉపయోగించట్లేదు. అలా చేస్తే, ఫలిత సిరీస్లో చాలా `NaN` (*Not a Number*) విలువలు వస్తాయి. ఇది ఎందుకంటే `additional_items` సిరీస్లో కొన్ని ఇండెక్స్ పాయింట్లకు విలువలు లేవు, మరియు `NaN` ను ఏదైనా విలువకు జోడిస్తే ఫలితం `NaN` అవుతుంది. అందువల్ల జోడింపు సమయంలో `fill_value` పారామీటర్ను నిర్దేశించాలి.
|
|
|
|
|
|
టైమ్ సిరీస్తో, మేము సిరీస్ను వేరే సమయ వ్యవధులతో **రీసాంపుల్** చేయవచ్చు. ఉదాహరణకు, మేము నెలవారీ సగటు అమ్మకాలను లెక్కించాలనుకుంటే, క్రింది కోడ్ ఉపయోగించవచ్చు:
|
|
|
```python
|
|
|
monthly = total_items.resample("1M").mean()
|
|
|
ax = monthly.plot(kind='bar')
|
|
|
```
|
|
|
|
|
|
|
|
|
### డేటాఫ్రేమ్
|
|
|
|
|
|
డేటాఫ్రేమ్ అనేది ఒకే ఇండెక్స్ కలిగిన సిరీస్ల సేకరణ. మేము అనేక సిరీస్లను కలిపి ఒక డేటాఫ్రేమ్ సృష్టించవచ్చు:
|
|
|
```python
|
|
|
a = pd.Series(range(1,10))
|
|
|
b = pd.Series(["I","like","to","play","games","and","will","not","change"],index=range(0,9))
|
|
|
df = pd.DataFrame([a,b])
|
|
|
```
|
|
|
ఇది ఈ విధంగా ఒక ఆడంబరమైన పట్టికను సృష్టిస్తుంది:
|
|
|
| | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 |
|
|
|
| --- | --- | ---- | --- | --- | ------ | --- | ------ | ---- | ---- |
|
|
|
| 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 |
|
|
|
| 1 | I | like | to | use | Python | and | Pandas | very | much |
|
|
|
|
|
|
మేము సిరీస్లను కాలమ్స్గా కూడా ఉపయోగించవచ్చు, మరియు డిక్షనరీ ఉపయోగించి కాలమ్ పేర్లను నిర్దేశించవచ్చు:
|
|
|
```python
|
|
|
df = pd.DataFrame({ 'A' : a, 'B' : b })
|
|
|
```
|
|
|
ఇది ఈ విధంగా ఒక పట్టిక ఇస్తుంది:
|
|
|
|
|
|
| | A | B |
|
|
|
| --- | --- | ------ |
|
|
|
| 0 | 1 | I |
|
|
|
| 1 | 2 | like |
|
|
|
| 2 | 3 | to |
|
|
|
| 3 | 4 | use |
|
|
|
| 4 | 5 | Python |
|
|
|
| 5 | 6 | and |
|
|
|
| 6 | 7 | Pandas |
|
|
|
| 7 | 8 | very |
|
|
|
| 8 | 9 | much |
|
|
|
|
|
|
**గమనిక** మేము ఈ పట్టిక లేఅవుట్ను కూడా గత పట్టికను ట్రాన్స్పోజ్ చేయడం ద్వారా పొందవచ్చు, ఉదా., ఇలా రాయడం ద్వారా
|
|
|
```python
|
|
|
df = pd.DataFrame([a,b]).T..rename(columns={ 0 : 'A', 1 : 'B' })
|
|
|
```
|
|
|
ఇక్కడ `.T` అనేది డేటాఫ్రేమ్ను ట్రాన్స్పోజ్ చేయడం అంటే వరుసలు మరియు కాలమ్స్ మార్చడం ఆపరేషన్, మరియు `rename` ఆపరేషన్ మాకు కాలమ్లను గత ఉదాహరణకు సరిపడేలా పేరు మార్చడానికి అనుమతిస్తుంది.
|
|
|
|
|
|
ఇక్కడ డేటాఫ్రేమ్స్పై మేము చేయగల కొన్ని ముఖ్యమైన ఆపరేషన్లు ఉన్నాయి:
|
|
|
|
|
|
**కాలమ్ ఎంపిక**. మేము వ్యక్తిగత కాలమ్లను `df['A']` అని రాయడం ద్వారా ఎంచుకోవచ్చు - ఈ ఆపరేషన్ ఒక సిరీస్ను ఇస్తుంది. మేము `df[['B','A']]` అని రాయడం ద్వారా కాలమ్ల ఉపసమితిని మరో డేటాఫ్రేమ్గా ఎంచుకోవచ్చు - ఇది మరో డేటాఫ్రేమ్ ఇస్తుంది.
|
|
|
|
|
|
**నిర్దిష్ట వరుసలను ఫిల్టర్ చేయడం**. ఉదాహరణకు, కాలమ్ `A` విలువ 5 కంటే ఎక్కువ ఉన్న వరుసలను మాత్రమే ఉంచాలంటే, మేము `df[df['A']>5]` అని రాయవచ్చు.
|
|
|
|
|
|
> **గమనిక**: ఫిల్టరింగ్ ఎలా పనిచేస్తుందంటే, `df['A']<5` అనే వ్యక్తీకరణ ఒక బూలియన్ సిరీస్ను ఇస్తుంది, ఇది అసలు సిరీస్ `df['A']` లో ప్రతి అంశం కోసం వ్యక్తీకరణ `True` లేదా `False` అని సూచిస్తుంది. బూలియన్ సిరీస్ను ఇండెక్స్గా ఉపయోగిస్తే, అది డేటాఫ్రేమ్లోని వరుసల ఉపసమితిని ఇస్తుంది. అందువల్ల, సాధారణ పైథాన్ బూలియన్ వ్యక్తీకరణను ఉపయోగించడం సాధ్యం కాదు, ఉదా., `df[df['A']>5 and df['A']<7]` తప్పు. బదులుగా, మీరు బూలియన్ సిరీస్లపై ప్రత్యేక `&` ఆపరేషన్ ఉపయోగించాలి, ఇలా రాయాలి `df[(df['A']>5) & (df['A']<7)]` (*బ్రాకెట్లు ఇక్కడ ముఖ్యమైనవి*).
|
|
|
|
|
|
**కొత్త గణనీయమైన కాలమ్లను సృష్టించడం**. మేము సులభంగా కొత్త గణనీయమైన కాలమ్లను క్రింది వంటి సూటిగా అర్థమయ్యే వ్యక్తీకరణ ఉపయోగించి సృష్టించవచ్చు:
|
|
|
```python
|
|
|
df['DivA'] = df['A']-df['A'].mean()
|
|
|
```
|
|
|
ఈ ఉదాహరణ A యొక్క సగటు విలువ నుండి వ్యత్యాసాన్ని లెక్కిస్తుంది. ఇక్కడ నిజంగా జరుగుతున్నది ఏమిటంటే మేము ఒక సిరీస్ను లెక్కిస్తున్నాము, ఆ తర్వాత ఆ సిరీస్ను ఎడమవైపు కేటాయించడం ద్వారా మరో కాలమ్ సృష్టిస్తున్నాము. అందువల్ల, సిరీస్కు అనుకూలం కాని ఆపరేషన్లు ఉపయోగించలేము, ఉదా., క్రింది కోడ్ తప్పు:
|
|
|
```python
|
|
|
# తప్పు కోడ్ -> df['ADescr'] = "తక్కువ" if df['A'] < 5 else "ఎక్కువ"
|
|
|
df['LenB'] = len(df['B']) # <- తప్పు ఫలితం
|
|
|
```
|
|
|
ఈ చివరి ఉదాహరణ, సింటాక్సు పరంగా సరైనదైనా, తప్పు ఫలితాన్ని ఇస్తుంది, ఎందుకంటే ఇది కాలమ్లోని అన్ని విలువలకు సిరీస్ `B` యొక్క పొడవును కేటాయిస్తుంది, మరియు మేము ఉద్దేశించినట్లుగా వ్యక్తిగత అంశాల పొడవును కాదు.
|
|
|
|
|
|
ఇలాంటి సంక్లిష్ట వ్యక్తీకరణలను లెక్కించాల్సిన అవసరం ఉంటే, మేము `apply` ఫంక్షన్ ఉపయోగించవచ్చు. చివరి ఉదాహరణను ఇలా రాయవచ్చు:
|
|
|
```python
|
|
|
df['LenB'] = df['B'].apply(lambda x : len(x))
|
|
|
# లేదా
|
|
|
df['LenB'] = df['B'].apply(len)
|
|
|
```
|
|
|
|
|
|
పై ఆపరేషన్ల తర్వాత, మేము క్రింది డేటాఫ్రేమ్ను పొందుతాము:
|
|
|
|
|
|
| | A | B | DivA | LenB |
|
|
|
| --- | --- | ------ | ---- | ---- |
|
|
|
| 0 | 1 | I | -4.0 | 1 |
|
|
|
| 1 | 2 | like | -3.0 | 4 |
|
|
|
| 2 | 3 | to | -2.0 | 2 |
|
|
|
| 3 | 4 | use | -1.0 | 3 |
|
|
|
| 4 | 5 | Python | 0.0 | 6 |
|
|
|
| 5 | 6 | and | 1.0 | 3 |
|
|
|
| 6 | 7 | Pandas | 2.0 | 6 |
|
|
|
| 7 | 8 | very | 3.0 | 4 |
|
|
|
| 8 | 9 | much | 4.0 | 4 |
|
|
|
|
|
|
**సంఖ్యల ఆధారంగా వరుసలను ఎంచుకోవడం** `iloc` నిర్మాణం ఉపయోగించి చేయవచ్చు. ఉదాహరణకు, డేటాఫ్రేమ్ నుండి మొదటి 5 వరుసలను ఎంచుకోవడానికి:
|
|
|
```python
|
|
|
df.iloc[:5]
|
|
|
```
|
|
|
|
|
|
**గ్రూపింగ్** తరచుగా Excel లోని *pivot tables* లాంటి ఫలితాన్ని పొందడానికి ఉపయోగిస్తారు. ఉదాహరణకు, మేము ప్రతి `LenB` సంఖ్య కోసం కాలమ్ `A` యొక్క సగటు విలువను లెక్కించాలనుకుంటే, మేము మా డేటాఫ్రేమ్ను `LenB` ద్వారా గ్రూప్ చేసి, `mean` పిలవవచ్చు:
|
|
|
```python
|
|
|
df.groupby(by='LenB')[['A','DivA']].mean()
|
|
|
```
|
|
|
మేము సగటు మరియు గ్రూప్లో అంశాల సంఖ్యను లెక్కించాలనుకుంటే, మరింత సంక్లిష్టమైన `aggregate` ఫంక్షన్ ఉపయోగించవచ్చు:
|
|
|
```python
|
|
|
df.groupby(by='LenB') \
|
|
|
.aggregate({ 'DivA' : len, 'A' : lambda x: x.mean() }) \
|
|
|
.rename(columns={ 'DivA' : 'Count', 'A' : 'Mean'})
|
|
|
```
|
|
|
ఇది క్రింది పట్టిక ఇస్తుంది:
|
|
|
|
|
|
| LenB | Count | Mean |
|
|
|
| ---- | ----- | -------- |
|
|
|
| 1 | 1 | 1.000000 |
|
|
|
| 2 | 1 | 3.000000 |
|
|
|
| 3 | 2 | 5.000000 |
|
|
|
| 4 | 3 | 6.333333 |
|
|
|
| 6 | 2 | 6.000000 |
|
|
|
|
|
|
### డేటా పొందడం
|
|
|
మనం Python ఆబ్జెక్టుల నుండి Series మరియు DataFrames ను సులభంగా నిర్మించగలమని చూశాము. అయితే, డేటా సాధారణంగా టెక్స్ట్ ఫైల్ లేదా Excel పట్టిక రూపంలో వస్తుంది. అదృష్టవశాత్తు, Pandas మాకు డిస్క్ నుండి డేటాను లోడ్ చేయడానికి ఒక సులభమైన మార్గాన్ని అందిస్తుంది. ఉదాహరణకు, CSV ఫైల్ చదవడం ఇలా సులభం:
|
|
|
```python
|
|
|
df = pd.read_csv('file.csv')
|
|
|
```
|
|
|
మనం "Challenge" విభాగంలో బాహ్య వెబ్ సైట్ల నుండి డేటాను పొందడం సహా మరిన్ని లోడింగ్ ఉదాహరణలను చూడబోతున్నాము
|
|
|
|
|
|
|
|
|
### ముద్రణ మరియు చిత్రీకరణ
|
|
|
|
|
|
డేటా సైంటిస్ట్ తరచుగా డేటాను అన్వేషించాల్సి ఉంటుంది, కాబట్టి దాన్ని దృశ్యరూపంలో చూడగలగడం ముఖ్యమైనది. DataFrame పెద్దదైతే, మనం చాలా సార్లు మొదటి కొన్ని వరుసలను ముద్రించి మనం సరిగ్గా పని చేస్తున్నామా అని నిర్ధారించుకోవాలనుకుంటాము. ఇది `df.head()` ను పిలవడం ద్వారా చేయవచ్చు. మీరు Jupyter Notebook నుండి దీన్ని నడుపుతున్నట్లయితే, అది DataFrame ను మంచి పట్టిక రూపంలో ముద్రిస్తుంది.
|
|
|
|
|
|
మనం కొన్ని కాలమ్స్ ను దృశ్యరూపంలో చూపించడానికి `plot` ఫంక్షన్ ఉపయోగించడం కూడా చూశాము. `plot` అనేది అనేక పనులకు చాలా ఉపయోగకరమైనది, మరియు `kind=` పారామీటర్ ద్వారా అనేక రకాల గ్రాఫ్లను మద్దతు ఇస్తుంది, మీరు ఎప్పుడైనా మరింత క్లిష్టమైనది చిత్రీకరించడానికి ముడి `matplotlib` లైబ్రరీని ఉపయోగించవచ్చు. డేటా విజువలైజేషన్ను ప్రత్యేక కోర్సు పాఠాలలో వివరంగా చర్చిస్తాము.
|
|
|
|
|
|
ఈ అవలోకనం Pandas యొక్క అత్యంత ముఖ్యమైన భావనలను కవర్ చేస్తుంది, అయితే, లైబ్రరీ చాలా సమృద్ధిగా ఉంది, మరియు మీరు దానితో చేయగలిగే పనులకు ఎలాంటి పరిమితి లేదు! ఇప్పుడు ఈ జ్ఞానాన్ని నిర్దిష్ట సమస్యను పరిష్కరించడానికి ఉపయోగిద్దాం.
|
|
|
|
|
|
## 🚀 ఛాలెంజ్ 1: COVID వ్యాప్తి విశ్లేషణ
|
|
|
|
|
|
మనం మొదట దృష్టి సారించబోయే సమస్య COVID-19 మహమ్మారి వ్యాప్తి మోడలింగ్. దీని కోసం, మనం వివిధ దేశాలలో సంక్రమితుల సంఖ్యపై డేటాను ఉపయోగిస్తాము, ఇది [Center for Systems Science and Engineering](https://systems.jhu.edu/) (CSSE) ద్వారా [Johns Hopkins University](https://jhu.edu/) అందజేస్తుంది. డేటాసెట్ [ఈ GitHub రిపాజిటరీ](https://github.com/CSSEGISandData/COVID-19)లో అందుబాటులో ఉంది.
|
|
|
|
|
|
మనం డేటాతో ఎలా వ్యవహరించాలో చూపించాలనుకుంటున్నందున, మీరు [`notebook-covidspread.ipynb`](notebook-covidspread.ipynb) ను తెరిచి పై నుండి క్రింద వరకు చదవమని ఆహ్వానిస్తున్నాము. మీరు సెల్స్ను కూడా నడిపించవచ్చు, మరియు చివరలో మేము మీ కోసం వదిలిన కొన్ని ఛాలెంజ్లను చేయవచ్చు.
|
|
|
|
|
|
|
|
|
|
|
|
> మీరు Jupyter Notebook లో కోడ్ ఎలా నడుపాలో తెలియకపోతే, [ఈ వ్యాసం](https://soshnikov.com/education/how-to-execute-notebooks-from-github/)ను చూడండి.
|
|
|
|
|
|
## అసంఘటిత డేటాతో పని చేయడం
|
|
|
|
|
|
డేటా చాలా సార్లు పట్టిక రూపంలో వస్తుంది, కానీ కొన్ని సందర్భాల్లో మనం తక్కువ నిర్మాణాత్మక డేటాతో వ్యవహరించాల్సి ఉంటుంది, ఉదాహరణకు, టెక్స్ట్ లేదా చిత్రాలు. ఈ సందర్భంలో, పైగా చూచిన డేటా ప్రాసెసింగ్ సాంకేతికతలను వర్తింపజేయడానికి మనం ఏదో విధంగా నిర్మాణాత్మక డేటాను **ఎగుమతి** చేయాలి. కొన్ని ఉదాహరణలు:
|
|
|
|
|
|
* టెక్స్ట్ నుండి కీలకపదాలను ఎగుమతి చేసి, ఆ కీలకపదాలు ఎంతసార్లు కనిపిస్తాయో చూడటం
|
|
|
* చిత్రంలోని వస్తువుల గురించి సమాచారం పొందడానికి న్యూరల్ నెట్వర్క్లను ఉపయోగించడం
|
|
|
* వీడియో కెమెరా ఫీడ్లోని వ్యక్తుల భావోద్వేగాలపై సమాచారం పొందడం
|
|
|
|
|
|
## 🚀 ఛాలెంజ్ 2: COVID పేపర్ల విశ్లేషణ
|
|
|
|
|
|
ఈ ఛాలెంజ్లో, మనం COVID మహమ్మారి విషయంపై కొనసాగుతాము, మరియు ఈ విషయం పై శాస్త్రీయ పత్రాలను ప్రాసెస్ చేయడంపై దృష్టి సారిస్తాము. [CORD-19 Dataset](https://www.kaggle.com/allen-institute-for-ai/CORD-19-research-challenge) COVID పై 7000 కంటే ఎక్కువ (రాయడుతున్న సమయంలో) పత్రాలతో అందుబాటులో ఉంది, మెటాడేటా మరియు సారాంశాలతో (మరియు వాటిలో సగానికి పూర్తి టెక్స్ట్ కూడా అందుబాటులో ఉంది).
|
|
|
|
|
|
[Text Analytics for Health](https://docs.microsoft.com/azure/cognitive-services/text-analytics/how-tos/text-analytics-for-health/?WT.mc_id=academic-77958-bethanycheum) కాగ్నిటివ్ సర్వీస్ ఉపయోగించి ఈ డేటాసెట్ను విశ్లేషించే పూర్తి ఉదాహరణ [ఈ బ్లాగ్ పోస్ట్](https://soshnikov.com/science/analyzing-medical-papers-with-azure-and-text-analytics-for-health/)లో వివరించబడింది. మనం ఈ విశ్లేషణ యొక్క సరళీకృత సంస్కరణను చర్చిస్తాము.
|
|
|
|
|
|
> **NOTE**: ఈ రిపాజిటరీలో డేటాసెట్ కాపీని అందించము. మీరు ముందుగా [`metadata.csv`](https://www.kaggle.com/allen-institute-for-ai/CORD-19-research-challenge?select=metadata.csv) ఫైల్ను [Kaggleలోని ఈ డేటాసెట్](https://www.kaggle.com/allen-institute-for-ai/CORD-19-research-challenge) నుండి డౌన్లోడ్ చేసుకోవాలి. Kaggleలో రిజిస్ట్రేషన్ అవసరం కావచ్చు. మీరు రిజిస్ట్రేషన్ లేకుండా [ఇక్కడ](https://ai2-semanticscholar-cord-19.s3-us-west-2.amazonaws.com/historical_releases.html) నుండి కూడా డేటాసెట్ను డౌన్లోడ్ చేసుకోవచ్చు, కానీ అది మెటాడేటా ఫైల్తో పాటు అన్ని పూర్తి టెక్స్ట్లను కూడా కలిగి ఉంటుంది.
|
|
|
|
|
|
[`notebook-papers.ipynb`](notebook-papers.ipynb) ను తెరిచి పై నుండి క్రింద వరకు చదవండి. మీరు సెల్స్ను కూడా నడిపించవచ్చు, మరియు చివరలో మేము మీ కోసం వదిలిన కొన్ని ఛాలెంజ్లను చేయవచ్చు.
|
|
|
|
|
|
|
|
|
|
|
|
## చిత్ర డేటా ప్రాసెసింగ్
|
|
|
|
|
|
ఇటీవల, చిత్రాలను అర్థం చేసుకునే శక్తివంతమైన AI మోడల్స్ అభివృద్ధి చేయబడ్డాయి. ప్రీ-ట్రెయిన్డ్ న్యూరల్ నెట్వర్క్లు లేదా క్లౌడ్ సర్వీసులు ఉపయోగించి అనేక పనులను పరిష్కరించవచ్చు. కొన్ని ఉదాహరణలు:
|
|
|
|
|
|
* **చిత్ర వర్గీకరణ**, ఇది చిత్రాన్ని ముందుగా నిర్వచించిన వర్గాలలో ఒకటిగా వర్గీకరించడంలో సహాయపడుతుంది. మీరు [Custom Vision](https://azure.microsoft.com/services/cognitive-services/custom-vision-service/?WT.mc_id=academic-77958-bethanycheum) వంటి సర్వీసులను ఉపయోగించి మీ స్వంత చిత్ర వర్గీకరణలను సులభంగా శిక్షణ ఇవ్వవచ్చు
|
|
|
* **వస్తు గుర్తింపు** చిత్రంలో వివిధ వస్తువులను గుర్తించడానికి. [computer vision](https://azure.microsoft.com/services/cognitive-services/computer-vision/?WT.mc_id=academic-77958-bethanycheum) వంటి సర్వీసులు సాధారణ వస్తువులను గుర్తించగలవు, మరియు మీరు కొన్ని ప్రత్యేక వస్తువులను గుర్తించడానికి [Custom Vision](https://azure.microsoft.com/services/cognitive-services/custom-vision-service/?WT.mc_id=academic-77958-bethanycheum) మోడల్ను శిక్షణ ఇవ్వవచ్చు.
|
|
|
* **ముఖం గుర్తింపు**, వయస్సు, లింగం మరియు భావోద్వేగ గుర్తింపుతో సహా. ఇది [Face API](https://azure.microsoft.com/services/cognitive-services/face/?WT.mc_id=academic-77958-bethanycheum) ద్వారా చేయవచ్చు.
|
|
|
|
|
|
అన్ని ఆ క్లౌడ్ సర్వీసులను [Python SDKs](https://docs.microsoft.com/samples/azure-samples/cognitive-services-python-sdk-samples/cognitive-services-python-sdk-samples/?WT.mc_id=academic-77958-bethanycheum) ఉపయోగించి పిలవవచ్చు, కాబట్టి అవి మీ డేటా అన్వేషణ వర్క్ఫ్లోలో సులభంగా చేర్చుకోవచ్చు.
|
|
|
|
|
|
ఇక్కడ చిత్ర డేటా మూలాల నుండి డేటాను అన్వేషించే కొన్ని ఉదాహరణలు ఉన్నాయి:
|
|
|
* [How to Learn Data Science without Coding](https://soshnikov.com/azure/how-to-learn-data-science-without-coding/) అనే బ్లాగ్ పోస్ట్లో మనం Instagram ఫోటోలని అన్వేషించి, ఫోటోకు ఎక్కువ లైక్స్ రావడానికి కారణమేమిటో అర్థం చేసుకోవడానికి ప్రయత్నిస్తాము. మొదట [computer vision](https://azure.microsoft.com/services/cognitive-services/computer-vision/?WT.mc_id=academic-77958-bethanycheum) ఉపయోగించి చిత్రాల నుండి ఎక్కువ సమాచారం ఎగుమతి చేస్తాము, తరువాత [Azure Machine Learning AutoML](https://docs.microsoft.com/azure/machine-learning/concept-automated-ml/?WT.mc_id=academic-77958-bethanycheum) ఉపయోగించి అర్థం చేసుకునే మోడల్ను నిర్మిస్తాము.
|
|
|
* [Facial Studies Workshop](https://github.com/CloudAdvocacy/FaceStudies)లో మనం [Face API](https://azure.microsoft.com/services/cognitive-services/face/?WT.mc_id=academic-77958-bethanycheum) ఉపయోగించి ఈవెంట్ల ఫోటోలలోని వ్యక్తుల భావోద్వేగాలను ఎగుమతి చేసి, ప్రజలను సంతోషంగా చేసే అంశాలను అర్థం చేసుకోవడానికి ప్రయత్నిస్తాము.
|
|
|
|
|
|
## ముగింపు
|
|
|
|
|
|
మీకు ఇప్పటికే నిర్మాణాత్మక లేదా అసంఘటిత డేటా ఉన్నా, Python ఉపయోగించి మీరు డేటా ప్రాసెసింగ్ మరియు అర్థం చేసుకోవడంలో సంబంధించిన అన్ని దశలను నిర్వహించవచ్చు. ఇది డేటా ప్రాసెసింగ్ యొక్క అత్యంత అనుకూలమైన మార్గం కావచ్చు, అందుకే చాలా మంది డేటా సైంటిస్ట్లు Python ను వారి ప్రాథమిక సాధనంగా ఉపయోగిస్తారు. మీరు మీ డేటా సైన్స్ ప్రయాణంలో గంభీరంగా ఉంటే Python లో లోతుగా నేర్చుకోవడం మంచి ఆలోచన!
|
|
|
|
|
|
## [పోస్ట్-లెక్చర్ క్విజ్](https://ff-quizzes.netlify.app/en/ds/quiz/13)
|
|
|
|
|
|
## సమీక్ష & స్వీయ అధ్యయనం
|
|
|
|
|
|
**పుస్తకాలు**
|
|
|
* [Wes McKinney. Python for Data Analysis: Data Wrangling with Pandas, NumPy, and IPython](https://www.amazon.com/gp/product/1491957662)
|
|
|
|
|
|
**ఆన్లైన్ వనరులు**
|
|
|
* అధికారిక [10 minutes to Pandas](https://pandas.pydata.org/pandas-docs/stable/user_guide/10min.html) ట్యుటోరియల్
|
|
|
* [Pandas Visualization పై డాక్యుమెంటేషన్](https://pandas.pydata.org/pandas-docs/stable/user_guide/visualization.html)
|
|
|
|
|
|
**Python నేర్చుకోవడం**
|
|
|
* [Turtle Graphics మరియు Fractals తో సరదాగా Python నేర్చుకోండి](https://github.com/shwars/pycourse)
|
|
|
* [Python తో మీ మొదటి అడుగులు వేయండి](https://docs.microsoft.com/learn/paths/python-first-steps/?WT.mc_id=academic-77958-bethanycheum) [Microsoft Learn](http://learn.microsoft.com/?WT.mc_id=academic-77958-bethanycheum) లో లెర్నింగ్ పాత్
|
|
|
|
|
|
## అసైన్మెంట్
|
|
|
|
|
|
[పై ఛాలెంజ్ల కోసం మరింత వివరమైన డేటా అధ్యయనం చేయండి](assignment.md)
|
|
|
|
|
|
## క్రెడిట్స్
|
|
|
|
|
|
ఈ పాఠం ♥️ తో [Dmitry Soshnikov](http://soshnikov.com) రచించారు
|
|
|
|
|
|
---
|
|
|
|
|
|
<!-- CO-OP TRANSLATOR DISCLAIMER START -->
|
|
|
**అస్పష్టత**:
|
|
|
ఈ పత్రాన్ని AI అనువాద సేవ [Co-op Translator](https://github.com/Azure/co-op-translator) ఉపయోగించి అనువదించబడింది. మేము ఖచ్చితత్వానికి ప్రయత్నించినప్పటికీ, ఆటోమేటెడ్ అనువాదాల్లో పొరపాట్లు లేదా తప్పిదాలు ఉండవచ్చు. మూల పత్రం దాని స్వదేశీ భాషలో అధికారిక మూలంగా పరిగణించాలి. ముఖ్యమైన సమాచారానికి, ప్రొఫెషనల్ మానవ అనువాదం సిఫార్సు చేయబడుతుంది. ఈ అనువాదం వాడకంలో ఏర్పడిన ఏవైనా అపార్థాలు లేదా తప్పుదారితీసే అర్థాలు కోసం మేము బాధ్యత వహించము.
|
|
|
<!-- CO-OP TRANSLATOR DISCLAIMER END --> |
