Python Basics

Learning the logic

Python is a very friendly programming language, and has numerous applications. It is also a great language to use if learning how to code for this first time. This will not be even close to a complete tutorial in Python, because there is so much to cover (and others have done it before, much better than I). But hopefully I can cover some of the basics well enough for you to understand how it is being used to build a web app.

So let's begin by covering the basic 'utility belt' at your disposal with Python.

Variables

strings, ints, doubles, and booleans

Variables are an essential part of your "complete breakfast". Variables are used to store data, whether it's data you're manipulating or information from the user that is to be remembered. Variables have a handful of primary types which are the kinds of data that can be stored in a variable. Some languages are strongly typed, but Python is not so you generally don't have to worry about keeping your variable types consistent. Variables in Python can be named anything you want, as long as the name begins with a character or underscore, and not a number.

However, there are only a handful of different primary types. They are strings, ints, doubles, and booleans. String variables are used to store any series of characters. Strings can represent a letter, a word, a sentence, a paragraph, numbers, equations, etc. Integers are used to represent whole numbers, and can be very useful for mathematic situations. Doubles are used to represent numbers with decimal points. Booleans are used to represent true and false and are used in boolean logic.

Let's go through a quick Python interactive example. If you'd like to follow along (which I recommend) just type python into the Terminal to start an interactive session. If you're not following along >>> indicates the prompt for the next command. Interactive mode is very useful to quickly prototype what a small piece of code is going to do without writing an entire program.

>>> num_x = 4
>>> num_x
4
>>> num_y = num_x + 2
>>> num_y
6
>>> str_x = "Hello, World!"
>>> str_x
Hello, World!
>>> dbl_x = 4.14
>>> dbl_y = 1.00
>>> dbl_z = dbl_x + dbl_y
>>> dbl_z
5.14

To escape from the Python interactive session, you can type exit(), or you can hit Ctrl D.

Data Structures

lists, and dicts

Now, keeping a variable for every piece of information you want to keep might be unruly. Especially if you are looping through a piece of code and need to programatically create new variables. This is where data structures become useful. You then can use one variable to represent a list or dict of information. And these structure come with all sorts of fun helper functions.

Lists are essentially just a series of variables. Lists, in Python, are similar to arrays in other languages. If you're not familiar with an array, they store a series of variables together. If you want to access a single element in the list you reference its index. Lists are 0-indexed, meaning that the first element has an index of 0, the second has an index of 1, and so on.

Dicts are similar to lists except each entry has a key and a value, similar to a dictionary. Dicts are similar to maps in other languages. If you want to access a single value, you have to use the provided key. All keys have to be unique within a single dict. The key can be thought of as a custom index in the list example. Lets do another interactive example.

>>> list_x = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
>>> list_y = ["Hello", "World!"]
>>> list_z = [True, False]
>>> dict_x = {"a": "hello", "r": "world"}
>>> dict_y = {"first": "John", "last": "Smith"}
>>> dict_z = {"address": "123 First St", "state": "Texas", "zip": 12345}
>>> list_x
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
>>> list_x[3]
4
>>> list_y[0]
Hello
>>> dict_x["r"]
world
>>> dict_y["first"]
John
>>> dict_z["zip"]
12345

Control Flow Tools

if elif else statements

The if block is your program's mitochondria (mitochondria is the powerhouse of the cell!). It allows for multiple paths to be taken through your code. The code inside of the first if will be executed if the boolean check immediately after the if is true. If it is false, then it will check the next elif boolean check to see if it is true. If nothing evaluates to true, the else block will execute. The only required piece is the if block. The following are all correct.

x = 1
if x < 5:
  print "x is less than 5"

x = 10
if x < 5:
  print "x is less than 5"
else:
  print "x is greater than or equal to 5"

x = 10
if x < 5:
  print "x is less than 5"
elif x > 5:
  print "x is greater than 5"
else:
  print "x is equal to 5"

x is less than 5
x is greater than or equal to 5
x is greater than 5

for loops

The for loop is also a crucial part of controlling the flow of your program. If you want to repeat the same block of code multiple times, or iterate through every element in a list, then the for loop is for you!

The range() function is a built-in function in python. It will create a list out of the integer parameter (we'll cover functions and parameters soon). If you call range(4) a list will be created of integers from 0 to 3. This is very useful with for loops in Python. There is an example below that makes use of the range() function, a for loop, and an if/else block.

words = ["hello", "my", "name", "is", "tod"]
string = "hello"

for word in words:
  print word

print ""

for letter in string:
  print letter

print ""

for i in range(10):
  if i == 6:
    print "i is 6"
  else:
    print "i is not 6"

hello
my
name
is
tod

h
e
l
l
o

i is not 6
i is not 6
i is not 6
i is not 6
i is not 6
i is 6
i is not 6
i is not 6
i is not 6
i is not 6

while loops

while loops are very similar to for loops. They allow you to repeat certain sections of your code for the duration that some check is true. While loops perform a boolean check before every iteration to make sure it should repeat, or break. The boolean check comes immediately after the while keyword. Below is a simple example:

x = 10
while x > 4:
  print x
  x = x - 1

10
9
8
7
6
5

def functions

Sometimes you might want to use the same block of code in multiple places and you'll be tempted to copy and paste. Never ever copy and paste. If there is a piece of code that you would like to reuse, turn it into a function! A function is your own custom set of commands that you can call with a single command instead of copying and pasting multiple lines of code. Don't worry if your output doesn't exactly match on this one; 5 random colors should be printed out.

import random

def print_random_color():
  colors = ["red", "orange", "yellow", "green", "blue", "purple"]
  print random.choice(colors)

for i in range(5):
  print_random_color()

orange
red
red
red
blue

function arguments

Functions become much more powerful if they can accept variables that you can then manipulate. If we modify the previous function we wrote, we can have it accept incoming arguments, or parameters. But we'll modify it so that the functionality stays the same. Again, don't worry about the output being exactly the same.

import random

def print_random_color(times):
  colors = ["red", "orange", "yellow", "green", "blue", "purple"]
  for i in range(times):
    print random.choice(colors)

print_random_color(5)

yellow
green
green
orange
yellow

Custom Structures AKA Objects

classes

If you would like to create your own object, like a string or int, you have to build it out of the existing primary types. You could create and object called Person, and it could contain a name, a birthday, and an ethnicity. And you could give it custom functions like get_age(). Here's an example of what a Person class might look like.

from datetime import datetime

class Person():
  def __init__(self, name, birth_year, ethnicity=None):
    self.name = name
    self.birth_year = birth_year
    self.ethnicity = ethnicity
    
  def get_age(self):
    age = datetime.now().year - self.birth_year
    return age
    
john = Person("John", 1990)

Scope

visibility

The scope is always something you have to keep in mind. All variables, functions, and data structures maintain some kind of scope. The scope refers to what is visible in certain parts of your code. If you declare a global variable at the top of your code, all of your functions will be able to see it. But if you declare a variable in one function, only that function can see the variable. Here's a quick demo.

x = "Hello, World!" # global variable

def local_one():
  y = "Hello locals."
  print x # global variables are visible here

def local_two():
  z = "Howdy folks."
  print z # printed from the same scope z was declared

print x
print y # error! local_one() scope has ended, along with y

Hopefully by now, you should be able to figure out what this piece of code is doing quite easily.

def repeat(times):
  for i in range(times):
    print "Hello"

repeat(4)

hello
hello
hello
hello

HTML Basics

Developing in the Shell