Home | Schedule & Readings | Links & Resources

Radical Software

LCST 2234, Fall 2021 (CRN 9430)
Rory Solomon

Project 1, Tutorial 2: Expanding bot functionality with Python lists and random()

Today we're going to talk about how you can expand your Twitter bot functionality so that instead of simply posting one fixed phrase, your code will choose between several options. We'll talk about four techniques for achieving this.

When computer programs include fixed, unchanging values that are specified explicitly by the programmer, we say that those values are hard-coded. The alternative is that your program is dynamic or flexible. So today we're going to see how to go from a Twitter bot with one hard-coded message, to a bot that somehow dynamically generates a message.

But first, a review and clarification of some concepts from last week's tutorial ...

Review and clarifications

OK, let's move on to the technical tutorial for today ...

Expanding bot functionality: Python lists and random()

In this tutorial I am going to talk about four possible options for expanding the functionality of your Twitter bot, somewhat inspired by Christopher Strachey's "Love Letter Generator".

Remember, all the blue background text is Python code, and should be entered into main.py using Atom or your text editor.

  1. Import the Python commands for making random choices

    To have your Twitter bot dynamically generate variation in its output, we are going to use functionality that Python offers us to generate randomness. This can be used to pick random numbers, but in our case we're going to ask Python to make a random choice from a list of possible values. To use any of these Python features, we have to import them into our program.

    After line 3 (which adds your authorization_tokens) press enter twice to make a new line, and type the following: 

    import random

    This will give us access to all of Python's randomness-generating features.

  2. Create a new variable for your message.

    After the above line, press enter two more times to make some space and type the following: 

    message = ""

    This is making a new variable (like a placeholder) to hold the message that you will be tweeting later. The name I used here is arbitrary. I could have called it rory or spaghetti. I chose this name because it is informative: the name tells me what the variable will be used for, i.e., holding a message.

    Now you can use this message by modifying your update_status command (probably line 14) like so: 

    api.update_status(message)

    For the rest of this tutorial, in between lines 7 and 14, I'm going to show you some techniques for setting the message variable to different values, which will then get tweeted by the update_status command.

  3. Option 1: Selecting a message from a list

    Python is very good at working with lists of things. In Python, a list can contain any valid data value: numbers, letters, words, etc.

    We are going to make a list of phrases, and then ask Python to choose one randomly.

    To create a list you use square bracket notation: [ ]. After line 7, make an empty line and type the following: 

    # Option 1: Select a message randomly from a list of messages
phrase_list = []

    The first line there is just a comment. It is ignored by Python and is just a note-to-self. The second line creates an empty list. Again, the name that I used here is arbitrary and I could have called it rory or spaghetti, but the name I chose is informative about the value it will hold.

    Let's add some text phrases to our list. Each phrase should be in double quotes ("), and should be separated by commas. You are allowed to have line breaks in your list, which can aid with clarity and readability. Like so: 

    phrase_list = [ "Hi my name is Gritty.",
                "I am a monster.",
                "I am orange and furry." ]

    You can use whatever text you want obviously. When I add new code to an example, it will always be in blue with a thick dotted underline to help you recognize the change.

    Now that we have a list, let's ask Python to choose a random item from it. To do that, you use a command called random.choice(). You can read more about it here in the Python documentation. (Give a person a fish, teach a person to fish ...)

    After your list creation code, add the following line: 

    message = random.choice(phrase_list)

    And that's it for option 1! Make sure to save your main.py, return to the command line, and try to run it with: 

    $ python app/main.py
Done.

    (Or possibly python3 on your system.)

    If you just see output that states "Done." then your code worked! Check our class twitter bot at twitter.com/bot_ror and look for your message.

    Try to run your code several more times. Do you get an error message that says "Status is a duplicate"? If so that is OK. Twitter tries to prevent spamming by not allowing bots to repost the same message multiple times. You only have three messages to choose from here, so after a few runs, Python will make the same choice again, and you'll get his error message. Try adding more messages to phrase_list and it should decrease the likelihood that this could happen.

    Challenge: Can you add a random number to your message somewhere to give a much higher chance that the message will not be a duplication?

  4. Option 2: A simple Mad Lib

    Next, let's use those same techniques to create a simple Mad Lib.

    In addition to being good with lists, Python is also very good at working with strings. In coding, a string is the technical term for a bit of text (like a bunch of charactes strung together). For this option, we're going to use some Python functionality around string formatting and string templates.

    First, comment out all the code for option 1. You can do this by putting a hashtag symbol at the start of each line. Or, in Atom, you can highlight the text and from the menu select Edit > Toggle Comments, or type the keyboard shortcut (on Mac that's ⌘-\).

    Next, make some new lines after that, and add the following: 

    # Option 2: A simple Mad Lib

    Next we're going to create the text of the Mad Lib itself. In Python, instead of using blank lines, like you'd see in a paper Mad Lib, you use curly braces { }. Curly braces must always com in pairs and symbolize a placeholder in a string. Add a new line and type the following: 

    string_template = "Some people like {} but I like {}."

    As before, string_template is a variable name and I could have used anything I wish.

    Next, let's make a list of words that can be used to fill in the blanks: 

    word_list = [ "sports", "skorts", "meatloaf", "monsters", "hockey", "badminton" ]

    Now let's ask Python to randomly choose two words from this list: 

    word1 = random.choice(word_list)
word2 = random.choice(word_list)

    And finally, let's use Python's string formatting feature to "fill in the blanks" with those two words: 

    message = string_template.format(word1,word2)

    And that's it for this technique! Try to run your code again and see what happens. Try to run it a few times and see if you get the duplication error again. Check for your messages on the class twitter bot: twitter.com/bot_ror.

    Challenge: Sometimes this can produce awkward sentences where the same word is used twice. Can you modify this code so that it never choose the same word twice? You could use if but that wouldn't work if Python chooses the same word three times in a row. So you could use while. You could also use the remove() command (docs here).

  5. Option 3: Select from a list of possible Mad Libs

    This next technique merges the above two in a way. We're going to use the same principles from Option 2, but instead of just one template, we'll make a list of templates and let Python choose one randomly.

    Think about how Mad Libs work here. Your word list will be the same regardless of which template is selected, so make sure the parts of speech are consistent.

    First things first, comment out all of Option 2, and add some new lines beneath where you can add new code, and add a comment for this new option: 

    # Option 3: A list of possible Mad Libs

    Next we're going to proceed similar to before, but instead of one template, let's make a list of them: 

    template_list = [ "My name is {} and I like {}.",
                  "People say I look like {} but only when I'm {}.",
                  "I think {} is the best at {}." ]

    Again, the variable name template_list is arbitrary and you can call it whatever you'd like.

    Next, as before, let's make words to fill in the blanks. In this case, let's make two lists: one for the first blank in each sentence, and one for the second: 

    word_list1 = [ "Gritty", "Rory", "Nicolas Cage" ]
word_list2 = [ "playing hockey", "coding", "acting" ]

    Now let's choose a template from our list: 

    template = random.choice(template_list)

    Then choose a random word from each list: 

    word1 = random.choice(word_list1)
word2 = random.choice(word_list2)

    And finally, let's substitute those words in to the template: 

    message = template.format(word1,word2)

    And that's it. Try to run your bot, and check for your messages on the class twitter bot: twitter.com/bot_ror.

  6. Option 4: Using logic to make more intentional choices

    With the fourth and final option, we're going to look at how to actually use Python code to make some more careful and intentional choices based on the initial random choices that Python makes.

    We'll do this using a programming language construct called an if statement. This let's you ask questions and make choices based on the values of variables in your code.

    Start by comment out Option 3 and adding a new comment for this option: 

    # Option 4: Using IF statements

    Let's start with the basic structure of Option 2: one Mad Lib. Create a template with two blanks: 

    string_template = "Hi there, I'm {}, master of {}."

    Now, similar to Option 3, let's create word lists that could apply to each blank. But unlike Option 3, let's create two separate lists that would make sense in the second blank, one that would make sense if paired with the first word, and another that would make sense if paired with the second word: 

    word_list1 = [ "Gritty", "Nicolas Cage" ]	  

word_list2_a = [ "monsters", "playing hockey", "scaring people" ]
word_list2_b = [ "movies", "acting", "saying 'woah'" ]

    As before, let's ask Python to choose a random word from the first list: 

    word1 = random.choice(word_list1)

    But now, based on this choice, we'll determine which list to use for the second blank by using an if statement, like this: 

    if word1 == "Gritty":
    word2 = random.choice(word_list2_a)
elif word1 == "Nicolas Cage":
    word2 = random.choice(word_list2_b)

    Some important things to note:

    • In this case, spaces matter. Most of the time in Python, spaces are ignored (you can add spaces wherever you want if it helps with readability) but at the start of a line, spaces are called indentation and they have special meaning. Indentation is used to specify the structure of your program. In this case, the indentation signifies that the indented lines are "inside" the various cases indicated by the if statement. You can use as many spaces for indentation as you wish, but you must be consistent. I will always use 4 spaces and suggest you do the same!

    • Here, the indented lines will only be run if the condition is met.

    • Note the two equal signs: ==. This is how you ask a question about sameness or equivalence in Python and in most programming languages. == is like asking: "are these two things the same?" In this case: "Does my word1 variable hold the value 'Gritty'?"

    • Note also the colon: : That is how you tell Python that an indented block of code is coming.

    • You can put as many lines as you like in an indented block, i.e. inside each if condition. You could do more things here if you want to make this example more complicated.

    • elif is short for "else if", and its semantic meaning in code is like "if not." Together, these two conditional statements are asking: "Does word1 hold the value 'Gritty'? If not, does it hold the value 'Nicolas Cage'?" In other words, the second question will only ever be asked if the answer to the first question is "No." If the answer to the first question is "Yes", the second question will be skipped.

    • You can string together more conditions here by adding more elif statements.

    • If you want a catch-all, something that matches more than one condition, you can also use else. So you could say: 

    if word1 == "Gritty":
    word2 = random.choice(word_list2_a)
else:
    word2 = random.choice(word_list2_b)

    Which is like saying "If word1 has the value 'Gritty', do the first block, otherwise (in all other cases) do the second block." It is useful if you have more cases and you want some code to apply to all of them.

    Now as before, use Python's string formatting to fill in the blanks: 

    message = string_template.format(word1,word2)

    And that's it for this option! Again run your code, and check the class twitter bot: twitter.com/bot_ror for your messages.

For your homework, add some thoughts and reflections about these various options to your lab notebook. Which option is most interesting to you? Which do you understand best? Which do you think could make the most interesting bot? What are some connections between this and the Strachey "Love Letter Generator"?

For homework, pick one of these options and try to exapand and embellish it, adding more choices and more possible outputs.