Chapter 8 Strings

• Strings Revisited
  • the data we've worked with so far are "primitive" data types
  • built into the language, not made of smaller parts
  • Objects are not like this (instances of classes) like files or graphics objects
• A Collection Data Type
  • strings and lists are "collections" of data
  • have component parts
  • can refer to a string as a whole thing, or as individual characters
  • strings and lists both have order, their elements have first one, second one, ..., last one
  • there is an empty string, just quotes next to each other
• Operations on Strings
  • concatenation - the "plus" sign
    • sticks strings together end to end
    • NOT commutative! "a" + "b" is not the same as "b" + "a"
    • does not add spaces between strings
    • both things must be strings - not integers or floats
    • what is the difference between print("a"+"b") and print(a,b)
  • repetition - the "times" sign (asterisk)
    one of the two operands must be an integer - can be first or last
  • precedence is same as when arithmetic, * before +
• Index Operator: Working with the Characters of a String
  • characters can be referred to by their position (called an index or a subscript)
  • see textbook for numbering scheme
    • from left to right, starts at 0
    • from right to left, starts at -1
  • syntax - uses [] square brackets to refer to a character
  • name[3] is the fourth character in the string
  • be very careful NOT to go past the end of the string! "string index out of range"
  • some languages just give you garbage when you do that
  • can use expressions as subscripts "name[i]" "name[j+2]"
  • indexing has higher precedence than most operators (see table in chapter 6 notes)
• String Methods
  • strings are objects
  • use the "dot notation" for calling functions on strings
  • these methods do NOT change the original string, they create a new string with the appropriate value
  • upper(), lower() - no arguments
  • strip - removes leading and trailing whitespace
  • replace
  • find
  • index
  • count
  • see notes below about "strings are immutable"
• Length
  • len is a function (Not a method!) which returns an integer
  • it tells how many characters are in the string
  • example:

    	s = "abcde"
    	print(len(s))  # note does not use dot notation
    	print(s[len(s)])   # error!
    	print(s[-1])  # gives the last character
    	print(s[len(s)-1])  # also gives the last character
    	print(s[len(s)]-1)  # error - [] is higher priority
    

• The Slice Operator
  • most languages need a way to get a piece of a string
  • often called "substring", Python calls it a "slice"
  • need to specify which piece - usually with start and stop positions (C++ uses "start" and "how many")
  • use two numbers inside the [], with a colon between
  • syntax "s[a:b]" a is starting position, b is ONE PAST the end position
  • if leave off first number "s[:b]" then start at left end (pos. 0)
  • if leave off second number "s[a:]" then goes to end of string
  • if leave off BOTH numbers "s[:]"
    • why would you do that? sometimes need to make a copy of a whole string
    • [:] will give entire string
• String Comparison
  • (textbook does not mention ASCII =American Standard Code for Information Interchange)
  • ord("Character") gives the ASCII code of a character - you can't give more than one character as argument
  • chr(number) gives a character as a string of length one
  • in textbook just after ActiveCode:16, space IS a character, that is correct (ASCII code 32) - it is a printable character, not a NON-printing character as book says
  • whitespace
    • most languages have some definition of whitespace
    • always includes the space character
    • usually includes the tab and newline
    • usually has other odd characters
    • useful for delimiters (separators for items)
• Strings are Immutable
  • several data structures in Python are immutable
  • literally means "unchangeable"
  • strings are like that (lists, next chapter, are not)
  • if s = "abc", you cannot say s[2] = "d"
  • instead, usually make a new copy of the string using slice or some of the other methods from above, making changes as it is constructed
  • t = s[0:2]+"d" would give t as "abd"
  • be careful when reading docs pages - some tables only apply to mutable types!
• Traversal and the for Loop: By Item
  • can use for loop and "in" to process each character in the string
  • syntax: for i in "string constant":
  • syntax: for i in stringvariable:
  • i becomes each character in the string, starting from the left
  • if string is empty, loop does not execute
  • every character matters - spaces or anything else counts!
• Traversal and the for Loop: By Index
  • NOTE difference in these two pieces of code!

    	st = "Kentucky"
    	for i in st:
    		print(i)
    
    	for i in range(len(st)):
    		print(st[i])
    

  • the two loops seem to do the exact same thing, and they do
  • BUT in the first loop, i is a string (length 1)
  • in the second loop, i is an integer
  • if you needed to know something about the location of a character in the string, you need to use the second option
  • example: printing a string out backwards
• Traversal and the while Loop
  • you might use a while loop to access a string
  • can do counter-controlled loop but for loop is better for that if you are going to access ALL characters in the string
  • if you want to leave the loop early, i.e. before all characters are processed, then a while is your friend!
  • example: (find first vowel in string)

    	i = 0
    	found = False
    	st = "WORD"
    	while i < len(st) and not found:
    	      if st[i] == "A" or st[i] == "E" or st[i] == "I"
    			or st[i] == "O" or st[i] == "U":
    			found = True
    	      i +=1
    

  • this loop stops as soon as it finds any of the vowels
  • if i == len(st) after the loop is over, the vowel was not found
  • otherwise i is the location of the left-most vowel
• The in and not in operators
  • in operator (same one as used in for loops!)
  • reports True or False with strings
  • does NOT report the location (see "find" method for that)
  • if ch in st: where ch is one string, st is another
  • empty string is a substring of every string
  • every string is a substring of itself
  • if you want to negate the result you can write it as

    	if not (ch in st):
    

    but you can also use

    	if ch not in st:
    

• The Accumulator Pattern with Strings
  • using strings and concatenation inside loops
  • very powerful technique to build up strings one piece at a time
  • example - make a string that is a collection of the words entered by the user

    	print("Enter 5 words.  Press enter between each one.")
    	sentence = ""
    	for i in range(5):
    		wd = input("Enter a word")
    		sentence = sentence + wd
    	print("the complete sentence is", sentence)
    

  • how would you get the words in reverse order?
  • side note: this is actually creating a new string with each loop iteration. the old version of the string is destroyed (deallocated). Python does a lot of this "garbage collection" while working with collections.
• Looping and counting
• A find function
  • this uses the concept of a flag see chapter 6 notes
  • found is a flag
• Optional parameters
  • if you want to write some functions which do similar but not identical tasks
  • can write each one separately obviously but seems a waste of time
  • example: want a function that will raise one number to the second power (yes, this is the same job that the ** operator does)

  •        def pow (base):
               return base * base 
    

  • would also like a function that would raise a number to an arbitrary power, not just 2

  •       def pow(base, ex):
                res = 1
                for i in range(ex):
                    res = res * base
                return res
        

  • but it's not as easy to raise to the second power, would have to call it with pow(base, 2)
  • would be nice to have a "default" value for a parameter, so if it is not given, will have a value!
  • syntax:

              def fun (parm1, parm2, parm3=value, parm4=value, ...):
    

  • semantics: the parameters parm3 and parm4 have default values.
    • If they are not included in the call to the function they will have the values given in the header
    • if they ARE included in the call, they will have whatever values are given in the call
    • "optional parameters" must be at the end of the list of parameters
    • in the call to this function, if parm3 is left out of the call, parm4 would have to be too
  • for example above you could do

          def pow(base, ex=2):
                res = 1
                for i in range(ex):
                    res = res * base
                return res
          
    

  • so that if you called it with pow(x) you would get x squared,
  • if you called it with pow(x, 5) you would get x to the 5th power
• Character classification
  • string library has some predefined constant strings
    • ascii_uppercase
    • ascii_lowercase
    • digits
    • punctuation
    • whitespace
    • example:

      from string import *
      
      def main():
          s = "abc123%^&"
          print(s in ascii_lowercase)
          print(s[2] in ascii_lowercase)
          print(s in digits)
          print(s[3] in digits)
          print(s in punctuation)
          print(s[6] in punctuation)
          
      main()