Terminology

• Code Reuse
  • A single copy of code can be used elsewhere
  • Basis of any library
  • Important for maintenance
  • Function names should state what the function does or what it returns
• Scope (local, global)
  • Region of code in which a name is known (or visible) and accessible
  • In scope/ out of scope
  • Python blocks do not create a new scope
  • Modules, classes, and functions do
  • Don't use global variables; for constants: chose names that indicate globals (all caps)
• Case sensitivity
• Argument - a value passed to a function in which it is accessed through a parameter
  • default parameters
  • positional arguments
  • keyword arguments
  • eg. print(s, ..., sep=' ', end='\n', file=sys.stdout, flush=False)
• Return value - a function can offer (return) its result to the caller
  • eg. total = min(12, 5, 7)
• DRY – Don't Repeat Yourself
  • Fundamental programming principle
  • Every piece of knowledge in a system should have a single representation
  • Formulated by Andy Hunt and Dave Thomas in "The Pragmatic Programmer"
  • Duplication is waste (=> maintenance!!)
  • There should be only one obvious and painless way to accomplish a task
  • Steve Smith in [Henney (2010), p. 60f]
• Method
  • Function associated with data of a given type (class or object)
  • Function:
    min(3, 4, 2)
  • Method:
    a_string = 'Python'; a_string.upper()
  • Function or Method?
    text = 'a,b,c'; text.split(',')
• Python standard library functions, methods and modules

Functions

• Snippets of code usable from the rest of the program
• Separate out common actions (examples!)
• Functions package up and parameterize functionality
• Avoid code duplication and allow reusing code
• Code becomes easier to read

  # ...delta_x, delta_y are defined
  delta_x2 = delta_x * delta_x
  delta_y2 = delta_y * delta_y
  distance = math.sqrt(delta_x2 + delta_y2)
  # vs.
  import math
  distance = math.hypot(delta_x, delta_y)
  

• Maintenance becomes easier
• kloc/ sloc is a dangerous metric

Python Functions

• Functions/ methods we already know
  • print(.), open(.), min(.), ...
  • string.upper(), string.split(.), ...
  • math.sqrt(.), math.hypot(.), ...
• Docstrings
• Creating Python functions

  def name(arg1, arg2, ..., argN):
      """
      Textual explanation of what the function is supposed to do.
      """
      # calculate result...
      return result
  

• Default parameters

  def power(base, exp=2):
      return base ** exp
  

• Defining and using a function

• #!/usr/bin/env python3
  
  def interest(capital, rate, years=1):
      """
      Return the total interest of investing `capital` at `rate`.
      """
      value = capital * (1 + rate) ** years
      return value - capital
  
  print(interest(100, 0.03))
  result = interest(100, 0.03, 3)
  profit = interest(1300, 0.025, 5)
  

• Python 3 Video Tutorial - Functions

More on Python Functions

• Python passes references to objects
  • No need to worry when passing immutable objects

• Object references

• #!/usr/bin/env python3
  
  def print_uppercase(text):
      """
      Print the passed text as upper case.
      """
      print(text.upper())
  
  a_text = "Programming is fun!"
  result = print_uppercase(a_text)
  
  
  def print_sorted_list(l):
      l.sort()
      print(l)
  
  a_list = [5, 3, 7, 1, 4]
  another_result = print_sorted_list(a_list)
  

• Keyword arguments

• #!/usr/bin/env python3
  
  def interest(capital=1000, rate=0.04, years=1):
      """
      Return the total interest of investing `capital` at `rate`.
      """
      value = capital * (1 + rate) ** years
      return value - capital
  
  print(interest(100, 0.03))
  profit = interest(capital=1300, rate=0.025, years=5)
  profit = interest(years=5)
  profit = interest(1300, years=5)
  result = interest(1000 + interest(rate=0.06), 0.03, 3)
  

• Define functions before using them
  • Best practice is to avoid regular code in the global scope
  • Use "ifmain" at the end to call the main function
  • Allows re-use of entire file

  if __name__ == "__main__":
      sys.exit(main())
  

• Lambda (unnamed) functions

• #!/usr/bin/env python3
  
  """
  Lambda functions are expressions that can be created at their point of use.
  
  They are limited in comparison to regular functions, but useful as arguments,
  e.g. for sorting.
  """
  
  interest = lambda c, r, y: c * (1 + r) ** y - c
  
  print(interest(100, 0.03, 1))
  result = interest(100, 0.03, 3)
  profit = interest(1300, 0.025, 5)
  
  a_list = [3, 4, 19, 11, 1, 4, 6, 8, 5, 2, 0, 12, 13, 3]
  a_list.sort(key=lambda x: x % 3)  # sort by remainder of division by 3
  print(a_list)
  

• Method chaining
  • instead of sin(sqrt(12)) method chaining is done using
  • text.upper().split()

Pair programming

• Definition
  • Agile software development technique
  • Two programmers work together at one workstation
  • One (the driver) writes code; the other (the navigator) reviews each line as it is typed
  • The two programmers switch roles frequently
• Motivations
  • Pairing contributes to flow
  • Skills and knowledge are distributed
  • A task doesn't need to be completed before rotating teams
  • Reduces truck/ bus factor (also in the interest of the employee)
  • Gives partners to discuss problems
  • Code quality is improved (Having enough eyes, all bugs seem shallow. – Linus Torvalds)
  • Mitigates interruptions (keeps the flow)
  • New team members get to know other team members

  • ---

    Gudny Hauknes et. al. in [Henney (2010), pg 128f]
• Rules for pair programming
  • Be patient with developers less experienced than you (explaining improves your own understanding!)
  • Frequent rotation of pairs is crucial (use agreed rule of rotation)
  • Adjust the rotation rule when necessary

  • ---

    Gudny Hauknes et. al. in [Henney (2010), pg 128f]