This module is designed to expose you to a variety of elementary programming techniques such as data types, formatting strings and debugging strategies. When you're finished with the module please visit our NYU Classes site and take the Module 02 Quiz.
Your programs will eventually get to be very, very long. Commenting is a way for you to leave "notes" for yourself or other programmers so that you (and/or others) understand what your thinking process was when you originally wrote your program
Python supports comments via the
# symbol. You can use the
# symbol to tell Python to essentially ignore anything else on that line which comes after the symbol. Here are some examples:
print ('Hello, world!') # this will print the string Hello World # the following line will print my name print ('Craig')
It's important to get into the practice of commenting early and to be consistent about leaving comments throughout your program.
Python also supports multi line comments through the use of the triple quote delimiter. For example:
""" This line will be ignored So will this one And this one """ # the following line will NOT be ignored print ('hi there')
We sometimes use comments as a way to pseudocode a programming project before we launch into writing it using real code. Think of this as writing a "rough draft" or "outline" of what you want your program to do before you actually write any real Python code. Pseudocoding allows us to outline the necessary tasks without having to be burdened with writing the actual code to accomplish the desired tasks. For example:
# get two test scores from the user # add them together and divide by 200 # print out the result and report the average # score to the student
A value is a fundamental unit of data that a program works with. The values we have seen so far have been numeric (i.e. 7, 5.5, etc.) or strings (i.e. "Hello!")
When storing data in memory, Python needs to keep track of the value (i.e. the number 5) as well as the "data type" of the value (in this case, an Integer). The "data type" describes the kind of data being stored, and allows you to perform certain actions on the value (i.e. you can add or subtract two Integer values)
There are three basic types of data that we will be working with during the first half of the term:
Python has two different data types for numeric values:
You can store numeric data inside variables and Python will automatically select the correct data type for you. For example:
num_1 = 5 # this is an int num_2 = 4.99 # this is a float
Keep in mind that you do not use separators (e.g. commas) or symbols (e.g. $, %, etc.) when storing numeric data. Example:
num_3 = $5,123.99 # error!
You can check the data type being stored by a variable by using the "type" function. The "type" function takes one argument (the value to be analyzed) and returns the data type as a string. Here's an example:
var1 = "Hello" var2 = 5 var3 = 10.532 print (type(var1)) print (type(var2)) print (type(var3))
The result of the program above would be to display that var1 is a string, var2 is an Integer and var3 is a floating point number.
Sometimes we need to convert values from one data type to another. For example, say you had the following variable in your program:
price = "1.99"
The data type of the variable "price" is a string (because it is initialized using quotes). However, let's say you want to perform a math operation using this variable. In this program you couldn't do that because strings are not numbers - they are only sequences of characters.
We can convert the value stored in the variable "price" to a floating point number using a data type conversion function:
price = "1.99" # convert price to a floating point number real_price = float(price)
Python has a number of data type conversion functions built in. All of these functions accept a value and attempt to convert that value into the data type that corresponds with the name of the function. The result is returned out of the function. For example:
# define our variables a = "1" # a is a string b = 5.75 # b is a floating point number c = 3 # c is an integer # convert data types d = int(a) # d is now the integer value 1 e = str(b) # e is now the string "5.75" f = float(c) # f is now the floating point value 3.0
int are data type conversation functions. They each take one argument and convert that argument into the desired data type.
Note that sometimes you can't convert from one data type to another. For example, what do you think would happen if you tried to run the following code? (Hint: Python won't be very happy with this!)
a = "hello world!" b = float(a)
Remember that we can use the
input function to ask the user a question from within our programs. However, the
input function returns a string – this means that the data type that comes out of the
input function is a series of printed characters. If we want to use the value supplied by the user in a calculation we need to convert the string into one of the two numeric data types that Python supports (float and int). Here's an example:
# ask the user for their monthly salary monthly_salary = input('how much do you make in a month?') # convert the salary into a float monthly_salary_float = float(monthly_salary) # calculate the yearly salary yearly_salary = monthly_salary_float * 12 # print the result print ('that means you make', yearly_salary, 'in a year')
In the previous example we performed our data type conversion in two lines. We could have done that in a single line using a technique called "nesting". Here's an example:
mynum = float( input("give me a number!") )
In this example we execute the innermost function first (the input function) - this returns a string, which is then immediately passed as an argument to the
float function, which converts the string to a floating point number. The result is stored in the variable "mynum"
floatfunctions. Click the "Run" button to see the program in action or download a copy.
Enter student: Craig Enter 5 scores (one per line): 90 85 92 87 94.5 Average test score for Craig: 89.7Click the "Run" button to check your work, and click here to download the solution.
Python contains two different division operators.
/operator is used to calculate the floating-point result of a division operation. The result is always a floating point value.
//operator is used to calculate the integer result of a division operation (essentially throwing away the remainder). This operation will always round down. The result is always an integer.
Most times you will use the floating point division operator (
/). Here are a few examples of these operators in action:
print (5/2) # output: 2.5 print (5//2) # output: 2 print (-5/2) # output: -2.5 print (-5//2) # output: -3
Python supports the standard order of mathematical operations (PEMDAS). You can use parenthetical notation inside your math expressions to group operations For example:
((5+10+20)/60) * 100
You can raise any number to a power by using the "**" operator. For example:
answer = 3 ** 2 print (answer) # output: 9
The modulo operator (
%) returns the whole number remainder portion of a division operation. For example:
print (5/2) # output: 2.5 print (5%2) # output: 1
Python allows you to mix integers and floating point numbers when performing calculations. The result of a mixed-type expression will evaluate based on the operands used in the expression. Python will automatically "widen" the data type of your result based on the values in your expression (i.e. if you add together an integer and a float the result will be a float since Python will need to preserve the decimal values from the floating point operand).
Operand #1 Operand #2 Result int int int float float float int float float float int float
You can't "add" two strings together, but you can "concatenate" them into a single compound string using the same symbol that is used for numeric addition. For example:
a = input("first name: ") b = input("last name: ") fullname = b + ',' + a print (fullname)
You can also "multiply" a string by an integer value to produce a larger string. The resulting string concatenates the original string 'n' times, where n is the integer you use in your expression. For example:
lyrics = 'Fa ' + 'La ' * 8 print (lyrics) # Fa La La La La La La La La
*string operators. Click the "Run" button to see the program in action or download a copy.
Word Pig Latin python "ython" + "p" + "ay"Here's a sample running of your program:
Enter the first letter of a word: p Enter the rest of your word: ython The Pig Latin version of python is ythonpayClick the "Run" button to check your work, and click here to download the solution.
format function can be used to format a string before you decide to print it out to the user.
format takes two arguments – a number and a formatting pattern (expressed as a string).
format() returns a string which can be treated like any other string (i.e. you can print it out immediately, store its value in a variable, etc.)
The first argument passed to the
format function is the item that you wish to format. The second argument passed to the function is the formatting "pattern" you wish to apply to this item. This pattern varies based on what you would like to do to the item in question. Once the pattern is applied to the item the
format function will return a string version of your item with the formatting pattern applied.
format function can be used to generate a customized string version of a float or integer number. For example, here's a program that truncates a floating point number to two decimal places:
a = 1/6 print (a) # 0.16666666667, float b = format (a, '.2f') print (b) # 0.17, string
In the example above we called the
format function with two arguments - a variable of type float and a formatting pattern of type string. The formatting pattern ('.2f') means "we are formatting a floating point value (as indicated by the 'f' character). We want to limit the number of decimal places to 2 (as indicated by the '.2' before the 'f' character)"
Here are some additional examples of formatting numbers using the format() function:
a = 10000/6 # float b = format (a, '.2f') # format a as a 2 digit number - b is a string c = format (a, '.5f') # format a as a 5 digit number - c is a string d = format (a, ',.5f') # format a as a 5 digit number with the "," separator between placed into the resulting string - b is a string
Another common use of the
format function is to generate a string that contains a known # of characters. For example, say you have the strings "Craig" and "Computer Science". You might want to generate output that looks like the following given these items:
Name Department Craig Computer Science
In this case we need to ensure that the strings "Name" and "Craig" are the same width so that the strings that come after them ("Department" and "Computer Science") line up correctly. You can use the
format function to "pad" a string with extra spaces at the beginning or the end of the string. For example:
x = format('Craig', '<20s')
This will generate a new string (x) that contains the string 'Craig' plus 15 spaces at the end of the string (because "Craig" is 5 spaces the resulting string will have 15 additional spaces added to yield a string that contains 20 total characters). The total length of the string in this case will be 20 characters. The '<' character in the formatting pattern tells Python to left justify the string and place the extra spaces at the end of the new string. You can also have Python right justify the string and place the spaces at the beginning of the new string by doing the following:
b = format('Craig', '>20s')
Note that the
format function always returns a string. This means that the result of the
format function is unable to be used in a math expression. However, you could use a data type conversion function ( int() or float() ) to turn the string generated by the format() function back into a numeric data type if you wanted to.
In general, there are three different kinds of errors that can occur to you while writing a program:
Here are some suggestions for isolating errors and correcting them:
So far we have explored how to use Python to produce text-based output using the
"Turtle Graphics" is a method of producing pictures by instructing a cursor (called a 'turtle') to move around on a Cartesian coordinate plane. The turtle can move left, right and forward and carries a pen around with it which can be used to draw lines to the canvas. By calling a series of functions we can cause the "turtle" to trace out shapes and figures on the screen.
In order to start working with turtle graphics we need to gain access to some graphics-specific functions that are not part of the standard Python language. We can do this by asking Python to "import" these functions into a program from a function library, which we refer to as a "module" in Python. A "module" is nothing more than a file that a programmer has written that contains specialized functions that go above and beyond the basic capabilities of a programming language. We can do this by using the "import" statement, like this:
This tells Python to make available all of the functions stored in the "turtle" library. We can now call functions inside of this module by using the module name as a prefix - for example, there is a function in the "turtle" library called "setup" - to call it you can do the following:
# import the functions from the "turtle" library import turtle # call the "setup" function that exists in the "turtle" library turtle.setup(500, 500)
Note that we could not just call "setup" all by itself because that function doesn't exist in the standard set of Python functions. By adding the prefix
turtle. we tell Python to call a function called "setup" that exists within the "turtle" module. We will discuss modules and how they work in greater detail in future lessons.
The "setup" function in the turtle module takes two arguments - the width and height of the graphical canvas you wish to create. Graphical canvases can be thought of as a standard Cartesian coordinate plane with 0,0 being at the center of the canvas (see image below):
Turtle Graphics canvas - width = 10, height = 10
Here's a basic program that shows this in action. Simply copy and paste this code into a new program in IDLE.
# make the turtle module available import turtle # set up the screen size (width=500, height=500) - measured in pixels # the starting point of the turtle to the center of the screen(0, 0) turtle.setup(500, 500)
When you run this program you will notice that IDLE will pop up a new window for you of the desired height. The window will appear blank (all white) because we haven't directed our program to draw anything to it just yet.
To draw basic shapes we need to instruct our "turtle cursor" to move around the screen. The turtle can be instructed to move using some basic functions, including:
# forward: tells the turtle to move forward by # a desired number of units (pixels) turtle.forward(100) # right: tells the turtle to adjust its heading # to the right by a desired number of degrees turtle.right(90) # left: tells the turtle to adjust its heading # to the left by a desired number of degrees turtle.left(45)
Here's a sample program that shows how to draw a square to the screen. Note that the turtle initially faces to the right when your program starts.
# make the turtle graphics module available import turtle # set up our graphical canvas # width = 500, height = 500 # starting point = 0, 0 turtle.setup(500,500,0,0) # move the turtle forward by 100 pixels # note that the turtle initially faces to the right turtle.forward(100) # now turn to the right by 90 degrees turtle.right(90) # now the turtle is facing down. move another 100 pixels turtle.forward(100) # turn to the right by 90 more degrees # this will point the turtle to the left turtle.right(90) # and move forward by another 100 pixels turtle.forward(100) # repeat the process one more time! turtle.right(90) turtle.forward(100)
... and here's what should be generated when you run the program above:
A simple square drawn in Turtle Graphics
Here are a few challenges
Programming Challenge: Write a series of Python programs that draw the following shapes to the screen:
If you'd like to view the solutions download a copy.
The turtle cursor can be controlled using some additional functions, including:
# goto: instructs the turtle cursor to move to a specific position on the canvas # note that the turtle's heading is unaffected by this function (i.e. if the turtle # is facing right and then is told to move to a particular coordinate it will still # be facing to the right when it gets to that location) turtle.goto(100, 50) # setheading: tells the turtle to turn and face a specific direction (expressed as # an angle). 0=right, 90=up, 180=left, 270=down turtle.setheading(90) # penup: tells the turtle to pick up its pen - no "ink" will be drawn to the canvas # if the turtle is asked to move from this point forward (this function takes no arguments) turtle.penup() # pendown: tells the turtle to put down its pen - resumes drawing "ink" to the screen turtle.pendown()
Here's a sample program that draws two squares at opposite sides of the canvas:
# make the turtle graphics module available import turtle # set up our graphical canvas # width = 500, height = 500 # starting point will be the center of the screen turtle.setup(500,500) # pick up the pen so we can move to a new position turtle.penup() # now move to the top left side of the screen turtle.goto(-200, 200) # put the pen down turtle.pendown() # draw a square here turtle.forward(100) turtle.right(90) turtle.forward(100) turtle.right(90) turtle.forward(100) turtle.right(90) turtle.forward(100) turtle.right(90) # pick up the pen and move to the bottom right side # of the screen turtle.penup() turtle.goto(100, -100) # put the pen down when we get here turtle.pendown() # make sure we are facing to the right turtle.setheading(0) # now draw another square turtle.forward(100) turtle.right(90) turtle.forward(100) turtle.right(90) turtle.forward(100) turtle.right(90) turtle.forward(100) turtle.right(90)
... and here's what the program above should look like when run:
Two squares drawn on opposite sides of the canvas
Programming Challenge: Write a Python program that draws a triangle, a square, a pentagon and an octogon at different positions on the screen. Make sure that each figure is drawn so that it appears fully on the screen. Here's a sample image of what your program should look like when run:
If you'd like to view the solutions download a copy.
In summary, here are the turtle functions that were covered in this section. In future modules we will explore turtle graphics in greater detail, including how to control color, speed and add interativity to our drawings. If you're curious to learn more feel free to check out the official Turtle Graphics Documentation Site.
# setting up a turtle canvas turtle.setup(width, height) # orientation functions turtle.right(degrees) turtle.left(degrees) turtle.setheading(degrees) # movement functions turtle.forward(pixels) turtle.goto(x_position, y_position) # drawing control turtle.penup() turtle.pendown()
Now that you've completed this module, please visit our NYU Classes site and take the corresponding quiz for this module. These quizzes are worth 5% of your total grade and are a great way to test your Python skills! You may also use the following scratch space to test out any code you want.