Cheatsheets / Learn Python 3

Python: Code Challenges (Optional)

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

  # Expression evaluates to False

the if statement.

  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
"Yes" and 100     # Evaluates to True
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 differs 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
  print("You have a cat.")
following an initial if to perform a series of checks.
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
val2 = 20
evaluated to a value of True or False before the
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 first list’s items coming first. 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',

confused with returning an entirely new list with the
'tulips']
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']
defining 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',
'Andy' is found at index 2 . 'Novak']

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 defined using parameters. def write_a_book(character, setting,
Parameters are variables that are defined in the special_skill):
function definition.
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 definition defines parameters

for a character, a setting, and a skill, which are used as

inputs to write the first 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,
a pencil case, functions may also need more than one pencil_case):
input to carry out their operations.   if (backpack == 'full' and pencil_case
To define a function with multiple parameters, == 'full'):
parameter names are placed one after another,
    print ("I'm ready for school!")
separated by commas, within the parentheses of the
function definition.

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
same level. A Python function is one type of code blocks
block. All code under a function declaration should be

indented to identify it as part of the function. There can

def testfunction(number):
be additional indentation within a function to handle

  # This code is part of testfunction

other statements such as for and if so long as the

  print("Inside the testfunction")

lines are not indented less than the first line of the

  sum = 0
function code.

  for x in range(number):

    # 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,
function is called, these values are passed in as cost):
arguments.

  print(grocery_store + " is selling "

For example, the arguments passed into the function + item_on_sale + " for " + cost)
.sales() are the “The Farmer’s Market”, “toothpaste”,

and “$1” which correspond to the parameters

sales("The Farmer’s Market",

grocery_store , item_on_sale , and cost .
"toothpaste", "$1")

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 or not.
year."

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 defined as part
my_function(7)
of the definition of my_function , and therefore can
only be accessed within my_function . Attempting to
# Causes an error as `value` no longer
print the contents of value from outside the function
exists
causes an error.
print(value)