automate boring.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Usage of len() on a range function to automatically set the precise range of numbers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Index 0 in suplies is: pens\n",
      "Index 1 in suplies is: staplers\n",
      "Index 2 in suplies is: flamethrowers\n",
      "Index 3 in suplies is: binders\n"
     ]
    }
   ],
   "source": [
    "supplies=['pens','staplers','flamethrowers','binders']\n",
    "for i in range(len(supplies)):\n",
    "    print('Index ' + str(i)+' in suplies is: ' + supplies[i])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Usage of IN, similar to SQL "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'pens' in supplies"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'scissors' in supplies"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Usage of the =+ command. Similar to C++ language =+"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "57\n"
     ]
    }
   ],
   "source": [
    "spp=56\n",
    "spp += 1\n",
    "print(spp)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Usage of sort(). Notice How calling the method sorts the list in place and is needed to be called again"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[-7, 1, 2, 3.14, 5]"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "spam=[2,5,3.14,1,-7]\n",
    "spam.sort()\n",
    "spam"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['ants', 'badgers', 'cats', 'dogs', 'elephants']"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "spam2=['ants','cats','dogs','badgers','elephants']\n",
    "spam2.sort()\n",
    "spam2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Small program for random messages based on luck"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "very doubtful\n"
     ]
    }
   ],
   "source": [
    "import random\n",
    "messages=['it is certain','it is decidedly so','yes definitely','reply hazy try again','ask again later','concentrate and ask again','my reply is no','outlook not so good','very doubtful']\n",
    "print(messages[random.randint(0,len(messages)-1)])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Printing messages with a border style"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "***c***\n",
      "***o***\n",
      "***k***\n",
      "***i***\n",
      "***t***\n",
      "***o***\n",
      "*** ***\n",
      "***e***\n",
      "***l***\n",
      "*** ***\n",
      "***p***\n",
      "***e***\n",
      "***r***\n",
      "***r***\n",
      "***i***\n",
      "***t***\n",
      "***o***\n"
     ]
    }
   ],
   "source": [
    "name='cokito el perrito'\n",
    "for i in name:\n",
    "    print('***'+i+'***')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Useful printing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "cokito AGUAS el perrito\n"
     ]
    }
   ],
   "source": [
    "newName=name[0:7]+'AGUAS '+name[7:len(name)]\n",
    "print(newName)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 'Hello', 2, 3, 4, 5]"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "spam3=[0,1,2,3,4,5]\n",
    "cheese=spam3\n",
    "cheese[1]='Hello'\n",
    "spam\n",
    "cheese"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 'Hello', 2, 3, 4, 5]"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "spam3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "How to copy a list correctly. Beign able to modify a variable without modifying the original"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['a', 'b', 'c', 'd']\n",
      "['a', 42, 'c', 'd']\n"
     ]
    }
   ],
   "source": [
    "import copy\n",
    "spam=['a','b','c','d']\n",
    "cheese=copy.copy(spam)\n",
    "cheese[1]=42\n",
    "print(spam)\n",
    "print(cheese)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "applesbananastofucatsapples  bananas  tofu  cats\n",
      "apples bananas tofu and cats "
     ]
    }
   ],
   "source": [
    "spam=['apples','bananas','tofu','cats']\n",
    "for i in spam:\n",
    "    print(i,end='')\n",
    "s=[str(i) for i in spam]\n",
    "res=\"  \".join(s)\n",
    "print(res)\n",
    "\n",
    "spam.insert(-1,'and')\n",
    "for j in spam:\n",
    "    print(j,end=' ')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "grid = [['.', '.', '.', '.', '.', '.'],\n",
    "        ['.', 'O', 'O', '.', '.', '.'],\n",
    "        ['O', 'O', 'O', 'O', '.', '.'],\n",
    "        ['O', 'O', 'O', 'O', 'O', '.'],\n",
    "        ['.', 'O', 'O', 'O', 'O', 'O'],\n",
    "        ['O', 'O', 'O', 'O', 'O', '.'],\n",
    "        ['O', 'O', 'O', 'O', '.', '.'],\n",
    "        ['.', 'O', 'O', '.', '.', '.'],\n",
    "        ['.', '.', '.', '.', '.', '.']]\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Dictionaries"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Alice\n",
      "\n",
      "I dunno whos that\n",
      "when is his birthday\n",
      "dec 16\n",
      "{'Alice': 'Apr 1', 'Bob': 'Dec 12', 'Carol': 'Mar 4', '': 'dec 16'}\n"
     ]
    }
   ],
   "source": [
    "birthdays={'Alice':'Apr 1','Bob':'Dec 12', 'Carol':'Mar 4'}\n",
    "\n",
    "while True:\n",
    "    name=input()\n",
    "    if name =='':\n",
    "        break\n",
    "        \n",
    "if name in birthdays:\n",
    "    print(birthdays[name]+'birthday of'+ name)\n",
    "else:\n",
    "    print('I dunno whos that')\n",
    "    print('when is his birthday')\n",
    "    bday=input()\n",
    "    birthdays[name]=bday\n",
    "    print(birthdays)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Useful adding to list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['perro', 'otro perro']\n"
     ]
    }
   ],
   "source": [
    "a=['perro']\n",
    "a+=['otro perro']\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "inserta un numero de variables5\n",
      "[0, 0, 0, 0, 0]\n",
      "12 34 56 78 92\n",
      "[12, 34, 56, 78, 92]\n"
     ]
    }
   ],
   "source": [
    "x1=input('inserta un numero de variables')\n",
    "x2=int(x1)\n",
    "l1=[0]*x2\n",
    "print(l1)\n",
    "l2=[int(y) for y in input().split() ]\n",
    "print(l2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "I am bringing 5 cups\n",
      "I am bringing 0 eggs\n"
     ]
    }
   ],
   "source": [
    "picnicItems={'apples':5,'cups':5}\n",
    "print('I am bringing '+str(picnicItems.get('cups',0))+' cups')\n",
    "\n",
    "print('I am bringing '+str(picnicItems.get('eggs',0))+' eggs')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{' ': 13,\n",
      " ',': 1,\n",
      " '.': 1,\n",
      " 'A': 1,\n",
      " 'I': 1,\n",
      " 'a': 4,\n",
      " 'b': 1,\n",
      " 'c': 3,\n",
      " 'd': 3,\n",
      " 'e': 5,\n",
      " 'g': 2,\n",
      " 'h': 3,\n",
      " 'i': 6,\n",
      " 'k': 2,\n",
      " 'l': 3,\n",
      " 'n': 4,\n",
      " 'o': 2,\n",
      " 'p': 1,\n",
      " 'r': 5,\n",
      " 's': 3,\n",
      " 't': 6,\n",
      " 'w': 2,\n",
      " 'y': 1}\n",
      "['It', 'was', 'a', 'bright', 'cold', 'day', 'in', 'April,', 'and', 'the', 'clocks', 'were', 'striking', 'thirteen.']\n",
      "{'April,': 1,\n",
      " 'It': 1,\n",
      " 'a': 1,\n",
      " 'and': 1,\n",
      " 'bright': 1,\n",
      " 'clocks': 1,\n",
      " 'cold': 1,\n",
      " 'day': 1,\n",
      " 'in': 1,\n",
      " 'striking': 1,\n",
      " 'the': 1,\n",
      " 'thirteen.': 1,\n",
      " 'was': 1,\n",
      " 'were': 1}\n"
     ]
    }
   ],
   "source": [
    "import pprint\n",
    "message = 'It was a bright cold day in April, and the clocks were striking thirteen.'\n",
    "count={}\n",
    "for character in message:\n",
    "    count.setdefault(character,0)\n",
    "    count[character]=count[character]+1\n",
    "pprint.pprint(count)\n",
    "\n",
    "a=message.split()\n",
    "print(a)\n",
    "cont={}\n",
    "for j in a:\n",
    "    cont.setdefault(j,0)\n",
    "    cont[j]+=1\n",
    "pprint.pprint(cont)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello there! \n",
      " Howare you?\n",
      "I'm doing fine.\n"
     ]
    }
   ],
   "source": [
    "print(\"Hello there! \\n Howare you?\\nI\\'m doing fine.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "this is a single quote ' \n",
      " This is a double quote \" \n",
      " this is \t tab \n",
      " and this is a backlash \\ \n",
      " yoyo\n"
     ]
    }
   ],
   "source": [
    "print(\"this is a single quote \\' \\n This is a double quote \\\" \\n this is \\t tab \\n and this is a backlash \\\\ \\n yoyo\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "That is Carol\\'s cat.\n"
     ]
    }
   ],
   "source": [
    "print(r'That is Carol\\'s cat.')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Dear Alice,\n",
      "\n",
      "Eve's cat has been arrested for catnapping, cat burglary, and extortion.\n",
      "\n",
      "Sincerely,\n",
      "Bob\n"
     ]
    }
   ],
   "source": [
    "print('''Dear Alice,\n",
    "\n",
    "Eve's cat has been arrested for catnapping, cat burglary, and extortion.\n",
    "\n",
    "Sincerely,\n",
    "Bob''')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "!dlroW olleH\n",
      "HloWrd\n"
     ]
    }
   ],
   "source": [
    "spam='Hello World!'\n",
    "print(spam[::-1])\n",
    "a=spam[::2]\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'ello' in spam"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello World!\n",
      "HELLO WORLD!\n",
      "hello world!\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "print(spam)\n",
    "print(spam.upper())\n",
    "print(spam.lower())\n",
    "'hay una serpiente en mi bota'.islower()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "stringy1='this is a test of only strings'\n",
    "stringy1.isalpha()\n",
    "stringy1='this is a test of numbers 12345 and strings'\n",
    "stringy1.isalnum()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter your age:\n",
      "5\n",
      "Select a new password (letters and numbers only):\n",
      "coco323\n"
     ]
    }
   ],
   "source": [
    "while True:\n",
    "    print('Enter your age:')\n",
    "    age = input()\n",
    "    if age.isdecimal():\n",
    "        break\n",
    "    print('Please enter a number for your age.')\n",
    "\n",
    "while True:\n",
    "    print('Select a new password (letters and numbers only):')\n",
    "    password = input()\n",
    "    if password.isalnum():\n",
    "        break\n",
    "    print('Passwords can only have letters and numbers.')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'Hello puebla'.startswith('Hello')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'Hello puebla'.endswith('p puebla')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'cats,rats,bats'"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "','.join(['cats','rats','bats'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'My name is Saul'"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a=' '.join(['My','name','is','Saul'])\n",
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "tmes='my name is coko el perro'.split()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'my name is coko el perro'"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "' '.join(tmes)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['My', 'name', 'is', 'coco']"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'MyCOCOnameCOCOisCOCOcoco'.split('COCO')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['dice',\n",
       " 'que',\n",
       " 'no',\n",
       " 'quiere',\n",
       " 'nada',\n",
       " 'aaa',\n",
       " 'que',\n",
       " 'ella',\n",
       " 'quiere',\n",
       " 'estar',\n",
       " 'sola',\n",
       " 'aaa',\n",
       " 'que',\n",
       " 'no',\n",
       " 'le',\n",
       " 'pregunten',\n",
       " 'nada',\n",
       " 'aaa',\n",
       " 'porque',\n",
       " 'ella',\n",
       " 'se',\n",
       " 'ilusiona',\n",
       " 'aaa']"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "spam='dice que no quiere nada aaa que ella quiere estar sola aaa que no le pregunten nada aaa porque ella se ilusiona aaa'\n",
    "spam.split()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "List to dictionary function for fantasy game inventory"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "dragonLoot=['gold coin','dagger','gold coin','gold coin','ruby']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "inv={'gold coin': 50, 'rope':2}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "def addtoinv(inventory,added_items):\n",
    "    for loot in added_items:\n",
    "        inventory.setdefault(loot,0)\n",
    "        inventory[loot] =+1\n",
    "    return(inventory)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "inv=addtoinv(inv,dragonLoot)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'gold coin': 1, 'rope': 2, 'dagger': 1, 'ruby': 1}\n"
     ]
    }
   ],
   "source": [
    "print(inv)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'     Hello'"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'Hello'.rjust(10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Hello     '"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'Hello'.ljust(10)    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'*****Hello'"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'Hello'.rjust(10,'*')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'===Hello===='"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'Hello'.center(12,'=')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "---PICNIC ITEMS--\n",
      "sandwiches..    4\n",
      "apples......   12\n",
      "cups........    4\n",
      "cookies..... 8000\n",
      "-------PICNIC ITEMS-------\n",
      "sandwiches..........     4\n",
      "apples..............    12\n",
      "cups................     4\n",
      "cookies.............  8000\n"
     ]
    }
   ],
   "source": [
    "def printPicnic(itemsDict, leftWidth, rightWidth):\n",
    "    print('PICNIC ITEMS'.center(leftWidth + rightWidth, '-'))\n",
    "    for k, v in itemsDict.items():\n",
    "        print(k.ljust(leftWidth, '.') + str(v).rjust(rightWidth))\n",
    "picnicItems = {'sandwiches': 4, 'apples': 12, 'cups': 4, 'cookies': 8000}\n",
    "printPicnic(picnicItems, 12, 5)\n",
    "printPicnic(picnicItems, 20, 6)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Hello World    '"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "spam='    Hello World    '\n",
    "spam.strip()\n",
    "spam.lstrip()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello World    \n",
      "    Hello World\n"
     ]
    }
   ],
   "source": [
    "spam='    Hello World    '\n",
    "print(spam.lstrip())\n",
    "print(spam.rstrip())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 45 49 16\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "['1', '45', '49', '16']"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x=input()\n",
    "list(x.split())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'SpamSpamBaconSpamEggsSpamSpam'"
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x22='SpamSpamBaconSpamEggsSpamSpam'\n",
    "x22.strip('Bacon')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'dice que no quiere nada aaa que ella quiere estar sola aaa que no le pregunten nada aaa porque ella se ilusiona aaa'"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "spam='dice que no quiere nada aaa que ella quiere estar sola aaa que no le pregunten nada aaa porque ella se ilusiona aaa'\n",
    "spam.strip()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "415-555-4242 is a phone number:\n",
      "True\n",
      "Moshi moshi is a phone number:\n",
      "False\n",
      "Call me at 4\n",
      "all me at 41\n",
      "ll me at 415\n",
      "l me at 415-\n",
      " me at 415-5\n",
      "me at 415-55\n",
      "e at 415-555\n",
      " at 415-555-\n",
      "at 415-555-1\n",
      "t 415-555-10\n",
      " 415-555-101\n",
      "415-555-1011\n",
      "Phone number found: 415-555-1011\n",
      "15-555-1011 \n",
      "5-555-1011 t\n",
      "-555-1011 to\n",
      "555-1011 tom\n",
      "55-1011 tomo\n",
      "5-1011 tomor\n",
      "-1011 tomorr\n",
      "1011 tomorro\n",
      "011 tomorrow\n",
      "11 tomorrow.\n",
      "1 tomorrow. \n",
      " tomorrow. 4\n",
      "tomorrow. 41\n",
      "omorrow. 415\n",
      "morrow. 415-\n",
      "orrow. 415-5\n",
      "rrow. 415-55\n",
      "row. 415-555\n",
      "ow. 415-555-\n",
      "w. 415-555-9\n",
      ". 415-555-99\n",
      " 415-555-999\n",
      "415-555-9999\n",
      "Phone number found: 415-555-9999\n",
      "15-555-9999 \n",
      "5-555-9999 i\n",
      "-555-9999 is\n",
      "555-9999 is \n",
      "55-9999 is m\n",
      "5-9999 is my\n",
      "-9999 is my \n",
      "9999 is my o\n",
      "999 is my of\n",
      "99 is my off\n",
      "9 is my offi\n",
      " is my offic\n",
      "is my office\n",
      "s my office.\n",
      " my office.\n",
      "my office.\n",
      "y office.\n",
      " office.\n",
      "office.\n",
      "ffice.\n",
      "fice.\n",
      "ice.\n",
      "ce.\n",
      "e.\n",
      ".\n",
      "Done\n"
     ]
    }
   ],
   "source": [
    "def isPhoneNumber(text):\n",
    "    if len(text) != 12:\n",
    "        return False\n",
    "    for i in range(0,3):\n",
    "        if not text[i].isdecimal():\n",
    "            return False\n",
    "    if text[3] !='-':\n",
    "        return False\n",
    "    for i in range(4,7):\n",
    "        if not text[i].isdecimal():\n",
    "            return False\n",
    "    if text[7] !='-':\n",
    "        return False\n",
    "    for i in range(8,12):\n",
    "        if not text[i].isdecimal():\n",
    "            return False\n",
    "    return True\n",
    "print('415-555-4242 is a phone number:')\n",
    "print(isPhoneNumber('415-555-4242'))\n",
    "print('Moshi moshi is a phone number:')\n",
    "print(isPhoneNumber('Moshi moshi'))\n",
    "\n",
    "message = 'Call me at 415-555-1011 tomorrow. 415-555-9999 is my office.'\n",
    "for i in range(len(message)):\n",
    "    chunk=message[i:i+12]\n",
    "    print(chunk)\n",
    "    if isPhoneNumber(chunk):\n",
    "        print('Phone number found: ' + chunk)\n",
    "print('Done')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import re"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Phone number found: 415-222-5252\n"
     ]
    }
   ],
   "source": [
    "phoneNumRegex=re.compile(r'\\d\\d\\d-\\d\\d\\d-\\d\\d\\d\\d')\n",
    "mo=phoneNumRegex.search('My number is 415-222-5252')\n",
    "print('Phone number found: ' + mo.group())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'555-555-5555'"
      ]
     },
     "execution_count": 73,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "phoneNumRegex=re.compile(r'(\\d\\d\\d)-(\\d\\d\\d-\\d\\d\\d\\d)')\n",
    "mo=phoneNumRegex.search('My number is 555-555-5555.')\n",
    "mo.group()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('555', '555-5555')"
      ]
     },
     "execution_count": 74,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mo.groups()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "555\n"
     ]
    }
   ],
   "source": [
    "areaCode,mainNumber=mo.groups()\n",
    "print(areaCode)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "555-5555\n"
     ]
    }
   ],
   "source": [
    "print(mainNumber)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Batman'"
      ]
     },
     "execution_count": 84,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bort=re.compile(r'Batman|Tina')\n",
    "mo1=bort.search('Batman and Tina is in the room')\n",
    "mo1.group()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Tina'"
      ]
     },
     "execution_count": 86,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mo2=bort.search('Tina and Batman is in the room')\n",
    "mo2.group()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Batmobile'"
      ]
     },
     "execution_count": 89,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "BatRegex=re.compile(r'Bat(man|mobile|copter|phone)')\n",
    "mo=BatRegex.search('Batmobile lost a wheel')\n",
    "mo.group()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Batman'"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "batRegex=re.compile(r'Bat(wo)?man')\n",
    "mo1=batRegex.search('The adventures of Batman')\n",
    "mo1.group()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('wo',)"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mo2=batRegex.search('The adventures of Batwoman')\n",
    "mo2.group()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Batman'"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "batRegex=re.compile(r'Bat(wo)*man')\n",
    "mo1=batRegex.search('The adventures of Batman')\n",
    "mo1.group()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Batwoman'"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "batRegex=re.compile(r'Bat(wo)*man')\n",
    "mo2=batRegex.search('The adventures of Batwoman')\n",
    "mo2.group()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Batwowowoman'"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "batRegex=re.compile(r'Bat(wo)*man')\n",
    "mo3=batRegex.search('The adventures of Batwowowoman')\n",
    "mo3.group()"
   ]
  },
  {
   "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.6.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}