msb-public
/
Data-Science-For-Beginners
mirror of https://github.com/microsoft/Data-Science-For-Beginners.git
1
0
Code Issues Projects Releases Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from 'd2bec516ae'
${ noResults }
Data-Science-For-Beginners/translations/ur/2-Working-With-Data/08-data-preparation/notebook.ipynb

4241 lines
138 KiB
Raw Blame History Escape

This file contains ambiguous Unicode characters!

This file contains ambiguous Unicode characters that may be confused with others in your current locale. If your use case is intentional and legitimate, you can safely ignore this warning. Use the Escape button to highlight these characters.

{
"cells": [
{
"cell_type": "markdown",
"metadata": {
"id": "rQ8UhzFpgRra"
},
"source": [
"# ڈیٹا کی تیاری\n",
"\n",
"[اصل نوٹ بک کا ماخذ *ڈیٹا سائنس: ڈیٹا سائنس کے لیے مشین لرننگ کا تعارف، پائتھون اور مشین لرننگ اسٹوڈیو از لی اسٹاٹ*](https://github.com/leestott/intro-Datascience/blob/master/Course%20Materials/4-Cleaning_and_Manipulating-Reference.ipynb)\n",
"\n",
"## `DataFrame` کی معلومات کا جائزہ لینا\n",
"\n",
"> **سیکھنے کا مقصد:** اس ذیلی حصے کے اختتام تک، آپ pandas DataFrames میں محفوظ کردہ ڈیٹا کے بارے میں عمومی معلومات حاصل کرنے میں مہارت حاصل کر لیں گے۔\n",
"\n",
"جب آپ نے اپنا ڈیٹا pandas میں لوڈ کر لیا ہو، تو زیادہ امکان ہے کہ یہ `DataFrame` میں ہوگا۔ لیکن اگر آپ کے `DataFrame` میں موجود ڈیٹا سیٹ میں 60,000 قطاریں اور 400 کالم ہوں، تو آپ کام شروع کرنے کے لیے اس کا اندازہ کیسے لگائیں گے؟ خوش قسمتی سے، pandas کچھ آسان ٹولز فراہم کرتا ہے جو `DataFrame` کے بارے میں مجموعی معلومات کے ساتھ ساتھ ابتدائی اور آخری چند قطاروں کو جلدی دیکھنے میں مدد کرتے ہیں۔\n",
"\n",
"اس فعالیت کو دریافت کرنے کے لیے، ہم Python کی scikit-learn لائبریری درآمد کریں گے اور ایک مشہور ڈیٹا سیٹ استعمال کریں گے جسے ہر ڈیٹا سائنسدان نے سینکڑوں بار دیکھا ہے: برطانوی حیاتیات دان رونالڈ فشر کا *Iris* ڈیٹا سیٹ، جو انہوں نے 1936 کے اپنے مقالے \"The use of multiple measurements in taxonomic problems\" میں استعمال کیا تھا:\n"
]
},
{
"cell_type": "code",
"execution_count": 1,
"metadata": {
"collapsed": true,
"id": "hB1RofhdgRrp",
"trusted": false
},
"outputs": [],
"source": [
"import pandas as pd\n",
"from sklearn.datasets import load_iris\n",
"\n",
"iris = load_iris()\n",
"iris_df = pd.DataFrame(data=iris['data'], columns=iris['feature_names'])"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "AGA0A_Y8hMdz"
},
"source": [
"### `DataFrame.shape`\n",
"ہم نے Iris Dataset کو متغیر `iris_df` میں لوڈ کیا ہے۔ ڈیٹا میں گہرائی سے جانے سے پہلے یہ جاننا مفید ہوگا کہ ہمارے پاس کتنے ڈیٹا پوائنٹس ہیں اور ڈیٹا سیٹ کا مجموعی سائز کیا ہے۔ یہ دیکھنا فائدہ مند ہے کہ ہم کس حجم کے ڈیٹا سے نمٹ رہے ہیں۔\n"
]
},
{
"cell_type": "code",
"execution_count": 2,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/"
},
"id": "LOe5jQohhulf",
"outputId": "fb0577ac-3b4a-4623-cb41-20e1b264b3e9"
},
"outputs": [
{
"data": {
"text/plain": [
"(150, 4)"
]
},
"execution_count": 2,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"iris_df.shape"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "smE7AGzOhxk2"
},
"source": [
"تو، ہم 150 قطاروں اور 4 کالمز کے ڈیٹا کے ساتھ کام کر رہے ہیں۔ ہر قطار ایک ڈیٹا پوائنٹ کی نمائندگی کرتی ہے اور ہر کالم ڈیٹا فریم سے متعلق ایک خصوصیت کی نمائندگی کرتا ہے۔ تو بنیادی طور پر، یہاں 150 ڈیٹا پوائنٹس ہیں جن میں ہر ایک کے ساتھ 4 خصوصیات موجود ہیں۔\n",
"\n",
"`shape` یہاں ڈیٹا فریم کی ایک خصوصیت ہے نہ کہ ایک فنکشن، اسی لیے یہ ایک جوڑے قوسین پر ختم نہیں ہوتی۔\n"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "d3AZKs0PinGP"
},
"source": [
"### `DataFrame.columns`\n",
"اب ہم ڈیٹا کے 4 کالمز کی طرف بڑھتے ہیں۔ ہر کالم بالکل کس چیز کی نمائندگی کرتا ہے؟ `columns` ایٹریبیوٹ ہمیں ڈیٹا فریم میں کالمز کے نام فراہم کرے گا۔\n"
]
},
{
"cell_type": "code",
"execution_count": 3,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/"
},
"id": "YPGh_ziji-CY",
"outputId": "74e7a43a-77cc-4c80-da56-7f50767c37a0"
},
"outputs": [
{
"data": {
"text/plain": [
"Index(['sepal length (cm)', 'sepal width (cm)', 'petal length (cm)',\n",
" 'petal width (cm)'],\n",
" dtype='object')"
]
},
"execution_count": 3,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"iris_df.columns"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "TsobcU_VjCC_"
},
"source": [
"جیسا کہ ہم دیکھ سکتے ہیں، یہاں چار (4) کالم ہیں۔ `columns` خصوصیت ہمیں کالمز کے نام بتاتی ہے اور بنیادی طور پر کچھ اور نہیں۔ یہ خصوصیت اس وقت اہمیت اختیار کرتی ہے جب ہم یہ شناخت کرنا چاہتے ہیں کہ ایک ڈیٹاسیٹ میں کون سی خصوصیات شامل ہیں۔\n"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "2UTlvkjmgRrs"
},
"source": [
"### `DataFrame.info`\n",
"ڈیٹا کی مقدار (`shape` attribute کے ذریعے دی گئی) اور فیچرز یا کالمز کے نام (`columns` attribute کے ذریعے دیے گئے) ہمیں ڈیٹاسیٹ کے بارے میں کچھ معلومات فراہم کرتے ہیں۔ اب، ہم ڈیٹاسیٹ کو مزید گہرائی میں سمجھنا چاہیں گے۔ `DataFrame.info()` فنکشن اس کے لیے کافی مفید ہے۔\n"
]
},
{
"cell_type": "code",
"execution_count": 4,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/"
},
"id": "dHHRyG0_gRrt",
"outputId": "d8fb0c40-4f18-4e19-da48-c8db77d1d3a5",
"trusted": false
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"<class 'pandas.core.frame.DataFrame'>\n",
"RangeIndex: 150 entries, 0 to 149\n",
"Data columns (total 4 columns):\n",
" # Column Non-Null Count Dtype \n",
"--- ------ -------------- ----- \n",
" 0 sepal length (cm) 150 non-null float64\n",
" 1 sepal width (cm) 150 non-null float64\n",
" 2 petal length (cm) 150 non-null float64\n",
" 3 petal width (cm) 150 non-null float64\n",
"dtypes: float64(4)\n",
"memory usage: 4.8 KB\n"
]
}
],
"source": [
"iris_df.info()"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "1XgVMpvigRru"
},
"source": [
"یہاں سے، ہم چند مشاہدات کر سکتے ہیں:\n",
"1. ہر کالم کا DataType: اس ڈیٹا سیٹ میں، تمام ڈیٹا 64-bit floating-point نمبروں کی صورت میں محفوظ ہے۔\n",
"2. Non-Null ویلیوز کی تعداد: null ویلیوز سے نمٹنا ڈیٹا کی تیاری میں ایک اہم قدم ہے۔ اس پر بعد میں نوٹ بک میں کام کیا جائے گا۔\n"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "IYlyxbpWFEF4"
},
"source": [
"### DataFrame.describe()\n",
"فرض کریں کہ ہمارے ڈیٹا سیٹ میں بہت سا عددی ڈیٹا موجود ہے۔ یک متغیری شماریاتی حسابات جیسے اوسط، درمیانی قدر، چوتھائی وغیرہ ہر کالم پر الگ الگ کیے جا سکتے ہیں۔ `DataFrame.describe()` فنکشن ہمیں ڈیٹا سیٹ کے عددی کالمز کا شماریاتی خلاصہ فراہم کرتا ہے۔\n"
]
},
{
"cell_type": "code",
"execution_count": 5,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/",
"height": 297
},
"id": "tWV-CMstFIRA",
"outputId": "4fc49941-bc13-4b0c-a412-cb39e7d3f289"
},
"outputs": [
{
"data": {
"text/html": [
"<div>\n",
"<style scoped>\n",
" .dataframe tbody tr th:only-of-type {\n",
" vertical-align: middle;\n",
" }\n",
"\n",
" .dataframe tbody tr th {\n",
" vertical-align: top;\n",
" }\n",
"\n",
" .dataframe thead th {\n",
" text-align: right;\n",
" }\n",
"</style>\n",
"<table border=\"1\" class=\"dataframe\">\n",
" <thead>\n",
" <tr style=\"text-align: right;\">\n",
" <th></th>\n",
" <th>sepal length (cm)</th>\n",
" <th>sepal width (cm)</th>\n",
" <th>petal length (cm)</th>\n",
" <th>petal width (cm)</th>\n",
" </tr>\n",
" </thead>\n",
" <tbody>\n",
" <tr>\n",
" <th>count</th>\n",
" <td>150.000000</td>\n",
" <td>150.000000</td>\n",
" <td>150.000000</td>\n",
" <td>150.000000</td>\n",
" </tr>\n",
" <tr>\n",
" <th>mean</th>\n",
" <td>5.843333</td>\n",
" <td>3.057333</td>\n",
" <td>3.758000</td>\n",
" <td>1.199333</td>\n",
" </tr>\n",
" <tr>\n",
" <th>std</th>\n",
" <td>0.828066</td>\n",
" <td>0.435866</td>\n",
" <td>1.765298</td>\n",
" <td>0.762238</td>\n",
" </tr>\n",
" <tr>\n",
" <th>min</th>\n",
" <td>4.300000</td>\n",
" <td>2.000000</td>\n",
" <td>1.000000</td>\n",
" <td>0.100000</td>\n",
" </tr>\n",
" <tr>\n",
" <th>25%</th>\n",
" <td>5.100000</td>\n",
" <td>2.800000</td>\n",
" <td>1.600000</td>\n",
" <td>0.300000</td>\n",
" </tr>\n",
" <tr>\n",
" <th>50%</th>\n",
" <td>5.800000</td>\n",
" <td>3.000000</td>\n",
" <td>4.350000</td>\n",
" <td>1.300000</td>\n",
" </tr>\n",
" <tr>\n",
" <th>75%</th>\n",
" <td>6.400000</td>\n",
" <td>3.300000</td>\n",
" <td>5.100000</td>\n",
" <td>1.800000</td>\n",
" </tr>\n",
" <tr>\n",
" <th>max</th>\n",
" <td>7.900000</td>\n",
" <td>4.400000</td>\n",
" <td>6.900000</td>\n",
" <td>2.500000</td>\n",
" </tr>\n",
" </tbody>\n",
"</table>\n",
"</div>"
],
"text/plain": [
" sepal length (cm) sepal width (cm) petal length (cm) petal width (cm)\n",
"count 150.000000 150.000000 150.000000 150.000000\n",
"mean 5.843333 3.057333 3.758000 1.199333\n",
"std 0.828066 0.435866 1.765298 0.762238\n",
"min 4.300000 2.000000 1.000000 0.100000\n",
"25% 5.100000 2.800000 1.600000 0.300000\n",
"50% 5.800000 3.000000 4.350000 1.300000\n",
"75% 6.400000 3.300000 5.100000 1.800000\n",
"max 7.900000 4.400000 6.900000 2.500000"
]
},
"execution_count": 5,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"iris_df.describe()"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "zjjtW5hPGMuM"
},
"source": [
"اوپر دیا گیا نتیجہ ہر کالم کے کل ڈیٹا پوائنٹس، اوسط، معیاری انحراف، کم از کم، نچلا چوتھائی (25٪)، درمیانی (50٪)، اوپری چوتھائی (75٪) اور زیادہ سے زیادہ قدر کو ظاہر کرتا ہے۔\n"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "-lviAu99gRrv"
},
"source": [
"### `DataFrame.head`\n",
"تمام مذکورہ فنکشنز اور خصوصیات کے ساتھ، ہمیں ڈیٹا سیٹ کا ایک اعلیٰ سطحی جائزہ مل گیا ہے۔ ہمیں معلوم ہے کہ کتنے ڈیٹا پوائنٹس موجود ہیں، کتنی خصوصیات ہیں، ہر خصوصیت کا ڈیٹا ٹائپ کیا ہے اور ہر خصوصیت کے غیر خالی (non-null) ویلیوز کی تعداد کیا ہے۔\n",
"\n",
"اب وقت ہے کہ خود ڈیٹا کو دیکھیں۔ آئیے دیکھتے ہیں کہ ہمارے `DataFrame` کی ابتدائی چند قطاریں (ابتدائی چند ڈیٹا پوائنٹس) کیسی نظر آتی ہیں:\n"
]
},
{
"cell_type": "code",
"execution_count": 6,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/",
"height": 204
},
"id": "DZMJZh0OgRrw",
"outputId": "d9393ee5-c106-4797-f815-218f17160e00",
"trusted": false
},
"outputs": [
{
"data": {
"text/html": [
"<div>\n",
"<style scoped>\n",
" .dataframe tbody tr th:only-of-type {\n",
" vertical-align: middle;\n",
" }\n",
"\n",
" .dataframe tbody tr th {\n",
" vertical-align: top;\n",
" }\n",
"\n",
" .dataframe thead th {\n",
" text-align: right;\n",
" }\n",
"</style>\n",
"<table border=\"1\" class=\"dataframe\">\n",
" <thead>\n",
" <tr style=\"text-align: right;\">\n",
" <th></th>\n",
" <th>sepal length (cm)</th>\n",
" <th>sepal width (cm)</th>\n",
" <th>petal length (cm)</th>\n",
" <th>petal width (cm)</th>\n",
" </tr>\n",
" </thead>\n",
" <tbody>\n",
" <tr>\n",
" <th>0</th>\n",
" <td>5.1</td>\n",
" <td>3.5</td>\n",
" <td>1.4</td>\n",
" <td>0.2</td>\n",
" </tr>\n",
" <tr>\n",
" <th>1</th>\n",
" <td>4.9</td>\n",
" <td>3.0</td>\n",
" <td>1.4</td>\n",
" <td>0.2</td>\n",
" </tr>\n",
" <tr>\n",
" <th>2</th>\n",
" <td>4.7</td>\n",
" <td>3.2</td>\n",
" <td>1.3</td>\n",
" <td>0.2</td>\n",
" </tr>\n",
" <tr>\n",
" <th>3</th>\n",
" <td>4.6</td>\n",
" <td>3.1</td>\n",
" <td>1.5</td>\n",
" <td>0.2</td>\n",
" </tr>\n",
" <tr>\n",
" <th>4</th>\n",
" <td>5.0</td>\n",
" <td>3.6</td>\n",
" <td>1.4</td>\n",
" <td>0.2</td>\n",
" </tr>\n",
" </tbody>\n",
"</table>\n",
"</div>"
],
"text/plain": [
" sepal length (cm) sepal width (cm) petal length (cm) petal width (cm)\n",
"0 5.1 3.5 1.4 0.2\n",
"1 4.9 3.0 1.4 0.2\n",
"2 4.7 3.2 1.3 0.2\n",
"3 4.6 3.1 1.5 0.2\n",
"4 5.0 3.6 1.4 0.2"
]
},
"execution_count": 6,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"iris_df.head()"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "EBHEimZuEFQK"
},
"source": [
"جیسا کہ یہاں آؤٹ پٹ میں، ہم ڈیٹاسیٹ کے پانچ (5) اندراجات دیکھ سکتے ہیں۔ اگر ہم بائیں طرف کے انڈیکس کو دیکھیں، تو ہمیں پتہ چلتا ہے کہ یہ پہلی پانچ قطاریں ہیں۔\n"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "oj7GkrTdgRry"
},
"source": [
"### مشق:\n",
"\n",
"اوپر دیے گئے مثال سے یہ واضح ہے کہ، ڈیفالٹ کے طور پر، `DataFrame.head` ایک `DataFrame` کی پہلی پانچ قطاریں واپس کرتا ہے۔ نیچے دیے گئے کوڈ سیل میں، کیا آپ ایک طریقہ تلاش کر سکتے ہیں جس سے پانچ سے زیادہ قطاریں دکھائی جا سکیں؟\n"
]
},
{
"cell_type": "code",
"execution_count": 7,
"metadata": {
"collapsed": true,
"id": "EKRmRFFegRrz",
"trusted": false
},
"outputs": [],
"source": [
"# Hint: Consult the documentation by using iris_df.head?"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "BJ_cpZqNgRr1"
},
"source": [
"### `DataFrame.tail`\n",
"ڈیٹا کو دیکھنے کا ایک اور طریقہ آخر سے ہو سکتا ہے (شروع کے بجائے)۔ `DataFrame.head` کا الٹ `DataFrame.tail` ہے، جو `DataFrame` کی آخری پانچ قطاریں واپس کرتا ہے:\n"
]
},
{
"cell_type": "code",
"execution_count": 8,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/",
"height": 0
},
"id": "heanjfGWgRr2",
"outputId": "6ae09a21-fe09-4110-b0d7-1a1fbf34d7f3",
"trusted": false
},
"outputs": [
{
"data": {
"text/html": [
"<div>\n",
"<style scoped>\n",
" .dataframe tbody tr th:only-of-type {\n",
" vertical-align: middle;\n",
" }\n",
"\n",
" .dataframe tbody tr th {\n",
" vertical-align: top;\n",
" }\n",
"\n",
" .dataframe thead th {\n",
" text-align: right;\n",
" }\n",
"</style>\n",
"<table border=\"1\" class=\"dataframe\">\n",
" <thead>\n",
" <tr style=\"text-align: right;\">\n",
" <th></th>\n",
" <th>sepal length (cm)</th>\n",
" <th>sepal width (cm)</th>\n",
" <th>petal length (cm)</th>\n",
" <th>petal width (cm)</th>\n",
" </tr>\n",
" </thead>\n",
" <tbody>\n",
" <tr>\n",
" <th>145</th>\n",
" <td>6.7</td>\n",
" <td>3.0</td>\n",
" <td>5.2</td>\n",
" <td>2.3</td>\n",
" </tr>\n",
" <tr>\n",
" <th>146</th>\n",
" <td>6.3</td>\n",
" <td>2.5</td>\n",
" <td>5.0</td>\n",
" <td>1.9</td>\n",
" </tr>\n",
" <tr>\n",
" <th>147</th>\n",
" <td>6.5</td>\n",
" <td>3.0</td>\n",
" <td>5.2</td>\n",
" <td>2.0</td>\n",
" </tr>\n",
" <tr>\n",
" <th>148</th>\n",
" <td>6.2</td>\n",
" <td>3.4</td>\n",
" <td>5.4</td>\n",
" <td>2.3</td>\n",
" </tr>\n",
" <tr>\n",
" <th>149</th>\n",
" <td>5.9</td>\n",
" <td>3.0</td>\n",
" <td>5.1</td>\n",
" <td>1.8</td>\n",
" </tr>\n",
" </tbody>\n",
"</table>\n",
"</div>"
],
"text/plain": [
" sepal length (cm) sepal width (cm) petal length (cm) petal width (cm)\n",
"145 6.7 3.0 5.2 2.3\n",
"146 6.3 2.5 5.0 1.9\n",
"147 6.5 3.0 5.2 2.0\n",
"148 6.2 3.4 5.4 2.3\n",
"149 5.9 3.0 5.1 1.8"
]
},
"execution_count": 8,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"iris_df.tail()"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "31kBWfyLgRr3"
},
"source": [
"عملی طور پر، یہ فائدہ مند ہوتا ہے کہ آپ آسانی سے `DataFrame` کی ابتدائی چند قطاروں یا آخری چند قطاروں کا جائزہ لے سکیں، خاص طور پر جب آپ ترتیب شدہ ڈیٹا سیٹس میں غیر معمولی اقدار تلاش کر رہے ہوں۔\n",
"\n",
"کوڈ کی مثالوں کی مدد سے دکھائی گئی تمام فنکشنز اور خصوصیات ہمیں ڈیٹا کی جھلک اور احساس حاصل کرنے میں مدد دیتی ہیں۔\n",
"\n",
"> **خلاصہ:** صرف `DataFrame` میں موجود معلومات کے میٹا ڈیٹا یا اس کی ابتدائی اور آخری چند قدروں کو دیکھ کر ہی آپ فوری طور پر اس ڈیٹا کے حجم، شکل، اور مواد کے بارے میں ایک اندازہ لگا سکتے ہیں جس کے ساتھ آپ کام کر رہے ہیں۔\n"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "TvurZyLSDxq_"
},
"source": [
"### گمشدہ ڈیٹا\n",
"آئیے گمشدہ ڈیٹا کے بارے میں بات کرتے ہیں۔ گمشدہ ڈیٹا تب ہوتا ہے جب کچھ کالمز میں کوئی ویلیو محفوظ نہ ہو۔\n",
"\n",
"آئیے ایک مثال لیتے ہیں: فرض کریں کوئی شخص اپنے وزن کے بارے میں حساس ہے اور سروے میں وزن کا خانہ نہیں بھرتا۔ تو اس شخص کے لیے وزن کی ویلیو گمشدہ ہوگی۔\n",
"\n",
"زیادہ تر وقت، حقیقی دنیا کے ڈیٹا سیٹس میں گمشدہ ویلیوز ہوتی ہیں۔\n",
"\n",
"**پینڈاز گمشدہ ڈیٹا کو کیسے ہینڈل کرتا ہے**\n",
"\n",
"پینڈاز گمشدہ ویلیوز کو دو طریقوں سے ہینڈل کرتا ہے۔ پہلا طریقہ آپ پہلے دیکھ چکے ہیں: `NaN`، یا \"Not a Number\"۔ یہ دراصل ایک خاص ویلیو ہے جو IEEE فلوٹنگ پوائنٹ اسپیسفیکیشن کا حصہ ہے اور یہ صرف گمشدہ فلوٹنگ پوائنٹ ویلیوز کو ظاہر کرنے کے لیے استعمال ہوتی ہے۔\n",
"\n",
"فلوٹس کے علاوہ گمشدہ ویلیوز کے لیے، پینڈاز Python کے `None` آبجیکٹ کا استعمال کرتا ہے۔ اگرچہ یہ تھوڑا الجھن پیدا کر سکتا ہے کہ آپ کو دو مختلف قسم کی ویلیوز ملیں گی جو بنیادی طور پر ایک ہی بات کہتی ہیں، لیکن اس ڈیزائن کے انتخاب کے پیچھے مضبوط پروگرامنگ وجوہات ہیں۔ عملی طور پر، یہ طریقہ پینڈاز کو زیادہ تر کیسز کے لیے ایک اچھا حل فراہم کرنے کے قابل بناتا ہے۔ اس کے باوجود، `None` اور `NaN` دونوں میں کچھ پابندیاں ہیں جنہیں آپ کو ذہن میں رکھنا ہوگا کہ انہیں کیسے استعمال کیا جا سکتا ہے۔\n"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "lOHqUlZFgRr5"
},
"source": [
"### `None`: غیر فلوٹ گمشدہ ڈیٹا\n",
"چونکہ `None` Python سے آتا ہے، اسے NumPy اور pandas arrays میں استعمال نہیں کیا جا سکتا جو ڈیٹا ٹائپ `'object'` کے نہیں ہیں۔ یاد رکھیں، NumPy arrays (اور pandas میں ڈیٹا اسٹرکچرز) صرف ایک قسم کے ڈیٹا پر مشتمل ہو سکتے ہیں۔ یہی چیز انہیں بڑے پیمانے پر ڈیٹا اور حسابی کام کے لیے زبردست طاقت دیتی ہے، لیکن یہ ان کی لچک کو بھی محدود کرتی ہے۔ ایسے arrays کو \"کم از کم مشترکہ عنصر\" میں تبدیل کرنا پڑتا ہے، یعنی وہ ڈیٹا ٹائپ جو array میں موجود ہر چیز کو شامل کر سکے۔ جب array میں `None` موجود ہو، تو اس کا مطلب ہے کہ آپ Python objects کے ساتھ کام کر رہے ہیں۔\n",
"\n",
"اسے عملی طور پر دیکھنے کے لیے، درج ذیل مثال کے array پر غور کریں (اس کا `dtype` نوٹ کریں):\n"
]
},
{
"cell_type": "code",
"execution_count": 9,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/"
},
"id": "QIoNdY4ngRr7",
"outputId": "92779f18-62f4-4a03-eca2-e9a101604336",
"trusted": false
},
"outputs": [
{
"data": {
"text/plain": [
"array([2, None, 6, 8], dtype=object)"
]
},
"execution_count": 9,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"import numpy as np\n",
"\n",
"example1 = np.array([2, None, 6, 8])\n",
"example1"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "pdlgPNbhgRr7"
},
"source": [
"ڈیٹا ٹائپس کے اپکاسٹ ہونے کی حقیقت کے ساتھ دو اثرات جڑے ہوتے ہیں۔ پہلا یہ کہ آپریشنز انٹرپریٹڈ پائتھون کوڈ کی سطح پر انجام دیے جائیں گے، نہ کہ کمپائلڈ NumPy کوڈ کی سطح پر۔ بنیادی طور پر، اس کا مطلب یہ ہے کہ اگر `Series` یا `DataFrames` میں `None` موجود ہو تو ان پر کیے جانے والے آپریشنز سست ہوں گے۔ اگرچہ آپ کو یہ کارکردگی کا فرق شاید محسوس نہ ہو، لیکن بڑے ڈیٹا سیٹس کے لیے یہ مسئلہ بن سکتا ہے۔\n",
"\n",
"دوسرا اثر پہلے اثر سے جڑا ہوا ہے۔ کیونکہ `None` بنیادی طور پر `Series` یا `DataFrame`s کو واپس عام پائتھون کی دنیا میں لے جاتا ہے، اس لیے اگر آپ NumPy/pandas کے ایگریگیشن فنکشنز جیسے `sum()` یا `min()` کو ایسے arrays پر استعمال کریں جن میں ``None`` موجود ہو، تو عام طور پر ایک ایرر پیدا ہوگا:\n"
]
},
{
"cell_type": "code",
"execution_count": 10,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/",
"height": 292
},
"id": "gWbx-KB9gRr8",
"outputId": "ecba710a-22ec-41d5-a39c-11f67e645b50",
"trusted": false
},
"outputs": [
{
"ename": "TypeError",
"evalue": "ignored",
"output_type": "error",
"traceback": [
"\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
"\u001b[0;31mTypeError\u001b[0m Traceback (most recent call last)",
"\u001b[0;32m<ipython-input-10-ce9901ad18bd>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mexample1\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msum\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
"\u001b[0;32m/usr/local/lib/python3.7/dist-packages/numpy/core/_methods.py\u001b[0m in \u001b[0;36m_sum\u001b[0;34m(a, axis, dtype, out, keepdims, initial, where)\u001b[0m\n\u001b[1;32m 45\u001b[0m def _sum(a, axis=None, dtype=None, out=None, keepdims=False,\n\u001b[1;32m 46\u001b[0m initial=_NoValue, where=True):\n\u001b[0;32m---> 47\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mumr_sum\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0ma\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0maxis\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdtype\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mkeepdims\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0minitial\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mwhere\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 48\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 49\u001b[0m def _prod(a, axis=None, dtype=None, out=None, keepdims=False,\n",
"\u001b[0;31mTypeError\u001b[0m: unsupported operand type(s) for +: 'int' and 'NoneType'"
]
}
],
"source": [
"example1.sum()"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "LcEwO8UogRr9"
},
"source": [
"**اہم نکتہ**: عددی اقدار اور `None` کے درمیان جمع (اور دیگر عملیات) غیر معین ہے، جو ایسے ڈیٹا سیٹس کے ساتھ کام کرنے کی صلاحیت کو محدود کر سکتا ہے جن میں یہ موجود ہوں۔\n"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "pWvVHvETgRr9"
},
"source": [
"### `NaN`: گمشدہ فلوٹ ویلیوز\n",
"\n",
"`None` کے برعکس، NumPy (اور اسی طرح pandas) اپنے تیز، ویکٹرائزڈ آپریشنز اور ufuncs کے لیے `NaN` کو سپورٹ کرتا ہے۔ بری خبر یہ ہے کہ `NaN` پر کی جانے والی کوئی بھی حسابی کارروائی ہمیشہ `NaN` ہی دیتی ہے۔ مثال کے طور پر:\n"
]
},
{
"cell_type": "code",
"execution_count": 11,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/"
},
"id": "rcFYfMG9gRr9",
"outputId": "699e81b7-5c11-4b46-df1d-06071768690f",
"trusted": false
},
"outputs": [
{
"data": {
"text/plain": [
"nan"
]
},
"execution_count": 11,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"np.nan + 1"
]
},
{
"cell_type": "code",
"execution_count": 12,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/"
},
"id": "BW3zQD2-gRr-",
"outputId": "4525b6c4-495d-4f7b-a979-efce1dae9bd0",
"trusted": false
},
"outputs": [
{
"data": {
"text/plain": [
"nan"
]
},
"execution_count": 12,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"np.nan * 0"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "fU5IPRcCgRr-"
},
"source": [
"اچھی خبر: ایسے arrays پر aggregations چلانے سے جن میں `NaN` ہو، errors ظاہر نہیں ہوتے۔ بری خبر: نتائج یکساں طور پر مفید نہیں ہوتے:\n"
]
},
{
"cell_type": "code",
"execution_count": 13,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/"
},
"id": "LCInVgSSgRr_",
"outputId": "fa06495a-0930-4867-87c5-6023031ea8b5",
"trusted": false
},
"outputs": [
{
"data": {
"text/plain": [
"(nan, nan, nan)"
]
},
"execution_count": 13,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"example2 = np.array([2, np.nan, 6, 8]) \n",
"example2.sum(), example2.min(), example2.max()"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "nhlnNJT7gRr_"
},
"source": [
"### ورزش:\n"
]
},
{
"cell_type": "code",
"execution_count": 11,
"metadata": {
"collapsed": true,
"id": "yan3QRaOgRr_",
"trusted": false
},
"outputs": [],
"source": [
"# What happens if you add np.nan and None together?\n"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "_iDvIRC8gRsA"
},
"source": [
"یاد رکھیں: `NaN` صرف گمشدہ فلوٹنگ پوائنٹ قدروں کے لیے ہے؛ عددی، سٹرنگز یا بولینز کے لیے کوئی `NaN` متبادل نہیں ہے۔\n"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "kj6EKdsAgRsA"
},
"source": [
"### `NaN` اور `None`: pandas میں null ویلیوز\n",
"\n",
"اگرچہ `NaN` اور `None` کا رویہ کچھ مختلف ہو سکتا ہے، pandas کو اس طرح بنایا گیا ہے کہ وہ انہیں ایک دوسرے کے ساتھ استعمال کر سکے۔ اس بات کو سمجھنے کے لیے، ایک integers کی `Series` پر غور کریں:\n"
]
},
{
"cell_type": "code",
"execution_count": 15,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/"
},
"id": "Nji-KGdNgRsA",
"outputId": "36aa14d2-8efa-4bfd-c0ed-682991288822",
"trusted": false
},
"outputs": [
{
"data": {
"text/plain": [
"0 1\n",
"1 2\n",
"2 3\n",
"dtype: int64"
]
},
"execution_count": 15,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"int_series = pd.Series([1, 2, 3], dtype=int)\n",
"int_series"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "WklCzqb8gRsB"
},
"source": [
"### ورزش:\n"
]
},
{
"cell_type": "code",
"execution_count": 16,
"metadata": {
"collapsed": true,
"id": "Cy-gqX5-gRsB",
"trusted": false
},
"outputs": [],
"source": [
"# Now set an element of int_series equal to None.\n",
"# How does that element show up in the Series?\n",
"# What is the dtype of the Series?\n"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "WjMQwltNgRsB"
},
"source": [
"پینڈاز میں `Series` اور `DataFrame`s کے ڈیٹا کی یکسانیت قائم کرنے کے لیے ڈیٹا ٹائپس کو اپ کاسٹ کرنے کے عمل میں، پینڈاز آسانی سے گمشدہ اقدار کو `None` اور `NaN` کے درمیان تبدیل کر سکتا ہے۔ اس ڈیزائن فیچر کی وجہ سے، پینڈاز میں `None` اور `NaN` کو \"null\" کی دو مختلف اقسام کے طور پر سوچنا مفید ہو سکتا ہے۔ درحقیقت، پینڈاز میں گمشدہ اقدار سے نمٹنے کے لیے استعمال ہونے والے کچھ بنیادی طریقے اس خیال کو اپنے ناموں میں ظاہر کرتے ہیں:\n",
"\n",
"- `isnull()`: گمشدہ اقدار کی نشاندہی کرنے کے لیے ایک Boolean ماسک تیار کرتا ہے\n",
"- `notnull()`: `isnull()` کے برعکس کام کرتا ہے\n",
"- `dropna()`: ڈیٹا کا فلٹر شدہ ورژن واپس کرتا ہے\n",
"- `fillna()`: ڈیٹا کی ایک کاپی واپس کرتا ہے جس میں گمشدہ اقدار کو بھر دیا گیا ہو یا ان کی جگہ متبادل دی گئی ہو\n",
"\n",
"یہ طریقے سیکھنا اور ان کے ساتھ مہارت حاصل کرنا بہت ضروری ہے، تو آئیے ان میں سے ہر ایک کو تفصیل سے سمجھتے ہیں۔\n"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "Yh5ifd9FgRsB"
},
"source": [
"### خالی اقدار کا پتہ لگانا\n",
"\n",
"اب جب کہ ہم نے گمشدہ اقدار کی اہمیت کو سمجھ لیا ہے، ہمیں اپنے ڈیٹا سیٹ میں ان کا پتہ لگانا ہوگا، اس سے نمٹنے سے پہلے۔\n",
"`isnull()` اور `notnull()` دونوں خالی ڈیٹا کا پتہ لگانے کے لیے آپ کے بنیادی طریقے ہیں۔ دونوں آپ کے ڈیٹا پر Boolean ماسک واپس کرتے ہیں۔\n"
]
},
{
"cell_type": "code",
"execution_count": 17,
"metadata": {
"collapsed": true,
"id": "e-vFp5lvgRsC",
"trusted": false
},
"outputs": [],
"source": [
"example3 = pd.Series([0, np.nan, '', None])"
]
},
{
"cell_type": "code",
"execution_count": 18,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/"
},
"id": "1XdaJJ7PgRsC",
"outputId": "92fc363a-1874-471f-846d-f4f9ce1f51d0",
"trusted": false
},
"outputs": [
{
"data": {
"text/plain": [
"0 False\n",
"1 True\n",
"2 False\n",
"3 True\n",
"dtype: bool"
]
},
"execution_count": 18,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"example3.isnull()"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "PaSZ0SQygRsC"
},
"source": [
"کیا آپ کو نتیجہ دیکھ کر کوئی حیرت ہوئی؟ اگرچہ `0` ایک حسابی خالی قدر ہے، یہ پھر بھی ایک بالکل درست عدد ہے اور pandas اسے اسی طرح سمجھتا ہے۔ `''` تھوڑا زیادہ پیچیدہ ہے۔ اگرچہ ہم نے اسے سیکشن 1 میں خالی سٹرنگ ویلیو کی نمائندگی کے لیے استعمال کیا تھا، یہ پھر بھی ایک سٹرنگ آبجیکٹ ہے اور pandas کے لحاظ سے خالی قدر کی نمائندگی نہیں کرتا۔\n",
"\n",
"اب، آئیے اس کو الٹ کر دیکھتے ہیں اور ان طریقوں کو اس طرح استعمال کرتے ہیں جیسے آپ انہیں عملی طور پر استعمال کریں گے۔ آپ Boolean ماسک کو براہ راست ``Series`` یا ``DataFrame`` انڈیکس کے طور پر استعمال کر سکتے ہیں، جو الگ تھلگ خالی (یا موجود) قدروں کے ساتھ کام کرنے کی کوشش کرتے وقت مفید ہو سکتا ہے۔\n",
"\n",
"اگر ہم خالی قدروں کی کل تعداد جاننا چاہتے ہیں، تو ہم صرف `isnull()` طریقے سے پیدا ہونے والے ماسک پر ایک سم کر سکتے ہیں۔\n"
]
},
{
"cell_type": "code",
"execution_count": 19,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/"
},
"id": "JCcQVoPkHDUv",
"outputId": "001daa72-54f8-4bd5-842a-4df627a79d4d"
},
"outputs": [
{
"data": {
"text/plain": [
"2"
]
},
"execution_count": 19,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"example3.isnull().sum()"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "PlBqEo3mgRsC"
},
"source": [
"### ورزش:\n"
]
},
{
"cell_type": "code",
"execution_count": 20,
"metadata": {
"collapsed": true,
"id": "ggDVf5uygRsD",
"trusted": false
},
"outputs": [],
"source": [
"# Try running example3[example3.notnull()].\n",
"# Before you do so, what do you expect to see?\n"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "D_jWN7mHgRsD"
},
"source": [
"**اہم نکتہ**: دونوں `isnull()` اور `notnull()` طریقے ڈیٹا فریمز میں استعمال کرنے پر مشابہ نتائج پیدا کرتے ہیں: یہ نتائج اور ان نتائج کے انڈیکس کو دکھاتے ہیں، جو آپ کے ڈیٹا کے ساتھ کام کرتے وقت آپ کی بہت مدد کریں گے۔\n"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "BvnoojWsgRr4"
},
"source": [
"### گمشدہ ڈیٹا سے نمٹنا\n",
"\n",
"> **سیکھنے کا مقصد:** اس حصے کے اختتام تک، آپ کو معلوم ہونا چاہیے کہ ڈیٹا فریمز سے null ویلیوز کو کب اور کیسے تبدیل یا ہٹایا جائے۔\n",
"\n",
"مشین لرننگ ماڈلز خود گمشدہ ڈیٹا کو نہیں سنبھال سکتے۔ لہذا، ماڈل میں ڈیٹا دینے سے پہلے، ہمیں ان گمشدہ ویلیوز کو حل کرنا ہوگا۔\n",
"\n",
"گمشدہ ڈیٹا کو سنبھالنے کا طریقہ اپنے ساتھ باریک تجارتی پہلو لے کر آتا ہے، جو آپ کے حتمی تجزیے اور حقیقی دنیا کے نتائج کو متاثر کر سکتا ہے۔\n",
"\n",
"گمشدہ ڈیٹا سے نمٹنے کے بنیادی طور پر دو طریقے ہیں:\n",
"\n",
"1. گمشدہ ویلیو والی قطار کو حذف کریں\n",
"2. گمشدہ ویلیو کو کسی اور ویلیو سے تبدیل کریں\n",
"\n",
"ہم ان دونوں طریقوں اور ان کے فوائد و نقصانات کو تفصیل سے زیر بحث لائیں گے۔\n"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "3VaYC1TvgRsD"
},
"source": [
"### خالی قدروں کو ہٹانا\n",
"\n",
"جو ڈیٹا ہم اپنے ماڈل کو فراہم کرتے ہیں، اس کی مقدار براہ راست اس کی کارکردگی پر اثر ڈالتی ہے۔ خالی قدروں کو ہٹانے کا مطلب یہ ہے کہ ہم ڈیٹا پوائنٹس کی تعداد کم کر رہے ہیں، اور اس طرح ڈیٹاسیٹ کا سائز بھی کم ہو رہا ہے۔ لہٰذا، یہ مشورہ دیا جاتا ہے کہ جب ڈیٹاسیٹ کافی بڑا ہو تو خالی قدروں والی قطاروں کو ہٹا دیا جائے۔\n",
"\n",
"ایک اور صورت یہ ہو سکتی ہے کہ کسی خاص قطار یا کالم میں بہت زیادہ خالی قدریں ہوں۔ تب، انہیں ہٹایا جا سکتا ہے کیونکہ وہ ہماری تجزیے میں زیادہ قدر نہیں ڈالیں گے کیونکہ اس قطار/کالم کے زیادہ تر ڈیٹا غائب ہیں۔\n",
"\n",
"خالی قدروں کی شناخت سے آگے، pandas ایک آسان طریقہ فراہم کرتا ہے `Series` اور `DataFrame`s سے خالی قدروں کو ہٹانے کا۔ اس کو عملی طور پر دیکھنے کے لیے، آئیے `example3` پر واپس چلتے ہیں۔ `DataFrame.dropna()` فنکشن خالی قدروں والی قطاروں کو ہٹانے میں مدد کرتا ہے۔\n"
]
},
{
"cell_type": "code",
"execution_count": 21,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/"
},
"id": "7uIvS097gRsD",
"outputId": "c13fc117-4ca1-4145-a0aa-42ac89e6e218",
"trusted": false
},
"outputs": [
{
"data": {
"text/plain": [
"0 0\n",
"2 \n",
"dtype: object"
]
},
"execution_count": 21,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"example3 = example3.dropna()\n",
"example3"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "hil2cr64gRsD"
},
"source": [
"نوٹ کریں کہ یہ آپ کے `example3[example3.notnull()]` کے آؤٹ پٹ کی طرح نظر آنا چاہیے۔ یہاں فرق یہ ہے کہ، صرف ماسک شدہ اقدار پر انڈیکسنگ کرنے کے بجائے، `dropna` نے `Series` `example3` سے وہ گمشدہ اقدار ہٹا دی ہیں۔\n",
"\n",
"چونکہ DataFrames دو جہتوں کے حامل ہوتے ہیں، یہ ڈیٹا کو ہٹانے کے لیے مزید اختیارات فراہم کرتے ہیں۔\n"
]
},
{
"cell_type": "code",
"execution_count": 22,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/",
"height": 142
},
"id": "an-l74sPgRsE",
"outputId": "340876a0-63ad-40f6-bd54-6240cdae50ab",
"trusted": false
},
"outputs": [
{
"data": {
"text/html": [
"<div>\n",
"<style scoped>\n",
" .dataframe tbody tr th:only-of-type {\n",
" vertical-align: middle;\n",
" }\n",
"\n",
" .dataframe tbody tr th {\n",
" vertical-align: top;\n",
" }\n",
"\n",
" .dataframe thead th {\n",
" text-align: right;\n",
" }\n",
"</style>\n",
"<table border=\"1\" class=\"dataframe\">\n",
" <thead>\n",
" <tr style=\"text-align: right;\">\n",
" <th></th>\n",
" <th>0</th>\n",
" <th>1</th>\n",
" <th>2</th>\n",
" </tr>\n",
" </thead>\n",
" <tbody>\n",
" <tr>\n",
" <th>0</th>\n",
" <td>1.0</td>\n",
" <td>NaN</td>\n",
" <td>7</td>\n",
" </tr>\n",
" <tr>\n",
" <th>1</th>\n",
" <td>2.0</td>\n",
" <td>5.0</td>\n",
" <td>8</td>\n",
" </tr>\n",
" <tr>\n",
" <th>2</th>\n",
" <td>NaN</td>\n",
" <td>6.0</td>\n",
" <td>9</td>\n",
" </tr>\n",
" </tbody>\n",
"</table>\n",
"</div>"
],
"text/plain": [
" 0 1 2\n",
"0 1.0 NaN 7\n",
"1 2.0 5.0 8\n",
"2 NaN 6.0 9"
]
},
"execution_count": 22,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"example4 = pd.DataFrame([[1, np.nan, 7], \n",
" [2, 5, 8], \n",
" [np.nan, 6, 9]])\n",
"example4"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "66wwdHZrgRsE"
},
"source": [
"(کیا آپ نے دیکھا کہ pandas نے `NaN`s کو ایڈجسٹ کرنے کے لیے دو کالمز کو floats میں تبدیل کر دیا؟)\n",
"\n",
"آپ `DataFrame` سے ایک واحد ویلیو کو نہیں ہٹا سکتے، اس لیے آپ کو مکمل قطاریں یا کالمز ہٹانے ہوں گے۔ جو کام آپ کر رہے ہیں اس پر منحصر ہے، آپ ایک یا دوسرا انتخاب کر سکتے ہیں، اور اسی لیے pandas آپ کو دونوں کے لیے اختیارات دیتا ہے۔ کیونکہ ڈیٹا سائنس میں، کالمز عام طور پر متغیرات کی نمائندگی کرتے ہیں اور قطاریں مشاہدات کی، آپ زیادہ تر ڈیٹا کی قطاریں ہٹانے کو ترجیح دیں گے؛ `dropna()` کی ڈیفالٹ سیٹنگ یہ ہے کہ وہ تمام قطاریں ہٹا دے جو کسی بھی null ویلیو پر مشتمل ہوں:\n"
]
},
{
"cell_type": "code",
"execution_count": 23,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/",
"height": 80
},
"id": "jAVU24RXgRsE",
"outputId": "0b5e5aee-7187-4d3f-b583-a44136ae5f80",
"trusted": false
},
"outputs": [
{
"data": {
"text/html": [
"<div>\n",
"<style scoped>\n",
" .dataframe tbody tr th:only-of-type {\n",
" vertical-align: middle;\n",
" }\n",
"\n",
" .dataframe tbody tr th {\n",
" vertical-align: top;\n",
" }\n",
"\n",
" .dataframe thead th {\n",
" text-align: right;\n",
" }\n",
"</style>\n",
"<table border=\"1\" class=\"dataframe\">\n",
" <thead>\n",
" <tr style=\"text-align: right;\">\n",
" <th></th>\n",
" <th>0</th>\n",
" <th>1</th>\n",
" <th>2</th>\n",
" </tr>\n",
" </thead>\n",
" <tbody>\n",
" <tr>\n",
" <th>1</th>\n",
" <td>2.0</td>\n",
" <td>5.0</td>\n",
" <td>8</td>\n",
" </tr>\n",
" </tbody>\n",
"</table>\n",
"</div>"
],
"text/plain": [
" 0 1 2\n",
"1 2.0 5.0 8"
]
},
"execution_count": 23,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"example4.dropna()"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "TrQRBuTDgRsE"
},
"source": [
"اگر ضروری ہو، تو آپ کالمز سے NA ویلیوز کو ہٹا سکتے ہیں۔ ایسا کرنے کے لیے `axis=1` استعمال کریں:\n"
]
},
{
"cell_type": "code",
"execution_count": 24,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/",
"height": 142
},
"id": "GrBhxu9GgRsE",
"outputId": "ff4001f3-2e61-4509-d60e-0093d1068437",
"trusted": false
},
"outputs": [
{
"data": {
"text/html": [
"<div>\n",
"<style scoped>\n",
" .dataframe tbody tr th:only-of-type {\n",
" vertical-align: middle;\n",
" }\n",
"\n",
" .dataframe tbody tr th {\n",
" vertical-align: top;\n",
" }\n",
"\n",
" .dataframe thead th {\n",
" text-align: right;\n",
" }\n",
"</style>\n",
"<table border=\"1\" class=\"dataframe\">\n",
" <thead>\n",
" <tr style=\"text-align: right;\">\n",
" <th></th>\n",
" <th>2</th>\n",
" </tr>\n",
" </thead>\n",
" <tbody>\n",
" <tr>\n",
" <th>0</th>\n",
" <td>7</td>\n",
" </tr>\n",
" <tr>\n",
" <th>1</th>\n",
" <td>8</td>\n",
" </tr>\n",
" <tr>\n",
" <th>2</th>\n",
" <td>9</td>\n",
" </tr>\n",
" </tbody>\n",
"</table>\n",
"</div>"
],
"text/plain": [
" 2\n",
"0 7\n",
"1 8\n",
"2 9"
]
},
"execution_count": 24,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"example4.dropna(axis='columns')"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "KWXiKTfMgRsF"
},
"source": [
"نوٹ کریں کہ یہ بہت سا ڈیٹا ختم کر سکتا ہے جو آپ رکھنا چاہتے ہیں، خاص طور پر چھوٹے ڈیٹا سیٹس میں۔ اگر آپ صرف وہ قطاریں یا کالم ختم کرنا چاہتے ہیں جن میں کئی یا تمام null ویلیوز ہوں؟ آپ `dropna` میں `how` اور `thresh` پیرامیٹرز کے ذریعے یہ سیٹنگز متعین کرتے ہیں۔\n",
"\n",
"ڈیفالٹ طور پر، `how='any'` ہوتا ہے (اگر آپ خود چیک کرنا چاہتے ہیں یا دیکھنا چاہتے ہیں کہ اس میتھڈ کے دیگر پیرامیٹرز کیا ہیں، تو کوڈ سیل میں `example4.dropna?` چلائیں)۔ آپ متبادل طور پر `how='all'` متعین کر سکتے ہیں تاکہ صرف وہ قطاریں یا کالم ختم کیے جائیں جن میں تمام null ویلیوز ہوں۔ آئیے اپنے مثال کے `DataFrame` کو اگلی مشق میں دیکھتے ہیں تاکہ یہ عمل واضح ہو۔\n"
]
},
{
"cell_type": "code",
"execution_count": 25,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/",
"height": 142
},
"id": "Bcf_JWTsgRsF",
"outputId": "72e0b1b8-52fa-4923-98ce-b6fbed6e44b1",
"trusted": false
},
"outputs": [
{
"data": {
"text/html": [
"<div>\n",
"<style scoped>\n",
" .dataframe tbody tr th:only-of-type {\n",
" vertical-align: middle;\n",
" }\n",
"\n",
" .dataframe tbody tr th {\n",
" vertical-align: top;\n",
" }\n",
"\n",
" .dataframe thead th {\n",
" text-align: right;\n",
" }\n",
"</style>\n",
"<table border=\"1\" class=\"dataframe\">\n",
" <thead>\n",
" <tr style=\"text-align: right;\">\n",
" <th></th>\n",
" <th>0</th>\n",
" <th>1</th>\n",
" <th>2</th>\n",
" <th>3</th>\n",
" </tr>\n",
" </thead>\n",
" <tbody>\n",
" <tr>\n",
" <th>0</th>\n",
" <td>1.0</td>\n",
" <td>NaN</td>\n",
" <td>7</td>\n",
" <td>NaN</td>\n",
" </tr>\n",
" <tr>\n",
" <th>1</th>\n",
" <td>2.0</td>\n",
" <td>5.0</td>\n",
" <td>8</td>\n",
" <td>NaN</td>\n",
" </tr>\n",
" <tr>\n",
" <th>2</th>\n",
" <td>NaN</td>\n",
" <td>6.0</td>\n",
" <td>9</td>\n",
" <td>NaN</td>\n",
" </tr>\n",
" </tbody>\n",
"</table>\n",
"</div>"
],
"text/plain": [
" 0 1 2 3\n",
"0 1.0 NaN 7 NaN\n",
"1 2.0 5.0 8 NaN\n",
"2 NaN 6.0 9 NaN"
]
},
"execution_count": 25,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"example4[3] = np.nan\n",
"example4"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "pNZer7q9JPNC"
},
"source": [
"> اہم نکات:\n",
"1. null ویلیوز کو ختم کرنا صرف تب ہی اچھا خیال ہے جب ڈیٹا سیٹ کافی بڑا ہو۔\n",
"2. مکمل قطاریں یا کالم ختم کیے جا سکتے ہیں اگر ان میں زیادہ تر ڈیٹا غائب ہو۔\n",
"3. `DataFrame.dropna(axis=)` میتھڈ null ویلیوز کو ختم کرنے میں مدد کرتا ہے۔ `axis` آرگومنٹ بتاتا ہے کہ قطاریں ختم کی جائیں یا کالم۔\n",
"4. `how` آرگومنٹ بھی استعمال کیا جا سکتا ہے۔ ڈیفالٹ میں یہ `any` پر سیٹ ہوتا ہے، اس لیے یہ صرف ان قطاروں/کالموں کو ختم کرتا ہے جن میں کوئی بھی null ویلیو ہو۔ اسے `all` پر سیٹ کیا جا سکتا ہے تاکہ صرف ان قطاروں/کالموں کو ختم کیا جائے جہاں تمام ویلیوز null ہوں۔\n"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "oXXSfQFHgRsF"
},
"source": [
"### ورزش:\n"
]
},
{
"cell_type": "code",
"execution_count": 22,
"metadata": {
"collapsed": true,
"id": "ExUwQRxpgRsF",
"trusted": false
},
"outputs": [],
"source": [
"# How might you go about dropping just column 3?\n",
"# Hint: remember that you will need to supply both the axis parameter and the how parameter.\n"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "38kwAihWgRsG"
},
"source": [
"`thresh` پیرامیٹر آپ کو زیادہ باریک بینی سے کنٹرول فراہم کرتا ہے: آپ اس تعداد کو مقرر کرتے ہیں کہ ایک قطار یا ستون میں کتنی *غیر-خالی* قدریں ہونی چاہئیں تاکہ اسے برقرار رکھا جا سکے۔\n"
]
},
{
"cell_type": "code",
"execution_count": 27,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/",
"height": 80
},
"id": "M9dCNMaagRsG",
"outputId": "8093713a-54d2-4e54-c73f-4eea315cb6f2",
"trusted": false
},
"outputs": [
{
"data": {
"text/html": [
"<div>\n",
"<style scoped>\n",
" .dataframe tbody tr th:only-of-type {\n",
" vertical-align: middle;\n",
" }\n",
"\n",
" .dataframe tbody tr th {\n",
" vertical-align: top;\n",
" }\n",
"\n",
" .dataframe thead th {\n",
" text-align: right;\n",
" }\n",
"</style>\n",
"<table border=\"1\" class=\"dataframe\">\n",
" <thead>\n",
" <tr style=\"text-align: right;\">\n",
" <th></th>\n",
" <th>0</th>\n",
" <th>1</th>\n",
" <th>2</th>\n",
" <th>3</th>\n",
" </tr>\n",
" </thead>\n",
" <tbody>\n",
" <tr>\n",
" <th>1</th>\n",
" <td>2.0</td>\n",
" <td>5.0</td>\n",
" <td>8</td>\n",
" <td>NaN</td>\n",
" </tr>\n",
" </tbody>\n",
"</table>\n",
"</div>"
],
"text/plain": [
" 0 1 2 3\n",
"1 2.0 5.0 8 NaN"
]
},
"execution_count": 27,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"example4.dropna(axis='rows', thresh=3)"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "fmSFnzZegRsG"
},
"source": [
"یہاں، پہلی اور آخری قطار کو حذف کر دیا گیا ہے، کیونکہ ان میں صرف دو غیر خالی اقدار موجود ہیں۔\n"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "mCcxLGyUgRsG"
},
"source": [
"### خالی قدروں کو بھرنا\n",
"\n",
"کبھی کبھار خالی قدروں کو ایسی قدروں سے بھرنا مناسب ہوتا ہے جو ممکنہ طور پر درست ہو سکتی ہیں۔ خالی قدروں کو بھرنے کے لیے چند تکنیکیں موجود ہیں۔ پہلی تکنیک یہ ہے کہ موضوع کے علم (جس پر ڈیٹا سیٹ مبنی ہے) کا استعمال کرتے ہوئے خالی قدروں کا اندازہ لگایا جائے۔\n",
"\n",
"آپ `isnull` کا استعمال کر کے یہ کام کر سکتے ہیں، لیکن یہ خاصا محنت طلب ہو سکتا ہے، خاص طور پر اگر آپ کے پاس بھرنے کے لیے بہت سی قدریں ہوں۔ چونکہ یہ کام ڈیٹا سائنس میں بہت عام ہے، pandas `fillna` فراہم کرتا ہے، جو `Series` یا `DataFrame` کی ایک کاپی واپس کرتا ہے جس میں خالی قدریں آپ کی منتخب کردہ قدر سے بدل دی جاتی ہیں۔ آئیے ایک اور مثال `Series` بناتے ہیں تاکہ دیکھ سکیں کہ یہ عملی طور پر کیسے کام کرتا ہے۔\n"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "CE8S7louLezV"
},
"source": [
"### زمرہ بندی ڈیٹا (غیر عددی)\n",
"سب سے پہلے، آئیے غیر عددی ڈیٹا پر غور کریں۔ ڈیٹا سیٹس میں، ہمارے پاس زمرہ بندی ڈیٹا والے کالمز ہوتے ہیں۔ مثلاً جنس، صحیح یا غلط وغیرہ۔\n",
"\n",
"زیادہ تر صورتوں میں، ہم گمشدہ اقدار کو کالم کے `mode` سے بدل دیتے ہیں۔ فرض کریں، ہمارے پاس 100 ڈیٹا پوائنٹس ہیں، جن میں سے 90 نے صحیح کہا، 8 نے غلط کہا اور 2 نے کچھ نہیں بھرا۔ تو ہم ان 2 کو صحیح سے بھر سکتے ہیں، پورے کالم کو مدنظر رکھتے ہوئے۔\n",
"\n",
"یہاں بھی ہم ڈومین نالج استعمال کر سکتے ہیں۔ آئیے `mode` سے بھرنے کی ایک مثال پر غور کریں۔\n"
]
},
{
"cell_type": "code",
"execution_count": 28,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/",
"height": 204
},
"id": "MY5faq4yLdpQ",
"outputId": "19ab472e-1eed-4de8-f8a7-db2a3af3cb1a"
},
"outputs": [
{
"data": {
"text/html": [
"<div>\n",
"<style scoped>\n",
" .dataframe tbody tr th:only-of-type {\n",
" vertical-align: middle;\n",
" }\n",
"\n",
" .dataframe tbody tr th {\n",
" vertical-align: top;\n",
" }\n",
"\n",
" .dataframe thead th {\n",
" text-align: right;\n",
" }\n",
"</style>\n",
"<table border=\"1\" class=\"dataframe\">\n",
" <thead>\n",
" <tr style=\"text-align: right;\">\n",
" <th></th>\n",
" <th>0</th>\n",
" <th>1</th>\n",
" <th>2</th>\n",
" </tr>\n",
" </thead>\n",
" <tbody>\n",
" <tr>\n",
" <th>0</th>\n",
" <td>1</td>\n",
" <td>2</td>\n",
" <td>True</td>\n",
" </tr>\n",
" <tr>\n",
" <th>1</th>\n",
" <td>3</td>\n",
" <td>4</td>\n",
" <td>None</td>\n",
" </tr>\n",
" <tr>\n",
" <th>2</th>\n",
" <td>5</td>\n",
" <td>6</td>\n",
" <td>False</td>\n",
" </tr>\n",
" <tr>\n",
" <th>3</th>\n",
" <td>7</td>\n",
" <td>8</td>\n",
" <td>True</td>\n",
" </tr>\n",
" <tr>\n",
" <th>4</th>\n",
" <td>9</td>\n",
" <td>10</td>\n",
" <td>True</td>\n",
" </tr>\n",
" </tbody>\n",
"</table>\n",
"</div>"
],
"text/plain": [
" 0 1 2\n",
"0 1 2 True\n",
"1 3 4 None\n",
"2 5 6 False\n",
"3 7 8 True\n",
"4 9 10 True"
]
},
"execution_count": 28,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"fill_with_mode = pd.DataFrame([[1,2,\"True\"],\n",
" [3,4,None],\n",
" [5,6,\"False\"],\n",
" [7,8,\"True\"],\n",
" [9,10,\"True\"]])\n",
"\n",
"fill_with_mode"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "MLAoMQOfNPlA"
},
"source": [
"اب، آئیے پہلے موڈ تلاش کریں اس سے پہلے کہ `None` کی قدر کو موڈ سے بھرا جائے۔\n"
]
},
{
"cell_type": "code",
"execution_count": 29,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/"
},
"id": "WKy-9Y2tN5jv",
"outputId": "8da9fa16-e08c-447e-dea1-d4b1db2feebf"
},
"outputs": [
{
"data": {
"text/plain": [
"True 3\n",
"False 1\n",
"Name: 2, dtype: int64"
]
},
"execution_count": 29,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"fill_with_mode[2].value_counts()"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "6iNz_zG_OKrx"
},
"source": [
"تو، ہم None کو True سے بدل دیں گے۔\n"
]
},
{
"cell_type": "code",
"execution_count": 30,
"metadata": {
"id": "TxPKteRvNPOs"
},
"outputs": [],
"source": [
"fill_with_mode[2].fillna('True',inplace=True)"
]
},
{
"cell_type": "code",
"execution_count": 31,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/",
"height": 204
},
"id": "tvas7c9_OPWE",
"outputId": "ec3c8e44-d644-475e-9e22-c65101965850"
},
"outputs": [
{
"data": {
"text/html": [
"<div>\n",
"<style scoped>\n",
" .dataframe tbody tr th:only-of-type {\n",
" vertical-align: middle;\n",
" }\n",
"\n",
" .dataframe tbody tr th {\n",
" vertical-align: top;\n",
" }\n",
"\n",
" .dataframe thead th {\n",
" text-align: right;\n",
" }\n",
"</style>\n",
"<table border=\"1\" class=\"dataframe\">\n",
" <thead>\n",
" <tr style=\"text-align: right;\">\n",
" <th></th>\n",
" <th>0</th>\n",
" <th>1</th>\n",
" <th>2</th>\n",
" </tr>\n",
" </thead>\n",
" <tbody>\n",
" <tr>\n",
" <th>0</th>\n",
" <td>1</td>\n",
" <td>2</td>\n",
" <td>True</td>\n",
" </tr>\n",
" <tr>\n",
" <th>1</th>\n",
" <td>3</td>\n",
" <td>4</td>\n",
" <td>True</td>\n",
" </tr>\n",
" <tr>\n",
" <th>2</th>\n",
" <td>5</td>\n",
" <td>6</td>\n",
" <td>False</td>\n",
" </tr>\n",
" <tr>\n",
" <th>3</th>\n",
" <td>7</td>\n",
" <td>8</td>\n",
" <td>True</td>\n",
" </tr>\n",
" <tr>\n",
" <th>4</th>\n",
" <td>9</td>\n",
" <td>10</td>\n",
" <td>True</td>\n",
" </tr>\n",
" </tbody>\n",
"</table>\n",
"</div>"
],
"text/plain": [
" 0 1 2\n",
"0 1 2 True\n",
"1 3 4 True\n",
"2 5 6 False\n",
"3 7 8 True\n",
"4 9 10 True"
]
},
"execution_count": 31,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"fill_with_mode"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "SktitLxxOR16"
},
"source": [
"جیسا کہ ہم دیکھ سکتے ہیں، خالی قدر کو تبدیل کر دیا گیا ہے۔ کہنے کی ضرورت نہیں، ہم اس جگہ کچھ بھی لکھ سکتے تھے یا `'True'` اور یہ تبدیل ہو جاتا۔\n"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "heYe1I0dOmQ_"
},
"source": [
"### عددی ڈیٹا\n",
"اب، عددی ڈیٹا کی بات کرتے ہیں۔ یہاں، گمشدہ اقدار کو تبدیل کرنے کے دو عام طریقے ہیں:\n",
"\n",
"1. قطار کے میڈین سے تبدیل کریں\n",
"2. قطار کے اوسط سے تبدیل کریں\n",
"\n",
"ہم میڈین سے تبدیل کرتے ہیں، جب ڈیٹا میں آؤٹ لائرز کے ساتھ اسکیو ہوتا ہے۔ اس کی وجہ یہ ہے کہ میڈین آؤٹ لائرز کے لیے مضبوط ہے۔\n",
"\n",
"جب ڈیٹا نارملائز ہو، تو ہم اوسط استعمال کر سکتے ہیں، کیونکہ اس صورت میں اوسط اور میڈین کافی قریب ہوں گے۔\n",
"\n",
"سب سے پہلے، آئیے ایک کالم لیتے ہیں جو عام طور پر تقسیم شدہ ہے اور گمشدہ قدر کو کالم کے اوسط سے بھرتے ہیں۔\n"
]
},
{
"cell_type": "code",
"execution_count": 32,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/",
"height": 204
},
"id": "09HM_2feOj5Y",
"outputId": "7e309013-9acb-411c-9b06-4de795bbeeff"
},
"outputs": [
{
"data": {
"text/html": [
"<div>\n",
"<style scoped>\n",
" .dataframe tbody tr th:only-of-type {\n",
" vertical-align: middle;\n",
" }\n",
"\n",
" .dataframe tbody tr th {\n",
" vertical-align: top;\n",
" }\n",
"\n",
" .dataframe thead th {\n",
" text-align: right;\n",
" }\n",
"</style>\n",
"<table border=\"1\" class=\"dataframe\">\n",
" <thead>\n",
" <tr style=\"text-align: right;\">\n",
" <th></th>\n",
" <th>0</th>\n",
" <th>1</th>\n",
" <th>2</th>\n",
" </tr>\n",
" </thead>\n",
" <tbody>\n",
" <tr>\n",
" <th>0</th>\n",
" <td>-2.0</td>\n",
" <td>0</td>\n",
" <td>1</td>\n",
" </tr>\n",
" <tr>\n",
" <th>1</th>\n",
" <td>-1.0</td>\n",
" <td>2</td>\n",
" <td>3</td>\n",
" </tr>\n",
" <tr>\n",
" <th>2</th>\n",
" <td>NaN</td>\n",
" <td>4</td>\n",
" <td>5</td>\n",
" </tr>\n",
" <tr>\n",
" <th>3</th>\n",
" <td>1.0</td>\n",
" <td>6</td>\n",
" <td>7</td>\n",
" </tr>\n",
" <tr>\n",
" <th>4</th>\n",
" <td>2.0</td>\n",
" <td>8</td>\n",
" <td>9</td>\n",
" </tr>\n",
" </tbody>\n",
"</table>\n",
"</div>"
],
"text/plain": [
" 0 1 2\n",
"0 -2.0 0 1\n",
"1 -1.0 2 3\n",
"2 NaN 4 5\n",
"3 1.0 6 7\n",
"4 2.0 8 9"
]
},
"execution_count": 32,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"fill_with_mean = pd.DataFrame([[-2,0,1],\n",
" [-1,2,3],\n",
" [np.nan,4,5],\n",
" [1,6,7],\n",
" [2,8,9]])\n",
"\n",
"fill_with_mean"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "ka7-wNfzSxbx"
},
"source": [
"کالم کا اوسط ہے\n"
]
},
{
"cell_type": "code",
"execution_count": 33,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/"
},
"id": "XYtYEf5BSxFL",
"outputId": "68a78d18-f0e5-4a9a-a959-2c3676a57c70"
},
"outputs": [
{
"data": {
"text/plain": [
"0.0"
]
},
"execution_count": 33,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"np.mean(fill_with_mean[0])"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "oBSRGxKRS39K"
},
"source": [
"میان سے بھرنا\n"
]
},
{
"cell_type": "code",
"execution_count": 34,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/",
"height": 204
},
"id": "FzncQLmuS5jh",
"outputId": "00f74fff-01f4-4024-c261-796f50f01d2e"
},
"outputs": [
{
"data": {
"text/html": [
"<div>\n",
"<style scoped>\n",
" .dataframe tbody tr th:only-of-type {\n",
" vertical-align: middle;\n",
" }\n",
"\n",
" .dataframe tbody tr th {\n",
" vertical-align: top;\n",
" }\n",
"\n",
" .dataframe thead th {\n",
" text-align: right;\n",
" }\n",
"</style>\n",
"<table border=\"1\" class=\"dataframe\">\n",
" <thead>\n",
" <tr style=\"text-align: right;\">\n",
" <th></th>\n",
" <th>0</th>\n",
" <th>1</th>\n",
" <th>2</th>\n",
" </tr>\n",
" </thead>\n",
" <tbody>\n",
" <tr>\n",
" <th>0</th>\n",
" <td>-2.0</td>\n",
" <td>0</td>\n",
" <td>1</td>\n",
" </tr>\n",
" <tr>\n",
" <th>1</th>\n",
" <td>-1.0</td>\n",
" <td>2</td>\n",
" <td>3</td>\n",
" </tr>\n",
" <tr>\n",
" <th>2</th>\n",
" <td>0.0</td>\n",
" <td>4</td>\n",
" <td>5</td>\n",
" </tr>\n",
" <tr>\n",
" <th>3</th>\n",
" <td>1.0</td>\n",
" <td>6</td>\n",
" <td>7</td>\n",
" </tr>\n",
" <tr>\n",
" <th>4</th>\n",
" <td>2.0</td>\n",
" <td>8</td>\n",
" <td>9</td>\n",
" </tr>\n",
" </tbody>\n",
"</table>\n",
"</div>"
],
"text/plain": [
" 0 1 2\n",
"0 -2.0 0 1\n",
"1 -1.0 2 3\n",
"2 0.0 4 5\n",
"3 1.0 6 7\n",
"4 2.0 8 9"
]
},
"execution_count": 34,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"fill_with_mean[0].fillna(np.mean(fill_with_mean[0]),inplace=True)\n",
"fill_with_mean"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "CwpVFCrPTC5z"
},
"source": [
"جیسا کہ ہم دیکھ سکتے ہیں، گمشدہ قدر کو اس کے اوسط سے بدل دیا گیا ہے۔\n"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "jIvF13a1i00Z"
},
"source": [
"آئیے اب ایک اور ڈیٹا فریم آزمائیں، اور اس بار ہم None کی قدروں کو کالم کے درمیانی قدر سے بدل دیں گے۔\n"
]
},
{
"cell_type": "code",
"execution_count": 35,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/",
"height": 204
},
"id": "DA59Bqo3jBYZ",
"outputId": "85dae6ec-7394-4c36-fda0-e04769ec4a32"
},
"outputs": [
{
"data": {
"text/html": [
"<div>\n",
"<style scoped>\n",
" .dataframe tbody tr th:only-of-type {\n",
" vertical-align: middle;\n",
" }\n",
"\n",
" .dataframe tbody tr th {\n",
" vertical-align: top;\n",
" }\n",
"\n",
" .dataframe thead th {\n",
" text-align: right;\n",
" }\n",
"</style>\n",
"<table border=\"1\" class=\"dataframe\">\n",
" <thead>\n",
" <tr style=\"text-align: right;\">\n",
" <th></th>\n",
" <th>0</th>\n",
" <th>1</th>\n",
" <th>2</th>\n",
" </tr>\n",
" </thead>\n",
" <tbody>\n",
" <tr>\n",
" <th>0</th>\n",
" <td>-2</td>\n",
" <td>0.0</td>\n",
" <td>1</td>\n",
" </tr>\n",
" <tr>\n",
" <th>1</th>\n",
" <td>-1</td>\n",
" <td>2.0</td>\n",
" <td>3</td>\n",
" </tr>\n",
" <tr>\n",
" <th>2</th>\n",
" <td>0</td>\n",
" <td>NaN</td>\n",
" <td>5</td>\n",
" </tr>\n",
" <tr>\n",
" <th>3</th>\n",
" <td>1</td>\n",
" <td>6.0</td>\n",
" <td>7</td>\n",
" </tr>\n",
" <tr>\n",
" <th>4</th>\n",
" <td>2</td>\n",
" <td>8.0</td>\n",
" <td>9</td>\n",
" </tr>\n",
" </tbody>\n",
"</table>\n",
"</div>"
],
"text/plain": [
" 0 1 2\n",
"0 -2 0.0 1\n",
"1 -1 2.0 3\n",
"2 0 NaN 5\n",
"3 1 6.0 7\n",
"4 2 8.0 9"
]
},
"execution_count": 35,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"fill_with_median = pd.DataFrame([[-2,0,1],\n",
" [-1,2,3],\n",
" [0,np.nan,5],\n",
" [1,6,7],\n",
" [2,8,9]])\n",
"\n",
"fill_with_median"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "mM1GpXYmjHnc"
},
"source": [
"دوسرے ستون کا میڈین ہے\n"
]
},
{
"cell_type": "code",
"execution_count": 36,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/"
},
"id": "uiDy5v3xjHHX",
"outputId": "564b6b74-2004-4486-90d4-b39330a64b88"
},
"outputs": [
{
"data": {
"text/plain": [
"4.0"
]
},
"execution_count": 36,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"fill_with_median[1].median()"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "z9PLF75Jj_1s"
},
"source": [
"میڈین کے ساتھ بھرنا\n"
]
},
{
"cell_type": "code",
"execution_count": 37,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/",
"height": 204
},
"id": "lFKbOxCMkBbg",
"outputId": "a8bd18fb-2765-47d4-e5fe-e965f57ed1f4"
},
"outputs": [
{
"data": {
"text/html": [
"<div>\n",
"<style scoped>\n",
" .dataframe tbody tr th:only-of-type {\n",
" vertical-align: middle;\n",
" }\n",
"\n",
" .dataframe tbody tr th {\n",
" vertical-align: top;\n",
" }\n",
"\n",
" .dataframe thead th {\n",
" text-align: right;\n",
" }\n",
"</style>\n",
"<table border=\"1\" class=\"dataframe\">\n",
" <thead>\n",
" <tr style=\"text-align: right;\">\n",
" <th></th>\n",
" <th>0</th>\n",
" <th>1</th>\n",
" <th>2</th>\n",
" </tr>\n",
" </thead>\n",
" <tbody>\n",
" <tr>\n",
" <th>0</th>\n",
" <td>-2</td>\n",
" <td>0.0</td>\n",
" <td>1</td>\n",
" </tr>\n",
" <tr>\n",
" <th>1</th>\n",
" <td>-1</td>\n",
" <td>2.0</td>\n",
" <td>3</td>\n",
" </tr>\n",
" <tr>\n",
" <th>2</th>\n",
" <td>0</td>\n",
" <td>4.0</td>\n",
" <td>5</td>\n",
" </tr>\n",
" <tr>\n",
" <th>3</th>\n",
" <td>1</td>\n",
" <td>6.0</td>\n",
" <td>7</td>\n",
" </tr>\n",
" <tr>\n",
" <th>4</th>\n",
" <td>2</td>\n",
" <td>8.0</td>\n",
" <td>9</td>\n",
" </tr>\n",
" </tbody>\n",
"</table>\n",
"</div>"
],
"text/plain": [
" 0 1 2\n",
"0 -2 0.0 1\n",
"1 -1 2.0 3\n",
"2 0 4.0 5\n",
"3 1 6.0 7\n",
"4 2 8.0 9"
]
},
"execution_count": 37,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"fill_with_median[1].fillna(fill_with_median[1].median(),inplace=True)\n",
"fill_with_median"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "8JtQ53GSkKWC"
},
"source": [
"جیسا کہ ہم دیکھ سکتے ہیں، NaN کی قدر کو کالم کے میڈین سے تبدیل کر دیا گیا ہے۔\n"
]
},
{
"cell_type": "code",
"execution_count": 38,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/"
},
"id": "0ybtWLDdgRsG",
"outputId": "b8c238ef-6024-4ee2-be2b-aa1f0fcac61d",
"trusted": false
},
"outputs": [
{
"data": {
"text/plain": [
"a 1.0\n",
"b NaN\n",
"c 2.0\n",
"d NaN\n",
"e 3.0\n",
"dtype: float64"
]
},
"execution_count": 38,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"example5 = pd.Series([1, np.nan, 2, None, 3], index=list('abcde'))\n",
"example5"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "yrsigxRggRsH"
},
"source": [
"آپ تمام خالی اندراجات کو ایک واحد قدر، جیسے `0` سے بھر سکتے ہیں:\n"
]
},
{
"cell_type": "code",
"execution_count": 39,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/"
},
"id": "KXMIPsQdgRsH",
"outputId": "aeedfa0a-a421-4c2f-cb0d-183ce8f0c91d",
"trusted": false
},
"outputs": [
{
"data": {
"text/plain": [
"a 1.0\n",
"b 0.0\n",
"c 2.0\n",
"d 0.0\n",
"e 3.0\n",
"dtype: float64"
]
},
"execution_count": 39,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"example5.fillna(0)"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "RRlI5f_hkfKe"
},
"source": [
"> اہم نکات:\n",
"1. گمشدہ اقدار کو بھرنا تب ضروری ہوتا ہے جب یا تو ڈیٹا کم ہو یا گمشدہ ڈیٹا کو بھرنے کے لیے کوئی حکمت عملی موجود ہو۔\n",
"2. گمشدہ اقدار کو اندازے سے بھرنے کے لیے ڈومین علم کا استعمال کیا جا سکتا ہے۔\n",
"3. زمرہ جاتی ڈیٹا کے لیے، زیادہ تر گمشدہ اقدار کو کالم کے موڈ سے تبدیل کیا جاتا ہے۔\n",
"4. عددی ڈیٹا کے لیے، گمشدہ اقدار کو عام طور پر کالمز کے اوسط (نارملائزڈ ڈیٹا سیٹس کے لیے) یا میڈین سے بھرا جاتا ہے۔\n"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "FI9MmqFJgRsH"
},
"source": [
"### ورزش:\n"
]
},
{
"cell_type": "code",
"execution_count": 40,
"metadata": {
"collapsed": true,
"id": "af-ezpXdgRsH",
"trusted": false
},
"outputs": [],
"source": [
"# What happens if you try to fill null values with a string, like ''?\n"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "kq3hw1kLgRsI"
},
"source": [
"آپ null قدروں کو **آگے بھر** سکتے ہیں، یعنی آخری درست قدر کو استعمال کرتے ہوئے null کو بھرنا:\n"
]
},
{
"cell_type": "code",
"execution_count": 41,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/"
},
"id": "vO3BuNrggRsI",
"outputId": "e2bc591b-0b48-4e88-ee65-754f2737c196",
"trusted": false
},
"outputs": [
{
"data": {
"text/plain": [
"a 1.0\n",
"b 1.0\n",
"c 2.0\n",
"d 2.0\n",
"e 3.0\n",
"dtype: float64"
]
},
"execution_count": 41,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"example5.fillna(method='ffill')"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "nDXeYuHzgRsI"
},
"source": [
"آپ اگلے درست قدر کو پیچھے کی طرف پھیلانے کے لیے **بیک فل** بھی کر سکتے ہیں تاکہ ایک نل کو بھر سکیں۔\n"
]
},
{
"cell_type": "code",
"execution_count": 42,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/"
},
"id": "4M5onHcEgRsI",
"outputId": "8f32b185-40dd-4a9f-bd85-54d6b6a414fe",
"trusted": false
},
"outputs": [
{
"data": {
"text/plain": [
"a 1.0\n",
"b 2.0\n",
"c 2.0\n",
"d 3.0\n",
"e 3.0\n",
"dtype: float64"
]
},
"execution_count": 42,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"example5.fillna(method='bfill')"
]
},
{
"cell_type": "markdown",
"metadata": {
"collapsed": true,
"id": "MbBzTom5gRsI"
},
"source": [
"جیسا کہ آپ اندازہ لگا سکتے ہیں، یہ ڈیٹا فریمز کے ساتھ بھی اسی طرح کام کرتا ہے، لیکن آپ ایک `axis` بھی مخصوص کر سکتے ہیں جس کے ساتھ null قدروں کو بھرنا ہے۔\n"
]
},
{
"cell_type": "code",
"execution_count": 43,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/",
"height": 142
},
"id": "aRpIvo4ZgRsI",
"outputId": "905a980a-a808-4eca-d0ba-224bd7d85955",
"trusted": false
},
"outputs": [
{
"data": {
"text/html": [
"<div>\n",
"<style scoped>\n",
" .dataframe tbody tr th:only-of-type {\n",
" vertical-align: middle;\n",
" }\n",
"\n",
" .dataframe tbody tr th {\n",
" vertical-align: top;\n",
" }\n",
"\n",
" .dataframe thead th {\n",
" text-align: right;\n",
" }\n",
"</style>\n",
"<table border=\"1\" class=\"dataframe\">\n",
" <thead>\n",
" <tr style=\"text-align: right;\">\n",
" <th></th>\n",
" <th>0</th>\n",
" <th>1</th>\n",
" <th>2</th>\n",
" <th>3</th>\n",
" </tr>\n",
" </thead>\n",
" <tbody>\n",
" <tr>\n",
" <th>0</th>\n",
" <td>1.0</td>\n",
" <td>NaN</td>\n",
" <td>7</td>\n",
" <td>NaN</td>\n",
" </tr>\n",
" <tr>\n",
" <th>1</th>\n",
" <td>2.0</td>\n",
" <td>5.0</td>\n",
" <td>8</td>\n",
" <td>NaN</td>\n",
" </tr>\n",
" <tr>\n",
" <th>2</th>\n",
" <td>NaN</td>\n",
" <td>6.0</td>\n",
" <td>9</td>\n",
" <td>NaN</td>\n",
" </tr>\n",
" </tbody>\n",
"</table>\n",
"</div>"
],
"text/plain": [
" 0 1 2 3\n",
"0 1.0 NaN 7 NaN\n",
"1 2.0 5.0 8 NaN\n",
"2 NaN 6.0 9 NaN"
]
},
"execution_count": 43,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"example4"
]
},
{
"cell_type": "code",
"execution_count": 44,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/",
"height": 142
},
"id": "VM1qtACAgRsI",
"outputId": "71f2ad28-9b4e-4ff4-f5c3-e731eb489ade",
"trusted": false
},
"outputs": [
{
"data": {
"text/html": [
"<div>\n",
"<style scoped>\n",
" .dataframe tbody tr th:only-of-type {\n",
" vertical-align: middle;\n",
" }\n",
"\n",
" .dataframe tbody tr th {\n",
" vertical-align: top;\n",
" }\n",
"\n",
" .dataframe thead th {\n",
" text-align: right;\n",
" }\n",
"</style>\n",
"<table border=\"1\" class=\"dataframe\">\n",
" <thead>\n",
" <tr style=\"text-align: right;\">\n",
" <th></th>\n",
" <th>0</th>\n",
" <th>1</th>\n",
" <th>2</th>\n",
" <th>3</th>\n",
" </tr>\n",
" </thead>\n",
" <tbody>\n",
" <tr>\n",
" <th>0</th>\n",
" <td>1.0</td>\n",
" <td>1.0</td>\n",
" <td>7.0</td>\n",
" <td>7.0</td>\n",
" </tr>\n",
" <tr>\n",
" <th>1</th>\n",
" <td>2.0</td>\n",
" <td>5.0</td>\n",
" <td>8.0</td>\n",
" <td>8.0</td>\n",
" </tr>\n",
" <tr>\n",
" <th>2</th>\n",
" <td>NaN</td>\n",
" <td>6.0</td>\n",
" <td>9.0</td>\n",
" <td>9.0</td>\n",
" </tr>\n",
" </tbody>\n",
"</table>\n",
"</div>"
],
"text/plain": [
" 0 1 2 3\n",
"0 1.0 1.0 7.0 7.0\n",
"1 2.0 5.0 8.0 8.0\n",
"2 NaN 6.0 9.0 9.0"
]
},
"execution_count": 44,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"example4.fillna(method='ffill', axis=1)"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "ZeMc-I1EgRsI"
},
"source": [
"نوٹ کریں کہ جب فارورڈ فلنگ کے لیے پچھلی قدر دستیاب نہیں ہوتی، تو خالی قدر برقرار رہتی ہے۔\n"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "eeAoOU0RgRsJ"
},
"source": [
"### ورزش:\n"
]
},
{
"cell_type": "code",
"execution_count": 45,
"metadata": {
"collapsed": true,
"id": "e8S-CjW8gRsJ",
"trusted": false
},
"outputs": [],
"source": [
"# What output does example4.fillna(method='bfill', axis=1) produce?\n",
"# What about example4.fillna(method='ffill') or example4.fillna(method='bfill')?\n",
"# Can you think of a longer code snippet to write that can fill all of the null values in example4?\n"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "YHgy0lIrgRsJ"
},
"source": [
"آپ `fillna` کے استعمال میں تخلیقی ہو سکتے ہیں۔ مثال کے طور پر، آئیے دوبارہ `example4` کو دیکھتے ہیں، لیکن اس بار آئیے گمشدہ قدروں کو `DataFrame` میں موجود تمام قدروں کے اوسط سے بھر دیتے ہیں:\n"
]
},
{
"cell_type": "code",
"execution_count": 46,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/",
"height": 142
},
"id": "OtYVErEygRsJ",
"outputId": "708b1e67-45ca-44bf-a5ee-8b2de09ece73",
"trusted": false
},
"outputs": [
{
"data": {
"text/html": [
"<div>\n",
"<style scoped>\n",
" .dataframe tbody tr th:only-of-type {\n",
" vertical-align: middle;\n",
" }\n",
"\n",
" .dataframe tbody tr th {\n",
" vertical-align: top;\n",
" }\n",
"\n",
" .dataframe thead th {\n",
" text-align: right;\n",
" }\n",
"</style>\n",
"<table border=\"1\" class=\"dataframe\">\n",
" <thead>\n",
" <tr style=\"text-align: right;\">\n",
" <th></th>\n",
" <th>0</th>\n",
" <th>1</th>\n",
" <th>2</th>\n",
" <th>3</th>\n",
" </tr>\n",
" </thead>\n",
" <tbody>\n",
" <tr>\n",
" <th>0</th>\n",
" <td>1.0</td>\n",
" <td>5.5</td>\n",
" <td>7</td>\n",
" <td>NaN</td>\n",
" </tr>\n",
" <tr>\n",
" <th>1</th>\n",
" <td>2.0</td>\n",
" <td>5.0</td>\n",
" <td>8</td>\n",
" <td>NaN</td>\n",
" </tr>\n",
" <tr>\n",
" <th>2</th>\n",
" <td>1.5</td>\n",
" <td>6.0</td>\n",
" <td>9</td>\n",
" <td>NaN</td>\n",
" </tr>\n",
" </tbody>\n",
"</table>\n",
"</div>"
],
"text/plain": [
" 0 1 2 3\n",
"0 1.0 5.5 7 NaN\n",
"1 2.0 5.0 8 NaN\n",
"2 1.5 6.0 9 NaN"
]
},
"execution_count": 46,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"example4.fillna(example4.mean())"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "zpMvCkLSgRsJ"
},
"source": [
"نوٹ کریں کہ کالم 3 ابھی بھی خالی ہے: ڈیفالٹ سمت یہ ہے کہ اقدار کو قطار کے لحاظ سے بھرا جائے۔\n",
"\n",
"> **اہم نکتہ:** اپنے ڈیٹا سیٹس میں موجود خالی اقدار سے نمٹنے کے کئی طریقے ہیں۔ جو خاص حکمت عملی آپ اپناتے ہیں (انہیں ہٹانا، تبدیل کرنا، یا یہاں تک کہ کس طرح تبدیل کرنا) وہ ڈیٹا کی خصوصیات پر منحصر ہونا چاہیے۔ جتنا زیادہ آپ ڈیٹا سیٹس کے ساتھ کام کریں گے اور ان سے تعامل کریں گے، اتنا ہی بہتر آپ خالی اقدار سے نمٹنے کا طریقہ سمجھیں گے۔\n"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "bauDnESIl9FH"
},
"source": [
"### زمرہ وار ڈیٹا کو انکوڈ کرنا\n",
"\n",
"مشین لرننگ ماڈلز صرف نمبروں اور کسی بھی قسم کے عددی ڈیٹا کے ساتھ کام کرتے ہیں۔ یہ \"ہاں\" اور \"نہیں\" کے درمیان فرق نہیں بتا سکتے، لیکن یہ 0 اور 1 کے درمیان فرق کر سکتے ہیں۔ لہذا، گمشدہ اقدار کو بھرنے کے بعد، ہمیں زمرہ وار ڈیٹا کو کسی عددی شکل میں انکوڈ کرنا ہوگا تاکہ ماڈل اسے سمجھ سکے۔\n",
"\n",
"انکوڈنگ دو طریقوں سے کی جا سکتی ہے۔ ہم اگلے حصے میں ان پر بات کریں گے۔\n"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "uDq9SxB7mu5i"
},
"source": [
"**لیبل انکوڈنگ**\n",
"\n",
"لیبل انکوڈنگ بنیادی طور پر ہر زمرے کو ایک نمبر میں تبدیل کرنا ہے۔ مثال کے طور پر، فرض کریں کہ ہمارے پاس ایئر لائن مسافروں کا ایک ڈیٹا سیٹ ہے اور اس میں ایک کالم ہے جو ان کی کلاس کو ظاہر کرتا ہے، جیسے ['بزنس کلاس', 'اکانومی کلاس', 'فرسٹ کلاس']۔ اگر اس پر لیبل انکوڈنگ کی جائے تو یہ [0,1,2] میں تبدیل ہو جائے گا۔ آئیے کوڈ کے ذریعے ایک مثال دیکھتے ہیں۔ چونکہ ہم آنے والے نوٹ بکس میں `scikit-learn` سیکھیں گے، اس لیے ہم اسے یہاں استعمال نہیں کریں گے۔\n"
]
},
{
"cell_type": "code",
"execution_count": 47,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/",
"height": 235
},
"id": "1vGz7uZyoWHL",
"outputId": "9e252855-d193-4103-a54d-028ea7787b34"
},
"outputs": [
{
"data": {
"text/html": [
"<div>\n",
"<style scoped>\n",
" .dataframe tbody tr th:only-of-type {\n",
" vertical-align: middle;\n",
" }\n",
"\n",
" .dataframe tbody tr th {\n",
" vertical-align: top;\n",
" }\n",
"\n",
" .dataframe thead th {\n",
" text-align: right;\n",
" }\n",
"</style>\n",
"<table border=\"1\" class=\"dataframe\">\n",
" <thead>\n",
" <tr style=\"text-align: right;\">\n",
" <th></th>\n",
" <th>ID</th>\n",
" <th>class</th>\n",
" </tr>\n",
" </thead>\n",
" <tbody>\n",
" <tr>\n",
" <th>0</th>\n",
" <td>10</td>\n",
" <td>business class</td>\n",
" </tr>\n",
" <tr>\n",
" <th>1</th>\n",
" <td>20</td>\n",
" <td>first class</td>\n",
" </tr>\n",
" <tr>\n",
" <th>2</th>\n",
" <td>30</td>\n",
" <td>economy class</td>\n",
" </tr>\n",
" <tr>\n",
" <th>3</th>\n",
" <td>40</td>\n",
" <td>economy class</td>\n",
" </tr>\n",
" <tr>\n",
" <th>4</th>\n",
" <td>50</td>\n",
" <td>economy class</td>\n",
" </tr>\n",
" <tr>\n",
" <th>5</th>\n",
" <td>60</td>\n",
" <td>business class</td>\n",
" </tr>\n",
" </tbody>\n",
"</table>\n",
"</div>"
],
"text/plain": [
" ID class\n",
"0 10 business class\n",
"1 20 first class\n",
"2 30 economy class\n",
"3 40 economy class\n",
"4 50 economy class\n",
"5 60 business class"
]
},
"execution_count": 47,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"label = pd.DataFrame([\n",
" [10,'business class'],\n",
" [20,'first class'],\n",
" [30, 'economy class'],\n",
" [40, 'economy class'],\n",
" [50, 'economy class'],\n",
" [60, 'business class']\n",
"],columns=['ID','class'])\n",
"label"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "IDHnkwTYov-h"
},
"source": [
"پہلے کالم پر لیبل انکوڈنگ کرنے کے لیے، ہمیں پہلے ہر کلاس سے ایک نمبر تک نقشہ بندی بیان کرنی ہوگی، اس سے پہلے کہ ہم تبدیل کریں۔\n"
]
},
{
"cell_type": "code",
"execution_count": 48,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/",
"height": 235
},
"id": "ZC5URJG3o1ES",
"outputId": "aab0f1e7-e0f3-4c14-8459-9f9168c85437"
},
"outputs": [
{
"data": {
"text/html": [
"<div>\n",
"<style scoped>\n",
" .dataframe tbody tr th:only-of-type {\n",
" vertical-align: middle;\n",
" }\n",
"\n",
" .dataframe tbody tr th {\n",
" vertical-align: top;\n",
" }\n",
"\n",
" .dataframe thead th {\n",
" text-align: right;\n",
" }\n",
"</style>\n",
"<table border=\"1\" class=\"dataframe\">\n",
" <thead>\n",
" <tr style=\"text-align: right;\">\n",
" <th></th>\n",
" <th>ID</th>\n",
" <th>class</th>\n",
" </tr>\n",
" </thead>\n",
" <tbody>\n",
" <tr>\n",
" <th>0</th>\n",
" <td>10</td>\n",
" <td>0</td>\n",
" </tr>\n",
" <tr>\n",
" <th>1</th>\n",
" <td>20</td>\n",
" <td>2</td>\n",
" </tr>\n",
" <tr>\n",
" <th>2</th>\n",
" <td>30</td>\n",
" <td>1</td>\n",
" </tr>\n",
" <tr>\n",
" <th>3</th>\n",
" <td>40</td>\n",
" <td>1</td>\n",
" </tr>\n",
" <tr>\n",
" <th>4</th>\n",
" <td>50</td>\n",
" <td>1</td>\n",
" </tr>\n",
" <tr>\n",
" <th>5</th>\n",
" <td>60</td>\n",
" <td>0</td>\n",
" </tr>\n",
" </tbody>\n",
"</table>\n",
"</div>"
],
"text/plain": [
" ID class\n",
"0 10 0\n",
"1 20 2\n",
"2 30 1\n",
"3 40 1\n",
"4 50 1\n",
"5 60 0"
]
},
"execution_count": 48,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"class_labels = {'business class':0,'economy class':1,'first class':2}\n",
"label['class'] = label['class'].replace(class_labels)\n",
"label"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "ftnF-TyapOPt"
},
"source": [
"جیسا کہ ہم دیکھ سکتے ہیں، نتیجہ وہی ہے جو ہم نے سوچا تھا کہ ہوگا۔ تو، لیبل انکوڈنگ کب استعمال کی جاتی ہے؟ لیبل انکوڈنگ درج ذیل میں سے کسی ایک یا دونوں صورتوں میں استعمال کی جاتی ہے:\n",
"1. جب زمروں کی تعداد زیادہ ہو\n",
"2. جب زمرے ترتیب میں ہوں۔\n"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "eQPAPVwsqWT7"
},
"source": [
"**ون ہاٹ انکوڈنگ**\n",
"\n",
"ون ہاٹ انکوڈنگ ایک اور قسم کی انکوڈنگ ہے۔ اس قسم کی انکوڈنگ میں، کالم کی ہر کیٹیگری کو ایک الگ کالم کے طور پر شامل کیا جاتا ہے اور ہر ڈیٹا پوائنٹ کو 0 یا 1 دیا جاتا ہے، اس بنیاد پر کہ آیا وہ کیٹیگری موجود ہے یا نہیں۔ لہذا، اگر n مختلف کیٹیگریز ہوں، تو n کالمز ڈیٹا فریم میں شامل کیے جائیں گے۔\n",
"\n",
"مثال کے طور پر، آئیے وہی ہوائی جہاز کی کلاس کی مثال لیتے ہیں۔ کیٹیگریز تھیں: ['بزنس کلاس', 'اکانومی کلاس', 'فرسٹ کلاس']۔ تو، اگر ہم ون ہاٹ انکوڈنگ کریں، تو درج ذیل تین کالمز ڈیٹا سیٹ میں شامل کیے جائیں گے: ['class_business class', 'class_economy class', 'class_first class']۔\n"
]
},
{
"cell_type": "code",
"execution_count": 49,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/",
"height": 235
},
"id": "ZM0eVh0ArKUL",
"outputId": "83238a76-b3a5-418d-c0b6-605b02b6891b"
},
"outputs": [
{
"data": {
"text/html": [
"<div>\n",
"<style scoped>\n",
" .dataframe tbody tr th:only-of-type {\n",
" vertical-align: middle;\n",
" }\n",
"\n",
" .dataframe tbody tr th {\n",
" vertical-align: top;\n",
" }\n",
"\n",
" .dataframe thead th {\n",
" text-align: right;\n",
" }\n",
"</style>\n",
"<table border=\"1\" class=\"dataframe\">\n",
" <thead>\n",
" <tr style=\"text-align: right;\">\n",
" <th></th>\n",
" <th>ID</th>\n",
" <th>class</th>\n",
" </tr>\n",
" </thead>\n",
" <tbody>\n",
" <tr>\n",
" <th>0</th>\n",
" <td>10</td>\n",
" <td>business class</td>\n",
" </tr>\n",
" <tr>\n",
" <th>1</th>\n",
" <td>20</td>\n",
" <td>first class</td>\n",
" </tr>\n",
" <tr>\n",
" <th>2</th>\n",
" <td>30</td>\n",
" <td>economy class</td>\n",
" </tr>\n",
" <tr>\n",
" <th>3</th>\n",
" <td>40</td>\n",
" <td>economy class</td>\n",
" </tr>\n",
" <tr>\n",
" <th>4</th>\n",
" <td>50</td>\n",
" <td>economy class</td>\n",
" </tr>\n",
" <tr>\n",
" <th>5</th>\n",
" <td>60</td>\n",
" <td>business class</td>\n",
" </tr>\n",
" </tbody>\n",
"</table>\n",
"</div>"
],
"text/plain": [
" ID class\n",
"0 10 business class\n",
"1 20 first class\n",
"2 30 economy class\n",
"3 40 economy class\n",
"4 50 economy class\n",
"5 60 business class"
]
},
"execution_count": 49,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"one_hot = pd.DataFrame([\n",
" [10,'business class'],\n",
" [20,'first class'],\n",
" [30, 'economy class'],\n",
" [40, 'economy class'],\n",
" [50, 'economy class'],\n",
" [60, 'business class']\n",
"],columns=['ID','class'])\n",
"one_hot"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "aVnZ7paDrWmb"
},
"source": [
"آئیے پہلی کالم پر ون ہاٹ انکوڈنگ انجام دیں۔\n"
]
},
{
"cell_type": "code",
"execution_count": 50,
"metadata": {
"id": "RUPxf7egrYKr"
},
"outputs": [],
"source": [
"one_hot_data = pd.get_dummies(one_hot,columns=['class'])"
]
},
{
"cell_type": "code",
"execution_count": 51,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/",
"height": 235
},
"id": "TM37pHsFr4ge",
"outputId": "7be15f53-79b2-447a-979c-822658339a9e"
},
"outputs": [
{
"data": {
"text/html": [
"<div>\n",
"<style scoped>\n",
" .dataframe tbody tr th:only-of-type {\n",
" vertical-align: middle;\n",
" }\n",
"\n",
" .dataframe tbody tr th {\n",
" vertical-align: top;\n",
" }\n",
"\n",
" .dataframe thead th {\n",
" text-align: right;\n",
" }\n",
"</style>\n",
"<table border=\"1\" class=\"dataframe\">\n",
" <thead>\n",
" <tr style=\"text-align: right;\">\n",
" <th></th>\n",
" <th>ID</th>\n",
" <th>class_business class</th>\n",
" <th>class_economy class</th>\n",
" <th>class_first class</th>\n",
" </tr>\n",
" </thead>\n",
" <tbody>\n",
" <tr>\n",
" <th>0</th>\n",
" <td>10</td>\n",
" <td>1</td>\n",
" <td>0</td>\n",
" <td>0</td>\n",
" </tr>\n",
" <tr>\n",
" <th>1</th>\n",
" <td>20</td>\n",
" <td>0</td>\n",
" <td>0</td>\n",
" <td>1</td>\n",
" </tr>\n",
" <tr>\n",
" <th>2</th>\n",
" <td>30</td>\n",
" <td>0</td>\n",
" <td>1</td>\n",
" <td>0</td>\n",
" </tr>\n",
" <tr>\n",
" <th>3</th>\n",
" <td>40</td>\n",
" <td>0</td>\n",
" <td>1</td>\n",
" <td>0</td>\n",
" </tr>\n",
" <tr>\n",
" <th>4</th>\n",
" <td>50</td>\n",
" <td>0</td>\n",
" <td>1</td>\n",
" <td>0</td>\n",
" </tr>\n",
" <tr>\n",
" <th>5</th>\n",
" <td>60</td>\n",
" <td>1</td>\n",
" <td>0</td>\n",
" <td>0</td>\n",
" </tr>\n",
" </tbody>\n",
"</table>\n",
"</div>"
],
"text/plain": [
" ID class_business class class_economy class class_first class\n",
"0 10 1 0 0\n",
"1 20 0 0 1\n",
"2 30 0 1 0\n",
"3 40 0 1 0\n",
"4 50 0 1 0\n",
"5 60 1 0 0"
]
},
"execution_count": 51,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"one_hot_data"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "_zXRLOjXujdA"
},
"source": [
"ہر ایک ہاٹ انکوڈڈ کالم میں 0 یا 1 ہوتا ہے، جو یہ ظاہر کرتا ہے کہ آیا وہ زمرہ اس ڈیٹا پوائنٹ کے لیے موجود ہے۔\n"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "bDnC4NQOu0qr"
},
"source": [
"ہم ایک ہاٹ انکوڈنگ کب استعمال کرتے ہیں؟ ایک ہاٹ انکوڈنگ درج ذیل میں سے ایک یا دونوں صورتوں میں استعمال کی جاتی ہے:\n",
"\n",
"1. جب زمروں کی تعداد اور ڈیٹا سیٹ کا سائز چھوٹا ہو۔\n",
"2. جب زمرے کسی خاص ترتیب کی پیروی نہ کرتے ہوں۔\n"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "XnUmci_4uvyu"
},
"source": [
"> اہم نکات:\n",
"1. انکوڈنگ غیر عددی ڈیٹا کو عددی ڈیٹا میں تبدیل کرنے کے لیے کی جاتی ہے۔\n",
"2. انکوڈنگ کی دو اقسام ہیں: لیبل انکوڈنگ اور ون ہاٹ انکوڈنگ، جنہیں ڈیٹا سیٹ کی ضروریات کے مطابق انجام دیا جا سکتا ہے۔\n"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "K8UXOJYRgRsJ"
},
"source": [
"## ڈپلیکیٹ ڈیٹا کو ہٹانا\n",
"\n",
"> **سیکھنے کا مقصد:** اس ذیلی حصے کے اختتام تک، آپ کو ڈیٹا فریمز سے ڈپلیکیٹ ویلیوز کی شناخت اور انہیں ہٹانے میں مہارت حاصل ہو جانی چاہیے۔\n",
"\n",
"گمشدہ ڈیٹا کے علاوہ، آپ کو حقیقی دنیا کے ڈیٹا سیٹس میں اکثر ڈپلیکیٹ ڈیٹا کا سامنا کرنا پڑے گا۔ خوش قسمتی سے، pandas ڈپلیکیٹ اندراجات کا پتہ لگانے اور انہیں ہٹانے کا ایک آسان طریقہ فراہم کرتا ہے۔\n"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "qrEG-Wa0gRsJ"
},
"source": [
"### ڈپلیکیٹس کی شناخت: `duplicated`\n",
"\n",
"آپ pandas میں `duplicated` میتھڈ کا استعمال کرکے آسانی سے ڈپلیکیٹ ویلیوز کو پہچان سکتے ہیں، جو ایک Boolean ماسک واپس کرتا ہے جو یہ ظاہر کرتا ہے کہ آیا `DataFrame` میں کوئی اندراج پہلے والے کا ڈپلیکیٹ ہے۔ آئیے ایک اور مثال کے طور پر `DataFrame` بناتے ہیں تاکہ اسے عملی طور پر دیکھ سکیں۔\n"
]
},
{
"cell_type": "code",
"execution_count": 52,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/",
"height": 204
},
"id": "ZLu6FEnZgRsJ",
"outputId": "376512d1-d842-4db1-aea3-71052aeeecaf",
"trusted": false
},
"outputs": [
{
"data": {
"text/html": [
"<div>\n",
"<style scoped>\n",
" .dataframe tbody tr th:only-of-type {\n",
" vertical-align: middle;\n",
" }\n",
"\n",
" .dataframe tbody tr th {\n",
" vertical-align: top;\n",
" }\n",
"\n",
" .dataframe thead th {\n",
" text-align: right;\n",
" }\n",
"</style>\n",
"<table border=\"1\" class=\"dataframe\">\n",
" <thead>\n",
" <tr style=\"text-align: right;\">\n",
" <th></th>\n",
" <th>letters</th>\n",
" <th>numbers</th>\n",
" </tr>\n",
" </thead>\n",
" <tbody>\n",
" <tr>\n",
" <th>0</th>\n",
" <td>A</td>\n",
" <td>1</td>\n",
" </tr>\n",
" <tr>\n",
" <th>1</th>\n",
" <td>B</td>\n",
" <td>2</td>\n",
" </tr>\n",
" <tr>\n",
" <th>2</th>\n",
" <td>A</td>\n",
" <td>1</td>\n",
" </tr>\n",
" <tr>\n",
" <th>3</th>\n",
" <td>B</td>\n",
" <td>3</td>\n",
" </tr>\n",
" <tr>\n",
" <th>4</th>\n",
" <td>B</td>\n",
" <td>3</td>\n",
" </tr>\n",
" </tbody>\n",
"</table>\n",
"</div>"
],
"text/plain": [
" letters numbers\n",
"0 A 1\n",
"1 B 2\n",
"2 A 1\n",
"3 B 3\n",
"4 B 3"
]
},
"execution_count": 52,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"example6 = pd.DataFrame({'letters': ['A','B'] * 2 + ['B'],\n",
" 'numbers': [1, 2, 1, 3, 3]})\n",
"example6"
]
},
{
"cell_type": "code",
"execution_count": 53,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/"
},
"id": "cIduB5oBgRsK",
"outputId": "3da27b3d-4d69-4e1d-bb52-0af21bae87f2",
"trusted": false
},
"outputs": [
{
"data": {
"text/plain": [
"0 False\n",
"1 False\n",
"2 True\n",
"3 False\n",
"4 True\n",
"dtype: bool"
]
},
"execution_count": 53,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"example6.duplicated()"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "0eDRJD4SgRsK"
},
"source": [
"### ڈپلیکیٹس کو ختم کرنا: `drop_duplicates`\n",
"`drop_duplicates` صرف ان ڈیٹا کی ایک کاپی واپس کرتا ہے جن کے تمام `duplicated` ویلیوز `False` ہیں:\n"
]
},
{
"cell_type": "code",
"execution_count": 54,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/",
"height": 142
},
"id": "w_YPpqIqgRsK",
"outputId": "ac66bd2f-8671-4744-87f5-8b8d96553dea",
"trusted": false
},
"outputs": [
{
"data": {
"text/html": [
"<div>\n",
"<style scoped>\n",
" .dataframe tbody tr th:only-of-type {\n",
" vertical-align: middle;\n",
" }\n",
"\n",
" .dataframe tbody tr th {\n",
" vertical-align: top;\n",
" }\n",
"\n",
" .dataframe thead th {\n",
" text-align: right;\n",
" }\n",
"</style>\n",
"<table border=\"1\" class=\"dataframe\">\n",
" <thead>\n",
" <tr style=\"text-align: right;\">\n",
" <th></th>\n",
" <th>letters</th>\n",
" <th>numbers</th>\n",
" </tr>\n",
" </thead>\n",
" <tbody>\n",
" <tr>\n",
" <th>0</th>\n",
" <td>A</td>\n",
" <td>1</td>\n",
" </tr>\n",
" <tr>\n",
" <th>1</th>\n",
" <td>B</td>\n",
" <td>2</td>\n",
" </tr>\n",
" <tr>\n",
" <th>3</th>\n",
" <td>B</td>\n",
" <td>3</td>\n",
" </tr>\n",
" </tbody>\n",
"</table>\n",
"</div>"
],
"text/plain": [
" letters numbers\n",
"0 A 1\n",
"1 B 2\n",
"3 B 3"
]
},
"execution_count": 54,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"example6.drop_duplicates()"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "69AqoCZAgRsK"
},
"source": [
"`duplicated` اور `drop_duplicates` دونوں ڈیفالٹ طور پر تمام کالمز کو مدنظر رکھتے ہیں لیکن آپ یہ مخصوص کر سکتے ہیں کہ وہ آپ کے `DataFrame` میں صرف کالمز کے ایک ذیلی سیٹ کا جائزہ لیں:\n"
]
},
{
"cell_type": "code",
"execution_count": 55,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/",
"height": 111
},
"id": "BILjDs67gRsK",
"outputId": "ef6dcc08-db8b-4352-c44e-5aa9e2bec0d3",
"trusted": false
},
"outputs": [
{
"data": {
"text/html": [
"<div>\n",
"<style scoped>\n",
" .dataframe tbody tr th:only-of-type {\n",
" vertical-align: middle;\n",
" }\n",
"\n",
" .dataframe tbody tr th {\n",
" vertical-align: top;\n",
" }\n",
"\n",
" .dataframe thead th {\n",
" text-align: right;\n",
" }\n",
"</style>\n",
"<table border=\"1\" class=\"dataframe\">\n",
" <thead>\n",
" <tr style=\"text-align: right;\">\n",
" <th></th>\n",
" <th>letters</th>\n",
" <th>numbers</th>\n",
" </tr>\n",
" </thead>\n",
" <tbody>\n",
" <tr>\n",
" <th>0</th>\n",
" <td>A</td>\n",
" <td>1</td>\n",
" </tr>\n",
" <tr>\n",
" <th>1</th>\n",
" <td>B</td>\n",
" <td>2</td>\n",
" </tr>\n",
" </tbody>\n",
"</table>\n",
"</div>"
],
"text/plain": [
" letters numbers\n",
"0 A 1\n",
"1 B 2"
]
},
"execution_count": 55,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"example6.drop_duplicates(['letters'])"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "GvX4og1EgRsL"
},
"source": [
"> **حاصلِ کلام:** نقل شدہ ڈیٹا کو ہٹانا تقریباً ہر ڈیٹا سائنس منصوبے کا ایک لازمی حصہ ہے۔ نقل شدہ ڈیٹا آپ کے تجزیوں کے نتائج کو بدل سکتا ہے اور آپ کو غلط نتائج دے سکتا ہے!\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## حقیقی دنیا کے ڈیٹا کے معیار کی جانچ\n",
"\n",
"> **سیکھنے کا مقصد:** اس حصے کے اختتام تک، آپ حقیقی دنیا کے ڈیٹا کے معیار کے عام مسائل جیسے غیر مستقل زمرہ جاتی اقدار، غیر معمولی عددی اقدار (آؤٹ لائرز)، اور معمولی فرق کے ساتھ نقل شدہ اداروں کا پتہ لگانے اور درست کرنے میں مہارت حاصل کر لیں گے۔\n",
"\n",
"اگرچہ گمشدہ اقدار اور بالکل نقل شدہ ڈیٹا عام مسائل ہیں، حقیقی دنیا کے ڈیٹا سیٹس میں اکثر زیادہ پیچیدہ مسائل شامل ہوتے ہیں:\n",
"\n",
"1. **غیر مستقل زمرہ جاتی اقدار**: ایک ہی زمرہ مختلف طریقوں سے لکھا گیا (جیسے \"USA\"، \"U.S.A\"، \"United States\")\n",
"2. **غیر معمولی عددی اقدار**: انتہائی آؤٹ لائرز جو ڈیٹا انٹری کی غلطیوں کی نشاندہی کرتے ہیں (جیسے عمر = 999)\n",
"3. **قریب قریب نقل شدہ قطاریں**: وہ ریکارڈز جو ایک ہی ادارے کی نمائندگی کرتے ہیں لیکن معمولی فرق کے ساتھ\n",
"\n",
"آئیے ان مسائل کا پتہ لگانے اور ان سے نمٹنے کے طریقے دریافت کرتے ہیں۔\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### ایک نمونہ \"گندا\" ڈیٹاسیٹ بنانا\n",
"\n",
"سب سے پہلے، آئیے ایک نمونہ ڈیٹاسیٹ بناتے ہیں جس میں وہ مسائل شامل ہوں جو ہم عام طور پر حقیقی دنیا کے ڈیٹا میں دیکھتے ہیں:\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"import pandas as pd\n",
"import numpy as np\n",
"\n",
"# Create a sample dataset with quality issues\n",
"dirty_data = pd.DataFrame({\n",
" 'customer_id': [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12],\n",
" 'name': ['John Smith', 'Jane Doe', 'John Smith', 'Bob Johnson', \n",
" 'Alice Williams', 'Charlie Brown', 'John Smith', 'Eva Martinez',\n",
" 'Bob Johnson', 'Diana Prince', 'Frank Castle', 'Alice Williams'],\n",
" 'age': [25, 32, 25, 45, 28, 199, 25, 31, 45, 27, -5, 28],\n",
" 'country': ['USA', 'UK', 'U.S.A', 'Canada', 'USA', 'United Kingdom',\n",
" 'United States', 'Mexico', 'canada', 'USA', 'UK', 'usa'],\n",
" 'purchase_amount': [100.50, 250.00, 105.00, 320.00, 180.00, 90.00,\n",
" 102.00, 275.00, 325.00, 195.00, 410.00, 185.00]\n",
"})\n",
"\n",
"print(\"Sample 'Dirty' Dataset:\")\n",
"print(dirty_data)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### 1. غیر متوازن زمرہ جاتی اقدار کا پتہ لگانا\n",
"\n",
"دھیان دیں کہ `country` کالم میں ایک ہی ممالک کے لیے متعدد نمائندگیاں موجود ہیں۔ آئیے ان بے ترتیبیوں کی نشاندہی کرتے ہیں:\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# Check unique values in the country column\n",
"print(\"Unique country values:\")\n",
"print(dirty_data['country'].unique())\n",
"print(f\"\\nTotal unique values: {dirty_data['country'].nunique()}\")\n",
"\n",
"# Count occurrences of each variation\n",
"print(\"\\nValue counts:\")\n",
"print(dirty_data['country'].value_counts())"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"#### زمرہ وار اقدار کو معیاری بنانا\n",
"\n",
"ہم ان اقدار کو معیاری بنانے کے لیے ایک نقشہ بنا سکتے ہیں۔ ایک آسان طریقہ یہ ہے کہ انہیں چھوٹے حروف میں تبدیل کریں اور ایک نقشہ سازی کی ڈکشنری بنائیں:\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# Create a standardization mapping\n",
"country_mapping = {\n",
" 'usa': 'USA',\n",
" 'u.s.a': 'USA',\n",
" 'united states': 'USA',\n",
" 'uk': 'UK',\n",
" 'united kingdom': 'UK',\n",
" 'canada': 'Canada',\n",
" 'mexico': 'Mexico'\n",
"}\n",
"\n",
"# Standardize the country column\n",
"dirty_data['country_clean'] = dirty_data['country'].str.lower().map(country_mapping)\n",
"\n",
"print(\"Before standardization:\")\n",
"print(dirty_data['country'].value_counts())\n",
"print(\"\\nAfter standardization:\")\n",
"print(dirty_data[['country_clean']].value_counts())"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**متبادل: دھندلے مماثلت کا استعمال**\n",
"\n",
"زیادہ پیچیدہ معاملات کے لیے، ہم `rapidfuzz` لائبریری کے ساتھ دھندلے سٹرنگ مماثلت کا استعمال کر سکتے ہیں تاکہ خودکار طور پر مشابہت رکھنے والے سٹرنگز کا پتہ لگایا جا سکے:\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"try:\n",
" from rapidfuzz import process, fuzz\n",
"except ImportError:\n",
" print(\"rapidfuzz is not installed. Please install it with 'pip install rapidfuzz' to use fuzzy matching.\")\n",
" process = None\n",
" fuzz = None\n",
"\n",
"# Get unique countries\n",
"unique_countries = dirty_data['country'].unique()\n",
"\n",
"# For each country, find similar matches\n",
"if process is not None and fuzz is not None:\n",
" print(\"Finding similar country names (similarity > 70%):\")\n",
" for country in unique_countries:\n",
" matches = process.extract(country, unique_countries, scorer=fuzz.ratio, limit=3)\n",
" # Filter matches with similarity > 70 and not identical\n",
" similar = [m for m in matches if m[1] > 70 and m[0] != country]\n",
" if similar:\n",
" print(f\"\\n'{country}' is similar to:\")\n",
" for match, score, _ in similar:\n",
" print(f\" - '{match}' (similarity: {score}%)\")\n",
"else:\n",
" print(\"Skipping fuzzy matching because rapidfuzz is not available.\")"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### 2. غیر معمولی عددی قدروں کا پتہ لگانا (آؤٹ لائرز)\n",
"\n",
"`age` کالم کو دیکھتے ہوئے، ہمارے پاس کچھ مشکوک قدریں ہیں جیسے 199 اور -5۔ آئیے ان آؤٹ لائرز کا پتہ لگانے کے لیے شماریاتی طریقے استعمال کریں۔\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# Display basic statistics\n",
"print(\"Age column statistics:\")\n",
"print(dirty_data['age'].describe())\n",
"\n",
"# Identify impossible values using domain knowledge\n",
"print(\"\\nRows with impossible age values (< 0 or > 120):\")\n",
"impossible_ages = dirty_data[(dirty_data['age'] < 0) | (dirty_data['age'] > 120)]\n",
"print(impossible_ages[['customer_id', 'name', 'age']])"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"#### آئی کیو آر (Interquartile Range) طریقہ استعمال کرنا\n",
"\n",
"آئی کیو آر طریقہ ایک مضبوط شماریاتی تکنیک ہے جو غیر معمولی اقدار کی شناخت کے لیے استعمال ہوتی ہے اور انتہائی اقدار کے لیے کم حساس ہے:\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# Calculate IQR for age (excluding impossible values)\n",
"valid_ages = dirty_data[(dirty_data['age'] >= 0) & (dirty_data['age'] <= 120)]['age']\n",
"\n",
"Q1 = valid_ages.quantile(0.25)\n",
"Q3 = valid_ages.quantile(0.75)\n",
"IQR = Q3 - Q1\n",
"\n",
"# Define outlier bounds\n",
"lower_bound = Q1 - 1.5 * IQR\n",
"upper_bound = Q3 + 1.5 * IQR\n",
"\n",
"print(f\"IQR-based outlier bounds for age: [{lower_bound:.2f}, {upper_bound:.2f}]\")\n",
"\n",
"# Identify outliers\n",
"age_outliers = dirty_data[(dirty_data['age'] < lower_bound) | (dirty_data['age'] > upper_bound)]\n",
"print(f\"\\nRows with age outliers:\")\n",
"print(age_outliers[['customer_id', 'name', 'age']])"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"#### زیڈ اسکور طریقہ استعمال کرنا\n",
"\n",
"زیڈ اسکور طریقہ اوسط سے معیاری انحرافات کی بنیاد پر غیر معمولی اقدار کی نشاندہی کرتا ہے:\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"try:\n",
" from scipy import stats\n",
"except ImportError:\n",
" print(\"scipy is required for Z-score calculation. Please install it with 'pip install scipy' and rerun this cell.\")\n",
"else:\n",
" # Calculate Z-scores for age, handling NaN values\n",
" age_nonan = dirty_data['age'].dropna()\n",
" zscores = np.abs(stats.zscore(age_nonan))\n",
" dirty_data['age_zscore'] = np.nan\n",
" dirty_data.loc[age_nonan.index, 'age_zscore'] = zscores\n",
"\n",
" # Typically, Z-score > 3 indicates an outlier\n",
" print(\"Rows with age Z-score > 3:\")\n",
" zscore_outliers = dirty_data[dirty_data['age_zscore'] > 3]\n",
" print(zscore_outliers[['customer_id', 'name', 'age', 'age_zscore']])\n",
"\n",
" # Clean up the temporary column\n",
" dirty_data = dirty_data.drop('age_zscore', axis=1)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"#### آؤٹ لائرز کو سنبھالنا\n",
"\n",
"جب آؤٹ لائرز کا پتہ چل جائے، تو انہیں کئی طریقوں سے سنبھالا جا سکتا ہے:\n",
"1. **ہٹائیں**: آؤٹ لائرز والی قطاریں حذف کریں (اگر وہ غلطیاں ہیں)\n",
"2. **حد مقرر کریں**: حد کے اقدار سے تبدیل کریں\n",
"3. **NaN سے تبدیل کریں**: انہیں گمشدہ ڈیٹا کے طور پر سمجھیں اور امپیوٹیشن تکنیک استعمال کریں\n",
"4. **رکھیں**: اگر وہ جائز انتہائی اقدار ہیں\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# Create a cleaned version by replacing impossible ages with NaN\n",
"dirty_data['age_clean'] = dirty_data['age'].apply(\n",
" lambda x: np.nan if (x < 0 or x > 120) else x\n",
")\n",
"\n",
"print(\"Age column before and after cleaning:\")\n",
"print(dirty_data[['customer_id', 'name', 'age', 'age_clean']])"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### 3. قریب المثل قطاروں کا پتہ لگانا\n",
"\n",
"دھیان دیں کہ ہمارے ڈیٹا سیٹ میں \"John Smith\" کے لیے کئی اندراجات موجود ہیں جن میں قدرے مختلف اقدار ہیں۔ آئیے نام کی مماثلت کی بنیاد پر ممکنہ نقلیں شناخت کریں۔\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# First, let's look at exact name matches (ignoring extra whitespace)\n",
"dirty_data['name_normalized'] = dirty_data['name'].str.strip().str.lower()\n",
"\n",
"print(\"Checking for duplicate names:\")\n",
"duplicate_names = dirty_data[dirty_data.duplicated(['name_normalized'], keep=False)]\n",
"print(duplicate_names.sort_values('name_normalized')[['customer_id', 'name', 'age', 'country']])"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"#### دھندلے مماثلت کے ساتھ قریباً نقلیں تلاش کرنا\n",
"\n",
"زیادہ پیچیدہ نقلیں تلاش کرنے کے لیے، ہم دھندلے مماثلت کا استعمال کر سکتے ہیں تاکہ ملتے جلتے نام تلاش کیے جا سکیں:\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"try:\n",
" from rapidfuzz import process, fuzz\n",
"\n",
" # Function to find potential duplicates\n",
" def find_near_duplicates(df, column, threshold=90):\n",
" \"\"\"\n",
" Find near-duplicate entries in a column using fuzzy matching.\n",
" \n",
" Parameters:\n",
" - df: DataFrame\n",
" - column: Column name to check for duplicates\n",
" - threshold: Similarity threshold (0-100)\n",
" \n",
" Returns: List of potential duplicate groups\n",
" \"\"\"\n",
" values = df[column].unique()\n",
" duplicate_groups = []\n",
" checked = set()\n",
" \n",
" for value in values:\n",
" if value in checked:\n",
" continue\n",
" \n",
" # Find similar values\n",
" matches = process.extract(value, values, scorer=fuzz.ratio, limit=len(values))\n",
" similar = [m[0] for m in matches if m[1] >= threshold]\n",
" \n",
" if len(similar) > 1:\n",
" duplicate_groups.append(similar)\n",
" checked.update(similar)\n",
" \n",
" return duplicate_groups\n",
"\n",
" # Find near-duplicate names\n",
" duplicate_groups = find_near_duplicates(dirty_data, 'name', threshold=90)\n",
"\n",
" print(\"Potential duplicate groups:\")\n",
" for i, group in enumerate(duplicate_groups, 1):\n",
" print(f\"\\nGroup {i}:\")\n",
" for name in group:\n",
" matching_rows = dirty_data[dirty_data['name'] == name]\n",
" print(f\" '{name}': {len(matching_rows)} occurrence(s)\")\n",
" for _, row in matching_rows.iterrows():\n",
" print(f\" - Customer {row['customer_id']}: age={row['age']}, country={row['country']}\")\n",
"except ImportError:\n",
" print(\"rapidfuzz is not installed. Skipping fuzzy matching for near-duplicates.\")"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"#### ڈپلیکیٹس کو ہینڈل کرنا\n",
"\n",
"جب ڈپلیکیٹس کی شناخت ہو جائے، تو آپ کو فیصلہ کرنا ہوگا کہ انہیں کیسے ہینڈل کریں:\n",
"1. **پہلی بار وقوع کو رکھیں**: `drop_duplicates(keep='first')` استعمال کریں\n",
"2. **آخری بار وقوع کو رکھیں**: `drop_duplicates(keep='last')` استعمال کریں\n",
"3. **معلومات کو جمع کریں**: ڈپلیکیٹ قطاروں سے معلومات کو یکجا کریں\n",
"4. **دستی جائزہ**: انسانی جائزے کے لیے نشان زد کریں\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# Example: Remove duplicates based on normalized name, keeping first occurrence\n",
"cleaned_data = dirty_data.drop_duplicates(subset=['name_normalized'], keep='first')\n",
"\n",
"print(f\"Original dataset: {len(dirty_data)} rows\")\n",
"print(f\"After removing name duplicates: {len(cleaned_data)} rows\")\n",
"print(f\"Removed: {len(dirty_data) - len(cleaned_data)} duplicate rows\")\n",
"\n",
"print(\"\\nCleaned dataset:\")\n",
"print(cleaned_data[['customer_id', 'name', 'age', 'country_clean']])"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### خلاصہ: مکمل ڈیٹا صفائی کا عمل\n",
"\n",
"آئیے اسے ایک جامع صفائی کے عمل میں یکجا کرتے ہیں:\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"def clean_dataset(df):\n",
" \"\"\"\n",
" Comprehensive data cleaning function.\n",
" \"\"\"\n",
" # Create a copy to avoid modifying the original\n",
" cleaned = df.copy()\n",
" \n",
" # 1. Standardize categorical values (country)\n",
" country_mapping = {\n",
" 'usa': 'USA', 'u.s.a': 'USA', 'united states': 'USA',\n",
" 'uk': 'UK', 'united kingdom': 'UK',\n",
" 'canada': 'Canada', 'mexico': 'Mexico'\n",
" }\n",
" cleaned['country'] = cleaned['country'].str.lower().map(country_mapping)\n",
" \n",
" # 2. Clean abnormal age values\n",
" cleaned['age'] = cleaned['age'].apply(\n",
" lambda x: np.nan if (x < 0 or x > 120) else x\n",
" )\n",
" \n",
" # 3. Remove near-duplicate names (normalize whitespace)\n",
" cleaned['name'] = cleaned['name'].str.strip()\n",
" cleaned = cleaned.drop_duplicates(subset=['name'], keep='first')\n",
" \n",
" return cleaned\n",
"\n",
"# Apply the cleaning pipeline\n",
"final_cleaned_data = clean_dataset(dirty_data)\n",
"\n",
"print(\"Before cleaning:\")\n",
"print(f\" Rows: {len(dirty_data)}\")\n",
"print(f\" Unique countries: {dirty_data['country'].nunique()}\")\n",
"print(f\" Invalid ages: {((dirty_data['age'] < 0) | (dirty_data['age'] > 120)).sum()}\")\n",
"\n",
"print(\"\\nAfter cleaning:\")\n",
"print(f\" Rows: {len(final_cleaned_data)}\")\n",
"print(f\" Unique countries: {final_cleaned_data['country'].nunique()}\")\n",
"print(f\" Invalid ages: {((final_cleaned_data['age'] < 0) | (final_cleaned_data['age'] > 120)).sum()}\")\n",
"\n",
"print(\"\\nCleaned dataset:\")\n",
"print(final_cleaned_data[['customer_id', 'name', 'age', 'country', 'purchase_amount']])"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### 🎯 چیلنج مشق\n",
"\n",
"اب یہ آپ کی باری ہے! نیچے ایک نئی قطار دی گئی ہے جس میں کئی معیار کے مسائل ہیں۔ کیا آپ:\n",
"\n",
"1. اس قطار میں موجود تمام مسائل کی نشاندہی کر سکتے ہیں؟\n",
"2. ہر مسئلے کو صاف کرنے کے لیے کوڈ لکھ سکتے ہیں؟\n",
"3. صاف شدہ قطار کو ڈیٹاسیٹ میں شامل کر سکتے ہیں؟\n",
"\n",
"یہاں مسئلہ زدہ ڈیٹا ہے:\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# New problematic row\n",
"new_row = pd.DataFrame({\n",
" 'customer_id': [13],\n",
" 'name': [' Diana Prince '], # Extra whitespace\n",
" 'age': [250], # Impossible age\n",
" 'country': ['U.S.A.'], # Inconsistent format\n",
" 'purchase_amount': [150.00]\n",
"})\n",
"\n",
"print(\"New row to clean:\")\n",
"print(new_row)\n",
"\n",
"# TODO: Your code here to clean this row\n",
"# Hints:\n",
"# 1. Strip whitespace from the name\n",
"# 2. Check if the name is a duplicate (Diana Prince already exists)\n",
"# 3. Handle the impossible age value\n",
"# 4. Standardize the country name\n",
"\n",
"# Example solution (uncomment and modify as needed):\n",
"# new_row_cleaned = new_row.copy()\n",
"# new_row_cleaned['name'] = new_row_cleaned['name'].str.strip()\n",
"# new_row_cleaned['age'] = np.nan # Invalid age\n",
"# new_row_cleaned['country'] = 'USA' # Standardized\n",
"# print(\"\\nCleaned row:\")\n",
"# print(new_row_cleaned)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### اہم نکات\n",
"\n",
"1. **غیر مستقل زمروں** کا حقیقی دنیا کے ڈیٹا میں عام ہونا معمول کی بات ہے۔ ہمیشہ منفرد اقدار کو چیک کریں اور انہیں میپنگ یا فزی میچنگ کے ذریعے معیاری بنائیں۔\n",
"\n",
"2. **آؤٹ لائرز** آپ کے تجزیے پر نمایاں اثر ڈال سکتے ہیں۔ انہیں شناخت کرنے کے لیے ڈومین نالج کو شماریاتی طریقوں (IQR، Z-score) کے ساتھ استعمال کریں۔\n",
"\n",
"3. **قریب قریب نقلیں** بالکل نقلوں کی نسبت زیادہ مشکل ہوتی ہیں۔ انہیں پہچاننے کے لیے فزی میچنگ اور ڈیٹا کو نارملائز کرنے (لوئر کیس کرنا، اسپیس ہٹانا) پر غور کریں۔\n",
"\n",
"4. **ڈیٹا کی صفائی ایک تکراری عمل ہے**۔ آپ کو کئی تکنیکیں استعمال کرنی پڑ سکتی ہیں اور نتائج کا جائزہ لینا پڑ سکتا ہے، اس سے پہلے کہ آپ اپنے صاف شدہ ڈیٹا سیٹ کو حتمی شکل دیں۔\n",
"\n",
"5. **اپنے فیصلوں کو دستاویزی بنائیں**۔ یہ یاد رکھیں کہ آپ نے کون سے صفائی کے اقدامات کیے اور کیوں، کیونکہ یہ دوبارہ قابل عمل اور شفافیت کے لیے اہم ہے۔\n",
"\n",
"> **بہترین طریقہ:** ہمیشہ اپنے اصل \"گندے\" ڈیٹا کی ایک کاپی محفوظ رکھیں۔ اپنے سورس ڈیٹا فائلز کو کبھی اوور رائٹ نہ کریں - صاف شدہ ورژنز بنائیں اور واضح نام دینے کے اصول اپنائیں جیسے `data_cleaned.csv`۔\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"\n---\n\n**ڈسکلیمر**: \nیہ دستاویز AI ترجمہ سروس [Co-op Translator](https://github.com/Azure/co-op-translator) کا استعمال کرتے ہوئے ترجمہ کی گئی ہے۔ ہم درستگی کے لیے کوشش کرتے ہیں، لیکن براہ کرم آگاہ رہیں کہ خودکار ترجمے میں غلطیاں یا غیر درستیاں ہو سکتی ہیں۔ اصل دستاویز کو اس کی اصل زبان میں مستند ذریعہ سمجھا جانا چاہیے۔ اہم معلومات کے لیے، پیشہ ور انسانی ترجمہ کی سفارش کی جاتی ہے۔ ہم اس ترجمے کے استعمال سے پیدا ہونے والی کسی بھی غلط فہمی یا غلط تشریح کے ذمہ دار نہیں ہیں۔\n"
]
}
],
"metadata": {
"anaconda-cloud": {},
"colab": {
"name": "notebook.ipynb",
"provenance": []
},
"kernelspec": {
"display_name": "Python 3",
"language": "python",
"name": "python3"
},
"language_info": {
"codemirror_mode": {
"name": "ipython",
"version": 3
},
"file_extension": ".py",
"mimetype": "text/x-python",
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
"version": "3.5.4"
},
"coopTranslator": {
"original_hash": "6301339d1c9a301b00639c635dc9b731",
"translation_date": "2025-10-03T19:12:46+00:00",
"source_file": "2-Working-With-Data/08-data-preparation/notebook.ipynb",
"language_code": "ur"
}
},
"nbformat": 4,
"nbformat_minor": 0
}
Reference in new issue View Git Blame Copy Permalink