Variables
Used to store data/information so that it can easily be repeated or reused throughout the code
In Python variable are used for things that are subject to change
Primitive data
The most basic forms of data:
Strings
Boolean (defined in Python as true or false (1 or 0))
Number
Operators
Different symbols that represent an operation
Enable us to process data and transform it
Arithmetic operators - make calculations
Comparison operators - determine the relationship between two values resulting in a Boolean
Logical operators - determine the logical state of multiple Boolean values or expressions resulting in another Boolean
Functions
Used in coding lots they are sequences of instructions that perform specific tasks
The inputs are called parameters
The actual values for each input are called arguments
Lists
Order items so that they’re in a specific sequence
The position of a value in a list is called its index
Adding things to the end of an existing list is called appending them to the end
Print statement
Used in Python to get the computer to ‘say’ something
e.g. print “Hello, world” makes the computer display that
Mismatched quotation marks will cause an error
Python 3 also requires brackets
Modulo operator
Indicated by %
It returns the remainder after a division is performed
Comments
Pieces of information used to describe the code
Use a # followed by the comment
Multi line strings
Use triple quotation marks
Converting between data types
Use str() for converting to a string
Use int() to convert to a numeric data type
float() to make it a decimal
len()
Determines the length of a string
“Ryan”.lower()
“Ryan”.upper()
Makes all the letters in the string lowercase
So this would give ryan
Makes all the letters in the string uppercase
str()
Turns non-strings into strings
E.g. 2 to “2”
% operator
Used to combine strings with variable
The % variable will replace the %s in the string
Boolean operators order
Not
And
Or
Lists
come in these brackets []
to choose an item from a list use its index - remember to count from 0 (positive indexing)
can also choose negative indexing, but this is rarely used only for long lists (the last item had an index -1, the next one -2 and so on)
list slicing - use a colon to access a few items in the list e.g. [1:9] will access index 1 to 8 of the list (the last index is discluded)
e.g.
will = [jalksjfl, fslakdjf, fjlaj]
they can have mixed data types
if you have a list within a list, rather than accessing and then saving as a variable you can chain indices to access something
Dictionary
similar to a list but has ‘keys’ instead of indices and the contents are in { }
they come in the form key : value
to retrieve a value from a list you use the same form as lists
dictionary values can be of any data type whilst dictionary keys can be of any except lists and dictionaries
What two rules must be adhered to when naming variables?
Variable names cannot start with a number
We must only use letters, numbers or underscores
concatenation
The process of linking two or more strings together, usually involving the str() function
open()
reader()
list()
used to open files
used to read files (must be imported from the csv module)
transforms files into lists
For loops
Consist of an iteration variable, an iterable variable and a body
The indented code in the body gets repeated as many times as there are elements in the iterable variable
each time the code in the loop is executed its called an iteration
Comparison operators
== An operator used to describe/determine if two values are equal
The result is either true or false (boolean)
!= An operator used to describe/ determine if two values aren’t equal
there are also > < >= and <=
type()
Used to determine the data type of whatever is found between the brackets
If statements
Conditional statements that usually involve some sort of comparison
They must be followed by a boolean value or an expression that evaluates to a boolean value
logical operators : and or
these are added to the if statements to add more conditions
How does python use multiple booleans?
It combines them to a single boolean
when using and : will only be true if all the individual booleans are true
when using or : will only be false if all the individual booleans are false
else
Only executed if the if statement preceding it is false
Compound statement
When an if statement is combined with an else clause
elif
used within an if statement
it is only executed if the preceding clauses (e.g. if or elif)
resolve to false and the elif condition resolves to true
improves efficiency as it means the computer doesn’t iterate over redundant code
adding values to an empty dictionary
takes the form dictionary_name[index] = value
Why can’t dictionaries and lists be keys?
hash() python uses this to try and convert each dictionary key to an integer even if its not that type
the hash command doesn’t transform lists and dictionaries to integers hence lists and dictionaries can’t be keys
in operator
used to determine if certain keys exist within a dictionary
or used in loops
min()
max()
used to determine the minimum and maximum values
How does the len() function work
Imagine we have a list - list = [1, 2, 3, 4, 5]
if we use a loop and a variable called length we can manually determine the length:
length = 0
for value in list:
length += 1
This would give us an output of 5 and that is effectively how the len() function works
How does the sum function work?
Imagine we have: list = [1, 2, 4, 5, 64]
sum_manual = 0
for value in list:
sum_manual += value
This is effectively what the sum function does
Built-in functions
These are functions which pre-exist and can be readily used with python e.g. len() sum()
But python also allows us to build our own functions
How we make functions?
e.g. to make a function to square numbers:
def square(a_number):
squared_number = a_number * a_number
return squared_number to find the square of 6 we would then use square(a_number = 6) or we could use square(6)
Input variables like a_number are known as parameters, whereas 6 is known as the argument - the parameter a_number took in 6 as an argument
we start with a def statement to introduce defining the function
we specify the name of the variable that will serve as an input and then show what we want to do with that input
The definition of a function
The three elements that make up the definition are:
The def statement
The body
The return statement
Keyword arguments
When inputting the argument into the function the order doesn’t matter
e.g. subtract(a, b)
subtract(a=10, b=7) = 3 and subtract(b=7, a=10) = 3
Positional argument
The argument isn’t as clearly defined as keyword arguments so order does matter
e.g. def subtract(a, b):
return a - b
subtract(10, 7) isn’t the same as subtract(7, 10) as we are using positional arguments
Interfering with built in functions
Don’t name your functions the same as built in functions as this could confuse you and will alter the way the function operates
It leads to abnormal function behaviour
You should also avoid naming variables or lists after built in functions
Default arguments
Creating a function with some of the parameters being certain default values
e.g. def add_value(x, constant = 10):
return x + constant
What if we want to produce a function that can be used to produce either the sum of two numbers or the difference between two numbers?
We use multiple return statements with a conditional statement:
def sum_or_difference(a, b, do_sum = true):
if do_sum:
return a + b
else:
return a - bTuple
Another data type very similar to a list
It’s in this form: (9, 0) or this form 9, 0
Used for storing multiple values
Just as lists they support positive and negative indexing
Differences between tuples and lists - existing values can be modified in lists but they can’t in tuples
Functions with multiple outputs
We can have functions that return more than one variable
e.g. a function that returns the difference between two numbers and the sum of two numbers
This returns a tuple
If you put square brackets around the variables in the return statement then this returns a list
Immutable data types
Can’t change their state after they have been created
Booleans Strings Floats Integers Tuples
Mutable data types
Their state can be changed after being created
Lists
Dictionaries
Sets
Scope
The part of the a program where a variable can be accessed
Local scope - variables defined in a function (outside the function such variables would be undefined)
Global scope - variables defined in the main program (global variables)
Functions and temporary memory
Python only has a ‘temporary memory’ for variables used within a function
If such variables are used outside the function they are undefined thus causing an error
str.replace()
A method used to replace part of a string
We substitute str for the variable name of the string we want to modify, then in the brackets we first put the substring we want to replace and then what we want to replace it with
e. g will = ‘my favourite colour is red’
will. replace(‘red’, ‘green’)
This will replace red with green
str.title()
returns the string with the first letter of each word as a capital letter
str is replaced by the variable name of the string
str.split()
Used to split a string in two resulting in a list
The name of the variable replaces str and the point at which the split needs to take place goes in the brackets
e. g. date = ‘2002-2003’
date. split(‘-‘) = [‘2002’, ‘2003’]
Inserting a variable into a string using %
stuff_in_string = “Shepherd %s is %d years old.” % (shepherd, age)
print(stuff_in_string)
Shepherd Martha is 34 years old.
Inserting a variable into a string using the string format method
shepherd = “Mary”
string_in_string = “Shepherd {} is on duty.”.format(shepherd)
print(string_in_string)
Shepherd Mary is on duty.
Recursive functions
Functions that can call themselves
The function will continue to call itself until a base condition is satisfied
If there wasn’t a base condition the function would call itself infinitely
Example of a recursive function - finding factorials
def factorial(x):
if x == 1:
return 1
else:
return (x * factorial(x - 1))The base condition is x == 1 so the function will keep repeatedly calling itself until x == 1
this is how it works, let’s say x = 5:
factorial(5) = 5 * factorial(4) factorial(4) = 4 * factorial(3) factorial(3) = 3 * factorial(2) factorial(2) = 2 * factorial(1) factorial(1) = 1
hence factorial(5) = 5 * 4 * 3 * 2 * 1
Anonymous/ lambda functions
functions that are defined without a name
rather than being defined by def they are instead defined by lambda
Generally used as arguments for higher order functions
syntax is as follows:
lambda arguments : expression
It can have any number of arguments but only one expression
e.g. lambda x : x * 2 # this is a function that will double its input
so double = lambda x : x * 2
double(5) = 10
filter()
This is a higher - order function which takes a function and a list as its arguments and filters the list according to the function
e.g. mylist = [2, 4 ,6, 9]
newlist = list(filter(lambda x : (x%2 == 0), mylist)
newlist = [2, 4, 6]
Why do we use an asterix before an argument of a function? - Python arbitrary arguments
This is used when we do not know the number of arguments we are going to pass through the function in advance
It allows us to use a random number of arguments
docstring
Below the initial header of a function we can use triple quotation marks to produce a string which explains what the function does
This is documentation and it is good programming practice
Use this or comments
global keyword
This is used to make changes to a global variable from within a function
If this keyword is used outside the function then it has no effect
config. py
update. py
A single module used to store global variables
A single module used to change global variables
python modules
A python file containing statements and definitions
Used to break down a large programme into smaller, organised files
We use the import function to import a module and the module.function()
e.g. import example # this imports example.py
example.add(1, 2) #this makes use of the add function already defined in example
Renaming modules in a file
use ‘as’
e.g. import math as m #this renames math to m
Importing specific variables and functions from a module
use ‘from’
e.g. from math import pi #this imports the pi variable from math
or we can import all:
from math import *
dir()
the name of a module is entered in the brackets
this function then returns a list of all the attributes (e.g. functions and variables)
Python packages
A group of similar or related modules, often used for the same project etc
Must contain a init.py file for it to be considered a package even if this is empty
isinstance()
used to identify if an object is in a certain class or type
syntax is like this: isnstance(object, classinfo)
its result is true or false
complex numbers
in the form a + bj
where a is the real part and b is the imaginary part
string slicing
strings can be sliced the same way a list can be sliced
:.2f
This results in a precision of two decimal places
This is used when formatting a string to contain a given number
This must come after the thousands separator if its present
:,
Used when formatting a string to contain a given number
It puts commas for every thousand to make the number easier to read
This must come before the precision
dict.items()
returns a list of the dictionary’s (key, value) tuple pairs
the name of the dictionary replaces dict
Procedural programming
Writing code in a number of sequential steps, sometimes these steps are combined to form functions
Object-oriented programming
Code is designed around objects
In OOP the type of an object is known as its class
Focuses on creating reusable code - this concept is known as DRY (don’t repeat yourself)
Object
An entity which stores data
It combines data and functions
Class
Defines specific properties an object of that class will have
The rules for naming classes are the same as for naming functions and variables
We say two different objects of the same class are two instances of that class
The class can be thought of as a design and the object is the thing that we build using that design
Class definitions
These are like the ‘code blueprints’ for a class
They contain the information needed to create that class
its in the format:
class myclass(): #details of the class go here
similar to defining a function
Snake case
the convention used for naming functions and variables
uses lower case words with underscores like_this
Pascal case
the convention used for naming classes
uses no spaces and capital letters for the start of each word LikeThis
Instantiation
Creating an object of a defined class
‘Instantiate an object of that class’
An instance is a specific object created from a particular class
pass
A keyword that allows us to leave the details of a class empty when defining it, without raising an error
methods
used as part of the definition of a class to allow objects of that class to perform certain actions
can be thought of as special functions that belong to a particular class
methods are created as functions within a class by using indentation
we have to create one of the parameters to be self
attributes
special variables that belong to a particular class
attributes let us store particular values about each instance of the class
data is stored inside objects using attributes
attributes are the characteristics of the objects
__init__() method
This is used to define what is done with arguments provided at instantiation
It runs when an instance is created
It’s most common usage is to store data as a attribute
It’s a constructor that creates variables that contain values for each instance of the class - these values are specific to each instance due to the different arguments
self
The first argument passed to every method, the convention is to call this self as it represents the instance we are calling the function on
This prevents an error occurring
e.g. class MyClass():
def printclass(self):
print(self)mc = MyClass()
mc.printclass()
This will print the object itself - mc
What is a set in python?
Created using the set() function or by placing values in {}
It’s an unordered collection of items with each item being unique (no duplicates) and each item must be immutable
The set itself is mutable it can have elements added or subtracted
It can be used to perform mathematical set operations
How to change a set in python by adding elements?
They are unordered so they don’t support indexing or slicing
set. add() can be used to add individual elements to the set where the name of the set replaces set in this method
set. update() can be used to add multiple elements to the set
Duplicates are avoided
How to subtract elements from a set in python?
Elements can be removed via the set.discard() method and the set.remove() method
The only difference is that if discard is used and the element isn’t in the set it will remain unchanged
However, using remove in this scenario would result in an error
set. pop()
set. clear()
This can be used to add or remove elements from a set but it is completely random as to what element will be removed
All the items of a set can be removed using clear
Finding the union of two sets
Use the union() operator e.g. for union of set A and B
A.union(B)
OR use | e.g. print(A|B)
Finding the intersection of two sets
use the intersection method - e.g. for A intersection with B A.intersection(B)
or use & e.g. print(A & B)
Finding the difference of set A
This is known as the elements that are only in set A but not in B
in python its called the difference of A and B (A - B)
its found using print(A - B) or using the difference method
e.g. A.difference(B)
Set symmetric difference
This is all the elements in sets A and B except those that are common in both
We use the ^ operator or the set.symmetric difference method
Frozensets
These are another class
They are immutable sets and they are created using the frozenset() function
Inheritance
A way of creating a new class using the details of an existing class without modifying it
The child class inherits the functions of the parent class
We use the super() function to help achieve this
e.g, super().__init__() within the brackets of init would be the names of the attributes to be inherited
Polymorphism
The ability in OOP to use a common interface (often a function) that can be used by multiple form (data types/classes)
__Big__O
This is a measure of how long it takes to complete a particular algorithm when scaling it up
Constant time
When a computer performs a task that goes to the end of an array and looks at the last thing - the time taken to do this is independent of the number of items
Linear time O(n)
The time it takes to complete the task is directly proportional to the number of items
O(n^2)
The time it takes to process n items is directly proportional to n^2
This needs to be avoided in algorithms as much as is possible
O(n!)
The time taken to complete the task is directly proportional to n! where n is the number of items
An algorithm of O(n!) is to be avoided at all costs
Arrays
A data type similar to a list in which you can store values only of the same data type
It isn’t a fundamental data type so you have to import the array module
syntax is as follows arrayname = (typecode, [values])
the typecode defines the type of array
you can use indexing and most list methods
Using pandas for opening data
pandas is a software library that can be used to open and display csv files
We use panda.read_csv() to read the file
and filename.describe() to show the data
filename.columns shows the column names
using pandas to remove missing values
use filename.dropna(axis = 0)
re.search() method
This takes in two arguments, a string and a regular expression and it searches the string for the regular expression
e.g. re.search(‘will’, [aeiou])
It either returns match or none
It is usually followed by an if statement
Regular expressions
These are common patterns that we can search for in a string using the re.search() method
listname.sort() method
Used to sort an list
By default the method sorts based on ascending order either alphabetically or numerically
listname.sort(reverse=True) will sort it based on descending order
Linear search
Checks to see if the first item in the list is the item we are looking for, then it checks the third, fourth, fifth etc
It keeps checking until it finds the item we are looking for or until it reaches the end of the list
It’s O(n)
example function to perform a linear search
def linear_search(item, my_list)
i = 0
found = False
while i < len(my_list) and found == False:
if my_list[i] == item:
found = False
else:
i = i + 1
return foundBinary search
Relies on having a sorted list
Starts in the middle and if the item we are looking for is higher then anything lower than the middle is discarded and vice versa if its lower
This is repeated with the bit of the list that’s left - each time the length of the list that is left is halving
This process repeats until the item is found
example of a binary search algorithm
def binary_search(item, my_list):
found = false
first = 0
last = len(my_list) - 1
while first <= last and found == False:
midpoint = (first + last)// 2
if my_list[midpoint] == item:
found = True
else:
if my_list[midpoint] < item:
first = midpoint + 1
else:
last = midpoint - 1
return foundInsertion sort
Takes the second item in the list and compares it to the first item in the list, if it is greater than the first item then it remains where it is but if its smaller we move it before the first item. This process continues except the comparisons have to be with more items as this progresses to ensure it goes in the right location
