Cheatsheets / Learn Python 3

Python: Code Challenges (Optional)

Handling Exceptions in Python
A try and except block can be used to handle error
in code block. Code which may raise an error can be def check_leap_year(year):
written in the try block. During execution, if that code   is_leap_year = False
block raises an error, the rest of the try block will   if year % 4 == 0:
cease executing and the except code block will
    is_leap_year = True
execute.

try:
  check_leap_year(2018)
  print(is_leap_year)
  # The variable is_leap_year is declared
inside the function
except:
  print('Your code raised an error!')

or Operator
The Python or operator combines two Boolean
expressions and evaluates to True if at least one of the True or True      # Evaluates to True
expressions returns True . Otherwise, if both True or False     # Evaluates to True
expressions are False , then the entire expression False or False    # Evaluates to False
evaluates to False .
1 < 2 or 3 < 1    # Evaluates to True
3 < 1 or 1 > 6    # Evaluates to False
1 == 1 or 1 < 2   # Evaluates to True

Comparison Operators
In Python, relational operators compare two values or
expressions. The most common ones are: a = 2
b = 3
● < less than
a < b  # evaluates to True
● > greater than a > b  # evaluates to False
● <= less than or equal to a >= b # evaluates to False
a <= b # evaluates to True
● >= greater than or equal too
a <= a # evaluates to True
If the relation is sound, then the entire expression will
evaluate to True . If not, the expression evaluates to
False .
if Statement
The Python if statement is used to determine the
execution of code based on the evaluation of a Boolean # if Statement
expression.
test_value = 100
● If the if statement expression evaluates to
True , then the indented code following the
if test_value > 1:
statement is executed.
  # Expression evaluates to True
● If the expression evaluates to False then the
  print("This code is executed!")
indented code following the if statement is
skipped and the program executes the next line
if test_value > 1000:
of code which is indented at the same level as
the if statement.   # Expression evaluates to False
  print("This code is NOT executed!")

print("Program continues at this point.")

else Statement
The Python else statement provides alternate code to
execute if the expression in an if statement evaluates # else Statement
to False .
The indented code for the if statement is executed if test_value = 50
the expression evaluates to True . The indented code
immediately following the else is executed only if the
if test_value < 1:
expression evaluates to False . To mark the end of the
  print("Value is < 1")
else block, the code must be unindented to the same
else:
level as the starting if line.
  print("Value is >= 1")

test_string = "VALID"

if test_string == "NOT_VALID":
  print("String equals NOT_VALID")
else:
  print("String equals something else!")

and Operator
The Python and operator performs a Boolean
comparison between two Boolean values, variables, or True and True     # Evaluates to True
expressions. If both sides of the operator evaluate to True and False    # Evaluates to False
True then the and operator returns True . If either False and False   # Evaluates to False
side (or both sides) evaluates to False , then the and
1 == 1 and 1 < 2  # Evaluates to True
operator returns False . A non-Boolean value (or
1 < 2 and 3 < 1   # Evaluates to False
variable that stores a value) will always evaluate to True
"Yes" and 100     # Evaluates to True
when used with the and operator.
elif Statement
The Python elif statement allows for continued
checks to be performed after an initial if statement. # elif Statement
An elif statement di ers from the else statement
because another expression is provided to be checked, pet_type = "fish"
just as with the initial if statement.
If the expression is True , the indented code following
if pet_type == "dog":
the elif is executed. If the expression evaluates to
  print("You have a dog.")
False , the code can continue to an optional else
elif pet_type == "cat":
statement. Multiple elif statements can be used
following an initial if to perform a series of checks.   print("You have a cat.")
Once an elif expression evaluates to True , no elif pet_type == "fish":
further elif statements are executed.   # this is performed
  print("You have a fish")
else:
  print("Not sure!")

Equal Operator ==
The equal operator, == , is used to compare two
values, variables or expressions to determine if they are # Equal operator
the same.
If the values being compared are the same, the if 'Yes' == 'Yes':
operator returns True , otherwise it returns False .
  # evaluates to True
The operator takes the data type into account when
  print('They are equal')
making the comparison, so a string value of "2" is not
considered the same as a numeric value of 2 .
if (2 > 1) == (5 < 10):
  # evaluates to True
  print('Both expressions give the same
result')

c = '2'
d = 2

if c == d:
  print('They are equal')
else:
  print('They are not equal')
Not Equals Operator !=
The Python not equals operator, != , is used to
compare two values, variables or expressions to # Not Equals Operator
determine if they are NOT the same. If they are NOT the
same, the operator returns True . If they are the same, if "Yes" != "No":
then it returns False .
  # evaluates to True
The operator takes the data type into account when
  print("They are NOT equal")
making the comparison so a value of 10 would NOT be
equal to the string value "10" and the operator would
val1 = 10
return True . If expressions are used, then they are
evaluated to a value of True or False before the val2 = 20
comparison is made by the operator.
if val1 != val2:
  print("They are NOT equal")

if (10 > 1) != (10 > 1000):

  # True != False
  print("They are NOT equal")

List Method .count()

The .count() Python list method searches a list for
whatever search term it receives as an argument, then backpack = ['pencil', 'pen', 'notebook',
returns the number of matching entries found. 'textbook', 'pen', 'highlighter', 'pen']
numPen = backpack.count('pen')

print(numPen)
# Output: 3

Adding Lists Together

In Python, lists can be added to each other using the
plus symbol + . As shown in the code block, this will items = ['cake', 'cookie', 'bread']
result in a new list containing the same items in the total_items = items + ['biscuit', 'tart']
same order with the rst list’s items coming rst. print(total_items)
Note: This will not work for adding one item at a time # Result: ['cake', 'cookie', 'bread',
(use .append() method). In order to add one item,
'biscuit', 'tart']
create a new list with a single value and then use the
plus symbol to add the list.

Determining List Length with len()

The Python len() function can be used to determine
the number of items found in the list it accepts as an knapsack = [2, 4, 3, 7, 10]
argument. size = len(knapsack)
print(size)
# Output: 5
List Method .append()
In Python, you can add values to the end of a list using
the .append() method. This will place the object orders = ['daisies', 'periwinkle']
passed in as a new element at the very end of the list. orders.append('tulips')
Printing the list afterwards will visually show the print(orders)
appended value. This .append() method is not to be # Result: ['daisies', 'periwinkle', 'tulips']
confused with returning an entirely new list with the
passed object.

List Indices
Python list elements are ordered by index, a number
referring to their placement in the list. List indices start berries = ["blueberry", "cranberry",
at 0 and increment by one. "raspberry"]
To access a list element by index, square bracket
notation is used: list[index] .
berries[0]   # "blueberry"
berries[2]   # "raspberry"

Negative List Indices

Negative indices for lists in Python can be used to
reference elements in relation to the end of a list. This soups = ['minestrone', 'lentil', 'pho',
can be used to access single list elements or as part of 'laksa']
de ning a list range. For instance: soups[-1]   # 'laksa'
soups[-3:]  # 'lentil', 'pho', 'laksa'
● To select the last element, my_list[-1] .
soups[:-2]  # 'minestrone', 'lentil'
● To select the last three elements, my_list[-3:] .

● To select everything except the last two

elements, my_list[:-2] .

sorted() Function
The Python sorted() function accepts a list as an
argument, and will return a new, sorted list containing unsortedList = [4, 2, 1, 3]
the same elements as the original. Numerical lists will sortedList = sorted(unsortedList)
be sorted in ascending order, and lists of Strings will be print(sortedList)
sorted into alphabetical order. It does not modify the # Output: [1, 2, 3, 4]
original, unsorted list.

Zero-Indexing
In Python, list index begins at zero and ends at the
length of the list minus one. For example, in this list, names = ['Roger', 'Rafael', 'Andy', 'Novak']
'Andy' is found at index 2 .
List Slicing
A slice, or sub-list of Python list elements can be
selected from a list using a colon-separated starting tools = ['pen', 'hammer', 'lever']
and ending point. tools_slice = tools[1:3] # ['hammer',
The syntax pattern is myList[START_NUMBER:END_NUMBER] . 'lever']
The slice will include the START_NUMBER index, and tools_slice[0] = 'nail'
everything until but excluding the END_NUMBER item.
When slicing a list, a new list is returned, so if the slice
# Original list is unaltered:
is saved and then altered, the original list remains the
print(tools) # ['pen', 'hammer', 'lever']
same.

Function Parameters
Sometimes functions require input to provide data for
their code. This input is de ned using parameters. def write_a_book(character, setting,
Parameters are variables that are de ned in the special_skill):
function de nition. They are assigned the values which   print(character + " is in " + 
were passed as arguments when the function was         setting + " practicing her " + 
called, elsewhere in the code.
        special_skill)
For example, the function de nition de nes parameters
for a character, a setting, and a skill, which are used as
inputs to write the rst sentence of a book.

Multiple Parameters
Python functions can have multiple parameters. Just as
you wouldn’t go to school without both a backpack and def ready_for_school(backpack, pencil_case):
a pencil case, functions may also need more than one   if (backpack == 'full' and pencil_case ==
input to carry out their operations. 'full'):
To de ne a function with multiple parameters,     print ("I'm ready for school!")
parameter names are placed one after another,
separated by commas, within the parentheses of the
function de nition.

Function Indentation
Python uses indentation to identify blocks of code.
Code within the same block should be indented at the # Indentation is used to identify code blocks
same level. A Python function is one type of code
block. All code under a function declaration should be def testfunction(number):
indented to identify it as part of the function. There can   # This code is part of testfunction
be additional indentation within a function to handle
  print("Inside the testfunction")
other statements such as for and if so long as the
  sum = 0
lines are not indented less than the rst line of the
  for x in range(number):
function code.
    # More indentation because 'for' has
a code block
    # but still part of he function
    sum += x
  return sum
print("This is not part of testfunction")
Function Arguments
Parameters in python are variables — placeholders for
the actual values the function needs. When the def sales(grocery_store, item_on_sale, cost):
function is called, these values are passed in as   print(grocery_store + " is selling "
arguments. + item_on_sale + " for " + cost)
For example, the arguments passed into the function
.sales() are the “The Farmer’s Market”, “toothpaste”,
sales("The Farmer’s Market", "toothpaste",
and “$1” which correspond to the parameters
"$1")
grocery_store , item_on_sale , and cost .

Returning Value from Function

A return keyword is used to return a value from a
Python function. The value returned from a function def check_leap_year(year):
can be assigned to a variable which can then be used in   if year % 4 == 0:
the program.     return str(year) + " is a leap year."
In the example, the function check_leap_year returns a   else:
string which indicates if the passed parameter is a leap
    return str(year) + " is not a leap year."
year or not.

year_to_check = 2018
returned_value
= check_leap_year(year_to_check)
print(returned_value) # 2018 is not a leap
year.

Parameters as Local Variables

Function parameters behave identically to a function’s
local variables. They are initialized with the values def my_function(value):
passed into the function when it was called.   print(value)   
Like local variables, parameters cannot be referenced   
from outside the scope of the function. # Pass the value 7 into the function
In the example, the parameter value is de ned as part
my_function(7)
of the de nition of my_function , and therefore can only
be accessed within my_function . Attempting to print the
# Causes an error as `value` no longer exists
contents of value from outside the function causes an
error. print(value)