Classifying Character Methods

Understanding Check!

def revq(word):
    out = ""
    for char in word:
        if (char.isalnum() and 
            char.islower() ):
            out += " " + char
        elif char.isdigit():
            out += str(int(char)+1)
        elif not char.isalnum():
            out = out.replace("e", "r2")
    return out.strip()

Methods to find string patterns

The english.py Library

• To facilitate working with English words, we can take advantage of the pre-written english module
  • This will be highly useful in the Wordle project!
• The english module exports two resources:
  • ENGLISH_WORDS: a constant sequence which contains all the valid English words in alphabetical order
  • is_english_word(): a predicate function which takes a string as input and returns True or False depending on if that string is a valid English word

Biggest No-vowel Word

• Suppose we wanted to determine the longest word in the English language without vowels:

  from english import ENGLISH_WORDS
  
  def contains_vowels(word):
      for letter in word:
          if letter in "aeiou":
              return True
      return False
  
  def find_longest_no_vowels():
      best_length = 0
      for word in ENGLISH_WORDS:
          if ( not contains_vowels(word) and 
               len(word) > best_length ):
              best_length = len(word)
              print(word)
  
  
  if __name__ == '__main__':
      find_longest_no_vowels()

Igpay Atinlay

• Suppose we wanted to write a script that converted English to Pig Latin
• Rules of Pig Latin:
  • If the word begins with a consonant, move everything up to the first vowel to the end and append on “ay” at the end fleet ⟶ eetflay
  • If the word starts with a vowel, just append “way” to the end orange ⟶ orangeway
  • If the word has no vowels, do nothing
• Our decomposition:
  • Find first vowel location
  • Convert a single word

Indingfay Owelsvay

def find_first_vowel_index(word):
    """
    Find the first vowel in a word and return its index,
    or return None if no vowels found.
    """
    for i in range(len(word)):
        index = "aeiou".find(word[i].lower())
        if index != -1:
            return i
    return None

Onvertcay Oneway Ordway

def word_2_pig_latin(word):
    """
    Convert a single word with no special characters from
    English to Pig Latin.
    """
    vowel = find_first_vowel_index(word)
    if vowel is None:
        return word
    elif vowel == 0:
        return word + "way"
    else:
        return word[vowel:] + word[:vowel] + "ay"

When Pig Latin = English?

• What about when the Pig Latin version of a word is a different, but valid, English word?

def pig_latin_equals_english():
    count = 0
    for word in ENGLISH_WORDS:
        piglatin = word_2_pig_latin(word)
        if is_english_word(piglatin) and word != piglatin:
            print(word, ":", piglatin)
            count += 1
    return count

Introduction to Wordle

• Our first project is recreating Wordle
• Milestone guide was posted over the weekend
• Due next Monday (Sept 29)
• Section questions will relate to common Wordle issues this week
• Aiming to be done with Milestone 3 by end-of-day Friday would be a good target

Your Responsibilities

• We provide you with a custom data type that handles all the graphics and user interaction
  • Don’t worry, you’ll have a chance to implement your own GUIs later in the semester!
• Your responsibilities will include:
  • Displaying and reading letters from boxes
  • Evaluating whether a word is valid
  • Determining what color each letter of a word should be
  • Selecting a secret five letter word for guessing
  • Determining when victory or defeat occurs
  • Coloring the keys according to the guesses so far

Your Toolbox

• Special functions provided by the provided graphics data type: WordleGWindow
  • These are documented in the guide, and include, but are not limited to, things like
    • Getting or setting a letter in a particular box
    • Getting or changing the color of a given box
    • Changing which row is used when characters are typed in
• Variables and functions
• Control statements
  • Good use of loops and if statements will be very useful
• Basic string functions

An Approach to Success

• Each project is accompanied by a highly detailed guide: read it!
  • Explains background ideas so that you can understand the big picture of what you are needing to do
  • Also included a breakdown of individual milestones
    • A milestone is a discrete checkpoint that you should ensure is working (and that you understand!) before moving on
    • Whenever you complete a milestone, you should upload your current code to GitHub.
• Projects are all about managing complexity. If you start trying to implement milestones out of order, you are asking for disaster
• Don’t let yourself get overwhelmed by scale. Focus on one particular milestone at a time, which should involve focusing only on a small part of your overall code

Getting some input

• We’ve seen how to display information to a user, but to retrieve data from a user, we can use Python’s built-in input() function

• The form will generally look like:

  |||variable||| = input(|||prompt_text|||)

  • |||variable||| is the variable name you want to assign the user’s typed input to
  • |||prompt_text||| is the string that will be displayed on the screen to communicate to the user what they should be doing

• The input() function always returns a string

  • If you want to get an integer from the user, you will need to convert it yourself after retrieving it

    num = int(input('Pick a number between 1 and 10: '))

F not G

• Constructing text or sentences by interleaving strings and other objects comes up a lot in communicating code results to a user

• For any Python version past 3.6, the nicest and easiest way to do this is with what are called f-strings:

  A = 10
  print(f"The value of A is: {A}!")

• You can define an f-string anytime you would normally define a string, just be aware that the substitution happens with the values of variable at that point

  A = 10
  s = f"The value of A is {A}"
  A = 12
  print(s)

Formatting Strings

• F-strings allow up to easily substitute in values, but what if we want those values to have a particular format?
  • Rounded to the nearest two decimal places, for example
• One option would be to handle all this before the substitution manually
• Python gives a more streamlined method, using a format spec
• A format spec will be given inside the {} placeholder
  • Comes after the variable/value itself
  • There is a colon between the variable/value and the format spec

  A = 10.234
  print(f"The value of A is {A:0.2f}")

Shaping your format

• A format spec is a special string that determines the desired format
• Lots we can do, but we rarely need to do it all at once
• The basic building blocks (square brackets just to group):
  [[fill]align]>[sign][width][,][.precision][type]

Output Conversion Types

• Uppercase conversion types use capital characters where possible in output