Data science revision - chapter 1
Python basics
- Chapter 1: Python
lets get started
- Create, describe and differentiate standard Python datatypes such as
int,float,string,list,dict,tuple, etc. - Perform arithmetic operations like
+,-,*,**on numeric values. - Perform basic string operations like
.lower(),.split()to manipulate strings. - Compute boolean values using comparison operators operations (
==,!=,>, etc.) and boolean operators (and,or,not). - Assign, index, slice and subset values to and from tuples, lists, strings and dictionaries.
- Write a conditional statement with
if,elifandelse. - Identify code blocks by levels of indentation.
- Explain the difference between mutable objects like a
listand immutable objects like atuple.
The material presented on this website assumes no prior knowledge of Python. Experience with programming concepts or another programming language will help, but is not required to understand the material.
The website comprises the following:
- Chapters: these contain the core content. Read through these at your leisure.
- Practice Exercises: there are optional practice exercise sets to complement each chapter (solutions included). Try your hand at these for extra practice and to help solidify concepts in the Chapters.
A value is a piece of data that a computer program works with such as a number or text. There are different types of values: 42 is an integer and "Hello!" is a string. A variable is a name that refers to a value. In mathematics and statistics, we usually use variable names like $x$ and $y$. In Python, we can use any word as a variable name as long as it starts with a letter or an underscore. However, it should not be a reserved word in Python such as for, while, class, lambda, etc. as these words encode special functionality in Python that we don't want to overwrite!
It can be helpful to think of a variable as a box that holds some information (a single number, a vector, a string, etc). We use the assignment operator = to assign a value to a variable.
Image modified from: medium.com
{tip}
See the [Python 3 documentation](https://docs.python.org/3/library/stdtypes.html) for a summary of the standard built-in Python datatypes.Common built-in Python data types
| English name | Type name | Type Category | Description | Example |
|---|---|---|---|---|
| integer | int |
Numeric Type | positive/negative whole numbers | 42 |
| floating point number | float |
Numeric Type | real number in decimal form | 3.14159 |
| boolean | bool |
Boolean Values | true or false | True |
| string | str |
Sequence Type | text | "I Can Has Cheezburger?" |
| list | list |
Sequence Type | a collection of objects - mutable & ordered | ['Ali', 'Xinyi', 'Miriam'] |
| tuple | tuple |
Sequence Type | a collection of objects - immutable & ordered | ('Thursday', 6, 9, 2018) |
| dictionary | dict |
Mapping Type | mapping of key-value pairs | {'name':'DSCI', 'code':511, 'credits':2} |
| none | NoneType |
Null Object | represents no value | None |
There are three distinct numeric types: integers, floating point numbers, and complex numbers (not covered here). We can determine the type of an object in Python using type(). We can print the value of the object using print().
x = 42
type(x)
print(x)
In Jupyter/IPython (an interactive version of Python), the last line of a cell will automatically be printed to screen so we don't actually need to explicitly call print().
x # Anything after the pound/hash symbol is a comment and will not be run
pi = 3.14159
pi
type(pi)
Arithmetic Operators
Below is a table of the syntax for common arithmetic operations in Python:
| Operator | Description |
|---|---|
+ |
addition |
- |
subtraction |
* |
multiplication |
/ |
division |
** |
exponentiation |
// |
integer division / floor division |
% |
modulo |
Let's have a go at applying these operators to numeric types and observe the results.
1 + 2 + 3 + 4 + 5 # add
2 * 3.14159 # multiply
2 ** 10 # exponent
Division may produce a different dtype than expected, it will change int to float.
int_2 = 2
type(int_2)
int_2 / int_2 # divison
type(int_2 / int_2)
But the syntax // allows us to do "integer division" (aka "floor division") and retain the int data type, it always rounds down.
101 / 2
101 // 2 # "floor division" - always rounds down
We refer to this as "integer division" or "floor division" because it's like calling int on the result of a division, which rounds down to the nearest integer, or "floors" the result.
int(101 / 2)
The % "modulo" operator gives us the remainder after division.
100 % 2 # "100 mod 2", or the remainder when 100 is divided by 2
101 % 2 # "101 mod 2", or the remainder when 101 is divided by 2
100.5 % 2
x = None
print(x)
type(x)
Strings
Text is stored as a data type called a string. We can think of a string as a sequence of characters.
{tip}
Actually they are a sequence of Unicode code points. Here's a [great blog post](https://www.joelonsoftware.com/2003/10/08/the-absolute-minimum-every-software-developer-absolutely-positively-must-know-about-unicode-and-character-sets-no-excuses/) on Unicode if you're interested.We write strings as characters enclosed with either:
- single quotes, e.g.,
'Hello' - double quotes, e.g.,
"Goodbye"
There's no difference between the two methods, but there are cases where having both is useful (more on that below)! We also have triple double quotes, which are typically used for function documentation (more on that in a later chapter), e.g., """This function adds two numbers""".
my_name = "Tomas Beuzen"
my_name
type(my_name)
course = 'DSCI 511'
course
type(course)
If the string contains a quotation or apostrophe, we can use a combination of single and double quotes to define the string.
sentence = "It's a rainy day."
sentence
type(sentence)
quote = 'Donald Knuth: "Premature optimization is the root of all evil."'
quote
the_truth = True
the_truth
type(the_truth)
lies = False
lies
type(lies)
Comparison Operators
We can compare objects using comparison operators, and we'll get back a Boolean result:
| Operator | Description |
|---|---|
x == y |
is x equal to y? |
x != y |
is x not equal to y? |
x > y |
is x greater than y? |
x >= y |
is x greater than or equal to y? |
x < y |
is x less than y? |
x <= y |
is x less than or equal to y? |
x is y |
is x the same object as y? |
2 < 3
"Deep learning" == "Solve all the world's problems"
2 != "2"
2 is 2
2 == 2.0
True and True
True and False
True or False
False or False
("Python 2" != "Python 3") and (2 <= 3)
True
not True
not not True
{note}
Python also has [bitwise operators](https://wiki.python.org/moin/BitwiseOperators) like `&` and `|`. Bitwise operators literally compare the bits of two integers. That's beyond the scope of this course but I've included a code snippet below to show you them in action.print(f"Bit representation of the number 5: {5:0b}")
print(f"Bit representation of the number 4: {4:0b}")
print(f" ↓↓↓")
print(f" {5 & 4:0b}")
print(f" ↓ ")
print(f" {5 & 4}")
x = 5.0
type(x)
x = int(5.0)
x
type(x)
x = str(5.0)
x
type(x)
str(5.0) == 5.0
int(5.3)
float("hello")
Lists and tuples allow us to store multiple things ("elements") in a single object. The elements are ordered (we'll explore what that means a little later). We'll start with lists. Lists are defined with square brackets [].
my_list = [1, 2, "THREE", 4, 0.5]
my_list
type(my_list)
Lists can hold any datatype - even other lists!
another_list = [1, "two", [3, 4, "five"], True, None, {"key": "value"}]
another_list
You can get the length of the list with the function len():
len(my_list)
Tuples look similar to lists but have a key difference (they are immutable - but more on that a bit later). They are defined with parentheses ().
today = (1, 2, "THREE", 4, 0.5)
today
type(today)
len(today)
my_list
my_list[0]
my_list[2]
len(my_list)
my_list[5]
We can use negative indices to count backwards from the end of the list.
my_list
my_list[-1]
my_list[-2]
We can use the colon : to access a sub-sequence. This is called "slicing".
my_list[1:3]
Note from the above that the start of the slice is inclusive and the end is exclusive. So my_list[1:3] fetches elements 1 and 2, but not 3.
Strings behave the same as lists and tuples when it comes to indexing and slicing. Remember, we think of them as a sequence of characters.
alphabet = "abcdefghijklmnopqrstuvwxyz"
alphabet[0]
alphabet[-1]
alphabet[-3]
alphabet[:5]
alphabet[12:20]
List Methods
A list is an object and it has methods for interacting with its data. A method is like a function, it performs some operation with the data, but a method differs to a function in that it is defined on the object itself and accessed using a period .. For example, my_list.append(item) appends an item to the end of the list called my_list. You can see the documentation for more list methods.
primes = [2, 3, 5, 7, 11]
primes
len(primes)
primes.append(13)
primes
s = {2, 3, 5, 11}
s
{1, 2, 3} == {3, 2, 1}
[1, 2, 3] == [3, 2, 1]
s.add(2) # does nothing
s
s[0]
Above: throws an error because elements are not ordered and can't be indexing.
names_list = ["Indiana", "Fang", "Linsey"]
names_list
names_list[0] = "Cool guy"
names_list
names_tuple = ("Indiana", "Fang", "Linsey")
names_tuple
names_tuple[0] = "Not cool guy"
Same goes for strings. Once defined we cannot modifiy the characters of the string.
my_name = "Tom"
my_name[-1] = "q"
x = ([1, 2, 3], 5)
x[1] = 7
x
x[0][1] = 4
x
There are various useful string methods in Python.
all_caps = "HOW ARE YOU TODAY?"
all_caps
new_str = all_caps.lower()
new_str
Note that the method lower doesn't change the original string but rather returns a new one.
all_caps
There are many string methods. Check out the documentation.
all_caps.split()
all_caps.count("O")
One can explicitly cast a string to a list:
caps_list = list(all_caps)
caps_list
"".join(caps_list)
"-".join(caps_list)
We can also chain multiple methods together (more on this when we get to NumPy and Pandas in later chapters):
"".join(caps_list).lower().split(" ")
String formatting
Python has ways of creating strings by "filling in the blanks" and formatting them nicely. This is helpful for when you want to print statements that include variables or statements. There are a few ways of doing this but I use and recommend f-strings which were introduced in Python 3.6. All you need to do is put the letter "f" out the front of your string and then you can include variables with curly-bracket notation {}.
name = "Newborn Baby"
age = 4 / 12
day = 10
month = 6
year = 2020
template_new = f"Hello, my name is {name}. I am {age:.2f} years old. I was born {day}/{month:02}/{year}."
template_new
{note} Notes require **no** arguments,
In the code above, the notation after the colon in my curly braces is for formatting. For example, `:.2f` means, print this variable with 2 decimal places. See format code options [here](https://docs.python.org/3.4/library/string.html#format-specification-mini-language).
A dictionary is a mapping between key-values pairs and is defined with curly-brackets:
house = {
"bedrooms": 3,
"bathrooms": 2,
"city": "Vancouver",
"price": 2499999,
"date_sold": (1, 3, 2015),
}
condo = {
"bedrooms": 2,
"bathrooms": 1,
"city": "Burnaby",
"price": 699999,
"date_sold": (27, 8, 2011),
}
We can access a specific field of a dictionary with square brackets:
house["price"]
condo["city"]
We can also edit dictionaries (they are mutable):
condo["price"] = 5 # price already in the dict
condo
condo["flooring"] = "wood"
condo
We can also delete fields entirely (though I rarely use this):
del condo["city"]
condo
And we can easily add fields:
condo[5] = 443345
condo
Keys may be any immutable data type, even a tuple!
condo[(1, 2, 3)] = 777
condo
You'll get an error if you try to access a non-existent key:
condo["not-here"]
Sometimes you'll want to create empty objects that will be filled later on.
lst = list() # empty list
lst
lst = [] # empty list
lst
There's no real difference between the two methods above, [] is apparently marginally faster...
tup = tuple() # empty tuple
tup
tup = () # empty tuple
tup
dic = dict() # empty dict
dic
dic = {} # empty dict
dic
st = set() # empty set
st
Conditional statements allow us to write programs where only certain blocks of code are executed depending on the state of the program. Let's look at some examples and take note of the keywords, syntax and indentation.
name = "Tom"
if name.lower() == "tom":
print("That's my name too!")
elif name.lower() == "santa":
print("That's a funny name.")
else:
print(f"Hello {name}! That's a cool name!")
print("Nice to meet you!")
The main points to notice:
- Use keywords
if,elifandelse - The colon
:ends each conditional expression - Indentation (by 4 empty space) defines code blocks
- In an
ifstatement, the first block whose conditional statement returnsTrueis executed and the program exits theifblock -
ifstatements don't necessarily needeliforelse -
eliflets us check several conditions -
elselets us evaluate a default block if all other conditions areFalse - the end of the entire
ifstatement is where the indentation returns to the same level as the firstifkeyword
If statements can also be nested inside of one another:
name = "Super Tom"
if name.lower() == "tom":
print("That's my name too!")
elif name.lower() == "santa":
print("That's a funny name.")
else:
print(f"Hello {name}! That's a cool name.")
if name.lower().startswith("super"):
print("Do you really have superpowers?")
print("Nice to meet you!")
We can write simple if statements "inline", i.e., in a single line, for simplicity.
words = ["the", "list", "of", "words"]
x = "long list" if len(words) > 10 else "short list"
x
if len(words) > 10:
x = "long list"
else:
x = "short list"
x
Any object can be tested for "truth" in Python, for use in if and while (next chapter) statements.
-
Truevalues: all objects returnTrueunless they are aboolobject with valueFalseor havelen()== 0 -
Falsevalues:None,False,0, empty sequences and collections:'',(),[],{},set()
{tip}
Read more in the [docs here](https://docs.python.org/3/library/stdtypes.html#truth-value-testing).x = 1
if x:
print("I'm truthy!")
else:
print("I'm falsey!")
x = False
if x:
print("I'm truthy!")
else:
print("I'm falsey!")
x = []
if x:
print("I'm truthy!")
else:
print("I'm falsey!")
Python supports a concept known as "short-circuting". This is the automatic stopping of the execution of boolean operation if the truth value of expression has already been determined.
fake_variable # not defined
True or fake_variable
True and fake_variable
False and fake_variable
| Expression | Result | Detail |
|---|---|---|
| A or B | If A is True then A else B |
B only executed if A is False
|
| A and B | If A is False then A else B |
B only executed if A is True
|