Python_Lecture_3_PYTHON_STRINGS_LISTS.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Working with Sequences: Strings and Lists"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A sequence is an object that holds multiple items of data, stored one after the other. You can perform operations on a sequence, to examine and manipulate the items stored in it.\n",
    "\n",
    "Two of the fundamental sequence types: strings and lists."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Working with Strings"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python provides several ways to access the individual characters in a string. Strings also have methods that allow you to perform operations on them. The operations that you have performed with strings so far have primarily involved only input and output. For example, you have read strings as input from the keyboard and from files, and sent strings as output to the screen and to files."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Accessing the individual characters in strings"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "we will look at two techniques that you can use in Python to access the individual characters in a string: using the for loop, and indexing. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Iterating Over a String with the for Loop"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "One of the easiest ways to access the individual characters in a string is to use the for loop. Here is the general format:\n",
    "\n",
    "for variable  in  string : \n",
    "\n",
    "\tstatement \n",
    "\tstatement \n",
    "\tetc."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "J\n",
      "u\n",
      "l\n",
      "i\n",
      "e\n",
      "t\n",
      " \n"
     ]
    }
   ],
   "source": [
    "name = 'Juliet ' \n",
    "for ch in name:\n",
    "    print ch"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Juliet\n",
      "Juliet\n",
      "Juliet\n",
      "Juliet\n",
      "Juliet\n",
      "Juliet\n"
     ]
    }
   ],
   "source": [
    "name = 'Juliet' \n",
    "for ch in name:\n",
    "    ch = ' X '\n",
    "    print name"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter a sentence: TTTTTTTTTTTtttttttttttttttttwwww\n",
      "The letter T appears  28 times. \n"
     ]
    }
   ],
   "source": [
    "# This program counts the number times \n",
    "# the letter T (uppercase or lowercase) \n",
    "# appears in a string. \n",
    "def main():\n",
    "    # Create a variable to use to hold the count.\n",
    "    # The variable must start with 0 .\n",
    "    count = 0\n",
    "    # Get a string from the user.\n",
    "    my_string = raw_input('Enter a sentence: ' )\n",
    "    # Count the Ts.\n",
    "    for ch in my_string:\n",
    "        if ch == 'T' or ch =='t' :\n",
    "            count += 1\n",
    "        # Print the result.\n",
    "    print 'The letter T appears ' , count, 'times. '\n",
    "# Call the main function.\n",
    "main ( )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Indexing"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Another way that you can access the individual characters in a string is with an index. Each character in a string has an index which specifies its position in the string.\n",
    "\n",
    "Indexing starts at 0, so the index of the first character is 0, the index of the second character is 1, and so forth. The index of the last character in a string is 1 less than the number of characters in the string.\n",
    "\n",
    "You can use an index to retrieve a copy of an individual character in a string."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " R a  \n"
     ]
    }
   ],
   "source": [
    "my_string = 'Roses are red' \n",
    "print my_string[0], my_string[6], my_string[9]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can also use negative numbers as indexes, to identify character positions relative to the end of the string. The Python interpreter adds negative indexes to the length of the string to determine the character position. The index - 1 identifies the last character in a string, -2 identifies the next to last character, and so forth."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "d e r\n"
     ]
    }
   ],
   "source": [
    "my_string = 'Roses are red' \n",
    "print my_string[-1], my_string[-2], my_string[-3]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Index Error Exceptions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "An I n d e x E r r o r exception will occur if you try to use an index that is out of range for a particular string. For example, the string Boston ' has 6 characters, so the valid indexes are 0 through 5. (The valid negative indexes are -1 through -6.) The following is an example of code that causes an Index Error exception. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "ename": "IndexError",
     "evalue": "string 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-4fb4b17584eb>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0mcity\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m'Boston'\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0;32mprint\u001b[0m \u001b[0mcity\u001b[0m \u001b[0;34m[\u001b[0m \u001b[0;36m6\u001b[0m \u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mIndexError\u001b[0m: string index out of range"
     ]
    }
   ],
   "source": [
    "city = 'Boston' \n",
    "print city [ 6 ]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "More Examples:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "ename": "IndexError",
     "evalue": "string 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-14-415eda88dbc9>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0mmy_string\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m'Roses are red'\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0;32mprint\u001b[0m \u001b[0mmy_string\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m13\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mIndexError\u001b[0m: string index out of range"
     ]
    }
   ],
   "source": [
    "my_string = 'Roses are red' \n",
    "print my_string[13]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "ename": "IndexError",
     "evalue": "string 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-13-38f0944383f0>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0mmy_string\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m'Roses are red'\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0;32mprint\u001b[0m \u001b[0mmy_string\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m-\u001b[0m\u001b[0;36m14\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mIndexError\u001b[0m: string index out of range"
     ]
    }
   ],
   "source": [
    "my_string = 'Roses are red' \n",
    "print my_string[-14]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This type of error is most likely to happen when a loop incorrectly iterates beyond the end of a string, as shown here:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "B\n",
      "o\n",
      "s\n",
      "t\n",
      "o\n",
      "n\n"
     ]
    },
    {
     "ename": "IndexError",
     "evalue": "string 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-16-0767fdeaafdb>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      2\u001b[0m \u001b[0mindex\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;36m0\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      3\u001b[0m \u001b[0;32mwhile\u001b[0m \u001b[0mindex\u001b[0m \u001b[0;34m<\u001b[0m \u001b[0;36m7\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 4\u001b[0;31m     \u001b[0;32mprint\u001b[0m \u001b[0mcity\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mindex\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      5\u001b[0m     \u001b[0mindex\u001b[0m \u001b[0;34m+=\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mIndexError\u001b[0m: string index out of range"
     ]
    }
   ],
   "source": [
    "city = 'Boston' \n",
    "index = 0 \n",
    "while index < 7:\n",
    "    print city[index]\n",
    "    index += 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "he last time that this loop iterates, the index variable will be assigned the value 6 , which is an invalid index for the string 'Boston' . As a result, the print statement will cause an Index Error exception to be raised."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# The len Function"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python has a built-in function named l e n that returns the length of a sequence, such as a string. The following code demonstrates:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "6\n"
     ]
    }
   ],
   "source": [
    "city ='Boston' \n",
    "size = len(city)\n",
    "print size"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The len function is especially useful to prevent loops from iterating beyond the end of a string, as shown here:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "B\n",
      "o\n",
      "s\n",
      "t\n",
      "o\n",
      "n\n"
     ]
    }
   ],
   "source": [
    "city = 'Boston' \n",
    "index = 0 \n",
    "while index < len(city) :\n",
    "    print city[index]\n",
    "    index += 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Strings are Immutable"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In Python, strings are immutable, which means that once they are created, they cannot be changed. Some operations, such as concatenation, give the impression that they modify strings, but in reality they do not."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The name is  Carmen\n",
      "Now the name is Carmen Brown\n"
     ]
    }
   ],
   "source": [
    "# This program concatenates strings. \n",
    "def main ( ) :\n",
    "    name = 'Carmen'\n",
    "    print 'The name is ' , name\n",
    "    name = name + ' Brown'\n",
    "    print 'Now the name is', name \n",
    "# Call the main function. \n",
    "main ( )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here, the original string 'Carmen' is not modified. Instead, a new string containing 'Carmen Brown' is created and assigned to the name variable. (The original string, Carmen is no longer usable because no variable references it. The Python interpreter will eventually remove the unusable string from memory.)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Because strings are immutable, you cannot use an expression in the form string[index] on the left side of an assignment operator. For example, the following code will cause an error:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "'str' object does not support item assignment",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-28-efa8dbea11f3>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      2\u001b[0m \u001b[0mfriend\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m'Bill'\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      3\u001b[0m \u001b[0;31m# Can we change the first character to 'J'?\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 4\u001b[0;31m \u001b[0mfriend\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m'J'\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      5\u001b[0m \u001b[0;31m# No, this will cause an error!\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mTypeError\u001b[0m: 'str' object does not support item assignment"
     ]
    }
   ],
   "source": [
    "# Assign 'Bill' to friend. \n",
    "friend = 'Bill' \n",
    "# Can we change the first character to 'J'? \n",
    "friend[0] = 'J' \n",
    "# No, this will cause an error!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The last statement in this code will raise an exception because it attempts to change the value of the first character in the string 'Bill' ."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# String Slicing"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A slice is a span of items that are taken from a sequence. When you take a slice from a string, you get a span of characters from within the string. String slices are also called substrings.\n",
    "\n",
    "To get a slice of a string, you write an expression in the following general format:\n",
    "\n",
    "string [start : end]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Lynn \n",
      "Patty \n",
      "Smith \n",
      "Patty Lynn Smith \n",
      "Smith \n",
      "Patty Lynn Smith\n"
     ]
    }
   ],
   "source": [
    "full_name = 'Patty Lynn Smith' \n",
    "middle_name = full_name[6:10]\n",
    "first_name = full_name[:5]\n",
    "last_name = full_name[11:]\n",
    "last_name1 = full_name[:]\n",
    "first_name1 = full_name[-5:]\n",
    "my_string = full_name[0 : len(full_name)]\n",
    "print middle_name ,'\\n' ,first_name , '\\n' , last_name, '\\n', last_name1, '\\n', first_name1, '\\n', my_string"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ACEGIKMOQSUWY\n"
     ]
    }
   ],
   "source": [
    "letters = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' \n",
    "print letters[0:26:2]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Testing string with in and not in"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In Python you can use the i n operator to determine whether one string is contained in another string. Here is the general format of an expression using the i n operator with two strings:\n",
    "\n",
    "string1 in string2\n",
    "\n",
    "For example, look at the following code:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The string \"seven\" was found.\n"
     ]
    }
   ],
   "source": [
    "text = 'Four score and seven years ago' \n",
    "if 'seven' in text:\n",
    "    print 'The string \"seven\" was found.'\n",
    "else :\n",
    "    print 'The string \"seven\" was not found.'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Pierre was not found. \n"
     ]
    }
   ],
   "source": [
    "names = 'Bill Joanne Susan Chris Juan Katie' \n",
    "if 'Pierre' not in names:\n",
    "    print 'Pierre was not found. ' \n",
    "else :\n",
    "    print 'Pierre was found. '"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# String Methods"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A method is a function that belongs to an object, and performs some operation on that object. Strings in Python have numerous methods. we will discuss several string methods for performing the following types of operations: \n",
    "\n",
    "1. Testing the values of strings \n",
    "2. Performing various modifications \n",
    "3. Searching for substrings and replacing sequences of characters\n",
    "\n",
    "Here is the general format of a string method call:\n",
    "\n",
    "stringvar.method(arguments)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " 1200 contains characters other than digits.\n"
     ]
    }
   ],
   "source": [
    "stringl = ' 1200' \n",
    "if stringl.isdigit():\n",
    "    print stringl, 'contains only digits.' \n",
    "else :\n",
    "    print stringl, 'contains characters other than digits.'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter a string: 123\n",
      "This is what I found about that string: \n",
      "The string is alphanumeric.\n",
      "The string contains only digits.\n"
     ]
    }
   ],
   "source": [
    "# This program demonstrates several string testing methods. \n",
    "def main():\n",
    "    # Get a string from the user.\n",
    "    user_string = raw_input('Enter a string: ' )\n",
    "    print 'This is what I found about that string: '\n",
    "    # Test the string.\n",
    "    if user_string.isalnum():\n",
    "        print 'The string is alphanumeric.'\n",
    "    if user_string.isdigit():\n",
    "        print 'The string contains only digits.'\n",
    "    if user_string.isalpha():\n",
    "        print 'The string contains only alphabetic characters.'\n",
    "    if user_string.isspace():\n",
    "        print 'The string contains only whitespace characters.'\n",
    "    if user_string.islower():\n",
    "        print 'The letters in the string are all lowercase. '\n",
    "    if user_string.isupper():\n",
    "        print 'The letters in the string are all uppercase. ' \n",
    "# Call the string. \n",
    "main()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Modification Methods"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1. lower ( ) : Returns a copy of the string with all alphabetic letters converted to lowercase. Any character that is already lowercase, or is not an alphabetic letter, is unchanged.\n",
    "\n",
    "2. lstrip( ) : Returns a copy of the string with all leading whitespace characters removed. Leading whitespace characters are spaces, newlines ( \\ n ) , and tabs (\\t) that appear at the beginning of the string.\n",
    "\n",
    "3. lstrip(char) : The char argument is a string containing a character. Returns a copy of the string with all instances of char that appear at the beginning of the string removed.\n",
    "\n",
    "4. rstrip( ) : Returns a copy of the string with all trailing whitespace characters removed. Trailing whitespace characters are spaces, newlines ( \\ n ) , and tabs (\\t) that appear at the end of the string.\n",
    "\n",
    "5. rstrip(char) : The char argument is a string containing a character. The method returns a copy of the string with all instances of char. that appear at the end of the string removed.\n",
    "\n",
    "6. sstrip( ) : Returns a copy of the string with all leading and trailing whitespace characters removed.\n",
    "\n",
    "7. sstrip(char) : Returns a copy of the string with all instances of char that appear at the beginning and the end of the string removed.\n",
    "\n",
    "8. upper() :  Returns a copy of the string with all alphabetic letters converted to uppercase. Any character that is already uppercase, or is not an alphabetic letter, is unchanged."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WXYZ wxyz\n",
      "Hello\n",
      "Do you want to see that again?\n",
      " y =. yes, anything else = no: y\n",
      "Hello\n",
      "Do you want to see that again?\n",
      " y =. yes, anything else = no: y\n",
      "Hello\n",
      "Do you want to see that again?\n",
      " y =. yes, anything else = no: n\n"
     ]
    }
   ],
   "source": [
    "letters = 'WXYZ' \n",
    "print letters, letters.lower()\n",
    "\n",
    "again = 'y' \n",
    "while again.lower() == 'y':\n",
    "    print 'Hello'\n",
    "    print 'Do you want to see that again?'\n",
    "    again = raw_input( ' y =. yes, anything else = no: ' )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Searching and Replacing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter the filename: eee\n",
      "Unknown file type. \n"
     ]
    }
   ],
   "source": [
    "filename = raw_input('Enter the filename: ' ) \n",
    "if filename.endswith('.txt'):\n",
    "    print 'That is the name of a text file. ' \n",
    "elif filename.endswith('.py'):\n",
    "    print 'That is the name of a Python source file. ' \n",
    "elif filename.endswith('.doc'):\n",
    "    print 'That is the name of a word processing document' \n",
    "else :\n",
    "    print 'Unknown file type. '"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The word \"seven\" was found at index 15\n"
     ]
    }
   ],
   "source": [
    "string = 'Four score and seven years ago' \n",
    "position = string.find('seven') \n",
    "if position != -1:\n",
    "    print 'The word \"seven\" was found at index', position \n",
    "else :\n",
    "    print 'The word \"seven\" was not found. '"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Four score and seven days ago\n"
     ]
    }
   ],
   "source": [
    "string = 'Four score and seven years ago' \n",
    "new_string = string.replace('years', 'days') \n",
    "print new_string"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Repetition operator"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "when the operand on the left side of the * symbol is a string and the operand on the right side is an integer, it becomes the repetition operator. Here is the general format: \n",
    "\n",
    "string-to-copy * n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello Hello Hello Hello Hello \n"
     ]
    }
   ],
   "source": [
    "print 'Hello ' * 5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " 2 \n",
      " 2  2 \n",
      " 2  2  2 \n",
      " 2  2  2  2 \n",
      " 2  2  2  2  2 \n",
      " 2  2  2  2  2  2 \n",
      " 2  2  2  2  2  2  2 \n",
      " 2  2  2  2  2  2  2  2 \n",
      " 2  2  2  2  2  2  2  2  2 \n",
      "ZZZZZZZZ\n",
      "ZZZZZZZ\n",
      "ZZZZZZ\n",
      "ZZZZZ\n",
      "ZZZZ\n",
      "ZZZ\n",
      "ZZ\n",
      "Z\n"
     ]
    }
   ],
   "source": [
    "# This program demonstrates the repetition operator. \n",
    "def main():\n",
    "    # Print 9 rows increasing in length.\n",
    "    for count in range(1, 10):\n",
    "        print ' 2 ' * count\n",
    "    # Print 9 rows decreasing in length.\n",
    "    for count in range(8, 0, -1):\n",
    "        print 'Z' * count\n",
    "# Call the main function. \n",
    "main()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Lists"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A list is an object that contains multiple data items. Lists are mutable, \n",
    "which means that their contents can be changed during a program's \n",
    "execution. Lists are dynamic data structures, meaning that items may be \n",
    "added to them or removed from them. You can use indexing, slicing, and \n",
    "various methods to work with lists in a program.\n",
    "\n",
    "A list is an object that contains multiple data items. Each item that is stored in a list is called \n",
    "an element. Here is a statement that creates a list of integers:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2, 4, 6, 8, 10]\n"
     ]
    }
   ],
   "source": [
    "even_numbers = [2, 4, 6 , 8, 10]\n",
    "print even_numbers"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can use the range function, to generate a list of integers. Here is an example: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 1, 2, 3, 4]\n"
     ]
    }
   ],
   "source": [
    "numbers = range(5)\n",
    "print numbers"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this statement the r a n g e function will return a list of integers in the range of 0 up \n",
    "to (but not including) 5. This statement will assign the list [0, 1, 2 , 3, 4 ] to the \n",
    "numbers variable. Here is another example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 3, 5, 7, 9]\n"
     ]
    }
   ],
   "source": [
    "numbers = range(1, 10, 2 )\n",
    "print numbers"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can use the repetition operator ( * ) to easily create a list with a specific number of \n",
    "elements, each with the same value. Here is an example: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 0, 0, 0, 0]\n"
     ]
    }
   ],
   "source": [
    "numbers = [0 ] * 5\n",
    "print numbers"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Iterating over a List with the for Loop"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "199\n",
      "100\n",
      "101\n",
      "102\n"
     ]
    }
   ],
   "source": [
    "numbers = [199, 100, 101, 102]\n",
    "for n in numbers:\n",
    "    print n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Indexing"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Indexing works with lists just as it does with strings. Each element in a list has an index \n",
    "which specifies its position in the list. Indexing starts at 0, so the index of the first element \n",
    "is 0, the index of the second element is 1, and so forth. The index of the last element in a \n",
    "list is 1 less than the number of elements in the list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10 20 30 40\n"
     ]
    }
   ],
   "source": [
    "my_list = [10, 20, 30, 40]\n",
    "print my_list[0],my_list[1],my_list[2], my_list[3]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The following loop also prints the elements of the list: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n",
      "20\n",
      "30\n",
      "40\n"
     ]
    }
   ],
   "source": [
    "index = 0 \n",
    "while index < 4:\n",
    "    print my_list[index]\n",
    "    index += 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can also use negative indexes with lists, to identify element positions relative to the end \n",
    "of the list. The Python interpreter adds negative indexes to the length of the list to deter- \n",
    "mine the element position. The index -1 identifies the last element in a list, -2 identifies \n",
    "the next to last element, and so forth. The following code shows an example: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "40 30 20 10\n"
     ]
    }
   ],
   "source": [
    "my_list = [10, 20, 30, 40]\n",
    "print my_list[-1], my_list[-2], my_list[-3], my_list[-4]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Index Error Exception"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "An Index Error exception will be raised if you use an invalid index with a list. For example, look at the following code:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n",
      "20\n",
      "30\n",
      "40\n"
     ]
    },
    {
     "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-79-dd3232ba22ed>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      3\u001b[0m \u001b[0mindex\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;36m0\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      4\u001b[0m \u001b[0;32mwhile\u001b[0m \u001b[0mindex\u001b[0m \u001b[0;34m<\u001b[0m \u001b[0;36m5\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 5\u001b[0;31m     \u001b[0;32mprint\u001b[0m \u001b[0mmy_list\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mindex\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      6\u001b[0m     \u001b[0mindex\u001b[0m \u001b[0;34m+=\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mIndexError\u001b[0m: list index out of range"
     ]
    }
   ],
   "source": [
    "# This code will cause an IndexError exception. \n",
    "my_list = [10, 20, 30, 40]\n",
    "index = 0 \n",
    "while index < 5:\n",
    "    print my_list[index]\n",
    "    index += 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n",
      "20\n",
      "30\n",
      "40\n"
     ]
    }
   ],
   "source": [
    "my_list = [ 10 , 20, 30, 40]\n",
    "index = 0 \n",
    "while index < len(my_list):\n",
    "           print my_list[index]\n",
    "           index += 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Slicing operations"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Slicing operations work with lists just as they do with strings. For example, suppose we \n",
    "create the following list: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Tuesday', 'Wednesday', 'Thursday']\n"
     ]
    }
   ],
   "source": [
    "days = ['Sunday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday']\n",
    "mid_days = days[2:5]\n",
    "print mid_days"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Finding items in a List with in and not in"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter a product number: ert8\n",
      "ert8 was not found in the list. \n"
     ]
    }
   ],
   "source": [
    "# This program demonstrates the in operator \n",
    "# used with a list. \n",
    "def main( ) :\n",
    "    # Create a list of product numbers.\n",
    "    prod_nums = ['V475', 'F987', 'Q143', 'R688']\n",
    "    # Get a product number to search for.\n",
    "    search =raw_input('Enter a product number: ' )\n",
    "    # Determine whether the product number is in the list.\n",
    "    if search in prod_nums:\n",
    "        print search, 'was found in the list.'\n",
    "    else:\n",
    "        print search, 'was not found in the list. ' \n",
    "# Call the main function. \n",
    "main()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Lists are mutable"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Unlike strings, lists in Python are mutable, which means their elements can be changed. \n",
    "Consequently, an expression in the form list[index] can appear on the left side of an \n",
    "assignment operator. The following code shows an example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 4]\n",
      "[99, 2, 3, 4]\n"
     ]
    }
   ],
   "source": [
    "numbers = [ 1 , 2,3,4]\n",
    "print numbers\n",
    "numbers[0] = 99\n",
    "print numbers"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Index Error"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {},
   "outputs": [
    {
     "ename": "IndexError",
     "evalue": "list assignment 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-88-02125212dfbf>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0mnumbers\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m \u001b[0;36m1\u001b[0m \u001b[0;34m,\u001b[0m \u001b[0;36m2\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m3\u001b[0m \u001b[0;34m,\u001b[0m \u001b[0;36m4\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m5\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;31m# Create a list with 5 elements.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0mnumbers\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;36m5\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;36m99\u001b[0m \u001b[0;31m# This raises an exception!\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mIndexError\u001b[0m: list assignment index out of range"
     ]
    }
   ],
   "source": [
    "numbers = [ 1 , 2, 3 , 4, 5] # Create a list with 5 elements. \n",
    "numbers [5] = 99 # This raises an exception!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Create a list with 5 elements."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[99, 99, 99, 99, 99]\n"
     ]
    }
   ],
   "source": [
    "# Create a list with 5 elements. \n",
    "numbers = [0] * 5 \n",
    "# Fill the list with the value 99. \n",
    "index = 0 \n",
    "while index < len(numbers):\n",
    "    numbers[index] = 99\n",
    "    index += 1\n",
    "print numbers"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The following program shows an example of how user input can be assigned to the elements of a list. \n",
    "This program gets sales amounts from the user and assigns them to a list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter the sales for each day.\n",
      "Day # 1: 25\n",
      "Day # 2: 55\n",
      "Day # 3: 66\n",
      "Day # 4: 66\n",
      "Day # 5: 66\n",
      "Here are the values you entered: \n",
      "25\n",
      "55\n",
      "66\n",
      "66\n",
      "66\n"
     ]
    }
   ],
   "source": [
    "# The NUM-DAYS constant holds the number of \n",
    "# days that we will gather sales data for. \n",
    "NUM_DAYS = 5\n",
    "def main():\n",
    "    # Create a list to hold the sales\n",
    "    # for each day.\n",
    "    sales = [0] * NUM_DAYS\n",
    "    # Create a variable to hold an index.\n",
    "    index = 0\n",
    "    print 'Enter the sales for each day.'\n",
    "    # Get the sales for each day.\n",
    "    while index < NUM_DAYS:\n",
    "        sales[index] = input('Day # ' + str(index+1) + ': ')\n",
    "        index += 1\n",
    "    # Display the values entered.\n",
    "    print 'Here are the values you entered: '\n",
    "    for value in sales:\n",
    "        print value\n",
    "# Call the main function. \n",
    "main()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# List Methods"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# The append Method"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The append method is commonly used to add items to a list. The item that is passed as an \n",
    "argument is appended to the end of the list's existing elements."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " Enter a name: eee\n",
      "Do you want to add another name?\n",
      "Y = yes, anything else = no:y\n",
      "\n",
      " Enter a name: rr\n",
      "Do you want to add another name?\n",
      "Y = yes, anything else = no:n\n",
      "\n",
      "Here are the names you entered.\n",
      "eee\n",
      "rr\n"
     ]
    }
   ],
   "source": [
    "# This program demonstrates how the append \n",
    "# method can be used to add items to a list.\n",
    "def main ( ) :\n",
    "    # First, create an empty list.\n",
    "    name_list = [ ]\n",
    "    # Create a variable to control the loop.\n",
    "    again = 'Y'\n",
    "    # Add some names to the list. \n",
    "    while again.upper() == 'Y':\n",
    "        # Get a name from the user.\n",
    "        name = raw_input ( ' Enter a name: ' )\n",
    "        # Append the name to the list.\n",
    "        name_list.append(name)\n",
    "        # Add another one?\n",
    "        print 'Do you want to add another name?'\n",
    "        again = raw_input( 'Y = yes, anything else = no:')\n",
    "        print\n",
    "    # Display the names that were entered.\n",
    "    print 'Here are the names you entered.'\n",
    "    for name in name_list:\n",
    "        print name\n",
    "# Call the main function.\n",
    "main()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# The index Method"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You pass an argument to the index method and it returns the index of the first element in the list containing that item. If the item is not found in the list, the method raises a Value Error exception."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " Here are the items in the food list: \n",
      "['Pizza', 'Burgers', 'Chips']\n",
      "Which item should I change? Pizza\n",
      "Enter the new value: 100\n",
      "Here is the revised list:\n",
      "['100', 'Burgers', 'Chips']\n"
     ]
    }
   ],
   "source": [
    "# This program demonstrates how to get the \n",
    "# index of an item in a list and then replace \n",
    "# that item with a new item. \n",
    "def main():\n",
    "    # Create a list with some items.\n",
    "    food = ['Pizza', 'Burgers', 'Chips'] \n",
    "    # Display the list.\n",
    "    print ' Here are the items in the food list: '\n",
    "    print food\n",
    "    # Get the item to change.\n",
    "    item = raw_input('Which item should I change? ' )\n",
    "    try:\n",
    "        # Get the item's index in the list.\n",
    "        item_index = food.index(item)\n",
    "        # Get the value to replace it with.\n",
    "        new_item = raw_input( 'Enter the new value: ' )\n",
    "        # Replace the old item with the new item.\n",
    "        food[item_index] = new_item\n",
    "        # Display the list.\n",
    "        print 'Here is the revised list:'\n",
    "        print food\n",
    "    except ValueError:\n",
    "        print 'That item was not found in the list. '\n",
    "# Call the main function. \n",
    "main()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# The insert Method"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The list before the insert: \n",
      "['James', 'Kathryn', 'Bill']\n",
      "The list after the insert: \n",
      "['Joe', 'James', 'Kathryn', 'Bill']\n"
     ]
    }
   ],
   "source": [
    "# This program demonstrates the insert method.\n",
    "def main ( ) :\n",
    "    # Create a list with some names.\n",
    "    names = ['James', 'Kathryn', 'Bill'] \n",
    "    # Display the list.\n",
    "    print 'The list before the insert: '\n",
    "    print names\n",
    "    # Insert a new name at element 0.\n",
    "    names.insert(0, 'Joe') \n",
    "    # Display the list again.\n",
    "    print 'The list after the insert: '\n",
    "    print names \n",
    "# Call the main function. \n",
    "main ( )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# The sort Method"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The sort method rearranges the elements of a list so they appear in ascending order (from \n",
    "the lowest value to the highest value). Here is an example: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Original order: [9, 1, 0, 2, 8, 6, 7, 4, 5, 3]\n",
      "Sorted order: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]\n"
     ]
    }
   ],
   "source": [
    "my_list= [ 9 , 1, 0, 2, 8, 6, 7 , 4, 5, 3]\n",
    "print 'Original order:', my_list \n",
    "my_list.sort() \n",
    "print 'Sorted order:', my_list"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Here is another example: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Original order: ['beta', 'alpha', 'delta', 'gamma']\n",
      "Sorted order: ['alpha', 'beta', 'delta', 'gamma']\n"
     ]
    }
   ],
   "source": [
    "my_list = ['beta', 'alpha', 'delta', 'gamma'] \n",
    "print 'Original order:', my_list \n",
    "my_list.sort() \n",
    "print 'Sorted order:', my_list"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# The remove Method"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The remove method removes an item from the list. You pass an item to the method as an \n",
    "argument and the first element containing that item is removed. This reduces the size of the \n",
    "list by one element. All of the elements after the removed element are shifted one position \n",
    "toward the beginning of the list. A ValueError exception is raised if the item is not found \n",
    "in the list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 104,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Here are the items in the food list: \n",
      "['Pizza', 'Burgers', 'Chips']\n",
      "Which item should I remove? pizza\n",
      " That item was not found in the list. \n"
     ]
    }
   ],
   "source": [
    "# This program demonstrates how to use the remove \n",
    "# method to remove an item from a list.\n",
    "def main ( ) :\n",
    "    # Create a list with some items.\n",
    "    food = ['Pizza', 'Burgers', 'Chips']\n",
    "    # Display the list.\n",
    "    print 'Here are the items in the food list: ' \n",
    "    print food\n",
    "    # Get the item to change.\n",
    "    item = raw_input( 'Which item should I remove? ' )\n",
    "    try:\n",
    "        # Remove the item. \n",
    "        food.remove(item)\n",
    "        # Display the list. \n",
    "        print ' Here is the revised list: ' \n",
    "        print food \n",
    "    except ValueError:\n",
    "        print ' That item was not found in the list. '\n",
    "# Call the main function. \n",
    "main()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# The reverse Method"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The reverse method simply reverses the order of the items in the list. Here is an example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 105,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Original order: [1, 2, 3, 4, 5]\n",
      "Reversed: [5, 4, 3, 2, 1]\n"
     ]
    }
   ],
   "source": [
    "my_list = [ 1 , 2 , 3 , 4 , 5 ] \n",
    "print 'Original order:', my_list \n",
    "my_list.reverse() \n",
    "print 'Reversed:', my_list"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# The del Statement"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The remove method that you saw earlier removes a specific item from a list, if that item is \n",
    "in the list. Some situations might require that you remove an element from a specific index, \n",
    "regardless of the item that is stored at that index. This can be accomplished with the del \n",
    "statement. Here is an example of how to use the del statement:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 107,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Before deletion: [1, 2, 3, 4, 5]\n",
      "After deletion: [1, 2, 4, 5]\n"
     ]
    }
   ],
   "source": [
    "my_list = [ 1, 2 , 3 , 4 , 5 ]\n",
    "print 'Before deletion:', my_list \n",
    "del my_list[2] \n",
    "print 'After deletion:', my_list"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# The min and max Functions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python has two built-in functions named min and max that work with sequences. The min \n",
    "function accepts a sequence, such as a list or a string, as an argument and returns the item \n",
    "that has the lowest value in the sequence."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 113,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The lowest value is 2\n"
     ]
    }
   ],
   "source": [
    "my_list = [ 5 , 4 , 3 , 2 , 50 , 40 , 30]\n",
    "print 'The lowest value is', min(my_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The max function accepts a sequence, such as a list or a string, as an argument and returns \n",
    "the item that has the highest value in the sequence. Here is an example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 114,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The highest value is 50\n"
     ]
    }
   ],
   "source": [
    "my_list = [ 5 , 4 , 3 , 2 , 50 , 40 , 30]\n",
    "print 'The highest value is', max(my_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Concatenating Lists"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 116,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 4, 5, 6, 7, 8]\n"
     ]
    }
   ],
   "source": [
    "listl =[1, 2, 3, 4 ]\n",
    "list2 =[5,6,7,8]\n",
    "list3 =listl + list2\n",
    "print list3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Copying Lists"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Recall that in Python, assigning one variable to another variable simply makes both variables reference the same object in memory. For example, look at the following code:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 118,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create a list. \n",
    "list1 = [1, 2, 3, 4]\n",
    "# Assign the list to the list2 variable. \n",
    "list2 = list1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "After this code executes, both variables listl and list2 will reference the same list in \n",
    "memory.\n",
    "\n",
    "Suppose you wish to make a copy of the list, so that list1 and list2 reference two \n",
    "separate but identical lists. One way to do this is with a loop that copies each element of \n",
    "the list. Here is an example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 119,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Create a list with values. \n",
    "listl = [1, 2, 3, 4]\n",
    "# Create an empty list.\n",
    "list2 = [ ] \n",
    "# Copy the elements of listl to list2. \n",
    "for item in listl:\n",
    "    list2.append(item)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "After this code executes, list1 and list2 will reference two separate but identical lists. \n",
    "A simpler and more elegant way to accomplish the same task is to use the concatenation \n",
    "operator, as shown here:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 120,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Create a list with values. \n",
    "list1 = [1, 2, 3, 4]\n",
    "# Create a copy of listl. \n",
    "list2 = [ ] + list1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# To calling the values in a list"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Assuming a list contains numeric values, to calculate the total of those values you use a loop \n",
    "with an accumulator variable. The loop steps through the list, adding the value of each element \n",
    "to the accumulator."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 121,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The total of the elements is 30\n"
     ]
    }
   ],
   "source": [
    "# This program calculates the total of the values \n",
    "# in a list. \n",
    "def main ( ) :\n",
    "    # Create a list.\n",
    "    numbers = [2, 4, 6, 8, 10]\n",
    "    # Create a variable to use as an accumulator. \n",
    "    total = 0\n",
    "    # Calculate the total of the list elements.\n",
    "    for value in numbers:\n",
    "        total += value \n",
    "        # Display the total of the list elements.\n",
    "    print 'The total of the elements is', total \n",
    "# Call the main function. \n",
    "main ( )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Averaging the Values In a List"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The first step in calculating the average of the values in a list is to get the total of the \n",
    "values. You saw how to do that with a loop in the preceding section. The second step is\n",
    "to divide the total by the number of elements in the list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 123,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The average of the elements is 5.16833333333\n"
     ]
    }
   ],
   "source": [
    "# This program calculates the average of the values \n",
    "# in a list. \n",
    "def main ( ) :\n",
    "    # Create a list.\n",
    "    scores = [ 2, 5, 8.3, 6.5, 4.0, 5.21 ]\n",
    "    # Create a variable to use as an accumulator.\n",
    "    total = 0.0 \n",
    "    # Calculate the total of the list elements.\n",
    "    for value in scores:\n",
    "        total += value \n",
    "    # Calculate the average of the elements.\n",
    "    average = total / len(scores)\n",
    "    # Display the total of the list elements.\n",
    "    print 'The average of the elements is', average \n",
    "# Call the main function. \n",
    "main ( )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Passing a List as an Argument to a Fuaction"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can easily pass a list as an argument to a function. This gives you the ability to put \n",
    "many of the operations that you perform on a list in their own functions. When you need \n",
    "to call these functions, you can pass the list as an argument.\n",
    "The function in this program accepts a list as an argument and returns the total of the list's \n",
    "elements."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 125,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " The total is 30\n"
     ]
    }
   ],
   "source": [
    "# This program uses a function to calculate the \n",
    "# total of the values in a list. \n",
    "def main ( ) :\n",
    "    # Create a list.\n",
    "    numbers = [2, 4, 6 , 8, 10] \n",
    "    # Display the total of the list elements.\n",
    "    print 'The total is', get_total(numbers) \n",
    "    # The get-total function accepts a list as an \n",
    "    # argument returns the total of the values in \n",
    "    # the list. \n",
    "def get_total(value_list):\n",
    "    # Create a variable to use as an accumulator. \n",
    "    total = 0 \n",
    "    # Calculate the total of the list elements. \n",
    "    for num in value_list: \n",
    "        total += num \n",
    "    # Return the total \n",
    "    return total \n",
    "#Call the main function.\n",
    "main()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Returning a List From a Function"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A function can return a reference to a list. This gives you the ability to write a function that \n",
    "creates a list and adds elements to it, and then returns a reference to the list so other parts \n",
    "of the program can work with it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 128,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter a number: 5\n",
      "Do you want to add another number?\n",
      "Y = yes, anything else = no: y\n",
      "\n",
      "Enter a number: 6\n",
      "Do you want to add another number?\n",
      "Y = yes, anything else = no: n\n",
      "\n",
      "The numbers in the list are: \n",
      "[5, 6]\n"
     ]
    }
   ],
   "source": [
    "# This program uses a function to create a list. \n",
    "# The function returns a reference to the list.\n",
    "def main ( ) : \n",
    "    # Get a list with values stored in it. \n",
    "    numbers = get_values() \n",
    "    # Display the values in the list. \n",
    "    print 'The numbers in the list are: ' \n",
    "    print numbers \n",
    "    # The get-values function gets a series of numbers \n",
    "    # from the user and stores them in a list. The \n",
    "    # function returns a reference to the list. \n",
    "def get_values(): \n",
    "    # Create an empty list. \n",
    "    values = []\n",
    "    # Create a variable to control the loop. \n",
    "    again = 'Y' \n",
    "    # Get values from the user and add them to \n",
    "    # the list. \n",
    "    while again.upper() == 'Y':\n",
    "        # Get a number and add it to the list.\n",
    "        num = input('Enter a number: ')\n",
    "        values.append(num) \n",
    "        # Want to do this again? \n",
    "        print 'Do you want to add another number?' \n",
    "        again = raw_input( 'Y = yes, anything else = no: ' ) \n",
    "        print \n",
    "    # Return the list.\n",
    "    return values \n",
    "# Call the main function. \n",
    "main()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Working with Lists and Files"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 130,
   "metadata": {},
   "outputs": [],
   "source": [
    "# This program uses the writelines method to save \n",
    "# a list of strings to a file.\n",
    "def main( ) :\n",
    "    # Create a list of strings.\n",
    "    cities = ['New York', 'Boston', 'Atlanta', 'Dallas']\n",
    "    # Open a file for writing. \n",
    "    outfile = open('cities.txt', 'w' ) \n",
    "    # Write the list to the file. \n",
    "    outfile.writelines(cities)\n",
    "    # Close the file.\n",
    "    outfile.close()\n",
    "# Call the main function.\n",
    "main()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 131,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# This program saves a list of strings to a file. \n",
    "def main(): \n",
    "    # Create a list of strings.\n",
    "    cities = ['New York', 'Boston', 'Atlanta', 'Dallas'] \n",
    "    # Open a file for writing. \n",
    "    outfile=open('cities.txt', 'w') \n",
    "    # Write the list to the file. \n",
    "    for item in cities: \n",
    "        outfile.write(item + '\\n')\n",
    "    # Close the file.\n",
    "    outfile.close()\n",
    "# Call the main function.\n",
    "main()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 132,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['New York', 'Boston', 'Atlanta', 'Dallas']\n"
     ]
    }
   ],
   "source": [
    "# This program reads a file's contents into a list. \n",
    "def main( ) :\n",
    "    # Open a file for reading.\n",
    "    infile = open('cities.txt', 'r' )\n",
    "    # Read the contents of the file into a list. \n",
    "    cities = infile.readlines() \n",
    "    # Close the file. \n",
    "    infile.close() \n",
    "    # Strip the \\n from each element. \n",
    "    index = 0 \n",
    "    while index < len(cities) : \n",
    "        cities[index] = cities[index].rstrip('\\n') \n",
    "        index += 1 \n",
    "    # Print the contents of the list. \n",
    "    print cities \n",
    "# Call the main function. \n",
    "main()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 134,
   "metadata": {},
   "outputs": [],
   "source": [
    "# This program saves a list of numbers to a file. \n",
    "def main( ) : \n",
    "    # Create a list of numbers. \n",
    "    numbers = [ 1 , 2, 3 , 4, 5 , 6 , 7]\n",
    "    # Open a file for writing. \n",
    "    outfile = open('numberlist.txt', 'w')\n",
    "    # write the list to the file. \n",
    "    for item in numbers: \n",
    "        outfile.write(str(item) + '\\n') \n",
    "    # Close the file. \n",
    "    outfile.close() \n",
    "# Call the main function. \n",
    "main()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 135,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 4, 5, 6, 7]\n"
     ]
    }
   ],
   "source": [
    "# This program reads numbers from a file into a list. \n",
    "def main ( ) : \n",
    "    # Open a file for reading. \n",
    "    infile = open('numberlist.txt', 'r') \n",
    "    # Read the contents of the file into a list. \n",
    "    numbers = infile.readlines() \n",
    "    # Close the file. \n",
    "    infile.close()\n",
    "    # Convert each element to an int. \n",
    "    index = 0 \n",
    "    while index < len(numbers ) : \n",
    "        numbers[index] = int(numbers[index]) \n",
    "        index += 1 \n",
    "    # Print the contents of the list. \n",
    "    print numbers \n",
    "# Call the main function.\n",
    "main()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Splitting a String"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 136,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['One', 'two', 'three', 'four']\n"
     ]
    }
   ],
   "source": [
    "# This program demonstrates the split method. \n",
    "def main(): \n",
    "    # Create a string with multiple words. \n",
    "    my_string = 'One two three four'\n",
    "    # Split the string. \n",
    "    word_list = my_string.split() \n",
    "    # Print the list of words. \n",
    "    print word_list \n",
    "# Call the main function. \n",
    "main()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 139,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " Month: 11\n",
      "Day: 26\n",
      "Year: 2008\n"
     ]
    }
   ],
   "source": [
    "# This program calls the split method, using the \n",
    "# '/' character as a separator. \n",
    "def main(): \n",
    "    # Create a string with a date. \n",
    "    date_string = '11/26/2008' \n",
    "    # Split the date. \n",
    "    date_list = date_string.split('/') \n",
    "    # Display each piece of the date. \n",
    "    print 'Month:', date_list[0] \n",
    "    print 'Day:', date_list[1] \n",
    "    print 'Year:', date_list[2]\n",
    "main()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 2",
   "language": "python",
   "name": "python2"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}