Trainingpython 120828061919 Phpapp02 - 2 PDF

TRAINING PYTHON
INTRODUCTION TO PYTHON
(BASIC LEVEL)
Editor: Nguyễn Đức Minh Khôi
@HCMC University of Technology, September 2011
9/2/2011 Training Python Chapte 0: Introduction to Python 1
TRAINING PYTHON
Chapter 0: INTRODUCTION TO PYTHON
CONTENTS
Python in general
How Python program runs?
How to run Python?

Python in general
• What is python?
• High level programming language
• Emphasize on code readability
• Very clear syntax + large and comprehensive standard library
• Use of indentation for block delimiters
• Multiprogramming paradigm: OO, imperative, functional,
procedural, reflective
• A fully dynamic type system and automatic memory management
• Scripting language + standalone executable program + interpreter
• Can run on many platform: Windows, Linux, Mactonish
• Updates:
• Newest version: 3.2.2 (CPython, JPython, IronPython)
• Website: www.python.org
Python in general (Cont’)

• Advantages:
• Software quality
• Developer productivity
• Program portability
• Support libraries
• Component integration
• Enjoyment
• Disadvantages:
• not always be as fast as that of compiled languages such as C and
C++

• Applications of python:

• Python’s Capability:
• System Programming
• GUI
• Internet Scripting
• Component Integration
• Database Programming
• Rapid Prototyping
• Numeric and Scientific Programming
• Gaming, Images, Serial Ports, XML, Robots, and More
How Python program runs?
Notice: pure Python code runs at speeds somewhere between those of

a traditional compiled language and a traditional interpreted language
How to run Python?

• Install Python 3.2.2:
• Go to website:
http://www.python.org/download/ and
download the latest version of Python
• Run and install follow the instructions
of the .msi file
• If you successfully install, you will see
this picture:
• Coding Python:
• Not IDE support: use notepad++
http://notepad-plus-plus.org/
• Use IDE support: Eclipse (3.7) or
Netbeans (7.0)
How to run Python? (Cont’)

• Install Eclipse: follow the instructions from this website:
http://wiki.eclipse.org/FAQ_Where_do_I_get_and_install_Eclipse%3F
(you should download the Eclipse Classics version)
• Install Pydev plugin for eclipse: follow this instruction:
http://pydev.org/manual_101_install.html
THANKS FOR LISTENING

Contact: nguyenducminhkhoi@gmail.com
Main reference: Part I – Getting Started
Learning Python – O’reilly
TRAINING PYTHON
CHAPTER 1: TYPES AND OPERATIONS
CONTENTS
Lists
Dictionaries
Tuples
Files
Numeric Typing
Dynamic Typing
Summary
5/22/2011 Training Python 3
Lists
• Ordered collections of arbitrary objects
• Accessed by offset
• Variable-length, heterogeneous, and arbitrarily nestable
• Of the category “mutable sequence”
• Arrays of object references
Lists literals and operations

Lists literals and operations (cont’)

Dictionaries
• Accessed by key, not offset
• Accessed by key, not offset
• Variable-length, heterogeneous, and arbitrarily nestable
• Of the category “mutable mapping”
• Tables of object references (hash tables)
Dictionaries literals and operations

Dictionaries literals and operations (c)

Tuples
• Ordered collections of arbitrary objects
• Accessed by offset
• Of the category “immutable sequence”
• Fixed-length, heterogeneous, and arbitrarily nestable
• Arrays of object references
Tuples literals and operations

Tuples literals and operations (con’t)

Files – common operations

2
NUMERIC TYPES
• Integers and floating-point numbers
• Complex numbers
• Fixed-precision decimal numbers
• Rational fraction numbers
• Sets
• Booleans
• Unlimited integer precision
• A variety of numeric built-ins and modules
3
NUMERIC TYPES (Cont’)

4
NUMERIC TYPES (Cont’)

Dynamic Typing
• Variables, Objects, References:
• Variables are entries in a system table, with spaces for links to
objects.
• Objects are pieces of allocated memory, with enough space to
represent the values for which they stand.
• References are automatically followed pointers from variables to
objects.
Dynamic Typing (Cont’) - Shared references
• Immutable types:
• Mutable types:
• Notices:
• It’s also just the default: if you don’t want such behavior, you can
request that Python copy objects instead of making references.
• Notices (next):
• “is” function returns False if the names point to equivalent but different
objects, as is the case when we run two different literal expressions.
• Small integers and strings are cached and reused, though, is tells us
they reference the same single object.
Summary
• Object just classification
Summary (con’t)
• Object Flexibility
• Lists, dictionaries, and tuples can hold any kind of object.
• Lists, dictionaries, and tuples can be arbitrarily nested.
• Lists and dictionaries can dynamically grow and shrink.
• Object copy
• Slice expressions with empty limits (L[:]) copy sequences.
• The dictionary and set copy method (X.copy()) copies a dictionary
or set.
• Some built-in functions, such as list, make copies (list(L)).
• The copy standard library module makes full copies.
9/2/2011 Learning Python Chapter 1 1

Main reference: Part II – Types and Operations
TRAINING PYTHON
STATEMENTS AND SYNTAX
Content
Statements
Assignment, Expression, Print
Conditional statements
Loop statements
Iterations and comprehensions

Python program structures:

• Programs are composed of modules.
• Modules contain statements.
• Statements contain expressions.
• Expressions create and process objects.
Python statements
Python statements (Cont’)

Python statements (Cont’)

Assignment Statements
Assignment Properties:
• Assignments create object references
• Names are created when first assigned
• Names must be assigned before being referenced
• Some operations perform assignments implicitly
Assignment Statement Forms:
Variable name rules (opt)

• Syntax: (underscore or letter) + (any number of letters,
digits, or underscores)
• Case matters: SPAM is not the same as spam
• Reserved words are off-limits
Expression Statements
Print Operations
• Call format
• Example:
Conditional Statements - IF
• General Format:
• The if/else ternary expression:
• Example:
IF Statements - Truth tests (opt)

Conditional expression:
• Any nonzero number or nonempty object is true.
• Zero numbers, empty objects, and the special object None are
considered false.
• Comparisons and equality tests are applied recursively to data
structures.
• Comparisons and equality tests return True or False (custom versions
of 1 and 0).
• Boolean “and” and “or” operators return a true or false operand
object.
IF Statements - Truth tests (opt) (Cont)

• “and” and “or” operands:
Loop Statements – while statements

• General while format:
• Notice:
Loop Statements – for statements

• General Format:
• Loop Coding Techniques:

• The built-in range function produces a series of successively higher
integers, which can be used as indexes in a for.
• The built-in zip function returns a series of parallel-item tuples,
which can be used to traverse multiple sequences in a for.
• Notice: for loops typically run quicker than while-based counter
loops, it’s to your advantage to use tools like these that allow you to
use for when possible.
Loop statements - examples

Iterations and comprehensions

• Iterable:
• an object is considered iterable if it is either a physically stored
sequence or an object that produces one result at a time in the
context of an iteration tool like a for loop.
• iterable objects include both physical sequences and virtual
sequences computed on demand.
• Iterations:
• Any object with a __next__ method to advance to a next result,
which raises StopIteration at the end of the series of results, is
considered iterable in Python.
• Example:
List comprehension
• Example:
• (x + 10): arbitrary expression
• (for x in L): iterable object
• Extend List Comprehension:
New Iterator in Python 3.0

• Iterators associated:
• built-in type :set, list, dictionary, tuple, file
• Dictionary method: keys, values, items
• Built-in function: range (multiple iterator), map, zip, filter (single)
• Examples:
Iterators examples (cont’)


Main reference: Part III – Statements and Syntax
9/6/2011 Training Python Chapter 3 1
TRAINING PYTHON
Chapter 3: FUNCTION
CONTENTS
Function Basics
Scope
Arguments
Function Advanced
Iterations and Comprehension Advanced

Function Basics
• Function: A function is a device that groups a set of
statements so they can be run more than once in a
program.
• Why use?:
• Maximizing code reuse and minimizing redundancy
• Procedural decomposition
Function Basics – def Statements

• General format:
• Use “def” statements:

Function Basics – Examples

Scopes
• Three different scopes
• If a variable is assigned inside a def, it is local to that function.
• If a variable is assigned in an enclosing def, it is nonlocal to nested
functions.
• If a variable is assigned outside all defs, it is global to the entire file.
• Notice:
• All names assigned inside a function def statement (or a lambda,
an expression we’ll meet later) are locals by default.
• Functions can freely use names as-signed in syntactically
enclosing functions and the global scope, but they must declare
such nonlocals and globals in order to change them.
Scopes – the LEGB rules

Scopes – examples
Global names: X, func
Local names: Y, Z
# The Built – in Scopes

Scopes – Global statements

• Global Statement:
• Other ways to access Globals:

Scopes – Global statements(Cont’)

Scopes – Nested functions
• Factory function
• These terms refer to a function object that remembers values in enclosing
scopes regardless of whether those scopes are still present in memory.
Scopes – Nested scope (Cont’)
• Nested scope and lambda:

Scopes – Nonlocal statements

• The nonlocal statement:
• Is a close cousin to global
• Like global: nonlocal declares that a name will be changed in an
enclosing scope.
• Unlike global:
• nonlocal applies to a name in an enclosing function’s scope, not the
global module scope outside all defs.
• nonlocal names must already exist in the enclosing function’s scope
when declared
• Format:
Scopes – Nonlocal statements (Con’t)

Arguments – Passing Basics

• Arguments are passed by automatically assigning objects to local
variable names.
• Assigning to argument names inside a function does not affect the
caller.
• Changing a mutable object argument in a function may impact the
caller.
• Immutable arguments are effectively passed “by value.”
• Mutable arguments are effectively passed “by pointer.”
Arguments – Matching Modes
• Keyword-only arguments: arguments that must be passed by keyword

only and will never be filled in by a positional argument.
Arguments - Examples
Arguments – Examples (Cont’)

Arguments – Bonus Points

Function Advanced
• General guidelines:
• Coupling: use arguments for inputs and return for outputs.
• Coupling: use global variables only when truly necessary.
• Coupling: don’t change mutable arguments unless the caller
expects it.
• Cohesion: each function should have a single, unified purpose.
• Size: each function should be relatively small.
• Coupling: avoid changing variables in another module file directly.
Function Advanced - Recursions

• Examples:
• Alternatives:
Function Advanced – Lambda Expression

• Lambda format:
• Use lambda for:
• inline a function definition
• defer execution of a piece of code
• Notices:
• lambda is an expression, not a statement
• lambda’s body is a single expression, not a block of statements.
• If you have larger logic to code, use def; lambda is for small pieces of
inline code. On the other hand, you may find these techniques useful in
moderation
• Examples:
Lambda Expression (Cont’)

• Logic within lambda function:
• Nested lambda:
• Used with map function:
• Used with filter function:
• Used with reduce function:

Iterations and Comprehension Part 2

• List Comprehension:
• Vs. Map:
• Vs. filter:
• Vs. Nested for:


• Generators:
• Generator functions: are coded as normal def statements but use
yield statements to return results one at a time, suspending and
resuming their state between each.
• Generator expressions: are similar to the list comprehensions
of the prior section, but they return an object that produces results
on demand instead of building a result list.
• Generator functions:

• Generator Expression:
3.0 Comprehension Syntax

Function Pitfall
• “List comprehensions were nearly twice as fast as equivalent for
loop statements, and map was slightly quicker than list
comprehensions when mapping a built-in function such as abs
(absolute value)”
• Python detects locals statically, when it compiles the def’s code,
rather than by noticing assignments as they happen at runtime.

Main reference: Part IV – Functions
Learning Python 4th Edition – O’reilly 2010
TRAINING PYTHON
Chapter 4: MODULES
Contents
Modules Basics
Modules Package
Modules in advance
Modules Basics
• Modules are process with:
• import: Lets a client (importer) fetch a module as a whole
• from: Allows clients to fetch particular names from a module
• imp.reload: Provides a way to reload a module’s code without
stopping Python
• Why use Modules?
• Code reuse
• System namespace partitioning
• Implementing service or data
Modules Basics – import statements

• How imports work?
1. Find the module’s file.
2. Compile it to byte code (if needed).
3. Run the module’s code to build the objects it defines.
• The Module Search Path:

1. The home directory of the program
2. PYTHONPATH directories (if set)
3. Standard library directories
4. The contents of any .pth files (if present)
Modules Basics – create Modules

• In fact, both the names of module files and the names of
directories used in package must conform to the rules for
variable names:
• They may, for instance, contain only letters, digits, and
underscores.
• Package directories also cannot contain platform-specific syntax
such as spaces in their names.
• Modules in Python can be written in external languages
such as C/C++ in Cpython, Java in Jython, .net languages
in IronPython
Modules Basics - Usages

• The import statement:
• The from statement:
• The from * statement
• The import happens only once

Modules Basics – Usages (Con’t)

• Import assigns an entire module object to a single name.
• From assigns one or more names to objects of the same names in
another module.
Be careful:
Modules Basics - namespaces

• Files generate Namespaces:
• Module statements run on the first import.
• Top-level assignments create module attributes.
• Module namespaces can be accessed via the attribute__dict__or dir(M)
• Modules are a single scope (local is global)
• Namespace nesting:
• In mod3.py:
• In mod2.py:
• In mod1.py:
Modules Basics – reloading function

• Unlike import and from:
• reload is a function in Python, not a statement.
• reload is passed an existing module object, not a name.
• reload lives in a module in Python 3.0 and must be imported itself.
• How to use:
Modules Basics – reload example

• In changer.py:
• Change global message variable:
•
Modules package
• Package __init__.py files:
• Directory: dir0\dir1\dir2\mod.py
• Import statement: import dir1.dir2.mod
• Rules:
• dir1 and dir2 both must contain an __init__.py file.
• dir0, the container, does not require an __init__.py file; this file will
simply be ignored if present.
• dir0, not dir0\dir1, must be listed on the module search path (i.e., it must
be the home directory, or be listed in your PYTHONPATH, etc.).
• Present in tree mode:
Modules package
• Relative import:
• instructs Python to import a module named spam located in the

same package directory as the file in which this statement appears.
• Sibling import:
Modules In Advance – Data Hiding

• Minimizing from * Damage: _X and __all__
• you can prefix names with a single underscore (e.g., _X) to prevent
them from being copied out when a client imports a module’s
names with a from * statement.
• Enabling future language features
• Mixed Usage Modes: __name__ and __main__

• If the file is being run as a top-level program file, __name__ is set
to the string "__main__" when it starts.
• If the file is being imported instead, __name__ is set to the
module’s name as known by its clients
Modules in Advance (Cont’)

• In runme.py:
• Unit Tests with __name__:

• we can wrap up the self-test call in a __name__ check, so that it
will be launched only when the file is run as a top-level script, not
when it is imported
Modules in Advance (Cont’)

• The as Extension for import and from:
Module Gotchas
• Statement Order Matters in Top-Level Code
• from Copies Names but Doesn’t Link
• from * Can Obscure the Meaning of Variables
• Recursive from Imports May Not Work

• You can usually eliminate import cycles like this by careful design—
maximizing cohesion and minimizing coupling are good first steps.
Main reference: Part V – Modules
TRAINING PYTHON
Chapter 5: CLASSES AND OOP
9/18/2011 Training Python Chapter 5: Classes and OOP 2
Contents
Class Coding Basics
Class Coding Detail
Advanced Class topics

Class Coding Basics

• OOP program must show:
• Abstraction (or sometimes called encapsulation)
• Inheritance (vs. composition)
• Polymorphism
• Class vs. Instance Object:
• Class: Serve as instance factories. Their attributes provide
behavior—data and functions—that is inherited by all the instances
generated from them.
• Instance: Represent the concrete items in a program’s domain.
Their attributes record data that varies per specific object
Class Coding Basics (Cont’)
• Each class statement generates a new class object.

• Each time a class is called, it generates a new instance object.
• Instances are automatically linked to the classes from which they are created.
• Classes are linked to their superclasses by listing them in parentheses in a class
header line; the left-to-right order there gives the order in the tree.
Class Coding Basics – Class trees
• Notice:
• Python uses multiple inheritance: if there is more than one
superclass listed in parentheses in a class statement (like C1’s
here), their left-to-right order gives the order in which those
superclasses will be searched for attributes.
• Attributes are usually attached to classes by assignments made
within class statements, and not nested inside function def
statements.
• Attributes are usually attached to instances by assignments to a
special argument passed to functions inside classes, called self.
Class Coding Basics - Class vs. Instance

• Class Object:
• The class statement creates a class object and assigns it a name.
• Assignments inside class statements make class attributes.
• Class attributes provide object state and behavior.
• Instance Object:
• Calling a class object like a function makes a new instance object.
• Each instance object inherits class attributes and gets its own
namespace.
• Assignments to attributes of self in methods make per-instance
attributes.
Class Coding Basics ©

• First Example:
Class Coding Basics - Inheritance

• Attribute inheritance:
• Superclasses are listed in parentheses in a class header.
• Classes inherit attributes from their superclasses.
• Instances inherit attributes from all accessible classes.
• Each object.attribute reference invokes a new, independent search.
• Logic changes are made by subclassing, not by changing
superclasses.
Class Coding Basics – Inheritance ©

• Second Example:
Class Coding Details

• Class statement:
Assigning names inside the class statement makes class attributes,

and nested defs make class methods, but other assignments make
attributes, too.
• Examples:
Class Coding Details ©

• Method call:
• Example:
Class Coding Details - Inheritance

• Example:
Class Coding Details – Inheritance ©

• Class Interface Techniques:
• Real:


• Abstract superclass:
Class Coding Details ©

• Python namespaces – Assignments Classify names:
Class Coding Details – operator overloading

• Common operator overloading method:
Class Coding Details – operator overloading ©

Advanced Class topics - Relationships

• Is – relationship vs. has - relationship
In employees.py file
Express: inheritance
– is relationship
Advanced Class topics – Relationships ©
In pizzashop.py file
Express: has - relationship
Advanced Class topics – Extending built in types

• By embedding:
Advanced Class topics – Extending built in types

• By subclassing:
Advanced Class topics –

Diamond Inheritance
• Old and new style inheritance:

Diamond Inheritance
• Explicit Conflict Resolution:

static class method
• Notice:

static and class method
Advanced Class topics - Decorators

• Function decorators provide a way to specify special operation
modes for functions, by wrapping them in an extra layer of logic
implemented as another function.
• Syntax:
• Example:
Advanced Class topics – Decorators ©

• Class decorators are similar to function decorators, but they are run
at the end of a class statement to rebind a class name to a callable.
• Syntax:
• Example:
Advanced Class topics – Class gotchas

• Changing Class Attributes Can Have Side Effects
• Changing Mutable Class Attributes Can Have Side
Effects, Too
• Multiple Inheritance: Order Matters
• multiple inheritance works best when your mix-in classes are as
self-contained as possible—because they may be used in a variety
of contexts, they should not make assumptions about names
related to other classes in a tree.
Main reference: Part VI – Classes and OOP
TRAINING PYTHON
INTRODUCTION TO PYTHON
(BASIC LEVEL)
@HCMC University of Technology, September 2011
TRAINING PYTHON
Chapter 6: Exception Handling
7/13/2012 Training Python @HCMUT Summer 2012 - Chapter 6 3
Contents
Basic Concepts
Exception in Details
Examples
Basic Concepts
• What is Exceptions:
• Are events that can modify the flow of control through a program
• Are triggered automatically on errors, and they can be triggered and
intercepted by your code.
• What is Exception Handlers:
• Try statement
• Roles of Exceptions:
• Error Handling
• Event Notification
• Special case Handling
• Termination Actions
• Unusual control flows
Basic Concepts (cont.)

• Suppose we have the function like this:
• Default handler:
• Catching Exception:

• Raising Exception:
• User define Exception:


• Terminate Actions:
• Let’s compare:
Contents
Basic Concepts
Examples
• Try statement clauses:
Exception in Details (cont.)

• How it runs?
• If an exception does occur while the try block’s statements are running,
Python jumps back to the try and runs the statements under the first
except clause that matches the raised exception. Control resumes below
the entire try statement after the except block runs (unless the except
block raises another exception).
• If an exception happens in the try block and no except clause matches,
the exception is propagated up to the last matching try statement that
was entered in the program or, if it’s the first such statement, to the top
level of the process (in which case Python kills the program and prints a
default error message).
• If no exception occurs while the statements under the try header run,
Python runs the statements under the else line (if present), and control
then resumes below the entire try statement

• Notices:
• Except:
Vs.
• Else:
• Vs.

• Try/finally statement:
• How it works?
• If no exception occurs while the try block is running, Python jumps back
to run the finally block and then continues execution past below the try
statement.
• If an exception does occur during the try block’s run, Python still comes
back and runs the finally block, but it then propagates the exception up
to a higher try or the top-level default handler; the program does not
resume execution below the try statement. That is, the finally block is
run even if an exception is raised, but unlike an except, the finally does
not terminate the exception—it continues being raised after the finally
block runs.

• Nested Exception Handlers:

• The Raise statement
• Example
• Propagating Exception with raise:


• The Assert Statement
• Example:

• Your own Exception Class:
superclass called General and two subclasses
called Specific1 and Specific2
Exception is the Superclass Of all Exception Class
• Python Built in Exception:
• You can use directly or inherit
them to your own Exception
Contents
Basic Concepts
Examples
Examples
• The try/finally statement examples:
• allows you to specify cleanup actions that always must occur, such as file
closes and server disconnects.
Examples (cont.)
• Unified Try Example:
Main reference: Part VI – Classes and OOP

Trainingpython 120828061919 Phpapp02 - 2 PDF

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Trainingpython 120828061919 Phpapp02 - 2 PDF

Uploaded by

Copyright:

Available Formats

TRAINING PYTHON

How Python program runs?

How to run Python?

Python in general (Cont’)

Python in general (Cont’)

Python in general (Cont’)

How Python program runs?

Notice: pure Python code runs at speeds somewhere between those of

How to run Python?

How to run Python? (Cont’)

THANKS FOR LISTENING

Lists literals and operations

Lists literals and operations (cont’)

Dictionaries literals and operations

Dictionaries literals and operations (c)

Tuples literals and operations

Tuples literals and operations (con’t)

Files – common operations

NUMERIC TYPES (Cont’)

NUMERIC TYPES (Cont’)

THANKS FOR LISTENING

Assignment, Expression, Print

Iterations and comprehensions

Python program structures:

Python statements (Cont’)

Python statements (Cont’)

Variable name rules (opt)

• The if/else ternary expression:

IF Statements - Truth tests (opt)

IF Statements - Truth tests (opt) (Cont)

Loop Statements – while statements

Loop Statements – for statements

• Loop Coding Techniques:

Loop statements - examples

Iterations and comprehensions

New Iterator in Python 3.0

Iterators examples (cont’)

THANKS FOR LISTENING

Iterations and Comprehension Advanced

Function Basics – def Statements

• Use “def” statements:

Function Basics – Examples

Scopes – the LEGB rules

# The Built – in Scopes

Scopes – Global statements

• Other ways to access Globals:

Scopes – Global statements(Cont’)

Scopes – Nested functions

Scopes – Nested scope (Cont’)

• Nested scope and lambda:

Scopes – Nonlocal statements

Scopes – Nonlocal statements (Con’t)

Arguments – Passing Basics

Arguments – Matching Modes

• Keyword-only arguments: arguments that must be passed by keyword

Arguments – Examples (Cont’)

Arguments – Bonus Points

Function Advanced - Recursions

Function Advanced – Lambda Expression

Lambda Expression (Cont’)

• Used with map function:

• Used with filter function:

• Used with reduce function:

• Mixed Usage Modes: name and main

• Unit Tests with name: