Lecture07.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter student name: Jason \n",
      "Enter student name: Hunter\n"
     ]
    }
   ],
   "source": [
    "nameHandle = open('students','w')\n",
    "for i in range(2):\n",
    "    name=input('Enter student name: ')\n",
    "    nameHandle.write(name+'\\n')\n",
    "nameHandle.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Jason \n",
      "\n",
      "Hunter\n",
      "\n"
     ]
    }
   ],
   "source": [
    "nameHandle = open('students','r')\n",
    "for line in nameHandle:\n",
    "    print(line)\n",
    "nameHandle.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Archimedes\n",
      "Diophantus\n"
     ]
    }
   ],
   "source": [
    "nameHandle=open('students', 'w')\n",
    "nameHandle.write('Archimedes\\n')\n",
    "nameHandle.write('Diophantus\\n')\n",
    "nameHandle.close()\n",
    "nameHandle = open('students','r')\n",
    "for line in nameHandle:\n",
    "    print(line[:-1])\n",
    "nameHandle.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Archimedes\n",
      "Diophantus\n",
      "Jason\n",
      "Hunter\n"
     ]
    }
   ],
   "source": [
    "nameHandle = open('students','a')\n",
    "nameHandle.write('Jason\\n')\n",
    "nameHandle.write('Hunter\\n')\n",
    "nameHandle.close()\n",
    "nameHandle = open('students','r')\n",
    "for line in nameHandle:\n",
    "    print(line[:-1])\n",
    "nameHandle.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "()\n",
      "(1, 'two', 3.0)\n"
     ]
    }
   ],
   "source": [
    "t1=()\n",
    "t2=(1,'two',3.0)\n",
    "print(t1)\n",
    "print(t2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "((1, 'two', 3), 3.25)\n",
      "(1, 'two', 3, (1, 'two', 3), 3.25)\n",
      "(1, 'two', 3)\n",
      "(3, (1, 'two', 3), 3.25)\n"
     ]
    }
   ],
   "source": [
    "t1=(1,'two',3)\n",
    "t2=(t1,3.25)\n",
    "t3=t1+t2\n",
    "print(t2)\n",
    "print(t3)\n",
    "print(t3[3])\n",
    "print(t3[2:5])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 2, 4, 5, 8, 10, 16, 20, 25, 40, 50, 80, 100, 200, 400)\n",
      "The sum of divisors is: 961\n"
     ]
    }
   ],
   "source": [
    "def findDivisors (n1,n2):\n",
    "    \"\"\"Assumes that n1 and n2 are postive integers.\n",
    "        Returns a tuple containing all common divisors of n1 and n2\"\"\"\n",
    "    divisors=()   #empty tuple\n",
    "    for i in range(1, min(n1,n2)+1):\n",
    "        if n1%i==0 and n2%i==0:\n",
    "            divisors = divisors  + (i,)\n",
    "    return divisors\n",
    "\n",
    "divisors=findDivisors(800,2000)\n",
    "print(divisors)\n",
    "total= 0\n",
    "for d in divisors:\n",
    "    total += d\n",
    "print(\"The sum of divisors is:\", total)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x = 1  and c = t\n"
     ]
    }
   ],
   "source": [
    "x, y = (1,2)\n",
    "a, b, c = 'cat'\n",
    "print(\"x =\",x,\" and c =\",c)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "def findExtremeDivisors(n1,n2):\n",
    "    \"\"\"Assumes that n1 and n2 are positive integers.  Returns \n",
    "    a tuple containing the smallest common divisor>1 and the \n",
    "    largest common divisor of n1 and n2 \"\"\"\n",
    "    divisors = () #the empty tuple\n",
    "    minVal, maxVal = None, None\n",
    "    for i in range(2, min(n1, n2) + 1):\n",
    "        if n1%i == 0 and n2%i == 0:\n",
    "            if minVal == None or i < minVal:\n",
    "                minVal = i\n",
    "            if maxVal == None or i > maxVal:\n",
    "                maxVal = i\n",
    "    return (minVal, maxVal)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2 100\n"
     ]
    }
   ],
   "source": [
    "minDivisor, maxDivisor = findExtremeDivisors(100,200)\n",
    "print(minDivisor, maxDivisor)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "pears\n",
      "5\n",
      "----------\n",
      "apples\n",
      "pears\n",
      "corn\n",
      "2019\n",
      "2020\n"
     ]
    }
   ],
   "source": [
    "L=['apples','pears','corn',2019, 2020]\n",
    "print(L[1])\n",
    "print(len(L))\n",
    "print(\"----------\")\n",
    "for i in range(len(L)):\n",
    "    print(L[i])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "M=['alone',]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "ename": "IndexError",
     "evalue": "list index out of range",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mIndexError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-15-6b125f96825d>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mM\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;31m#The blank is not a string\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mIndexError\u001b[0m: list index out of range"
     ]
    }
   ],
   "source": [
    "print(M[1]) #The blank is not a string"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[['Harvard', 'Yale'], ['UF', 'UCF']]\n",
      "[['Harvard', 'Yale'], ['UF', 'UCF']]\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "Ivys=['Harvard', 'Yale']\n",
    "Florida=['UF','UCF']\n",
    "jux=[Ivys,Florida] #juxtaposition \n",
    "tog=[['Harvard', 'Yale'],['UF','UCF']]\n",
    "print(jux)\n",
    "print(tog)\n",
    "print(jux==tog)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "False\n",
      "Id of tog= 2347967040328\n",
      "Id of jux= 2347966972936\n"
     ]
    }
   ],
   "source": [
    "print(jux==tog)\n",
    "print(id(jux)==id(tog))\n",
    "print('Id of tog=', id(tog))\n",
    "print('Id of jux=',id(jux))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[['Harvard', 'Yale'], ['UF', 'UCF', 'FSU']]\n",
      "[['Harvard', 'Yale'], ['UF', 'UCF']]\n"
     ]
    }
   ],
   "source": [
    "Florida.append('FSU') #append to list \n",
    "print(jux)\n",
    "print(tog)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "schools:  ['Harvard', 'Yale']\n",
      " which contains\n",
      "   Harvard\n",
      "   Yale\n",
      "schools:  ['UF', 'UCF']\n",
      " which contains\n",
      "   UF\n",
      "   UCF\n"
     ]
    }
   ],
   "source": [
    "for i in tog: #each item in the list\n",
    "    print('schools: ',i) \n",
    "    print(' which contains') # 1 space in front\n",
    "    for u in i: #each item in the sublist\n",
    "        print('  ',u) # 2 spaces in front\n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "t1 before append:  (1, 'two', 3)\n",
      "t3 before append to t1: (1, 'two', 3, 'apple', 'onion')\n",
      "t1 after append:  (1, 'two', 3, '5')\n",
      "t3 after append to t1: (1, 'two', 3, 'apple', 'onion')\n"
     ]
    }
   ],
   "source": [
    "t1=(1,'two',3)\n",
    "t2=('apple', 'onion')\n",
    "t3=t1+t2 #created a tuple with t1\n",
    "print('t1 before append: ',t1)\n",
    "print('t3 before append to t1:',t3)\n",
    "t1=t1+('5',) #append to tuple t1\n",
    "print('t1 after append: ',t1)\n",
    "print('t3 after append to t1:',t3)  #check if t3 is affected\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "L3= [1, 2, 3, 4, 5, 6]\n",
      "L1= [1, 2, 3, 4, 5, 6]\n",
      "L1= [1, 2, 3, 4, 5, 6, [4, 5, 6]]\n",
      "L3= [1, 2, 3, 4, 5, 6]\n"
     ]
    }
   ],
   "source": [
    "L1=[1,2,3]\n",
    "L2=[4,5,6]\n",
    "L3=L1+L2      #creates a new list\n",
    "print('L3=', L3)\n",
    "L1.extend(L2)  #mutated L1\n",
    "print('L1=',L1)\n",
    "L1.append(L2)  #mutated L1 again!\n",
    "print('L1=',L1)\n",
    "print('L3=', L3) #L3 should stay the same"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "L1= [2, 3, 4]\n"
     ]
    }
   ],
   "source": [
    "def removeDups(L1,L2):\n",
    "    \"\"\"Assumes that L1 and L2 are lists\n",
    "    Removes any element from L1 that also occurs in L2\"\"\"\n",
    "    for e1 in L1:\n",
    "        if e1 in L2:\n",
    "            L1.remove(e1)\n",
    "            \n",
    "L1=[1,2,3,4]\n",
    "L2=[1,2,5,6]\n",
    "removeDups(L1,L2)\n",
    "print('L1=',L1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "L1= [3, 4]\n"
     ]
    }
   ],
   "source": [
    "def removeDups(L1,L2):\n",
    "    \"\"\"Assumes that L1 and L2 are lists\n",
    "    Removes any element from L1 that also occurs in L2\"\"\"\n",
    "    for e1 in L1[:]:   #Wow! So subtle! What did that do?\n",
    "        if e1 in L2:\n",
    "            L1.remove(e1)\n",
    "            \n",
    "L1=[1,2,3,4]\n",
    "L2=[1,2,5,6]\n",
    "removeDups(L1,L2)\n",
    "print('L1=',L1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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
}