01 - Python Crash Course.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Python for Financial Analysis and Algorithmic Trading"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 01 -  Python Crash Course"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Fundamental Data Types\n",
    "# Comparison and Logical Operators\n",
    "# Control Flow Statements\n",
    "# Functions\n",
    "# Built-in Python Expressions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"single don't care about double\""
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# String\n",
    "single = 'single' \n",
    "double = \"don't care about double\"\n",
    "single + \" \" + double "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hi my name is Metin and I am 99 yearsold\n"
     ]
    }
   ],
   "source": [
    "name = \"Metin\"\n",
    "age = 99\n",
    "print(\"hi my name is {x} and I am {y} yearsold\".format(x = name, y = age))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[3, 4]"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# list - append method - slicing\n",
    "my_list = [1, 2, 3]\n",
    "my_list.append(4)\n",
    "my_list[-2:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'a'"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "nested=[my_list, ['a', 'b'], 'c']\n",
    "nested[1][0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'seconditem'"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# dict : key value pair - unordered\n",
    "d = {'key': 10,  'key2':'seconditem'}\n",
    "d['key2']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Boolean\n",
    "True and not False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Tuple (immutable )- vs List (mutable)\n",
    "my_list = [1, 2, 3, 4]\n",
    "my_tuple = (1, 2, 3, 4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n",
      "['NEW', 2, 3, 4]\n",
      "(1, 2, 3, 4)\n"
     ]
    }
   ],
   "source": [
    "print(my_list == my_tuple)\n",
    "my_list[0]='NEW'\n",
    "# my_tuple[0]= 'NEW' # TypeError: 'tuple' object does not support item assignment\n",
    "print(my_list)\n",
    "print(my_tuple)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{1, 4, 5, 'a', 'b'}"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Set  - unordered collection of unique instances\n",
    "set = {1,4, 4, 5, 5, 5, 'a' , 'a' , 'b'}\n",
    "set "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Comparison Operators\n",
    "1 < 2 ;  1>=3 ; 1 == '1'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Logical Operators\n",
    "# and  or not\n",
    "(1==1) and not (1 == 2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['NEW', 2, 3, 4]\n"
     ]
    }
   ],
   "source": [
    "# Conditionals \n",
    "if True:\n",
    "    print(my_list)\n",
    "elif 2 == 2:\n",
    "    print(d)\n",
    "else:\n",
    "    print(my_tuple)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "NEW\n",
      "2\n",
      "3\n",
      "4\n",
      "<class 'dict'>\n",
      "key 10\n",
      "key2 seconditem\n"
     ]
    }
   ],
   "source": [
    "# for Loops\n",
    "for item in my_list:\n",
    "    print(item)\n",
    "\n",
    "print(type(d)) # d is dictionary variable defined above\n",
    "\n",
    "for k,v in d.items():\n",
    "    print(k , v)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "i is currently 1\n",
      "i is currently 2\n",
      "i is currently 3\n",
      "i is currently 4\n"
     ]
    }
   ],
   "source": [
    "# while loop\n",
    "i = 1\n",
    "while i < 5:\n",
    "    print(\"i is currently {}\".format(i))\n",
    "    i = i+1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'range'>\n",
      "range(0, 10, 2)\n",
      "[0, 2, 4, 6, 8]\n"
     ]
    }
   ],
   "source": [
    "# range()\n",
    "my_range = range(0, 10, 2) # range(start, stop, step)\n",
    "print(type(my_range)) # <class 'range'>\n",
    "print(my_range)  # range(0, 10, 2)\n",
    "print(list(my_range)) # [0, 2, 4, 6, 8] "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "out : [0, 4, 16, 36, 64]\n",
      "-------\n",
      "out : [0, 4, 16, 36, 64]\n"
     ]
    }
   ],
   "source": [
    "# list comprehension\n",
    "nums = [0, 2, 4, 6, 8] \n",
    "out = []\n",
    "\n",
    "for num in nums:\n",
    "    out.append(num**2)\n",
    "\n",
    "print(\"out :\", out)\n",
    "\n",
    "# Rephrase above expression with list comprehension\n",
    "print(\"-------\")\n",
    "\n",
    "out = [num**2 for num in nums]\n",
    "\n",
    "print(\"out :\", out)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Functions\n",
    "# Lambda Expressions\n",
    "# map and filter\n",
    "# various useful methods"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hello   Hello\n",
      "hello   there!\n"
     ]
    }
   ],
   "source": [
    "def my_func(param='there!'):\n",
    "    \"\"\"\n",
    "    Docstring goes here! Press \"shift+Tab\" to see Docstring\n",
    "    \n",
    "    \"\"\"\n",
    "    print('hello  ', param)\n",
    "\n",
    "my_func('Hello')\n",
    "my_func?\n",
    "my_func() # shift + Tab when cursor is on the end of func()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 2, 4, 6, 8, 0, 2, 4, 6, 8, 0, 2, 4, 6, 8, 0, 2, 4, 6, 8, 0, 2, 4, 6, 8]\n"
     ]
    }
   ],
   "source": [
    "nums = [0, 2, 4, 6, 8] \n",
    "\n",
    "def func2(arg):\n",
    "    \"\"\"\n",
    "    Docstring goes here! Press \"shift+Tab\" to see Docstring\n",
    "    \n",
    "    \"\"\"\n",
    "    return arg * 5\n",
    "\n",
    "x = func2(nums)\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4\n"
     ]
    }
   ],
   "source": [
    "# lambda expressions with map and filter\n",
    "def times_two(var):\n",
    "    return var*2\n",
    "\n",
    "result = times_two(2)\n",
    "print(result)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<function <lambda> at 0x00000000052C2430>\n"
     ]
    }
   ],
   "source": [
    "var = 2\n",
    "print(lambda var: var*2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[2, 4, 6, 8, 10]"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "seq = [1, 2, 3, 4, 5]\n",
    "list(map(times_two, seq))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[2, 4, 6, 8, 10]"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(map(lambda num: num*2, seq))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[2, 4]"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# filter\n",
    "list(filter(lambda num:num%2 == 0, seq))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "' name is sam!'"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# String Methods\n",
    "st = \"hello My # name is sam!\"\n",
    "st.upper()\n",
    "st.lower() #  .capitalize()\n",
    "st.split(\" \")\n",
    "st.split(\"#\")[1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "' #cool'"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tweet = \"Go #Tigers! #cool\"\n",
    "tweet.split(\"!\")[1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dict_items([('key', 10), ('key2', 'seconditem')])"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d.items()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "1 in my_list"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# *** END OF CHAPTER ***"
   ]
  }
 ],
 "metadata": {
  "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.8.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}