Python - the basics

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

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

Editor: Nguy n Đ c Minh Khôi
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’)


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: dir0dir1dir2mod.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 dir0dir1, 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 - 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 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 - Inheritance
• Example:


• Abstract superclass:


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


Advanced Class topics - Relationships
• Is – relationship vs. has - relationship
In employees.py file
Express: inheritance
– is 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

Python - the basics

More Related Content

What's hot (20)

Viewers also liked (20)

Similar to Python - the basics (20)

More from University of Technology (13)

Recently uploaded (20)

Python - the basics