Text-Fabric-Tutorial_Python_TF.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Introduction to Text-Fabric"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "By Martijn Naaijer (m.naaijer@vu.nl) in collaboration with Cody Kingham (c.a.kingham@student.vu.nl)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Welcome to this course on Text-Fabric. This course will teach you how to extract data from the Eep Talstra Centre for Bible and Computer (ETCBC) database using the Python package Text-Fabric. You do not need to have any Python knowledge to do this course, because you will learn Python and Text-Fabric at the same time.   "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Text-Fabric was developed by Dirk Roorda and Wido van Peursen as part of the SHEBANQ-project. On the [SHEBANQ website](https://shebanq.ancient-data.org/) you can inspect the text of the Hebrew Bible and you can make queries on the Hebrew text. Queries are made by using the Mini Query Language (MQL) with the features of the ETCBC database. Text-fabric serves as a research tool to make datasets that can be analyzed further. The whole ETCBC database is archived at the website of [Data Archiving and Networked Sevices (DANS)](https://easy.dans.knaw.nl/ui/datasets/id/easy-dataset:62732), where it can also be downloaded."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "In this course you will first need to learn some basic Python, before you can start learning to use Text-Fabric."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1. About Python"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We start with some basic things you need to know about the Python language. It includes basic data types, data structures and data flow control. When you have finished this notebook, you should know the following basic Python things:\n",
    "\n",
    "* different data-types (string, integer, float, boolean, list, tuple, dictionary, set)\n",
    "* slicing strings, string concatenation, lower() and upper()\n",
    "* print()\n",
    "* control flow tools (if-statements (if, elif, else), for-loop, range(), while-loop, write your own functions)\n",
    "* use import\n",
    "* export data to text files and csv files\n",
    "\n",
    "There are two versions of Python one can use: Python 2 and Python 3. This notebook works with the newest version, Python 3. Many programmers still use Python 2, because there is no compatibility between Python 3 and the libraries they want to use. If you want to know more about different versions of Python, you can take a look [here](https://wiki.python.org/moin/Python2orPython3)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can find a lot of good information about Python on the internet. A valuable source is the Python documentation: https://docs.python.org/3/"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This introduction to Python is by no means a complete Python course. If you want to know more about Python it is recommended to follow a complete course. Good online courses can be found here:\n",
    "https://www.codecademy.com/learn/python\n",
    "\n",
    "On Coursera you can find many different Python courses. Some are more general, others are focused on data science.\n",
    "https://www.coursera.org/courses?languages=en&query=python"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this file we will extract data from the ETCBC database with Text-Fabric using basic Python programming. However, with Text-Fabric it is also possible to make queries with an MQL-like template, which is called _Search_."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2. Basic Python, Data Types, Print"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We start the course with some basic Python:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello world!\n"
     ]
    }
   ],
   "source": [
    "print(\"Hello world!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This statement prints the text \"Hello world!\". `print()` is a function, and it prints what is inside the parentheses. We call this the argument. The part between the quotes is called a string and it consists of a number of characters, including a space and an exclamation mark. The function `print()` can have multiple arguments."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello world! How are you?\n"
     ]
    }
   ],
   "source": [
    "print(\"Hello world!\", \"How are you?\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can add comments after #. It is strongly recommended to add comments to your code. Comments do not only clarify the code for new readers, but they are also helpful for yourself. Especially if you haven't worked on your code for a while.\n",
    "\n",
    "The string is not the only data type in Python. There are also other data types, such as the integer. In the following cell the value 5 is assigned to the variable a. 5 is an integer. Integers a whole numbers."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = 5  # 5 is an integer."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python stores the data type of an object in memory. You can find out the data type of an object with the function `type()`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'int'>\n"
     ]
    }
   ],
   "source": [
    "print(type(a))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'str'>\n"
     ]
    }
   ],
   "source": [
    "print(type(\"Hello world!\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "The real numbers are a separate data type, called float. In the following cell numeric values are assigned to variable names with the names b, c and d. Assignment takes place with the = sign."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "b = 5.  # this is a float, note the decimal '.'.\n",
    "c = 2.3\n",
    "d = float(5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'float'>\n",
      "<class 'float'>\n",
      "<class 'float'>\n"
     ]
    }
   ],
   "source": [
    "print(type(b))\n",
    "print(type(c))\n",
    "print(type(d))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "You can use the variable name to do calculations."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "25.0\n",
      "3125.0\n"
     ]
    }
   ],
   "source": [
    "print(b * 5)  # multiplication\n",
    "print(b**5)  # power"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It is important to know what the type of an object is. Let's have a look at the difference between a string and an integer."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "What happens if you do `'5' + '5'` ?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'55'"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'5' + '5'  # This is called string concatenation. Strings are 'glued' together. You can do this with any kind of strings,\n",
    "# e.g. 'etc' + 'bc' + '_' + '40'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "The same happens if you do the following."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'55'"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'5' * 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This differs from the addition of two integers."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "5 + 5"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "This happens if you want to add a string to an integer."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "can only concatenate str (not \"int\") to str",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-12-4dd8efb5fac1>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[1;34m'5'\u001b[0m \u001b[1;33m+\u001b[0m \u001b[1;36m5\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m: can only concatenate str (not \"int\") to str"
     ]
    }
   ],
   "source": [
    "'5' + 5"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can convert the string '5' into an integer with `int()`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "num_str = '5'\n",
    "\n",
    "int(num_str) + 5"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Another important data type is the boolean. A boolean variable can have two values: `True` and `False`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "bool"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bool_var = True\n",
    "\n",
    "type(bool_var)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3. Conditions, If Statements"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notice the difference between an assignment (=) and 'is equal to' (==). "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "4 == 5  # this is evaluated to False"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "!= is 'is not equal to' ."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "4 != 5"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There is also > (greater than), < (smaller than), >= (greater than or equal to), and <= (smaller than or equal to)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "4 <= 5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "4 >= 5"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `if` statement checks if a certain condition is evaluated to True."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello,\n"
     ]
    }
   ],
   "source": [
    "a = 0\n",
    "\n",
    "if a == 0:\n",
    "    print('Hello,')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [],
   "source": [
    "if a != 0:\n",
    "    print('Eep')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `if` statament ends with a colon. In Python it is required that the line after the colon is indented (with a tab or 4 spaces). Later you will see the colon also after `for` and `while` statements and in a function header, which starts with `def`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To the `if` statement you can add zero or more `elif`'s and an optional `else`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a is 0\n"
     ]
    }
   ],
   "source": [
    "if a == 0:\n",
    "    print('a is 0')  #what is printed here is one string\n",
    "\n",
    "elif a < 10:\n",
    "    print('a is geater than 0 and smaller than 10')\n",
    "\n",
    "elif a < 15:\n",
    "    print('a is geater than 9 and smaller than 15')\n",
    "\n",
    "else:\n",
    "    print('a is geater than 14')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 4. While Loops"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "With `while` you loop until a specific condition is not evaluated to the value `True` anymore."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n",
      "9\n",
      "8\n",
      "7\n",
      "6\n",
      "5\n",
      "4\n",
      "3\n",
      "2\n",
      "1\n"
     ]
    }
   ],
   "source": [
    "number = 10\n",
    "\n",
    "while number > 0:\n",
    "    print(number)\n",
    "    number -= 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the example above you saw number -= 1. This is a short way of writing `number = number - 1`. Similarly you have +=, \\*= and /= in Python."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n",
      "3\n",
      "4\n",
      "5\n",
      "6\n",
      "7\n",
      "8\n",
      "9\n",
      "10\n",
      "11\n",
      "12\n",
      "13\n",
      "14\n",
      "15\n",
      "16\n",
      "17\n",
      "18\n",
      "19\n",
      "20\n",
      "21\n",
      "22\n",
      "23\n",
      "24\n"
     ]
    }
   ],
   "source": [
    "number2 = 2\n",
    "\n",
    "while number2 < 25:\n",
    "    print(number2)\n",
    "    number2 += 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 5. Writing Functions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You use a function for operations that have to be done more than once in a program. The advantage of using functions is that you need to write the piece of code in the function only once, which keeps your code concise. Every time you want that piece of code to be executed, you call the function.\n",
    "\n",
    "The structure of a function is as follows:\n",
    "\n",
    "\n",
    "def functionName(arg1, arg2, ...):  \n",
    "\"\"\"  \n",
    "This is the docstring, here you explain what the function does. Use triple quotes.\n",
    "It can cover more than one line.  \n",
    "\"\"\"  \n",
    "&nbsp;&nbsp;&nbsp;&nbsp;function body  \n",
    "&nbsp;&nbsp;&nbsp;&nbsp;...  \n",
    "&nbsp;&nbsp;&nbsp;&nbsp;...  \n",
    "&nbsp;&nbsp;&nbsp;&nbsp;return(certain_object)\n",
    "\n",
    "    \n",
    "If a function name consists of more words, as the name functionName, it is good Python style to use camel case, which means that the first letters of the words after the first word are capitalized. There is a whole document about Python style programming. You can find it here: https://www.python.org/dev/peps/pep-0008/ You can refer to it as PEP8. There are many things that you can do in various ways in Python. Often, one of those ways is considered the \"Pythonic way\". This Pythonic way gives you clean and efficient code. Many of these efficient coding manners are described in PEP8."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [],
   "source": [
    "def cubicCalculator(num):\n",
    "    \"\"\"calculates cube of a number\"\"\"\n",
    "\n",
    "    cub_num = num**3\n",
    "    return (cub_num)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The function is called."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "64\n",
      "216\n"
     ]
    }
   ],
   "source": [
    "print(cubicCalculator(4))\n",
    "\n",
    "print(cubicCalculator(6))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you want to work further with the result of a function, you assign its value to a new variable."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [],
   "source": [
    "new_var = cubicCalculator(10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A function often has more than one argument. An argument can have a default value."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [],
   "source": [
    "def addition(num_a, num_b=5):\n",
    "    '''adds two numbers together'''\n",
    "\n",
    "    num_c = num_a + num_b\n",
    "    return (num_c)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the next cell the function is called. The value 10 in the function call corresponds with num_a in the function definition, and the value 12 in the function call corresponds with num_b."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "22\n"
     ]
    }
   ],
   "source": [
    "print(addition(10, 12))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we give the function call only one argument. The second argument gets the default value 5 in this case."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "15\n"
     ]
    }
   ],
   "source": [
    "print(addition(10))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 6. Lists"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A list is an ordered sequence of elements. You can recognize it by its square brackets. Here an empty list is initialized, which is called a_list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [],
   "source": [
    "a_list = []  # this is equivalent to a_list = list()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can add elements to the list with the method `.append()` ."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[40]\n"
     ]
    }
   ],
   "source": [
    "a_list.append(40)\n",
    "\n",
    "print(a_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We add a string to a_list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[40, 'ETCBC']\n"
     ]
    }
   ],
   "source": [
    "a_list.append('ETCBC')\n",
    "\n",
    "print(a_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A list can also be populated manually."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[3, 2, 1, 5]\n"
     ]
    }
   ],
   "source": [
    "unsorted_list = [3, 2, 1, 5]\n",
    "\n",
    "print(unsorted_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can sort a list with the built-in function `sorted()`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 5]\n"
     ]
    }
   ],
   "source": [
    "print(sorted(unsorted_list))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And you can sort it in reversed order with the argument reverse."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[5, 3, 2, 1]\n"
     ]
    }
   ],
   "source": [
    "print(sorted(unsorted_list, reverse=True))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 7. About Text-Fabric"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we start using Text-Fabric. If you want to work with it offline, you need to install it on your computer first. For the installation, look at: https://github.com/ETCBC/text-fabric. \n",
    "\n",
    "In the [API](https://annotation.github.io/text-fabric/cheatsheet.html) you find technical documentation about everything you can do with Text-Fabric."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It is important to know the features of the ETCBC database to be able to work with text-fabric. If you want to know more about the features, check the feature documentation. The following link explains the feature 'nu', the number of a word: https://etcbc.github.io/bhsa/features/nu/"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 8. Importing and Loading Text-Fabric"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Every time you make a notebook in which you want to use text-fabric, you start with the following 'standard' cells. These standard cells import Text-Fabric data into the notebook. You can change the features that you want to load into the notebook, maybe with some slight modifications."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "First import some modules"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [],
   "source": [
    "import sys, collections, os\n",
    "import pprint as pp"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Make sure you have installed text-fabric in Anaconda Prompt first! If not, you can to install it here by uncommenting the first line (simply remove `#`)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#!pip install text-fabric\n",
    "from tf.app import use\n",
    "A = use('bhsa:hot', hoist=globals())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 9. For Loops and Looping over the Nodes in the ETCBC Database."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You are ready to work with text-fabric now. You can select words or clauses or other linguistic units with specific characteristics. In text-fabric you do this by looping over all the objects in the ETCBC database and check for each object whether it has the desired properties. You can do this by making a for loop. With a for loop you loop over a sequence."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can make a numeric sequence with `range()` and loop over it with a `for` loop."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `for` statement ends with a colon. In Python it is required that the line following the colon is indented. Later you will see the colon also after `for` and `while` statements and in a function header, which starts with `def`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n",
      "6\n",
      "7\n",
      "8\n",
      "9\n",
      "10\n",
      "11\n",
      "12\n",
      "13\n",
      "14\n"
     ]
    }
   ],
   "source": [
    "for number in range(15):\n",
    "    print(number)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "Look carefully at what `range()` does in the following examples."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4\n",
      "5\n",
      "6\n",
      "7\n",
      "8\n",
      "9\n",
      "10\n",
      "11\n",
      "12\n",
      "13\n",
      "14\n"
     ]
    }
   ],
   "source": [
    "for number in range(4, 15):  # with two arguments we have range(start, stop)\n",
    "    print(number)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4\n",
      "6\n",
      "8\n",
      "10\n",
      "12\n",
      "14\n"
     ]
    }
   ],
   "source": [
    "for number in range(\n",
    "        4, 15, 2):  # with three arguments we have range(start, stop, step)\n",
    "    print(number)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that the arguments of `range()` are integers."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Instead of just printing the integers, you can store them in a list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14]\n"
     ]
    }
   ],
   "source": [
    "integer_list = []\n",
    "\n",
    "for number in range(15):\n",
    "    integer_list.append(number)\n",
    "\n",
    "print(integer_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "Note that the `print` statement in the previous cell is not indented. If we indent it it falls within the `for` loop:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0]\n",
      "[0, 1]\n",
      "[0, 1, 2]\n",
      "[0, 1, 2, 3]\n",
      "[0, 1, 2, 3, 4]\n",
      "[0, 1, 2, 3, 4, 5]\n",
      "[0, 1, 2, 3, 4, 5, 6]\n",
      "[0, 1, 2, 3, 4, 5, 6, 7]\n",
      "[0, 1, 2, 3, 4, 5, 6, 7, 8]\n",
      "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]\n",
      "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]\n",
      "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]\n",
      "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]\n",
      "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13]\n",
      "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14]\n"
     ]
    }
   ],
   "source": [
    "integer_list = []\n",
    "\n",
    "for number in range(15):\n",
    "    integer_list.append(number)\n",
    "    print(integer_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now the print statement is executed 15 times, and each time an extra integer is added to the list. If you want to get a good impression of what your code does exactly, it can be useful to print something within a `for` loop. So, while coding it can help you to print intermediate results. However, if the `for` loop loops over a large amount of elements (for instance hundreds of thousands or even millions) your code may become very slow, and the large amount of printed text may not be so illuminating anymore."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Data Model"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In text-fabric the ETCBC-database is constructed as a graph database. A graph consists of nodes, which are linked to each other with edges. The objects in the database are textual objects. These can be words, phrases, clauses, et cetera. The edges between the nodes indicate that certain objects are included in other objects (for instance, the words in a clause), but the edges can also indicate other linguistic relationships. If you want to know more about the data model, which is recommended, read the [Text-Fabric documentation on the data model](https://annotation.github.io/text-fabric)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We are ready now to do the first search in the ETCBC database. We want to find out what the names of the biblical books are. We do this by looping over all the objects in the database and if we encounter a book, we print its name."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Genesis\n",
      "Exodus\n",
      "Leviticus\n",
      "Numeri\n",
      "Deuteronomium\n",
      "Josua\n",
      "Judices\n",
      "Samuel_I\n",
      "Samuel_II\n",
      "Reges_I\n",
      "Reges_II\n",
      "Jesaia\n",
      "Jeremia\n",
      "Ezechiel\n",
      "Hosea\n",
      "Joel\n",
      "Amos\n",
      "Obadia\n",
      "Jona\n",
      "Micha\n",
      "Nahum\n",
      "Habakuk\n",
      "Zephania\n",
      "Haggai\n",
      "Sacharia\n",
      "Maleachi\n",
      "Psalmi\n",
      "Iob\n",
      "Proverbia\n",
      "Ruth\n",
      "Canticum\n",
      "Ecclesiastes\n",
      "Threni\n",
      "Esther\n",
      "Daniel\n",
      "Esra\n",
      "Nehemia\n",
      "Chronica_I\n",
      "Chronica_II\n"
     ]
    }
   ],
   "source": [
    "for node in N.walk(\n",
    "):  # N.walk() is a so-called generator. With this line of code you loop over all the nodes in the database.\n",
    "    if F.otype.v(node) == 'book':\n",
    "        print(F.book.v(node))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "What has happened here? In the first line the for loop loops over all the objects (nodes) in the database.\n",
    "In the second line for each node is checked if its object type is 'book'. It is crucial to understand this line, especially this part: F.otype.v(node). F is the class of all node features. otype stands for object type, and v returns the value of the feature for a specific node. In other words, for every F.otype.v(node) returns the object type of every node, and with `if F.otype.v(node) == 'book':` it is checked if this value is equal to 'book'. If this condition is evaluated to True, in the third line the value of the feature book is returned for this node, which is the name of the book."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 10. Lists and Retrieving Booknames and Lexemes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We use the same script as above, which produces the names of the biblical books, and store them in a list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Genesis', 'Exodus', 'Leviticus', 'Numeri', 'Deuteronomium', 'Josua', 'Judices', 'Samuel_I', 'Samuel_II', 'Reges_I', 'Reges_II', 'Jesaia', 'Jeremia', 'Ezechiel', 'Hosea', 'Joel', 'Amos', 'Obadia', 'Jona', 'Micha', 'Nahum', 'Habakuk', 'Zephania', 'Haggai', 'Sacharia', 'Maleachi', 'Psalmi', 'Iob', 'Proverbia', 'Ruth', 'Canticum', 'Ecclesiastes', 'Threni', 'Esther', 'Daniel', 'Esra', 'Nehemia', 'Chronica_I', 'Chronica_II']\n"
     ]
    }
   ],
   "source": [
    "book_list = []  # an empty list is initialized.\n",
    "\n",
    "for node in N.walk():\n",
    "    if F.otype.v(node) == 'book':\n",
    "        book_name = F.book.v(node)\n",
    "        book_list.append(\n",
    "            book_name)  # every book name is appended to the list book_list\n",
    "\n",
    "print(book_list)  # book_list can be accessed later."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can check if a certain element is in a list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'Genesis' in book_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 62,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'Genesis' not in book_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 63,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'Henoch' in book_list"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you want to know what the number of elements in a list is, you use the built-in function `len()`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "39\n"
     ]
    }
   ],
   "source": [
    "print(len(book_list))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the following cell we modify the code a little bit. Instead of selecting books, words are selected, and their lexemes are retrieved witht the feature lex. Each lexeme is stored in the list lex_list. The objects in the database are only abstract entities, and we can get information from them by using features that are related to the object type. lex is a feature that is characteristic of the word object."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [],
   "source": [
    "lex_list = []\n",
    "\n",
    "for node in N.walk():\n",
    "    if F.otype.v(node) == 'word':\n",
    "        lexeme = F.lex.v(node)\n",
    "        lex_list.append(lexeme)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "What is the length of this list?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "426584\n"
     ]
    }
   ],
   "source": [
    "print(len(lex_list))  # this is a long list!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We want to retrieve the first element in this list. You can do this by using an index with []. The first element in a list is retrieved with index 0, because Python is zero based."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "B\n"
     ]
    }
   ],
   "source": [
    "print(lex_list[0])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we would like to find out what the first ten elements of the list are."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['B', 'R>CJT/', 'BR>[', '>LHJM/', '>T', 'H', 'CMJM/', 'W', '>T']\n"
     ]
    }
   ],
   "source": [
    "print(lex_list[0:9])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "You recognize the first ten words in the book of Genesis."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "What is the lexeme of the last word in the Hebrew Bible? The last element in a list is retrieved with index -1."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<LH[\n"
     ]
    }
   ],
   "source": [
    "print(lex_list[-1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And the last ten elements? There is nothing after the colon, which means that it looks for everything from the tenth last element until the last element"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['MJ', 'B', 'MN', 'KL/', '<M/', 'JHWH/', '>LHJM/', '<M', 'W', '<LH[']\n"
     ]
    }
   ],
   "source": [
    "print(lex_list[-10:])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can choose any range that we want, of course."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['JCB[', 'B', 'BJT/', 'W', 'B', 'HLK[', 'B', 'H', 'DRK/', 'W', 'B', 'CKB[', 'W', 'B', 'QWM[', 'W', 'KTB[', '<L', 'MZWZH/', 'BJT/', 'W', 'B', 'C<R/', 'LM<N', 'RBH[', 'JWM/', 'W', 'JWM/', 'BN/', '<L', 'H', '>DMH/', '>CR', 'CB<[', 'JHWH/', 'L', '>B/', 'L', 'NTN[', 'L', 'K', 'JWM/', 'H', 'CMJM/', '<L', 'H', '>RY/', 'KJ', '>M', 'CMR[', 'CMR[', '>T', 'KL/', 'H', 'MYWH/']\n"
     ]
    }
   ],
   "source": [
    "print(lex_list[100000:100055]\n",
    "      )  # do you see in which biblical book this fragment can be found?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 11. Some Details about Lists and Strings"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A Python list can contain elements of different data types."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'bool'>\n",
      "<class 'int'>\n",
      "<class 'float'>\n",
      "<class 'str'>\n"
     ]
    }
   ],
   "source": [
    "varied_list = [True, 5, 5.0, 'Hebrew']\n",
    "\n",
    "print(type(varied_list[0]))\n",
    "print(type(varied_list[1]))\n",
    "print(type(varied_list[2]))\n",
    "print(type(varied_list[3]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The following does not work."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [
    {
     "ename": "IndexError",
     "evalue": "list index out of range",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mIndexError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-73-d75aa2ddf8e5>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mtype\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mvaried_list\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m4\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mIndexError\u001b[0m: list index out of range"
     ]
    }
   ],
   "source": [
    "print(type(varied_list[4]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The elements of a list can also be lists."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2]\n"
     ]
    }
   ],
   "source": [
    "list_of_lists = [[1, 2], [3, 4], [5, 6]]  # this is a list of lists.\n",
    "# you can also say that three lists are nested in list_of_lists.\n",
    "\n",
    "print(list_of_lists[0])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We use a double index to access the individual integers."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n"
     ]
    }
   ],
   "source": [
    "print(list_of_lists[0][1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A list comprehension is a fast and clean way to create a list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[144, 169, 196, 225, 256, 289, 324, 361]\n"
     ]
    }
   ],
   "source": [
    "another_list = [number**2 for number in range(12, 20)]\n",
    "\n",
    "print(another_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can find the minimum and maximum values in a list with the functions `min()` and `max()`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "144\n",
      "361\n"
     ]
    }
   ],
   "source": [
    "print(min(another_list))\n",
    "\n",
    "print(max(another_list))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It can be very useful to retrieve the position of a certain value in a list. You do that with the method `.index()`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "7\n"
     ]
    }
   ],
   "source": [
    "highest_value = max(another_list)\n",
    "\n",
    "pos_of_highest = another_list.index(highest_value)\n",
    "\n",
    "print(pos_of_highest)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here is an example of a list comprehension with strings. Look at what `lower()` and `upper()` do."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [],
   "source": [
    "books_list = ['Genesis', 'Exodus', 'Leviticus']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['genesis', 'exodus', 'leviticus']\n"
     ]
    }
   ],
   "source": [
    "book_list_lower = [book.lower() for book in books_list]\n",
    "\n",
    "print(book_list_lower)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['GENESIS', 'EXODUS', 'LEVITICUS']\n"
     ]
    }
   ],
   "source": [
    "book_list_upper = [book.upper() for book in books_list]\n",
    "\n",
    "print(book_list_upper)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Often you need to make slices of a string."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {},
   "outputs": [],
   "source": [
    "book_string = 'Genesis'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you want to retrieve the first character of a string, you use the index 0."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "G\n"
     ]
    }
   ],
   "source": [
    "print(book_string[0])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And if you need the first three character, you use the index 0:3."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Gen\n"
     ]
    }
   ],
   "source": [
    "print(book_string[0:3])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you want to know the last character, the index is -1."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "s\n"
     ]
    }
   ],
   "source": [
    "print(book_string[-1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And finally, if you want to know the last three letters, you use -3: . "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "sis\n"
     ]
    }
   ],
   "source": [
    "print(book_string[-3:])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 12. Dictionaries and Counting Object Types"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Which object types are there in the ETCBC database and how many of each of them? This is a problem that is slightly more difficult. We will walk through all the nodes again, but we have to keep track of all of them at the same time. To be able to do this, we introduce a new data type, the dictionary."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A dictionary is a structure which contains key-value pairs. You can recognize a dictionary by the curly brackets. A dictionary is initialized as follows."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {},
   "outputs": [],
   "source": [
    "geo_dict = {\n",
    "    'Netherlands': 'Amsterdam',\n",
    "    'Germany': 'Berlin',\n",
    "    'Belgium': 'Brussels',\n",
    "    'Italy': 'Rome'\n",
    "}\n",
    "\n",
    "# the dict geo_dict is populated manually. An empty dict would be initialized with:\n",
    "# geo_dict = {}\n",
    "# or: geo_dict = dict()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The geo_dict contains four keys, 'Netherlands', 'Belgium','Germany', and 'Italy', and four values. Between key and value you see a colon, and the key:value pairs are separated by comma's. How many elements does this dictionary contain?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4\n"
     ]
    }
   ],
   "source": [
    "geo_dict_len = len(geo_dict)\n",
    "\n",
    "print(geo_dict_len)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can retrieve the value of a specific key as follows."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Amsterdam\n"
     ]
    }
   ],
   "source": [
    "print(geo_dict['Netherlands'])  # returns the value of the key 'Netherlands'."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can add new key:value pairs to a dictionary."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'Netherlands': 'Amsterdam', 'Germany': 'Berlin', 'Belgium': 'Brussels', 'Italy': 'Rome', 'USA': 'Baton Rouge'}\n"
     ]
    }
   ],
   "source": [
    "geo_dict['USA'] = 'Baton Rouge'\n",
    "\n",
    "print(geo_dict)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you want to iterate over all the keys, you use .keys() ."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Amsterdam\n",
      "Berlin\n",
      "Brussels\n",
      "Rome\n",
      "Baton Rouge\n"
     ]
    }
   ],
   "source": [
    "for country in geo_dict.keys():\n",
    "    print(geo_dict[country])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A specific key can only occur once in a dictionary, it's keys are unique. What happens if we add an existing key with a new value?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'Netherlands': 'Amsterdam', 'Germany': 'Berlin', 'Belgium': 'Brussels', 'Italy': 'Rome', 'USA': 'Amsterdam'}\n"
     ]
    }
   ],
   "source": [
    "geo_dict['USA'] = 'Amsterdam'\n",
    "\n",
    "print(geo_dict)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You see the old value is overwritten."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There is no order in a dictionary. If you want to get the capitals in a certain order, you need an alternative solution, for instance an iteration over an ordered structure like a list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Amsterdam\n",
      "Berlin\n",
      "Brussels\n",
      "Rome\n"
     ]
    }
   ],
   "source": [
    "for country in ['Netherlands', 'Germany', 'Belgium', 'Italy']:\n",
    "    print(geo_dict[country])  # returns capitals in alphabetical order"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can use a dictionary to count elements in a list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "metadata": {},
   "outputs": [],
   "source": [
    "letter_list = ['a', 'b', 'c', 'a', 'b', 'c', 'b', 'b', 'b']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'a': 2, 'b': 5, 'c': 2}\n"
     ]
    }
   ],
   "source": [
    "let_count_dict = {}\n",
    "\n",
    "for letter in letter_list:\n",
    "    if letter in let_count_dict:\n",
    "        let_count_dict[letter] += 1\n",
    "    else:\n",
    "        let_count_dict[letter] = 0\n",
    "        let_count_dict[letter] += 1\n",
    "\n",
    "print(let_count_dict)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can make this code slightly shorter by using the `defaultdict()` from the collections library. A library is a package which contains a number of functions. You get access to these functions with the import statement. Many libraries need to be downloaded an installed before you can use them."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "metadata": {},
   "outputs": [],
   "source": [
    "import collections"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "defaultdict(<class 'int'>, {'a': 2, 'b': 5, 'c': 2})\n"
     ]
    }
   ],
   "source": [
    "let_default_dict = collections.defaultdict(int)\n",
    "for letter in letter_list:\n",
    "    let_default_dict[letter] += 1\n",
    "\n",
    "print(let_default_dict)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Or you can make the code even shorter with `Counter()`, also from the collections library."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Counter({'b': 5, 'a': 2, 'c': 2})\n"
     ]
    }
   ],
   "source": [
    "let_counter_dict = collections.Counter(letter_list)\n",
    "\n",
    "print(let_counter_dict)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can also use `Counter()` to count the characters in a string."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Counter({'d': 6, 'j': 5, 'k': 4, 'n': 3, 'l': 3, 'c': 2, 'f': 2, ' ': 2, 'a': 1, 's': 1, 'h': 1, ';': 1, 'x': 1})\n"
     ]
    }
   ],
   "source": [
    "random_string = 'ajskddhcjcjfnfn  djddllk;xlkkdjn'\n",
    "\n",
    "let_counter_dict2 = collections.Counter(random_string)\n",
    "\n",
    "print(let_counter_dict2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we return to text-fabric. Which object types are there in the ETCBC database and how many are there of each? In the following cell they are counted.\n",
    "The total number of objects is called n. The different types of objects are counted in the dictionary called 'object_types'. This is a defaultdict() from the collections module. Using the defaultdict instaed of an ordinary dictionary has the advantage that new keys in the dictionary do not need to be initialized explicitly."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1446799 defaultdict(<class 'int'>, {'book': 39, 'chapter': 929, 'verse': 23213, 'sentence': 63727, 'sentence_atom': 64525, 'clause': 88121, 'clause_atom': 90688, 'half_verse': 45180, 'phrase': 253207, 'phrase_atom': 267541, 'lex': 9233, 'word': 426584, 'subphrase': 113812})\n"
     ]
    }
   ],
   "source": [
    "n = 0\n",
    "object_types = collections.defaultdict(int)\n",
    "\n",
    "for node in N.walk():\n",
    "    n += 1\n",
    "    object_types[F.otype.v(node)] += 1\n",
    "\n",
    "print(n, object_types)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "With `for node in N.walk():` you walk through all the nodes (or objects) in the database. This script will add 1 to the variable n every time it sees a new node. The next line of code is a bit more complex. Of every node, it asks what kind of object it is using the feature \"otype\". Note that this feature does not need to be initialized when you import Text_Fabric."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When object_types is initialized it is still an empty dictionary. Once it encounters the first node, it checks the object-type, adds that object-type to the dictionary and adds 1 to its initial value 0. In `F.otype.v()`, F is the class of object features, which is followed by the name of the feature. This is followed by v, which stands for the value of the feature. The values for the feature otype are word, clause, sentence, and so on."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Compare `print()` with `pprint()` from the pprint module. It prints a dictionary in a clear way in alphabetical order."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "defaultdict(<class 'int'>,\n",
      "            {'book': 39,\n",
      "             'chapter': 929,\n",
      "             'clause': 88121,\n",
      "             'clause_atom': 90688,\n",
      "             'half_verse': 45180,\n",
      "             'lex': 9233,\n",
      "             'phrase': 253207,\n",
      "             'phrase_atom': 267541,\n",
      "             'sentence': 63727,\n",
      "             'sentence_atom': 64525,\n",
      "             'subphrase': 113812,\n",
      "             'verse': 23213,\n",
      "             'word': 426584})\n"
     ]
    }
   ],
   "source": [
    "pp.pprint(object_types)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "The result is clear, the database contains 39 books, 929 chapters, and so on."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If we would not have used the `defaultdict()`, the script would have looked like this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1446799 {'book': 39, 'chapter': 929, 'verse': 23213, 'sentence': 63727, 'sentence_atom': 64525, 'clause': 88121, 'clause_atom': 90688, 'half_verse': 45180, 'phrase': 253207, 'phrase_atom': 267541, 'lex': 9233, 'word': 426584, 'subphrase': 113812}\n"
     ]
    }
   ],
   "source": [
    "n = 0\n",
    "object_types = {}\n",
    "\n",
    "for node in N.walk():\n",
    "    n += 1\n",
    "    if F.otype.v(node) in object_types:\n",
    "        object_types[F.otype.v(node)] += 1\n",
    "    else:\n",
    "        object_types[F.otype.v(node)] = 1\n",
    "        # the object-type has to be initialized\n",
    "\n",
    "print(n, object_types)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There is a more efficient way of walking through the nodes. In general you do not need information from all the objects, but only from one specific object-type, for instance words. If this is the case, you do the following:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "426584\n"
     ]
    }
   ],
   "source": [
    "word_count = 0\n",
    "\n",
    "for word in F.otype.s('word'):  # now you walk through the word nodes only. You can do this with all the object types.\n",
    "    word_count += 1\n",
    "\n",
    "print(word_count)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In previous examples you have seen that dictionaries are useful if you want to count things, for instance object types. It becomes a bit more difficult if you want to count the object types in each book of the Hebrew Bible. How many words, clauses, sentences, and so on can be found in each book? We solve this problem by using embedded dictionaries."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 104,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "defaultdict(<function <lambda> at 0x0000013D100DCC18>,\n",
      "            {'1_Chronicles': defaultdict(<class 'int'>,\n",
      "                                         {'book': 1,\n",
      "                                          'chapter': 29,\n",
      "                                          'clause': 2514,\n",
      "                                          'clause_atom': 2577,\n",
      "                                          'half_verse': 1609,\n",
      "                                          'lex': 515,\n",
      "                                          'phrase': 7189,\n",
      "                                          'phrase_atom': 8336,\n",
      "                                          'sentence': 1856,\n",
      "                                          'sentence_atom': 1891,\n",
      "                                          'subphrase': 5828,\n",
      "                                          'verse': 943,\n",
      "                                          'word': 15564}),\n",
      "             '1_Kings': defaultdict(<class 'int'>,\n",
      "                                    {'book': 1,\n",
      "                                     'chapter': 22,\n",
      "                                     'clause': 3596,\n",
      "                                     'clause_atom': 3701,\n",
      "                                     'half_verse': 1593,\n",
      "                                     'lex': 233,\n",
      "                                     'phrase': 10684,\n",
      "                                     'phrase_atom': 11578,\n",
      "                                     'sentence': 2512,\n",
      "                                     'sentence_atom': 2535,\n",
      "                                     'subphrase': 4686,\n",
      "                                     'verse': 817,\n",
      "                                     'word': 18685}),\n",
      "             '1_Samuel': defaultdict(<class 'int'>,\n",
      "                                     {'book': 1,\n",
      "                                      'chapter': 31,\n",
      "                                      'clause': 4012,\n",
      "                                      'clause_atom': 4079,\n",
      "                                      'half_verse': 1608,\n",
      "                                      'lex': 244,\n",
      "                                      'phrase': 12194,\n",
      "                                      'phrase_atom': 12612,\n",
      "                                      'sentence': 3124,\n",
      "                                      'sentence_atom': 3131,\n",
      "                                      'subphrase': 3786,\n",
      "                                      'verse': 811,\n",
      "                                      'word': 18929}),\n",
      "             '2_Chronicles': defaultdict(<class 'int'>,\n",
      "                                         {'book': 1,\n",
      "                                          'chapter': 36,\n",
      "                                          'clause': 3317,\n",
      "                                          'clause_atom': 3439,\n",
      "                                          'half_verse': 1599,\n",
      "                                          'lex': 67,\n",
      "                                          'phrase': 10155,\n",
      "                                          'phrase_atom': 11144,\n",
      "                                          'sentence': 2244,\n",
      "                                          'sentence_atom': 2271,\n",
      "                                          'subphrase': 6146,\n",
      "                                          'verse': 822,\n",
      "                                          'word': 19764}),\n",
      "             '2_Kings': defaultdict(<class 'int'>,\n",
      "                                    {'book': 1,\n",
      "                                     'chapter': 25,\n",
      "                                     'clause': 3400,\n",
      "                                     'clause_atom': 3506,\n",
      "                                     'half_verse': 1425,\n",
      "                                     'lex': 247,\n",
      "                                     'phrase': 10024,\n",
      "                                     'phrase_atom': 10832,\n",
      "                                     'sentence': 2530,\n",
      "                                     'sentence_atom': 2544,\n",
      "                                     'subphrase': 4672,\n",
      "                                     'verse': 719,\n",
      "                                     'word': 17307}),\n",
      "             '2_Samuel': defaultdict(<class 'int'>,\n",
      "                                     {'book': 1,\n",
      "                                      'chapter': 24,\n",
      "                                      'clause': 3185,\n",
      "                                      'clause_atom': 3253,\n",
      "                                      'half_verse': 1370,\n",
      "                                      'lex': 274,\n",
      "                                      'phrase': 9585,\n",
      "                                      'phrase_atom': 10181,\n",
      "                                      'sentence': 2406,\n",
      "                                      'sentence_atom': 2418,\n",
      "                                      'subphrase': 3398,\n",
      "                                      'verse': 695,\n",
      "                                      'word': 15612}),\n",
      "             'Amos': defaultdict(<class 'int'>,\n",
      "                                 {'book': 1,\n",
      "                                  'chapter': 9,\n",
      "                                  'clause': 639,\n",
      "                                  'clause_atom': 647,\n",
      "                                  'half_verse': 288,\n",
      "                                  'lex': 35,\n",
      "                                  'phrase': 1849,\n",
      "                                  'phrase_atom': 1915,\n",
      "                                  'sentence': 451,\n",
      "                                  'sentence_atom': 457,\n",
      "                                  'subphrase': 642,\n",
      "                                  'verse': 146,\n",
      "                                  'word': 2780}),\n",
      "             'Daniel': defaultdict(<class 'int'>,\n",
      "                                   {'book': 1,\n",
      "                                    'chapter': 12,\n",
      "                                    'clause': 1732,\n",
      "                                    'clause_atom': 1817,\n",
      "                                    'half_verse': 704,\n",
      "                                    'lex': 579,\n",
      "                                    'phrase': 5074,\n",
      "                                    'phrase_atom': 5295,\n",
      "                                    'sentence': 1155,\n",
      "                                    'sentence_atom': 1164,\n",
      "                                    'subphrase': 2126,\n",
      "                                    'verse': 357,\n",
      "                                    'word': 8072}),\n",
      "             'Deuteronomy': defaultdict(<class 'int'>,\n",
      "                                        {'book': 1,\n",
      "                                         'chapter': 34,\n",
      "                                         'clause': 3859,\n",
      "                                         'clause_atom': 4012,\n",
      "                                         'half_verse': 1867,\n",
      "                                         'lex': 323,\n",
      "                                         'phrase': 11542,\n",
      "                                         'phrase_atom': 12310,\n",
      "                                         'sentence': 2354,\n",
      "                                         'sentence_atom': 2379,\n",
      "                                         'subphrase': 5046,\n",
      "                                         'verse': 959,\n",
      "                                         'word': 20127}),\n",
      "             'Ecclesiastes': defaultdict(<class 'int'>,\n",
      "                                         {'book': 1,\n",
      "                                          'chapter': 12,\n",
      "                                          'clause': 998,\n",
      "                                          'clause_atom': 1024,\n",
      "                                          'half_verse': 425,\n",
      "                                          'lex': 52,\n",
      "                                          'phrase': 2722,\n",
      "                                          'phrase_atom': 2772,\n",
      "                                          'sentence': 575,\n",
      "                                          'sentence_atom': 593,\n",
      "                                          'subphrase': 810,\n",
      "                                          'verse': 222,\n",
      "                                          'word': 4233}),\n",
      "             'Esther': defaultdict(<class 'int'>,\n",
      "                                   {'book': 1,\n",
      "                                    'chapter': 10,\n",
      "                                    'clause': 733,\n",
      "                                    'clause_atom': 785,\n",
      "                                    'half_verse': 324,\n",
      "                                    'lex': 80,\n",
      "                                    'phrase': 2291,\n",
      "                                    'phrase_atom': 2502,\n",
      "                                    'sentence': 434,\n",
      "                                    'sentence_atom': 451,\n",
      "                                    'subphrase': 1356,\n",
      "                                    'verse': 167,\n",
      "                                    'word': 4621}),\n",
      "             'Exodus': defaultdict(<class 'int'>,\n",
      "                                   {'book': 1,\n",
      "                                    'chapter': 40,\n",
      "                                    'clause': 4326,\n",
      "                                    'clause_atom': 4454,\n",
      "                                    'half_verse': 2358,\n",
      "                                    'lex': 633,\n",
      "                                    'phrase': 13238,\n",
      "                                    'phrase_atom': 13784,\n",
      "                                    'sentence': 3227,\n",
      "                                    'sentence_atom': 3262,\n",
      "                                    'subphrase': 6998,\n",
      "                                    'verse': 1213,\n",
      "                                    'word': 23748}),\n",
      "             'Ezekiel': defaultdict(<class 'int'>,\n",
      "                                    {'book': 1,\n",
      "                                     'chapter': 48,\n",
      "                                     'clause': 5534,\n",
      "                                     'clause_atom': 5683,\n",
      "                                     'half_verse': 2477,\n",
      "                                     'lex': 286,\n",
      "                                     'phrase': 15801,\n",
      "                                     'phrase_atom': 16418,\n",
      "                                     'sentence': 4094,\n",
      "                                     'sentence_atom': 4150,\n",
      "                                     'subphrase': 7400,\n",
      "                                   "
     ]
    },
    {
     "data": {
      "text/html": [
       "<b>limit_output extension: Maximum message size of 10000 exceeded with 29475 characters</b>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "obj_per_book_dict = collections.defaultdict(lambda: collections.defaultdict(\n",
    "    int))  #we do not discuss the syntax of lambda here\n",
    "\n",
    "for node in N.walk():\n",
    "    where = T.sectionFromNode(node)\n",
    "    book = where[0]  # now we know the book\n",
    "    obj_type = F.otype.v(node)  #now we know the object type\n",
    "    obj_per_book_dict[book][obj_type] += 1\n",
    "\n",
    "pp.pprint(obj_per_book_dict)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For information about lambda, read the [Python documentation](https://docs.python.org/3/tutorial/controlflow.html)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 13. More Features and Tuples"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you want to know which range of slots is used for one specific object, you use sInterval."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 105,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 426584)\n",
      "(651542, 904748)\n",
      "(427553, 515673)\n"
     ]
    }
   ],
   "source": [
    "print(F.otype.sInterval('word'))\n",
    "\n",
    "print(F.otype.sInterval('phrase'))\n",
    "\n",
    "print(F.otype.sInterval('clause'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We have seen the word feature lex, but there are more features, such as sp, part of speech."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 106,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "prep\n",
      "subs\n",
      "verb\n",
      "subs\n",
      "prep\n",
      "art\n",
      "subs\n",
      "conj\n",
      "prep\n",
      "art\n"
     ]
    }
   ],
   "source": [
    "for word_slot in range(1, 11):\n",
    "    print(F.sp.v(word_slot))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We saw that the range of phrases is (605144, 858317). What are the phrase types and phrase functions of the first ten phrases within this range?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 107,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "InfC None\n",
      "ZIm0 None\n",
      "ZYq0 None\n",
      "WayX None\n",
      "InfC None\n",
      "Defc None\n",
      "NmCl None\n",
      "ZQt0 None\n",
      "NmCl None\n"
     ]
    }
   ],
   "source": [
    "for phr in range(605144, 605153):\n",
    "    print(F.typ.v(phr), F.function.v(phr))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In which book can you find word slot 100000? To be able to locate it, use T.sectionfromNode(), which returns a tuple with the book (by default in English), chapter and verse."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 108,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('Deuteronomy', 11, 19)"
      ]
     },
     "execution_count": 108,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "T.sectionFromNode(100000)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you need the name of the book in a different language, you use the argument \"lang\"."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 109,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('Deutéronome', 11, 19)"
      ]
     },
     "execution_count": 109,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "T.sectionFromNode(100000, lang='fr')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "T.sectionFromNode returns a tuple. A tuple is also an ordered sequence of elements, but its values are immutable. It elements can be indexed with [] and a tuple can be recognized by the parentheses that embrace it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 110,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n"
     ]
    }
   ],
   "source": [
    "this_tuple = (2, 4, 4, 5)\n",
    "\n",
    "print(this_tuple[3])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`T.sectionFromNode()` returns a tuple of length 3."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 111,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n"
     ]
    }
   ],
   "source": [
    "print(len(T.sectionFromNode(10)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The tuple starts with the biblical book of a node."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 112,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Genesis\n"
     ]
    }
   ],
   "source": [
    "print(T.sectionFromNode(10)[0])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Another way of accessing the elements in the tuple is by using tuple unpacking. As already said, `T.sectionFromNode()` returns a tuple with three elements, which are book, chapter and verse. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 113,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Genesis\n",
      "1\n",
      "1\n"
     ]
    }
   ],
   "source": [
    "book, chapter, verse = T.sectionFromNode(\n",
    "    10\n",
    ")  # each element on the left hand side corresponds to an element in the tuple.\n",
    "\n",
    "print(book)\n",
    "\n",
    "print(chapter)\n",
    "\n",
    "print(verse)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We have seen the feature \"lex\", which is a word feature. Other important word features are \"sp\" (part of speech), \"gn\" (gender), \"nu\" (number), \"vt\" (verbal tense), \"vs\" (verbal stem). The latter two have a value only if the word is a verb. Suppose you want to know the values of all of these features of the first 10 words of Genesis, we do this: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 114,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "B prep NA NA NA NA\n",
      "R>CJT/ subs f sg NA NA\n",
      "BR>[ verb m sg perf qal\n",
      ">LHJM/ subs m pl NA NA\n",
      ">T prep NA NA NA NA\n",
      "H art NA NA NA NA\n",
      "CMJM/ subs m pl NA NA\n",
      "W conj NA NA NA NA\n",
      ">T prep NA NA NA NA\n",
      "H art NA NA NA NA\n"
     ]
    }
   ],
   "source": [
    "for word in F.otype.s('word'):\n",
    "    if word < 11:  # an alternative way of finding the first 10 words\n",
    "        print(F.lex.v(word), F.sp.v(word), F.gn.v(word), F.nu.v(word),\n",
    "              F.vt.v(word), F.vs.v(word))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If a feature has no value in the case of a specific word, NA is returned."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 14. Sets and Counting the Number of Unique Lexemes in the Hebrew Bible"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The set is another basic data type in Python. In contrast to the list it contains unique elements only without order. You can use a set if you want to know which unique elements there are in a large mount of data. First we look at a simple example."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 115,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "set()\n"
     ]
    }
   ],
   "source": [
    "integer_set = set()  # an empty set is initialized\n",
    "\n",
    "print(integer_set)  # prints the empty set"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "With .add() you can add an element to a set. In this case we add the integer 5."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 116,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{5}\n"
     ]
    }
   ],
   "source": [
    "integer_set.add(5)\n",
    "\n",
    "print(integer_set)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we add another integer."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 117,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{27, 5}\n"
     ]
    }
   ],
   "source": [
    "integer_set.add(27)\n",
    "\n",
    "print(integer_set)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we try to add 5 again."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 118,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{27, 5}\n"
     ]
    }
   ],
   "source": [
    "integer_set.add(5)\n",
    "\n",
    "print(integer_set)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now you see that the set still contains 27 and 5 only once, because the set becomes bigger only if a new unique element is added."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "In the following cell we investigate how many unique lexemes occur in the Hebrew parts of the Hebrew Bible."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 119,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n"
     ]
    }
   ],
   "source": [
    "lex_set = set()\n",
    "\n",
    "for word in F.otype.s('word'):\n",
    "    if F.language.v(word) == 'hbo':\n",
    "        lex_set.add(F.lex.v(word))\n",
    "\n",
    "#print(lex_set) #uncomment this line if you want to see the whole set of lexemes. You will see that there is no specific order\n",
    "print(len(lex_set))  # returns the number of elements in the set"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Use a Set or a List?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You could have solved the problem of counting the unique lexemes in the Hebrew Bible with a list as well, by simply appending a lexeme to a list if it does not occur in the list already. The code would be only one line longer, but there is another difference, and that is the time it takes to do the calculation. Let us compare the time it would take using a list and a set."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We start with the list-implementation. First we import the class datetime from the module datetime."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 120,
   "metadata": {},
   "outputs": [],
   "source": [
    "from datetime import datetime"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 121,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "0:00:00.108708\n"
     ]
    }
   ],
   "source": [
    "startTime = datetime.now(\n",
    ")  # the variable startTime saves the date and the time of the start of the execution of the cell\n",
    "\n",
    "lex_list = []\n",
    "\n",
    "for word in F.otype.s('word'):\n",
    "    if F.language.v(word) == 'hbo':\n",
    "        if not F.lex.v(\n",
    "                word\n",
    "        ) in lex_list:  # this is the extra line of code. It checks whether a lexeme occurs in the list already.\n",
    "            lex_list.append(F.lex.v(word))\n",
    "\n",
    "print(len(lex_list))\n",
    "\n",
    "print(\n",
    "    datetime.now() -\n",
    "    startTime)  # again, the time is measured and the starttime is subtracted."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And now we look at the set-implementation again and measure how long it takes to execute the code."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 122,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "0:00:00.106714\n"
     ]
    }
   ],
   "source": [
    "startTime = datetime.now()\n",
    "\n",
    "lex_set = set()\n",
    "\n",
    "for word in F.otype.s('word'):\n",
    "    if F.language.v(word) == 'hbo':\n",
    "        lex_set.add(F.lex.v(word))\n",
    "\n",
    "print(len(lex_set))\n",
    "\n",
    "print(datetime.now() - startTime)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It is clear that the set-implementation is much faster than the list-implementation. This is the case because checking whether a certain lexeme occurs already in the list takes more time when the list becomes longer."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 15. Who Is Eating? Retrieving the Subject of a Predicate"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Very often you may not only interested be interested in the features of specific objects, but also of other objects in its environment. Suppose you are interested in eating habits in the Hebrew Bible. You decide to search for cases of the verb >KL[ (to eat), used as the predicate of a clause, and you are interested in those cases in which that clause has an explicit subject. You would like to know all the lexemes in the subject.  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The strategy is as follows. Fist we search for all cases of >KL[. From the word >KL[ we move upward to the phrase in which it occurs, using `L.u()`. Of this phrase it is checked if it is a predicate. We move upward again, to the level of the clause, and in the clause we check if there is an explicit subject, by moving downwards to the phrases in the clause, which is done with `L.d()`.\n",
    "\n",
    "The L in `L.u()` and `L.d()` stands for Layer, and u and d stand for up and down. Going up and down between linguistic layers is very important if you want to get access to various elements of linguistic units like clauses. In the script below we use L four times. In the figure below the use of L is schematically pictured."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<figure>\n",
    "   <img src=\"https://raw.githubusercontent.com/ETCBC/course_materials/master/Layer_picture.png\">\n",
    "   <figcaption> Source: https://github.com/ETCBC/course_materials\n",
    "   </figcaption>\n",
    "</figure>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 123,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['H', 'N<R/']\n",
      "['XRB=/']\n",
      "['BN/', 'JFR>L/']\n",
      "['XJH/', 'R</']\n",
      "['XJH/', 'R</']\n",
      "['HW>']\n",
      "['H', '<WP/']\n",
      "['H', '<WP/']\n",
      "['H', 'PRH/', 'R</', 'H', 'MR>H/', 'W', 'DQ/', 'H', 'BFR/']\n",
      "['H', 'PRH/', 'H', 'RQ=/', 'W', 'H', 'R</']\n",
      "['H', '>JC/']\n",
      "['KL/', 'BN/', 'NKR/']\n",
      "['TWCB/', 'W', 'FKJR/']\n",
      "['KL/', '<RL/']\n",
      "['XMY/']\n",
      "['BN/', 'JFR>L/']\n",
      "['>T', 'BFR/']\n",
      "['GDJC/', '>W', 'H', 'QMH/', '>W', 'H', 'FDH/']\n",
      "['>BJWN/', '<M/']\n",
      "['XJH/', 'H', 'FDH/']\n",
      "['MR>H/', 'KBWD/', 'JHWH/']\n",
      "['>HRN/', 'W', 'BN/']\n",
      "['ZR/']\n",
      "['H', '>C/']\n",
      "['>HRN/', 'W', 'BN/']\n",
      "['KL/', 'ZKR=/', 'B', 'BN/', '>HRN/']\n",
      "['H', 'KHN/']\n",
      "['KL/', 'ZKR=/', 'B', 'H', 'KHN/']\n",
      "['KL/', 'XV>T/']\n",
      "['KL/', 'ZKR=/', 'B', 'H', 'KHN/']\n",
      "['BFR/', 'ZBX/', 'TWDH/', 'CLM/']\n",
      "['H', 'BFR/']\n",
      "['KL/', 'VHR/']\n",
      "['>HRN/', 'W', 'BN/']\n",
      "['>TH', 'W', 'BN/', 'W', 'BT/', '>T==']\n",
      "['KL/', 'NPC/', 'MN']\n",
      "['H', 'GR/']\n",
      "['>JC/', '>JC/', 'MN', 'ZR</', '>HRN/']\n",
      "['KL/', 'ZR/']\n",
      "['TWCB/', 'KHN/', 'W', 'FKJR/']\n",
      "['HW>']\n",
      "['HM']\n",
      "['HJ>']\n",
      "['BT/', 'KHN/']\n",
      "['KL/', 'ZR/']\n",
      "['>JB[']\n",
      "['>RY/', '>JB[']\n",
      "['MJ']\n",
      "['MJ']\n",
      "['XYJ/', 'BFR/']\n",
      "['KL/', 'ZKR=/']\n",
      "['KL/', 'VHR/', 'B', 'BJT/']\n",
      "['KL/', 'VHR/', 'B', 'BJT/']\n",
      "['>TM', 'W', 'BJT/']\n",
      "['H', '<M/']\n",
      "['H', '>C/']\n",
      "['HW>']\n",
      "['H', '>C/', 'H', 'GDWL/', 'H', 'Z>T']\n",
      "['HW>']\n",
      "['H', 'VM>/', 'W', 'H', 'VHR/']\n",
      "['>TH', 'W', 'BN/', 'W', 'BT/', 'W', '<BD/', 'W', '>MH/', 'W', 'H', 'LWJ/']\n",
      "['>T', 'H', 'YBJ=/', 'W', '>T', 'H', '>JL/']\n",
      "['H', 'VM>/', 'W', 'H', 'VHR/']\n",
      "['>TH', 'W', 'BJT/']\n",
      "['<M/']\n",
      "['H', 'TWL<T/']\n",
      "['XRB/']\n",
      "['>TM']\n",
      "['CNJM/']\n",
      "['CNJM/']\n",
      "['H', '<M/']\n",
      "['H', 'QR>[']\n",
      "['C>WL=/']\n",
      "['H', '<M/']\n",
      "['H', '<M/']\n",
      "['XRB/']\n",
      "['>TH']\n",
      "['MPJBCT/', 'BN/', '>DWN/']\n",
      "['MPJBCT/']\n",
      "['HW>']\n",
      "['H', 'XRB/']\n",
      "['H', 'N<R/']\n",
      "['H', 'XRB/']\n",
      "['>C/', 'MN', 'PH/']\n",
      "['H', '>RJH/']\n",
      "['H', 'KLB/']\n",
      "['<WP/', 'H', 'CMJM/']\n",
      "['H', 'KLB/']\n",
      "['<WP/', 'H', 'CMJM/']\n",
      "['HJ>', 'W', 'HW>', 'W', 'BJT/']\n",
      "['H', 'KLB/']\n",
      "['H', 'KLB/']\n",
      "['<WP/', 'H', 'CMJM/']\n",
      "['H', 'KLB/']\n",
      "['H', 'KLB/']\n",
      "['ZR/']\n",
      "['GWR[']\n",
      "['LCWN/', '>C/']\n",
      "['KL/']\n",
      "['>RJH/']\n",
      "['>LH=/']\n",
      "['>P', '>C/', 'YR=/']\n",
      "['H', '>LP/', 'W', 'H', '<JR=/']\n",
      "['LCWN/']\n",
      "['XRB/', 'L>', '>DM/']\n",
      "['<C/']\n",
      "['<C/']\n",
      "['SS/']\n",
      "['<BD/']\n",
      "['>XR=/']\n",
      "['>RJH/']\n",
      "['XRB/']\n",
      "['H', 'BCT/']\n",
      "['BN/', 'W', 'BT/']\n",
      "['XRB/', 'L', 'JHWH/']\n",
      "['KL/', '>KL[']\n",
      "['>B/']\n",
      "['H', 'BSR/']\n",
      "['XRB/']\n",
      "['XRB/']\n",
      "['KL/', 'MY>[']\n",
      "['MLK/', '>CWR/']\n",
      "['BN/', 'JFR>L/']\n",
      "['>B/']\n",
      "['BN/']\n",
      "['R<B/', 'W', 'DBR=/']\n",
      "['H', '>C/']\n",
      "['>C/']\n",
      "['H', '>C/']\n",
      "['>B/']\n",
      "['>C/']\n",
      "['>XRJT/']\n",
      "['HMH']\n",
      "['HJ>']\n",
      "['XJH/', 'H', '>RY/']\n",
      "['>T=']\n",
      "['>TJQ/']\n",
      "['H', 'KHN/']\n",
      "['HMH']\n",
      "['H', 'KHN/']\n",
      "['XJH/', 'H', 'FDH/']\n",
      "['XDC=/']\n",
      "['ZR/']\n",
      "['H', '>RBH/']\n",
      "['H', 'JLQ/']\n",
      "['H', 'XSJL/']\n",
      "['>C/']\n",
      "['>C/']\n",
      "['>C/']\n",
      "['H', '>RBH/', 'H', 'JLQ/', 'W', 'H', 'XSJL/', 'W', 'H', 'GZM/', 'XJL/', 'H', 'GDWL/']\n",
      "['H', 'GZM/']\n",
      "['>TH']\n",
      "['XRB/']\n",
      "['>C/']\n",
      "['>C/']\n",
      "['KL/', 'H', '>RY/']\n",
      "['KL/', 'H', '>RY/']\n",
      "['HJ>']\n",
      "['>C/']\n",
      "['>KL[', '<M/']\n",
      "['>C/']\n",
      "['>C/']\n",
      "['<NW/']\n",
      "['>C/']\n",
      "['>KL[', '<M/']\n",
      "['QN>H/', 'BJT/']\n",
      "['>JC/']\n",
      "['>C/']\n",
      "['BN/', 'W', 'BT/']\n",
      "['BN/', 'W', 'BT/']\n",
      "['R<B=/']\n",
      "['TPL=/']\n",
      "['<C/']\n",
      "['>C/']\n",
      "['BKR/', 'MWT/']\n",
      "['>C/']\n",
      "['>C/']\n",
      "['>XR=/']\n",
      "['JTWM/']\n",
      "['BHMWT/']\n",
      "['YDJQ/']\n",
      "['>HB[']\n",
      "['NYR[', 'T>NH/']\n",
      "['BN/', 'NCR/']\n",
      "['B<Z/']\n",
      "['MJ']\n",
      "['>JC/', 'NKRJ/']\n",
      "['FR/']\n",
      "['FR/']\n",
      "['>CH/']\n",
      "['QRY/', 'DJ', 'JHWDJ/']\n",
      "['BN/', 'JFR>L/', 'W', 'KL/']\n",
      "['C<R/']\n",
      "['C<R/']\n",
      "['>NJ', 'W', '>X/']\n"
     ]
    }
   ],
   "source": [
    "for word in F.otype.s('word'):\n",
    "    if F.lex.v(word) == '>KL[':\n",
    "        phrase = L.u(word, 'phrase')[0]  # L.u() returns a tuple.\n",
    "        # We want to know the id of the phrase, so we add the index [0], which is the first value of the tuple.\n",
    "\n",
    "        # now we check if the phrase is a predicate, we chech also for cases in a nominal predicate (PreC),\n",
    "        # and predicates with an object suffix (PreO):\n",
    "        if F.function.v(phrase) in {'Pred', 'PreC', 'PreO'}:\n",
    "            # we move upwards to the clause\n",
    "            clause = L.u(phrase, 'clause')[0]\n",
    "            # and we go down again to all the phrases in that clause\n",
    "            phrases = L.d(clause, 'phrase')\n",
    "\n",
    "            # we loop over all the phrases to check if there is an explicit subject:\n",
    "            for phr in phrases:\n",
    "                if F.function.v(phr) == 'Subj':\n",
    "                    # we create an empty list, in which all lexemes are stored.\n",
    "                    lex_list = []\n",
    "\n",
    "                    # we move down to the lexemes of the subject:\n",
    "                    words = L.d(phr, 'word')\n",
    "\n",
    "                    for word in words:\n",
    "                        lex_list.append(F.lex.v(word))\n",
    "\n",
    "                    print(lex_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can use `T.nodeFromSection()` to find out which node corresponds in a specific piece of text. You can print the text of a sequence of words with `T.text()`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 124,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "וְאֵ֗לֶּה שְׁמֹות֙ בְּנֵ֣י יִשְׂרָאֵ֔ל הַבָּאִ֖ים מִצְרָ֑יְמָה אֵ֣ת יַעֲקֹ֔ב אִ֥ישׁ וּבֵיתֹ֖ו בָּֽאוּ׃ \n"
     ]
    }
   ],
   "source": [
    "exod_1_1 = T.nodeFromSection(('Exodus', 1, 1))\n",
    "words_exod_1_1 = L.d(exod_1_1, 'word')  # retrieve the word nodes with L.d()\n",
    "\n",
    "print(T.text(words_exod_1_1))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The following is nearly the same, but now we print the whole chapter"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 125,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "וְאֵ֗לֶּה שְׁמֹות֙ בְּנֵ֣י יִשְׂרָאֵ֔ל הַבָּאִ֖ים מִצְרָ֑יְמָה אֵ֣ת יַעֲקֹ֔ב אִ֥ישׁ וּבֵיתֹ֖ו בָּֽאוּ׃ רְאוּבֵ֣ן שִׁמְעֹ֔ון לֵוִ֖י וִיהוּדָֽה׃ יִשָּׂשכָ֥ר זְבוּלֻ֖ן וּבְנְיָמִֽן׃ דָּ֥ן וְנַפְתָּלִ֖י גָּ֥ד וְאָשֵֽׁר׃ וַֽיְהִ֗י כָּל־נֶ֛פֶשׁ יֹצְאֵ֥י יֶֽרֶךְ־יַעֲקֹ֖ב שִׁבְעִ֣ים נָ֑פֶשׁ וְיֹוסֵ֖ף הָיָ֥ה בְמִצְרָֽיִם׃ וַיָּ֤מָת יֹוסֵף֙ וְכָל־אֶחָ֔יו וְכֹ֖ל הַדֹּ֥ור הַהֽוּא׃ וּבְנֵ֣י יִשְׂרָאֵ֗ל פָּר֧וּ וַֽיִּשְׁרְצ֛וּ וַיִּרְבּ֥וּ וַיַּֽעַצְמ֖וּ בִּמְאֹ֣ד מְאֹ֑ד וַתִּמָּלֵ֥א הָאָ֖רֶץ אֹתָֽם׃ פ וַיָּ֥קָם מֶֽלֶךְ־חָדָ֖שׁ עַל־מִצְרָ֑יִם אֲשֶׁ֥ר לֹֽא־יָדַ֖ע אֶת־יֹוסֵֽף׃ וַיֹּ֖אמֶר אֶל־עַמֹּ֑ו הִנֵּ֗ה עַ֚ם בְּנֵ֣י יִשְׂרָאֵ֔ל רַ֥ב וְעָצ֖וּם מִמֶּֽנּוּ׃ הָ֥בָה נִֽתְחַכְּמָ֖ה לֹ֑ו פֶּן־יִרְבֶּ֗ה וְהָיָ֞ה כִּֽי־תִקְרֶ֤אנָה מִלְחָמָה֙ וְנֹוסַ֤ף גַּם־הוּא֙ עַל־שֹׂ֣נְאֵ֔ינוּ וְנִלְחַם־בָּ֖נוּ וְעָלָ֥ה מִן־הָאָֽרֶץ׃ וַיָּשִׂ֤ימוּ עָלָיו֙ שָׂרֵ֣י מִסִּ֔ים לְמַ֥עַן עַנֹּתֹ֖ו בְּסִבְלֹתָ֑ם וַיִּ֜בֶן עָרֵ֤י מִסְכְּנֹות֙ לְפַרְעֹ֔ה אֶת־פִּתֹ֖ם וְאֶת־רַעַמְסֵֽס׃ וְכַאֲשֶׁר֙ יְעַנּ֣וּ אֹתֹ֔ו כֵּ֥ן יִרְבֶּ֖ה וְכֵ֣ן יִפְרֹ֑ץ וַיָּקֻ֕צוּ מִפְּנֵ֖י בְּנֵ֥י יִשְׂרָאֵֽל׃ וַיַּעֲבִ֧דוּ מִצְרַ֛יִם אֶת־בְּנֵ֥י יִשְׂרָאֵ֖ל בְּפָֽרֶךְ׃ וַיְמָרְר֨וּ אֶת־חַיֵּיהֶ֜ם בַּעֲבֹדָ֣ה קָשָׁ֗ה בְּחֹ֨מֶר֙ וּבִלְבֵנִ֔ים וּבְכָל־עֲבֹדָ֖ה בַּשָּׂדֶ֑ה אֵ֚ת כָּל־עֲבֹ֣דָתָ֔ם אֲשֶׁר־עָבְד֥וּ בָהֶ֖ם בְּפָֽרֶךְ׃ וַיֹּ֨אמֶר֙ מֶ֣לֶךְ מִצְרַ֔יִם לַֽמְיַלְּדֹ֖ת הָֽעִבְרִיֹּ֑ת אֲשֶׁ֨ר שֵׁ֤ם הָֽאַחַת֙ שִׁפְרָ֔ה וְשֵׁ֥ם הַשֵּׁנִ֖ית פּוּעָֽה׃ וַיֹּ֗אמֶר בְּיַלֶּדְכֶן֙ אֶת־הָֽעִבְרִיֹּ֔ות וּרְאִיתֶ֖ן עַל־הָאָבְנָ֑יִם אִם־בֵּ֥ן הוּא֙ וַהֲמִתֶּ֣ן אֹתֹ֔ו וְאִם־בַּ֥ת הִ֖יא וָחָֽיָה׃ וַתִּירֶ֤אןָ הַֽמְיַלְּדֹת֙ אֶת־הָ֣אֱלֹהִ֔ים וְלֹ֣א עָשׂ֔וּ כַּאֲשֶׁ֛ר דִּבֶּ֥ר אֲלֵיהֶ֖ן מֶ֣לֶךְ מִצְרָ֑יִם וַתְּחַיֶּ֖יןָ אֶת־הַיְלָדִֽים׃ וַיִּקְרָ֤א מֶֽלֶךְ־מִצְרַ֨יִם֙ לַֽמְיַלְּדֹ֔ת וַיֹּ֣אמֶר לָהֶ֔ן מַדּ֥וּעַ עֲשִׂיתֶ֖ן הַדָּבָ֣ר הַזֶּ֑ה וַתְּחַיֶּ֖יןָ אֶת־הַיְלָדִֽים׃ וַתֹּאמַ֤רְןָ הַֽמְיַלְּדֹת֙ אֶל־פַּרְעֹ֔ה כִּ֣י לֹ֧א כַנָּשִׁ֛ים הַמִּצְרִיֹּ֖ת הָֽעִבְרִיֹּ֑ת כִּֽי־חָיֹ֣ות הֵ֔נָּה בְּטֶ֨רֶם תָּבֹ֧וא אֲלֵהֶ֛ן הַמְיַלֶּ֖דֶת וְיָלָֽדוּ׃ וַיֵּ֥יטֶב אֱלֹהִ֖ים לַֽמְיַלְּדֹ֑ת וַיִּ֧רֶב הָעָ֛ם וַיַּֽעַצְמ֖וּ מְאֹֽד׃ וַיְהִ֕י כִּֽי־יָֽרְא֥וּ הַֽמְיַלְּדֹ֖ת אֶת־הָאֱלֹהִ֑ים וַיַּ֥עַשׂ לָהֶ֖ם בָּתִּֽים׃ וַיְצַ֣ו פַּרְעֹ֔ה לְכָל־עַמֹּ֖ו לֵאמֹ֑ר כָּל־הַבֵּ֣ן הַיִּלֹּ֗וד הַיְאֹ֨רָה֙ תַּשְׁלִיכֻ֔הוּ וְכָל־הַבַּ֖ת תְּחַיּֽוּן׃ ס \n"
     ]
    }
   ],
   "source": [
    "exod_1 = T.nodeFromSection((\n",
    "    'Exodus',\n",
    "    1,\n",
    "))\n",
    "words_exod_1 = L.d(exod_1, 'word')  # retrieve the word nodes with L.d()\n",
    "\n",
    "print(T.text(words_exod_1))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 16. Making Structured Datasets with Text-Fabric, a Standard Recipe\n",
    "\n",
    "In the following cells a csv file containing a number of features related to a topic of interest is created. The file is saved on the harddisk and can be processed further. The strategy of making this file is as follows.\n",
    "The features of an observation are stored in a list, and all these lists are stored in a dictionary:\n",
    "\n",
    "{id1 : [feat11, feat12, feat13, ...],  \n",
    "  id2 : [feat21, feat22, feat23, ...],  \n",
    "  id3 : [feat31, feat32, feat33, ...],  \n",
    "  ...  \n",
    "  ...  \n",
    " }\n",
    " \n",
    "The keys of this dictionary have to be unique of course, so in general it is convenient to use the tf-id of the object under investigation as key. The dictionary does not remember the order of the id's, so another structure is needed in which this order is remembered. We use a list to do this. The id's are added to the list in the canonical order in which our observations occur:\n",
    "\n",
    "[id1, id2, id3, ...]\n",
    "\n",
    "After all the observations are stored in the list and the dictionary the csv file is made by looping over the id's in the list, then for each id the feature list is fetched in the dictionary and added to the csv."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We will first show this with a very simple example, in which we make a csv file which contains all the places where the name JHWH occurs. The csv file will contain 4 columns: slot of the lexeme JHWH/, book, chapter, verse. On every row there will be one observation of the name."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 126,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "6828\n"
     ]
    }
   ],
   "source": [
    "jhwh_list = []\n",
    "jhwh_dict = {}\n",
    "\n",
    "for word in F.otype.s('word'):\n",
    "    if F.lex.v(word) == 'JHWH/':\n",
    "        bo, ch, ve = T.sectionFromNode(word)  # unpack the tuple!\n",
    "        info = [str(word), bo, str(ch), str(ve)]\n",
    "        jhwh_list.append(word)\n",
    "        jhwh_dict[word] = info\n",
    "\n",
    "print(len(jhwh_list))  # prints total number of occurrences of the name"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 127,
   "metadata": {},
   "outputs": [],
   "source": [
    "with open(r'jhwh_data.csv', \"w\") as csv_file:\n",
    "\n",
    "    # it is often useful to make a header\n",
    "    header = ['slot', 'book', 'chapter', 'verse']\n",
    "    csv_file.write('{}\\n'.format(','.join(header)))\n",
    "\n",
    "    for case in jhwh_list:\n",
    "        info = jhwh_dict[case]\n",
    "\n",
    "        # with .write() the information from info is added to the our file, but the elements in info need to be formatted first.\n",
    "        csv_file.write('{}\\n'.format(\n",
    "            ','.join(info)))  #see below for explanation of this line"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 17. Join() and String Formatting"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the last line of the previous code cell the information in the info-list was added to the csv file. How exactly was this done?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Join()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "First all the elements in the list were concatenated into one string with `join()`. `join()` concatenates everything in the list into one long string, and the separator is specified first. We want to make a csv file, so the comma is the natural choice, but you can use any character. Note that the list should contain only strings."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 128,
   "metadata": {},
   "outputs": [],
   "source": [
    "info = ['Genesis', '1', '1']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 129,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Genesis,1,1\n"
     ]
    }
   ],
   "source": [
    "new_string = (','.join(info))\n",
    "print(new_string)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### String Formatting"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "String formatting is used if you want to organize various kinds of information in a string."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 130,
   "metadata": {},
   "outputs": [],
   "source": [
    "t = 5  # integer\n",
    "p = 'Amsterdam'  # string\n",
    "f = True  # boolean"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you want to put these together in one string, you use the placeholders {} and separate them with a character of choice. In the example below they are separated by spaces."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 131,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'5 Amsterdam True'"
      ]
     },
     "execution_count": 131,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'{} {} {}'.format(t, p, f)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "In the cell in which the jhwh_data.csv file was made, you saw `{}\\n` . \\n is the newline. With this the next string that is added to the csv file comes on a new line."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 18. Semi-structured Datasets"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the previous examples a so called structured dataset was made, which we saved in a csv file. The dataset is called structured, because it has a fixed format. It consists of a number of columns, and in each column you find the same kind of information for each case in the database."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You should also be able to make unstructured or semi-structured datasets. An unstructured dataset contains data that are closer to the raw data as we find them in 'nature'. An example is a picture of a Dead Sea Scroll. In a semi-structured dataset the data are structured partly. In our case you could for instance make a text file with the consonantal text of the Hebrew Bible. In the following example, a text file is made in which the biblical text is represented per verse as a sequence of lexemes, separated by spaces."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 132,
   "metadata": {},
   "outputs": [],
   "source": [
    "with open(\"lexemes.txt\", \"w\") as lex_file:\n",
    "    for verse in F.otype.s('verse'):\n",
    "        bo, ch, ve = T.sectionFromNode(verse)\n",
    "        # do not forget to make strings of chapter and verse\n",
    "        verse_string = '{} {} {} '.format(bo, ch, ve)\n",
    "        words = L.d(verse, 'word')\n",
    "\n",
    "        for word in words:  # this is an alternative approach to string formatting\n",
    "            if word != words[-1]:  # if the word is not the last word,\n",
    "                verse_string += F.lex.v(word)  #add the lexeme\n",
    "                verse_string += ' '  # and add a space\n",
    "\n",
    "            else:  # this is the last word\n",
    "                verse_string += F.lex.v(word)\n",
    "                verse_string += '\\n'  # add a newline\n",
    "\n",
    "        lex_file.write(verse_string)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the previous script a file was made that contains the text of the whole MT. If you want to make a separate file for each book, you can do the following."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 133,
   "metadata": {},
   "outputs": [],
   "source": [
    "def lexeme_processing(v):\n",
    "    \"\"\" \n",
    "    This function returns a string of lexemes for a verse node, which is the input.\n",
    "    It is identical to part of the code you have seen in the previous cell.\n",
    "    \"\"\"\n",
    "    bo, ch, ve = T.sectionFromNode(v)\n",
    "    verse_string = '{} {} {} '.format(bo, ch, ve)\n",
    "\n",
    "    words = L.d(verse, 'word')\n",
    "    for word in words:\n",
    "        if word != words[-1]:\n",
    "            verse_string += F.lex.v(word)\n",
    "            verse_string += ' '\n",
    "        else:\n",
    "            verse_string += F.lex.v(word)\n",
    "            # a new verse gets a new line.\n",
    "            verse_string += '\\n'\n",
    "    return (verse_string)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 134,
   "metadata": {},
   "outputs": [],
   "source": [
    "# for every book a new file is created.\n",
    "for book in F.otype.s('book'):\n",
    "    book_file = F.book.v(book) + '.txt'\n",
    "\n",
    "    with open(book_file, \"w\") as new_file:\n",
    "        verses = L.d(book, 'verse')\n",
    "        for verse in verses:\n",
    "            # here the function lexeme_processing is called\n",
    "            new_string = lexeme_processing(verse)\n",
    "            new_file.write(new_string)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 19. Final Example of a Structured Dataset: the Eat-Data"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "Now we continue with the >KL[ data. On every row in the csv file we store information about one clause containing >KL[, with the following information in columns:  \n",
    "slot of >KL[,  \n",
    "book,  \n",
    "chapter,  \n",
    "verse,  \n",
    "verbal tense,  \n",
    "verbal stem,  \n",
    "predicate type (Pred, PreC, PreO, PreS)  \n",
    "lexemes of the subject, concatenated in a string, separated by underscores.  \n",
    "The first 6 columns contain information about the verb, the predicate type contains information about the phrase in which >KL[ occurs, and the last column contains information about the subject of the clause. It may look like a lot of work, but you will notice that it is done straightforwardly."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 135,
   "metadata": {},
   "outputs": [],
   "source": [
    "eat_list = []\n",
    "eat_dict = {}\n",
    "\n",
    "# this part is nearly identical to what you have already seen\n",
    "for w in F.otype.s('word'):\n",
    "\n",
    "    # select the words with the right lexeme and make sure the language is Hebrew.\n",
    "    if F.lex.v(w) == '>KL[' and F.language.v(w) == 'hbo':\n",
    "        phrase = L.u(w, 'phrase')[0]\n",
    "\n",
    "        # we include cases with a subjectsuffix\n",
    "        if F.function.v(phrase) == 'PreS':\n",
    "            suffix = F.prs.v(w)\n",
    "            # now we collect the information needed in a list called info\n",
    "            bo, ch, ve = T.sectionFromNode(w)\n",
    "            info = [\n",
    "                w, bo, ch, ve,\n",
    "                F.vt.v(w),\n",
    "                F.vs.v(w),\n",
    "                F.function.v(phrase), suffix\n",
    "            ]\n",
    "            eat_dict[w] = info\n",
    "            eat_list.append(w)\n",
    "\n",
    "        # the other predicate types are processed now\n",
    "        else:\n",
    "            if F.function.v(phrase) in {'Pred', 'PreC', 'PreO'}:\n",
    "                bo, ch, ve = T.sectionFromNode(w)\n",
    "                clause = L.u(phrase, 'clause')[0]\n",
    "                phrases = L.d(clause, 'phrase')\n",
    "                subject = False  # we only include those cases that have an explicit subject\n",
    "\n",
    "                for phr in phrases:\n",
    "                    if F.function.v(phr) == 'Subj':\n",
    "                        subject = True\n",
    "                        words = L.d(phr, 'word')\n",
    "                        words_lex = (F.lex.v(w) for w in words)\n",
    "                        subj_lexemes = \"_\".join(words_lex)\n",
    "\n",
    "                if subject:  # this is the same as: if subject == True:, but it is a bit cleaner\n",
    "                    info = [\n",
    "                        w, bo, ch, ve,\n",
    "                        F.vt.v(w),\n",
    "                        F.vs.v(w),\n",
    "                        F.function.v(phrase), subj_lexemes\n",
    "                    ]\n",
    "                    eat_dict[w] = info\n",
    "                    eat_list.append(w)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 136,
   "metadata": {},
   "outputs": [],
   "source": [
    "with open(r'eat_data.csv', \"w\") as csv_file:\n",
    "\n",
    "    # we make a header again\n",
    "    header = [\n",
    "        'slot', 'book', 'chapter', 'verse', 'tense', 'stem', 'predicate',\n",
    "        'subj_lex'\n",
    "    ]\n",
    "    csv_file.write('{}\\n'.format(','.join(header)))\n",
    "\n",
    "    for case in eat_list:\n",
    "        info_list = eat_dict[case]\n",
    "        line = [str(element) for element in info_list]\n",
    "        csv_file.write('{}\\n'.format(','.join(line)))"
   ]
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "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.7.6"
  },
  "varInspector": {
   "cols": {
    "lenName": 16,
    "lenType": 16,
    "lenVar": 40
   },
   "kernels_config": {
    "python": {
     "delete_cmd_postfix": "",
     "delete_cmd_prefix": "del ",
     "library": "var_list.py",
     "varRefreshCmd": "print(var_dic_list())"
    },
    "r": {
     "delete_cmd_postfix": ") ",
     "delete_cmd_prefix": "rm(",
     "library": "var_list.r",
     "varRefreshCmd": "cat(var_dic_list()) "
    }
   },
   "types_to_exclude": [
    "module",
    "function",
    "builtin_function_or_method",
    "instance",
    "_Feature"
   ],
   "window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}