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

Nondeterministic Programming

• For Wordle, the game is only interesting if the secret word is not the same every time!
• Let’s take a moment to look at the built-in random library, which lets us simulate random processes
• Programs that involve random processes that cannot be predicted in advance are said to be nondeterministic
• Nondeterministic behavior is essential to many applications.
  • Many games would not be enjoyable if they behaved the exact same way every playthrough
  • Important practical uses in simulations, computer security, and algorithm research

Important Functions in random

Random Example 1

import random

def random_redblue():
    if random.random() > 0.5:
        return "red"
    else:
        return "blue"

Random Example 2

def random_color():
    color_string = "#"
    for i in range(6):
        color_string += random.choice("0123456789ABCDEF")
    return color

The Worth of a Picture

The Portable Graphics Library

The Pieces

• At its simplest then, we have two main parts:
  • The window (or felt-board/cork-board)
    • Created with the GWindow function
    • Takes two arguments: a width and a height in pixels
  • The contents
    • A wide assortment of shapes that can be added to the scene
    • Control over where they are placed, how large they are, what color they are, etc

Blue Rectangle!

from pgl import GWindow, GRect

GW_WIDTH = 500
GW_HEIGHT = 200

gw = GWindow(GW_WIDTH, GW_HEIGHT)
rect = GRect(150, 50 ,200, 100)
rect.set_color("Blue")
rect.set_filled(True)
gw.add(rect)

The Coordinate System

Other Simple Objects

Functions to create simple geometric objects:

• Rectangles!
  • GRect( |||x|||, |||y|||, |||width|||, |||height||| )
  • Creates a rectangle whose upper left corner is at (x,y) of the specified size
• Circles/Ovals!
  • GOval( |||x|||, |||y|||, |||width|||, |||height||| )
  • Creates an oval that fits inside the rectangle with the same dimensions
• Lines!
  • GLine( |||x1|||, |||y1|||, |||x2|||, |||y2||| )
  • Creates a line extending from (x1,y1) to (x2,y2)

The GObject Hierarchy

• The types of graphical objects form a hierarchy:

• The GObject type represents the collection of all graphical objects
• The GFillableObject type represents those that have a fillable interior

Interacting with the GWindow

• We’ve already shown creation:

  gw = GWindow(|||width|||, |||height|||)

• You have several more operations that you can apply to the GWindow object:

Interacting with GObjects

• The following operations apply to all GObjects, where object is the name of any specific instance.

• All coordinates and distances are measured in pixels

Interacting with GFillableObjects

• Fillable GObjects have a smaller subset of commands that also apply to them.
• Initially the only fillable objects available to you are rectangles and ovals

Smile!

gw = GWindow(400, 400)

head = GOval(20, 20, 360, 360)
head.set_fill_color("yellow")
head.set_filled(True)
gw.add(head)

reye = GOval(110, 100, 40, 40)
reye.set_filled(True)
gw.add(reye)

leye = GOval(250, 100, 40, 40)
leye.set_filled(True)
gw.add(leye)

mouth = GLine(150, 250, 250, 250)
mouth.set_line_width(5)
gw.add(mouth)