Lecture 5: Python 3
===================

Before this class you should:

.. include:: prep05.txt

Before next class you should:

.. include:: prep06.txt

Note taker: Evan Rutten

Strings
-------

A String is a Sequence
~~~~~~~~~~~~~~~~~~~~~~

A string is a sequence of characters that can be accessed one at a time with the bracket operator::

    fruit = 'banana'
    letter = fruit[1]  # Gets 'a'

The index indicates which character in the sequence you want:

* Indexing starts at 0 (first character)
* The index must be an integer
* You can use expressions containing variables and operators as indices
* Negative indices count backward from the end of the string

Length
~~~~~~

The :func:`len()` function returns the number of characters in a string::

    fruit = 'banana'
    length = len(fruit)  # Returns 6

String Traversal
~~~~~~~~~~~~~~~~

You can process a string one character at a time using either a :keyword:`while` loop or a :keyword:`for` loop.

Using :keyword:`while`::

    index = 0
    while index < len(fruit):
        letter = fruit[index]
        print(letter)
        index = index + 1

Using :keyword:`for` (preferred)::

    for letter in fruit:
        print(letter)

String Slices
~~~~~~~~~~~~~

A segment of a string is called a slice. Selecting a slice is similar to selecting a character::

    s = 'Monty Python'
    first = s[0:5]    # Gets 'Monty'
    second = s[6:12]  # Gets 'Python'

Slice features:

* ``[n:m]`` returns part of string from "n-eth" to "m-eth" character
* Includes first position, excludes last position
* Omitting first index starts from beginning
* Omitting second index goes to end
* ``fruit[:]`` creates a copy of the entire string

Additional examples with omitted indices::

    s = "Hello, World!"
    print(s[:5])   # "Hello" (start omitted, defaults to 0)
    print(s[7:])   # "World!" (end omitted, goes to end)
    print(s[:])    # "Hello, World!" (copy of entire string)

Strings are Immutable
~~~~~~~~~~~~~~~~~~~~~

You cannot change an existing string. The best you can do is create a new string that is a variation on the original::

    greeting = 'Hello, world!'
    # This will raise an error:
    # greeting[0] = 'J'
    
    # Instead, create a new string:
    new_greeting = 'J' + greeting[1:]

String Methods
~~~~~~~~~~~~~~

Strings provide various built-in methods::

    word = 'banana'
    new_word = word.upper()  # Convert to uppercase
    
    # find method
    index = word.find('na')      # Find substring
    index = word.find('na', 3)   # Find substring starting at index 3
    index = word.find('na', 3, 5)  # Find substring between indices 3 and 5

String replacement (useful since strings are immutable)::

    greeting = "Hello, world!"
    new_greeting = greeting.replace("Hello", "Hi")  # Creates new string "Hi, world!"

The ``in`` Operator
~~~~~~~~~~~~~~~~~~~

The ``in`` operator is a boolean operator that returns True if first string appears as substring in second::

    'a' in 'banana'     # Returns True
    'seed' in 'banana'  # Returns False

String Comparison
~~~~~~~~~~~~~~~~~

Relational operators work on strings::

    word = 'Pineapple'
    if word < 'banana':
        print('Your word comes before banana.')
    elif word > 'banana':
        print('Your word comes after banana.')

Note: Python handles uppercase and lowercase letters differently: all uppercase letters come before lowercase letters.

Lists
-----

Lists as Sequences
~~~~~~~~~~~~~~~~~~

A list is a sequence of values of any type::

    numbers = [10, 20, 30, 40]
    strings = ['crunchy frog', 'ram bladder', 'lark vomit']
    mixed = ['spam', 2.0, 5, [10, 20]]  # Nested list
    empty = []

Using list comprehensions for more concise list traversal::

    # Instead of:
    squares = []
    for x in range(10):
        squares.append(x**2)

    # Use list comprehension:
    squares = [x**2 for x in range(10)]

Lists are Mutable
~~~~~~~~~~~~~~~~~

Unlike strings, lists are mutable. You can change elements using the bracket operator::

    numbers = [42, 123]
    numbers[1] = 5  # List is now [42, 5]

List indices work the same way as string indices:

* Any integer expression can be an index
* Out of range indices raise IndexError
* Negative indices count from the end

List Traversal
~~~~~~~~~~~~~~

Common ways to traverse lists::

    # Method 1: Process elements
    for cheese in cheeses:
        print(cheese)
        
    # Method 2: Process indices
    for i in range(len(numbers)):
        numbers[i] = numbers[i] * 2

List Operations
~~~~~~~~~~~~~~~

Lists support concatenation and repetition::

    a = [1, 2, 3]
    b = [4, 5, 6]
    c = a + b          # Concatenation
    d = [0] * 4       # Repetition
    e = [1, 2, 3] * 3  # More repetition

List Slices
~~~~~~~~~~~

The slice operator works on lists similar to strings::

    t = ['a', 'b', 'c', 'd', 'e', 'f']
    t[1:3]  # Gets ['b', 'c']
    t[:4]   # Gets ['a', 'b', 'c', 'd']
    t[:]    # Creates a copy of the whole list

You can also update multiple elements using slices::

    t[1:3] = ['x', 'y']

List Methods
~~~~~~~~~~~~

Common list methods::

    t = ['a', 'b', 'c']
    t.append('d')        # Add single element
    t.extend(['e', 'f']) # Add multiple elements
    t.sort()            # Sort in place
    
    # Removing elements
    x = t.pop(1)        # Remove and return element at index
    t.remove('b')       # Remove specific value
    del t[1]            # Delete element at index
    del t[1:5]          # Delete slice

Map, Filter, and Reduce
~~~~~~~~~~~~~~~~~~~~~~~

Common list operations patterns::

    # Reduce - combine elements
    def add_all(t):
        total = 0
        for x in t:
            total += x
        return total
    
    # Map - transform elements
    def capitalize_all(t):
        res = []
        for s in t:
            res.append(s.capitalize())
        return res
    
    # Filter - select elements
    def only_upper(t):
        res = []
        for s in t:
            if s.isupper():
                res.append(s)
        return res

Lists and Strings
~~~~~~~~~~~~~~~~~

Converting between strings and lists::

    # String to list of characters
    s = 'spam'
    t = list(s)
    
    # String to list of words
    s = 'pining for the fjords'
    t = s.split()
    
    # List to string
    t = ['pining', 'for', 'the', 'fjords']
    s = ' '.join(t)

Objects and Values
~~~~~~~~~~~~~~~~~~

Two variables can refer to the same object (aliasing) or different objects with the same value::

    a = [1, 2, 3]
    b = [1, 2, 3]  # Different object, same value
    c = a          # Same object (alias)
    
    # Test identity
    a is b  # False
    a is c  # True

List Arguments
~~~~~~~~~~~~~~

When you pass a list to a function, the function gets a reference to the list::

    def delete_head(t):
        del t[0]    # Modifies original list
    
    def tail(t):
        return t[1:]  # Returns new list

Dictionaries
------------

Dictionaries as Mappings
~~~~~~~~~~~~~~~~~~~~~~~~

A dictionary maps keys to values::

    eng2sp = dict()              # Empty dictionary
    eng2sp['one'] = 'uno'        # Add key-value pair
    eng2sp = {'one': 'uno', 'two': 'dos', 'three': 'tres'}  # Create with items

Dictionary features:

* Keys must be hashable (immutable)
* Values can be any type
* Each key maps to exactly one value
* Order is preserved (Python 3.7+)

Performance considerations:

* **List searches:** :math:`O(n)` (linear search required)
* **Dictionary lookups:** :math:`O(1)` (hash-based retrieval)

Nested dictionaries are useful for complex data structures::

    students = {
        "Alice": {"age": 21, "major": "CS"},
        "Bob": {"age": 22, "major": "Math"}
    }
    print(students["Alice"]["major"])  # Output: "CS"

Dictionary Operations
~~~~~~~~~~~~~~~~~~~~~

Common operations::

    # Length
    len(eng2sp)
    
    # Membership testing (keys only)
    'one' in eng2sp
    
    # Access values
    eng2sp['two']           # Direct access
    eng2sp.get('four', 0)   # Access with default

Counters
~~~~~~~~

Dictionaries are useful for counting::

    def histogram(s):
        d = dict()
        for c in s:
            if c not in d:
                d[c] = 1
            else:
                d[c] += 1
        return d

Dictionary Traversal
~~~~~~~~~~~~~~~~~~~~

Ways to process dictionaries::

    # Traverse keys
    for c in h:
        print(c, h[c])
    
    # Traverse in sorted order
    for key in sorted(h):
        print(key, h[key])

Reverse Lookup
~~~~~~~~~~~~~~

Finding a key based on a value::

    def reverse_lookup(d, v):
        for k in d:
            if d[k] == v:
                return k
        raise LookupError('value not found')

Dictionaries and Lists
~~~~~~~~~~~~~~~~~~~~~~

Lists can be dictionary values but not keys::

    def invert_dict(d):
        inverse = dict()
        for key in d:
            val = d[key]
            if val not in inverse:
                inverse[val] = [key]
            else:
                inverse[val].append(key)
        return inverse

Best Practices
--------------

1. Choose appropriate data structures:

* Strings for text data
* Lists for ordered sequences
* Dictionaries for key-value mappings

2. Remember mutability:
   
* Strings are immutable
* Lists are mutable
* Dictionary values are mutable, keys must be immutable

3. Consider performance:
   
* Dictionary lookups are fast
* List searches are linear time
* String operations create new strings

4. Use built-in methods when available:
   
* String methods for text processing
* List methods for sequence operations
* Dictionary methods for mapping operations