Google Drive
Gist
Clipboard
Week 17 W17D4To import code from a module, we use the import keyword. The import keyword will locate and initialize a module, and give you access to the specific names you have imported in the file.
There are no exports in Python! Anything we define in a module/file is automatically available for import.
import keywordThe Python standard library has a number of packages you can import without having to install them. Let's use the random package as an example (this would work the same with any package).
import random # import everything from random
print(random.randint(0, 10))
Use the as keyword to alias package/object names.
import random as rand # import everything, alias random as rand
print(rand.randint(0, 10))
You can also import specific objects from a package using the from keyword.
from random import randint, shuffle # import multiple functions at the same time
print(randint(0, 10))
If two files are at the same level, import using the filename (without the .py extension).
project_folder
| my_code.py
| other_code.py
# inside my_code.py
import other_code
# import just a specific item
from other_code import my_function
If we need to specify a path to a file, we use dot notation:
# inside my_code.py
from folder.subfolder.filename import something
__init__.pyThis file should go in any directory being imported. It will transform a plain old directory into a Python module/package. It can be completely empty, and often will be!
Upon import from a module/package, its__init__.py file is implicitly executed, and all objects it defines are bound to the module's namespace (documentation).
Python Import Short Practice - 15 min
A decorator is a function that takes in another function as a callback and modifies or extends the behavior of the callback function.
Let's create a decorator that could be used for timing function calls.
from datetime import datetime
# our decorator, which takes in a callback function
def timer(func):
# define the wrapper function that we're going to return
def wrapper():
# get current time before function call
before_time = datetime.now()
# invoke the callback
val = func()
# log the return value of the function
print(val)
# get current time after function call
after_time = datetime.now()
# calculate total time
total = after_time - before_time
# return the total time
return total
# decorator returns the wrapper function object
return wrapper
Using the @decorator_name syntax, we can shorten this:
def my_function():
return "hello"
my_function = timer(my_function)
To this:
@timer
def my_function():
return "hello"
Decorating a function definition (with the @decorator syntax) does the same thing as reassigning the function name to the return value of the decorator.
What if I want to wrap functions that take arguments… but I want to be flexible about what kind of arguments the function takes?
from datetime import datetime
def timer(func):
def wrapper(*args, **kwargs):
before_time = datetime.now()
val = func(*args, **kwargs)
print(val)
after_time = datetime.now()
total = after_time - before_time
return total
return wrapper
@timer
def my_function_args(name):
return f"hello {name}"
@timer
def my_sum(sum1, sum2):
return sum1 + sum2
Decorators Quiz - 5 min (in your howework)
Hello World Decorator - 3 min
Order Decorator - 3 min
Timer Decorator - 10 min
Chain Decorator - 10 min
To create a class we use the class keyword, and by convention, we capitalize the names of classes.
# python example
class Icon:
# more code to come
Python's constructor method is called __init__().
# python example
class Icon:
def __init__(self, color, shape):
self.color = color
self.shape = shape
We create instances of a class by invoking the class as though it is a function (this invokes the class's __init__() method).
# in python
my_new_icon = Icon("blue", "circle")
self?self refers to the instance that a method was called on.
Whenever you invoke an instance method on a class instance, it is as though you are invoking the class's own method, and passing in the instance as an argument.
some_icon = Icon("blue", "square")
# both below do the same thing
some_icon.my_method("other argument")
Icon.my_method(some_icon, "other argument")
You can set attributes on the instance with dot notation (self.some_attribute = value).
You can add instance methods to the class by defining functions and passing in self.
class Icon:
def __init__(self, color, shape):
self.color = color
self.shape = shape
def my_method(self, word):
print(f"hello {word}")
return
Class variables are not attached to self. They are available for access on the class itself and across instances.
If we update a class variable on an instance, a shadow instance variable is created that hides the class variable of the same name.
class Widget:
price = "$5"
def __init__(self, color):
# instance variables
self.color = color
my_widget = Widget("blue")
second_widget = Widget("chartreuse")
print(my_widget.price) # "$5"
print(Widget.price) # "$5"
my_widget.price = "$100"
print(second_widget.price) # "$5"
print(Widget.price) # "$5"
Widget.price = "$50"
print(second_widget.price) # "$50"
print(my_widget.price) # "$100"
We can use the @classmethod decorator to write class methods.
The first argument will refer to the class itself (conventionally called cls), rather than an individual instance.
# inside class
@classmethod
def widget_factory(cls, colors):
widgets = [cls(color) for color in colors]
print([widget.greet_widget() for widget in widgets])
return widgets
print(Widget.widget_factory(["red",
"yellow", "beige"]))
Static methods don't take implicit arguments—they can't access the class or any instance of it.
@staticmethod
def something_about_widgets():
return "widgets are neat"
Getters & setters allow us to have methods that behave like properties.
They provide a convenient interface for implementing more complicated logic necessary for getting/setting a class property.
They can also be useful for protecting "private" values on your class.
A getter allows you to define a method that behaves like a readable property. The @property decorator over a method creates a getter.
While the getter is a function, it is invoked as if it were a property.
class Icon():
def __init__(self, color, shape):
self.color = color
self.shape = shape
# getter for ~secret~ password
@property
def my_password(self):
return "somebody's secret password"
my_icon = Icon("blue", "square")
print(my_icon.color)
# call the getter method as if we were just
# reading a property
print(my_icon.my_password)
A setter allows you to define a method that updates the getter "property". The decorator used to create a setter is @<getter_method_name>.setter.
You can have a standalone getter, but you must have a getter in order to have a setter. The setter method runs when you change the getter "property."
class Icon():
def __init__(self, color, shape, pswd):
self.color = color
self.shape = shape
# set initial ~secret~ password
# this calls the setter method!
self.my_password = pswd
# getter for ~secret~ password
@property
def my_password(self):
return self._password
# setter for ~secret~ password
@my_password.setter
def my_password(self, new_val):
print("hashing password....")
self._password = str(new_val) + "12345" * 3
my_icon = Icon("blue", "square", "beepboop")
print(my_icon.my_password)
# call the setter method as if we were
# setting my_password as a regular property
my_icon.my_password = "new thing"
print(my_icon.my_password)
Bad Calculator - 10 min
Getters and Setters - 10 min
Regular Polygon - 15 min
Tree Traversal - Challenge - 15 min
To inherit from another class, we pass a reference to that class as an argument in the class definition.
We can use the super() function to get a reference to the parent class, then invoke the desired function.
class Icon:
def __init__(self, color, shape):
self.color = color
self.shape = shape
class Gadget(Icon):
def __init__(self, color, shape, noise):
super().__init__(color, shape)
self.noise = noise
thingie = Icon("purple", "spiral", "whrrrrrr")
print(thingie) # <__main__.Gadget object at 0x105103d60>
print(thingie.color, thingie.shape, thingie.noise) # purple spiral whrrrrrr
In OOP, polymorphism allows us to have methods/attributes that behave differently for different classes.
Polymorphism is tied to inheritance. When a child class inherits from a parent class, that child class can override methods from the parent class.
With polymorphism, we can have our Gadget class redefine a method from our parent Icon class:
class Icon:
def __init__(self, color, shape):
self.color = color
self.shape = shape
def info(self):
return f"Icon that is a {self.color} {self.shape}"
class Gadget(Icon):
def __init__(self, color, shape, noise):
super().__init__(color, shape)
self.noise = noise
def info(self):
return f"Gadget that is a {self.color} {self.shape} and makes a {self.noise} noise"
icon = Icon("blue", "square")
print(icon.info())
thingie = Gadget("purple", "spiral", "whrrrrrr")
print(thingie.info())
Quadrilateral with Inheritance - 10 min
Triangle with Inheritance - 10 min
Book Polymorphism - 10 min
Magic Methods - 10 min
Linked List Iterator - 20 min
Linked List Project - 2 hrs
-
Any changes
Be notified of any changes
-
Mention me
Be notified of mention me
-
Unsubscribe
Subscribe