|
|
<!--
|
|
|
CO_OP_TRANSLATOR_METADATA:
|
|
|
{
|
|
|
"original_hash": "7bfec050f4717dcc2dfd028aca9d21f3",
|
|
|
"translation_date": "2025-12-19T15:32:07+00:00",
|
|
|
"source_file": "2-Working-With-Data/07-python/README.md",
|
|
|
"language_code": "ml"
|
|
|
}
|
|
|
-->
|
|
|
# ഡാറ്റയുമായി പ്രവർത്തിക്കൽ: പൈത്തൺയും പാൻഡാസ് ലൈബ്രറിയും
|
|
|
|
|
|
|  ](../../sketchnotes/07-WorkWithPython.png) |
|
|
|
| :-------------------------------------------------------------------------------------------------------: |
|
|
|
| Python ഉപയോഗിച്ച് പ്രവർത്തിക്കൽ - _Sketchnote by [@nitya](https://twitter.com/nitya)_ |
|
|
|
|
|
|
[](https://youtu.be/dZjWOGbsN4Y)
|
|
|
|
|
|
ഡാറ്റാബേസുകൾ ഡാറ്റ സംഭരിക്കാനും ക്വറി ഭാഷകൾ ഉപയോഗിച്ച് അവയെ ക്വറി ചെയ്യാനും വളരെ കാര്യക്ഷമമായ മാർഗങ്ങൾ നൽകുമ്പോഴും, ഡാറ്റ പ്രോസസ്സിംഗിന്റെ ഏറ്റവും ലവച്ഛമായ മാർഗം ഡാറ്റ കൈകാര്യം ചെയ്യാൻ നിങ്ങളുടെ സ്വന്തം പ്രോഗ്രാം എഴുതുകയാണ്. പലപ്പോഴും, ഡാറ്റാബേസ് ക്വറി ചെയ്യുന്നത് കൂടുതൽ ഫലപ്രദമായ മാർഗമായിരിക്കും. എന്നാൽ, കൂടുതൽ സങ്കീർണ്ണമായ ഡാറ്റ പ്രോസസ്സിംഗ് ആവശ്യമായപ്പോൾ, അത് എളുപ്പത്തിൽ SQL ഉപയോഗിച്ച് ചെയ്യാനാകില്ല.
|
|
|
ഡാറ്റ പ്രോസസ്സിംഗ് ഏതെങ്കിലും പ്രോഗ്രാമിംഗ് ഭാഷയിൽ പ്രോഗ്രാം ചെയ്യാം, പക്ഷേ ഡാറ്റ കൈകാര്യം ചെയ്യുന്നതിൽ ഉയർന്ന തലത്തിലുള്ള ചില ഭാഷകൾ ഉണ്ട്. ഡാറ്റ സയന്റിസ്റ്റുകൾ സാധാരണയായി താഴെപ്പറയുന്ന ഭാഷകളിൽ ഒന്നിനെ മുൻഗണന നൽകുന്നു:
|
|
|
|
|
|
* **[Python](https://www.python.org/)**, ഒരു പൊതുവായ പ്രോഗ്രാമിംഗ് ഭാഷ, അതിന്റെ ലളിതത്വം കാരണം തുടക്കക്കാർക്ക് ഏറ്റവും മികച്ച ഓപ്ഷനുകളിൽ ഒന്നായി പരിഗണിക്കപ്പെടുന്നു. Python-ന് നിരവധി അധിക ലൈബ്രറികൾ ഉണ്ട്, ഉദാഹരണത്തിന് ZIP ആർക്കൈവ് നിന്ന് ഡാറ്റ എടുക്കൽ, അല്ലെങ്കിൽ ചിത്രം ഗ്രേസ്കെയിലിലേക്ക് മാറ്റൽ പോലുള്ള പ്രായോഗിക പ്രശ്നങ്ങൾ പരിഹരിക്കാൻ സഹായിക്കുന്നവ. ഡാറ്റ സയൻസിനൊപ്പം, Python വെബ് ഡെവലപ്പ്മെന്റിനും വ്യാപകമായി ഉപയോഗിക്കുന്നു.
|
|
|
* **[R](https://www.r-project.org/)**, പാരമ്പര്യമായ ഒരു ടൂൾബോക്സ്, സ്റ്റാറ്റിസ്റ്റിക്കൽ ഡാറ്റ പ്രോസസ്സിംഗിനായി വികസിപ്പിച്ചിരിക്കുന്നു. ഇതിൽ വലിയ ലൈബ്രറി സംഭരണം (CRAN) ഉണ്ട്, ഇത് ഡാറ്റ പ്രോസസ്സിംഗിന് നല്ലൊരു തിരഞ്ഞെടുപ്പാണ്. എന്നാൽ, R ഒരു പൊതുവായ പ്രോഗ്രാമിംഗ് ഭാഷയല്ല, ഡാറ്റ സയൻസ് മേഖലയ്ക്ക് പുറത്തു അപൂർവമായി മാത്രമേ ഉപയോഗിക്കപ്പെടൂ.
|
|
|
* **[Julia](https://julialang.org/)**, ഡാറ്റ സയൻസിനായി പ്രത്യേകമായി വികസിപ്പിച്ച മറ്റൊരു ഭാഷ. Python-നേക്കാൾ മികച്ച പ്രകടനം നൽകാൻ ഉദ്ദേശിച്ചിരിക്കുന്നു, ശാസ്ത്രീയ പരീക്ഷണങ്ങൾക്ക് മികച്ച ഉപകരണം.
|
|
|
|
|
|
ഈ പാഠത്തിൽ, നാം ലളിതമായ ഡാറ്റ പ്രോസസ്സിംഗിനായി Python ഉപയോഗിക്കുന്നതിൽ ശ്രദ്ധ കേന്ദ്രീകരിക്കും. ഭാഷയുടെ അടിസ്ഥാന പരിചയം ഉണ്ടെന്ന് നാം കരുതുന്നു. Python-ന്റെ കൂടുതൽ വിശദമായ പഠനത്തിന്, താഴെപ്പറയുന്ന സ്രോതസുകളിൽ ഒന്നിനെ കാണാം:
|
|
|
|
|
|
* [Learn Python in a Fun Way with Turtle Graphics and Fractals](https://github.com/shwars/pycourse) - GitHub-അധിഷ്ഠിത Python പ്രോഗ്രാമിംഗിന്റെ വേഗത്തിലുള്ള പരിചയക്കുറിപ്പ്
|
|
|
* [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/) സാധാരണയായി Python-ൽ പല സാധാരണ ജോലികൾക്കുള്ള നിരവധി പ്രയോജനകരമായ കോഡ് സാമ്പിളുകൾ അടങ്ങിയിരിക്കുന്നു.
|
|
|
|
|
|
|
|
|
|
|
|
## [പ്രീ-ലെക്ചർ ക്വിസ്](https://ff-quizzes.netlify.app/en/ds/quiz/12)
|
|
|
|
|
|
## ടാബുലർ ഡാറ്റയും ഡാറ്റാഫ്രെയിമുകളും
|
|
|
|
|
|
റിലേഷണൽ ഡാറ്റാബേസുകൾക്കുറിച്ച് സംസാരിക്കുമ്പോൾ നിങ്ങൾ ടാബുലർ ഡാറ്റ നേരത്തെ കണ്ടിട്ടുണ്ട്. നിങ്ങൾക്ക് വലിയ ഡാറ്റ ഉണ്ടെങ്കിൽ, അത് പല വ്യത്യസ്ത ബന്ധമുള്ള പട്ടികകളിൽ ഉൾക്കൊള്ളുന്നുവെങ്കിൽ, അതുമായി പ്രവർത്തിക്കാൻ SQL ഉപയോഗിക്കുന്നത് തീർച്ചയായും ഉചിതമാണ്. എന്നാൽ, പലപ്പോഴും നമുക്ക് ഒരു ഡാറ്റ പട്ടിക ഉണ്ടാകുമ്പോൾ, ആ ഡാറ്റയെക്കുറിച്ച് ചില **അർത്ഥം** അല്ലെങ്കിൽ **അവബോധം** നേടേണ്ടതുണ്ടാകാം, ഉദാഹരണത്തിന് വിതരണവും മൂല്യങ്ങൾ തമ്മിലുള്ള സഹബന്ധവും. ഡാറ്റ സയൻസിൽ, നാം പലപ്പോഴും മൗലിക ഡാറ്റയിൽ ചില പരിവർത്തനങ്ങൾ നടത്തേണ്ടതുണ്ടാകുന്നു, തുടർന്ന് ദൃശ്യവൽക്കരണം നടത്തുന്നു. ഈ രണ്ട് ഘട്ടങ്ങളും Python ഉപയോഗിച്ച് എളുപ്പത്തിൽ ചെയ്യാം.
|
|
|
|
|
|
Python-ൽ ടാബുലർ ഡാറ്റ കൈകാര്യം ചെയ്യാൻ സഹായിക്കുന്ന ഏറ്റവും പ്രയോജനകരമായ രണ്ട് ലൈബ്രറികൾ ഉണ്ട്:
|
|
|
* **[Pandas](https://pandas.pydata.org/)**, **ഡാറ്റാഫ്രെയിമുകൾ** എന്നറിയപ്പെടുന്ന, റിലേഷണൽ പട്ടികകളോട് സമാനമായ ഘടനകളെ കൈകാര്യം ചെയ്യാൻ അനുവദിക്കുന്നു. നിങ്ങൾക്ക് നാമകരിച്ച കോളങ്ങൾ ഉണ്ടാകാം, കൂടാതെ വരി, കോളം, ഡാറ്റാഫ്രെയിമുകൾ എന്നിവയിൽ വ്യത്യസ്ത പ്രവർത്തനങ്ങൾ നടത്താം.
|
|
|
* **[Numpy](https://numpy.org/)**, **ടെൻസറുകൾ** എന്നറിയപ്പെടുന്ന, അഥവാ ബഹുമാനദണ്ഡ **അറേകൾ** കൈകാര്യം ചെയ്യാനുള്ള ലൈബ്രറി. അറേയിൽ ഒരേ തരം മൂല്യങ്ങൾ ഉണ്ടാകണം, ഇത് ഡാറ്റാഫ്രെയിമിനേക്കാൾ ലളിതമാണ്, പക്ഷേ കൂടുതൽ ഗണിത പ്രവർത്തനങ്ങൾ നൽകുന്നു, കൂടാതെ കുറവ് ഓവർഹെഡ് സൃഷ്ടിക്കുന്നു.
|
|
|
|
|
|
കൂടാതെ നിങ്ങൾ അറിയേണ്ട ചില മറ്റ് ലൈബ്രറികളും ഉണ്ട്:
|
|
|
* **[Matplotlib](https://matplotlib.org/)**, ഡാറ്റ ദൃശ്യവൽക്കരണത്തിനും ഗ്രാഫുകൾ വരയ്ക്കുന്നതിനും ഉപയോഗിക്കുന്ന ലൈബ്രറി
|
|
|
* **[SciPy](https://www.scipy.org/)**, ചില അധിക ശാസ്ത്രീയ ഫംഗ്ഷനുകൾ ഉള്ള ലൈബ്രറി. നാം ഇതിനകം പ്രൊബബിലിറ്റി, സ്റ്റാറ്റിസ്റ്റിക്സ് സംബന്ധിച്ച് സംസാരിക്കുമ്പോൾ ഈ ലൈബ്രറി കണ്ടിട്ടുണ്ട്
|
|
|
|
|
|
Python പ്രോഗ്രാമിന്റെ തുടക്കത്തിൽ ഈ ലൈബ്രറികൾ ഇമ്പോർട്ട് ചെയ്യാൻ സാധാരണയായി ഉപയോഗിക്കുന്ന കോഡ് ഇതാണ്:
|
|
|
```python
|
|
|
import numpy as np
|
|
|
import pandas as pd
|
|
|
import matplotlib.pyplot as plt
|
|
|
from scipy import ... # നിങ്ങൾക്ക് ആവശ്യമായ കൃത്യമായ സബ്-പാക്കേജുകൾ വ്യക്തമാക്കേണ്ടതാണ്
|
|
|
```
|
|
|
|
|
|
Pandas ചില അടിസ്ഥാന ആശയങ്ങൾ ചുറ്റിപ്പറ്റിയാണ്.
|
|
|
|
|
|
### സീരീസ്
|
|
|
|
|
|
**സീരീസ്** മൂല്യങ്ങളുടെ ഒരു ക്രമമാണ്, ലിസ്റ്റ് അല്ലെങ്കിൽ numpy അറേ പോലെയാണ്. പ്രധാന വ്യത്യാസം സീരീസിന് ഒരു **ഇൻഡക്സ്** ഉണ്ടാകുന്നതാണ്, സീരീസുകളിൽ പ്രവർത്തിക്കുമ്പോൾ (ഉദാ., കൂട്ടിച്ചേർക്കുമ്പോൾ) ഇൻഡക്സ് പരിഗണിക്കപ്പെടുന്നു. ഇൻഡക്സ് ലിസ്റ്റ് അല്ലെങ്കിൽ അറേയിൽ നിന്നുള്ള സീരീസ് സൃഷ്ടിക്കുമ്പോൾ ഡിഫോൾട്ട് ഉപയോഗിക്കുന്ന പൂർണ്ണസംഖ്യ വരി നമ്പർ പോലെയോ, അല്ലെങ്കിൽ തീയതി ഇടവേള പോലെയുള്ള സങ്കീർണ്ണ ഘടനയുള്ളതായിരിക്കാം.
|
|
|
|
|
|
> **കുറിപ്പ്**: സഹായി നോട്ട്ബുക്കിൽ [`notebook.ipynb`](notebook.ipynb) ചില പരിചയപരമായ Pandas കോഡ് ഉണ്ട്. ഇവിടെ നാം ചില ഉദാഹരണങ്ങൾ മാത്രം ചുരുക്കി കാണിക്കുന്നു, നിങ്ങൾക്ക് പൂർണ്ണ നോട്ട്ബുക്ക് പരിശോധിക്കാം.
|
|
|
|
|
|
ഒരു ഉദാഹരണം പരിഗണിക്കാം: നമ്മുടെ ഐസ്ക്രീം കടയുടെ വിൽപ്പന വിശകലനം ചെയ്യണം. ഒരു സമയപരിധിക്കായി വിൽപ്പന സംഖ്യകളുടെ സീരീസ് (പ്രതിദിനം വിറ്റ വസ്തുക്കളുടെ എണ്ണം) സൃഷ്ടിക്കാം:
|
|
|
|
|
|
```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 |
|
|
|
|
|
|
**കുറിപ്പ്**: നാം മുമ്പത്തെ പട്ടിക ട്രാൻസ്പോസ് ചെയ്ത് (അഥവാ `.T` ഉപയോഗിച്ച്) ഈ പട്ടിക രൂപം ലഭിക്കാമെന്ന് ശ്രദ്ധിക്കുക, ഉദാ.
|
|
|
```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` ആണ്. ബൂളിയൻ സീരീസ് ഇൻഡക്സ് ആയി ഉപയോഗിക്കുമ്പോൾ, ഡാറ്റാഫ്രെയിമിലെ വരികളുടെ ഉപസമൂഹം തിരികെ നൽകുന്നു. അതിനാൽ, സാധാരണ Python ബൂളിയൻ പ്രകടനം ഉപയോഗിക്കാനാകില്ല, ഉദാ., `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'] = "Low" if df['A'] < 5 else "Hi"
|
|
|
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-ലെ *പിവോട്ട് ടേബിളുകൾ* പോലുള്ള ഫലം ലഭിക്കാൻ സാധാരണ ഉപയോഗിക്കുന്നു. ഉദാഹരണത്തിന്, ഓരോ `LenB` മൂല്യത്തിനും `A`-യുടെ ശരാശരി കണക്കാക്കണം എങ്കിൽ, `LenB` പ്രകാരം ഗ്രൂപ്പ് ചെയ്ത് `mean` വിളിക്കാം:
|
|
|
```python
|
|
|
df.groupby(by='LenB')[['A','DivA']].mean()
|
|
|
```
|
|
|
`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')
|
|
|
```
|
|
|
|
|
|
|
|
|
ഡാറ്റ ലോഡിംഗിന്റെ കൂടുതൽ ഉദാഹരണങ്ങൾ, പുറം വെബ് സൈറ്റുകളിൽ നിന്ന് ഡാറ്റ എടുക്കുന്നതും ഉൾപ്പെടെ, "ചലഞ്ച്" വിഭാഗത്തിൽ കാണാം.
|
|
|
|
|
|
|
|
|
### പ്രിന്റിംഗ് ആൻഡ് പ്ലോട്ടിംഗ്
|
|
|
|
|
|
ഒരു ഡാറ്റ സയന്റിസ്റ്റ് പലപ്പോഴും ഡാറ്റ എക്സ്പ്ലോർ ചെയ്യേണ്ടതുണ്ടാകുന്നു, അതിനാൽ അത് ദൃശ്യവൽക്കരിക്കാൻ കഴിയുന്നത് പ്രധാനമാണ്. 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/) കാണുക.
|
|
|
|
|
|
## അസംഘടിത ഡാറ്റയുമായി പ്രവർത്തിക്കൽ
|
|
|
|
|
|
ഡാറ്റ സാധാരണയായി പട്ടിക രൂപത്തിലാണ് ലഭിക്കുന്നത്, എന്നാൽ ചില സാഹചര്യങ്ങളിൽ കുറച്ച് കുറവുള്ള ഘടനയുള്ള ഡാറ്റ, ഉദാഹരണത്തിന്, ടെക്സ്റ്റ് അല്ലെങ്കിൽ ചിത്രങ്ങൾ, കൈകാര്യം ചെയ്യേണ്ടിവരും. ഈ സാഹചര്യത്തിൽ, മുകളിൽ കണ്ട ഡാറ്റ പ്രോസസ്സിംഗ് സാങ്കേതികവിദ്യകൾ പ്രയോഗിക്കാൻ, നാം somehow **ഘടനയുള്ള** ഡാറ്റ **എക്സ്ട്രാക്റ്റ്** ചെയ്യേണ്ടതുണ്ട്. ചില ഉദാഹരണങ്ങൾ:
|
|
|
|
|
|
* ടെക്സ്റ്റിൽ നിന്നുള്ള കീവേഡുകൾ എടുക്കുകയും ആ കീവേഡുകൾ എത്രത്തോളം പ്രത്യക്ഷപ്പെടുന്നു എന്ന് കാണുകയും ചെയ്യുക
|
|
|
* ചിത്രത്തിലെ വസ്തുക്കൾ സംബന്ധിച്ച വിവരങ്ങൾ എടുക്കാൻ ന്യൂറൽ നെറ്റ്വർക്കുകൾ ഉപയോഗിക്കുക
|
|
|
* വീഡിയോ ക്യാമറ ഫീഡിൽ ആളുകളുടെ വികാരങ്ങളെക്കുറിച്ചുള്ള വിവരങ്ങൾ നേടുക
|
|
|
|
|
|
## 🚀 ചലഞ്ച് 2: COVID പേപ്പറുകൾ വിശകലനം
|
|
|
|
|
|
ഈ ചലഞ്ചിൽ, COVID മഹാമാരിയുടെ വിഷയത്തിൽ ശാസ്ത്രീയ പേപ്പറുകൾ പ്രോസസ്സ് ചെയ്യുന്നതിൽ നാം തുടരും. COVID സംബന്ധിച്ച 7000-ലധികം പേപ്പറുകൾ (എഴുതിയ സമയത്ത്) ഉള്ള [CORD-19 Dataset](https://www.kaggle.com/allen-institute-for-ai/CORD-19-research-challenge) ഉണ്ട്, മെടാഡേറ്റയും ആബ്സ്ട്രാക്റ്റുകളും ഉൾപ്പെടെ (അവയിൽ പകുതിയിലധികത്തിനും പൂർണ്ണ ടെക്സ്റ്റും ലഭ്യമാണ്).
|
|
|
|
|
|
[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/) വിശദീകരിച്ചിരിക്കുന്നു. നാം ഈ വിശകലനത്തിന്റെ ലളിതമായ പതിപ്പ് ചർച്ച ചെയ്യും.
|
|
|
|
|
|
> **കുറിപ്പ്**: ഈ റിപോസിറ്ററിയുടെ ഭാഗമായിട്ടുള്ള ഡാറ്റാസെറ്റ് നമുക്ക് നൽകുന്നില്ല. ആദ്യം [Kaggle](https://www.kaggle.com/allen-institute-for-ai/CORD-19-research-challenge) ൽ നിന്നുള്ള [`metadata.csv`](https://www.kaggle.com/allen-institute-for-ai/CORD-19-research-challenge?select=metadata.csv) ഫയൽ ഡൗൺലോഡ് ചെയ്യേണ്ടതുണ്ടാകും. 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 പഠനം**
|
|
|
* [Learn Python in a Fun Way with Turtle Graphics and Fractals](https://github.com/shwars/pycourse)
|
|
|
* [Take your First Steps with 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 --> |
