A Python Crash Course
This is a short introduction to python that assumes you are already familiar with another programming language, in particular something that uses a C-like syntax. If you find this is too brief or just want more details, then you might be interested in my post Python Programming: A Self-Learning Guide.
Python is a high-level, object-oriented, interpreted language. We can process python code by either typing commands directly into the interpreter or by using the interpreter to process a file of commands (what I would call an actual program). Most python tutorials and books will demonstrate python commands by typing them into the interpreter; you will recognize this by the >>>
prompt. Much of what I show will be programs that you can copy and then run yourself with the Python interpreter.
Let’s start with some obvious differences between Python and C (or its descendents, like C++ or Java).
- Python requires that indentation be used for the bodies of functions, conditionals, and loops. In those languages with a C-like syntax, this would be done via curly brackets. This forces the indentation to match the logic.
- While Python does have object types, you don’t need to declare variable types nor declare variables before their use.
- Variable names can be re-used with the same or different types; a new object is created.
- Strings and Booleans are built-in types in Python. The print() function automatically adds a newline. If you don’t want this behavior, then you must suppress it.
- In Python versions beginning with 3.0, dividing an integer by an integer using a single slash produces a floating-point value. To get an integer result from dividing an integer by an integer you should use two slashes. In C the integer is produced by truncating any part to the right of the decimal value. In Python the result is rounded down to the nearest integer.
Statements
Single line comments begin with #
. Multiline comments are wrapped in sets of three single quotes or three double quotes.
C-style format specifiers can be use, although there are newer ways that don’t require that you know the type.
""" the type() function allows us to see what type Python thinks an object is this is particularly helpful when debugging since a variable name can be re-used with a new object of a different type """ a = 14 print( type(a) ) print("a = %d" % a) print() # print a blank line b = 37 print( type(b) ) print("b = %d" % b, end="") # suppress the newline print("\n") # print two newlines c = b/a print( type(c) ) print( c ) print("%d/%d = %.3f" % (b, a, c) ) # C-style print("{}/{} = {:.3f}".format(b, a, c)) # one of the new ways print() c = b//a print( type(c) ) print("{}//{} = {}".format(b, a, c)) print() d, e = 99, 123 print("d = %d, e = %d" % (d, e)) d, e = e, d print("d = %d, e = %d" % (d, e)) """ output <class 'int'> a = 14 <class 'int'> b = 37 <class 'float'> 2.642857142857143 37/14 = 2.643 37/14 = 2.643 <class 'int'> 37//14 = 2 d = 99, e = 123 d = 123, e = 99 """
Booleans and Logical Operators
a = True print( type(a) ) print(a) b = False print( type(b) ) print(b) print() print(not a) print() print(a and a) # only True and True is True print(a and b) print(b and b) print() print(a or a) # only need one True among the or'd values print(a or b) print(b or b) """ output <class 'bool'> True <class 'bool'> False False True False False True True False """
Conditionals
a = 5 b = 6 if a==5 : print("this is true\n") if a == 100 or b >= 99 : print("at least one condition is true\n") else : print("neither condition is true\n") if a == 1 : print("one\n") elif a == 3 : # only get here if previous condition false print("three\n") elif a == 5 : # only get here if previous conditions false print("five\n") else : # only get here if previous conditions false print("something else\n") if a == 5 : print("a is 5", end="") if b == 6 : # only get here is a is 5 print(" and b is 6") """ output this is true neither condition is true five a is 5 and b is 6 """
Loops
i = 0 while i < 5 : if i%2 == 0 : print("%d is even" % i) else : print("%d is odd" % i) i += 1 print() # the for loop in Python iterates through # a set of objects # it's similar to foreach in some languages for i in range(0, 10, 3) : print("i is {}".format(i) ) """ output 0 is even 1 is odd 2 is even 3 is odd 4 is even i is 0 i is 3 i is 6 i is 9 """
Functions
def f(a, b, c=5) : # if c is not passed in, use c = 5 val1 = 2*a + b - c val2 = 3*a + b**2 + c # b**2 is b squared return val1, val2 #### program starts here x = 4 y = -2 z = 1 v1, v2 = f(x, y) print("v1 = {}, v2 = {}".format(v1, v2)) v1, v2 = f(x, y, z) print("v1 = {}, v2 = {}".format(v1, v2)) """ output v1 = 1, v2 = 21 v1 = 5, v2 = 17 """
Lists and Tuples
Lists in Python are similar to what you would call an array in C-style languages. There are some notable differences, however:
- while indexing begins with 0 for the first element and counts up from there, we can also apply indexing to the end. That is, the last element has index -1, the next to last element has index -2, and so forth.
- Python lists can contain multiple types, for example, we could have an int followed by a string followed by another list.
- we can add and remove elements from the list, with all of the memory management handled for us.
sample program #1
# a list is created with square brackets d = [1, 2.345, "cat", [7, 8]] # iterate through elements of list for x in d : print("{} has type {}".format(x, type(x))) print() size = len(d) # get number of elements in list d[0] = 99 # change the first value i = 0 while i < size : print(d[i]) i = i + 1 print( d[3][0] ) print( d[3][1] ) print() print( d[-1] ) print( d[-2] ) # a tuple is created with parenthesis t = (12.34, "cat") print( t[0] ) """ tuples are immutable, so this would cause an error t[0] = 66 """ """ output 1 has type <class 'int'> 2.345 has type <class 'float'> cat has type <class 'str'> [7, 8] has type <class 'list'> 99 2.345 cat [7, 8] 7 8 [7, 8] cat 12.34 """
sample program #2
# we can slice a list, producing a new list a = [3, 4, 5, 6, 7, 8, 9, 10, 11, 12] print("a = {}".format(a)) # start slice at index 1, while less # than index 6, with step sizes of 2 b = a[1 : 6 : 2] print("b = {}".format(b)) """ what if we want to copy an entire list? writing c = a is legal, but c will be an alias for the same list that a names """ c = a.copy() # one of several ways to copy print("c = {}".format(c)) """ output a = [3, 4, 5, 6, 7, 8, 9, 10, 11, 12] b = [4, 6, 8] c = [3, 4, 5, 6, 7, 8, 9, 10, 11, 12] """
sample program #3
""" lists are objects and have many associated methods """ x = [1, 2, 3] print("1: x = {}".format(x)) x.append(99) # add to end print("2: x = {}".format(x)) x.insert(1, 456) # insert at index 1 print("3: x = {}".format(x)) x.pop() # remove from end print("4: x = {}".format(x)) x.pop(2) # remove at index 2 print("5: x = {}".format(x)) x.sort() print("6: x = {}".format(x)) x.reverse() print("7: x = {}".format(x)) print() print(3 in x) # check if 3 in list print(75 in x) # check if 75 in list """ output 1: x = [1, 2, 3] 2: x = [1, 2, 3, 99] 3: x = [1, 456, 2, 3, 99] 4: x = [1, 456, 2, 3] 5: x = [1, 456, 3] 6: x = [1, 3, 456] 7: x = [456, 3, 1] True False """
sample program #4
""" what if we want to use one list as a starting point for making another list? Python supports list comprehensions """ # loop version d = [] for i in a : if i%2 == 1 : d.append(i) print("d = {}".format(d)) # list comprehension version d = [i for i in a if i%2 == 1] print("d = {}".format(d)) """ d = [3, 5, 7, 9, 11] d = [3, 5, 7, 9, 11] """
Strings
# strings are enclosed by single or double quotes a = 'single quotes' b = "double quotes" c = "it's a mixture of quotes" print("a = %s" % a) print("b = %s" % b) print("c = %s" % c) d = """this string begins on this line but extends to this line""" print("d = %s" % d) """ output a = single quotes b = double quotes c = it's a mixture of quotes d = this string begins on this line but extends to this line """ # we can use relational operators with strings a = "cat" b = "car" if a > b : print("{} comes after {}".format(a, b)) elif a < b : print("{} comes before {}".format(a, b)) else : print("{} and {} have equal values".format(a, b)) # prints "cat comes after car" # we can concatenate strings using + s = "this" s = s + "string" s = s + "is" + "getting" + "longer" print(s) # prints "thisstringisgettinglonger" a = "bookend" b = a[ :4] # when slicing lists or strings, if going all c = a[4: ] # the way to an end can leave out that index print("a {} without the {} is just a {}".format(a, c, b)) # prints "a bookend without the end is just a book" # there are many string methods a = "123,abc,XYZ" b = a.lower() c = a.upper() d = a.split(',') # tokenize with comma as delimiter print("a = {}".format(a)) print("b = {}".format(b)) print("c = {}".format(c)) print("d = {}".format(d)) # a list of tokens """ output a = 123,abc,XYZ b = 123,abc,xyz c = 123,ABC,XYZ d = ['123', 'abc', 'XYZ'] """
File Input/Output
""" code below reads sample.txt one two three """ fp = open("sample.txt", "r") for line in fp : print(line) # print lines from file fp.close() """ output # each line ends in a newline and print() also adds a newline one two three """ fp = open("sample.txt", "r") data = fp.readlines() # store lines from file in a list as strings fp.close() fp = open("output.txt", "w") for line in data : fp.write("out: %s" % line) fp.close() """ output.txt out: one out: two out: three """
Dictionaries
A dictionary is a built-in data structure in Python that stores information using key/value pairs. They are hash tables, so finding values by key is quick.
# dictionaries are created using curly braces # the syntax is key : value # keys must be unique and immutable d = {"cat" : "Felix", 123 : "dog", "aList" : [1, 2, 3]} print(d) print(d[123]) print(d["aList"]) """ output {'cat': 'Felix', 123: 'dog', 'aList': [1, 2, 3]} dog [1, 2, 3] """ d["aList"].append(4) d["aList"].append(5) d["aList"].append(6) d["newKey"] = "newValue" # add key/value pair d[123] = "elephant" # change value del d["cat"] # delete key/value pair print(d) """ output {123: 'elephant', 'aList': [1, 2, 3, 4, 5, 6], 'newKey': 'newValue'} """ print("the keys are {}".format(d.keys())) print("the values are {}".format(d.values())) """ output the keys are dict_keys([123, 'aList', 'newKey']) the values are dict_values(['elephant', [1, 2, 3, 4, 5, 6], 'newValue']) """ for k in d : print("key: {}, value: {}".format(k, d[k])) """ output key: 123, value: elephant key: aList, value: [1, 2, 3, 4, 5, 6] key: newKey, value: newValue """
Modules (aka, libraries)
One of the reasons that Python is so popular is that there are a huge number of libraries (modules in Python terminology) available, many of which come with the standard Python installation. Here is a sample of some libraries I have found useful.
import math print("e^1 = {}".format(math.exp(1)) ) print("log base 2 of {} is {}".format(2048, math.log2(2048)) ) print("sqrt(2) = {}".format(math.sqrt(2)) ) print("sin(pi/4) = {}".format(math.sin(math.pi/4)) ) """ output e^1 = 2.718281828459045 log base 2 of 2048 is 11.0 sqrt(2) = 1.4142135623730951 sin(pi/4) = 0.7071067811865475 """
import csv fp = open("csvFile.csv", "r") reader = csv.reader(fp) for line in reader : print(line) # each line is a list of tokens fp.close() """ csvFile.csv 1,2,3 4,5,6,7 program prints ['1', '2', '3'] ['4', '5', '6', '7'] """
import datetime today = datetime.date.today() future = datetime.timedelta(days=14) futureString = "%s" % (today + future) f = datetime.datetime.strptime(futureString, '%Y-%m-%d') future = f.strftime('%m/%d/%Y') d = today.strftime("%m/%d/%y") print("today is {} or {}".format(today,d) ) print("in 14 days it will be {}".format(future) ) """ output today is 2020-08-24 or 08/24/20 in 14 days it will be 09/07/2020 """