Introduction to Python

Difficulty level: undergraduate

Objectives:

Learn about Python
Get to speed with writing programs in Python

Introducing Python

Python is:

A high-level programming langauge
Dynamically, Strongly typed
For general-purpose computing
Interpreted
Automatic/Internal Memory Management
Object-oriented, Structural, a “little” Functional and Aspect-Oriented

CPython is an open-source implementation of Python

Was first written in late 1980s by Guido van Rossum.

Advantages of learning Python (over other high-level languages)

Generally uses fewer lines of code to express concepts
Has libraries for literally anything you can think of (Web, Mobile, Scientific, Data Storage, etc.)
Dynamically and strongly typed? Has support for type-hinting
More productive; can be used for small to large products; prototyping to production-grade systems
Has an open-source implementation

Most linux distributions ship with Python 2.7.

In this course, we’re going to use Python 3.4+. The Python 2 series are scheduled to be deprecated by 2020.

The “hello world”
Basics
- Variable Assignments
- Function calls
- Variable scope
- Input and Output
- Exception handling
- Loops and conditional statements
Data Types
- Mutable and non-mutable types
- Iterators and Generators
- Closures
- Decorators
Packaged utilities
- Collections
- Itertools
A bit of OOP
Using external libraries
Basic packaging

Application Development Examples

A web server
Data crunching with numpy and pandas

The “Hello World”

if __name__ == "__main__":
    
    print("Hello World!")

Hello World!

Basics

Variable Assignments

Python uses duck-typing…
It is dynamically, but strongly typed.

x = 2 # int
y = ‘5’ # or y = “5”; String
z = 2.0 # float
t = [1, 2] # This is a list – which is similar to your linked list (more on this later)

print(x + z) # Involves automatic type conversion to float, since z is a float

del x # Deleting a variable

try:
print(y + z) # Throws an error as type casting is not done.
except TypeError:
print(“TypeError occurred”)

x = 2 # int
y = '5' # or y = "5"; String
z = 2.0 # float
t = [1, 2] # This is a list - which is similar to your linked list (more on this later)

print(x + z) # Involves automatic type conversion to float, since z is a float

del x # Deleting a variable

try:
    print(y + z) # Throws an error as type casting is not done.
except TypeError:
    print("TypeError occurred")

4.0
TypeError occurred

Function Calls

Built-in functions listed at: https://docs.python.org/3/library/functions.html

# defining a fucntion

print ("defining a function")
def foo(x, y, a=5): # x and y are positional parameters, a has a default value of 5
    print(x, y, a)

foo(1, 2, 2)
foo(1, 2)
print("--")

# defining a function with variable number of arguments
print ("defining a function with arbitrary number of arguments")
def foo(*args):
    for a in args:
        print(a)

foo(1)
print("--")
foo(1,2,3)

# defining a function with variable number of arguments after compulsary arguments
print ("defining a function with arbitrary number of arguments after compulsory arguments")
def foo(x, y, *args):
    print(x, y, args)
    
foo(1, 2, 3, 4, 5)

# calling a function using a dictionary of values
print ("calling a function using a dictionary of values that pose as arguments")
foo(**{"x": 1, "y": 2})

# everything in one function
print("a function with arguments of all kinds")
def foo(x, *args, y=1, **kwargs):
    print(x, y, args, kwargs)

foo(1, 2, 3, 4, y=2, z=5)

# anonymous functions
print("anonymous function")
sqr = lambda x: x*x
print(sqr(2))

print("examples of builtin functions")
# some useful built-in functions
print("sorted")
print(sorted([10, 2, 22, 1, 33, 44, 11, 23])) # sorted
print("filter")
print(list(filter(lambda x: x > 10, [10, 2, 22, 1, 33, 44, 11, 23]))) # filter
print("length")
print(len([1,2,3])) # len
print("max")
print(max([1,2,3])) # max

# checkout the documentation for other such built-ins

defining a function
1 2 2
1 2 5
--
defining a function with arbitrary number of arguments
1
--
1
2
3
defining a function with arbitrary number of arguments after compulsory arguments
1 2 (3, 4, 5)
calling a function using a dictionary of values that pose as arguments
1 2 ()
a function with arguments of all kinds
1 2 (2, 3, 4) {'z': 5}
anonymous function
4
examples of builtin functions
sorted
[1, 2, 10, 11, 22, 23, 33, 44]
filter
[22, 33, 44, 11, 23]
length
3
max
3

Variable Scope

x = 0

def foo():
    x = 1
    print(x)

def foo2():
    global x
    x = 1
    print(x)
    
print(x)
foo()
print(x)
foo2()
print(x)

0
1
0
1
1

Input and Ouput

Documentation: https://docs.python.org/3/tutorial/inputoutput.html

# Output
x = 2
print(x) # Output to screen

# Formatting output
print("This is a %s; number %d; float %f" % ("test", 1, 2.0))
print("This is a {}; number {}; float {}".format("test", 1, 2.0))

open('test.txt', 'w').write(str(x)) # Output to file

# Input
x = input('Enter a number: ') # Read from screen
print(x, type(x))

x = open('test.txt', 'r').read() # Read from file
print(x)

# Type casting
x = '2'
print(int(x) + 1)
try:
    print(x + 1) # Will throw an error
except TypeError:
    print("TypeError occurred")

2
This is a test; number 1; float 2.000000
This is a test; number 1; float 2.0
Enter a number: 10
10 <class 'str'>
2
3
TypeError occurred

Exception Handling

import traceback # this provides functions to get the error trace

# Example of exception handling...

try: # try statement
    x = int('a') # throws an exception as the string a cannot be cast to int
except ValueError as err: # catches an exception
    print("ValueError occurred")
    traceback.print_exc() # prints details
    print("Error returned...", err)
finally:
    print("This gets executed irrespective of whether an exception occurred")

ValueError occurred
Error returned... invalid literal for int() with base 10: 'a'
This gets executed irrespective of whether an exception occurred

Traceback (most recent call last):
  File "", line 6, in 
    x = int('a') # throws an exception as the string a cannot be cast to int
ValueError: invalid literal for int() with base 10: 'a'

Loops and Conditional Statements

# if statement
print("if statement")
x = 5
if x == 5:
    print("x is 5")
elif x > 5: # else if
    print("x > 5")
else:
    print("x < 5")

# for loop
print("for loop")
for ii in range(10): # range(10) --> iterator giving 0 ... 9
    print(ii)

print("for loop: multiple vars")
for a, b in zip([1, 2, 3], [4, 5, 6]): # having multiple vars to iterate thru'
    print(a, b)

# while loop
print("while loop")
c = 0
while c < 3:
    print(c)
    c += 1
    
print("for loop with pass statement")
for ii in range(10):
    pass # similar to nop in assembly code

print("for loop with break statement")
for ii in range(10):
    print(ii)
    break # break from loop
    
print("for loop with continue statement")
for ii in range(10):
    if ii < 5:
        continue # skip loop to next iteration
    print(ii)

print("in-line for loop")
print([v * v for v in [1, 2, 3] if v >= 2]) # in-line for loop

if statement
x is 5
for loop
0
1
2
3
4
5
6
7
8
9
for loop: multiple vars
1 4
2 5
3 6
while loop
0
1
2
for loop with pass statement
for loop with break statement
0
for loop with continue statement
5
6
7
8
9
in-line for loop
[4, 9]

Data Types

Mutable and non-mutable types

Mutable Objects: Can be modified after instantiation
non-Mutable: Can’t!

Python in-built data types,

str, int, float, complex, frozenset, tuple, bytes, complex, and bool are immutable
bytearray, list, set, and dict are mutable

Some examples of data structures are given below.

Documentation: https://docs.python.org/3/library/datatypes.html

# List (A heterogeneous collection of elements)
x = [1, int(2), 3, 'a', "bcd", 2.0, complex(2, 3), 5 + 6j, [5, 6]]
print(x)

# Adding an element
x.append(3)
print(x)

# Adding many elements
x.extend([1, 2, 3])
print(x)

# Removing (the first matching) element
x.remove(1)
print(x)

# Reversing a list
x.reverse()
print(x)

# Remove all elements
x.clear()
print(x)

# Inline list comprehension
x = [1, 2, 3, 4, 5, 6]
print("Even numbers in x", [v for v in x if v % 2 == 0])

[1, 2, 3, 'a', 'bcd', 2.0, (2+3j), (5+6j), [5, 6]]
[1, 2, 3, 'a', 'bcd', 2.0, (2+3j), (5+6j), [5, 6], 3]
[1, 2, 3, 'a', 'bcd', 2.0, (2+3j), (5+6j), [5, 6], 3, 1, 2, 3]
[2, 3, 'a', 'bcd', 2.0, (2+3j), (5+6j), [5, 6], 3, 1, 2, 3]
[3, 2, 1, 3, [5, 6], (5+6j), (2+3j), 2.0, 'bcd', 'a', 3, 2]
[]
Even numbers in x [2, 4, 6]

# Dict (hashmap)

x = {} # or x = dict()

# Adding elements
x['test'] = 1
x[1] = 100
x[2.0] = 2.35
print(x)

# Alternative initialization
x = {'test': 1, 1: 100, 2.0: 2.35}
print(x)

# Removing an element
del x['test']

# To find out the methods available:
print(dir(x))

# Getting help
help(x)

{'test': 1, 1: 100, 2.0: 2.35}
{'test': 1, 1: 100, 2.0: 2.35}
['__class__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__gt__', '__hash__', '__init__', '__iter__', '__le__', '__len__', '__lt__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__setitem__', '__sizeof__', '__str__', '__subclasshook__', 'clear', 'copy', 'fromkeys', 'get', 'items', 'keys', 'pop', 'popitem', 'setdefault', 'update', 'values']
Help on dict object:

class dict(object)
 |  dict() -> new empty dictionary
 |  dict(mapping) -> new dictionary initialized from a mapping object's
 |      (key, value) pairs
 |  dict(iterable) -> new dictionary initialized as if via:
 |      d = {}
 |      for k, v in iterable:
 |          d[k] = v
 |  dict(**kwargs) -> new dictionary initialized with the name=value pairs
 |      in the keyword argument list.  For example:  dict(one=1, two=2)
 |  
 |  Methods defined here:
 |  
 |  __contains__(self, key, /)
 |      True if D has a key k, else False.
 |  
 |  __delitem__(self, key, /)
 |      Delete self[key].
 |  
 |  __eq__(self, value, /)
 |      Return self==value.
 |  
 |  __ge__(self, value, /)
 |      Return self>=value.
 |  
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |  
 |  __getitem__(...)
 |      x.__getitem__(y) <==> x[y]
 |  
 |  __gt__(self, value, /)
 |      Return self>value.
 |  
 |  __init__(self, /, *args, **kwargs)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  __iter__(self, /)
 |      Implement iter(self).
 |  
 |  __le__(self, value, /)
 |      Return self<=value.
 |  
 |  __len__(self, /)
 |      Return len(self).
 |  
 |  __lt__(self, value, /)
 |      Return self size of D in memory, in bytes
 |  
 |  clear(...)
 |      D.clear() -> None.  Remove all items from D.
 |  
 |  copy(...)
 |      D.copy() -> a shallow copy of D
 |  
 |  fromkeys(iterable, value=None, /) from builtins.type
 |      Returns a new dict with keys from iterable and values equal to value.
 |  
 |  get(...)
 |      D.get(k[,d]) -> D[k] if k in D, else d.  d defaults to None.
 |  
 |  items(...)
 |      D.items() -> a set-like object providing a view on D's items
 |  
 |  keys(...)
 |      D.keys() -> a set-like object providing a view on D's keys
 |  
 |  pop(...)
 |      D.pop(k[,d]) -> v, remove specified key and return the corresponding value.
 |      If key is not found, d is returned if given, otherwise KeyError is raised
 |  
 |  popitem(...)
 |      D.popitem() -> (k, v), remove and return some (key, value) pair as a
 |      2-tuple; but raise KeyError if D is empty.
 |  
 |  setdefault(...)
 |      D.setdefault(k[,d]) -> D.get(k,d), also set D[k]=d if k not in D
 |  
 |  update(...)
 |      D.update([E, ]**F) -> None.  Update D from dict/iterable E and F.
 |      If E is present and has a .keys() method, then does:  for k in E: D[k] = E[k]
 |      If E is present and lacks a .keys() method, then does:  for k, v in E: D[k] = v
 |      In either case, this is followed by: for k in F:  D[k] = F[k]
 |  
 |  values(...)
 |      D.values() -> an object providing a view on D's values
 |  
 |  ----------------------------------------------------------------------
 |  Data and other attributes defined here:
 |  
 |  __hash__ = None

Iterators and Generators

Generators are iterators: they are implemented using the yield keyword (that yields partial results of a function)
Iterators are iterables: they implement the next() and iter() methods

# Example of a generator

def foo():
    for ii in range(4):
        yield ii # this gives out a partial result.

t = foo()
print(t) # --> Shows that the return value is a generator object
import collections; isinstance(t, collections.Iterator) # --> This is an iterator object
# (OOP concepts in python will be covered later...)

for partial_result in t: # Iterating thru' a generator
    print(partial_result)

t = foo()

#Another way to iterate thru' a generator
while True:
    try:
        print(next(t))
    except StopIteration:
        break
        
# generator expressions
t = (x*x for x in range(10))
print(t) # --> t is a generator!

0
1
2
3
0
1
2
3
 at 0x7f092cb78e60>

Closures

enables us to abstract out the state of a function.

a closure is formed when the following three conditions are satisfied

there must be nested functions
the nested function must use the variables defined in the enclosing function
the enclosing function should return the nested function

def thresholder(n=10):
    def thresholding_function(lst):
        return list(filter(lambda x: x > n, lst))
    return thresholding_function

x = [1, 2, 3, 4, 5, 6, 11, 12, 13]
thresholder_10 = thresholder(10)
print(thresholder_10(x))
thresholder_5 = thresholder(5)
print(thresholder_5(x))

[11, 12, 13]
[6, 11, 12, 13]

Decorators

Decorators are a syntactic convenience that allow us to define what needs to be done to the output of a function before the function is called.

# Example of an in-built decorator
class Foo:
    
    @property # --> Foo.state is equivalent to property(state)
    def state(self):
        return True

foo = Foo()
print(foo.state)

# Example of a custom decorator
import time
def timer(func):
    def time_func(*args, **kwargs):
        start_time = time.time()
        func(*args, **kwargs)
        print("Function '%s' took %3.4f seconds." %(func.__name__, time.time() - start_time))
    return time_func

@timer
def add(x, y):
    return x + y

add(2, 3)

True
Function 'add' took 0.0000 seconds.

Collections

Python offers an inbuilt library called collections that has several useful datastructures like: namedtuple, defaultDict, OrderedDict, deque, and Counter.
A few basic examples are given below…

Documentation https://docs.python.org/3/library/collections.html

from collections import defaultdict

x = defaultdict(int) # an element that does not exist in the dictionary (hashmap) 
                     # will be assumed to be a 0 (Since int() returns 0)

print(x['test'])
x['abc'] = 2
print(x)

from collections import OrderedDict

x = OrderedDict() # Stores items in the order of insertion
x['a'] = 1
x['b'] = 2

print(x)

from collections import Counter
x = Counter() # A counter
x['a'] = 10
x['b'] = 20
print(x)
print(x.most_common(1))
print(x - x)
print(x + x)

# Deque is left as an exercise

0
defaultdict(<class 'int'>, {'test': 0, 'abc': 2})
OrderedDict([('a', 1), ('b', 2)])
Counter({'b': 20, 'a': 10})
[('b', 20)]
Counter()
Counter({'b': 40, 'a': 20})

Packaged Utilities

Itertools

Efficient set of functions for various constructs inspiried from other languages…

Documentation: https://docs.python.org/3/library/itertools.html

from itertools import count, cycle, repeat, accumulate, groupby

def exec_func(func, x=10):
    c = 0
    for ii in func(x):
        print(ii)
        c += 1
        if c == 5:
            print("Break")
            break

# count
print("Count")
exec_func(count, 10)

#cycle
print("Cycle")
exec_func(cycle, "ABC")

#repeat
print("Repeat")
exec_func(repeat, 10)

# accumulate
print("Accumulate")
for entry in accumulate(range(0,10)):
    print(entry)

# Groupby
print("Groupby")
x = [1,1,2,2,3,3,3,3,5,5,5,5,5,5,1,1,1,3,5,1,1,3,5,5,2]
fd = [[a, len(list(b))] for a, b in groupby(sorted(x))] # Computing the frequency distribution
print(fd)

Count
10
11
12
13
14
Break
Cycle
A
B
C
A
B
Break
Repeat
10
10
10
10
10
Break
Accumulate
0
1
3
6
10
15
21
28
36
45
Groupby
[[1, 7], [2, 3], [3, 6], [5, 9]]

A bit of OOP

Python supports object-oriented programming

Defining object oriented concepts

# defining a class

class Foo:
    
    svar = 25 # static variable
    
    def __init__(self, x): # Constructor; self refers to the instance
        self.x = x # object variable
        self.__x = x # private variable
    
    @property
    def state(self):
        return self.x

    def add(self, a, b): # method
        return a + b
    
    def __private_method(self, a): # private method (mostly syntactic sugar)
        print(a)
    
    @staticmethod
    def t():
        print("This is a static method")

foo = Foo(5) # instantiating a class
print(foo.state)
Foo.t() # calling a static method
print(Foo.svar) # calling static variable

5
This is a static method
25

Inheritence, polymorphism, encapsulation..

General philosophy is that data is strictly not hidden, but there is a convention of using “_” or “__” to mark private variables.
Polymorphism is achieved through the ability to accept arbitrary (and keyword) arguments

# Example of inheritence

class Foo:
    def __init__(self, x):
        self.x = x
    
    @property
    def state(self):
        return self.x

    def method(self):
        print("This is a Foo method")
    
class Bar(Foo): # Bar inherits Foo
    def __init__(self):
        Foo.__init__(self, 10)

    def method(self): # Overriding
        print("This is a Bar method")
        super(Bar, self).method() # Calling method of super class
        
bar = Bar()
print(bar.state)
bar.method()

10
This is a Bar method
This is a Foo method

Using external libraries

Python comes with a large set of community managed libraries.
To use them, you can use one of the existing “package managers” like easy_install or pip (python-in-python).

First, you have to install the package manager; in a debian-based system, it amounts to:

sudo apt-get install python3-pip

or

sudo apt-get install python-setuptools

After that, you can install a package of your choice using:

pip3 install

example: pip3 install web.py to install web.py – which is a simple web server library for python

or easy_install

Here are a few popular libraries:

Data Analysis: numpy, scipy, pandas, jupyter-notebook
Web Development: tornado, gunicorn, flask, web.py, web2py, django
Mobile Development: kivy
Desktop Application Development: pyqt, pygtk
Machine Learning: sklearn, sklearn-image
NLP: nltk, spacy
DevOps: fabric

There are many, many more…!

Application Development Examples

Web Service

An example is given below using bottle.py

Documentation: http://bottlepy.org/docs/dev/index.html

! pip3 install -U bottle

from bottle import route, run, template

@route('/hello/')
def index(name):
    return template('Hello {{name}}!', name=name)

run(host='localhost', port=9000)

Collecting bottle
Installing collected packages: bottle
Successfully installed bottle-0.12.13
You are using pip version 8.1.1, however version 9.0.1 is available.
You should consider upgrading via the 'pip install --upgrade pip' command.

Bottle v0.12.13 server starting up (using WSGIRefServer())...
Listening on http://localhost:9000/
Hit Ctrl-C to quit.

Data crunching with numpy and pandas

numpy and pandas have to be separately installed using pip/easy_install

Read numpy documentation at: http://www.numpy.org/
Read pandas documentation at: http://pandas.pydata.org/

The functionalities are too large to fall within the scope of the current discussion.

For completeness and to give you a taste of how it is to use these libraries, a few (very basic) examples are given below…

# Examples of numpy
import numpy as np

x = np.array([1, 2, 3]) # one of the basic data types in numpy as an np-array
y = np.array([2, 3, 4])
print(x.dot(y)) # dot product of two vectors
y = np.array([[5, 6, 7], [3, 4, 5]])
print(np.matmul(x, y.T)) # matrix multiplication
z = np.array([[1, 2, 3], [1, 5, 6], [7, 6, 9]])
print(np.linalg.inv(z)) # matrix inverse

# Examples of pandas
import pandas as pd
x = pd.DataFrame(z) # one of the basic data types in pandas is a DataFrame
print(x)
x.iloc[1] # indexing 2nd row

20
[38 26]
[[ -7.50000000e-01  -1.26882631e-16   2.50000000e-01]
 [ -2.75000000e+00   1.00000000e+00   2.50000000e-01]
 [  2.41666667e+00  -6.66666667e-01  -2.50000000e-01]]
   0  1  2
0  1  2  3
1  1  5  6
2  7  6  9

0    1
1    5
2    6
Name: 1, dtype: int64

Final Exercise

Answer

Share this:

Introduction to Speech Processing

What is a signal?

What can we use speech signals for?

Share this:

Exercise 4

Answer

Share this:

Exercise 3

Answer

Share this:

Exercise-2

Share this:

Exercise-1

Answer

Share this:

Introduction to Python

Objectives:

Introducing Python

Advantages of learning Python (over other high-level languages)

Contents

The “Hello World”

Basics

Data Types

Packaged Utilities

A bit of OOP

Using external libraries

Application Development Examples

Share this:

Setting up the system¶

Libraries + Software needed:¶

Building a ConvNet for the dataset “First steps with Julia”¶

Share this:

Introduction to computational advertising: History and Definition

The Advertising Landscape

The stakeholders

Technology abstractions

Organizational abstractions

Data Science and Analytics Problems in Computational Advertising

Customer Segmentation and Audience Creation

Channel experience design

Budget Allocation

Contract negotiation and Stakeholder’s Optimization

Ad Networks

Publishers and SSPs

Advertisers and DSPs

Content Optimization

Measurement and Analysis

Fraud detection

Attribution

Cross-device identification

User Perceptions of Advertising

References

Share this:

Share this:

Recent Posts

Archives

Topic Trails

Subscribe