Introduction to Programming with Python¶

What you’ll need¶

What is Python, exactly?¶

Ok, so python is this thing called a programming language. It takes text that you’ve written (usually referred to as code), turns it into instructions for your computer, and runs those instructions. We’ll be learning how to write code to do cool and useful stuff. No longer will you be bound to use others’ programs to do things with your computer - you can make your own!

Practically, Python is just another program on your computer. The first thing to learn is how to use and interact with it. There are in fact many ways to do this; the first one to learn is to interact with python’s interpreter, using your operating system’s (OS) console.

A console (or ‘terminal’, or ‘command prompt’) is a textual way to interact with your OS, just as the ‘desktop’, in conjunction with your mouse, is the graphical way to interact your system.

mycomputer:~ myusername$

myusername@mycomputer:~$

C:\Users\myusername>

Using Python¶

The python program that you have installed will by default act as something called an interpreter. An interpreter takes text commands and runs them as you enter them - very handy for trying things out.

Just type python at your console, hit Enter, and you should enter Python’s Interpreter.

To find out which version of python you’re running, instead type python -V in your console to tell you.

Python 3.5.0 (default, Sep 20 2015, 11:28:25)
[GCC 5.2.0] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>>

print("Hello world")

>>> print("Hello world")
Hello world
>>> (1 + 4) * 2
10

>>> 239 + 588
827
>>> 827 * 827
683929

>>> (239 + 588) * (239 + 588)
683929

>>> (239 + 588) ** 2
683929

$ python hello.py

> cd Desktop\Python_Exercises

$ cd Desktop/Python_Exercises

Introduction¶

“Turtle” is a python feature like a drawing board, which lets you command a turtle to draw all over it!

You can use functions like turtle.forward(...) and turtle.left(...) which can move the turtle around.

Before you can use turtle, you have to import it. We recommend playing around with it in the interactive interpreter first, as there is an extra bit of work required to make it work from files. Just go to your terminal and type:

import turtle

turtle.forward(25)

turtle.left(30)

The turtle.forward(...) function tells the turtle to move forward by the given distance. turtle.left(...) takes a number of degrees which you want to rotate to the left. There is also turtle.backward(...) and turtle.right(...), too.

The standard turtle is just a triangle. That’s no fun! Let’s make it a turtle instead with the turtle.shape() command:

turtle.shape("turtle")

So much cuter!

If you put the commands into a file, you might have recognized that the turtle window vanishes after the turtle finished its movement. (That is because Python exits when your turtle has finished moving. Since the turtle window belongs to Python, it goes away as well.) To prevent that, just put turtle.exitonclick() at the bottom of your file. Now the window stays open until you click on it:

import turtle

turtle.shape("turtle")

turtle.forward(25)

turtle.exitonclick()

Drawing a square¶

Exercise¶

Draw a square as in the following picture:

For a square you will probably need a right angle, which is 90 degrees.

turtle.forward(50)
turtle.left(90)
turtle.forward(50)
turtle.left(90)
turtle.forward(50)
turtle.left(90)
turtle.forward(50)
turtle.left(90)

NameError: name 'turtle' is not defined

Drawing a rectangle¶

Exercise¶

Can you draw a rectangle too?

turtle.forward(100)
turtle.left(90)
turtle.forward(50)
turtle.left(90)
turtle.forward(100)
turtle.left(90)
turtle.forward(50)
turtle.left(90)

More squares¶

Exercise¶

Now, draw a tilted square. And another one, and another one. You can experiment with the angles between the individual squares.

The picture shows three 20 degree turns. But you could try 20, 30 and 40 degree turns, for example.

turtle.left(20)

turtle.forward(50)
turtle.left(90)
turtle.forward(50)
turtle.left(90)
turtle.forward(50)
turtle.left(90)
turtle.forward(50)
turtle.left(90)

turtle.left(30)

turtle.forward(50)
turtle.left(90)
turtle.forward(50)
turtle.left(90)
turtle.forward(50)
turtle.left(90)
turtle.forward(50)
turtle.left(90)

turtle.left(40)

turtle.forward(50)
turtle.left(90)
turtle.forward(50)
turtle.left(90)
turtle.forward(50)
turtle.left(90)
turtle.forward(50)
turtle.left(90)

Introduction¶

Whew. Experimenting with the angles requires you to change three different places in the code each time. Imagine you’d want to experiment with all of the square sizes, let alone with rectangles! We can do better than that.

This is where variables come into play: You can tell Python that from now on, whenever you refer to a variable, you actually mean something else. That concept might be familiar from symbolic maths, where you would write: Let x be 5. Then x * 2 will obviously be 10.

In Python syntax, that very statement translates to:

x = 5

After that statement, if you do print(x), it will actually output its value — 5. Well, can use that for your turtle too:

turtle.forward(x)

Variables can store all sorts of things, not just numbers. A typical other thing you want to have stored often is a string - a line of text. Strings are indicated with a starting and a leading " (double quote). You’ll learn about this and other types, as those are called in Python, and what you can do with them later on.

You can even use a variable to give the turtle a name:

timmy = turtle

Now every time you type timmy it knows you mean turtle. You can still continue to use turtle as well:

timmy.forward(50)
timmy.left(90)
turtle.forward(50)

A variable called angle¶

angle = 20

turtle.left(angle)

turtle.forward(50)
turtle.left(90)
turtle.forward(50)
turtle.left(90)
turtle.forward(50)
turtle.left(90)
turtle.forward(50)
turtle.left(90)

turtle.left(angle)

The house of santa claus¶

Exercise¶

Draw a house.

You can calculate the length of the diagonal line with the Pythagorean theorem. That value is a good candidate to store in a variable. To calculate the square root of a number in Python, you’ll need to import the math module and use the math.sqrt() function. The square of a number is calculated with the ** operator:

import math

c = math.sqrt(a**2 + b**2)

Introduction¶

Something you might have noticed: our programs often feature repetition. Python has a powerful concept it makes use of called looping (jargon: iteration), which we can use to cut out our reptitive code! For now, try this easy example:

for name in "John", "Sam", "Jill":
    print("Hello " + name)

This is incredibly helpful if we want to do something multiple times — say, drawing the individual border lines of a shape — but only want to write that action once. Here’s another version of a loop:

for i in range(10):
    print(i)

Notice how we write only one line of code using i, but it takes on 10 different values?

The range(n) function can be considered a shorthand for 0, 1, 2, ..., n-1. If you want to know more about it, you can use the help in the Python shell by typing help(range). Use the q key to exit the help again.

You can also loop over elements of your choice:

total = 0
for i in 5, 7, 11, 13:
    print(i)
    total = total + i

print(total)

Write this example out and run it with python, to check it works how you might expect.

Sometimes you want to repeat some code a number of times, but don’t care about the value of the i variable; so it can be good practice to replace it with _ instead. This signifies that we don’t care about its value, or don’t wish to use it. Here’s a simple example:

for _ in range(10):
    print("Hello!")

You may or may not be wondering about the variable i - why is it used all the time above? Well, it simply stands for “index” and is one of the most common variable names ever found in code. But if you are looping over something other than just numbers, be sure to name it something better! For instance:

for drink in list_of_beverages:
    print("Would you like a " + drink + "?")

This is immediately clearer to understand than if we had used i instead of drink.

Drawing a dashed line¶

Exercise¶

Draw a dashed line. You can move the turtle without the turtle drawing its movement by using the turtle.penup() function; to tell it to draw again, use turtle.pendown().

for i in range(10):
    turtle.forward(15)
    turtle.penup()
    turtle.forward(5)
    turtle.pendown()

Bonus¶

Can you make the dashes become larger as the line progresses?

Hint

Feeling lost? Inspect i at every run of the loop:

for i in range(10):
    print(i)
    # write more code here

Can you utilize i — commonly called the index variable or loop variable — to get increasing step sizes?

Comments¶

In the example above, the line that starts with a # is called a comment. In Python, anything that goes on a line after # is ignored by the computer. Use comments to explain what your program does, without changing the behaviour for the computer. They can also be used to easily and temporarily disable, or “comment out” some lines of code.

Comments can also go at the end of a line, like this:

turtle.left(20)     # tilt our next square slightly

More Efficient Squares¶

for _ in range(4):
    turtle.forward(100)
    turtle.left(90)

for ...:
    for ...:
        # drawing code inside the inner loop goes here
        ...
    # you can put some code here to move
    # around after!
    ...

Introduction¶

Programmers can deal with some pretty complex and abstract problems, but one sign of a good programmer is that they’re lazy. They only like to deal with one thing at a time. So you need a way to break up problems into smaller, discrete pieces, which lets you focus on just the piece you want to.

Functions are one way to do this abstraction in Python. Let’s take turtle.reset() for example. reset is a function we call on our turtle, and it is actually an abstraction for a number of steps, namely:

• Erase the drawing board.
• Set the width and color back to default.
• Move the turtle back to its initial position.

But because all the code is contained in the function, we don’t have to worry about these details. We can simply call this function, and know it will do what it says for us.

So - how to write your own?

A function can be defined with the def keyword in Python:

def line_without_moving():
    turtle.forward(50)
    turtle.backward(50)

This function we defined is called line_without_moving and it is an abstraction for two turtle steps - a move forward and a move backward.

To use it (or as it is usually called, “to call it”), write its name followed by parentheses:

line_without_moving()
turtle.right(90)
line_without_moving()
turtle.right(90)
line_without_moving()
turtle.right(90)
line_without_moving()

We could write more functions to remove some of the repetition:

def star_arm():
    line_without_moving()
    turtle.right(360 / 5)

for _ in range(5):
    star_arm()

A function for a square¶

def tilted_square():
  turtle.left(20)     # now we can change the angle only here
  for _ in range(4):
      turtle.forward(50)
      turtle.left(90)

tilted_square()
tilted_square()
tilted_square()

# bonus: you could have a separate function for drawing a square,
# which might be useful later:

def square():
  for _ in range(4):
      turtle.forward(50)
      turtle.left(90)

def tilted_square():
  turtle.left(20)
  square()

# etc

A function for a hexagon¶

Exercise¶

Write a function that draws a hexagon.

Now combine that function into a honeycomb. Just make it with a single layer like this:

Give it a good go!

Hint

Make sure your hexagon function returns your turtle to exactly the same position and angle it was before it was asked to draw the hexagon. This makes it easier to reason about.

def hexagon():
  for _ in range(6):
      turtle.forward(100)
      turtle.left(60)

for _ in range (6):
    hexagon()
    turtle.forward(100)
    turtle.right(60)

Introduction¶

As we shrink down our code and add functions to remove duplication, we are factorizing it. This is a good thing to do. But the functions we have defined so far are not very flexible. The variables are defined inside the function, so if we want to use a different angle or a distance then we need to write a new function. Our hexagon function can only draw one size of hexagon!

That is why we need to be able to give parameters, also called arguments, to the function. This way the variables in the function can have different values each time we call the function:

Remember how we defined the function line_without_moving() in the previous section:

def line_without_moving():
    turtle.forward(50)
    turtle.backward(50)

We can improve it by giving it a parameter:

def line_without_moving(length):
    turtle.forward(length)
    turtle.backward(length)

The parameter acts as a variable only known inside the function’s definition. We use the newly defined function by calling it with the value we want the parameter to have like this:

line_without_moving(50)
line_without_moving(40)

We have been using functions with parameters since the beginning of the tutorial with turtle.forward(), turtle.left(), etc...

And we can put as many arguments (or parameters) as we want, separating them with commas and giving them different names:

def tilted_line_without_moving(length, angle):
    turtle.left(angle)
    turtle.forward(length)
    turtle.backward(length)

A parameterized function for a variable size hexagon¶

def hexagon(size):
    for _ in range(6):
        turtle.forward(size)
        turtle.left(60)

A function of several parameters¶

Exercise¶

Write a function that will draw a shape of any number of sides (let’s assume greater than two) of any side length. Get it to draw some different shapes.

Here’s an example of drawing shapes with this function:

Tip

The sum of the external angles of any shape is always 360 degrees!

def draw_shape(sides, length):
    for _ in range(sides):
        turtle.forward(length)
        turtle.right(360 / sides)

Introduction¶

So far we have accomplished predefined tasks, but in all honesty we were accomplishing no better than old-time music boxes following one set of instructions to the end. What makes programming so much more powerful are conditional statements. This is the ability to test a variable against a value and act in one way if the condition is met by the variable or another way if not. They are also commonly called by programmers if statements.

To know if a condition is True of False, we need a new type of data: the booleans. They allow logical operations. A logic statement or operation can be evaluated to be True or False. Our conditional statement can then be understood like this:

if (a condition evaluates to True):

then do these things only for ‘True’

else:

otherwise do these things only for ‘False’.

The condition can be anything that evaluates as True or False. Comparisons always return True or False, for example == (equal to), > (greater than), < (less than.)

The else part is optional. If you leave it off, nothing will happen if the conditional evaluates to ‘False’.

Examples¶

Here are some examples. You may want to read them over line-by-line and see what you think they do, or run them to be certain:

condition = True
if condition:
    print("condition met")

if not condition:
    print("condition not met")

direction = -30
if direction > 0 :
    turtle.forward(direction)
else:
    turtle.left(180)
    turtle.forward(-direction)

Giving Directions¶

Python turtles can be very good at following instructions. Let’s use the input() function to ask the user for a direction to move the turtle. To keep things easy we will only accept two instructions: “left” and “right”.

It’s much easier to define this as a function, like so:

def move():
    direction = input("Go left or right? ")
    if direction == "left":
        turtle.left(60)
        turtle.forward(50)
    if direction == "right":
        turtle.right(60)
        turtle.forward(50)

Now whenever you use move() you are prompted to choose left or right.

“data munging”¶

In this program, the turtle will only respond to exactly left or right with no variation. Though Left or LEFT might seem the same as left to a human, that isn’t the case when programming. Python has a few utility methods to help with that. A string has the methods .strip(), which removes whitespace and .lower() which makes everything lower-case.

Here are some examples to print out the effects of .strip() and .lower():

my_variable = "       I Am Capitalised"
print(my_variable)
my_stripped = my_variable.strip()
print(my_stripped)
my_lower = my_variable.lower()
print(my_lower)

Try adding direction = direction.strip().lower() to the move() function, to see the effect. We often call this kind of code “data munging”, and it is very common.

Can you add some extra input choices to make the turtle draw other things? How about hexagon?

Introduction¶

Conditional loops are way to repeat something while a certain condition is satisfied, or True. If the condition is always satisfied (never becomes False), the loop can become infinite. If the condition starts off false, the code in the loop will never run! In Python conditional loops are defined with the while statement:

word = ''
sentence = ''
print('Please enter some words.')
print('Include a period (.) when you are finished.')
while '.' not in word:
    word = input('next word: ')
    sentence = word + ' ' + sentence
print()
print('Aha! You said:')
print(sentence)

We call this part of the code the ‘conditional’: '.' not in word

Whether the conditional returns True or not determines whether the code inside the while loop runs. Of course, it repeats the check every time the loop is run again.

Read the code above, and see if you can summarise in your head what it should do (what its final output will be).

Then copy it into a file, say sentence.py and run it - see exactly what it does. Does that match up with what you thought?

Turtle prison¶

def forward(distance):
    while distance > 0:
        if turtle.distance(0,0) > 100:
            angle = turtle.towards(0,0)
            turtle.setheading(angle)
        turtle.forward(1)
        distance = distance - 1

Draw a spiral¶

Loops can be interrupted with the break statement. This is especially useful if you write an infinite loop, which is a loop where the conditional is always True.

def draw_spiral(radius):
    original_xcor = turtle.xcor()
    original_ycor = turtle.ycor()
    speed = 1
    while True:
        turtle.forward(speed)
        turtle.left(10)
        speed += 0.1
        if turtle.distance(original_xcor, original_ycor) > radius:
            break

Introduction¶

Conditionals are a nice way to make decisions by asking if something equals True or not. But often one condition is not enough. We may want to take the opposite of our result. Or for instance if we want to make a decision upon turtle.xcor() and turtle.ycor() we have to combine them. This can be done with logical operators.

Negation of a statement¶

If we want something to be False we can use not. It is a logical operator:

x = False
if not x :
    print("condition met")
else:
    print("condition not met")

def stealthed_forward(distance):
    if not turtle.isdown():
        turtle.forward(distance)

This and that or something else¶

Two easy to understand operators are and and or. They do exactly what they sound like::

if 1 < 2 and 4 > 2:
    print("condition met")

if 1 > 2 and 4 < 10:
    print("condition not met")

if 4 < 10 or 1 < 2:
    print("condition met")

You are not restricted to one logical operator. You can combine as may as you want.

def forward(distance):
    while distance > 0:
        if (turtle.xcor() > 100
            or turtle.xcor() < -100
            or turtle.ycor() > 100
            or turtle.ycor() < -100):
            turtle.setheading(turtle.towards(0,0))
        turtle.forward(1)
        distance = distance - 1

Learning Python¶

Hopefully this tutorial has tought you just enough python to get you on your feet. However, there is much more that you can learn! Even professional programmers will always be trying to learn more about their language and how to code excellently with it.

What to do with Python¶

Well, that’s a tough one! See, practically anything you can think of involving some electronics - from your TV remote, to a smartphone, to the backend of a popular web service, to the scheduling of airport landings, to the software you use everyday - it all involves some programming somewhere!

And not only is it a big field practically, but also technically and academically. As soon as you have a basic understanding of a general language like python, you can start working on all manner of subjects: web frontends, web backend services, data analysis and statistics, Artificial Intelligence, GUI design, robotics, software development of all kinds, online transactions, automation of everything, and many more.

We wouldn’t blame if that all sounds daunting, so here’s some practical advice, that takes advantage of how wide a field “programming” is:

Apply your new skills to whatever you’re passionate about.

Whether that’s starting a new business, helping you do some task involving data faster, putting up an online site, calculating advantages in a game you play, creating art and music, or anything else, finding out how to use programming to help with whatever floats your boat will make learning much more exciting and relevant. Feel free to ask someone more experienced if you have no idea where to start, but always mention what makes you tick!

Contributors¶

The following people have contributed to this material, in alphabetical order:

• Alec Clews
• Alper Çugun
• Amélie Anglade
• Andreas Hug
• Angus Gratton
• Aur Saraf
• Benjamin Kampmann
• Benoît Bleuzé
• Charles Pletcher
• Haiko Schol
• julius.jann
• leenagupte
• Markus Zapke-Gründemann
• Matt Iversen
• Matthew Iversen
• OKso
• Robert Lehmann
• Robert Schwarz
• sorrymak
• staeff
• Steven Farlie

(This list is automatically generated from our source repository.)

The material is legally maintained by

OpenTechSchool e.V.

c/o co.up

Adalbertstr. 8

10999 Berlin, Germany