Updates

• Assignment 0 has been released! Due Tuesday 9/17 at 11:59PM.
• Expanded late day policy: any additional days an assignment is late is 25% off, up to 2 days.
  • This means you can submit an assignment up to max 4 days late for 50% credit.
• I will have office hours on Wendesdays 1-2pm over Zoom. Check the website for the link.

Agenda

1. Magic Methods
2. Functions
3. Comprehensions
4. Iterators/Generators
5. Lambdas
6. Decorators

Magic Methods

class Person:
  def __init__(self, name):
    self.name = name
  def say_hello(self):
    print(f"Hi my name is {self.name}!")

Magic Methods

• The main use case of magic methods is to enable custom objects to behave like built-in types
• There are ways that we can directly compare custom objects and even do arithmetic with them
• We can even make it so that our objects can behave like sequences!

# you might be familiar with something like
if myObject.equals(otherObject):
  doSomething()
# but using magic methods we can do
if myObject == otherObject:
  doSomething()

# using magic methods we can 
# enable this notation
myObject[1]

Magic Methods

Functions

Positional Arguments & Keyword Arguments

• We can allow for a variable number of arguments to our function using positional arguments or keywork arguments
• Positional arguments can be thought of as a tuple
• Keyword arguments can be thought of as a dictionary with keys of type string
  • We can also use these to set defaults for parameters!

Functions

Positional Arguments

def print_lines(*args):
  for line in args:
    print(line)
# I can "unpack" a list as arguments
my_lines = [1, 2, 3, 4]
print_lines(*my_lines)
# Unpacking is not constrained to functions with positional arguments
def f(x, y):
  print(x + y)
f(*[1,2])

Functions

Keyword Arguments

Consider the following divide function. The arguments are ambiguous! We can solve this with keyword arguments.

def divide(numerator, denominator):
  return numerator/denominator
# divide(10,5) and divide(5,10) could be interpreted in different ways 
# to someone reading our code.
divide(numerator=10, denominator=5)  # no longer ambiguous

Functions

Keyword Arguments

def print_kwargs(**kwargs):
  for key in kwargs:
    print(key, kwargs[key])
  
# I can similarly "unpack" a dictionary as arguments
my_kwargs = {"a": 1, "b": 2}
print_kwargs(*my_kwargs)

Comprehensions

Comprehensions are ways to filter and manipulate sequences elegantly, usually within a single line!

The general syntax for a comprehension is

(expression) for (value) in (sequence) (if condition)

Comprehensions

# list of squares, naive approach
numbers = [1,2,3,4,5]
squares = list()
for n in numbers:
  squares.append(n ** 2)

Comprehensions

# list of squares, naive approach
numbers = [1,2,3,4,5]
squares = list()
for n in numbers:
  squares.append(n ** 2)

numbers = [1,2,3,4,5]
squares = [n ** 2 for n in numbers]
# one-liner
squares = [n ** 2 for n in range(1,6)]
odd_squares = [n ** 2 for n in range(1,6) if n % 2 == 1]

Comprehensions

scores = ['david:90', 'ben:80', 'justin:100']
grades = dict()
for studentscore in scores:
  split = studentscore.split(':')
  name = split[0]
  score = split[1]
  grades[name] = score

Comprehensions

scores = ['david:90', 'ben:80', 'justin:100']
grades = dict()
for studentscore in scores:
  split = studentscore.split(':')
  name = split[0]
  score = split[1]
  grades[name] = score

grades = {s.split(':')[0]: s.split(':')[1] for s in scores}

Iterators

• We just saw how comprehensions can reduce the amount of code we write and make things more succinct, but how do they work under the hood? What kinds of things can we iterate over?
• Any object that implements the magic methods __iter__() and __next__() is considered iterable
  • This is what is known as a protocol in Python, which is very similar to an interface in Java

Iterators

my_list = list()
for item in my_list:
  doSomething(item)
done()

my_list = list()
# calls __iter__
iterator = iter(my_list)
while True:
  try:
    # calls __next__
    item = next(iterator)
  except StopIteration:
    # a `StopIteration` error is 
    # raised when there is nothing
    # left to iterate over
    break
  doSomething(item)
done()

Iterators

import random
class RandomBinaryIterable:
  def __iter__(self):
    return self
  
  def __next__(self):
    roll = random.choice([1, 0, "stop"])
    if roll == "stop":
      raise StopIteration
    return roll

In [3]: list(RandomBinaryIterable())
Out[3]: []
In [4]: list(RandomBinaryIterable())
Out[4]: [1, 0, 0]
In [5]: list(RandomBinaryIterable())
Out[5]: [1, 1, 0, 1, 0]
In [6]: list(RandomBinaryIterable())
Out[6]: [0, 1, 0, 0, 1, 0]

Generators

• Generators are used to lazily build or process a large sequence, typically used to build an iterator
  • These are highly useful in scenarios where you need to process things that cannot fit into memory
• Using the yield keyword allows us to easily build a lazy iterator
• It also saves us from writing boilerplate fairly easily

Generators

def first_n(n):
  i = 0
  nums = list()
  while i < n:
    nums.append(i)
    i += 1
  return nums
my_huge_list = first_n(1000000000)

def first_n(n):
  i = 0
  while i < n:
    yield i
    i += 1

Generators

import random
class RandomBinaryIterable:
  def __iter__(self):
    return self
  
  def __next__(self):
    roll = random.choice([1, 0, "stop"])
    if roll == "stop":
      raise StopIteration
    return roll

import random
def random_binary():
  while True:
    roll = random.choice([1, 0, "stop"])
    if roll == "stop":
      break
    yield roll

Generators

• list() can be passed a generator, which can save some code
• Be aware of when you are working with generators and need to manage memory

# these are equivalent
list(first_n(100))
[for x in first_n(100)]
# but not this!
[first_n(100)]

# returns a generator
first_n(100)
# instantiates the entire list!
list(first_n(100))

Lambdas

• Lambdas are syntatic sugar to help define simple functions
  • These are similar to anonymous functions in other languages
• Importantly, we saw that Python allows us to use functions as arguments, which is where the power of lambdas shines
  • You might remember map and filter from CIS1200, which Python also has

Lambdas

lambda <arguments>: <expression>

# simple increment lambda
lambda x: x + 1
# we can actually call it directly!
(lambda x: x + 1)(1)
# or use it to define a variable
adder = lambda x: x + 1
adder(1)
# lambdas can have multiple arguments
add = lambda x, y: x + y
add(1,2)

Lambdas

Lambdas can help us succinctly write complex logic

names = [("David", "Cao"), ("Ben", "Smith"), ("Justin", "Adam")]
# recall we can sort lists like so
# but this only sorts by the first element
names.sort()
[('Ben', 'Smith'), ('David', 'Cao'), ('Justin', 'Adam')]
# we can use lambdas to customize sorting, e.g. by last name
names.sort(key=lambda x: x[1])
[('Justin', 'Adam'), ('David', 'Cao'), ('Ben', 'Smith')]

Lambdas

# This is equivalent to what we did before, but look
# how much code we saved using lambdas!
names = [("David", "Cao"), ("Ben", "Smith"), ("Justin", "Adam")]
def last_name(x):
  return x[1]
names.sort(key=last_name)

However, they may be scenarios where a lambda does not suffice, e.g. complex logic needed that exceeds a single expression.

Lambdas

Lambdas can also be used in functional ways!

numbers = [1,2,3,4,5,6]
squares = map(lambda x: x ** 2, numbers)
odds = filter(lambda x: x % 2 == 1, numbers)
odd_squares = map(lambda x: x ** 2, filter(lambda x: x % 2 == 1, numbers))

Note: map and filter actually return generators.

Decorators

• Decorators are a fairly complex topic, but we will introduce the basics and revisit them when we begin discussing Django
• We saw that functions are able to be passed as parameters
• Decorators help add general flow control around functions

Decorators

def my_function():
  print("doing some stuff...")
def check(func):
  if True:
    print("check is good!")
    return func
  else:
    raise Exception()
wrapped = check(my_function)

def check(func):
  if True:
    print("check is good!")
    return func
  else:
    raise Exception()
@check
def my_function():
  print("doing some stuff...")

Decorators

• While the decorator we showed looks quite boring, they are useful in many paradigms
• Consider having many functions that all need to check if a user has some specific permission before being able to run