Introduction to Python
Upcoming SlideShare
Loading in...5
×
 

Introduction to Python

on

  • 185 views

The slides of my brown bag session that briefly introduced the Python programming language! ^__^

The slides of my brown bag session that briefly introduced the Python programming language! ^__^

Statistics

Views

Total Views
185
Views on SlideShare
185
Embed Views
0

Actions

Likes
0
Downloads
10
Comments
0

0 Embeds 0

No embeds

Accessibility

Categories

Upload Details

Uploaded via as Adobe PDF

Usage Rights

CC Attribution License

Report content

Flagged as inappropriate Flag as inappropriate
Flag as inappropriate

Select your reason for flagging this presentation as inappropriate.

Cancel
  • Full Name Full Name Comment goes here.
    Are you sure you want to
    Your message goes here
    Processing…
Post Comment
Edit your comment

Introduction to Python Introduction to Python Presentation Transcript

  • Gianluca Costa Introduction to Python
  • Main traits Interpreted Cross-technology Extensible Elegant 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.py The interpreter executes lines 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 Hello x x = 10 x = “Hello”
  • Assignment The key to Python's naming is the assignment operator X = 10 1)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 here print(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 = name self._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): @staticmethod def myStaticMethod(x, y): return x+y ● Static methods can be called via the class or via any instance
  • Class methods ● class Bear(object): @classmethod def 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