![]() |
|---|
| ืขืืืื ืขื Python - ืกืงืืฆื ืืืช @nitya |
ืืขืื ืฉืืืืจื ื ืชืื ืื ืืฆืืขืื ืืจืืื ืืขืืืืช ืืืื ืืืืกื ื ืชืื ืื ืืืืฆืข ืฉืืืืชืืช ืืืืฆืขืืช ืฉืคืืช ืฉืืืืชื, ืืืจื ืืืืืฉื ืืืืชืจ ืืขืืืื ื ืชืื ืื ืืื ืืชืืืช ืชืืื ืืช ืืฉืื ืืื ืืชืคืขื ื ืชืื ืื. ืืืงืจืื ืจืืื, ืืืฆืืข ืฉืืืืชื ืืืืืจ ื ืชืื ืื ืืืื ืืจื ืืขืืื ืืืชืจ. ืขื ืืืช, ืืืงืจืื ืฉืืื ื ืืจืฉ ืขืืืื ื ืชืื ืื ืืืจืื ืืืชืจ, ืื ื ืืชื ืืืฆืข ืืืช ืืงืืืช ืืืืฆืขืืช SQL.
ื ืืชื ืืชืื ืช ืขืืืื ื ืชืื ืื ืืื ืฉืคืช ืชืื ืืช, ืื ืืฉื ื ืฉืคืืช ืืกืืืืืช ืฉืื ืืจืื ืืืืื ืืืชืจ ืืื ืื ืืืข ืืขืืืื ืขื ื ืชืื ืื. ืืืขื ื ื ืชืื ืื ืืืจื ืืื ืืขืืืคืื ืืืช ืืืฉืคืืช ืืืืืช:
- Python, ืฉืคืช ืชืื ืืช ืืืืืช, ืฉื ืืฉืืช ืืขืืชืื ืงืจืืืืช ืืืืช ืืืคืฉืจืืืืช ืืืืืืช ืืืืชืจ ืืืชืืืืื ืืฉื ืืคืฉืืืช ืฉืื. ื-Python ืืฉ ืืจืื ืกืคืจืืืช ื ืืกืคืืช ืฉืืืืืืช ืืขืืืจ ืื ืืคืชืืจ ืืขืืืช ืืขืฉืืืช ืจืืืช, ืืื ืืืืืฅ ื ืชืื ืื ืืืจืืืื ZIP ืื ืืืจืช ืชืืื ื ืืืืื ื ืืคืืจ. ืื ืืกืฃ ืืืืขื ืื ืชืื ืื, Python ืืฉืืฉืช ืื ืืขืืชืื ืงืจืืืืช ืืคืืชืื ืืชืจืื.
- R ืืื ืืื ืืกืืจืชื ืฉืคืืชื ืขื ืขืืืื ื ืชืื ืื ืกืืืืกืืืื ืืจืืฉ. ืืื ืืืืื ืื ืืืืจ ืืืื ืฉื ืกืคืจืืืช (CRAN), ืื ืฉืืืคื ืืืชื ืืืืืจื ืืืื ืืขืืืื ื ืชืื ืื. ืขื ืืืช, R ืืื ื ืฉืคืช ืชืื ืืช ืืืืืช, ืืืื ืืฉืืฉืช ืืขืืชืื ืจืืืงืืช ืืืืฅ ืืชืืื ืืืขื ืื ืชืื ืื.
- Julia ืืื ืฉืคื ื ืืกืคืช ืฉืคืืชืื ืืืืืื ืขืืืจ ืืืขื ืื ืชืื ืื. ืืื ื ืืขืื ืืกืคืง ืืืฆืืขืื ืืืืื ืืืชืจ ื-Python, ืื ืฉืืืคื ืืืชื ืืืื ืืฆืืื ืื ืืกืืืื ืืืขืืื.
ืืฉืืขืืจ ืื, ื ืชืืงื ืืฉืืืืฉ ื-Python ืืขืืืื ื ืชืื ืื ืคืฉืื. ื ื ืื ืืืืจืืช ืืกืืกืืช ืขื ืืฉืคื. ืื ืืจืฆืื ื ืกืืืจ ืืขืืืง ืืืชืจ ื-Python, ืชืืื ืืขืืื ืืืื ืืืืฉืืืื ืืืืื:
- ืืื Python ืืืจื ืืื ื ืขื ืืจืคืืงื ืฉื ืฆื ืืคืจืงืืืื - ืงืืจืก ืืืื ืืืืจ ื-Python ืืืืกืก GitHub
- ืขืฉื ืืช ืืฆืขืืื ืืจืืฉืื ืื ืฉืื ืขื Python ืืกืืื ืืืืื ื-Microsoft Learn
ื ืชืื ืื ืืืืืื ืืืืืข ืืฆืืจืืช ืจืืืช. ืืฉืืขืืจ ืื, ื ืชืืงื ืืฉืืืฉ ืฆืืจืืช ืฉื ื ืชืื ืื - ื ืชืื ืื ืืืืืืื, ืืงืกื ืืชืืื ืืช.
ื ืชืืงื ืืืื ืืืืืืืช ืืขืืืื ื ืชืื ืื, ืืืงืื ืืชืช ืื ืกืงืืจื ืืืื ืฉื ืื ืืกืคืจืืืช ืืงืฉืืจืืช. ืื ืืืคืฉืจ ืื ืืืืื ืืช ืืจืขืืื ืืืจืืื ืฉื ืื ืืคืฉืจื, ืืืืฉืืืจ ืืืชื ืขื ืืื ื ืืืื ืืืฆืื ืคืชืจืื ืืช ืืืขืืืช ืฉืื ืืฉืืชื ืืงืืง ืืื.
ืืขืฆื ืืื ืฉืืืืฉืืช. ืืฉืืชื ืฆืจืื ืืืฆืข ืคืขืืื ืืกืืืืช ืขื ื ืชืื ืื ืฉืืื ื ืืืืข ืืืฆื ืืืฆืข, ื ืกื ืืืคืฉ ืืืชื ืืืื ืืจื ื. Stackoverflow ืืืจื ืืื ืืืื ืืจืื ืืืืืืืช ืงืื ืฉืืืืฉืืืช ื-Python ืขืืืจ ืืฉืืืืช ืืืคืืกืืืช ืจืืืช.
ืืืจ ืคืืฉืช ื ืชืื ืื ืืืืืืื ืืฉืืืืจื ื ืขื ืืืืจื ื ืชืื ืื ืืืกืืื. ืืฉืืฉ ืื ืืจืื ื ืชืื ืื, ืืื ื ืืฆืืื ืืืืืืืช ืจืืืช ืืืงืืฉืจืืช, ืืืืื ืืฉ ืืืืืื ืืืฉืชืืฉ ื-SQL ืืขืืืื ืืืชื. ืขื ืืืช, ืืฉื ื ืืงืจืื ืจืืื ืฉืืื ืืฉ ืื ื ืืืื ืฉื ื ืชืื ืื, ืืื ื ืฆืจืืืื ืืงืื ืืื ื ืื ืชืืื ืืช ืขื ืื ืชืื ืื ืืืื, ืืื ืืชืคืืืืช, ืงืืจืืฆืื ืืื ืขืจืืื, ืืื'. ืืืืขื ืื ืชืื ืื, ืืฉื ื ืืงืจืื ืจืืื ืฉืืื ืื ื ืฆืจืืืื ืืืฆืข ืืื ืืจื ืกืคืืจืืฆืืืช ืฉื ืื ืชืื ืื ืืืงืืจืืื, ืืืืืจ ืืื ืืืืืืืืืฆืื. ืฉื ื ืืฉืืืื ืืืื ืืืืืื ืืืชืืฆืข ืืงืืืช ืืืืฆืขืืช Python.
ืืฉื ื ืฉืชื ืกืคืจืืืช ืฉืืืืฉืืืช ืืืืชืจ ื-Python ืฉืืืืืืช ืืขืืืจ ืื ืืืชืืืื ืขื ื ืชืื ืื ืืืืืืื:
- Pandas ืืืคืฉืจืช ืื ืืชืคืขื Dataframes, ืฉืื ืื ืืืืืื ืืืืืืืช ืืืกืืืช. ื ืืชื ืืืืืืจ ืขืืืืืช ืขื ืฉืืืช, ืืืืฆืข ืคืขืืืืช ืฉืื ืืช ืขื ืฉืืจืืช, ืขืืืืืช ื-Dataframes ืืืืคื ืืืื.
- Numpy ืืื ืกืคืจืืื ืืขืืืื ืขื tensors, ืืืืืจ ืืขืจืืื ืจื-ืืืืืื. ืืขืจื ืืืื ืขืจืืื ืืกืื ืืกืืกื ืืื, ืืืื ืคืฉืื ืืืชืจ ื-Dataframe, ืื ืืฆืืข ืืืชืจ ืคืขืืืืช ืืชืืืืืช ืืืืฆืจ ืคืืืช ืขืืืก.
ืืฉื ื ืื ืืื ืกืคืจืืืช ื ืืกืคืืช ืฉืืืื ืืืืืจ:
- Matplotlib ืืื ืกืคืจืืื ืืืฉืืฉืช ืืืืืืืืืืฆืื ืฉื ื ืชืื ืื ืืฉืจืืื ืืจืคืื
- SciPy ืืื ืกืคืจืืื ืขื ืืื ืคืื ืงืฆืืืช ืืืขืืืช ื ืืกืคืืช. ืืืจ ื ืชืงืื ื ืืกืคืจืืื ืื ืืฉืืืืจื ื ืขื ืืกืชืืจืืช ืืกืืืืกืืืงื
ืื ื ืงืืข ืงืื ืฉืชืฉืชืืฉ ืื ืืืจื ืืื ืืื ืืืืื ืืช ืืกืคืจืืืช ืืืื ืืชืืืืช ืชืืื ืืช Python ืฉืื:
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from scipy import ... # you need to specify exact sub-packages that you needPandas ืืชืืงืืช ืืืื ืืืฉืืื ืืกืืกืืื.
Series ืืื ืจืฆืฃ ืฉื ืขืจืืื, ืืืืื ืืจืฉืืื ืื ืืขืจื numpy. ืืืืื ืืขืืงืจื ืืื ืฉ-Series ืืืืื ืื ืืื ืืงืก, ืืืฉืื ืื ื ืืืฆืขืื ืคืขืืืืช ืขื Series (ืืืฉื, ืืืกืืคืื ืืืชื), ืืืื ืืงืก ื ืืงื ืืืฉืืื. ืืืื ืืงืก ืืืื ืืืืืช ืคืฉืื ืืื ืืกืคืจ ืฉืืจื ืฉืื (ืืื ืืืื ืืงืก ืืืฉืืฉ ืืืจืืจืช ืืืื ืืขืช ืืฆืืจืช Series ืืจืฉืืื ืื ืืขืจื), ืื ืฉืืื ืืืื ืืืืืช ืืขื ืืื ื ืืืจืื, ืืื ืืจืืืื ืชืืจืืืื.
ืืขืจื: ืืฉ ืงืื ืืืื ื-Pandas ืืืืืจืช ืืืฆืืจืคืช
notebook.ipynb. ืื ื ืืฆืืื ืื ืืื ืจืง ืืื ืืืืืืืช, ืืืชื ืืืืื ืืืืื ืื ืืืืืง ืืช ืืืืืจืช ืืืืื.
ืืืืืื: ืื ื ืจืืฆืื ืื ืชื ืืืืจืืช ืฉื ืื ืืช ืืืืืื ืฉืื ื. ืืืื ื ืืฆืืจ ืกืืจืช ืืกืคืจื ืืืืจืืช (ืืกืคืจ ืืคืจืืืื ืฉื ืืืจื ืืื ืืื) ืขืืืจ ืชืงืืคืช ืืื ืืกืืืืช:
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 ืืืืืืช ื ืืกืคืืช ืฉื ืืืืื ืืืกืืื. ื ืืื ืืืฆืืจ ืกืืจื ื ืืกืคืช, ืขื ืืื ืืงืก ืืคื ืฉืืืข, ืืื ืืืืืื ืืืช:
additional_items = pd.Series(10,index=pd.date_range(start_date,end_date,freq="W"))ืืฉืื ื ืืืกืืคืื ืฉืชื ืกืืจืืช ืืื, ืื ื ืืงืืืื ืืช ืืืกืคืจ ืืืืื:
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ืืืืื ืืืืกืคื.
ืขื ืกืืจืืช ืืื, ืื ื ืืืืืื ืื ืืืืื ืืืืฉ ืืช ืืกืืจื ืขื ืืจืืืื ืืื ืฉืื ืื. ืืืืืื, ื ื ืื ืฉืื ื ืจืืฆืื ืืืฉื ืืช ืืืืฆืข ื ืคื ืืืืืจืืช ืืืืฉื. ื ืืื ืืืฉืชืืฉ ืืงืื ืืื:
monthly = total_items.resample("1M").mean()
ax = monthly.plot(kind='bar')DataFrame ืืื ืืืขืฉื ืืืกืฃ ืฉื ืกืืจืืช ืขื ืืืชื ืืื ืืงืก. ืื ื ืืืืืื ืืฉืื ืืื ืกืืจืืช ืืื ืืืฆืืจืช DataFrame:
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 |
ืื ื ืืืืืื ืื ืืืฉืชืืฉ ืืกืืจืืช ืืขืืืืืช, ืืืฆืืื ืฉืืืช ืขืืืืืช ืืืืฆืขืืช ืืืืื:
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 |
ืืขืจื ืฉืื ื ืืืืืื ืื ืืงืื ืืช ืคืจืืกืช ืืืืื ืืื ืขื ืืื ืืจื ืกืคืืืืฆืื ืฉื ืืืืื ืืงืืืืช, ืืืฉื ืขื ืืื ืืชืืื
df = pd.DataFrame([a,b]).T..rename(columns={ 0 : 'A', 1 : 'B' })ืืื .T ืืชืืืืก ืืคืขืืืช ืืืจื ืกืคืืืืฆืื ืฉื ื-DataFrame, ืืืืืจ ืฉืื ืื ืฉืืจืืช ืืขืืืืืช, ืืคืขืืืช rename ืืืคืฉืจืช ืื ื ืืฉื ืืช ืืช ืฉืืืช ืืขืืืืืช ืื ืฉืืชืืืื ืืืืืื ืืงืืืืช.
ืื ื ืืื ืืืคืขืืืืช ืืืฉืืืืช ืืืืชืจ ืฉื ืืชื ืืืฆืข ืขื DataFrames:
ืืืืจืช ืขืืืืืช. ื ืืชื ืืืืืจ ืขืืืืืช ืืืืืืช ืขื ืืื ืืชืืื df['A'] - ืคืขืืื ืื ืืืืืจื ืกืืจื. ื ืืชื ืื ืืืืืจ ืชืช-ืงืืืฆื ืฉื ืขืืืืืช ื-DataFrame ืืืจ ืขื ืืื ืืชืืื df[['B','A']] - ืคืขืืื ืื ืืืืืจื DataFrame ื ืืกืฃ.
ืกืื ืื ืฉืืจืืช ืืกืืืืืช ืืคื ืงืจืืืจืืื ืื. ืืืืืื, ืืื ืืืฉืืืจ ืจืง ืฉืืจืืช ืขื ืขืืืื A ืืืืื ื-5, ื ืืชื ืืืชืื df[df['A']>5].
ืืขืจื: ืืืจื ืฉืื ืกืื ืื ืขืืื ืืื ืืืืงืื. ืืืืืื
df['A']<5ืืืืืจ ืกืืจื ืืืืืื ืืช, ืฉืืฆืืื ืช ืืื ืืืืืื ืืืTrueืืFalseืขืืืจ ืื ืืืื ื ืืกืืจื ืืืงืืจืืชdf['A']. ืืืฉืจ ืกืืจื ืืืืืื ืืช ืืฉืืฉืช ืืืื ืืงืก, ืืื ืืืืืจื ืชืช-ืงืืืฆื ืฉื ืฉืืจืืช ื-DataFrame. ืืื, ืื ื ืืชื ืืืฉืชืืฉ ืืืืืื ืืืืืื ื ืฉืจืืจืืชื ืฉื Python, ืืืืืื, ืืชืืืdf[df['A']>5 and df['A']<7]ืชืืื ืฉืืืื. ืืืงืื ืืืช, ืืฉ ืืืฉืชืืฉ ืืคืขืืืช&ืืืืืืช ืขื ืกืืจืืช ืืืืืื ืืืช, ืืืืชืืdf[(df['A']>5) & (df['A']<7)](ืกืืืจืืื ืืฉืืืื ืืื).
ืืฆืืจืช ืขืืืืืช ืืืฉืืช ืืืืฉืื. ื ืืชื ืืืฆืืจ ืืงืืืช ืขืืืืืช ืืืฉืืช ืืืืฉืื ืขืืืจ ื-DataFrame ืฉืื ื ืืืืฆืขืืช ืืืืื ืืื ืืืืืืืื ืืื ืื:
df['DivA'] = df['A']-df['A'].mean() ืืืืื ืื ืืืฉืืช ืืช ืืกืืืื ืฉื A ืืขืจื ืืืืืฆืข ืฉืื. ืื ืฉืงืืจื ืืคืืขื ืืื ืืื ืฉืื ื ืืืฉืืื ืกืืจื, ืืื ืืงืฆืื ืืช ืืกืืจื ืืื ืืฆื ืืฉืืืื, ืืืืฆืจืื ืขืืืื ื ืืกืคืช. ืืื, ืื ื ืืชื ืืืฉืชืืฉ ืืคืขืืืืช ืฉืืื ื ืชืืืืืช ืืกืืจืืช, ืืืืืื, ืืงืื ืืื ืฉืืื:
# Wrong code -> df['ADescr'] = "Low" if df['A'] < 5 else "Hi"
df['LenB'] = len(df['B']) # <- Wrong resultืืืืืื ืืืืจืื ื, ืืืจืืช ืฉืืื ื ืืื ื ืืืืื ื ืชืืืืจืืช, ื ืืชื ืช ืื ื ืชืืฆืื ืฉืืืื, ืืืืืื ืฉืืื ืืงืฆื ืืช ืืืจื ืืกืืจื B ืืื ืืขืจืืื ืืขืืืื, ืืื ืืช ืืืจื ืืืืื ืืื ืืืืืืื ืืคื ืฉืืชืืืื ื.
ืื ืื ื ืฆืจืืืื ืืืฉื ืืืืืืื ืืืจืืืื ืืืื, ื ืืชื ืืืฉืชืืฉ ืืคืื ืงืฆืืืช apply. ืืืืืื ืืืืจืื ื ืืืืื ืืืืืชื ืื:
df['LenB'] = df['B'].apply(lambda x : len(x))
# or
df['LenB'] = df['B'].apply(len)ืืืืจ ืืคืขืืืืช ืืขืื, ื ืงืื ืืช ื-DataFrame ืืื:
| 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 ืืฉืืจืืช ืืจืืฉืื ืืช ืื-DataFrame:
df.iloc[:5]ืงืืืืฅ ืืฉืืฉ ืืขืืชืื ืงืจืืืืช ืืงืืืช ืชืืฆืื ืืืื ื-ืืืืืืช ืฆืืจ ื-Excel. ื ื ืื ืฉืื ื ืจืืฆืื ืืืฉื ืืช ืขืจื ืืืืืฆืข ืฉื ืขืืืื A ืขืืืจ ืื ืืกืคืจ ื ืชืื ืฉื LenB. ืื ื ืืื ืืงืืฅ ืืช ื-DataFrame ืฉืื ื ืืคื LenB, ืืืงืจืื ื-mean:
df.groupby(by='LenB')[['A','DivA']].mean()ืื ืื ื ืฆืจืืืื ืืืฉื ืืืืฆืข ืืืกืคืจ ืืืืื ืืื ืืงืืืฆื, ืื ื ืืื ืืืฉืชืืฉ ืืคืื ืงืฆืืืช aggregate ืืืจืืืช ืืืชืจ:
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 |
ืจืืื ื ืืื ืงื ืืืฆืืจ Series ื-DataFrames ืืืืืืืงืืื ืฉื Python. ืขื ืืืช, ื ืชืื ืื ืืืจื ืืื ืืืืขืื ืืฆืืจื ืฉื ืงืืืฅ ืืงืกื ืื ืืืืช Excel. ืืืจืื ืืืื, Pandas ืืฆืืขื ืืจื ืคืฉืืื ืืืขืื ื ืชืื ืื ืืืืืกืง. ืืืืืื, ืงืจืืืช ืงืืืฅ CSV ืืื ืคืฉืืื ืืื ืื:
df = pd.read_csv('file.csv')ื ืจืื ืืืืืืืช ื ืืกืคืืช ืืืขืื ืช ื ืชืื ืื, ืืืื ืืืืชื ืืืชืจืื ืืืฆืื ืืื, ืืืืง "ืืชืืจ".
ืืืขื ื ืชืื ืื ืืขืืชืื ืงืจืืืืช ืฆืจืื ืืืงืืจ ืืช ืื ืชืื ืื, ืืืื ืืฉืื ืืืืืช ืืกืืื ืืืฆืื ืืืชื ืืฆืืจื ืืืืชืืช. ืืืฉืจ DataFrame ืืืื, ืคืขืืื ืจืืืช ืื ื ืจืืฆืื ืจืง ืืืืื ืฉืื ืื ื ืขืืฉืื ืืื ื ืืื ืขื ืืื ืืืคืกืช ืืฉืืจืืช ืืจืืฉืื ืืช. ื ืืชื ืืขืฉืืช ืืืช ืขื ืืื ืงืจืืื ื-df.head(). ืื ืืชื ืืจืืฆืื ืืืช ืืชืื Jupyter Notebook, ืื ืืืคืืก ืืช ื-DataFrame ืืฆืืจื ืืืืืืช ืืคื.
ืืื ืื, ืจืืื ื ืืช ืืฉืืืืฉ ืืคืื ืงืฆืื plot ืืื ืืืฆืื ืืจืคืืช ืขืืืืืช ืืกืืืืืช. ืืขืื ืฉ-plot ืืืื ืฉืืืืฉืืช ืืืฉืืืืช ืจืืืช ืืชืืืืช ืืกืืื ืืจืคืื ืฉืื ืื ืืืืฆืขืืช ืืคืจืืืจ kind=, ืชืืื ื ืืชื ืืืฉืชืืฉ ืืกืคืจืืืช matplotlib ืืืืืืืช ืืื ืืืฆืืจ ืืจืคืื ืืืจืืืื ืืืชืจ. ื ืขืกืืง ืืืืืืืช ื ืชืื ืื ืืคืืจืื ืืฉืืขืืจืื ื ืคืจืืื ืืงืืจืก.
ืกืงืืจื ืื ืืืกื ืืช ืืจืขืืื ืืช ืืืฉืืืื ืืืืชืจ ืฉื Pandas, ืื ืืกืคืจืืื ืขืฉืืจื ืืืื ืืืื ืืืื ืืื ืฉื ืืชื ืืขืฉืืช ืืืชื! ืขืืฉืื ื ืืืฉื ืืช ืืืืข ืืื ืืคืชืจืื ืืขืื ืกืคืฆืืคืืช.
ืืืขืื ืืจืืฉืื ื ืฉืื ื ืชืืงื ืืื ืืืืืื ื ืฉื ืืชืคืฉืืืช ืืืคืช COVID-19. ืืื ืืขืฉืืช ืืืช, ื ืฉืชืืฉ ืื ืชืื ืื ืขื ืืกืคืจ ืื ืืืงืื ืืืืื ืืช ืฉืื ืืช, ืืืกืืคืงืื ืขื ืืื Center for Systems Science and Engineering (CSSE) ื-ืืื ืืืจืกืืืช ื'ืื ืก ืืืคืงืื ืก. ืืขืจื ืื ืชืื ืื ืืืื ื-ืืืืจ GitHub ืื.
ืืืืืื ืฉืื ืื ื ืจืืฆืื ืืืืืื ืืืฆื ืืืชืืืื ืขื ื ืชืื ืื, ืื ื ืืืืื ืื ืืชืื ืืคืชืื ืืช notebook-covidspread.ipynb ืืืงืจืื ืืืชื ืืืืชืืื ืืขื ืืกืืฃ. ืชืืืื ืื ืืืจืืฅ ืชืืื ืืืขืฉืืช ืืื ืืชืืจืื ืฉืืฉืืจื ื ืืื ืืกืืฃ.
ืื ืืื ืื ืืืืขืื ืืืฆื ืืืจืืฅ ืงืื ื-Jupyter Notebook, ืขืืื ื ื-ืืืืจ ืื.
ืืขืื ืฉื ืชืื ืื ืืขืืชืื ืงืจืืืืช ืืืืขืื ืืฆืืจื ืืืืืืช, ืืืงืจืื ืืกืืืืื ืื ื ืฆืจืืืื ืืืชืืืื ืขื ื ืชืื ืื ืคืืืช ืืืื ืื, ืืืฉื ืืงืกื ืื ืชืืื ืืช. ืืืงืจื ืืื, ืืื ืืืืฉื ืืื ืืงืืช ืขืืืื ื ืชืื ืื ืฉืจืืื ื ืงืืื, ืขืืื ื ืืืืฅ ื ืชืื ืื ืืืื ืื. ืื ื ืืื ืืืืืืืช:
- ืืืืืฅ ืืืืืช ืืคืชื ืืืงืกื ืืืืืงืช ืชืืืจืืช ืืืคืขืชื
- ืฉืืืืฉ ืืจืฉืชืืช ื ืืืจืื ืื ืืืืืืฅ ืืืืข ืขื ืืืืืืงืืื ืืชืืื ื
- ืงืืืช ืืืืข ืขื ืจืืฉืืช ืฉื ืื ืฉืื ืืืจื ืืฆืืืช ืืืืื
ืืืชืืจ ืื, ื ืืฉืื ืขื ื ืืฉื ืืืคืช COVID, ืื ืขืกืืง ืืขืืืื ืืืืจืื ืืืขืืื ืื ืืฉื. ืืฉื ื ืืขืจื ื ืชืื ืื CORD-19 ืขื ืืืชืจ ื-7000 (ืืืื ืืชืืืช ืฉืืจืืช ืืื) ืืืืจืื ืขื COVID, ืืืืื ืื ืขื ืืื-ื ืชืื ืื ืืชืงืฆืืจืื (ืืืืื ืืืืฆืืชื ืื ืืงืกื ืืื).
ืืืืื ืืืื ืื ืืชืื ืืขืจื ื ืชืื ืื ืื ืืืืฆืขืืช Text Analytics for Health ืืชืืืจืช ืืคืืกื ืืืืื ืื. ื ืืื ืืืจืกื ืคืฉืืื ืืืชืจ ืฉื ื ืืชืื ืื.
NOTE: ืืื ื ื ืืกืคืงืื ืขืืชืง ืฉื ืืขืจื ืื ืชืื ืื ืืืืง ืืืืืจ ืื. ืืืชืื ืฉืชืฆืืจืื ืืืืจืื ืชืืืื ืืช ืืงืืืฅ
metadata.csvืืืขืจื ื ืชืื ืื ืื ื-Kaggle. ืืืชืื ืฉืชืืืจืฉ ืืจืฉืื ื-Kaggle. ืชืืืื ืื ืืืืจืื ืืช ืืขืจื ืื ืชืื ืื ืืื ืืจืฉืื ืืืื, ืื ืืื ืืืืื ืืช ืื ืืืงืกืืื ืืืืืื ืื ืืกืฃ ืืงืืืฅ ืืืื-ื ืชืื ืื.
ืคืชืื ืืช notebook-papers.ipynb ืืงืจืื ืืืชื ืืืืชืืื ืืขื ืืกืืฃ. ืชืืืื ืื ืืืจืืฅ ืชืืื ืืืขืฉืืช ืืื ืืชืืจืื ืฉืืฉืืจื ื ืืื ืืกืืฃ.
ืืืืจืื ื ืคืืชืื ืืืืืื AI ืืืงืื ืืืื ืฉืืืคืฉืจืื ืื ื ืืืืื ืชืืื ืืช. ืืฉื ื ืืฉืืืืช ืจืืืช ืฉื ืืชื ืืคืชืืจ ืืืืฆืขืืช ืจืฉืชืืช ื ืืืจืื ืื ืืืื ืืช ืืจืืฉ ืื ืฉืืจืืชื ืขื ื. ืืื ืืืืืืืช ืืืืืืช:
- ืกืืืื ืชืืื ืืช, ืฉืืืื ืืขืืืจ ืืื ืืงืืื ืืช ืืชืืื ื ืืืืช ืืืงืืืืจืืืช ืืืืืืจืืช ืืจืืฉ. ื ืืชื ืืงืืืช ืืืื ืืกืืืื ืชืืื ืืช ืืฉืืื ืืืืฆืขืืช ืฉืืจืืชืื ืืื Custom Vision
- ืืืืื ืืืืืืงืืื ืืื ืืืืืช ืืืืืืงืืื ืฉืื ืื ืืชืืื ื. ืฉืืจืืชืื ืืื computer vision ืืืืืื ืืืืืช ืืกืคืจ ืืืืืืงืืื ื ืคืืฆืื, ืื ืืชื ืืืื ืืืื Custom Vision ืืืืืช ืืืืืืงืืื ืกืคืฆืืคืืื ืฉืืขื ืืื ืื ืืชืื.
- ืืืืื ืคื ืื, ืืืื ืืื, ืืืืจ ืืืืืื ืจืืฉืืช. ื ืืชื ืืขืฉืืช ืืืช ืืืืฆืขืืช Face API.
ืื ืฉืืจืืชื ืืขื ื ืืืื ืืืืืื ืืืืงืจื ืืืืฆืขืืช Python SDKs, ืืืื ื ืืชื ืืฉืืื ืืงืืืช ืืชืืืื ืืงืจ ืื ืชืื ืื ืฉืืื.
ืื ื ืืื ืืืืืืืช ืืืงืจ ื ืชืื ืื ืืืงืืจืืช ืชืืื ื:
- ืืคืืกื ืืืืื ืืื ืืืืื ืืืขื ื ืชืื ืื ืืื ืงืื ืื ื ืืืงืจืื ืชืืื ืืช ืืืื ืกืืืจื, ืื ืืกืืื ืืืืื ืื ืืืจื ืืื ืฉืื ืืชืช ืืืชืจ ืืืืงืื ืืชืืื ื. ืชืืืื ืื ื ืืืืฆืื ืืื ืฉืืืชืจ ืืืืข ืืชืืื ืืช ืืืืฆืขืืช computer vision, ืืื ืืฉืชืืฉืื ื-Azure Machine Learning AutoML ืืื ืืื ืืช ืืืื ืฉื ืืชื ืืคืจืฉ.
- ื-ืกืื ืช ืืืงืจื ืคื ืื ืื ื ืืฉืชืืฉืื ื-Face API ืืื ืืืืฅ ืจืืฉืืช ืฉื ืื ืฉืื ืืชืืื ืืช ืืืืจืืขืื, ืื ืืกืืื ืืืืื ืื ืืืจื ืืื ืฉืื ืืืืืช ืฉืืืื.
ืืื ืื ืืืจ ืืฉ ืืื ื ืชืื ืื ืืืื ืื ืื ืื ืืืื ืื, ืืืืฆืขืืช Python ืชืืืื ืืืฆืข ืืช ืื ืืฉืืืื ืืงืฉืืจืื ืืขืืืื ืืืื ืช ื ืชืื ืื. ืื ืื ืจืื ืืืจื ืืืืืฉื ืืืืชืจ ืืขืืืื ื ืชืื ืื, ืืื ืืกืืื ืฉืจืื ืืืขื ื ืื ืชืื ืื ืืฉืชืืฉืื ื-Python ืืืื ืืขืืงืจื ืฉืืื. ืืืืื Python ืืขืืืง ืื ืื ืจืื ืืืืื ืืืื ืื ืืชื ืจืฆืื ืืื ืืืื ืืืกืข ืฉืืื ืืืืขื ืื ืชืื ืื!
ืกืคืจืื
ืืฉืืืื ืืงืืื ืื
- ืืืจืื ืจืฉืื 10 ืืงืืช ื-Pandas
- ืชืืขืื ืขื ืืืืืืช ื ืชืื ืื ื-Pandas
ืืืืื Python
- ืืืื Python ืืฆืืจื ืืื ื ืขื ืืจืคืืงืช ืฆื ืืคืจืงืืืื
- ืขืฉื ืืช ืืฆืขืืื ืืจืืฉืื ืื ืฉืืื ืขื Python ืืกืืื ืืืืื ื-Microsoft Learn
ืืฆืขื ืืืงืจ ื ืชืื ืื ืืคืืจื ืืืชืจ ืขืืืจ ืืืชืืจืื ืืขืื
ืฉืืขืืจ ืื ื ืืชื ืืืืื ืขื ืืื Dmitry Soshnikov
ืืชื ืืืชืืจ:
ืืกืื ืื ืชืืจืื ืืืืฆืขืืช ืฉืืจืืช ืชืจืืื ืืืืกืก ืืื ื ืืืืืืชืืช Co-op Translator. ืืืจืืช ืฉืื ื ืฉืืืคืื ืืืืืง, ืืฉ ืืงืืช ืืืฉืืื ืฉืชืจืืืืื ืืืืืืืืื ืขืฉืืืื ืืืืื ืฉืืืืืช ืื ืื-ืืืืงืื. ืืืกืื ืืืงืืจื ืืฉืคืชื ืืืงืืจืืช ื ืืฉื ืืืงืืจ ืืกืืืืชื. ืืืืืข ืงืจืืื, ืืืืืฅ ืืืฉืชืืฉ ืืชืจืืื ืืงืฆืืขื ืขื ืืื ืื ื ืืื. ืืื ื ื ื ืืฉืืื ืืืืจืืืช ืืื ืื-ืืื ื ืื ืคืจืฉื ืืช ืฉืืืื ืื ืืืขืช ืืฉืืืืฉ ืืชืจืืื ืื.






