Python 3 Some material adapted from Upenn cis391 slides and other sources.

Slides:



Advertisements
Similar presentations
Python Objects and Classes
Advertisements

Chapter Modules CSC1310 Fall Modules Modules Modules are the highest level program organization unit, usually correspond to source files and.
Generics and the ArrayList Class
Object-Oriented PHP (1)
Road Map Introduction to object oriented programming. Classes
VBA Modules, Functions, Variables, and Constants
1 Programming for Engineers in Python Autumn Lecture 5: Object Oriented Programming.
OOP in Java Nelson Padua-Perez Chau-Wen Tseng Department of Computer Science University of Maryland, College Park.
CS 106 Introduction to Computer Science I 04 / 16 / 2010 Instructor: Michael Eckmann.
June 1, 2000 Object Oriented Programming in Java (95-707) Java Language Basics 1 Lecture 3 Object Oriented Programming in Java Language Basics Classes,
Chapter 14 Generics and the ArrayList Class Copyright © 2010 Pearson Addison-Wesley. All rights reserved.
Python 3 Some material adapted from Upenn cis391 slides and other sources.
Guide to Programming with Python
OOP Languages: Java vs C++
Python Crash Course Classes 3 rd year Bachelors V1.0 dd Hour 7.
UFCEUS-20-2 : Web Programming Lecture 5 : Object Oriented PHP (1)
1 Python Control of Flow and Defining Classes LING 5200 Computational Corpus Linguistics Martha Palmer.
Programming Languages and Paradigms Object-Oriented Programming.
Introduction to Object Oriented Programming. Object Oriented Programming Technique used to develop programs revolving around the real world entities In.
CSC1018F: Object Orientation, Exceptions and File Handling Diving into Python Ch. 5&6 Think Like a Comp. Scientist Ch
Builtins, namespaces, functions. There are objects that are predefined in Python Python built-ins When you use something without defining it, it means.
Python: Classes By Matt Wufsus. Scopes and Namespaces A namespace is a mapping from names to objects. ◦Examples: the set of built-in names, such as the.
1 Java Inheritance. 2 Inheritance On the surface, inheritance is a code re-use issue. –we can extend code that is already written in a manageable manner.
Programming in Java Unit 2. Class and variable declaration A class is best thought of as a template from which objects are created. You can create many.
Introduction to Python III CSE-391: Artificial Intelligence University of Pennsylvania Matt Huenerfauth January 2005.
By: Chris Harvey Python Classes. Namespaces A mapping from names to objects Different namespaces have different mappings Namespaces have varying lifetimes.
Spring 2008 Mark Fontenot CSE 1341 Principles of Computer Science I Note Set 2.
OOP IN PHP `Object Oriented Programming in any language is the use of objects to represent functional parts of an application and real life entities. For.
Everything Is an Object Manipulate objects with references The identifier you manipulate is actually a “reference” to an object. Like a television.
Python uses boolean variables to evaluate conditions. The boolean values True and False are returned when an expression is compared or evaluated.
Object Oriented Programming Elhanan Borenstein Lecture #3 copyrights © Elhanan Borenstein.
Programming in Java CSCI-2220 Object Oriented Programming.
Python Functions.
CS 376b Introduction to Computer Vision 01 / 23 / 2008 Instructor: Michael Eckmann.
Simple Classes. ADTs A specification for a real world data item –defines types and valid ranges –defines valid operations on the data. Specification is.
Overview The Basics – Python classes and objects Procedural vs OO Programming Entity modelling Operations / methods Program flow OOP Concepts and user-defined.
Introduction to Python III CIS 391: Artificial Intelligence Fall, 2008.
ProgLan Python Session 4. Functions are a convenient way to divide your code into useful blocks, allowing us to: order our code, make it more readable,
Programming with Java © 2002 The McGraw-Hill Companies, Inc. All rights reserved. 1 McGraw-Hill/Irwin Chapter 5 Creating Classes.
© Copyright 1992–2004 by Deitel & Associates, Inc. and Pearson Education Inc. All Rights Reserved. Chapter 26 - Java Object-Based Programming Outline 26.1Introduction.
Introduction to Java Chapter 7 - Classes & Object-oriented Programming1 Chapter 7 Classes and Object-Oriented Programming.
Object Oriented Programing (OOP)
M1G Introduction to Programming 2 5. Completing the program.
Guide to Programming with Python Chapter Eight (Part I) Object Oriented Programming; Classes, constructors, attributes, and methods.
 In the java programming language, a keyword is one of 50 reserved words which have a predefined meaning in the language; because of this,
Programming Fundamentals. Topics to be covered Today Recursion Inline Functions Scope and Storage Class A simple class Constructor Destructor.
Classes, Interfaces and Packages
Chapter 1 C++ Basics Review (Section 1.4). Classes Defines the organization of a data user-defined type. Members can be  Data  Functions/Methods Information.
OOP Basics Classes & Methods (c) IDMS/SQL News
15 – PHP(5) Informatics Department Parahyangan Catholic University.
LECTURE 2 Python Basics. MODULES So, we just put together our first real Python program. Let’s say we store this program in a file called fib.py. We have.
Java Generics. Lecture Objectives To understand the objective of generic programming To be able to implement generic classes and methods To know the limitations.
Mr H Kandjimi 2016/01/03Mr Kandjimi1 Week 3 –Modularity in C++
CSCI/CMPE 4341 Topic: Programming in Python Chapter 7: Introduction to Object- Oriented Programming in Python – Exercises Xiang Lian The University of.
CSC 108H: Introduction to Computer Programming Summer 2011 Marek Janicki.
CMSC201 Computer Science I for Majors Lecture 20 – Classes and Modules Prof. Katherine Gibson Prof. Jeremy Dixon Based on slides from the.
Lecture III Syntax ● Statements ● Output ● Variables ● Conditions ● Loops ● List Comprehension ● Function Calls ● Modules.
CMSC201 Computer Science I for Majors Lecture 25 – Classes
Python 3 Some material adapted from Upenn cis391 slides and other sources.
Object Oriented Programming in Python: Defining Classes
Friend Class Friend Class A friend class can access private and protected members of other class in which it is declared as friend. It is sometimes useful.
Lecture VI Objects The OOP Concept Defining Classes Methods
Creating and Deleting Instances Access to Attributes and Methods
Procedural Abstraction Object-Oriented Code
Object Oriented Programming in Python Session -3
Java Programming Language
CMSC201 Computer Science I for Majors Lecture 16 – Classes and Modules
Python 3 Some material adapted from Upenn cis391 slides and other sources.
Java Programming Language
Object-Oriented PHP (1)
Presentation transcript:

Python 3 Some material adapted from Upenn cis391 slides and other sources

Importing and Modules

 Use classes & functions defined in another file  A Python module is a file with the same name (plus the.py extension)  Like Java import, C++ include  Three formats of the command: import somefile from somefile import * from somefile import className  The difference? What gets imported from the file and what name refers to it after importing

import … import somefile  Everything in somefile.py gets imported.  To refer to something in the file, append the text “somefile.” to the front of its name: somefile.className.method(“abc”) somefile.myFunction(34)

from … import * from somefile import *  Everything in somefile.py gets imported  To refer to anything in the module, just use its name. Everything in the module is now in the current namespace.  Take care! Using this import command can easily overwrite the definition of an existing function or variable! className.method(“abc”) myFunction(34)

from … import … from somefile import className  Only the item className in somefile.py gets imported.  After importing className, you can just use it without a module prefix. It’s brought into the current namespace.  Take care! Overwrites the definition of this name if already defined in the current namespace! className.method(“abc”)  imported myFunction(34)  Not imported

Directories for module files  Where does Python look for module files?  The list of directories where Python will look for the files to be imported is sys.path  This is just a variable named ‘path’ stored inside the ‘sys’ module >>> import sys >>> sys.path ['', '/Library/Frameworks/Python.framework/Versions/2.5/lib/pyth on2.5/site-packages/setuptools-0.6c5-py2.5.egg’, …]  To add a directory of your own to this list, append it to this list sys.path.append(‘/my/new/path’)

Object Oriented Programming in Python: Defining Classes

It’s all objects…  Everything in Python is really an object. We’ve seen hints of this already… “hello”.upper() list3.append(‘a’) dict2.keys() These look like Java or C++ method calls. New object classes can easily be defined in addition to these built-in data-types.  In fact, programming in Python is typically done in an object oriented fashion.

Defining a Class  A class is a special data type which defines how to build a certain kind of object.  The class also stores some data items that are shared by all the instances of this class  Instances are objects that are created which follow the definition given inside of the class  Python doesn’t use separate class interface definitions as in some languages  You just define the class and then use it

Methods in Classes  Define a method in a class by including function definitions within the scope of the class block  There must be a special first argument self in all of method definitions which gets bound to the calling instance  There is usually a special method called __init__ in most classes  We’ll talk about both later…

A simple class def: student class student: “““A class representing a student ””” def __init__(self,n,a): self.full_name = n self.age = a def get_age(self): return self.age

Creating and Deleting Instances

Instantiating Objects  There is no “new” keyword as in Java.  Just use the class name with ( ) notation and assign the result to a variable  __init__ serves as a constructor for the class. Usually does some initialization work  The arguments passed to the class name are given to its __init__() method  So, the __init__ method for student is passed “Bob” and 21 and the new class instance is bound to b: b = student(“Bob”, 21)

Constructor: __init__  An __init__ method can take any number of arguments.  Like other functions or methods, the arguments can be defined with default values, making them optional to the caller.  However, the first argument self in the definition of __init__ is special…

Self  The first argument of every method is a reference to the current instance of the class  By convention, we name this argument self  In __init__, self refers to the object currently being created; so, in other class methods, it refers to the instance whose method was called  Similar to the keyword this in Java or C++  But Python uses self more often than Java uses this

Self  Although you must specify self explicitly when defining the method, you don’t include it when calling the method.  Python passes it for you automatically Defining a method:Calling a method: (this code inside a class definition.) def set_age(self, num):>>> x.set_age(23) self.age = num

Deleting instances: No Need to “free”  When you are done with an object, you don’t have to delete or free it explicitly.  Python has automatic garbage collection.  Python will automatically detect when all of the references to a piece of memory have gone out of scope. Automatically frees that memory.  Generally works well, few memory leaks  There’s also no “destructor” method for classes

Access to Attributes and Methods

Definition of student class student: “““A class representing a student ””” def __init__(self,n,a): self.full_name = n self.age = a def get_age(self): return self.age

Traditional Syntax for Access >>> f = student(“Bob Smith”, 23) >>> f.full_name # Access attribute “Bob Smith” >>> f.get_age() # Access a method 23

Accessing unknown members  Problem: Occasionally the name of an attribute or method of a class is only given at run time…  Solution: getattr(object_instance, string)  string is a string which contains the name of an attribute or method of a class  getattr(object_instance, string) returns a reference to that attribute or method

getattr(object_instance, string) >>> f = student(“Bob Smith”, 23) >>> getattr(f, “full_name”) “Bob Smith” >>> getattr(f, “get_age”) >>> getattr(f, “get_age”)() # call it 23 >>> getattr(f, “get_birthday”) # Raises AttributeError – No method!

hasattr(object_instance,string) >>> f = student(“Bob Smith”, 23) >>> hasattr(f, “full_name”) True >>> hasattr(f, “get_age”) True >>> hasattr(f, “get_birthday”) False

Attributes

Two Kinds of Attributes  The non-method data stored by objects are called attributes  Data attributes Variable owned by a particular instance of a class Each instance has its own value for it These are the most common kind of attribute  Class attributes Owned by the class as a whole All class instances share the same value for it Called “static” variables in some languages Good for (1) class-wide constants and (2) building counter of how many instances of the class have been made

Data Attributes  Data attributes are created and initialized by an __init__() method. Simply assigning to a name creates the attribute Inside the class, refer to data attributes using self —for example, self.full_name class teacher: “A class representing teachers.” def __init__(self,n): self.full_name = n def print_name(self): print self.full_name

Class Attributes  Because all instances of a class share one copy of a class attribute, when any instance changes it, the value is changed for all instances  Class attributes are defined within a class definition and outside of any method  Since there is one of these attributes per class and not one per instance, they’re accessed via a different notation: Access class attributes using self.__class__.name notation -- This is just one way to do this & the safest in general. class sample:>>> a = sample() x = 23 >>> a.increment() def increment(self): >>> a.__class__.x self.__class__.x += 124

Data vs. Class Attributes class counter: overall_total = 0 # class attribute def __init__(self): self.my_total = 0 # data attribute def increment(self): counter.overall_total = \ counter.overall_total + 1 self.my_total = \ self.my_total + 1 >>> a = counter() >>> b = counter() >>> a.increment() >>> b.increment() >>> b.increment() >>> a.my_total 1 >>> a.__class__.overall_total 3 >>> b.my_total 2 >>> b.__class__.overall_total 3

Inheritance

Subclasses  A class can extend the definition of another class Allows use (or extension ) of methods and attributes already defined in the previous one. New class: subclass. Original: parent, ancestor or superclass  To define a subclass, put the name of the superclass in parentheses after the subclass’s name on the first line of the definition. Class Cs_student(student): Python has no ‘extends’ keyword like Java. Multiple inheritance is supported.

Redefining Methods  To redefine a method of the parent class, include a new definition using the same name in the subclass. The old code won’t get executed.  To execute the method in the parent class in addition to new code for some method, explicitly call the parent’s version of the method. parentClass.methodName(self, a, b, c) The only time you ever explicitly pass ‘self’ as an argument is when calling a method of an ancestor.

Definition of a class extending student Class Student: “A class representing a student.” def __init__(self,n,a): self.full_name = n self.age = a def get_age(self): return self.age Class Cs_student (student): “A class extending student.” def __init__(self,n,a,s): student.__init__(self,n,a) #Call __init__ for student self.section_num = s def get_age(): #Redefines get_age method entirely print “Age: ” + str(self.age)

Extending __init__  Same as for redefining any other method… Commonly, the ancestor’s __init__ method is executed in addition to new commands. You’ll often see something like this in the __init__ method of subclasses: parentClass.__init__(self, x, y) where parentClass is the name of the parent’s class.

Special Built-In Methods and Attributes

Built-In Members of Classes  Classes contain many methods and attributes that are included by Python even if you don’t define them explicitly. Most of these methods define automatic functionality triggered by special operators or usage of that class. The built-in attributes define information that must be stored for all classes.  All built-in members have double underscores around their names: __init__ __doc__

Special Methods  For example, the method __repr__ exists for all classes, and you can always redefine it  The definition of this method specifies how to turn an instance of the class into a string print f sometimes calls f.__repr__() to produce a string for object f If you type f at the prompt and hit ENTER, then you are also calling __repr__ to determine what to display to the user as output

Special Methods – Example class student:... def __repr__(self): return “I’m named ” + self.full_name... >>> f = student(“Bob Smith”, 23) >>> print f I’m named Bob Smith >>> f “I’m named Bob Smith”

Special Methods  You can redefine these as well: __init__ : The constructor for the class __cmp__ : Define how == works for class __len__ : Define how len( obj ) works __copy__ : Define how to copy a class  Other built-in methods allow you to give a class the ability to use [ ] notation like an array or ( ) notation like a function call

Special Data Items  These attributes exist for all classes. __doc__ : Variable for documentation string for class __class__ : Variable which gives you a reference to the class from any instance of it __module__ : Variable which gives a reference to the module in which the particular class is defined __dict__:The dictionary that is actually the namespace for a class (but not its superclasses)  Useful: dir(x) returns a list of all methods and attributes defined for object x

Special Data Items – Example >>> f = student(“Bob Smith”, 23) >>> print f.__doc__ A class representing a student. >>> f.__class__ >>> g = f.__class__(“Tom Jones”, 34)

Private Data and Methods  Any attribute/method with 2 leading under- scores in its name (but none at the end) is private and can’t be accessed outside of class  Note: Names with two underscores at the beginning and the end are for built-in methods or attributes for the class  Note: There is no ‘protected’ status in Python; so, subclasses would be unable to access these private data either.