C1_Student_PyForDs_Fuhsd-Tahseen-Copy1.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Python for Data Science\n",
    "### FUHSD Adult School\n",
    "### Sanjay"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello Sunday\n"
     ]
    }
   ],
   "source": [
    "print(\"Hello Sunday\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello, Python!\n"
     ]
    }
   ],
   "source": [
    "print(\"Hello, Python!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### --- Exercise 1\n",
    "### Print the following string \"Learning Python for Data Science\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Learning Python for Data Science\n"
     ]
    }
   ],
   "source": [
    "# Exercise 1 - write code in this cell and click on Run\n",
    "print(\"Learning Python for Data Science\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "100\n",
      "1000.0\n",
      "John\n",
      "1\n",
      "1\n",
      "1\n"
     ]
    }
   ],
   "source": [
    "counter = 100          # An integer assignment\n",
    "miles   = 1000.0       # A floating point\n",
    "name    = \"John\"       # A string\n",
    "\n",
    "print(counter)\n",
    "print(miles)\n",
    "print(name)\n",
    "\n",
    "a = b = c = 1\n",
    "print(a)\n",
    "print(b)\n",
    "print(c)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### --- Exrecise 2\n",
    "### Create variables with your first_name and last_name\n",
    "### print first_name and last_name"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Tahseen\n",
      "Baig\n"
     ]
    }
   ],
   "source": [
    "# Exercise 2 - Python code\n",
    "first_name='Tahseen'\n",
    "last_name='Baig'\n",
    "print(first_name)\n",
    "print(last_name)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Python for Data Science class is on eight Saturdays 9am to noon\n"
     ]
    }
   ],
   "source": [
    "# Exercise 2b -- write code in this cell and click on Run\n",
    "# Initialise following variables:\n",
    "class_name = \"Python for Data Science\"\n",
    "which_day = \"Saturdays\"\n",
    "Num_days = \"eight\"\n",
    "Class_timings = \"9am to noon\"\n",
    "print(class_name + ' class is on ' + Num_days + ' ' + which_day + ' ' +Class_timings)\n",
    "# You want to print the following:\n",
    "# \"Python for Data Science class is on eight Saturdays 9 am to noon\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello World!\n",
      "H\n",
      "llo W\n",
      "llo World!\n",
      "Hello World!Hello World!\n",
      "Hello World! TEST\n",
      "!\n",
      "ld!\n"
     ]
    }
   ],
   "source": [
    "str = 'Hello World!'\n",
    "\n",
    "a = str\n",
    "b = str[0]\n",
    "c = str[2:7]\n",
    "d = str[2:]\n",
    "e = str * 2\n",
    "f = str + \" \" + \"TEST\"\n",
    "g = str[-1]\n",
    "h = str[-3:]\n",
    "print(a)          # Prints complete string\n",
    "print(b)       # Prints first character of the string\n",
    "print(c)     # Prints characters starting from 3rd to 5th\n",
    "print(d)      # Prints string starting from 3rd character\n",
    "print(e)      # Prints string two times\n",
    "print(f) # Prints concatenated string\n",
    "print(g)\n",
    "print(h)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### --- Exercise 3 \n",
    "### print first two characters of first_name and last two characters of last_name"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "T\n",
      "F\n",
      "B\n",
      "Ta\n",
      "ig\n"
     ]
    }
   ],
   "source": [
    "# Exercise 3 - write code in this cell \n",
    "# You want to extract first letter from first_name, middle_name, and last_name\n",
    "fn='Tahseen'\n",
    "mn='Fatema'\n",
    "ln='Baig'\n",
    "\n",
    "a=fn[0]\n",
    "b=mn[0]\n",
    "c=ln[0]\n",
    "\n",
    "print(a)\n",
    "print(b)\n",
    "print(c)\n",
    "\n",
    "#Print first two characters of Firstname \n",
    "d=fn[0:2]\n",
    "print(d)\n",
    "\n",
    "#Print last two characters of Lastname\n",
    "e=ln[-2:]\n",
    "print(e)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['abcd', 786, 2.23, 'john', 70.2]\n",
      "abcd\n",
      "[786, 2.23]\n",
      "[2.23, 'john', 70.2]\n"
     ]
    }
   ],
   "source": [
    "###########################################################\n",
    "## Python Lists\n",
    "###########################################################\n",
    "list = [ 'abcd', 786 , 2.23, 'john', 70.2 ]\n",
    "\n",
    "print(list)          # Prints complete list\n",
    "print(list[0])       # Prints first element of the list\n",
    "print(list[1:3])     # Prints elements starting from 2nd till 3rd \n",
    "print(list[-3:])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercise 4 -- Lists\n",
    "## Define a new Python list \"new_list\" and initialize it with \"1\",\"A\",\"2\",\"B\",\"3\",\"C\"\n",
    "## Print values with alternate indices 0,2,4 and 1,3,5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3]\n",
      "['A', 'B', 'C']\n"
     ]
    }
   ],
   "source": [
    "## Write code for Exercise 4 in this cell\n",
    "new_list = [1,'A',2,'B',3,'C']\n",
    "L1=new_list[0::2]\n",
    "print (L1)\n",
    "\n",
    "L2=new_list[1::2]\n",
    "print(L2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('abcde', 786, 2.23, 'john', 70.2)\n",
      "abcde\n",
      "(786, 2.23)\n",
      "aaaaa\n"
     ]
    }
   ],
   "source": [
    "###########################################################\n",
    "## Python Tuples\n",
    "###########################################################\n",
    "tuple = ('abcd', 786 , 2.23, 'john', 70.2 )\n",
    "tuple = ('abcde', 786 , 2.23, 'john', 70.2 )\n",
    "# tuple[0] = \"sanjay\"\n",
    "print(tuple)          # Prints complete list\n",
    "print(tuple[0])       # Prints first element of the list\n",
    "print(tuple[1:3])     # Prints elements starting from 2nd till 3rd \n",
    "var1 = \"jshjah\"\n",
    "var1 = \"aaaaa\"\n",
    "print(var1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4 - Got a false expression value\n",
      "150000\n"
     ]
    }
   ],
   "source": [
    "## Decisions in Python\n",
    "var = 150000\n",
    "if var == 2000:\n",
    "   print(\"1 - Got a true expression value\")\n",
    "   print(var)\n",
    "elif var == 150:\n",
    "   print(\"2 - Got a true expression value\")\n",
    "   print(var)\n",
    "elif var == 100:\n",
    "   print(\"3 - Got a true expression value\")\n",
    "   print(var)\n",
    "elif var == \"Sunnyvale\":\n",
    "    print(\"var is Sunnyvale\")\n",
    "else:\n",
    "   print(\"4 - Got a false expression value\")\n",
    "   print(var)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### --- Exercise 5 - if .. elif .. else\n",
    "### Initialize string state_name to be \"California\" or \"Texas\"\n",
    "### write if ... elif ... else checking state_name \n",
    "### if state_name is California, print \"Golden State\"\n",
    "### if state_name is Texas, print \"Lone Star State\"\n",
    "### default else to printing \"Not Golden State or Lone Star State\" "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Golden State\n"
     ]
    }
   ],
   "source": [
    "# Write code for Exercise 5 in this box\n",
    "state_name='California'\n",
    "if state_name == 'California':\n",
    "    print('Golden State')\n",
    "elif state_name == 'Texas':\n",
    "    print(\"Lone Star State\")\n",
    "else:\n",
    "    print('Not Golden State or Lone Star State')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The count is: 0\n",
      "The count is: 1\n",
      "The count is: 2\n",
      "The count is: 3\n",
      "The count is: 4\n",
      "The count is: 5\n",
      "The count is: 6\n",
      "The count is: 7\n",
      "The count is: 8\n",
      "Current Letter : P\n",
      "Current Letter : y\n",
      "Current Letter : t\n",
      "Current Letter : h\n",
      "Current Letter : o\n",
      "Current Letter : n\n",
      "Current fruit : banana\n",
      "Current fruit : apple\n",
      "Current fruit : mango\n",
      "['tesla', 'toyota', 'honda']\n"
     ]
    }
   ],
   "source": [
    "## For and while Loops\n",
    "## while loop\n",
    "count = 0\n",
    "while (count < 9):\n",
    "   print('The count is:', count)\n",
    "   count = count + 1\n",
    "\n",
    "## for loop\n",
    "for letter in 'Python':     # First Example\n",
    "   print('Current Letter :', letter)\n",
    "\n",
    "fruits = ['banana', 'apple',  'mango']\n",
    "for fruit in fruits:        # Second Example\n",
    "   print('Current fruit :', fruit)\n",
    "\n",
    "cars = [\"honda\",\"toyota\",\"tesla\"]\n",
    "cars.reverse()\n",
    "print(cars)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### --- Exercise 6 -- print fruits in reverse order, one line per fruit\n",
    "### mango\n",
    "### apple\n",
    "### banana"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "mango\n",
      "apple\n",
      "banana\n"
     ]
    }
   ],
   "source": [
    "# Write code for Exercise 6 in this cell\n",
    "fruits = ['banana','apple','mango']\n",
    "fruits.reverse()\n",
    "for fruit in fruits:\n",
    "    print(fruit)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "14\n",
      "15\n",
      "14\n",
      "110\n"
     ]
    }
   ],
   "source": [
    "## Functions in Python\n",
    "def add_numbers(a=5,b=10):\n",
    "    c = a + b\n",
    "    return c\n",
    "\n",
    "result = add_numbers(2,12)\n",
    "print(result)\n",
    "result = add_numbers()\n",
    "print(result)\n",
    "result = add_numbers(2,12)\n",
    "print(result)\n",
    "result = add_numbers(100)\n",
    "print(result)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### --- Exercise 7 -- functions -- \n",
    "### write function to find square(a) + square(b), given a and b\n",
    "### def square_and_sum(a,b)\n",
    "### when a = 2 and b = 3, the function should return 13\n",
    "###\n",
    "### write function to add strings \n",
    "### def add_strings(str1,str2)\n",
    "### when str1 = \"Hello\" and str2 = \"World\", \n",
    "### it should return \"Hello World!!!\" with space and !!!. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "13\n",
      "Hello World!!!\n"
     ]
    }
   ],
   "source": [
    "# Write code for Exercise 7 in this cell\n",
    "import math\n",
    "def square_and_sum(a,b):\n",
    "    c=math.pow(a,2)+math.pow(b,2)\n",
    "    return int(c)\n",
    "\n",
    "def add_strings(str1,str2):\n",
    "    str3=str1+ ' '+str2+'!!!'\n",
    "    return str3\n",
    "\n",
    "result = square_and_sum(2,3)\n",
    "print(result)\n",
    "\n",
    "result= add_strings('Hello','World')\n",
    "print(result)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "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"
     ]
    }
   ],
   "source": [
    "for x in range(10): \n",
    "    print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "3\n",
      "5\n"
     ]
    }
   ],
   "source": [
    "# range also follows the format range(start_value,stop_value,step_value)\n",
    "for x in range(1,6,2):\n",
    "    print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### --- Exercise 8 -- using range\n",
    "### print numbers 10, 9, 8, ..., 1"
   ]
  },
  {
   "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": [
    "# Write code for Exercise 8 in this cell\n",
    "for x in range(10,0,-1):\n",
    "    print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "list1-a = [1, 11, 111, 1111]\n",
      "list1-a = [1, 11, 111, 1111]\n",
      "list1-b = [1, 11, 111, 1111, 2, 22, 222]\n",
      "list1-c = [1, 11, 111, 1111, 2, 22]\n",
      "list1-d = [1, 2, 11, 22, 111, 1111]\n",
      "list1-e = [1111, 111, 22, 11, 2, 1]\n"
     ]
    }
   ],
   "source": [
    "## Appending and extending Python lists\n",
    "list1 = [1,11,111]\n",
    "list2 = [2,22,222]\n",
    "\n",
    "list1.append(1111)\n",
    "\n",
    "print(\"list1-a = %s\" % list1)\n",
    "print(\"list1-a =\",list1)\n",
    "\n",
    "list1.extend(list2)\n",
    "print(\"list1-b = %s\" % list1)\n",
    "\n",
    "list1.remove(222)\n",
    "print(\"list1-c = %s\" % list1)\n",
    "\n",
    "list1.sort()\n",
    "print(\"list1-d = %s\" % list1)\n",
    "\n",
    "list1.sort(reverse=True)\n",
    "print(\"list1-e = %s\" % list1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### --- Exercise 9 -- lists with strings\n",
    "### Initialize states_list with California, Texas, Arizona\n",
    "### step 1: Add Florida\n",
    "### step 2: Remove Texas\n",
    "### step 3: Sort ascending order, and print the list\n",
    "### step 4: Sort descending order, and print the list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "state_list-1 = ['California', 'Texas', 'Arizona', 'Florida']\n",
      "state_list-2 = ['California', 'Arizona', 'Florida']\n",
      "state_list-3 = ['Arizona', 'California', 'Florida']\n",
      "state_list-4 = ['Florida', 'California', 'Arizona']\n"
     ]
    }
   ],
   "source": [
    "# Write code for Exercise 9 in this cell\n",
    "state_list = ['California','Texas','Arizona']\n",
    "\n",
    "state_list.append('Florida')\n",
    "print(\"state_list-1 = %s\" % state_list)\n",
    "\n",
    "state_list.remove('Texas')\n",
    "print(\"state_list-2 = %s\" % state_list)\n",
    "\n",
    "state_list.sort()\n",
    "print(\"state_list-3 = %s\" %state_list)\n",
    "\n",
    "state_list.sort(reverse=True)\n",
    "print(\"state_list-4 = %s\" % state_list)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2.5\n",
      "2.5\n",
      "2\n",
      "2.0\n"
     ]
    }
   ],
   "source": [
    "## Integer and floating division\n",
    "def div1(x,y):\n",
    "    print(x/y)\n",
    "    \n",
    "def div2(x,y):\n",
    "    print(x//y) # integer division\n",
    "\n",
    "div1(5,2)\n",
    "div1(5.,2)\n",
    "div2(5,2)\n",
    "div2(5.,2.)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n",
      "22\n",
      "99\n"
     ]
    }
   ],
   "source": [
    "# Printing list length\n",
    "list1 = ['a', 'b', 'c', 'd', 'e']\n",
    "print(len(list1))\n",
    "\n",
    "list2 = [11,22,33,44,55,66,77,88,99,110]\n",
    "print(list2[1])\n",
    "\n",
    "print(list2[-2])       "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1-- 1\n",
      "2-- -1\n",
      "3-- 1\n",
      "4-- 7\n"
     ]
    }
   ],
   "source": [
    "state_name = \"California\"\n",
    "find_str = state_name.find(\"a\")\n",
    "print(\"1--\",find_str)\n",
    "\n",
    "find_str = state_name.find(\"z\")\n",
    "print(\"2--\",find_str)\n",
    "\n",
    "count_str = state_name.count(\"a\",0,4)\n",
    "print(\"3--\",count_str)\n",
    "\n",
    "find_str = state_name.find(\"nia\")\n",
    "print(\"4--\",find_str)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\"you\" at 39\n",
      "\"you\" at 52\n",
      "you_count = 2\n",
      "\"ing\" at 16\n",
      "\"ing\" at 69\n",
      "ing_count = 2\n",
      "life_count = 0\n"
     ]
    }
   ],
   "source": [
    "### --- Exercise 10 -- find, count --- define the string Albert_Einstein\n",
    "### Albert_Einstein = \"Life is like riding a bicycle. To keep your balance \n",
    "### you must keep moving.\"\n",
    "### Find number of occurences for: you, ing, life (all case sensitive)\n",
    "\n",
    "Albert_Einstein=\"Life is like riding a bicycle. To keep your balance you must keep moving.\"\n",
    "\n",
    "def find_substring_at(substring,string):\n",
    "    found = -1\n",
    "    while True:\n",
    "        found = string.find(substring, found + 1)\n",
    "        if found == -1:\n",
    "            break\n",
    "        yield found\n",
    "        \n",
    "def find_substring_count(substring,string):\n",
    "    found_count=string.count(substring)\n",
    "    return found_count\n",
    "    \n",
    "\n",
    "find_you_count = find_substring_count('you',Albert_Einstein)\n",
    "find_ing_count = find_substring_count('ing',Albert_Einstein)\n",
    "find_life_count = find_substring_count('life',Albert_Einstein)\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "find_you_at = find_substring_at('you',Albert_Einstein)\n",
    "for x in find_you_at:\n",
    "    print('\"you\" at %i' % x)\n",
    "print(\"you_count = %i\" %find_you_count)\n",
    "\n",
    "find_ing_at = find_substring_at('ing',Albert_Einstein)\n",
    "for x in find_ing_at:\n",
    "    print('\"ing\" at %i' %x)\n",
    "print(\"ing_count = %i\" %find_ing_count)\n",
    "    \n",
    "find_life_at = find_substring_at('life',Albert_Einstein)\n",
    "for x in find_life_at:\n",
    "    print(x)\n",
    "print(\"life_count = %i\" %find_life_count)\n",
    "\n",
    "#find_ing = Albert_Einstein.count('ing',0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "you at: 39\n",
      "you at: 52\n",
      "\"you\" count is 2\n",
      "ing at: 16\n",
      "ing at: 69\n",
      "\"ing\" count is 2\n",
      "\"life\" count is 0\n"
     ]
    }
   ],
   "source": [
    "# Write code for Exercise 10 in this cell\n",
    "##Using regexp and lookahead\n",
    "\n",
    "import re\n",
    "Albert_Einstein=\"Life is like riding a bicycle. To keep your balance you must keep moving.\"\n",
    "you=[x.start() for x in re.finditer('(?=you)',Albert_Einstein)]\n",
    "for y in you:\n",
    "    print('you at: %i' %y)\n",
    "\n",
    "you_count = Albert_Einstein.count('you')\n",
    "print('\"you\" count is %i' % you_count)\n",
    "\n",
    "ing=[x.start() for x in re.finditer('(?=ing)', Albert_Einstein)]\n",
    "for n in ing:\n",
    "    print('ing at: %i' %n)\n",
    "    \n",
    "ing_count = Albert_Einstein.count('ing')\n",
    "print('\"ing\" count is %i'%ing_count)\n",
    "                                  \n",
    "life=[x.start() for x in re.finditer('(?=life)',Albert_Einstein)]\n",
    "for l in life:\n",
    "    print('life at: %i' %l)\n",
    "\n",
    "life_count=Albert_Einstein.count('life')\n",
    "print('\"life\" count is %i' %life_count)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Words is a list:  ['Python', 'for', 'Data', 'Science', 'at', 'FUHSD', 'Adult', 'School']\n",
      "ss1 is a string:  Python for Data Science at FUHSD Adult School\n"
     ]
    }
   ],
   "source": [
    "# Splitting strings\n",
    "ss = \"Python for Data Science at FUHSD Adult School\"\n",
    "\n",
    "words = ss.split()\n",
    "print(\"Words is a list: \",words)\n",
    "\n",
    "ss1 = \" \".join(words)\n",
    "print(\"ss1 is a string: \",ss1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "states_1 = [\"Washington\",\"Oregon\",\"California\"]\n",
    "states_2 = [\"Texas\",\"Arizona\",\"New Mexico\",\"Nevada\"]\n",
    "states_3 = [\"Florida\",\"Georgia\",\"Alabama\",\"Louisiana\"]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### --- Exrecise 11 Concatenate lists and print alternate\n",
    "### 1) create a new list \"states_123\" which includes states_1,\n",
    "### states_2, and states_3\n",
    "### 2) Sort the list in ascending order\n",
    "### 3) print alternate state names from states_123"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Alternate_States= ['Alabama', 'California', 'Georgia', 'Nevada', 'Oregon', 'Washington']\n"
     ]
    }
   ],
   "source": [
    "states_1 = [\"Washington\",\"Oregon\",\"California\"]\n",
    "states_2 = [\"Texas\",\"Arizona\",\"New Mexico\",\"Nevada\"]\n",
    "states_3 = [\"Florida\",\"Georgia\",\"Alabama\",\"Louisiana\"]\n",
    "\n",
    "#1 Create a New List that iincludes all the three lists\n",
    "states_123= states_1 + states_2 + states_3\n",
    "\n",
    "#print('states_123 = %s' %states_123)\n",
    "\n",
    "#2 Sort the list in ascending order\n",
    "states_123.sort()\n",
    "\n",
    "#Print Alternate statenames from states_123\n",
    "Alternate_states= states_123[0::2]\n",
    "print ('Alternate_States= %s'  %Alternate_states)\n"
   ]
  }
 ],
 "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.6.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}