Gianluca Costa

Introduction to Python

Main traits

Interpreted

Cross-technology

ExtensibleElegant

VHLL

Timeline

1991 2000 2008

Python 1.0 Python 2 Python 3

2014

Python 3.4

Python 2.7

The execution model

x = 10

print(x)

Myscript.pyThe interpreter

executeslines of code

following the flow

Running Python scripts

● python <script path>

● On Windows: shell associations

● On Linux: traditional #!

Trying out Python

Python's interpreter is interactive, too!

Variables

● x = 10

● Later, you can write:

x = “Hello”

Names are remote controls

10

Hellox

x = 10

x = “Hello”

Assignment

The key to Python's naming is the assignment operator

X = 101)Expression evaluation

2)Name creation & binding

Basic data types

● bool: True, False● str: “Cip”, 'Cip', r“\d+”, “““Multiline string”””● unicode: u“Ciop”, u'Ciop', ur“\d+”,

u“““Multiline”””● int: 2 ** 90● float: 5.3● complex: 8 + 7j

None

● X = None

Inspecting a Python object

● type(obj)● dir(obj)● isinstance(obj, <type>)● obj is None● obj is not None

Strings: a warning

● In Python 2, str and unicode

● In Python 3, str and bytes

Collections

● Arrays do not exist in Python (^__^!)● list: [], [90, 100, 474, “Yogi”]● tuple: (), (2,), (4.3, 12.1)● dict: {}, {“Alpha”: 90, “Beta”: 2, 15: 20}● set: set(), {1, 2, 3}

Flow control

● if / elif / else● while● try / except / finally● raise● with● for● yield● pass

For in Python

● No C-style for

● Python only uses iterations on collections:– for i in range(10):

print(i)

List comprehension

● topStudents = [student for student in students if student.average >= 85

]● coordinates = [

(x + 5, y - 2)for x in range(1, 11)for y in range(1, 6)

]

coordinates = [ ]

for x in range(1, 11):for y in range(1, 6):

coordinates.append((x + 5, y – 2)

)

Exceptions

try:raise MyException(“Epic!”)

except (ExcType1, ExcType2) as ex:pass

except ExcType3:pass

except:pass

finally:pass

The WITH statement

with open(“readme.txt”, “r”) as myFile: for line in myFile:

#Process line hereprint(line)

Functions

● def f(x, y):return x + y

● A new function object is created and the name “f” gets bound to it.

Functions as objects

● def f(x, y):return x + y

● h = f

● h(90, 100)

No overloading in Python

● In Python, def creates a function object and binds a name to it!

● Cannot do overloading!!! X___X!

Parameters VS Argument

● Parameter = variable in a function signature. It's a placeholder for the actual value

● Argument = actual value passed when invoking the function

Function parameters

● Standard parameters: f(x, y)● Default values: f(x, y, z = 90)● Arbitrary sequence: f(*args)● Keyword params: f(**kwargs)

● They can all be introduced, in this order:f(x, y, z = 90, *args, **kwargs)

Function arguments● Given a function f(x, y)...● ...pass by position: f(9, 10)● ...pass by name: f(y = 10, x = 9)● ...unpack a list of arguments:

– myParamsSequence = [9, 10]

– f(*myParamsSequence)

● ...pass a map of arguments:– myParamsMap = { “x”: 9, “y”: 10” }

– f(**myParamsMap)

Lambdas

● myFunction = lambda x, y: x + y

● myFunction(90, 100)

Classes

● class Panda(object):pass #can be used for classes, too

● In Python 3, you can just write:

class Panda:pass

Creating methods

● class Panda(object):def sayHello(self):

print(“Hello! ^__^!”)

● self is the first parameter of instance methods, and it's passed as an implicit argument! It refers to the current instance, just like this in Java/C#.

No overloading for methods

● Methods are bound functions

● Methods do not support overloading

Fields and constructor

● class Panda(object):def __init__(self, name):

self._name = nameself._picnicChests = 0

def addPicnicChest(self, picnicChest):self._picnicChests += 1

def getName(self):return self._name

No access control in Python

If a member of an object should not be used by other objects, just prepend “_” to its name.

For example:

● self._privateField = 0● def _privateMethod(self):

pass

Instantiating an object

● yogi = Panda(“Yogi”)

● print(yogi.name)● yogi.addPicnicChest(myPicnicChest)

Class fields

● class Panda(object):_population = 0

def __init__(self):Panda._population += 1

● print(Panda._population)print(yogi._population)

Class fields - Caveat

● yogi = Panda(“Yogi”)● print(yogi._population)● yogi._population = 10● print(Panda._population) #Output == ?

Object's name resolution

3. Super namespaces

2. Class namespace

1. Object namespace

… = obj.name

Multiple inheritance

● Python does not define explicit interfaces...● ...but it supports multiple inheritance!

● class Panda(Bear, VeryCuteAnimal):pass

Diamond resolution

Just too difficult to learn! ^__^''''

Explicit method resolution

● Given an object instance, how to call the method of a specific superclass?

– Super1.f(obj, <args>)

– Super2.f(obj, <args>)

Overriding methods

● Python supports overriding!● But how to call the version provided by the

superclass?

super()

● super(CurrentClassName, self).f(<args>)

● In Python 3:super().f(<args>)

● Not mandatory (you can use explicit method resolution instead)

Static methods

● class Panda(object):@staticmethoddef myStaticMethod(x, y):

return x+y● Static methods can be called via the class

or via any instance

Class methods

● class Bear(object):@classmethoddef f(cls, x, y):

return x + y● They can be called via class or instance

Operator overloading

● To overload “+”– def __add__(self, other):

return ...

● There are several operators available

String representations (v. 2.x)

● __repr__(self)● __str__(self)● __unicode__(self)

String representations (v. 3.x)

● __repr__(self)● __bytes__(self)● __str__(self)

Equality and hashcode

● __eq__(self, other) and __neq__(self, other). Both should be implemented.

● __hash__(self) returns the hash code

Comparisons

● Binary operators: __gt__, __gte__, __lt__, __lte__

● Alternatively, __cmp__ behaves just like Java's compareTo()

Modules

● Python files are modules...

● ...but not all modules are files! ^__^!

● PYTHONPATH

Importing a module

● import re

● from re import compile

● from re import * (good just while learning)

Module caching and reloading

● Importing a module executes it only the first time

● The module cache is sys.modules

● reload() reloads a module

● .pyc files to optimize loading in future sessions

Packages

● Python supports packages!

● Directory structure

● __init__.py

● Within a package, use relative import!

Further execution options

● Py2exe for Windows● PyInstaller for Windows & Unix● Jython● IronPython● Boo