In this Tutorial, I am going to experiment with the Table class under the Datascience module for some exploratory analysis of the Quran. Let us get started.

First, I used a Quran database already available under Kaggle and brought it under my folder.

below is the standard Kaggle prefix.

# This Python 3 environment comes with many helpful analytics libraries installed
# It is defined by the kaggle/python Docker image: https://github.com/kaggle/docker-python
# For example, here's several helpful packages to load

import numpy as np # linear algebra
import pandas as pd # data processing, CSV file I/O (e.g. pd.read_csv)

# Input data files are available in the read-only "../input/" directory
# For example, running this (by clicking run or pressing Shift+Enter) will list all files under the input directory

import os
for dirname, _, filenames in os.walk('/kaggle/input'):
    for filename in filenames:
        print(os.path.join(dirname, filename))

# You can write up to 5GB to the current directory (/kaggle/working/) that gets preserved as output when you create a version using "Save & Run All" 
# You can also write temporary files to /kaggle/temp/, but they won't be saved outside of the current session

/kaggle/input/quran-makki-madani/quran-toc.csv
/kaggle/input/qurancsv/Quran.csv
/kaggle/input/quran-clean-without-araab/Quran-clean-without-aarab.csv

Next, I have to install the datascience module using pip. Full documentation of this module can be found here.

!pip install datascience

I have ignored the long output of executing the pip function above. So, now let us bring the use of the Table module under the datascience package.

from datascience import *

Here is the first step, reading the table using read_table method.

q = Table.read_table('/kaggle/input/quran-clean-without-araab/Quran-clean-without-aarab.csv')

q

... (6226 rows omitted)

With Table we can show certain number of rows from top, for example

q.show(3)

... (6233 rows omitted)

Similarly we can selec certain columns only

q.select('Ayah')

... (6226 rows omitted)

How many rows are there in this quranic table. In other words, how many total Ayaat are there in the Quran?

q.num_rows

6236

let us see the last row

q.row(q.num_rows-1)

Row(Unnamed: 0=6235, SurahNum=114, AyahNum=6, Ayah='من الجنة والناس')

Counting Words

Let us see how you can apply a function to each row of the Table.

Here is a function that given a sentence will return the number of words in that sentence.

def count_words(item):
    return len(item.split())

Thus, we can apply a function on a table as follows

q.apply(count_words, 'Ayah')

array([4, 4, 2, ..., 4, 5, 3])

given this we can write the following handy code,and assign the result to a new table called qwc meaning quran with word counts.

qwc = q.with_columns("words", q.apply(count_words, 'Ayah'))
qwc

... (6226 rows omitted)

Let me rename the first coulumn from unnamed to SrNo

qwc = qwc.relabeled(0,'SrNo')
qwc

... (6226 rows omitted)

qwc.row(qwc.num_rows-1)

Row(SrNo=6235, SurahNum=114, AyahNum=6, Ayah='من الجنة والناس', words=3)

Find English translation

Notice that the datasource we got does not have English translation. But kaggle has other datasources that has English translations. Sounds like a good use case for joining two tables. Let us do that.

en = Table.read_table('/kaggle/input/qurancsv/Quran.csv')
en

... (6226 rows omitted)

As you can see, we have the English translation under a column called “EnglishTranslation”, here is how to relabel the filed (which is the fourth one if you count from zero) to a shorter column name.

en = en.relabeled(4, 'en')
en

... (6226 rows omitted)

en = en.select(['SrNo', 'en'])
en

... (6226 rows omitted)

I have noticed a problem while checking the ‘SrNo’ of both datasets. The first dataset qwc has SrNo starting from Zero, while the second en starts from 1. So, let us create a new column sr in the second dataset so we have similar ID value to join both tables.

en = en.with_columns('sr', en.column('SrNo')-1).drop('SrNo')
en

... (6226 rows omitted)

en.row(en.num_rows-1)

Row(en='Among Jinns and among men.', sr=6235)

Everything seems in place. So, let us join. It works as follows: Join the first table qwc using the SrNo as the ID with the corresponding table en which has the same ID under column sr. This will append all remaining columns of the second table en to the new table which I chose to name it as quran.

quran = qwc.join('SrNo', en, 'sr')
quran

... (6226 rows omitted)

for convinience let us relable further some long fileds.

quran = quran.relabeled(1, 'sno').relabeled(2,'vno')
quran

... (6226 rows omitted)

Display a verse

So, let us see how to find verse 2:255 in the quran?

quran.where('sno', 2).where('vno',255)

another example: find me first verses of all surahs.

quran.where('vno', 1)

... (104 rows omitted)

Conditional selectivity

With the above example, we need to be mindful of the fact that the Arabic text in this dataset includes the bismillah as the first part of the verse no. 1 of each surah, whereas the English translation does not do that. This have implications on the count of words.

So, let us adjust the words count of the first verse of each surah by discounting 4 words (which is the count of words in Basmalah). But the last caviat is that we do not want to do this discounting on the first chapter of the Quran, because as we know the first verse of Sura Fatiha is a basmalah.

The same goes for Surah at-Tawbah which does not have the basmalah at the start, and hence it should not be discounted.

So, let us start defining a function that does that exactly.

def discount_basmalah(sura_no, verse_no, words):
    if (sura_no==1 or sura_no==9):
        return words
    if (verse_no == 1):
        return words-4
    else:
        return words

all it matters now is to apply that function to each row of the quran.

quran = quran.with_columns('wc', quran.apply(discount_basmalah,'sno','vno', 'words'))
quran

... (6226 rows omitted)

Makki or Madani

Let us bring in another interesting table about the place of revelation, i.e., Makki or Madani. I have brought in the data, so let us join it with out table.

q_place = Table.read_table('/kaggle/input/quran-makki-madani/quran-toc.csv')
q_place

... (104 rows omitted)

Let us just select the two columns that interest us when it comes to joining.

q_select = q_place.select(['No.','Place'])
q_select

... (104 rows omitted)

Everything is ready, so let us do it.

quran = quran.join('sno',q_select,'No.')
quran

... (6226 rows omitted)

we can run a quick analysis of the verse lengths, by using the sort function.

quran.sort('wc', descending=True)

... (6226 rows omitted)

The above tells us that Madani surahs are generally has bigger verse size, and that among the Meccan surahs the verse 20 or surah al-Muzzammil (sno. 73) is the largest among Meccan surah (and 4th largest in the Quran).

If we are interested to know the largest verses in only Meccan surah, then we apply the filter and then do the sort as follows.

quran.where('Place', 'Meccan').sort('wc', descending=True)

... (4603 rows omitted)

The words column in the quran table seems redundent, so we can drop it.

quran2 = quran.drop('words')
quran2

... (6226 rows omitted)

With a small logic, we can have another column that counts the number of characters in each verse. The logic is that we can use len function to count all characters in a verse which includes the whitespace which we can then discount by no. of words plus one. Let us do it.

lc = quran2.apply(len, 'Ayah')-quran2.column('wc')+1

quran2 = quran2.with_columns('lc', lc)
quran2

... (6226 rows omitted)

as previous, I am curious to know which verses has the most letters.

quran2.sort('lc', descending=True)

... (6226 rows omitted)

Having the letter counts would enable lots more analysis on the stylistic properties of the Quran. For example, what is the average size of a single word in the Quran?

np.array(quran2.column('lc')).sum()/np.array(quran2.column('wc')).sum()

4.284034088718074

If we wanted to be a more detailed, we can repeat the same for Meccan and Medinan surahs.

qmeccan = quran2.where('Place','Meccan').select('wc','lc')
np.array(qmeccan.column('lc')).sum()/np.array(qmeccan.column('wc')).sum()

4.242243587052354

qmedinan = quran2.where('Place','Medinan').select('wc','lc')
np.array(qmedinan.column('lc')).sum()/np.array(qmedinan.column('wc')).sum()

4.350044762757386

It shows that on average, Quranic words are around 4.3 letters and that Medinan surahs has slighly bigger word size but not that much significant.

Saving the File

Above was just scratching the surface of what we can do with the Quranic dataset. I will leave the rest for you. Here, I am going to save the Quran Table as a csv file.

quran.to_csv('quran-en-ar-place.csv')

You can play and extend with the above notebook in the Kaggle site.