CME 193: Introduction to Scientific Python Lecture 5: Object Oriented Programming

Transcription

1 CME 193: Introduction to Scientific Python Lecture 5: Object Oriented Programming Nolan Skochdopole stanford.edu/class/cme193 5: Object Oriented Programming 5-1

2 Contents Classes Numpy Exercises 5: Object Oriented Programming 5-2

3 Simplest example # define class: class Leaf: pass # instantiate object leaf = Leaf() print leaf # < main.leaf instance at 0x10049df80> 5: Object Oriented Programming 5-3

4 Initializing an object Define how a class is instantiated by defining the init method. Seasoned programmer: in Python only one constructor method. 5: Object Oriented Programming 5-4

5 Initializing an object The init or constructor method. class Leaf: def init (self, color): self.color = color # (default) public attribute redleaf = Leaf( red ) blueleaf = Leaf( blue ) print redleaf.color # red Note how we access object attributes. We will have more on public/private attributes and encapsulation next time. 5: Object Oriented Programming 5-5

6 Self The self parameter seems strange at first sight. It refers to the the object (instance) itself. Hence self.color = color sets the color of the object self.color equal to the variable color. 5: Object Oriented Programming 5-6

7 Another example Classes have methods (similar to functions) class Stock(): def init (self, name, symbol, prices=[]): self.name = name self.symbol = symbol self.prices = prices def high_price(self): if len(self.prices) == 0: return MISSING PRICES return max(self.prices) apple = Stock( Apple, APPL, [500.43, ]) print apple.high_price() Recall: list.append() or dict.items(). These are simply class methods! 5: Object Oriented Programming 5-7

8 Another example Classes have methods (similar to functions) class Stock(): def init (self, name, symbol, prices=[]): self.name = name self.symbol = symbol self.prices = prices def high_price(self): if len(self.prices) == 0: return MISSING PRICES return max(self.prices) apple = Stock( Apple, APPL, [500.43, ]) print apple.high_price() Recall: list.append() or dict.items(). These are simply class methods! 5: Object Oriented Programming 5-8

9 Class attributes class Leaf: n_leafs = 0 # class attribute: shared def init (self, color): self.color = color # object attribute Leaf.n_leafs += 1 redleaf = Leaf( red ) blueleaf = Leaf( blue ) print redleaf.color # red print Leaf.n_leafs # 2 Class attributes are shared among all objects of that class. 5: Object Oriented Programming 5-9

10 Attributes are by default public! class Leaf: def init (self, color): self.color = color def getcolor(self): return self.color blueleaf = Leaf( blue ) color = blueleaf.getcolor() print color # blue color = red print blueleaf.getcolor() #? blueleaf.color = red print blueleaf.getcolor() #? What do you think is returned by the last two print statements? 5: Object Oriented Programming 5-10

11 Access attributes by returning them with methods What happens with this example? class Student: def init (self, name, classes=[]): self.name = name self.classes = classes def getclasses(self): return self.classes def addclass(self, c): self.classes.append(c) s = Student( Jabrill ) s.addclass( CME 193 ) classes = s.getclasses() print classes # [ CME 193 ] classes[0] = CME 195 print s.getclasses() #? 5: Object Oriented Programming 5-11

12 Access attributes by returning them with methods How would you fix the last example? class Student: def init (self, name, classes=[]): self.name = name self.classes = classes def getclasses(self): return list(self.classes) def addclass(self, c): self.classes.append(c) s = Student( Jabrill ) s.addclass( CME 193 ) classes = s.getclasses() print classes # [ CME 193 ] classes[0] = CME 195 print s.getclasses() #? 5: Object Oriented Programming 5-12

13 Access attributes by returning them with methods How would you fix the last example? class Student: def init (self, name, classes=[]): self.name = name self.classes = classes def getclasses(self): return list(self.classes) def addclass(self, c): self.classes.append(c) s = Student( Jabrill ) s.addclass( CME 193 ) classes = s.getclasses() print classes # [ CME 193 ] classes[0] = CME 195 print s.getclasses() #? 5: Object Oriented Programming 5-13

14 Private attributes Python does have a way to declare attributes as private. class Leaf: def init (self, color): self. color = color def getcolor(self): return self. color blueleaf = Leaf( blue ) color = blueleaf.getcolor() print color # blue color = red print blueleaf.getcolor() #? print blueleaf. color # AttributeError: Leaf instance has # no attribute color 5: Object Oriented Programming 5-14

15 Private attributes However, there is still a way for us to access private attributes outside of the class methods. class Leaf: def init (self, color): self. color = color def getcolor(self): return self. color blueleaf = Leaf( blue ) color = blueleaf.getcolor() print color # blue color = red print blueleaf.getcolor() #? print blueleaf._leaf color #? 5: Object Oriented Programming 5-15

16 Public vs private attributes As we ve seen, no real way to fully protect our class attributes. Bad practice to access object attributes directly. Can use private attributes to make it harder/more work to access. 5: Object Oriented Programming 5-16

17 Operator overloading We can override built in methods to define how our objects behave with Python operators/functions. Some methods to override init (self,...): Constructor repr (self): Represent the object (machine) cmp (self, other): Compare self and other add (self, other): Add self and other Many more! 5: Object Oriented Programming 5-17

18 Example class Student: def init (self, name, classes=[]): self.name = name self.classes = classes def getclasses(self): return self.classes def getname(self): return self.name s = Student( Jabrill, [ CME 193, CME 195 ]) print s # < main.student instance at 0x7f68f0c39d88> print s.getname() # Jabrill print s.getclasses() # [ CME 193, CME 195 ] 5: Object Oriented Programming 5-18

19 Example class Student: def init (self, name, classes=[]): self.name = name self.classes = classes def getclasses(self): return self.classes def getname(self): return self.name def repr (self): string = %s: % self.name string += %s % self.classes return string s = Student( Jabrill, [ CME 193, CME 195 ]) print s # Jabrill: [ CME 193, CME 195 ] 5: Object Oriented Programming 5-19

20 Operator overloading This ability to define how objects behave with basic operators allows us to define interactions between objects. One of the most powerful aspects of object oriented programming. 5: Object Oriented Programming 5-20

21 Example Implementing Rational numbers class Rational: pass 5: Object Oriented Programming 5-21

22 Setup What information should the class hold? Numerator Denominator 5: Object Oriented Programming 5-22

23 Setup What information should the class hold? Numerator Denominator 5: Object Oriented Programming 5-23

24 Init Implement the init method class Rational: def init (self, p, q=1): self.p = p self.q = q 5: Object Oriented Programming 5-24

25 Init Implement the init method class Rational: def init (self, p, q=1): self.p = p self.q = q 5: Object Oriented Programming 5-25

26 Issues Issues? class Rational: def init (self, p, q=1): self.p = p self.q = q Ignore the division by 0 for now, more on that later. 5: Object Oriented Programming 5-26

27 Issues Issues? class Rational: def init (self, p, q=1): self.p = p self.q = q Ignore the division by 0 for now, more on that later. 5: Object Oriented Programming 5-27

28 Greatest common divisor and 1 2 are the same rational. We d like to for the objects to be the same. Let s store our rational numbers in fully reduced form. Implement a gcd(a, b) function that computes the greatest common divisor of a and b. def gcd(a, b): if b == 0: return a else: return gcd(b, a%b) If interested: Verify Euclidean Algorithm 5: Object Oriented Programming 5-28

29 Greatest common divisor class Rational: def init (self, p, q=1): g = gcd(p, q) self.p = p / g self.q = q / g Can put the gcd function in the same file as your class outside of the class definition (easiest to put above class definition) or import file with the function. 5: Object Oriented Programming 5-29

30 Representing your class: Operator overloading Implement repr or str early to print Useful for debugging 5: Object Oriented Programming 5-30

31 Operator overloading: adding two Rationals Add Rationals just like Ints and Doubles? Rational(10,2) + Rational(4,3) To use +, we implement the add method class Rational: #... def add (self, other): p = self.p * other.q + other.p * self.q q = self.q * other.q return Rational(p, q) #... Does this change any of self or other? 5: Object Oriented Programming 5-31

32 Operator overloading: Comparing cmp compares objects If self is smaller than other, return a negative value If self and other are equal, return 0 If self is larger than other, return a positive value You will implement this function and others in the exercise for today. 5: Object Oriented Programming 5-32

33 Class hierarchy through inheritance It can be useful (especially in larger projects) to have a hierarchy of classes. Example Animal Bird Pet Hawk Seagull... Dog Cat : Object Oriented Programming 5-33

34 Inheritance Can have one class inherit attributes from another class. Original class is called base class or parent class. New class is called derived class or child class. Child classes will usually redefine or add new attributes. 5: Object Oriented Programming 5-34

35 Inheritance Suppose we first define an abstract class class Animal: def init (self, n_legs, color): self.n_legs = n_legs self.color = color def make_noise(self): print noise 5: Object Oriented Programming 5-35

36 Inheritance We can define sub classes and inherit from another class. class Dog(Animal): def init (self, color, name): Animal. init (self, 4, color) self.name = name def make_noise(self): print self.name + : + woof bird = Animal(2, white ) bird.make_noise() # noise brutus = Dog( black, Brutus ) brutus.make_noise() # Brutus: woof shelly = Dog( white, Shelly ) shelly.make_noise() # Shelly: woof 5: Object Oriented Programming 5-36

37 Contents Classes Numpy Exercises 5: Object Oriented Programming 5-37

38 Numpy Fundamental package for scientific computing with Python N-dimensional array object Linear algebra, Fourier transform, random number capabilities Building block for other packages (e.g. Scipy) Open source 5: Object Oriented Programming 5-38

39 Numpy Fundamental package for scientific computing with Python N-dimensional array object Linear algebra, Fourier transform, random number capabilities Building block for other packages (e.g. Scipy) Open source 5: Object Oriented Programming 5-39

40 import numpy as np Basics: import numpy as np A = np.array([[1, 2, 3], [4, 5, 6]]) print A # [[1 2 3] # [4 5 6]] Af = np.array([1, 2, 3], float) Slicing as usual. 5: Object Oriented Programming 5-40

41 More basics np.arange(0, 1, 0.2) # array([ 0., 0.2, 0.4, 0.6, 0.8]) np.linspace(0, 2*np.pi, 4) # array([ 0.0, 2.09, 4.18, 6.28]) A = np.zeros((2,3)) # array([[ 0., 0., 0.], # [ 0., 0., 0.]]) # np.ones, np.diag A.shape # (2, 3) 5: Object Oriented Programming 5-41

42 More basics np.random.random((2,3)) # array([[ , , ], # [ , , ]]) a = np.random.normal(loc=1.0, scale=2.0, size=(2,2)) # array([[ , ], # [ , ]]) np.savetxt("a_out.txt", a) # save to file b = np.loadtxt("a_out.txt") # read from file 5: Object Oriented Programming 5-42

43 Arrays are mutable A = np.zeros((2, 2)) # array([[ 0., 0.], # [ 0., 0.]]) C = A C[0, 0] = 1 print A # [[ 1. 0.] # [ 0. 0.]] 5: Object Oriented Programming 5-43

44 Array attributes a = np.arange(10).reshape((2,5)) a.ndim a.shape a.size a.t a.dtype # 2 dimension # (2, 5) shape of array # 10 # of elements # transpose # data type 5: Object Oriented Programming 5-44

45 Basic operations Arithmetic operators: elementwise application a = np.arange(4) # array([0, 1, 2, 3]) b = np.array([2, 3, 2, 4]) a * b # array([ 0, 3, 4, 12]) b - a # array([2, 2, 0, 1]) c = [2, 3, 4, 5] a * c # array([ 0, 3, 8, 15]) Also, we can use += and *=. 5: Object Oriented Programming 5-45

46 Array broadcasting When operating on two arrays, numpy compares shapes. Two dimensions are compatible when 1. They are of equal size 2. One of them is 1 5: Object Oriented Programming 5-46

47 Array broadcasting 5: Object Oriented Programming 5-47

48 Array broadcasting with scalars This also allows us to add a constant to a matrix or multiply a matrix by a constant A = np.ones((3,3)) print 3 * A - 1 # [[ ] # [ ] # [ ]] 5: Object Oriented Programming 5-48

49 Vector operations inner product outer product dot product (matrix multiplication) # note: numpy automatically converts lists u = [1, 2, 3] v = [1, 1, 1] np.inner(u, v) # 6 np.outer(u, v) # array([[1, 1, 1], # [2, 2, 2], # [3, 3, 3]]) np.dot(u, v) # 6 5: Object Oriented Programming 5-49

50 Matrix operations First, define some matrices: A = np.ones((3, 2)) # array([[ 1., 1.], # [ 1., 1.], # [ 1., 1.]]) A.T # array([[ 1., 1., 1.], # [ 1., 1., 1.]]) B = np.ones((2, 3)) # array([[ 1., 1., 1.], # [ 1., 1., 1.]]) 5: Object Oriented Programming 5-50

51 Matrix operations np.dot(a, B) # array([[ 2., 2., 2.], # [ 2., 2., 2.], # [ 2., 2., 2.]]) np.dot(b, A) # array([[ 3., 3.], # [ 3., 3.]]) np.dot(b.t, A.T) # array([[ 2., 2., 2.], # [ 2., 2., 2.], # [ 2., 2., 2.]]) np.dot(a, B.T) # Traceback (most recent call last): # File "<stdin>", line 1, in <module> # ValueError: shapes (3,2) and (3,2) not aligned:... #... 2 (dim 1)!= 3 (dim 0) 5: Object Oriented Programming 5-51

52 Operations along axes a = np.random.random((2,3)) # array([[ , , ], # [ , , ]]) a.sum() # a.sum(axis=0) # column sum # array([ , , ]) a.cumsum() # array([ , , , , # , ]) a.cumsum(axis=1) # cumulative row sum # array([[ , , ], # [ , , ]]) a.min() # a.max(axis=0) # array([ , , ]) 5: Object Oriented Programming 5-52

53 Slicing arrays More advanced slicing a = np.random.random((4,5)) a[2, :] # third row, all columns a[1:3] # 2nd, 3rd row, all columns a[:, 2:4] # all rows, columns 3 and 4 5: Object Oriented Programming 5-53

54 Iterating over arrays Iterating over multidimensional arrays is done with respect to the first axis: for row in A Looping over all elements: for element in A.flat 5: Object Oriented Programming 5-54

55 Reshaping Reshape using reshape. Total size must remain the same. Resize using resize, always works: chopping or appending zeros First dimension has priority, so beware of unexpected results Try it! 5: Object Oriented Programming 5-55

56 Reshaping Reshape using reshape. Total size must remain the same. Resize using resize, always works: chopping or appending zeros First dimension has priority, so beware of unexpected results Try it! 5: Object Oriented Programming 5-56

57 Reshaping Reshape using reshape. Total size must remain the same. Resize using resize, always works: chopping or appending zeros First dimension has priority, so beware of unexpected results Try it! 5: Object Oriented Programming 5-57

58 Matrix operations import numpy.linalg eye(3) trace(a) column_stack((a,b)) row_stack((a,b,a)) Identity matrix Trace Stack column wise Stack row wise 5: Object Oriented Programming 5-58

59 Linear algebra import numpy.linalg qr cholesky inv(a) solve(a,b) Computes the QR decomposition Computes the Cholesky decomposition Inverse Solves Ax = b for A full rank lstsq(a,b) Solves arg min x Ax b 2 eig(a) Eigenvalue decomposition eig(a) Eigenvalue decomposition for symmetric or hermitian eigvals(a) Computes eigenvalues. svd(a, full) Singular value decomposition pinv(a) Computes pseudo-inverse of A 5: Object Oriented Programming 5-59

60 Fourier transform import numpy.fft fft 1-dimensional DFT fft2 2-dimensional DFT fftn N-dimensional DFT ifft 1-dimensional inverse DFT (etc.) rfft Real DFT (1-dim) ifft Imaginary DFT (1-dim) 5: Object Oriented Programming 5-60

61 Random sampling import numpy.random rand(d0,d1,...,dn) randn(d0, d1,...,dn) randint(lo, hi, size) choice(a, size, repl, p) shuffle(a) permutation(a) Random values in a given shape Random standard normal Random integers [lo, hi) Sample from a Permutation (in-place) Permutation (new array) 5: Object Oriented Programming 5-61

62 import numpy.random Distributions in random The list of distributions to sample from is quite long, and includes beta binomial chisquare exponential dirichlet gamma laplace lognormal pareto poisson power 5: Object Oriented Programming 5-62

63 Contents Classes Numpy Exercises 5: Object Oriented Programming 5-63

64 Exercises See course website for exercises for this lecture. 5: Object Oriented Programming 5-64