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 'main'
${ noResults }
Data-Science-For-Beginners/translations/ur/2-Working-With-Data/08-data-preparation/notebook.ipynb

3721 lines
116 KiB
Raw Permalink 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. ہر کالم کا ڈیٹا ٹائپ: اس ڈیٹا سیٹ میں، تمام ڈیٹا 64-بٹ فلوٹنگ پوائنٹ نمبرز کے طور پر محفوظ کیا گیا ہے۔\n",
"2. نان-نل ویلیوز کی تعداد: نل ویلیوز سے نمٹنا ڈیٹا کی تیاری میں ایک اہم قدم ہے۔ اس پر بعد میں نوٹ بک میں کام کیا جائے گا۔\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",
"\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 پھر بھی انہیں ایک دوسرے کے ساتھ استعمال کرنے کے لیے بنایا گیا ہے۔ اس بات کو سمجھنے کے لیے، ایک `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 کے نقطہ نظر سے یہ null کی نمائندگی نہیں کرتا۔\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 کو ایڈجسٹ کرنے کے لیے دو کالمز کو فلوٹس میں تبدیل کر دیا؟)\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": [
"یہ بات ذہن میں رکھیں کہ یہ خاص طور پر چھوٹے ڈیٹاسیٹس میں آپ کے مطلوبہ ڈیٹا کا کافی حصہ ختم کر سکتا ہے۔ اگر آپ صرف وہ قطاریں یا کالم حذف کرنا چاہتے ہیں جن میں کچھ یا تمام خالی قدریں ہوں، تو آپ `dropna` میں `how` اور `thresh` پیرامیٹرز کے ذریعے یہ ترتیب دے سکتے ہیں۔\n",
"\n",
"ڈیفالٹ کے طور پر، `how='any'` ہوتا ہے (اگر آپ خود چیک کرنا چاہیں یا دیکھنا چاہیں کہ اس میتھڈ کے اور کون سے پیرامیٹرز ہیں، تو کوڈ سیل میں `example4.dropna?` چلائیں)۔ آپ متبادل طور پر `how='all'` بھی استعمال کر سکتے ہیں تاکہ صرف وہ قطاریں یا کالم حذف کیے جائیں جن میں تمام قدریں خالی ہوں۔ آئیے اگلی مشق میں اپنے مثال کے `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. صرف اسی وقت خالی قدروں کو ہٹانا اچھا خیال ہے جب ڈیٹا سیٹ کافی بڑا ہو۔\n",
"2. مکمل قطاریں یا کالم ہٹائے جا سکتے ہیں اگر ان میں زیادہ تر ڈیٹا غائب ہو۔\n",
"3. `DataFrame.dropna(axis=)` میتھڈ خالی قدروں کو ہٹانے میں مدد کرتا ہے۔ `axis` دلیل یہ ظاہر کرتی ہے کہ قطاریں ہٹانی ہیں یا کالم۔\n",
"4. `how` دلیل بھی استعمال کی جا سکتی ہے۔ ڈیفالٹ میں یہ `any` پر سیٹ ہوتی ہے۔ اس لیے یہ صرف ان قطاروں/کالموں کو ہٹاتی ہے جن میں کوئی بھی خالی قدر ہو۔ اسے `all` پر سیٹ کیا جا سکتا ہے تاکہ یہ ظاہر کیا جا سکے کہ ہم صرف ان قطاروں/کالموں کو ہٹائیں گے جہاں تمام قدریں خالی ہوں۔\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": [
"### غیر عددی ڈیٹا (Categorical Data)\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": []
},
{
"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": []
},
{
"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": []
},
{
"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": [
"آپ خالی قدروں کو **آگے بھر** سکتے ہیں، یعنی آخری درست قدر کو استعمال کرتے ہوئے خالی جگہ کو بھرنا:\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",
"\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یہ دستاویز 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": "8533b3a2230311943339963fc7f04c21",
"translation_date": "2025-09-01T22:16:48+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