P01.2_Data_Types.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Computer Programming with Python\n",
    "\n",
    "#### Instructor : Dr. Aydin Demir\n",
    "\n",
    "www.aydindemir.com | GitHub & Instagram: @craxLab | Web: www.craxLab.com\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Python Data Types\n",
    "\n",
    "Variables can hold values, and every value has a data-type. Python is a dynamically typed language; hence we do not need to define the type of the variable while declaring it. The interpreter implicitly binds the value with its type."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**_Integer data type:_**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n"
     ]
    }
   ],
   "source": [
    "a  = 5\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**_String data type:_**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sakarya\n"
     ]
    }
   ],
   "source": [
    "b = \"Sakarya\"\n",
    "print(b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**To check the type of a variable used in the program.**\n",
    "\n",
    "Python provides us the **type()** function, which returns the type of the variable passed.\n",
    "\n",
    "print(type(a)) ; print(type(b))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'int'>\n"
     ]
    }
   ],
   "source": [
    "print(type(a))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'str'>\n"
     ]
    }
   ],
   "source": [
    "print(type(b))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**_Float data type:_**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'float'>\n"
     ]
    }
   ],
   "source": [
    "c = 2.5\n",
    "print(type(c))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "# Data Types in Python\n",
    "\n",
    "Definition of the data type classifies and categorize data items. Its a way to understand which kind of value determines what operatoins can be performed. Different types of variable can do different things.\n",
    "\n",
    "* In Python, we don't need to specify the type of variable because Python is a infer language and smart enough to get variable type.\n",
    "\n",
    "<img src=\"./Figures/Datatypes-in-python2.png\" align=\"left\"/>\n",
    "\n",
    "Source: https://www.javatpoint.com/python-data-types"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "## 1) Numbers\n",
    "Number stores numeric values. Python supports three types of numeric data.\n",
    "\n",
    "**Int** : Integer value can be any length such as integers 10, 2, 29, -20, -150 etc. Python has no restriction on the length of an integer. Its value belongs to int\n",
    "\n",
    "**Float** : Float is used to store floating-point numbers like 1.9, 9.902, -15.2, etc. It is accurate upto 15 decimal points.\n",
    "\n",
    "**complex** : A complex number contains an ordered pair, i.e., x + iy where x and y denote the real and imaginary parts, respectively. The complex numbers like 2.14j, 2.0 + 2.3j, etc."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**_Create an integer number:_**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'int'>\n"
     ]
    }
   ],
   "source": [
    "x = 3\n",
    "print(type(x))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**_Create a float number:_**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'float'>\n"
     ]
    }
   ],
   "source": [
    "b = -2.5\n",
    "print(type(b))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**_Create a complex number:_**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(2+3j)\n",
      "<class 'complex'>\n"
     ]
    }
   ],
   "source": [
    "c = 2 + 3j\n",
    "print(c)\n",
    "print(type(c))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "## 2) Sequence Type (Sıra/Dizi Tip)\n",
    "\n",
    "### 2.a) String\n",
    "The string can be defined as the sequence of characters represented in the quotation marks. \n",
    "\n",
    "In Python, we can use single, double, or triple quotes to define a string."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**_String using single quote (' '):_**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'str'>\n"
     ]
    }
   ],
   "source": [
    "univ = 'Sakarya Üniversitesi'\n",
    "print(type(univ))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**_String using double quote (\" \"):_**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'str'>\n"
     ]
    }
   ],
   "source": [
    "univ = \"Sakarya Üniversitesi\"\n",
    "print(type(univ))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.b) List\n",
    "Python Lists are similar to arrays. The list can contain data of different types. \n",
    "\n",
    "The items stored in the list are separated with a **comma (,)** and enclosed within **square brackets [ ]**.\n",
    "\n",
    "The **size and value of the items** in a list can be modified."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**_Create a list:_**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 5, 9, -5, 'ali']\n",
      "<class 'list'>\n"
     ]
    }
   ],
   "source": [
    "listem = [1, 2, 5, 9, -5, \"ali\"]\n",
    "print(listem)\n",
    "print(type(listem))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**_Using list() function:_** \n",
    "\n",
    "syntax: list([...])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 5, 9, -5, 'ali']\n",
      "<class 'list'>\n"
     ]
    }
   ],
   "source": [
    "listem = list([1, 2, 5, 9, -5, \"ali\"])\n",
    "print(listem)\n",
    "print(type(listem))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**_Creating an empty list :_**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[]\n"
     ]
    }
   ],
   "source": [
    "boslistem = list()\n",
    "boslistem = [ ]\n",
    "print(boslistem)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.c) Tuple\n",
    "\n",
    "A tuple is similar to the list in many ways. Like lists, tuples also contain the collection of the items of different data types. \n",
    "\n",
    "The items of the tuple are separated with a **comma (,)** and enclosed in **parentheses ()**.\n",
    "\n",
    "A tuple is a **read-only** data structure as we **can't modify** the **size and value of the items** of a tuple."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**_Create a tuple:_**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(3, 5, 8, -15, 'x', 'sakarya')\n",
      "<class 'tuple'>\n"
     ]
    }
   ],
   "source": [
    "mytuple = (3, 5, 8, -15, \"x\", \"sakarya\")\n",
    "print(mytuple)\n",
    "print(type(mytuple))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**_Using tuple() function_:** \n",
    "\n",
    "syntax: tuple([...])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(3, 5, 8, -15, 'x', 'sakarya')\n",
      "<class 'tuple'>\n"
     ]
    }
   ],
   "source": [
    "mytuple = tuple([3, 5, 8, -15, \"x\", \"sakarya\"])\n",
    "print(mytuple)\n",
    "print(type(mytuple))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**_Creating an empty tuple :_**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "()\n"
     ]
    }
   ],
   "source": [
    "myemptytuple = tuple()\n",
    "print(myemptytuple)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "## 3) Set (Küme)\n",
    "\n",
    "Python Set is the unordered collection of the data type. It is iterable, mutable(can modify after creation), and has unique elements. \n",
    "\n",
    "In set, the order of the elements is undefined; it may return the changed sequence of the element. \n",
    "\n",
    "The set is created by using a built-in function set(), or a sequence of elements is passed in the **curly braces {}** and **separated by the comma**. \n",
    "\n",
    "It can contain various types of values. Consider the following example."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**_Creating a set:_**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'Toyota', 'Fiat', 'Ford', 'Ferrari'}\n",
      "<class 'set'>\n"
     ]
    }
   ],
   "source": [
    "arabalar = {\"Ferrari\", \"Ford\", \"Fiat\", \"Toyota\"}\n",
    "print(arabalar)\n",
    "print(type(arabalar))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**_Using set() function_:** \n",
    "\n",
    "syntax: set([...])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "set()\n"
     ]
    }
   ],
   "source": [
    "kumem = set()\n",
    "print(kumem)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**_Creating an empty set:_**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**_Adding element to the set:_** \n",
    "\n",
    "syntax: setName.add(...)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'Fiat', 'Ford', 'Toyota', 'Volvo', 'Ferrari'}\n"
     ]
    }
   ],
   "source": [
    "arabalar.add(\"Volvo\")\n",
    "print(arabalar)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**_Removing element from the set:_** \n",
    "\n",
    "syntax: setName.remove(...)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'Ford', 'Toyota', 'Volvo', 'Ferrari'}\n"
     ]
    }
   ],
   "source": [
    "arabalar.remove(\"Fiat\")\n",
    "print(arabalar)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "## 4) Dictionary (Sözlük)\n",
    "\n",
    "Dictionary is an unordered set of a key-value pair of items. It is like an associative array or a hash table where each key stores a specific value. \n",
    "\n",
    "- It is a composition of **key : value** pairs. Key can hold any primitive data type (specific value), whereas value is an arbitrary Python object.\n",
    "\n",
    "- The items in the dictionary are separated with the **comma (,)** and enclosed in the **curly braces {}**.\n",
    "\n",
    "- For string keys or values, use ' ' or \" \""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**_Create a dictionary:_**\n",
    "\n",
    "dicName = {key1:value1 , key2:value2, ...} "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'isim': 'Ali', 'yas': 15, 'ulke': 'Turkiye'}\n",
      "<class 'dict'>\n"
     ]
    }
   ],
   "source": [
    "sozlugum = {\"isim\":\"Ali\", \"yas\":15, \"ulke\":\"Turkiye\"}\n",
    "print(sozlugum)\n",
    "print(type(sozlugum))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'h': 500, 'b': 100, 'adi': '500x100'}\n"
     ]
    }
   ],
   "source": [
    "kesit = {\"h\": 500, \"b\":100, \"adi\":\"500x100\"}\n",
    "print(kesit)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**_Using dict() function_:**\n",
    "\n",
    "dicName = dict(key1=value1 , key2=value2, ...)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'h': 500, 'b': 100, 'adi': '500x100'}\n"
     ]
    }
   ],
   "source": [
    "kesit = dict(h=500, b=100, adi=\"500x100\")\n",
    "print(kesit)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**_Print keys and values:_**\n",
    "\n",
    "dicName.keys() | dicName.values())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "dict_keys(['h', 'b', 'adi'])\n"
     ]
    }
   ],
   "source": [
    "print(kesit.keys())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "dict_values([500, 100, '500x100'])\n"
     ]
    }
   ],
   "source": [
    "print(kesit.values())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**_Accesing values using keys:_**\n",
    "\n",
    "dicName[keyName]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "500\n"
     ]
    }
   ],
   "source": [
    "print(kesit[\"h\"])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "## 5) Boolean (mantıksal)\n",
    "\n",
    "Boolean type provides two built-in values, **True** and **False**. These values are used to determine the given statement true or false. It denotes by the class bool. \n",
    "\n",
    "True can be represented by any non-zero value or 'T' whereas false can be represented by the 0 or 'F'. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "_Python to check the boolean type:_ type(True) ; type(False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'bool'>\n"
     ]
    }
   ],
   "source": [
    "print(type(True))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'bool'>\n"
     ]
    }
   ],
   "source": [
    "print(type(False))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**_Equal to:_** \n",
    "\n",
    "value1 == value2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "1 == 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "1 == 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "1 == 1.0"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "string: string1 == string2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"sakarya\" == \"sakarya\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"sakarya\" == \"Sakarya\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**_Not equal to:_**\n",
    "\n",
    "value1 != value2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "1 != 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "1 != 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**_Smaller than:_** \n",
    "\n",
    "value1 < value2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "10 > 5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "10 < 5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "10 >= 10"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "\n",
    "## _None_ data type in Python\n",
    "\n",
    "None is merely a keyword that is frequently used to denote \"empty\" or \"no value.\" None is frequently used to represent the absence of a value"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "None\n",
      "<class 'NoneType'>\n"
     ]
    }
   ],
   "source": [
    "x = None\n",
    "print(x)\n",
    "print(type(x))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[15, 16, 15, None, 18]\n"
     ]
    }
   ],
   "source": [
    "sicaklik = [15, 16, 15, None, 18]\n",
    "print(sicaklik)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'adi': 'Fatma', 'Soyadi': 'Gezer', 'yas': None, 'sehir': 'Ankara'}\n"
     ]
    }
   ],
   "source": [
    "ogrenci = dict(adi=\"Fatma\", Soyadi = \"Gezer\", yas = None , sehir=\"Ankara\")\n",
    "print(ogrenci)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "hide_input": false,
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.9.13"
  },
  "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": 4
}