A cheat sheet for the basic syntax and constructs of Python 3. It includes basic IO, conditionals, collections, functions, classes, modules and packages.


  • Python uses indentation to mark code blocks

Basic IO

  • input() and output() functions are used to handle basic IO (input and output)
  • String interpolation: add f before string opening quote and surround a variable or an expression with curly brackets {}
    name = input("Hello World! What is your name?\n")
    welcome_message = f"Hello, {name} !"

Basic Types

Numeric types

  • We have our usual suspect operators +, -, *, / and %. We use ** for exponents
  • We have some basic functions to apply on numbers abs, round. However, if we want to go fancy, we can import the math module


  • Logical Operators and, or and not
  • Comparison Operators ==, !=, <, >, <= and >=


  • We can use either Single quote ' or double quotes " to surround a string literals.
  • We use triple single quotes ''' or double quotes """ for multiline strings
import datetime
birth_year = input("What is your birth year?\n")
now = datetime.datetime.now()
age = int(now.year) - int(birth_year)
age_message = f"You are, {age}  years old!"

Useful String Methods

  • Case manipulation: upper(), lower(), title()
  • Finding index: find() which returns -1 if element is not found


if Statment

temperature = int(input("What is the temperature today?\n"))
if temperature < 15:
    print("It is freezing")
elif temperature > 25:
    print("It is getting hot in here")



i = 0
while i < 2:
    i += 1


for element in [1, 2]:

loop keywords

  • break



  • We create a range using range() function
    • range(stop) creates a range from zero to the number stop, excluding the stop number
    • range(start, stop, step) creates a range from start to stop, excluding stop. step will be 1 if omitted


  • Create a list using square brackets l = ["a", "b", "c"]
  • access elements of the list by supplying index to square brackets a = l[0]
  • We can use negative index to access the elements counting from the end, d = l[-1]
  • we can use sequence operations to get a sub-list
    • ab = l[0:2] a list includes all the elements from index 0 to 1, the result doesn’t include the closing index
    • ab = l[:2] The start index can be omitted
    • cd = l[1:] The end index can be omitted
    • ab = l[:-1] We can still use negative values for index, note that the value at the last index will still be excluded
  • To check if an item exists in a collection, we can use the keyword in which returns a boolean. 1 in [1, 2, 3] will result in true
  • Useful functions
    • len() find list length
  • Useful methods
    • index(item), which will show error if the item doesn’t exist
    • append(item), insert(index, item)
    • remove(item), clear()
    • pop()
    • sort()
    • reverse()
    • copy()

      Unpacking Lists

      x, y, z = [1, 2, 3]


  • Tuples are immutable
  • We use parenthesis () to define a new tuple
  • We can access items via square brackets the same way we did for lists

Unpacking Tuples

x, y, z = (1, 2, 3)

Dictionaries (Maps)

  • We use curly braces {} to define a dictionary {"a": a, "b":b}
  • We get the value using square brackets [] that is d["a"], which will return an error if the key doesn’t exist
  • We can use the get(key) method, which will return None if the key doesn’t exist. None is an object that represents the absence of a value
  • get(key, default) will return the default value if a value doesn’t exist

Useful methods

  • values() return a list of the values in the dictionary. Useful for iterating over the dictionary values
  • items() return a list of tuples, each of which is one of the key-value pairs in the dictionary keys and values


  • Functions must be declared before the scope in which they are used
  • def is the keyword to define a function
    def calculate_age(birth_year):
      now = datetime.datetime.now()
      return calculate_years_between(now.year, birth_year)
  • A function will return None if no return is present


Let’s look at this example

def concatenate(s1, s2=""):
    return s1 + s2
  • The function concatenate has two parameters s1 and s2
  • s2 has a default value of an empty string. We can apply this function concatenate("hello") and it would not complain of a missing argument.
  • Parameters that have default values must come after those that do not have default parameters
  • We can use keyword arguments and not care for the order of the parameters (as compared to positional arguments) concatenate(s2="world", s1="hello)
  • Keyword arguments must come after positional arguments

    Variadic Parameters

  • A variadic parameter is a parameter that may map to one or more arguments
  • We add an * before the argument name to indicate a variadic parameter def myFun(*argv):
    def concatenate(*strings):
      result = ""
      for string in strings:
          result += string
      return result
  • We can call the concatenate method mentioned above, with any number of arguments, and those arguments would be bound to the list strings: concatenate("a", "b", "c")

Variadic Keyword Parameters

  • We prefix the parameter name with ** to indicate that it is variadic keyword parameter.
  • We can bind any number of named arguments, or key-value pairs of arguments to a keyword parameter
    def concatenate(**kwargs):
      return kwargs["s1"] + kwargs["s2"]
    print(concatenate(s1="a", s2="b"))  # prints `ab`
  • The same function could have been written as
    def concatenate(**kwargs):
      result = ""
      for value in kwargs.values():
          result += value
      return result


Class Declaration

class User:
    def __init__(self, name, year_of_birth):
        self.name = name
        self.year_of_birth = year_of_birth

    def age(self):
        now = datetime.datetime.now()
        return int(now.year) - int(self.year_of_birth)

Object Instantiation

name = input("Hello! What is your name?\n")
year_of_birth = input("What is your birth year?\n")
user = User(name, year_of_birth)

welcome_message = f"Hello, {user.name} !"
age_message = f"You are, {user.age()}  years old!"

Modules and Packages

  • A module is represented by a file
  • A package is represented by a directory with a special __init__.py file in it. That file can be empty
  • Logically, packages contain modules
  • We use import to import modules which may be in the same or in another package
    • We can import the whole module via import package_name.module_name, in that case we will need to use the fully qualified name to call any construct imported from that module package_name.module_name.function_name() for example
    • We can import specific construct form a module from package_name.module_name import some_construct. Here we can call the construct directly without needing to qualify it